qidian-vue-ui 1.1.55 → 1.1.57

package/dist/node_modules/.pnpm/cose-base@2.2.0/node_modules/cose-base/cose-base.mjs

@@ -1,2556 +0,0 @@
-import { __module as coseBase$1 } from "../../../../../_virtual/cose-base.mjs";
-import { __require as requireLayoutBase } from "../../../layout-base@2.0.1/node_modules/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
-};
-//# sourceMappingURL=cose-base.mjs.map