@fecp/designer 5.6.6 → 5.6.8

package/es/node_modules/cytoscape-fcose/node_modules/cose-base/cose-base.mjs

@@ -0,0 +1,2555 @@
+import { __module as coseBase$1 } from "../../../../_virtual/cose-base.mjs";
+import { __require as requireLayoutBase } from "../layout-base/layout-base.mjs";
+var coseBase = coseBase$1.exports;
+var hasRequiredCoseBase;
+function requireCoseBase() {
+  if (hasRequiredCoseBase) return coseBase$1.exports;
+  hasRequiredCoseBase = 1;
+  (function(module, exports) {
+    (function webpackUniversalModuleDefinition(root, factory) {
+      module.exports = factory(requireLayoutBase());
+    })(coseBase, function(__WEBPACK_EXTERNAL_MODULE__551__) {
+      return (
+        /******/
+        (() => {
+          var __webpack_modules__ = {
+            /***/
+            45: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                var coseBase2 = {};
+                coseBase2.layoutBase = __webpack_require__2(551);
+                coseBase2.CoSEConstants = __webpack_require__2(806);
+                coseBase2.CoSEEdge = __webpack_require__2(767);
+                coseBase2.CoSEGraph = __webpack_require__2(880);
+                coseBase2.CoSEGraphManager = __webpack_require__2(578);
+                coseBase2.CoSELayout = __webpack_require__2(765);
+                coseBase2.CoSENode = __webpack_require__2(991);
+                coseBase2.ConstraintHandler = __webpack_require__2(902);
+                module2.exports = coseBase2;
+              }
+            ),
+            /***/
+            806: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                var FDLayoutConstants = __webpack_require__2(551).FDLayoutConstants;
+                function CoSEConstants() {
+                }
+                for (var prop in FDLayoutConstants) {
+                  CoSEConstants[prop] = FDLayoutConstants[prop];
+                }
+                CoSEConstants.DEFAULT_USE_MULTI_LEVEL_SCALING = false;
+                CoSEConstants.DEFAULT_RADIAL_SEPARATION = FDLayoutConstants.DEFAULT_EDGE_LENGTH;
+                CoSEConstants.DEFAULT_COMPONENT_SEPERATION = 60;
+                CoSEConstants.TILE = true;
+                CoSEConstants.TILING_PADDING_VERTICAL = 10;
+                CoSEConstants.TILING_PADDING_HORIZONTAL = 10;
+                CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = true;
+                CoSEConstants.ENFORCE_CONSTRAINTS = true;
+                CoSEConstants.APPLY_LAYOUT = true;
+                CoSEConstants.RELAX_MOVEMENT_ON_CONSTRAINTS = true;
+                CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = true;
+                CoSEConstants.PURE_INCREMENTAL = CoSEConstants.DEFAULT_INCREMENTAL;
+                module2.exports = CoSEConstants;
+              }
+            ),
+            /***/
+            767: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                var FDLayoutEdge = __webpack_require__2(551).FDLayoutEdge;
+                function CoSEEdge(source, target, vEdge) {
+                  FDLayoutEdge.call(this, source, target, vEdge);
+                }
+                CoSEEdge.prototype = Object.create(FDLayoutEdge.prototype);
+                for (var prop in FDLayoutEdge) {
+                  CoSEEdge[prop] = FDLayoutEdge[prop];
+                }
+                module2.exports = CoSEEdge;
+              }
+            ),
+            /***/
+            880: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                var LGraph = __webpack_require__2(551).LGraph;
+                function CoSEGraph(parent, graphMgr, vGraph) {
+                  LGraph.call(this, parent, graphMgr, vGraph);
+                }
+                CoSEGraph.prototype = Object.create(LGraph.prototype);
+                for (var prop in LGraph) {
+                  CoSEGraph[prop] = LGraph[prop];
+                }
+                module2.exports = CoSEGraph;
+              }
+            ),
+            /***/
+            578: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                var LGraphManager = __webpack_require__2(551).LGraphManager;
+                function CoSEGraphManager(layout) {
+                  LGraphManager.call(this, layout);
+                }
+                CoSEGraphManager.prototype = Object.create(LGraphManager.prototype);
+                for (var prop in LGraphManager) {
+                  CoSEGraphManager[prop] = LGraphManager[prop];
+                }
+                module2.exports = CoSEGraphManager;
+              }
+            ),
+            /***/
+            765: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                var FDLayout = __webpack_require__2(551).FDLayout;
+                var CoSEGraphManager = __webpack_require__2(578);
+                var CoSEGraph = __webpack_require__2(880);
+                var CoSENode = __webpack_require__2(991);
+                var CoSEEdge = __webpack_require__2(767);
+                var CoSEConstants = __webpack_require__2(806);
+                var ConstraintHandler = __webpack_require__2(902);
+                var FDLayoutConstants = __webpack_require__2(551).FDLayoutConstants;
+                var LayoutConstants = __webpack_require__2(551).LayoutConstants;
+                var Point = __webpack_require__2(551).Point;
+                var PointD = __webpack_require__2(551).PointD;
+                var DimensionD = __webpack_require__2(551).DimensionD;
+                var Layout = __webpack_require__2(551).Layout;
+                var Integer = __webpack_require__2(551).Integer;
+                var IGeometry = __webpack_require__2(551).IGeometry;
+                var LGraph = __webpack_require__2(551).LGraph;
+                var Transform = __webpack_require__2(551).Transform;
+                var LinkedList = __webpack_require__2(551).LinkedList;
+                function CoSELayout() {
+                  FDLayout.call(this);
+                  this.toBeTiled = {};
+                  this.constraints = {};
+                }
+                CoSELayout.prototype = Object.create(FDLayout.prototype);
+                for (var prop in FDLayout) {
+                  CoSELayout[prop] = FDLayout[prop];
+                }
+                CoSELayout.prototype.newGraphManager = function() {
+                  var gm = new CoSEGraphManager(this);
+                  this.graphManager = gm;
+                  return gm;
+                };
+                CoSELayout.prototype.newGraph = function(vGraph) {
+                  return new CoSEGraph(null, this.graphManager, vGraph);
+                };
+                CoSELayout.prototype.newNode = function(vNode) {
+                  return new CoSENode(this.graphManager, vNode);
+                };
+                CoSELayout.prototype.newEdge = function(vEdge) {
+                  return new CoSEEdge(null, null, vEdge);
+                };
+                CoSELayout.prototype.initParameters = function() {
+                  FDLayout.prototype.initParameters.call(this, arguments);
+                  if (!this.isSubLayout) {
+                    if (CoSEConstants.DEFAULT_EDGE_LENGTH < 10) {
+                      this.idealEdgeLength = 10;
+                    } else {
+                      this.idealEdgeLength = CoSEConstants.DEFAULT_EDGE_LENGTH;
+                    }
+                    this.useSmartIdealEdgeLengthCalculation = CoSEConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION;
+                    this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH;
+                    this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH;
+                    this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR;
+                    this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR;
+                    this.prunedNodesAll = [];
+                    this.growTreeIterations = 0;
+                    this.afterGrowthIterations = 0;
+                    this.isTreeGrowing = false;
+                    this.isGrowthFinished = false;
+                  }
+                };
+                CoSELayout.prototype.initSpringEmbedder = function() {
+                  FDLayout.prototype.initSpringEmbedder.call(this);
+                  this.coolingCycle = 0;
+                  this.maxCoolingCycle = this.maxIterations / FDLayoutConstants.CONVERGENCE_CHECK_PERIOD;
+                  this.finalTemperature = 0.04;
+                  this.coolingAdjuster = 1;
+                };
+                CoSELayout.prototype.layout = function() {
+                  var createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;
+                  if (createBendsAsNeeded) {
+                    this.createBendpoints();
+                    this.graphManager.resetAllEdges();
+                  }
+                  this.level = 0;
+                  return this.classicLayout();
+                };
+                CoSELayout.prototype.classicLayout = function() {
+                  this.nodesWithGravity = this.calculateNodesToApplyGravitationTo();
+                  this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity);
+                  this.calcNoOfChildrenForAllNodes();
+                  this.graphManager.calcLowestCommonAncestors();
+                  this.graphManager.calcInclusionTreeDepths();
+                  this.graphManager.getRoot().calcEstimatedSize();
+                  this.calcIdealEdgeLengths();
+                  if (!this.incremental) {
+                    var forest = this.getFlatForest();
+                    if (forest.length > 0) {
+                      this.positionNodesRadially(forest);
+                    } else {
+                      this.reduceTrees();
+                      this.graphManager.resetAllNodesToApplyGravitation();
+                      var allNodes = new Set(this.getAllNodes());
+                      var intersection = this.nodesWithGravity.filter(function(x) {
+                        return allNodes.has(x);
+                      });
+                      this.graphManager.setAllNodesToApplyGravitation(intersection);
+                      this.positionNodesRandomly();
+                    }
+                  } else {
+                    if (CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL) {
+                      this.reduceTrees();
+                      this.graphManager.resetAllNodesToApplyGravitation();
+                      var allNodes = new Set(this.getAllNodes());
+                      var intersection = this.nodesWithGravity.filter(function(x) {
+                        return allNodes.has(x);
+                      });
+                      this.graphManager.setAllNodesToApplyGravitation(intersection);
+                    }
+                  }
+                  if (Object.keys(this.constraints).length > 0) {
+                    ConstraintHandler.handleConstraints(this);
+                    this.initConstraintVariables();
+                  }
+                  this.initSpringEmbedder();
+                  if (CoSEConstants.APPLY_LAYOUT) {
+                    this.runSpringEmbedder();
+                  }
+                  return true;
+                };
+                CoSELayout.prototype.tick = function() {
+                  this.totalIterations++;
+                  if (this.totalIterations === this.maxIterations && !this.isTreeGrowing && !this.isGrowthFinished) {
+                    if (this.prunedNodesAll.length > 0) {
+                      this.isTreeGrowing = true;
+                    } else {
+                      return true;
+                    }
+                  }
+                  if (this.totalIterations % FDLayoutConstants.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) {
+                    if (this.isConverged()) {
+                      if (this.prunedNodesAll.length > 0) {
+                        this.isTreeGrowing = true;
+                      } else {
+                        return true;
+                      }
+                    }
+                    this.coolingCycle++;
+                    if (this.layoutQuality == 0) {
+                      this.coolingAdjuster = this.coolingCycle;
+                    } else if (this.layoutQuality == 1) {
+                      this.coolingAdjuster = this.coolingCycle / 3;
+                    }
+                    this.coolingFactor = Math.max(this.initialCoolingFactor - Math.pow(this.coolingCycle, Math.log(100 * (this.initialCoolingFactor - this.finalTemperature)) / Math.log(this.maxCoolingCycle)) / 100 * this.coolingAdjuster, this.finalTemperature);
+                    this.animationPeriod = Math.ceil(this.initialAnimationPeriod * Math.sqrt(this.coolingFactor));
+                  }
+                  if (this.isTreeGrowing) {
+                    if (this.growTreeIterations % 10 == 0) {
+                      if (this.prunedNodesAll.length > 0) {
+                        this.graphManager.updateBounds();
+                        this.updateGrid();
+                        this.growTree(this.prunedNodesAll);
+                        this.graphManager.resetAllNodesToApplyGravitation();
+                        var allNodes = new Set(this.getAllNodes());
+                        var intersection = this.nodesWithGravity.filter(function(x) {
+                          return allNodes.has(x);
+                        });
+                        this.graphManager.setAllNodesToApplyGravitation(intersection);
+                        this.graphManager.updateBounds();
+                        this.updateGrid();
+                        if (CoSEConstants.PURE_INCREMENTAL) this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2;
+                        else this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+                      } else {
+                        this.isTreeGrowing = false;
+                        this.isGrowthFinished = true;
+                      }
+                    }
+                    this.growTreeIterations++;
+                  }
+                  if (this.isGrowthFinished) {
+                    if (this.isConverged()) {
+                      return true;
+                    }
+                    if (this.afterGrowthIterations % 10 == 0) {
+                      this.graphManager.updateBounds();
+                      this.updateGrid();
+                    }
+                    if (CoSEConstants.PURE_INCREMENTAL) this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2 * ((100 - this.afterGrowthIterations) / 100);
+                    else this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100);
+                    this.afterGrowthIterations++;
+                  }
+                  var gridUpdateAllowed = !this.isTreeGrowing && !this.isGrowthFinished;
+                  var forceToNodeSurroundingUpdate = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished;
+                  this.totalDisplacement = 0;
+                  this.graphManager.updateBounds();
+                  this.calcSpringForces();
+                  this.calcRepulsionForces(gridUpdateAllowed, forceToNodeSurroundingUpdate);
+                  this.calcGravitationalForces();
+                  this.moveNodes();
+                  this.animate();
+                  return false;
+                };
+                CoSELayout.prototype.getPositionsData = function() {
+                  var allNodes = this.graphManager.getAllNodes();
+                  var pData = {};
+                  for (var i = 0; i < allNodes.length; i++) {
+                    var rect = allNodes[i].rect;
+                    var id = allNodes[i].id;
+                    pData[id] = {
+                      id,
+                      x: rect.getCenterX(),
+                      y: rect.getCenterY(),
+                      w: rect.width,
+                      h: rect.height
+                    };
+                  }
+                  return pData;
+                };
+                CoSELayout.prototype.runSpringEmbedder = function() {
+                  this.initialAnimationPeriod = 25;
+                  this.animationPeriod = this.initialAnimationPeriod;
+                  var layoutEnded = false;
+                  if (FDLayoutConstants.ANIMATE === "during") {
+                    this.emit("layoutstarted");
+                  } else {
+                    while (!layoutEnded) {
+                      layoutEnded = this.tick();
+                    }
+                    this.graphManager.updateBounds();
+                  }
+                };
+                CoSELayout.prototype.moveNodes = function() {
+                  var lNodes = this.getAllNodes();
+                  var node;
+                  for (var i = 0; i < lNodes.length; i++) {
+                    node = lNodes[i];
+                    node.calculateDisplacement();
+                  }
+                  if (Object.keys(this.constraints).length > 0) {
+                    this.updateDisplacements();
+                  }
+                  for (var i = 0; i < lNodes.length; i++) {
+                    node = lNodes[i];
+                    node.move();
+                  }
+                };
+                CoSELayout.prototype.initConstraintVariables = function() {
+                  var self = this;
+                  this.idToNodeMap = /* @__PURE__ */ new Map();
+                  this.fixedNodeSet = /* @__PURE__ */ new Set();
+                  var allNodes = this.graphManager.getAllNodes();
+                  for (var i = 0; i < allNodes.length; i++) {
+                    var node = allNodes[i];
+                    this.idToNodeMap.set(node.id, node);
+                  }
+                  var calculateCompoundWeight = function calculateCompoundWeight2(compoundNode) {
+                    var nodes = compoundNode.getChild().getNodes();
+                    var node2;
+                    var fixedNodeWeight2 = 0;
+                    for (var i2 = 0; i2 < nodes.length; i2++) {
+                      node2 = nodes[i2];
+                      if (node2.getChild() == null) {
+                        if (self.fixedNodeSet.has(node2.id)) {
+                          fixedNodeWeight2 += 100;
+                        }
+                      } else {
+                        fixedNodeWeight2 += calculateCompoundWeight2(node2);
+                      }
+                    }
+                    return fixedNodeWeight2;
+                  };
+                  if (this.constraints.fixedNodeConstraint) {
+                    this.constraints.fixedNodeConstraint.forEach(function(nodeData) {
+                      self.fixedNodeSet.add(nodeData.nodeId);
+                    });
+                    var allNodes = this.graphManager.getAllNodes();
+                    var node;
+                    for (var i = 0; i < allNodes.length; i++) {
+                      node = allNodes[i];
+                      if (node.getChild() != null) {
+                        var fixedNodeWeight = calculateCompoundWeight(node);
+                        if (fixedNodeWeight > 0) {
+                          node.fixedNodeWeight = fixedNodeWeight;
+                        }
+                      }
+                    }
+                  }
+                  if (this.constraints.relativePlacementConstraint) {
+                    var nodeToDummyForVerticalAlignment = /* @__PURE__ */ new Map();
+                    var nodeToDummyForHorizontalAlignment = /* @__PURE__ */ new Map();
+                    this.dummyToNodeForVerticalAlignment = /* @__PURE__ */ new Map();
+                    this.dummyToNodeForHorizontalAlignment = /* @__PURE__ */ new Map();
+                    this.fixedNodesOnHorizontal = /* @__PURE__ */ new Set();
+                    this.fixedNodesOnVertical = /* @__PURE__ */ new Set();
+                    this.fixedNodeSet.forEach(function(nodeId) {
+                      self.fixedNodesOnHorizontal.add(nodeId);
+                      self.fixedNodesOnVertical.add(nodeId);
+                    });
+                    if (this.constraints.alignmentConstraint) {
+                      if (this.constraints.alignmentConstraint.vertical) {
+                        var verticalAlignment = this.constraints.alignmentConstraint.vertical;
+                        for (var i = 0; i < verticalAlignment.length; i++) {
+                          this.dummyToNodeForVerticalAlignment.set("dummy" + i, []);
+                          verticalAlignment[i].forEach(function(nodeId) {
+                            nodeToDummyForVerticalAlignment.set(nodeId, "dummy" + i);
+                            self.dummyToNodeForVerticalAlignment.get("dummy" + i).push(nodeId);
+                            if (self.fixedNodeSet.has(nodeId)) {
+                              self.fixedNodesOnHorizontal.add("dummy" + i);
+                            }
+                          });
+                        }
+                      }
+                      if (this.constraints.alignmentConstraint.horizontal) {
+                        var horizontalAlignment = this.constraints.alignmentConstraint.horizontal;
+                        for (var i = 0; i < horizontalAlignment.length; i++) {
+                          this.dummyToNodeForHorizontalAlignment.set("dummy" + i, []);
+                          horizontalAlignment[i].forEach(function(nodeId) {
+                            nodeToDummyForHorizontalAlignment.set(nodeId, "dummy" + i);
+                            self.dummyToNodeForHorizontalAlignment.get("dummy" + i).push(nodeId);
+                            if (self.fixedNodeSet.has(nodeId)) {
+                              self.fixedNodesOnVertical.add("dummy" + i);
+                            }
+                          });
+                        }
+                      }
+                    }
+                    if (CoSEConstants.RELAX_MOVEMENT_ON_CONSTRAINTS) {
+                      this.shuffle = function(array) {
+                        var j, x, i2;
+                        for (i2 = array.length - 1; i2 >= 2 * array.length / 3; i2--) {
+                          j = Math.floor(Math.random() * (i2 + 1));
+                          x = array[i2];
+                          array[i2] = array[j];
+                          array[j] = x;
+                        }
+                        return array;
+                      };
+                      this.nodesInRelativeHorizontal = [];
+                      this.nodesInRelativeVertical = [];
+                      this.nodeToRelativeConstraintMapHorizontal = /* @__PURE__ */ new Map();
+                      this.nodeToRelativeConstraintMapVertical = /* @__PURE__ */ new Map();
+                      this.nodeToTempPositionMapHorizontal = /* @__PURE__ */ new Map();
+                      this.nodeToTempPositionMapVertical = /* @__PURE__ */ new Map();
+                      this.constraints.relativePlacementConstraint.forEach(function(constraint) {
+                        if (constraint.left) {
+                          var nodeIdLeft = nodeToDummyForVerticalAlignment.has(constraint.left) ? nodeToDummyForVerticalAlignment.get(constraint.left) : constraint.left;
+                          var nodeIdRight = nodeToDummyForVerticalAlignment.has(constraint.right) ? nodeToDummyForVerticalAlignment.get(constraint.right) : constraint.right;
+                          if (!self.nodesInRelativeHorizontal.includes(nodeIdLeft)) {
+                            self.nodesInRelativeHorizontal.push(nodeIdLeft);
+                            self.nodeToRelativeConstraintMapHorizontal.set(nodeIdLeft, []);
+                            if (self.dummyToNodeForVerticalAlignment.has(nodeIdLeft)) {
+                              self.nodeToTempPositionMapHorizontal.set(nodeIdLeft, self.idToNodeMap.get(self.dummyToNodeForVerticalAlignment.get(nodeIdLeft)[0]).getCenterX());
+                            } else {
+                              self.nodeToTempPositionMapHorizontal.set(nodeIdLeft, self.idToNodeMap.get(nodeIdLeft).getCenterX());
+                            }
+                          }
+                          if (!self.nodesInRelativeHorizontal.includes(nodeIdRight)) {
+                            self.nodesInRelativeHorizontal.push(nodeIdRight);
+                            self.nodeToRelativeConstraintMapHorizontal.set(nodeIdRight, []);
+                            if (self.dummyToNodeForVerticalAlignment.has(nodeIdRight)) {
+                              self.nodeToTempPositionMapHorizontal.set(nodeIdRight, self.idToNodeMap.get(self.dummyToNodeForVerticalAlignment.get(nodeIdRight)[0]).getCenterX());
+                            } else {
+                              self.nodeToTempPositionMapHorizontal.set(nodeIdRight, self.idToNodeMap.get(nodeIdRight).getCenterX());
+                            }
+                          }
+                          self.nodeToRelativeConstraintMapHorizontal.get(nodeIdLeft).push({ right: nodeIdRight, gap: constraint.gap });
+                          self.nodeToRelativeConstraintMapHorizontal.get(nodeIdRight).push({ left: nodeIdLeft, gap: constraint.gap });
+                        } else {
+                          var nodeIdTop = nodeToDummyForHorizontalAlignment.has(constraint.top) ? nodeToDummyForHorizontalAlignment.get(constraint.top) : constraint.top;
+                          var nodeIdBottom = nodeToDummyForHorizontalAlignment.has(constraint.bottom) ? nodeToDummyForHorizontalAlignment.get(constraint.bottom) : constraint.bottom;
+                          if (!self.nodesInRelativeVertical.includes(nodeIdTop)) {
+                            self.nodesInRelativeVertical.push(nodeIdTop);
+                            self.nodeToRelativeConstraintMapVertical.set(nodeIdTop, []);
+                            if (self.dummyToNodeForHorizontalAlignment.has(nodeIdTop)) {
+                              self.nodeToTempPositionMapVertical.set(nodeIdTop, self.idToNodeMap.get(self.dummyToNodeForHorizontalAlignment.get(nodeIdTop)[0]).getCenterY());
+                            } else {
+                              self.nodeToTempPositionMapVertical.set(nodeIdTop, self.idToNodeMap.get(nodeIdTop).getCenterY());
+                            }
+                          }
+                          if (!self.nodesInRelativeVertical.includes(nodeIdBottom)) {
+                            self.nodesInRelativeVertical.push(nodeIdBottom);
+                            self.nodeToRelativeConstraintMapVertical.set(nodeIdBottom, []);
+                            if (self.dummyToNodeForHorizontalAlignment.has(nodeIdBottom)) {
+                              self.nodeToTempPositionMapVertical.set(nodeIdBottom, self.idToNodeMap.get(self.dummyToNodeForHorizontalAlignment.get(nodeIdBottom)[0]).getCenterY());
+                            } else {
+                              self.nodeToTempPositionMapVertical.set(nodeIdBottom, self.idToNodeMap.get(nodeIdBottom).getCenterY());
+                            }
+                          }
+                          self.nodeToRelativeConstraintMapVertical.get(nodeIdTop).push({ bottom: nodeIdBottom, gap: constraint.gap });
+                          self.nodeToRelativeConstraintMapVertical.get(nodeIdBottom).push({ top: nodeIdTop, gap: constraint.gap });
+                        }
+                      });
+                    } else {
+                      var subGraphOnHorizontal = /* @__PURE__ */ new Map();
+                      var subGraphOnVertical = /* @__PURE__ */ new Map();
+                      this.constraints.relativePlacementConstraint.forEach(function(constraint) {
+                        if (constraint.left) {
+                          var left = nodeToDummyForVerticalAlignment.has(constraint.left) ? nodeToDummyForVerticalAlignment.get(constraint.left) : constraint.left;
+                          var right = nodeToDummyForVerticalAlignment.has(constraint.right) ? nodeToDummyForVerticalAlignment.get(constraint.right) : constraint.right;
+                          if (subGraphOnHorizontal.has(left)) {
+                            subGraphOnHorizontal.get(left).push(right);
+                          } else {
+                            subGraphOnHorizontal.set(left, [right]);
+                          }
+                          if (subGraphOnHorizontal.has(right)) {
+                            subGraphOnHorizontal.get(right).push(left);
+                          } else {
+                            subGraphOnHorizontal.set(right, [left]);
+                          }
+                        } else {
+                          var top = nodeToDummyForHorizontalAlignment.has(constraint.top) ? nodeToDummyForHorizontalAlignment.get(constraint.top) : constraint.top;
+                          var bottom = nodeToDummyForHorizontalAlignment.has(constraint.bottom) ? nodeToDummyForHorizontalAlignment.get(constraint.bottom) : constraint.bottom;
+                          if (subGraphOnVertical.has(top)) {
+                            subGraphOnVertical.get(top).push(bottom);
+                          } else {
+                            subGraphOnVertical.set(top, [bottom]);
+                          }
+                          if (subGraphOnVertical.has(bottom)) {
+                            subGraphOnVertical.get(bottom).push(top);
+                          } else {
+                            subGraphOnVertical.set(bottom, [top]);
+                          }
+                        }
+                      });
+                      var constructComponents = function constructComponents2(graph, fixedNodes) {
+                        var components = [];
+                        var isFixed = [];
+                        var queue = new LinkedList();
+                        var visited = /* @__PURE__ */ new Set();
+                        var count = 0;
+                        graph.forEach(function(value, key) {
+                          if (!visited.has(key)) {
+                            components[count] = [];
+                            isFixed[count] = false;
+                            var currentNode = key;
+                            queue.push(currentNode);
+                            visited.add(currentNode);
+                            components[count].push(currentNode);
+                            while (queue.length != 0) {
+                              currentNode = queue.shift();
+                              if (fixedNodes.has(currentNode)) {
+                                isFixed[count] = true;
+                              }
+                              var neighbors = graph.get(currentNode);
+                              neighbors.forEach(function(neighbor) {
+                                if (!visited.has(neighbor)) {
+                                  queue.push(neighbor);
+                                  visited.add(neighbor);
+                                  components[count].push(neighbor);
+                                }
+                              });
+                            }
+                            count++;
+                          }
+                        });
+                        return { components, isFixed };
+                      };
+                      var resultOnHorizontal = constructComponents(subGraphOnHorizontal, self.fixedNodesOnHorizontal);
+                      this.componentsOnHorizontal = resultOnHorizontal.components;
+                      this.fixedComponentsOnHorizontal = resultOnHorizontal.isFixed;
+                      var resultOnVertical = constructComponents(subGraphOnVertical, self.fixedNodesOnVertical);
+                      this.componentsOnVertical = resultOnVertical.components;
+                      this.fixedComponentsOnVertical = resultOnVertical.isFixed;
+                    }
+                  }
+                };
+                CoSELayout.prototype.updateDisplacements = function() {
+                  var self = this;
+                  if (this.constraints.fixedNodeConstraint) {
+                    this.constraints.fixedNodeConstraint.forEach(function(nodeData) {
+                      var fixedNode = self.idToNodeMap.get(nodeData.nodeId);
+                      fixedNode.displacementX = 0;
+                      fixedNode.displacementY = 0;
+                    });
+                  }
+                  if (this.constraints.alignmentConstraint) {
+                    if (this.constraints.alignmentConstraint.vertical) {
+                      var allVerticalAlignments = this.constraints.alignmentConstraint.vertical;
+                      for (var i = 0; i < allVerticalAlignments.length; i++) {
+                        var totalDisplacementX = 0;
+                        for (var j = 0; j < allVerticalAlignments[i].length; j++) {
+                          if (this.fixedNodeSet.has(allVerticalAlignments[i][j])) {
+                            totalDisplacementX = 0;
+                            break;
+                          }
+                          totalDisplacementX += this.idToNodeMap.get(allVerticalAlignments[i][j]).displacementX;
+                        }
+                        var averageDisplacementX = totalDisplacementX / allVerticalAlignments[i].length;
+                        for (var j = 0; j < allVerticalAlignments[i].length; j++) {
+                          this.idToNodeMap.get(allVerticalAlignments[i][j]).displacementX = averageDisplacementX;
+                        }
+                      }
+                    }
+                    if (this.constraints.alignmentConstraint.horizontal) {
+                      var allHorizontalAlignments = this.constraints.alignmentConstraint.horizontal;
+                      for (var i = 0; i < allHorizontalAlignments.length; i++) {
+                        var totalDisplacementY = 0;
+                        for (var j = 0; j < allHorizontalAlignments[i].length; j++) {
+                          if (this.fixedNodeSet.has(allHorizontalAlignments[i][j])) {
+                            totalDisplacementY = 0;
+                            break;
+                          }
+                          totalDisplacementY += this.idToNodeMap.get(allHorizontalAlignments[i][j]).displacementY;
+                        }
+                        var averageDisplacementY = totalDisplacementY / allHorizontalAlignments[i].length;
+                        for (var j = 0; j < allHorizontalAlignments[i].length; j++) {
+                          this.idToNodeMap.get(allHorizontalAlignments[i][j]).displacementY = averageDisplacementY;
+                        }
+                      }
+                    }
+                  }
+                  if (this.constraints.relativePlacementConstraint) {
+                    if (CoSEConstants.RELAX_MOVEMENT_ON_CONSTRAINTS) {
+                      if (this.totalIterations % 10 == 0) {
+                        this.shuffle(this.nodesInRelativeHorizontal);
+                        this.shuffle(this.nodesInRelativeVertical);
+                      }
+                      this.nodesInRelativeHorizontal.forEach(function(nodeId) {
+                        if (!self.fixedNodesOnHorizontal.has(nodeId)) {
+                          var displacement = 0;
+                          if (self.dummyToNodeForVerticalAlignment.has(nodeId)) {
+                            displacement = self.idToNodeMap.get(self.dummyToNodeForVerticalAlignment.get(nodeId)[0]).displacementX;
+                          } else {
+                            displacement = self.idToNodeMap.get(nodeId).displacementX;
+                          }
+                          self.nodeToRelativeConstraintMapHorizontal.get(nodeId).forEach(function(constraint) {
+                            if (constraint.right) {
+                              var diff = self.nodeToTempPositionMapHorizontal.get(constraint.right) - self.nodeToTempPositionMapHorizontal.get(nodeId) - displacement;
+                              if (diff < constraint.gap) {
+                                displacement -= constraint.gap - diff;
+                              }
+                            } else {
+                              var diff = self.nodeToTempPositionMapHorizontal.get(nodeId) - self.nodeToTempPositionMapHorizontal.get(constraint.left) + displacement;
+                              if (diff < constraint.gap) {
+                                displacement += constraint.gap - diff;
+                              }
+                            }
+                          });
+                          self.nodeToTempPositionMapHorizontal.set(nodeId, self.nodeToTempPositionMapHorizontal.get(nodeId) + displacement);
+                          if (self.dummyToNodeForVerticalAlignment.has(nodeId)) {
+                            self.dummyToNodeForVerticalAlignment.get(nodeId).forEach(function(nodeId2) {
+                              self.idToNodeMap.get(nodeId2).displacementX = displacement;
+                            });
+                          } else {
+                            self.idToNodeMap.get(nodeId).displacementX = displacement;
+                          }
+                        }
+                      });
+                      this.nodesInRelativeVertical.forEach(function(nodeId) {
+                        if (!self.fixedNodesOnHorizontal.has(nodeId)) {
+                          var displacement = 0;
+                          if (self.dummyToNodeForHorizontalAlignment.has(nodeId)) {
+                            displacement = self.idToNodeMap.get(self.dummyToNodeForHorizontalAlignment.get(nodeId)[0]).displacementY;
+                          } else {
+                            displacement = self.idToNodeMap.get(nodeId).displacementY;
+                          }
+                          self.nodeToRelativeConstraintMapVertical.get(nodeId).forEach(function(constraint) {
+                            if (constraint.bottom) {
+                              var diff = self.nodeToTempPositionMapVertical.get(constraint.bottom) - self.nodeToTempPositionMapVertical.get(nodeId) - displacement;
+                              if (diff < constraint.gap) {
+                                displacement -= constraint.gap - diff;
+                              }
+                            } else {
+                              var diff = self.nodeToTempPositionMapVertical.get(nodeId) - self.nodeToTempPositionMapVertical.get(constraint.top) + displacement;
+                              if (diff < constraint.gap) {
+                                displacement += constraint.gap - diff;
+                              }
+                            }
+                          });
+                          self.nodeToTempPositionMapVertical.set(nodeId, self.nodeToTempPositionMapVertical.get(nodeId) + displacement);
+                          if (self.dummyToNodeForHorizontalAlignment.has(nodeId)) {
+                            self.dummyToNodeForHorizontalAlignment.get(nodeId).forEach(function(nodeId2) {
+                              self.idToNodeMap.get(nodeId2).displacementY = displacement;
+                            });
+                          } else {
+                            self.idToNodeMap.get(nodeId).displacementY = displacement;
+                          }
+                        }
+                      });
+                    } else {
+                      for (var i = 0; i < this.componentsOnHorizontal.length; i++) {
+                        var component = this.componentsOnHorizontal[i];
+                        if (this.fixedComponentsOnHorizontal[i]) {
+                          for (var j = 0; j < component.length; j++) {
+                            if (this.dummyToNodeForVerticalAlignment.has(component[j])) {
+                              this.dummyToNodeForVerticalAlignment.get(component[j]).forEach(function(nodeId) {
+                                self.idToNodeMap.get(nodeId).displacementX = 0;
+                              });
+                            } else {
+                              this.idToNodeMap.get(component[j]).displacementX = 0;
+                            }
+                          }
+                        } else {
+                          var sum = 0;
+                          var count = 0;
+                          for (var j = 0; j < component.length; j++) {
+                            if (this.dummyToNodeForVerticalAlignment.has(component[j])) {
+                              var actualNodes = this.dummyToNodeForVerticalAlignment.get(component[j]);
+                              sum += actualNodes.length * this.idToNodeMap.get(actualNodes[0]).displacementX;
+                              count += actualNodes.length;
+                            } else {
+                              sum += this.idToNodeMap.get(component[j]).displacementX;
+                              count++;
+                            }
+                          }
+                          var averageDisplacement = sum / count;
+                          for (var j = 0; j < component.length; j++) {
+                            if (this.dummyToNodeForVerticalAlignment.has(component[j])) {
+                              this.dummyToNodeForVerticalAlignment.get(component[j]).forEach(function(nodeId) {
+                                self.idToNodeMap.get(nodeId).displacementX = averageDisplacement;
+                              });
+                            } else {
+                              this.idToNodeMap.get(component[j]).displacementX = averageDisplacement;
+                            }
+                          }
+                        }
+                      }
+                      for (var i = 0; i < this.componentsOnVertical.length; i++) {
+                        var component = this.componentsOnVertical[i];
+                        if (this.fixedComponentsOnVertical[i]) {
+                          for (var j = 0; j < component.length; j++) {
+                            if (this.dummyToNodeForHorizontalAlignment.has(component[j])) {
+                              this.dummyToNodeForHorizontalAlignment.get(component[j]).forEach(function(nodeId) {
+                                self.idToNodeMap.get(nodeId).displacementY = 0;
+                              });
+                            } else {
+                              this.idToNodeMap.get(component[j]).displacementY = 0;
+                            }
+                          }
+                        } else {
+                          var sum = 0;
+                          var count = 0;
+                          for (var j = 0; j < component.length; j++) {
+                            if (this.dummyToNodeForHorizontalAlignment.has(component[j])) {
+                              var actualNodes = this.dummyToNodeForHorizontalAlignment.get(component[j]);
+                              sum += actualNodes.length * this.idToNodeMap.get(actualNodes[0]).displacementY;
+                              count += actualNodes.length;
+                            } else {
+                              sum += this.idToNodeMap.get(component[j]).displacementY;
+                              count++;
+                            }
+                          }
+                          var averageDisplacement = sum / count;
+                          for (var j = 0; j < component.length; j++) {
+                            if (this.dummyToNodeForHorizontalAlignment.has(component[j])) {
+                              this.dummyToNodeForHorizontalAlignment.get(component[j]).forEach(function(nodeId) {
+                                self.idToNodeMap.get(nodeId).displacementY = averageDisplacement;
+                              });
+                            } else {
+                              this.idToNodeMap.get(component[j]).displacementY = averageDisplacement;
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                };
+                CoSELayout.prototype.calculateNodesToApplyGravitationTo = function() {
+                  var nodeList = [];
+                  var graph;
+                  var graphs = this.graphManager.getGraphs();
+                  var size = graphs.length;
+                  var i;
+                  for (i = 0; i < size; i++) {
+                    graph = graphs[i];
+                    graph.updateConnected();
+                    if (!graph.isConnected) {
+                      nodeList = nodeList.concat(graph.getNodes());
+                    }
+                  }
+                  return nodeList;
+                };
+                CoSELayout.prototype.createBendpoints = function() {
+                  var edges = [];
+                  edges = edges.concat(this.graphManager.getAllEdges());
+                  var visited = /* @__PURE__ */ new Set();
+                  var i;
+                  for (i = 0; i < edges.length; i++) {
+                    var edge = edges[i];
+                    if (!visited.has(edge)) {
+                      var source = edge.getSource();
+                      var target = edge.getTarget();
+                      if (source == target) {
+                        edge.getBendpoints().push(new PointD());
+                        edge.getBendpoints().push(new PointD());
+                        this.createDummyNodesForBendpoints(edge);
+                        visited.add(edge);
+                      } else {
+                        var edgeList = [];
+                        edgeList = edgeList.concat(source.getEdgeListToNode(target));
+                        edgeList = edgeList.concat(target.getEdgeListToNode(source));
+                        if (!visited.has(edgeList[0])) {
+                          if (edgeList.length > 1) {
+                            var k;
+                            for (k = 0; k < edgeList.length; k++) {
+                              var multiEdge = edgeList[k];
+                              multiEdge.getBendpoints().push(new PointD());
+                              this.createDummyNodesForBendpoints(multiEdge);
+                            }
+                          }
+                          edgeList.forEach(function(edge2) {
+                            visited.add(edge2);
+                          });
+                        }
+                      }
+                    }
+                    if (visited.size == edges.length) {
+                      break;
+                    }
+                  }
+                };
+                CoSELayout.prototype.positionNodesRadially = function(forest) {
+                  var currentStartingPoint = new Point(0, 0);
+                  var numberOfColumns = Math.ceil(Math.sqrt(forest.length));
+                  var height = 0;
+                  var currentY = 0;
+                  var currentX = 0;
+                  var point = new PointD(0, 0);
+                  for (var i = 0; i < forest.length; i++) {
+                    if (i % numberOfColumns == 0) {
+                      currentX = 0;
+                      currentY = height;
+                      if (i != 0) {
+                        currentY += CoSEConstants.DEFAULT_COMPONENT_SEPERATION;
+                      }
+                      height = 0;
+                    }
+                    var tree = forest[i];
+                    var centerNode = Layout.findCenterOfTree(tree);
+                    currentStartingPoint.x = currentX;
+                    currentStartingPoint.y = currentY;
+                    point = CoSELayout.radialLayout(tree, centerNode, currentStartingPoint);
+                    if (point.y > height) {
+                      height = Math.floor(point.y);
+                    }
+                    currentX = Math.floor(point.x + CoSEConstants.DEFAULT_COMPONENT_SEPERATION);
+                  }
+                  this.transform(new PointD(LayoutConstants.WORLD_CENTER_X - point.x / 2, LayoutConstants.WORLD_CENTER_Y - point.y / 2));
+                };
+                CoSELayout.radialLayout = function(tree, centerNode, startingPoint) {
+                  var radialSep = Math.max(this.maxDiagonalInTree(tree), CoSEConstants.DEFAULT_RADIAL_SEPARATION);
+                  CoSELayout.branchRadialLayout(centerNode, null, 0, 359, 0, radialSep);
+                  var bounds = LGraph.calculateBounds(tree);
+                  var transform = new Transform();
+                  transform.setDeviceOrgX(bounds.getMinX());
+                  transform.setDeviceOrgY(bounds.getMinY());
+                  transform.setWorldOrgX(startingPoint.x);
+                  transform.setWorldOrgY(startingPoint.y);
+                  for (var i = 0; i < tree.length; i++) {
+                    var node = tree[i];
+                    node.transform(transform);
+                  }
+                  var bottomRight = new PointD(bounds.getMaxX(), bounds.getMaxY());
+                  return transform.inverseTransformPoint(bottomRight);
+                };
+                CoSELayout.branchRadialLayout = function(node, parentOfNode, startAngle, endAngle, distance, radialSeparation) {
+                  var halfInterval = (endAngle - startAngle + 1) / 2;
+                  if (halfInterval < 0) {
+                    halfInterval += 180;
+                  }
+                  var nodeAngle = (halfInterval + startAngle) % 360;
+                  var teta = nodeAngle * IGeometry.TWO_PI / 360;
+                  var x_ = distance * Math.cos(teta);
+                  var y_ = distance * Math.sin(teta);
+                  node.setCenter(x_, y_);
+                  var neighborEdges = [];
+                  neighborEdges = neighborEdges.concat(node.getEdges());
+                  var childCount = neighborEdges.length;
+                  if (parentOfNode != null) {
+                    childCount--;
+                  }
+                  var branchCount = 0;
+                  var incEdgesCount = neighborEdges.length;
+                  var startIndex;
+                  var edges = node.getEdgesBetween(parentOfNode);
+                  while (edges.length > 1) {
+                    var temp = edges[0];
+                    edges.splice(0, 1);
+                    var index = neighborEdges.indexOf(temp);
+                    if (index >= 0) {
+                      neighborEdges.splice(index, 1);
+                    }
+                    incEdgesCount--;
+                    childCount--;
+                  }
+                  if (parentOfNode != null) {
+                    startIndex = (neighborEdges.indexOf(edges[0]) + 1) % incEdgesCount;
+                  } else {
+                    startIndex = 0;
+                  }
+                  var stepAngle = Math.abs(endAngle - startAngle) / childCount;
+                  for (var i = startIndex; branchCount != childCount; i = ++i % incEdgesCount) {
+                    var currentNeighbor = neighborEdges[i].getOtherEnd(node);
+                    if (currentNeighbor == parentOfNode) {
+                      continue;
+                    }
+                    var childStartAngle = (startAngle + branchCount * stepAngle) % 360;
+                    var childEndAngle = (childStartAngle + stepAngle) % 360;
+                    CoSELayout.branchRadialLayout(currentNeighbor, node, childStartAngle, childEndAngle, distance + radialSeparation, radialSeparation);
+                    branchCount++;
+                  }
+                };
+                CoSELayout.maxDiagonalInTree = function(tree) {
+                  var maxDiagonal = Integer.MIN_VALUE;
+                  for (var i = 0; i < tree.length; i++) {
+                    var node = tree[i];
+                    var diagonal = node.getDiagonal();
+                    if (diagonal > maxDiagonal) {
+                      maxDiagonal = diagonal;
+                    }
+                  }
+                  return maxDiagonal;
+                };
+                CoSELayout.prototype.calcRepulsionRange = function() {
+                  return 2 * (this.level + 1) * this.idealEdgeLength;
+                };
+                CoSELayout.prototype.groupZeroDegreeMembers = function() {
+                  var self = this;
+                  var tempMemberGroups = {};
+                  this.memberGroups = {};
+                  this.idToDummyNode = {};
+                  var zeroDegree = [];
+                  var allNodes = this.graphManager.getAllNodes();
+                  for (var i = 0; i < allNodes.length; i++) {
+                    var node = allNodes[i];
+                    var parent = node.getParent();
+                    if (this.getNodeDegreeWithChildren(node) === 0 && (parent.id == void 0 || !this.getToBeTiled(parent))) {
+                      zeroDegree.push(node);
+                    }
+                  }
+                  for (var i = 0; i < zeroDegree.length; i++) {
+                    var node = zeroDegree[i];
+                    var p_id = node.getParent().id;
+                    if (typeof tempMemberGroups[p_id] === "undefined") tempMemberGroups[p_id] = [];
+                    tempMemberGroups[p_id] = tempMemberGroups[p_id].concat(node);
+                  }
+                  Object.keys(tempMemberGroups).forEach(function(p_id2) {
+                    if (tempMemberGroups[p_id2].length > 1) {
+                      var dummyCompoundId = "DummyCompound_" + p_id2;
+                      self.memberGroups[dummyCompoundId] = tempMemberGroups[p_id2];
+                      var parent2 = tempMemberGroups[p_id2][0].getParent();
+                      var dummyCompound = new CoSENode(self.graphManager);
+                      dummyCompound.id = dummyCompoundId;
+                      dummyCompound.paddingLeft = parent2.paddingLeft || 0;
+                      dummyCompound.paddingRight = parent2.paddingRight || 0;
+                      dummyCompound.paddingBottom = parent2.paddingBottom || 0;
+                      dummyCompound.paddingTop = parent2.paddingTop || 0;
+                      self.idToDummyNode[dummyCompoundId] = dummyCompound;
+                      var dummyParentGraph = self.getGraphManager().add(self.newGraph(), dummyCompound);
+                      var parentGraph = parent2.getChild();
+                      parentGraph.add(dummyCompound);
+                      for (var i2 = 0; i2 < tempMemberGroups[p_id2].length; i2++) {
+                        var node2 = tempMemberGroups[p_id2][i2];
+                        parentGraph.remove(node2);
+                        dummyParentGraph.add(node2);
+                      }
+                    }
+                  });
+                };
+                CoSELayout.prototype.clearCompounds = function() {
+                  var childGraphMap = {};
+                  var idToNode = {};
+                  this.performDFSOnCompounds();
+                  for (var i = 0; i < this.compoundOrder.length; i++) {
+                    idToNode[this.compoundOrder[i].id] = this.compoundOrder[i];
+                    childGraphMap[this.compoundOrder[i].id] = [].concat(this.compoundOrder[i].getChild().getNodes());
+                    this.graphManager.remove(this.compoundOrder[i].getChild());
+                    this.compoundOrder[i].child = null;
+                  }
+                  this.graphManager.resetAllNodes();
+                  this.tileCompoundMembers(childGraphMap, idToNode);
+                };
+                CoSELayout.prototype.clearZeroDegreeMembers = function() {
+                  var self = this;
+                  var tiledZeroDegreePack = this.tiledZeroDegreePack = [];
+                  Object.keys(this.memberGroups).forEach(function(id) {
+                    var compoundNode = self.idToDummyNode[id];
+                    tiledZeroDegreePack[id] = self.tileNodes(self.memberGroups[id], compoundNode.paddingLeft + compoundNode.paddingRight);
+                    compoundNode.rect.width = tiledZeroDegreePack[id].width;
+                    compoundNode.rect.height = tiledZeroDegreePack[id].height;
+                    compoundNode.setCenter(tiledZeroDegreePack[id].centerX, tiledZeroDegreePack[id].centerY);
+                    compoundNode.labelMarginLeft = 0;
+                    compoundNode.labelMarginTop = 0;
+                    if (CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                      var width = compoundNode.rect.width;
+                      var height = compoundNode.rect.height;
+                      if (compoundNode.labelWidth) {
+                        if (compoundNode.labelPosHorizontal == "left") {
+                          compoundNode.rect.x -= compoundNode.labelWidth;
+                          compoundNode.setWidth(width + compoundNode.labelWidth);
+                          compoundNode.labelMarginLeft = compoundNode.labelWidth;
+                        } else if (compoundNode.labelPosHorizontal == "center" && compoundNode.labelWidth > width) {
+                          compoundNode.rect.x -= (compoundNode.labelWidth - width) / 2;
+                          compoundNode.setWidth(compoundNode.labelWidth);
+                          compoundNode.labelMarginLeft = (compoundNode.labelWidth - width) / 2;
+                        } else if (compoundNode.labelPosHorizontal == "right") {
+                          compoundNode.setWidth(width + compoundNode.labelWidth);
+                        }
+                      }
+                      if (compoundNode.labelHeight) {
+                        if (compoundNode.labelPosVertical == "top") {
+                          compoundNode.rect.y -= compoundNode.labelHeight;
+                          compoundNode.setHeight(height + compoundNode.labelHeight);
+                          compoundNode.labelMarginTop = compoundNode.labelHeight;
+                        } else if (compoundNode.labelPosVertical == "center" && compoundNode.labelHeight > height) {
+                          compoundNode.rect.y -= (compoundNode.labelHeight - height) / 2;
+                          compoundNode.setHeight(compoundNode.labelHeight);
+                          compoundNode.labelMarginTop = (compoundNode.labelHeight - height) / 2;
+                        } else if (compoundNode.labelPosVertical == "bottom") {
+                          compoundNode.setHeight(height + compoundNode.labelHeight);
+                        }
+                      }
+                    }
+                  });
+                };
+                CoSELayout.prototype.repopulateCompounds = function() {
+                  for (var i = this.compoundOrder.length - 1; i >= 0; i--) {
+                    var lCompoundNode = this.compoundOrder[i];
+                    var id = lCompoundNode.id;
+                    var horizontalMargin = lCompoundNode.paddingLeft;
+                    var verticalMargin = lCompoundNode.paddingTop;
+                    var labelMarginLeft = lCompoundNode.labelMarginLeft;
+                    var labelMarginTop = lCompoundNode.labelMarginTop;
+                    this.adjustLocations(this.tiledMemberPack[id], lCompoundNode.rect.x, lCompoundNode.rect.y, horizontalMargin, verticalMargin, labelMarginLeft, labelMarginTop);
+                  }
+                };
+                CoSELayout.prototype.repopulateZeroDegreeMembers = function() {
+                  var self = this;
+                  var tiledPack = this.tiledZeroDegreePack;
+                  Object.keys(tiledPack).forEach(function(id) {
+                    var compoundNode = self.idToDummyNode[id];
+                    var horizontalMargin = compoundNode.paddingLeft;
+                    var verticalMargin = compoundNode.paddingTop;
+                    var labelMarginLeft = compoundNode.labelMarginLeft;
+                    var labelMarginTop = compoundNode.labelMarginTop;
+                    self.adjustLocations(tiledPack[id], compoundNode.rect.x, compoundNode.rect.y, horizontalMargin, verticalMargin, labelMarginLeft, labelMarginTop);
+                  });
+                };
+                CoSELayout.prototype.getToBeTiled = function(node) {
+                  var id = node.id;
+                  if (this.toBeTiled[id] != null) {
+                    return this.toBeTiled[id];
+                  }
+                  var childGraph = node.getChild();
+                  if (childGraph == null) {
+                    this.toBeTiled[id] = false;
+                    return false;
+                  }
+                  var children = childGraph.getNodes();
+                  for (var i = 0; i < children.length; i++) {
+                    var theChild = children[i];
+                    if (this.getNodeDegree(theChild) > 0) {
+                      this.toBeTiled[id] = false;
+                      return false;
+                    }
+                    if (theChild.getChild() == null) {
+                      this.toBeTiled[theChild.id] = false;
+                      continue;
+                    }
+                    if (!this.getToBeTiled(theChild)) {
+                      this.toBeTiled[id] = false;
+                      return false;
+                    }
+                  }
+                  this.toBeTiled[id] = true;
+                  return true;
+                };
+                CoSELayout.prototype.getNodeDegree = function(node) {
+                  node.id;
+                  var edges = node.getEdges();
+                  var degree = 0;
+                  for (var i = 0; i < edges.length; i++) {
+                    var edge = edges[i];
+                    if (edge.getSource().id !== edge.getTarget().id) {
+                      degree = degree + 1;
+                    }
+                  }
+                  return degree;
+                };
+                CoSELayout.prototype.getNodeDegreeWithChildren = function(node) {
+                  var degree = this.getNodeDegree(node);
+                  if (node.getChild() == null) {
+                    return degree;
+                  }
+                  var children = node.getChild().getNodes();
+                  for (var i = 0; i < children.length; i++) {
+                    var child = children[i];
+                    degree += this.getNodeDegreeWithChildren(child);
+                  }
+                  return degree;
+                };
+                CoSELayout.prototype.performDFSOnCompounds = function() {
+                  this.compoundOrder = [];
+                  this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes());
+                };
+                CoSELayout.prototype.fillCompexOrderByDFS = function(children) {
+                  for (var i = 0; i < children.length; i++) {
+                    var child = children[i];
+                    if (child.getChild() != null) {
+                      this.fillCompexOrderByDFS(child.getChild().getNodes());
+                    }
+                    if (this.getToBeTiled(child)) {
+                      this.compoundOrder.push(child);
+                    }
+                  }
+                };
+                CoSELayout.prototype.adjustLocations = function(organization, x, y, compoundHorizontalMargin, compoundVerticalMargin, compoundLabelMarginLeft, compoundLabelMarginTop) {
+                  x += compoundHorizontalMargin + compoundLabelMarginLeft;
+                  y += compoundVerticalMargin + compoundLabelMarginTop;
+                  var left = x;
+                  for (var i = 0; i < organization.rows.length; i++) {
+                    var row = organization.rows[i];
+                    x = left;
+                    var maxHeight = 0;
+                    for (var j = 0; j < row.length; j++) {
+                      var lnode = row[j];
+                      lnode.rect.x = x;
+                      lnode.rect.y = y;
+                      x += lnode.rect.width + organization.horizontalPadding;
+                      if (lnode.rect.height > maxHeight) maxHeight = lnode.rect.height;
+                    }
+                    y += maxHeight + organization.verticalPadding;
+                  }
+                };
+                CoSELayout.prototype.tileCompoundMembers = function(childGraphMap, idToNode) {
+                  var self = this;
+                  this.tiledMemberPack = [];
+                  Object.keys(childGraphMap).forEach(function(id) {
+                    var compoundNode = idToNode[id];
+                    self.tiledMemberPack[id] = self.tileNodes(childGraphMap[id], compoundNode.paddingLeft + compoundNode.paddingRight);
+                    compoundNode.rect.width = self.tiledMemberPack[id].width;
+                    compoundNode.rect.height = self.tiledMemberPack[id].height;
+                    compoundNode.setCenter(self.tiledMemberPack[id].centerX, self.tiledMemberPack[id].centerY);
+                    compoundNode.labelMarginLeft = 0;
+                    compoundNode.labelMarginTop = 0;
+                    if (CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                      var width = compoundNode.rect.width;
+                      var height = compoundNode.rect.height;
+                      if (compoundNode.labelWidth) {
+                        if (compoundNode.labelPosHorizontal == "left") {
+                          compoundNode.rect.x -= compoundNode.labelWidth;
+                          compoundNode.setWidth(width + compoundNode.labelWidth);
+                          compoundNode.labelMarginLeft = compoundNode.labelWidth;
+                        } else if (compoundNode.labelPosHorizontal == "center" && compoundNode.labelWidth > width) {
+                          compoundNode.rect.x -= (compoundNode.labelWidth - width) / 2;
+                          compoundNode.setWidth(compoundNode.labelWidth);
+                          compoundNode.labelMarginLeft = (compoundNode.labelWidth - width) / 2;
+                        } else if (compoundNode.labelPosHorizontal == "right") {
+                          compoundNode.setWidth(width + compoundNode.labelWidth);
+                        }
+                      }
+                      if (compoundNode.labelHeight) {
+                        if (compoundNode.labelPosVertical == "top") {
+                          compoundNode.rect.y -= compoundNode.labelHeight;
+                          compoundNode.setHeight(height + compoundNode.labelHeight);
+                          compoundNode.labelMarginTop = compoundNode.labelHeight;
+                        } else if (compoundNode.labelPosVertical == "center" && compoundNode.labelHeight > height) {
+                          compoundNode.rect.y -= (compoundNode.labelHeight - height) / 2;
+                          compoundNode.setHeight(compoundNode.labelHeight);
+                          compoundNode.labelMarginTop = (compoundNode.labelHeight - height) / 2;
+                        } else if (compoundNode.labelPosVertical == "bottom") {
+                          compoundNode.setHeight(height + compoundNode.labelHeight);
+                        }
+                      }
+                    }
+                  });
+                };
+                CoSELayout.prototype.tileNodes = function(nodes, minWidth) {
+                  var horizontalOrg = this.tileNodesByFavoringDim(nodes, minWidth, true);
+                  var verticalOrg = this.tileNodesByFavoringDim(nodes, minWidth, false);
+                  var horizontalRatio = this.getOrgRatio(horizontalOrg);
+                  var verticalRatio = this.getOrgRatio(verticalOrg);
+                  var bestOrg;
+                  if (verticalRatio < horizontalRatio) {
+                    bestOrg = verticalOrg;
+                  } else {
+                    bestOrg = horizontalOrg;
+                  }
+                  return bestOrg;
+                };
+                CoSELayout.prototype.getOrgRatio = function(organization) {
+                  var width = organization.width;
+                  var height = organization.height;
+                  var ratio = width / height;
+                  if (ratio < 1) {
+                    ratio = 1 / ratio;
+                  }
+                  return ratio;
+                };
+                CoSELayout.prototype.calcIdealRowWidth = function(members, favorHorizontalDim) {
+                  var verticalPadding = CoSEConstants.TILING_PADDING_VERTICAL;
+                  var horizontalPadding = CoSEConstants.TILING_PADDING_HORIZONTAL;
+                  var membersSize = members.length;
+                  var totalWidth = 0;
+                  var totalHeight = 0;
+                  var maxWidth = 0;
+                  members.forEach(function(node) {
+                    totalWidth += node.getWidth();
+                    totalHeight += node.getHeight();
+                    if (node.getWidth() > maxWidth) {
+                      maxWidth = node.getWidth();
+                    }
+                  });
+                  var averageWidth = totalWidth / membersSize;
+                  var averageHeight = totalHeight / membersSize;
+                  var delta = Math.pow(verticalPadding - horizontalPadding, 2) + 4 * (averageWidth + horizontalPadding) * (averageHeight + verticalPadding) * membersSize;
+                  var horizontalCountDouble = (horizontalPadding - verticalPadding + Math.sqrt(delta)) / (2 * (averageWidth + horizontalPadding));
+                  var horizontalCount;
+                  if (favorHorizontalDim) {
+                    horizontalCount = Math.ceil(horizontalCountDouble);
+                    if (horizontalCount == horizontalCountDouble) {
+                      horizontalCount++;
+                    }
+                  } else {
+                    horizontalCount = Math.floor(horizontalCountDouble);
+                  }
+                  var idealWidth = horizontalCount * (averageWidth + horizontalPadding) - horizontalPadding;
+                  if (maxWidth > idealWidth) {
+                    idealWidth = maxWidth;
+                  }
+                  idealWidth += horizontalPadding * 2;
+                  return idealWidth;
+                };
+                CoSELayout.prototype.tileNodesByFavoringDim = function(nodes, minWidth, favorHorizontalDim) {
+                  var verticalPadding = CoSEConstants.TILING_PADDING_VERTICAL;
+                  var horizontalPadding = CoSEConstants.TILING_PADDING_HORIZONTAL;
+                  var tilingCompareBy = CoSEConstants.TILING_COMPARE_BY;
+                  var organization = {
+                    rows: [],
+                    rowWidth: [],
+                    rowHeight: [],
+                    width: 0,
+                    height: minWidth,
+                    // assume minHeight equals to minWidth
+                    verticalPadding,
+                    horizontalPadding,
+                    centerX: 0,
+                    centerY: 0
+                  };
+                  if (tilingCompareBy) {
+                    organization.idealRowWidth = this.calcIdealRowWidth(nodes, favorHorizontalDim);
+                  }
+                  var getNodeArea = function getNodeArea2(n) {
+                    return n.rect.width * n.rect.height;
+                  };
+                  var areaCompareFcn = function areaCompareFcn2(n1, n2) {
+                    return getNodeArea(n2) - getNodeArea(n1);
+                  };
+                  nodes.sort(function(n1, n2) {
+                    var cmpBy = areaCompareFcn;
+                    if (organization.idealRowWidth) {
+                      cmpBy = tilingCompareBy;
+                      return cmpBy(n1.id, n2.id);
+                    }
+                    return cmpBy(n1, n2);
+                  });
+                  var sumCenterX = 0;
+                  var sumCenterY = 0;
+                  for (var i = 0; i < nodes.length; i++) {
+                    var lNode = nodes[i];
+                    sumCenterX += lNode.getCenterX();
+                    sumCenterY += lNode.getCenterY();
+                  }
+                  organization.centerX = sumCenterX / nodes.length;
+                  organization.centerY = sumCenterY / nodes.length;
+                  for (var i = 0; i < nodes.length; i++) {
+                    var lNode = nodes[i];
+                    if (organization.rows.length == 0) {
+                      this.insertNodeToRow(organization, lNode, 0, minWidth);
+                    } else if (this.canAddHorizontal(organization, lNode.rect.width, lNode.rect.height)) {
+                      var rowIndex = organization.rows.length - 1;
+                      if (!organization.idealRowWidth) {
+                        rowIndex = this.getShortestRowIndex(organization);
+                      }
+                      this.insertNodeToRow(organization, lNode, rowIndex, minWidth);
+                    } else {
+                      this.insertNodeToRow(organization, lNode, organization.rows.length, minWidth);
+                    }
+                    this.shiftToLastRow(organization);
+                  }
+                  return organization;
+                };
+                CoSELayout.prototype.insertNodeToRow = function(organization, node, rowIndex, minWidth) {
+                  var minCompoundSize = minWidth;
+                  if (rowIndex == organization.rows.length) {
+                    var secondDimension = [];
+                    organization.rows.push(secondDimension);
+                    organization.rowWidth.push(minCompoundSize);
+                    organization.rowHeight.push(0);
+                  }
+                  var w = organization.rowWidth[rowIndex] + node.rect.width;
+                  if (organization.rows[rowIndex].length > 0) {
+                    w += organization.horizontalPadding;
+                  }
+                  organization.rowWidth[rowIndex] = w;
+                  if (organization.width < w) {
+                    organization.width = w;
+                  }
+                  var h = node.rect.height;
+                  if (rowIndex > 0) h += organization.verticalPadding;
+                  var extraHeight = 0;
+                  if (h > organization.rowHeight[rowIndex]) {
+                    extraHeight = organization.rowHeight[rowIndex];
+                    organization.rowHeight[rowIndex] = h;
+                    extraHeight = organization.rowHeight[rowIndex] - extraHeight;
+                  }
+                  organization.height += extraHeight;
+                  organization.rows[rowIndex].push(node);
+                };
+                CoSELayout.prototype.getShortestRowIndex = function(organization) {
+                  var r = -1;
+                  var min = Number.MAX_VALUE;
+                  for (var i = 0; i < organization.rows.length; i++) {
+                    if (organization.rowWidth[i] < min) {
+                      r = i;
+                      min = organization.rowWidth[i];
+                    }
+                  }
+                  return r;
+                };
+                CoSELayout.prototype.getLongestRowIndex = function(organization) {
+                  var r = -1;
+                  var max = Number.MIN_VALUE;
+                  for (var i = 0; i < organization.rows.length; i++) {
+                    if (organization.rowWidth[i] > max) {
+                      r = i;
+                      max = organization.rowWidth[i];
+                    }
+                  }
+                  return r;
+                };
+                CoSELayout.prototype.canAddHorizontal = function(organization, extraWidth, extraHeight) {
+                  if (organization.idealRowWidth) {
+                    var lastRowIndex = organization.rows.length - 1;
+                    var lastRowWidth = organization.rowWidth[lastRowIndex];
+                    return lastRowWidth + extraWidth + organization.horizontalPadding <= organization.idealRowWidth;
+                  }
+                  var sri = this.getShortestRowIndex(organization);
+                  if (sri < 0) {
+                    return true;
+                  }
+                  var min = organization.rowWidth[sri];
+                  if (min + organization.horizontalPadding + extraWidth <= organization.width) return true;
+                  var hDiff = 0;
+                  if (organization.rowHeight[sri] < extraHeight) {
+                    if (sri > 0) hDiff = extraHeight + organization.verticalPadding - organization.rowHeight[sri];
+                  }
+                  var add_to_row_ratio;
+                  if (organization.width - min >= extraWidth + organization.horizontalPadding) {
+                    add_to_row_ratio = (organization.height + hDiff) / (min + extraWidth + organization.horizontalPadding);
+                  } else {
+                    add_to_row_ratio = (organization.height + hDiff) / organization.width;
+                  }
+                  hDiff = extraHeight + organization.verticalPadding;
+                  var add_new_row_ratio;
+                  if (organization.width < extraWidth) {
+                    add_new_row_ratio = (organization.height + hDiff) / extraWidth;
+                  } else {
+                    add_new_row_ratio = (organization.height + hDiff) / organization.width;
+                  }
+                  if (add_new_row_ratio < 1) add_new_row_ratio = 1 / add_new_row_ratio;
+                  if (add_to_row_ratio < 1) add_to_row_ratio = 1 / add_to_row_ratio;
+                  return add_to_row_ratio < add_new_row_ratio;
+                };
+                CoSELayout.prototype.shiftToLastRow = function(organization) {
+                  var longest = this.getLongestRowIndex(organization);
+                  var last = organization.rowWidth.length - 1;
+                  var row = organization.rows[longest];
+                  var node = row[row.length - 1];
+                  var diff = node.width + organization.horizontalPadding;
+                  if (organization.width - organization.rowWidth[last] > diff && longest != last) {
+                    row.splice(-1, 1);
+                    organization.rows[last].push(node);
+                    organization.rowWidth[longest] = organization.rowWidth[longest] - diff;
+                    organization.rowWidth[last] = organization.rowWidth[last] + diff;
+                    organization.width = organization.rowWidth[instance.getLongestRowIndex(organization)];
+                    var maxHeight = Number.MIN_VALUE;
+                    for (var i = 0; i < row.length; i++) {
+                      if (row[i].height > maxHeight) maxHeight = row[i].height;
+                    }
+                    if (longest > 0) maxHeight += organization.verticalPadding;
+                    var prevTotal = organization.rowHeight[longest] + organization.rowHeight[last];
+                    organization.rowHeight[longest] = maxHeight;
+                    if (organization.rowHeight[last] < node.height + organization.verticalPadding) organization.rowHeight[last] = node.height + organization.verticalPadding;
+                    var finalTotal = organization.rowHeight[longest] + organization.rowHeight[last];
+                    organization.height += finalTotal - prevTotal;
+                    this.shiftToLastRow(organization);
+                  }
+                };
+                CoSELayout.prototype.tilingPreLayout = function() {
+                  if (CoSEConstants.TILE) {
+                    this.groupZeroDegreeMembers();
+                    this.clearCompounds();
+                    this.clearZeroDegreeMembers();
+                  }
+                };
+                CoSELayout.prototype.tilingPostLayout = function() {
+                  if (CoSEConstants.TILE) {
+                    this.repopulateZeroDegreeMembers();
+                    this.repopulateCompounds();
+                  }
+                };
+                CoSELayout.prototype.reduceTrees = function() {
+                  var prunedNodesAll = [];
+                  var containsLeaf = true;
+                  var node;
+                  while (containsLeaf) {
+                    var allNodes = this.graphManager.getAllNodes();
+                    var prunedNodesInStepTemp = [];
+                    containsLeaf = false;
+                    for (var i = 0; i < allNodes.length; i++) {
+                      node = allNodes[i];
+                      if (node.getEdges().length == 1 && !node.getEdges()[0].isInterGraph && node.getChild() == null) {
+                        if (CoSEConstants.PURE_INCREMENTAL) {
+                          var otherEnd = node.getEdges()[0].getOtherEnd(node);
+                          var relativePosition = new DimensionD(node.getCenterX() - otherEnd.getCenterX(), node.getCenterY() - otherEnd.getCenterY());
+                          prunedNodesInStepTemp.push([node, node.getEdges()[0], node.getOwner(), relativePosition]);
+                        } else {
+                          prunedNodesInStepTemp.push([node, node.getEdges()[0], node.getOwner()]);
+                        }
+                        containsLeaf = true;
+                      }
+                    }
+                    if (containsLeaf == true) {
+                      var prunedNodesInStep = [];
+                      for (var j = 0; j < prunedNodesInStepTemp.length; j++) {
+                        if (prunedNodesInStepTemp[j][0].getEdges().length == 1) {
+                          prunedNodesInStep.push(prunedNodesInStepTemp[j]);
+                          prunedNodesInStepTemp[j][0].getOwner().remove(prunedNodesInStepTemp[j][0]);
+                        }
+                      }
+                      prunedNodesAll.push(prunedNodesInStep);
+                      this.graphManager.resetAllNodes();
+                      this.graphManager.resetAllEdges();
+                    }
+                  }
+                  this.prunedNodesAll = prunedNodesAll;
+                };
+                CoSELayout.prototype.growTree = function(prunedNodesAll) {
+                  var lengthOfPrunedNodesInStep = prunedNodesAll.length;
+                  var prunedNodesInStep = prunedNodesAll[lengthOfPrunedNodesInStep - 1];
+                  var nodeData;
+                  for (var i = 0; i < prunedNodesInStep.length; i++) {
+                    nodeData = prunedNodesInStep[i];
+                    this.findPlaceforPrunedNode(nodeData);
+                    nodeData[2].add(nodeData[0]);
+                    nodeData[2].add(nodeData[1], nodeData[1].source, nodeData[1].target);
+                  }
+                  prunedNodesAll.splice(prunedNodesAll.length - 1, 1);
+                  this.graphManager.resetAllNodes();
+                  this.graphManager.resetAllEdges();
+                };
+                CoSELayout.prototype.findPlaceforPrunedNode = function(nodeData) {
+                  var gridForPrunedNode;
+                  var nodeToConnect;
+                  var prunedNode = nodeData[0];
+                  if (prunedNode == nodeData[1].source) {
+                    nodeToConnect = nodeData[1].target;
+                  } else {
+                    nodeToConnect = nodeData[1].source;
+                  }
+                  if (CoSEConstants.PURE_INCREMENTAL) {
+                    prunedNode.setCenter(nodeToConnect.getCenterX() + nodeData[3].getWidth(), nodeToConnect.getCenterY() + nodeData[3].getHeight());
+                  } else {
+                    var startGridX = nodeToConnect.startX;
+                    var finishGridX = nodeToConnect.finishX;
+                    var startGridY = nodeToConnect.startY;
+                    var finishGridY = nodeToConnect.finishY;
+                    var upNodeCount = 0;
+                    var downNodeCount = 0;
+                    var rightNodeCount = 0;
+                    var leftNodeCount = 0;
+                    var controlRegions = [upNodeCount, rightNodeCount, downNodeCount, leftNodeCount];
+                    if (startGridY > 0) {
+                      for (var i = startGridX; i <= finishGridX; i++) {
+                        controlRegions[0] += this.grid[i][startGridY - 1].length + this.grid[i][startGridY].length - 1;
+                      }
+                    }
+                    if (finishGridX < this.grid.length - 1) {
+                      for (var i = startGridY; i <= finishGridY; i++) {
+                        controlRegions[1] += this.grid[finishGridX + 1][i].length + this.grid[finishGridX][i].length - 1;
+                      }
+                    }
+                    if (finishGridY < this.grid[0].length - 1) {
+                      for (var i = startGridX; i <= finishGridX; i++) {
+                        controlRegions[2] += this.grid[i][finishGridY + 1].length + this.grid[i][finishGridY].length - 1;
+                      }
+                    }
+                    if (startGridX > 0) {
+                      for (var i = startGridY; i <= finishGridY; i++) {
+                        controlRegions[3] += this.grid[startGridX - 1][i].length + this.grid[startGridX][i].length - 1;
+                      }
+                    }
+                    var min = Integer.MAX_VALUE;
+                    var minCount;
+                    var minIndex;
+                    for (var j = 0; j < controlRegions.length; j++) {
+                      if (controlRegions[j] < min) {
+                        min = controlRegions[j];
+                        minCount = 1;
+                        minIndex = j;
+                      } else if (controlRegions[j] == min) {
+                        minCount++;
+                      }
+                    }
+                    if (minCount == 3 && min == 0) {
+                      if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[2] == 0) {
+                        gridForPrunedNode = 1;
+                      } else if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[3] == 0) {
+                        gridForPrunedNode = 0;
+                      } else if (controlRegions[0] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) {
+                        gridForPrunedNode = 3;
+                      } else if (controlRegions[1] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) {
+                        gridForPrunedNode = 2;
+                      }
+                    } else if (minCount == 2 && min == 0) {
+                      var random = Math.floor(Math.random() * 2);
+                      if (controlRegions[0] == 0 && controlRegions[1] == 0) {
+                        if (random == 0) {
+                          gridForPrunedNode = 0;
+                        } else {
+                          gridForPrunedNode = 1;
+                        }
+                      } else if (controlRegions[0] == 0 && controlRegions[2] == 0) {
+                        if (random == 0) {
+                          gridForPrunedNode = 0;
+                        } else {
+                          gridForPrunedNode = 2;
+                        }
+                      } else if (controlRegions[0] == 0 && controlRegions[3] == 0) {
+                        if (random == 0) {
+                          gridForPrunedNode = 0;
+                        } else {
+                          gridForPrunedNode = 3;
+                        }
+                      } else if (controlRegions[1] == 0 && controlRegions[2] == 0) {
+                        if (random == 0) {
+                          gridForPrunedNode = 1;
+                        } else {
+                          gridForPrunedNode = 2;
+                        }
+                      } else if (controlRegions[1] == 0 && controlRegions[3] == 0) {
+                        if (random == 0) {
+                          gridForPrunedNode = 1;
+                        } else {
+                          gridForPrunedNode = 3;
+                        }
+                      } else {
+                        if (random == 0) {
+                          gridForPrunedNode = 2;
+                        } else {
+                          gridForPrunedNode = 3;
+                        }
+                      }
+                    } else if (minCount == 4 && min == 0) {
+                      var random = Math.floor(Math.random() * 4);
+                      gridForPrunedNode = random;
+                    } else {
+                      gridForPrunedNode = minIndex;
+                    }
+                    if (gridForPrunedNode == 0) {
+                      prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() - nodeToConnect.getHeight() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getHeight() / 2);
+                    } else if (gridForPrunedNode == 1) {
+                      prunedNode.setCenter(nodeToConnect.getCenterX() + nodeToConnect.getWidth() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getWidth() / 2, nodeToConnect.getCenterY());
+                    } else if (gridForPrunedNode == 2) {
+                      prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() + nodeToConnect.getHeight() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getHeight() / 2);
+                    } else {
+                      prunedNode.setCenter(nodeToConnect.getCenterX() - nodeToConnect.getWidth() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getWidth() / 2, nodeToConnect.getCenterY());
+                    }
+                  }
+                };
+                module2.exports = CoSELayout;
+              }
+            ),
+            /***/
+            991: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                var FDLayoutNode = __webpack_require__2(551).FDLayoutNode;
+                var IMath = __webpack_require__2(551).IMath;
+                function CoSENode(gm, loc, size, vNode) {
+                  FDLayoutNode.call(this, gm, loc, size, vNode);
+                }
+                CoSENode.prototype = Object.create(FDLayoutNode.prototype);
+                for (var prop in FDLayoutNode) {
+                  CoSENode[prop] = FDLayoutNode[prop];
+                }
+                CoSENode.prototype.calculateDisplacement = function() {
+                  var layout = this.graphManager.getLayout();
+                  if (this.getChild() != null && this.fixedNodeWeight) {
+                    this.displacementX += layout.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.fixedNodeWeight;
+                    this.displacementY += layout.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.fixedNodeWeight;
+                  } else {
+                    this.displacementX += layout.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren;
+                    this.displacementY += layout.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren;
+                  }
+                  if (Math.abs(this.displacementX) > layout.coolingFactor * layout.maxNodeDisplacement) {
+                    this.displacementX = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementX);
+                  }
+                  if (Math.abs(this.displacementY) > layout.coolingFactor * layout.maxNodeDisplacement) {
+                    this.displacementY = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementY);
+                  }
+                  if (this.child && this.child.getNodes().length > 0) {
+                    this.propogateDisplacementToChildren(this.displacementX, this.displacementY);
+                  }
+                };
+                CoSENode.prototype.propogateDisplacementToChildren = function(dX, dY) {
+                  var nodes = this.getChild().getNodes();
+                  var node;
+                  for (var i = 0; i < nodes.length; i++) {
+                    node = nodes[i];
+                    if (node.getChild() == null) {
+                      node.displacementX += dX;
+                      node.displacementY += dY;
+                    } else {
+                      node.propogateDisplacementToChildren(dX, dY);
+                    }
+                  }
+                };
+                CoSENode.prototype.move = function() {
+                  var layout = this.graphManager.getLayout();
+                  if (this.child == null || this.child.getNodes().length == 0) {
+                    this.moveBy(this.displacementX, this.displacementY);
+                    layout.totalDisplacement += Math.abs(this.displacementX) + Math.abs(this.displacementY);
+                  }
+                  this.springForceX = 0;
+                  this.springForceY = 0;
+                  this.repulsionForceX = 0;
+                  this.repulsionForceY = 0;
+                  this.gravitationForceX = 0;
+                  this.gravitationForceY = 0;
+                  this.displacementX = 0;
+                  this.displacementY = 0;
+                };
+                CoSENode.prototype.setPred1 = function(pred12) {
+                  this.pred1 = pred12;
+                };
+                CoSENode.prototype.getPred1 = function() {
+                  return pred1;
+                };
+                CoSENode.prototype.getPred2 = function() {
+                  return pred2;
+                };
+                CoSENode.prototype.setNext = function(next2) {
+                  this.next = next2;
+                };
+                CoSENode.prototype.getNext = function() {
+                  return next;
+                };
+                CoSENode.prototype.setProcessed = function(processed2) {
+                  this.processed = processed2;
+                };
+                CoSENode.prototype.isProcessed = function() {
+                  return processed;
+                };
+                module2.exports = CoSENode;
+              }
+            ),
+            /***/
+            902: (
+              /***/
+              (module2, __unused_webpack_exports, __webpack_require__2) => {
+                function _toConsumableArray(arr) {
+                  if (Array.isArray(arr)) {
+                    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+                      arr2[i] = arr[i];
+                    }
+                    return arr2;
+                  } else {
+                    return Array.from(arr);
+                  }
+                }
+                var CoSEConstants = __webpack_require__2(806);
+                var LinkedList = __webpack_require__2(551).LinkedList;
+                var Matrix = __webpack_require__2(551).Matrix;
+                var SVD = __webpack_require__2(551).SVD;
+                function ConstraintHandler() {
+                }
+                ConstraintHandler.handleConstraints = function(layout) {
+                  var constraints = {};
+                  constraints.fixedNodeConstraint = layout.constraints.fixedNodeConstraint;
+                  constraints.alignmentConstraint = layout.constraints.alignmentConstraint;
+                  constraints.relativePlacementConstraint = layout.constraints.relativePlacementConstraint;
+                  var idToNodeMap = /* @__PURE__ */ new Map();
+                  var nodeIndexes = /* @__PURE__ */ new Map();
+                  var xCoords = [];
+                  var yCoords = [];
+                  var allNodes = layout.getAllNodes();
+                  var index = 0;
+                  for (var i = 0; i < allNodes.length; i++) {
+                    var node = allNodes[i];
+                    if (node.getChild() == null) {
+                      nodeIndexes.set(node.id, index++);
+                      xCoords.push(node.getCenterX());
+                      yCoords.push(node.getCenterY());
+                      idToNodeMap.set(node.id, node);
+                    }
+                  }
+                  if (constraints.relativePlacementConstraint) {
+                    constraints.relativePlacementConstraint.forEach(function(constraint) {
+                      if (!constraint.gap && constraint.gap != 0) {
+                        if (constraint.left) {
+                          constraint.gap = CoSEConstants.DEFAULT_EDGE_LENGTH + idToNodeMap.get(constraint.left).getWidth() / 2 + idToNodeMap.get(constraint.right).getWidth() / 2;
+                        } else {
+                          constraint.gap = CoSEConstants.DEFAULT_EDGE_LENGTH + idToNodeMap.get(constraint.top).getHeight() / 2 + idToNodeMap.get(constraint.bottom).getHeight() / 2;
+                        }
+                      }
+                    });
+                  }
+                  var calculatePositionDiff = function calculatePositionDiff2(pos1, pos2) {
+                    return { x: pos1.x - pos2.x, y: pos1.y - pos2.y };
+                  };
+                  var calculateAvgPosition = function calculateAvgPosition2(nodeIdSet) {
+                    var xPosSum = 0;
+                    var yPosSum = 0;
+                    nodeIdSet.forEach(function(nodeId) {
+                      xPosSum += xCoords[nodeIndexes.get(nodeId)];
+                      yPosSum += yCoords[nodeIndexes.get(nodeId)];
+                    });
+                    return { x: xPosSum / nodeIdSet.size, y: yPosSum / nodeIdSet.size };
+                  };
+                  var findAppropriatePositionForRelativePlacement = function findAppropriatePositionForRelativePlacement2(graph, direction, fixedNodes2, dummyPositions, componentSources) {
+                    function setUnion(setA, setB) {
+                      var union = new Set(setA);
+                      var _iteratorNormalCompletion = true;
+                      var _didIteratorError = false;
+                      var _iteratorError = void 0;
+                      try {
+                        for (var _iterator = setB[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                          var elem = _step.value;
+                          union.add(elem);
+                        }
+                      } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                      } finally {
+                        try {
+                          if (!_iteratorNormalCompletion && _iterator.return) {
+                            _iterator.return();
+                          }
+                        } finally {
+                          if (_didIteratorError) {
+                            throw _iteratorError;
+                          }
+                        }
+                      }
+                      return union;
+                    }
+                    var inDegrees = /* @__PURE__ */ new Map();
+                    graph.forEach(function(value, key) {
+                      inDegrees.set(key, 0);
+                    });
+                    graph.forEach(function(value, key) {
+                      value.forEach(function(adjacent) {
+                        inDegrees.set(adjacent.id, inDegrees.get(adjacent.id) + 1);
+                      });
+                    });
+                    var positionMap = /* @__PURE__ */ new Map();
+                    var pastMap = /* @__PURE__ */ new Map();
+                    var queue = new LinkedList();
+                    inDegrees.forEach(function(value, key) {
+                      if (value == 0) {
+                        queue.push(key);
+                        if (!fixedNodes2) {
+                          if (direction == "horizontal") {
+                            positionMap.set(key, nodeIndexes.has(key) ? xCoords[nodeIndexes.get(key)] : dummyPositions.get(key));
+                          } else {
+                            positionMap.set(key, nodeIndexes.has(key) ? yCoords[nodeIndexes.get(key)] : dummyPositions.get(key));
+                          }
+                        }
+                      } else {
+                        positionMap.set(key, Number.NEGATIVE_INFINITY);
+                      }
+                      if (fixedNodes2) {
+                        pastMap.set(key, /* @__PURE__ */ new Set([key]));
+                      }
+                    });
+                    if (fixedNodes2) {
+                      componentSources.forEach(function(component) {
+                        var fixedIds = [];
+                        component.forEach(function(nodeId) {
+                          if (fixedNodes2.has(nodeId)) {
+                            fixedIds.push(nodeId);
+                          }
+                        });
+                        if (fixedIds.length > 0) {
+                          var position = 0;
+                          fixedIds.forEach(function(fixedId) {
+                            if (direction == "horizontal") {
+                              positionMap.set(fixedId, nodeIndexes.has(fixedId) ? xCoords[nodeIndexes.get(fixedId)] : dummyPositions.get(fixedId));
+                              position += positionMap.get(fixedId);
+                            } else {
+                              positionMap.set(fixedId, nodeIndexes.has(fixedId) ? yCoords[nodeIndexes.get(fixedId)] : dummyPositions.get(fixedId));
+                              position += positionMap.get(fixedId);
+                            }
+                          });
+                          position = position / fixedIds.length;
+                          component.forEach(function(nodeId) {
+                            if (!fixedNodes2.has(nodeId)) {
+                              positionMap.set(nodeId, position);
+                            }
+                          });
+                        } else {
+                          var _position = 0;
+                          component.forEach(function(nodeId) {
+                            if (direction == "horizontal") {
+                              _position += nodeIndexes.has(nodeId) ? xCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId);
+                            } else {
+                              _position += nodeIndexes.has(nodeId) ? yCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId);
+                            }
+                          });
+                          _position = _position / component.length;
+                          component.forEach(function(nodeId) {
+                            positionMap.set(nodeId, _position);
+                          });
+                        }
+                      });
+                    }
+                    var _loop = function _loop2() {
+                      var currentNode = queue.shift();
+                      var neighbors = graph.get(currentNode);
+                      neighbors.forEach(function(neighbor) {
+                        if (positionMap.get(neighbor.id) < positionMap.get(currentNode) + neighbor.gap) {
+                          if (fixedNodes2 && fixedNodes2.has(neighbor.id)) {
+                            var fixedPosition = void 0;
+                            if (direction == "horizontal") {
+                              fixedPosition = nodeIndexes.has(neighbor.id) ? xCoords[nodeIndexes.get(neighbor.id)] : dummyPositions.get(neighbor.id);
+                            } else {
+                              fixedPosition = nodeIndexes.has(neighbor.id) ? yCoords[nodeIndexes.get(neighbor.id)] : dummyPositions.get(neighbor.id);
+                            }
+                            positionMap.set(neighbor.id, fixedPosition);
+                            if (fixedPosition < positionMap.get(currentNode) + neighbor.gap) {
+                              var diff = positionMap.get(currentNode) + neighbor.gap - fixedPosition;
+                              pastMap.get(currentNode).forEach(function(nodeId) {
+                                positionMap.set(nodeId, positionMap.get(nodeId) - diff);
+                              });
+                            }
+                          } else {
+                            positionMap.set(neighbor.id, positionMap.get(currentNode) + neighbor.gap);
+                          }
+                        }
+                        inDegrees.set(neighbor.id, inDegrees.get(neighbor.id) - 1);
+                        if (inDegrees.get(neighbor.id) == 0) {
+                          queue.push(neighbor.id);
+                        }
+                        if (fixedNodes2) {
+                          pastMap.set(neighbor.id, setUnion(pastMap.get(currentNode), pastMap.get(neighbor.id)));
+                        }
+                      });
+                    };
+                    while (queue.length != 0) {
+                      _loop();
+                    }
+                    if (fixedNodes2) {
+                      var sinkNodes = /* @__PURE__ */ new Set();
+                      graph.forEach(function(value, key) {
+                        if (value.length == 0) {
+                          sinkNodes.add(key);
+                        }
+                      });
+                      var _components = [];
+                      pastMap.forEach(function(value, key) {
+                        if (sinkNodes.has(key)) {
+                          var isFixedComponent = false;
+                          var _iteratorNormalCompletion2 = true;
+                          var _didIteratorError2 = false;
+                          var _iteratorError2 = void 0;
+                          try {
+                            for (var _iterator2 = value[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                              var nodeId = _step2.value;
+                              if (fixedNodes2.has(nodeId)) {
+                                isFixedComponent = true;
+                              }
+                            }
+                          } catch (err) {
+                            _didIteratorError2 = true;
+                            _iteratorError2 = err;
+                          } finally {
+                            try {
+                              if (!_iteratorNormalCompletion2 && _iterator2.return) {
+                                _iterator2.return();
+                              }
+                            } finally {
+                              if (_didIteratorError2) {
+                                throw _iteratorError2;
+                              }
+                            }
+                          }
+                          if (!isFixedComponent) {
+                            var isExist = false;
+                            var existAt = void 0;
+                            _components.forEach(function(component, index2) {
+                              if (component.has([].concat(_toConsumableArray(value))[0])) {
+                                isExist = true;
+                                existAt = index2;
+                              }
+                            });
+                            if (!isExist) {
+                              _components.push(new Set(value));
+                            } else {
+                              value.forEach(function(ele) {
+                                _components[existAt].add(ele);
+                              });
+                            }
+                          }
+                        }
+                      });
+                      _components.forEach(function(component, index2) {
+                        var minBefore = Number.POSITIVE_INFINITY;
+                        var minAfter = Number.POSITIVE_INFINITY;
+                        var maxBefore = Number.NEGATIVE_INFINITY;
+                        var maxAfter = Number.NEGATIVE_INFINITY;
+                        var _iteratorNormalCompletion3 = true;
+                        var _didIteratorError3 = false;
+                        var _iteratorError3 = void 0;
+                        try {
+                          for (var _iterator3 = component[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                            var nodeId = _step3.value;
+                            var posBefore = void 0;
+                            if (direction == "horizontal") {
+                              posBefore = nodeIndexes.has(nodeId) ? xCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId);
+                            } else {
+                              posBefore = nodeIndexes.has(nodeId) ? yCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId);
+                            }
+                            var posAfter = positionMap.get(nodeId);
+                            if (posBefore < minBefore) {
+                              minBefore = posBefore;
+                            }
+                            if (posBefore > maxBefore) {
+                              maxBefore = posBefore;
+                            }
+                            if (posAfter < minAfter) {
+                              minAfter = posAfter;
+                            }
+                            if (posAfter > maxAfter) {
+                              maxAfter = posAfter;
+                            }
+                          }
+                        } catch (err) {
+                          _didIteratorError3 = true;
+                          _iteratorError3 = err;
+                        } finally {
+                          try {
+                            if (!_iteratorNormalCompletion3 && _iterator3.return) {
+                              _iterator3.return();
+                            }
+                          } finally {
+                            if (_didIteratorError3) {
+                              throw _iteratorError3;
+                            }
+                          }
+                        }
+                        var diff = (minBefore + maxBefore) / 2 - (minAfter + maxAfter) / 2;
+                        var _iteratorNormalCompletion4 = true;
+                        var _didIteratorError4 = false;
+                        var _iteratorError4 = void 0;
+                        try {
+                          for (var _iterator4 = component[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+                            var _nodeId = _step4.value;
+                            positionMap.set(_nodeId, positionMap.get(_nodeId) + diff);
+                          }
+                        } catch (err) {
+                          _didIteratorError4 = true;
+                          _iteratorError4 = err;
+                        } finally {
+                          try {
+                            if (!_iteratorNormalCompletion4 && _iterator4.return) {
+                              _iterator4.return();
+                            }
+                          } finally {
+                            if (_didIteratorError4) {
+                              throw _iteratorError4;
+                            }
+                          }
+                        }
+                      });
+                    }
+                    return positionMap;
+                  };
+                  var applyReflectionForRelativePlacement = function applyReflectionForRelativePlacement2(relativePlacementConstraints) {
+                    var reflectOnY = 0, notReflectOnY = 0;
+                    var reflectOnX = 0, notReflectOnX = 0;
+                    relativePlacementConstraints.forEach(function(constraint) {
+                      if (constraint.left) {
+                        xCoords[nodeIndexes.get(constraint.left)] - xCoords[nodeIndexes.get(constraint.right)] >= 0 ? reflectOnY++ : notReflectOnY++;
+                      } else {
+                        yCoords[nodeIndexes.get(constraint.top)] - yCoords[nodeIndexes.get(constraint.bottom)] >= 0 ? reflectOnX++ : notReflectOnX++;
+                      }
+                    });
+                    if (reflectOnY > notReflectOnY && reflectOnX > notReflectOnX) {
+                      for (var _i = 0; _i < nodeIndexes.size; _i++) {
+                        xCoords[_i] = -1 * xCoords[_i];
+                        yCoords[_i] = -1 * yCoords[_i];
+                      }
+                    } else if (reflectOnY > notReflectOnY) {
+                      for (var _i2 = 0; _i2 < nodeIndexes.size; _i2++) {
+                        xCoords[_i2] = -1 * xCoords[_i2];
+                      }
+                    } else if (reflectOnX > notReflectOnX) {
+                      for (var _i3 = 0; _i3 < nodeIndexes.size; _i3++) {
+                        yCoords[_i3] = -1 * yCoords[_i3];
+                      }
+                    }
+                  };
+                  var findComponents = function findComponents2(graph) {
+                    var components2 = [];
+                    var queue = new LinkedList();
+                    var visited = /* @__PURE__ */ new Set();
+                    var count = 0;
+                    graph.forEach(function(value, key) {
+                      if (!visited.has(key)) {
+                        components2[count] = [];
+                        var _currentNode = key;
+                        queue.push(_currentNode);
+                        visited.add(_currentNode);
+                        components2[count].push(_currentNode);
+                        while (queue.length != 0) {
+                          _currentNode = queue.shift();
+                          var neighbors = graph.get(_currentNode);
+                          neighbors.forEach(function(neighbor) {
+                            if (!visited.has(neighbor.id)) {
+                              queue.push(neighbor.id);
+                              visited.add(neighbor.id);
+                              components2[count].push(neighbor.id);
+                            }
+                          });
+                        }
+                        count++;
+                      }
+                    });
+                    return components2;
+                  };
+                  var dagToUndirected = function dagToUndirected2(dag2) {
+                    var undirected = /* @__PURE__ */ new Map();
+                    dag2.forEach(function(value, key) {
+                      undirected.set(key, []);
+                    });
+                    dag2.forEach(function(value, key) {
+                      value.forEach(function(adjacent) {
+                        undirected.get(key).push(adjacent);
+                        undirected.get(adjacent.id).push({ id: key, gap: adjacent.gap, direction: adjacent.direction });
+                      });
+                    });
+                    return undirected;
+                  };
+                  var dagToReversed = function dagToReversed2(dag2) {
+                    var reversed = /* @__PURE__ */ new Map();
+                    dag2.forEach(function(value, key) {
+                      reversed.set(key, []);
+                    });
+                    dag2.forEach(function(value, key) {
+                      value.forEach(function(adjacent) {
+                        reversed.get(adjacent.id).push({ id: key, gap: adjacent.gap, direction: adjacent.direction });
+                      });
+                    });
+                    return reversed;
+                  };
+                  var targetMatrix = [];
+                  var sourceMatrix = [];
+                  var standardTransformation = false;
+                  var reflectionType = false;
+                  var fixedNodes = /* @__PURE__ */ new Set();
+                  var dag = /* @__PURE__ */ new Map();
+                  var dagUndirected = /* @__PURE__ */ new Map();
+                  var components = [];
+                  if (constraints.fixedNodeConstraint) {
+                    constraints.fixedNodeConstraint.forEach(function(nodeData) {
+                      fixedNodes.add(nodeData.nodeId);
+                    });
+                  }
+                  if (constraints.relativePlacementConstraint) {
+                    constraints.relativePlacementConstraint.forEach(function(constraint) {
+                      if (constraint.left) {
+                        if (dag.has(constraint.left)) {
+                          dag.get(constraint.left).push({ id: constraint.right, gap: constraint.gap, direction: "horizontal" });
+                        } else {
+                          dag.set(constraint.left, [{ id: constraint.right, gap: constraint.gap, direction: "horizontal" }]);
+                        }
+                        if (!dag.has(constraint.right)) {
+                          dag.set(constraint.right, []);
+                        }
+                      } else {
+                        if (dag.has(constraint.top)) {
+                          dag.get(constraint.top).push({ id: constraint.bottom, gap: constraint.gap, direction: "vertical" });
+                        } else {
+                          dag.set(constraint.top, [{ id: constraint.bottom, gap: constraint.gap, direction: "vertical" }]);
+                        }
+                        if (!dag.has(constraint.bottom)) {
+                          dag.set(constraint.bottom, []);
+                        }
+                      }
+                    });
+                    dagUndirected = dagToUndirected(dag);
+                    components = findComponents(dagUndirected);
+                  }
+                  if (CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING) {
+                    if (constraints.fixedNodeConstraint && constraints.fixedNodeConstraint.length > 1) {
+                      constraints.fixedNodeConstraint.forEach(function(nodeData, i2) {
+                        targetMatrix[i2] = [nodeData.position.x, nodeData.position.y];
+                        sourceMatrix[i2] = [xCoords[nodeIndexes.get(nodeData.nodeId)], yCoords[nodeIndexes.get(nodeData.nodeId)]];
+                      });
+                      standardTransformation = true;
+                    } else if (constraints.alignmentConstraint) {
+                      (function() {
+                        var count = 0;
+                        if (constraints.alignmentConstraint.vertical) {
+                          var verticalAlign = constraints.alignmentConstraint.vertical;
+                          var _loop2 = function _loop22(_i42) {
+                            var alignmentSet = /* @__PURE__ */ new Set();
+                            verticalAlign[_i42].forEach(function(nodeId) {
+                              alignmentSet.add(nodeId);
+                            });
+                            var intersection = new Set([].concat(_toConsumableArray(alignmentSet)).filter(function(x) {
+                              return fixedNodes.has(x);
+                            }));
+                            var xPos = void 0;
+                            if (intersection.size > 0) xPos = xCoords[nodeIndexes.get(intersection.values().next().value)];
+                            else xPos = calculateAvgPosition(alignmentSet).x;
+                            verticalAlign[_i42].forEach(function(nodeId) {
+                              targetMatrix[count] = [xPos, yCoords[nodeIndexes.get(nodeId)]];
+                              sourceMatrix[count] = [xCoords[nodeIndexes.get(nodeId)], yCoords[nodeIndexes.get(nodeId)]];
+                              count++;
+                            });
+                          };
+                          for (var _i4 = 0; _i4 < verticalAlign.length; _i4++) {
+                            _loop2(_i4);
+                          }
+                          standardTransformation = true;
+                        }
+                        if (constraints.alignmentConstraint.horizontal) {
+                          var horizontalAlign = constraints.alignmentConstraint.horizontal;
+                          var _loop3 = function _loop32(_i52) {
+                            var alignmentSet = /* @__PURE__ */ new Set();
+                            horizontalAlign[_i52].forEach(function(nodeId) {
+                              alignmentSet.add(nodeId);
+                            });
+                            var intersection = new Set([].concat(_toConsumableArray(alignmentSet)).filter(function(x) {
+                              return fixedNodes.has(x);
+                            }));
+                            var yPos = void 0;
+                            if (intersection.size > 0) yPos = xCoords[nodeIndexes.get(intersection.values().next().value)];
+                            else yPos = calculateAvgPosition(alignmentSet).y;
+                            horizontalAlign[_i52].forEach(function(nodeId) {
+                              targetMatrix[count] = [xCoords[nodeIndexes.get(nodeId)], yPos];
+                              sourceMatrix[count] = [xCoords[nodeIndexes.get(nodeId)], yCoords[nodeIndexes.get(nodeId)]];
+                              count++;
+                            });
+                          };
+                          for (var _i5 = 0; _i5 < horizontalAlign.length; _i5++) {
+                            _loop3(_i5);
+                          }
+                          standardTransformation = true;
+                        }
+                        if (constraints.relativePlacementConstraint) {
+                          reflectionType = true;
+                        }
+                      })();
+                    } else if (constraints.relativePlacementConstraint) {
+                      var largestComponentSize = 0;
+                      var largestComponentIndex = 0;
+                      for (var _i6 = 0; _i6 < components.length; _i6++) {
+                        if (components[_i6].length > largestComponentSize) {
+                          largestComponentSize = components[_i6].length;
+                          largestComponentIndex = _i6;
+                        }
+                      }
+                      if (largestComponentSize < dagUndirected.size / 2) {
+                        applyReflectionForRelativePlacement(constraints.relativePlacementConstraint);
+                        standardTransformation = false;
+                        reflectionType = false;
+                      } else {
+                        var subGraphOnHorizontal = /* @__PURE__ */ new Map();
+                        var subGraphOnVertical = /* @__PURE__ */ new Map();
+                        var constraintsInlargestComponent = [];
+                        components[largestComponentIndex].forEach(function(nodeId) {
+                          dag.get(nodeId).forEach(function(adjacent) {
+                            if (adjacent.direction == "horizontal") {
+                              if (subGraphOnHorizontal.has(nodeId)) {
+                                subGraphOnHorizontal.get(nodeId).push(adjacent);
+                              } else {
+                                subGraphOnHorizontal.set(nodeId, [adjacent]);
+                              }
+                              if (!subGraphOnHorizontal.has(adjacent.id)) {
+                                subGraphOnHorizontal.set(adjacent.id, []);
+                              }
+                              constraintsInlargestComponent.push({ left: nodeId, right: adjacent.id });
+                            } else {
+                              if (subGraphOnVertical.has(nodeId)) {
+                                subGraphOnVertical.get(nodeId).push(adjacent);
+                              } else {
+                                subGraphOnVertical.set(nodeId, [adjacent]);
+                              }
+                              if (!subGraphOnVertical.has(adjacent.id)) {
+                                subGraphOnVertical.set(adjacent.id, []);
+                              }
+                              constraintsInlargestComponent.push({ top: nodeId, bottom: adjacent.id });
+                            }
+                          });
+                        });
+                        applyReflectionForRelativePlacement(constraintsInlargestComponent);
+                        reflectionType = false;
+                        var positionMapHorizontal = findAppropriatePositionForRelativePlacement(subGraphOnHorizontal, "horizontal");
+                        var positionMapVertical = findAppropriatePositionForRelativePlacement(subGraphOnVertical, "vertical");
+                        components[largestComponentIndex].forEach(function(nodeId, i2) {
+                          sourceMatrix[i2] = [xCoords[nodeIndexes.get(nodeId)], yCoords[nodeIndexes.get(nodeId)]];
+                          targetMatrix[i2] = [];
+                          if (positionMapHorizontal.has(nodeId)) {
+                            targetMatrix[i2][0] = positionMapHorizontal.get(nodeId);
+                          } else {
+                            targetMatrix[i2][0] = xCoords[nodeIndexes.get(nodeId)];
+                          }
+                          if (positionMapVertical.has(nodeId)) {
+                            targetMatrix[i2][1] = positionMapVertical.get(nodeId);
+                          } else {
+                            targetMatrix[i2][1] = yCoords[nodeIndexes.get(nodeId)];
+                          }
+                        });
+                        standardTransformation = true;
+                      }
+                    }
+                    if (standardTransformation) {
+                      var transformationMatrix = void 0;
+                      var targetMatrixTranspose = Matrix.transpose(targetMatrix);
+                      var sourceMatrixTranspose = Matrix.transpose(sourceMatrix);
+                      for (var _i7 = 0; _i7 < targetMatrixTranspose.length; _i7++) {
+                        targetMatrixTranspose[_i7] = Matrix.multGamma(targetMatrixTranspose[_i7]);
+                        sourceMatrixTranspose[_i7] = Matrix.multGamma(sourceMatrixTranspose[_i7]);
+                      }
+                      var tempMatrix = Matrix.multMat(targetMatrixTranspose, Matrix.transpose(sourceMatrixTranspose));
+                      var SVDResult = SVD.svd(tempMatrix);
+                      transformationMatrix = Matrix.multMat(SVDResult.V, Matrix.transpose(SVDResult.U));
+                      for (var _i8 = 0; _i8 < nodeIndexes.size; _i8++) {
+                        var temp1 = [xCoords[_i8], yCoords[_i8]];
+                        var temp2 = [transformationMatrix[0][0], transformationMatrix[1][0]];
+                        var temp3 = [transformationMatrix[0][1], transformationMatrix[1][1]];
+                        xCoords[_i8] = Matrix.dotProduct(temp1, temp2);
+                        yCoords[_i8] = Matrix.dotProduct(temp1, temp3);
+                      }
+                      if (reflectionType) {
+                        applyReflectionForRelativePlacement(constraints.relativePlacementConstraint);
+                      }
+                    }
+                  }
+                  if (CoSEConstants.ENFORCE_CONSTRAINTS) {
+                    if (constraints.fixedNodeConstraint && constraints.fixedNodeConstraint.length > 0) {
+                      var translationAmount = { x: 0, y: 0 };
+                      constraints.fixedNodeConstraint.forEach(function(nodeData, i2) {
+                        var posInTheory = { x: xCoords[nodeIndexes.get(nodeData.nodeId)], y: yCoords[nodeIndexes.get(nodeData.nodeId)] };
+                        var posDesired = nodeData.position;
+                        var posDiff = calculatePositionDiff(posDesired, posInTheory);
+                        translationAmount.x += posDiff.x;
+                        translationAmount.y += posDiff.y;
+                      });
+                      translationAmount.x /= constraints.fixedNodeConstraint.length;
+                      translationAmount.y /= constraints.fixedNodeConstraint.length;
+                      xCoords.forEach(function(value, i2) {
+                        xCoords[i2] += translationAmount.x;
+                      });
+                      yCoords.forEach(function(value, i2) {
+                        yCoords[i2] += translationAmount.y;
+                      });
+                      constraints.fixedNodeConstraint.forEach(function(nodeData) {
+                        xCoords[nodeIndexes.get(nodeData.nodeId)] = nodeData.position.x;
+                        yCoords[nodeIndexes.get(nodeData.nodeId)] = nodeData.position.y;
+                      });
+                    }
+                    if (constraints.alignmentConstraint) {
+                      if (constraints.alignmentConstraint.vertical) {
+                        var xAlign = constraints.alignmentConstraint.vertical;
+                        var _loop4 = function _loop42(_i92) {
+                          var alignmentSet = /* @__PURE__ */ new Set();
+                          xAlign[_i92].forEach(function(nodeId) {
+                            alignmentSet.add(nodeId);
+                          });
+                          var intersection = new Set([].concat(_toConsumableArray(alignmentSet)).filter(function(x) {
+                            return fixedNodes.has(x);
+                          }));
+                          var xPos = void 0;
+                          if (intersection.size > 0) xPos = xCoords[nodeIndexes.get(intersection.values().next().value)];
+                          else xPos = calculateAvgPosition(alignmentSet).x;
+                          alignmentSet.forEach(function(nodeId) {
+                            if (!fixedNodes.has(nodeId)) xCoords[nodeIndexes.get(nodeId)] = xPos;
+                          });
+                        };
+                        for (var _i9 = 0; _i9 < xAlign.length; _i9++) {
+                          _loop4(_i9);
+                        }
+                      }
+                      if (constraints.alignmentConstraint.horizontal) {
+                        var yAlign = constraints.alignmentConstraint.horizontal;
+                        var _loop5 = function _loop52(_i102) {
+                          var alignmentSet = /* @__PURE__ */ new Set();
+                          yAlign[_i102].forEach(function(nodeId) {
+                            alignmentSet.add(nodeId);
+                          });
+                          var intersection = new Set([].concat(_toConsumableArray(alignmentSet)).filter(function(x) {
+                            return fixedNodes.has(x);
+                          }));
+                          var yPos = void 0;
+                          if (intersection.size > 0) yPos = yCoords[nodeIndexes.get(intersection.values().next().value)];
+                          else yPos = calculateAvgPosition(alignmentSet).y;
+                          alignmentSet.forEach(function(nodeId) {
+                            if (!fixedNodes.has(nodeId)) yCoords[nodeIndexes.get(nodeId)] = yPos;
+                          });
+                        };
+                        for (var _i10 = 0; _i10 < yAlign.length; _i10++) {
+                          _loop5(_i10);
+                        }
+                      }
+                    }
+                    if (constraints.relativePlacementConstraint) {
+                      (function() {
+                        var nodeToDummyForVerticalAlignment = /* @__PURE__ */ new Map();
+                        var nodeToDummyForHorizontalAlignment = /* @__PURE__ */ new Map();
+                        var dummyToNodeForVerticalAlignment = /* @__PURE__ */ new Map();
+                        var dummyToNodeForHorizontalAlignment = /* @__PURE__ */ new Map();
+                        var dummyPositionsForVerticalAlignment = /* @__PURE__ */ new Map();
+                        var dummyPositionsForHorizontalAlignment = /* @__PURE__ */ new Map();
+                        var fixedNodesOnHorizontal = /* @__PURE__ */ new Set();
+                        var fixedNodesOnVertical = /* @__PURE__ */ new Set();
+                        fixedNodes.forEach(function(nodeId2) {
+                          fixedNodesOnHorizontal.add(nodeId2);
+                          fixedNodesOnVertical.add(nodeId2);
+                        });
+                        if (constraints.alignmentConstraint) {
+                          if (constraints.alignmentConstraint.vertical) {
+                            var verticalAlignment = constraints.alignmentConstraint.vertical;
+                            var _loop6 = function _loop62(_i112) {
+                              dummyToNodeForVerticalAlignment.set("dummy" + _i112, []);
+                              verticalAlignment[_i112].forEach(function(nodeId2) {
+                                nodeToDummyForVerticalAlignment.set(nodeId2, "dummy" + _i112);
+                                dummyToNodeForVerticalAlignment.get("dummy" + _i112).push(nodeId2);
+                                if (fixedNodes.has(nodeId2)) {
+                                  fixedNodesOnHorizontal.add("dummy" + _i112);
+                                }
+                              });
+                              dummyPositionsForVerticalAlignment.set("dummy" + _i112, xCoords[nodeIndexes.get(verticalAlignment[_i112][0])]);
+                            };
+                            for (var _i11 = 0; _i11 < verticalAlignment.length; _i11++) {
+                              _loop6(_i11);
+                            }
+                          }
+                          if (constraints.alignmentConstraint.horizontal) {
+                            var horizontalAlignment = constraints.alignmentConstraint.horizontal;
+                            var _loop7 = function _loop72(_i122) {
+                              dummyToNodeForHorizontalAlignment.set("dummy" + _i122, []);
+                              horizontalAlignment[_i122].forEach(function(nodeId2) {
+                                nodeToDummyForHorizontalAlignment.set(nodeId2, "dummy" + _i122);
+                                dummyToNodeForHorizontalAlignment.get("dummy" + _i122).push(nodeId2);
+                                if (fixedNodes.has(nodeId2)) {
+                                  fixedNodesOnVertical.add("dummy" + _i122);
+                                }
+                              });
+                              dummyPositionsForHorizontalAlignment.set("dummy" + _i122, yCoords[nodeIndexes.get(horizontalAlignment[_i122][0])]);
+                            };
+                            for (var _i12 = 0; _i12 < horizontalAlignment.length; _i12++) {
+                              _loop7(_i12);
+                            }
+                          }
+                        }
+                        var dagOnHorizontal = /* @__PURE__ */ new Map();
+                        var dagOnVertical = /* @__PURE__ */ new Map();
+                        var _loop8 = function _loop82(nodeId2) {
+                          dag.get(nodeId2).forEach(function(adjacent) {
+                            var sourceId = void 0;
+                            var targetNode = void 0;
+                            if (adjacent["direction"] == "horizontal") {
+                              sourceId = nodeToDummyForVerticalAlignment.get(nodeId2) ? nodeToDummyForVerticalAlignment.get(nodeId2) : nodeId2;
+                              if (nodeToDummyForVerticalAlignment.get(adjacent.id)) {
+                                targetNode = { id: nodeToDummyForVerticalAlignment.get(adjacent.id), gap: adjacent.gap, direction: adjacent.direction };
+                              } else {
+                                targetNode = adjacent;
+                              }
+                              if (dagOnHorizontal.has(sourceId)) {
+                                dagOnHorizontal.get(sourceId).push(targetNode);
+                              } else {
+                                dagOnHorizontal.set(sourceId, [targetNode]);
+                              }
+                              if (!dagOnHorizontal.has(targetNode.id)) {
+                                dagOnHorizontal.set(targetNode.id, []);
+                              }
+                            } else {
+                              sourceId = nodeToDummyForHorizontalAlignment.get(nodeId2) ? nodeToDummyForHorizontalAlignment.get(nodeId2) : nodeId2;
+                              if (nodeToDummyForHorizontalAlignment.get(adjacent.id)) {
+                                targetNode = { id: nodeToDummyForHorizontalAlignment.get(adjacent.id), gap: adjacent.gap, direction: adjacent.direction };
+                              } else {
+                                targetNode = adjacent;
+                              }
+                              if (dagOnVertical.has(sourceId)) {
+                                dagOnVertical.get(sourceId).push(targetNode);
+                              } else {
+                                dagOnVertical.set(sourceId, [targetNode]);
+                              }
+                              if (!dagOnVertical.has(targetNode.id)) {
+                                dagOnVertical.set(targetNode.id, []);
+                              }
+                            }
+                          });
+                        };
+                        var _iteratorNormalCompletion5 = true;
+                        var _didIteratorError5 = false;
+                        var _iteratorError5 = void 0;
+                        try {
+                          for (var _iterator5 = dag.keys()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+                            var nodeId = _step5.value;
+                            _loop8(nodeId);
+                          }
+                        } catch (err) {
+                          _didIteratorError5 = true;
+                          _iteratorError5 = err;
+                        } finally {
+                          try {
+                            if (!_iteratorNormalCompletion5 && _iterator5.return) {
+                              _iterator5.return();
+                            }
+                          } finally {
+                            if (_didIteratorError5) {
+                              throw _iteratorError5;
+                            }
+                          }
+                        }
+                        var undirectedOnHorizontal = dagToUndirected(dagOnHorizontal);
+                        var undirectedOnVertical = dagToUndirected(dagOnVertical);
+                        var componentsOnHorizontal = findComponents(undirectedOnHorizontal);
+                        var componentsOnVertical = findComponents(undirectedOnVertical);
+                        var reversedDagOnHorizontal = dagToReversed(dagOnHorizontal);
+                        var reversedDagOnVertical = dagToReversed(dagOnVertical);
+                        var componentSourcesOnHorizontal = [];
+                        var componentSourcesOnVertical = [];
+                        componentsOnHorizontal.forEach(function(component, index2) {
+                          componentSourcesOnHorizontal[index2] = [];
+                          component.forEach(function(nodeId2) {
+                            if (reversedDagOnHorizontal.get(nodeId2).length == 0) {
+                              componentSourcesOnHorizontal[index2].push(nodeId2);
+                            }
+                          });
+                        });
+                        componentsOnVertical.forEach(function(component, index2) {
+                          componentSourcesOnVertical[index2] = [];
+                          component.forEach(function(nodeId2) {
+                            if (reversedDagOnVertical.get(nodeId2).length == 0) {
+                              componentSourcesOnVertical[index2].push(nodeId2);
+                            }
+                          });
+                        });
+                        var positionMapHorizontal2 = findAppropriatePositionForRelativePlacement(dagOnHorizontal, "horizontal", fixedNodesOnHorizontal, dummyPositionsForVerticalAlignment, componentSourcesOnHorizontal);
+                        var positionMapVertical2 = findAppropriatePositionForRelativePlacement(dagOnVertical, "vertical", fixedNodesOnVertical, dummyPositionsForHorizontalAlignment, componentSourcesOnVertical);
+                        var _loop9 = function _loop92(key2) {
+                          if (dummyToNodeForVerticalAlignment.get(key2)) {
+                            dummyToNodeForVerticalAlignment.get(key2).forEach(function(nodeId2) {
+                              xCoords[nodeIndexes.get(nodeId2)] = positionMapHorizontal2.get(key2);
+                            });
+                          } else {
+                            xCoords[nodeIndexes.get(key2)] = positionMapHorizontal2.get(key2);
+                          }
+                        };
+                        var _iteratorNormalCompletion6 = true;
+                        var _didIteratorError6 = false;
+                        var _iteratorError6 = void 0;
+                        try {
+                          for (var _iterator6 = positionMapHorizontal2.keys()[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+                            var key = _step6.value;
+                            _loop9(key);
+                          }
+                        } catch (err) {
+                          _didIteratorError6 = true;
+                          _iteratorError6 = err;
+                        } finally {
+                          try {
+                            if (!_iteratorNormalCompletion6 && _iterator6.return) {
+                              _iterator6.return();
+                            }
+                          } finally {
+                            if (_didIteratorError6) {
+                              throw _iteratorError6;
+                            }
+                          }
+                        }
+                        var _loop10 = function _loop102(key2) {
+                          if (dummyToNodeForHorizontalAlignment.get(key2)) {
+                            dummyToNodeForHorizontalAlignment.get(key2).forEach(function(nodeId2) {
+                              yCoords[nodeIndexes.get(nodeId2)] = positionMapVertical2.get(key2);
+                            });
+                          } else {
+                            yCoords[nodeIndexes.get(key2)] = positionMapVertical2.get(key2);
+                          }
+                        };
+                        var _iteratorNormalCompletion7 = true;
+                        var _didIteratorError7 = false;
+                        var _iteratorError7 = void 0;
+                        try {
+                          for (var _iterator7 = positionMapVertical2.keys()[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+                            var key = _step7.value;
+                            _loop10(key);
+                          }
+                        } catch (err) {
+                          _didIteratorError7 = true;
+                          _iteratorError7 = err;
+                        } finally {
+                          try {
+                            if (!_iteratorNormalCompletion7 && _iterator7.return) {
+                              _iterator7.return();
+                            }
+                          } finally {
+                            if (_didIteratorError7) {
+                              throw _iteratorError7;
+                            }
+                          }
+                        }
+                      })();
+                    }
+                  }
+                  for (var _i13 = 0; _i13 < allNodes.length; _i13++) {
+                    var _node = allNodes[_i13];
+                    if (_node.getChild() == null) {
+                      _node.setCenter(xCoords[nodeIndexes.get(_node.id)], yCoords[nodeIndexes.get(_node.id)]);
+                    }
+                  }
+                };
+                module2.exports = ConstraintHandler;
+              }
+            ),
+            /***/
+            551: (
+              /***/
+              (module2) => {
+                module2.exports = __WEBPACK_EXTERNAL_MODULE__551__;
+              }
+            )
+            /******/
+          };
+          var __webpack_module_cache__ = {};
+          function __webpack_require__(moduleId) {
+            var cachedModule = __webpack_module_cache__[moduleId];
+            if (cachedModule !== void 0) {
+              return cachedModule.exports;
+            }
+            var module2 = __webpack_module_cache__[moduleId] = {
+              /******/
+              // no module.id needed
+              /******/
+              // no module.loaded needed
+              /******/
+              exports: {}
+              /******/
+            };
+            __webpack_modules__[moduleId](module2, module2.exports, __webpack_require__);
+            return module2.exports;
+          }
+          var __webpack_exports__ = __webpack_require__(45);
+          return __webpack_exports__;
+        })()
+      );
+    });
+  })(coseBase$1);
+  return coseBase$1.exports;
+}
+export {
+  requireCoseBase as __require
+};