qidian-vue-ui 1.1.55 → 1.1.57

package/dist/node_modules/.pnpm/cytoscape-fcose@2.2.0_cytoscape@3.33.1/node_modules/cytoscape-fcose/cytoscape-fcose.mjs

@@ -1,1279 +0,0 @@
-import { __module as cytoscapeFcose$1 } from "../../../../../_virtual/cytoscape-fcose2.mjs";
-import { __require as requireCoseBase } from "../../../cose-base@2.2.0/node_modules/cose-base/cose-base.mjs";
-var cytoscapeFcose = cytoscapeFcose$1.exports;
-var hasRequiredCytoscapeFcose;
-function requireCytoscapeFcose() {
-  if (hasRequiredCytoscapeFcose) return cytoscapeFcose$1.exports;
-  hasRequiredCytoscapeFcose = 1;
-  (function(module, exports) {
-    (function webpackUniversalModuleDefinition(root, factory) {
-      module.exports = factory(requireCoseBase());
-    })(cytoscapeFcose, function(__WEBPACK_EXTERNAL_MODULE__140__) {
-      return (
-        /******/
-        (() => {
-          var __webpack_modules__ = {
-            /***/
-            658: (
-              /***/
-              ((module2) => {
-                module2.exports = Object.assign != null ? Object.assign.bind(Object) : function(tgt) {
-                  for (var _len = arguments.length, srcs = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-                    srcs[_key - 1] = arguments[_key];
-                  }
-                  srcs.forEach(function(src) {
-                    Object.keys(src).forEach(function(k) {
-                      return tgt[k] = src[k];
-                    });
-                  });
-                  return tgt;
-                };
-              })
-            ),
-            /***/
-            548: (
-              /***/
-              ((module2, __unused_webpack_exports, __webpack_require__2) => {
-                var _slicedToArray = /* @__PURE__ */ (function() {
-                  function sliceIterator(arr, i) {
-                    var _arr = [];
-                    var _n = true;
-                    var _d = false;
-                    var _e = void 0;
-                    try {
-                      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-                        _arr.push(_s.value);
-                        if (i && _arr.length === i) break;
-                      }
-                    } catch (err) {
-                      _d = true;
-                      _e = err;
-                    } finally {
-                      try {
-                        if (!_n && _i["return"]) _i["return"]();
-                      } finally {
-                        if (_d) throw _e;
-                      }
-                    }
-                    return _arr;
-                  }
-                  return function(arr, i) {
-                    if (Array.isArray(arr)) {
-                      return arr;
-                    } else if (Symbol.iterator in Object(arr)) {
-                      return sliceIterator(arr, i);
-                    } else {
-                      throw new TypeError("Invalid attempt to destructure non-iterable instance");
-                    }
-                  };
-                })();
-                var LinkedList = __webpack_require__2(140).layoutBase.LinkedList;
-                var auxiliary = {};
-                auxiliary.getTopMostNodes = function(nodes) {
-                  var nodesMap = {};
-                  for (var i = 0; i < nodes.length; i++) {
-                    nodesMap[nodes[i].id()] = true;
-                  }
-                  var roots = nodes.filter(function(ele, i2) {
-                    if (typeof ele === "number") {
-                      ele = i2;
-                    }
-                    var parent = ele.parent()[0];
-                    while (parent != null) {
-                      if (nodesMap[parent.id()]) {
-                        return false;
-                      }
-                      parent = parent.parent()[0];
-                    }
-                    return true;
-                  });
-                  return roots;
-                };
-                auxiliary.connectComponents = function(cy, eles, topMostNodes, dummyNodes) {
-                  var queue = new LinkedList();
-                  var visited = /* @__PURE__ */ new Set();
-                  var visitedTopMostNodes = [];
-                  var currentNeighbor = void 0;
-                  var minDegreeNode = void 0;
-                  var minDegree = void 0;
-                  var isConnected = false;
-                  var count = 1;
-                  var nodesConnectedToDummy = [];
-                  var components = [];
-                  var _loop = function _loop2() {
-                    var cmpt = cy.collection();
-                    components.push(cmpt);
-                    var currentNode = topMostNodes[0];
-                    var childrenOfCurrentNode = cy.collection();
-                    childrenOfCurrentNode.merge(currentNode).merge(currentNode.descendants().intersection(eles));
-                    visitedTopMostNodes.push(currentNode);
-                    childrenOfCurrentNode.forEach(function(node) {
-                      queue.push(node);
-                      visited.add(node);
-                      cmpt.merge(node);
-                    });
-                    var _loop22 = function _loop23() {
-                      currentNode = queue.shift();
-                      var neighborNodes = cy.collection();
-                      currentNode.neighborhood().nodes().forEach(function(node) {
-                        if (eles.intersection(currentNode.edgesWith(node)).length > 0) {
-                          neighborNodes.merge(node);
-                        }
-                      });
-                      for (var i = 0; i < neighborNodes.length; i++) {
-                        var neighborNode = neighborNodes[i];
-                        currentNeighbor = topMostNodes.intersection(neighborNode.union(neighborNode.ancestors()));
-                        if (currentNeighbor != null && !visited.has(currentNeighbor[0])) {
-                          var childrenOfNeighbor = currentNeighbor.union(currentNeighbor.descendants());
-                          childrenOfNeighbor.forEach(function(node) {
-                            queue.push(node);
-                            visited.add(node);
-                            cmpt.merge(node);
-                            if (topMostNodes.has(node)) {
-                              visitedTopMostNodes.push(node);
-                            }
-                          });
-                        }
-                      }
-                    };
-                    while (queue.length != 0) {
-                      _loop22();
-                    }
-                    cmpt.forEach(function(node) {
-                      eles.intersection(node.connectedEdges()).forEach(function(e) {
-                        if (cmpt.has(e.source()) && cmpt.has(e.target())) {
-                          cmpt.merge(e);
-                        }
-                      });
-                    });
-                    if (visitedTopMostNodes.length == topMostNodes.length) {
-                      isConnected = true;
-                    }
-                    if (!isConnected || isConnected && count > 1) {
-                      minDegreeNode = visitedTopMostNodes[0];
-                      minDegree = minDegreeNode.connectedEdges().length;
-                      visitedTopMostNodes.forEach(function(node) {
-                        if (node.connectedEdges().length < minDegree) {
-                          minDegree = node.connectedEdges().length;
-                          minDegreeNode = node;
-                        }
-                      });
-                      nodesConnectedToDummy.push(minDegreeNode.id());
-                      var temp = cy.collection();
-                      temp.merge(visitedTopMostNodes[0]);
-                      visitedTopMostNodes.forEach(function(node) {
-                        temp.merge(node);
-                      });
-                      visitedTopMostNodes = [];
-                      topMostNodes = topMostNodes.difference(temp);
-                      count++;
-                    }
-                  };
-                  do {
-                    _loop();
-                  } while (!isConnected);
-                  if (dummyNodes) {
-                    if (nodesConnectedToDummy.length > 0) {
-                      dummyNodes.set("dummy" + (dummyNodes.size + 1), nodesConnectedToDummy);
-                    }
-                  }
-                  return components;
-                };
-                auxiliary.relocateComponent = function(originalCenter, componentResult, options) {
-                  if (!options.fixedNodeConstraint) {
-                    var minXCoord = Number.POSITIVE_INFINITY;
-                    var maxXCoord = Number.NEGATIVE_INFINITY;
-                    var minYCoord = Number.POSITIVE_INFINITY;
-                    var maxYCoord = Number.NEGATIVE_INFINITY;
-                    if (options.quality == "draft") {
-                      var _iteratorNormalCompletion = true;
-                      var _didIteratorError = false;
-                      var _iteratorError = void 0;
-                      try {
-                        for (var _iterator = componentResult.nodeIndexes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                          var _ref = _step.value;
-                          var _ref2 = _slicedToArray(_ref, 2);
-                          var key = _ref2[0];
-                          var value = _ref2[1];
-                          var cyNode = options.cy.getElementById(key);
-                          if (cyNode) {
-                            var nodeBB = cyNode.boundingBox();
-                            var leftX = componentResult.xCoords[value] - nodeBB.w / 2;
-                            var rightX = componentResult.xCoords[value] + nodeBB.w / 2;
-                            var topY = componentResult.yCoords[value] - nodeBB.h / 2;
-                            var bottomY = componentResult.yCoords[value] + nodeBB.h / 2;
-                            if (leftX < minXCoord) minXCoord = leftX;
-                            if (rightX > maxXCoord) maxXCoord = rightX;
-                            if (topY < minYCoord) minYCoord = topY;
-                            if (bottomY > maxYCoord) maxYCoord = bottomY;
-                          }
-                        }
-                      } catch (err) {
-                        _didIteratorError = true;
-                        _iteratorError = err;
-                      } finally {
-                        try {
-                          if (!_iteratorNormalCompletion && _iterator.return) {
-                            _iterator.return();
-                          }
-                        } finally {
-                          if (_didIteratorError) {
-                            throw _iteratorError;
-                          }
-                        }
-                      }
-                      var diffOnX = originalCenter.x - (maxXCoord + minXCoord) / 2;
-                      var diffOnY = originalCenter.y - (maxYCoord + minYCoord) / 2;
-                      componentResult.xCoords = componentResult.xCoords.map(function(x) {
-                        return x + diffOnX;
-                      });
-                      componentResult.yCoords = componentResult.yCoords.map(function(y) {
-                        return y + diffOnY;
-                      });
-                    } else {
-                      Object.keys(componentResult).forEach(function(item) {
-                        var node = componentResult[item];
-                        var leftX2 = node.getRect().x;
-                        var rightX2 = node.getRect().x + node.getRect().width;
-                        var topY2 = node.getRect().y;
-                        var bottomY2 = node.getRect().y + node.getRect().height;
-                        if (leftX2 < minXCoord) minXCoord = leftX2;
-                        if (rightX2 > maxXCoord) maxXCoord = rightX2;
-                        if (topY2 < minYCoord) minYCoord = topY2;
-                        if (bottomY2 > maxYCoord) maxYCoord = bottomY2;
-                      });
-                      var _diffOnX = originalCenter.x - (maxXCoord + minXCoord) / 2;
-                      var _diffOnY = originalCenter.y - (maxYCoord + minYCoord) / 2;
-                      Object.keys(componentResult).forEach(function(item) {
-                        var node = componentResult[item];
-                        node.setCenter(node.getCenterX() + _diffOnX, node.getCenterY() + _diffOnY);
-                      });
-                    }
-                  }
-                };
-                auxiliary.calcBoundingBox = function(parentNode, xCoords, yCoords, nodeIndexes) {
-                  var left = Number.MAX_SAFE_INTEGER;
-                  var right = Number.MIN_SAFE_INTEGER;
-                  var top = Number.MAX_SAFE_INTEGER;
-                  var bottom = Number.MIN_SAFE_INTEGER;
-                  var nodeLeft = void 0;
-                  var nodeRight = void 0;
-                  var nodeTop = void 0;
-                  var nodeBottom = void 0;
-                  var nodes = parentNode.descendants().not(":parent");
-                  var s = nodes.length;
-                  for (var i = 0; i < s; i++) {
-                    var node = nodes[i];
-                    nodeLeft = xCoords[nodeIndexes.get(node.id())] - node.width() / 2;
-                    nodeRight = xCoords[nodeIndexes.get(node.id())] + node.width() / 2;
-                    nodeTop = yCoords[nodeIndexes.get(node.id())] - node.height() / 2;
-                    nodeBottom = yCoords[nodeIndexes.get(node.id())] + node.height() / 2;
-                    if (left > nodeLeft) {
-                      left = nodeLeft;
-                    }
-                    if (right < nodeRight) {
-                      right = nodeRight;
-                    }
-                    if (top > nodeTop) {
-                      top = nodeTop;
-                    }
-                    if (bottom < nodeBottom) {
-                      bottom = nodeBottom;
-                    }
-                  }
-                  var boundingBox = {};
-                  boundingBox.topLeftX = left;
-                  boundingBox.topLeftY = top;
-                  boundingBox.width = right - left;
-                  boundingBox.height = bottom - top;
-                  return boundingBox;
-                };
-                auxiliary.calcParentsWithoutChildren = function(cy, eles) {
-                  var parentsWithoutChildren = cy.collection();
-                  eles.nodes(":parent").forEach(function(parent) {
-                    var check = false;
-                    parent.children().forEach(function(child) {
-                      if (child.css("display") != "none") {
-                        check = true;
-                      }
-                    });
-                    if (!check) {
-                      parentsWithoutChildren.merge(parent);
-                    }
-                  });
-                  return parentsWithoutChildren;
-                };
-                module2.exports = auxiliary;
-              })
-            ),
-            /***/
-            816: (
-              /***/
-              ((module2, __unused_webpack_exports, __webpack_require__2) => {
-                var aux = __webpack_require__2(548);
-                var CoSELayout = __webpack_require__2(140).CoSELayout;
-                var CoSENode = __webpack_require__2(140).CoSENode;
-                var PointD = __webpack_require__2(140).layoutBase.PointD;
-                var DimensionD = __webpack_require__2(140).layoutBase.DimensionD;
-                var LayoutConstants = __webpack_require__2(140).layoutBase.LayoutConstants;
-                var FDLayoutConstants = __webpack_require__2(140).layoutBase.FDLayoutConstants;
-                var CoSEConstants = __webpack_require__2(140).CoSEConstants;
-                var coseLayout = function coseLayout2(options, spectralResult) {
-                  var cy = options.cy;
-                  var eles = options.eles;
-                  var nodes = eles.nodes();
-                  var edges = eles.edges();
-                  var nodeIndexes = void 0;
-                  var xCoords = void 0;
-                  var yCoords = void 0;
-                  var idToLNode = {};
-                  if (options.randomize) {
-                    nodeIndexes = spectralResult["nodeIndexes"];
-                    xCoords = spectralResult["xCoords"];
-                    yCoords = spectralResult["yCoords"];
-                  }
-                  var isFn = function isFn2(fn) {
-                    return typeof fn === "function";
-                  };
-                  var optFn = function optFn2(opt, ele) {
-                    if (isFn(opt)) {
-                      return opt(ele);
-                    } else {
-                      return opt;
-                    }
-                  };
-                  var parentsWithoutChildren = aux.calcParentsWithoutChildren(cy, eles);
-                  var processChildrenList = function processChildrenList2(parent, children, layout, options2) {
-                    var size = children.length;
-                    for (var i = 0; i < size; i++) {
-                      var theChild = children[i];
-                      var children_of_children = null;
-                      if (theChild.intersection(parentsWithoutChildren).length == 0) {
-                        children_of_children = theChild.children();
-                      }
-                      var theNode = void 0;
-                      var dimensions = theChild.layoutDimensions({
-                        nodeDimensionsIncludeLabels: options2.nodeDimensionsIncludeLabels
-                      });
-                      if (theChild.outerWidth() != null && theChild.outerHeight() != null) {
-                        if (options2.randomize) {
-                          if (!theChild.isParent()) {
-                            theNode = parent.add(new CoSENode(layout.graphManager, new PointD(xCoords[nodeIndexes.get(theChild.id())] - dimensions.w / 2, yCoords[nodeIndexes.get(theChild.id())] - dimensions.h / 2), new DimensionD(parseFloat(dimensions.w), parseFloat(dimensions.h))));
-                          } else {
-                            var parentInfo = aux.calcBoundingBox(theChild, xCoords, yCoords, nodeIndexes);
-                            if (theChild.intersection(parentsWithoutChildren).length == 0) {
-                              theNode = parent.add(new CoSENode(layout.graphManager, new PointD(parentInfo.topLeftX, parentInfo.topLeftY), new DimensionD(parentInfo.width, parentInfo.height)));
-                            } else {
-                              theNode = parent.add(new CoSENode(layout.graphManager, new PointD(parentInfo.topLeftX, parentInfo.topLeftY), new DimensionD(parseFloat(dimensions.w), parseFloat(dimensions.h))));
-                            }
-                          }
-                        } else {
-                          theNode = parent.add(new CoSENode(layout.graphManager, new PointD(theChild.position("x") - dimensions.w / 2, theChild.position("y") - dimensions.h / 2), new DimensionD(parseFloat(dimensions.w), parseFloat(dimensions.h))));
-                        }
-                      } else {
-                        theNode = parent.add(new CoSENode(this.graphManager));
-                      }
-                      theNode.id = theChild.data("id");
-                      theNode.nodeRepulsion = optFn(options2.nodeRepulsion, theChild);
-                      theNode.paddingLeft = parseInt(theChild.css("padding"));
-                      theNode.paddingTop = parseInt(theChild.css("padding"));
-                      theNode.paddingRight = parseInt(theChild.css("padding"));
-                      theNode.paddingBottom = parseInt(theChild.css("padding"));
-                      if (options2.nodeDimensionsIncludeLabels) {
-                        theNode.labelWidth = theChild.boundingBox({ includeLabels: true, includeNodes: false, includeOverlays: false }).w;
-                        theNode.labelHeight = theChild.boundingBox({ includeLabels: true, includeNodes: false, includeOverlays: false }).h;
-                        theNode.labelPosVertical = theChild.css("text-valign");
-                        theNode.labelPosHorizontal = theChild.css("text-halign");
-                      }
-                      idToLNode[theChild.data("id")] = theNode;
-                      if (isNaN(theNode.rect.x)) {
-                        theNode.rect.x = 0;
-                      }
-                      if (isNaN(theNode.rect.y)) {
-                        theNode.rect.y = 0;
-                      }
-                      if (children_of_children != null && children_of_children.length > 0) {
-                        var theNewGraph = void 0;
-                        theNewGraph = layout.getGraphManager().add(layout.newGraph(), theNode);
-                        processChildrenList2(theNewGraph, children_of_children, layout, options2);
-                      }
-                    }
-                  };
-                  var processEdges = function processEdges2(layout, gm2, edges2) {
-                    var idealLengthTotal = 0;
-                    var edgeCount = 0;
-                    for (var i = 0; i < edges2.length; i++) {
-                      var edge = edges2[i];
-                      var sourceNode = idToLNode[edge.data("source")];
-                      var targetNode = idToLNode[edge.data("target")];
-                      if (sourceNode && targetNode && sourceNode !== targetNode && sourceNode.getEdgesBetween(targetNode).length == 0) {
-                        var e1 = gm2.add(layout.newEdge(), sourceNode, targetNode);
-                        e1.id = edge.id();
-                        e1.idealLength = optFn(options.idealEdgeLength, edge);
-                        e1.edgeElasticity = optFn(options.edgeElasticity, edge);
-                        idealLengthTotal += e1.idealLength;
-                        edgeCount++;
-                      }
-                    }
-                    if (options.idealEdgeLength != null) {
-                      if (edgeCount > 0) CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = idealLengthTotal / edgeCount;
-                      else if (!isFn(options.idealEdgeLength))
-                        CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = options.idealEdgeLength;
-                      else
-                        CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = 50;
-                      CoSEConstants.MIN_REPULSION_DIST = FDLayoutConstants.MIN_REPULSION_DIST = FDLayoutConstants.DEFAULT_EDGE_LENGTH / 10;
-                      CoSEConstants.DEFAULT_RADIAL_SEPARATION = FDLayoutConstants.DEFAULT_EDGE_LENGTH;
-                    }
-                  };
-                  var processConstraints = function processConstraints2(layout, options2) {
-                    if (options2.fixedNodeConstraint) {
-                      layout.constraints["fixedNodeConstraint"] = options2.fixedNodeConstraint;
-                    }
-                    if (options2.alignmentConstraint) {
-                      layout.constraints["alignmentConstraint"] = options2.alignmentConstraint;
-                    }
-                    if (options2.relativePlacementConstraint) {
-                      layout.constraints["relativePlacementConstraint"] = options2.relativePlacementConstraint;
-                    }
-                  };
-                  if (options.nestingFactor != null) CoSEConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = options.nestingFactor;
-                  if (options.gravity != null) CoSEConstants.DEFAULT_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = options.gravity;
-                  if (options.numIter != null) CoSEConstants.MAX_ITERATIONS = FDLayoutConstants.MAX_ITERATIONS = options.numIter;
-                  if (options.gravityRange != null) CoSEConstants.DEFAULT_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = options.gravityRange;
-                  if (options.gravityCompound != null) CoSEConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = options.gravityCompound;
-                  if (options.gravityRangeCompound != null) CoSEConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = options.gravityRangeCompound;
-                  if (options.initialEnergyOnIncremental != null) CoSEConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = options.initialEnergyOnIncremental;
-                  if (options.tilingCompareBy != null) CoSEConstants.TILING_COMPARE_BY = options.tilingCompareBy;
-                  if (options.quality == "proof") LayoutConstants.QUALITY = 2;
-                  else LayoutConstants.QUALITY = 0;
-                  CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS = FDLayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = options.nodeDimensionsIncludeLabels;
-                  CoSEConstants.DEFAULT_INCREMENTAL = FDLayoutConstants.DEFAULT_INCREMENTAL = LayoutConstants.DEFAULT_INCREMENTAL = !options.randomize;
-                  CoSEConstants.ANIMATE = FDLayoutConstants.ANIMATE = LayoutConstants.ANIMATE = options.animate;
-                  CoSEConstants.TILE = options.tile;
-                  CoSEConstants.TILING_PADDING_VERTICAL = typeof options.tilingPaddingVertical === "function" ? options.tilingPaddingVertical.call() : options.tilingPaddingVertical;
-                  CoSEConstants.TILING_PADDING_HORIZONTAL = typeof options.tilingPaddingHorizontal === "function" ? options.tilingPaddingHorizontal.call() : options.tilingPaddingHorizontal;
-                  CoSEConstants.DEFAULT_INCREMENTAL = FDLayoutConstants.DEFAULT_INCREMENTAL = LayoutConstants.DEFAULT_INCREMENTAL = true;
-                  CoSEConstants.PURE_INCREMENTAL = !options.randomize;
-                  LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES = options.uniformNodeDimensions;
-                  if (options.step == "transformed") {
-                    CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = true;
-                    CoSEConstants.ENFORCE_CONSTRAINTS = false;
-                    CoSEConstants.APPLY_LAYOUT = false;
-                  }
-                  if (options.step == "enforced") {
-                    CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = false;
-                    CoSEConstants.ENFORCE_CONSTRAINTS = true;
-                    CoSEConstants.APPLY_LAYOUT = false;
-                  }
-                  if (options.step == "cose") {
-                    CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = false;
-                    CoSEConstants.ENFORCE_CONSTRAINTS = false;
-                    CoSEConstants.APPLY_LAYOUT = true;
-                  }
-                  if (options.step == "all") {
-                    if (options.randomize) CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = true;
-                    else CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = false;
-                    CoSEConstants.ENFORCE_CONSTRAINTS = true;
-                    CoSEConstants.APPLY_LAYOUT = true;
-                  }
-                  if (options.fixedNodeConstraint || options.alignmentConstraint || options.relativePlacementConstraint) {
-                    CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = false;
-                  } else {
-                    CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = true;
-                  }
-                  var coseLayout3 = new CoSELayout();
-                  var gm = coseLayout3.newGraphManager();
-                  processChildrenList(gm.addRoot(), aux.getTopMostNodes(nodes), coseLayout3, options);
-                  processEdges(coseLayout3, gm, edges);
-                  processConstraints(coseLayout3, options);
-                  coseLayout3.runLayout();
-                  return idToLNode;
-                };
-                module2.exports = { coseLayout };
-              })
-            ),
-            /***/
-            212: (
-              /***/
-              ((module2, __unused_webpack_exports, __webpack_require__2) => {
-                var _createClass = /* @__PURE__ */ (function() {
-                  function defineProperties(target, props) {
-                    for (var i = 0; i < props.length; i++) {
-                      var descriptor = props[i];
-                      descriptor.enumerable = descriptor.enumerable || false;
-                      descriptor.configurable = true;
-                      if ("value" in descriptor) descriptor.writable = true;
-                      Object.defineProperty(target, descriptor.key, descriptor);
-                    }
-                  }
-                  return function(Constructor, protoProps, staticProps) {
-                    if (protoProps) defineProperties(Constructor.prototype, protoProps);
-                    if (staticProps) defineProperties(Constructor, staticProps);
-                    return Constructor;
-                  };
-                })();
-                function _classCallCheck(instance, Constructor) {
-                  if (!(instance instanceof Constructor)) {
-                    throw new TypeError("Cannot call a class as a function");
-                  }
-                }
-                var assign = __webpack_require__2(658);
-                var aux = __webpack_require__2(548);
-                var _require = __webpack_require__2(657), spectralLayout = _require.spectralLayout;
-                var _require2 = __webpack_require__2(816), coseLayout = _require2.coseLayout;
-                var defaults = Object.freeze({
-                  // 'draft', 'default' or 'proof' 
-                  // - 'draft' only applies spectral layout 
-                  // - 'default' improves the quality with subsequent CoSE layout (fast cooling rate)
-                  // - 'proof' improves the quality with subsequent CoSE layout (slow cooling rate) 
-                  quality: "default",
-                  // Use random node positions at beginning of layout
-                  // if this is set to false, then quality option must be "proof"
-                  randomize: true,
-                  // Whether or not to animate the layout
-                  animate: true,
-                  // Duration of animation in ms, if enabled
-                  animationDuration: 1e3,
-                  // Easing of animation, if enabled
-                  animationEasing: void 0,
-                  // Fit the viewport to the repositioned nodes
-                  fit: true,
-                  // Padding around layout
-                  padding: 30,
-                  // Whether to include labels in node dimensions. Valid in "proof" quality
-                  nodeDimensionsIncludeLabels: false,
-                  // Whether or not simple nodes (non-compound nodes) are of uniform dimensions
-                  uniformNodeDimensions: false,
-                  // Whether to pack disconnected components - valid only if randomize: true
-                  packComponents: true,
-                  // Layout step - all, transformed, enforced, cose - for debug purpose only
-                  step: "all",
-                  /* spectral layout options */
-                  // False for random, true for greedy
-                  samplingType: true,
-                  // Sample size to construct distance matrix
-                  sampleSize: 25,
-                  // Separation amount between nodes
-                  nodeSeparation: 75,
-                  // Power iteration tolerance
-                  piTol: 1e-7,
-                  /* CoSE layout options */
-                  // Node repulsion (non overlapping) multiplier
-                  nodeRepulsion: function nodeRepulsion(node) {
-                    return 4500;
-                  },
-                  // Ideal edge (non nested) length
-                  idealEdgeLength: function idealEdgeLength(edge) {
-                    return 50;
-                  },
-                  // Divisor to compute edge forces
-                  edgeElasticity: function edgeElasticity(edge) {
-                    return 0.45;
-                  },
-                  // Nesting factor (multiplier) to compute ideal edge length for nested edges
-                  nestingFactor: 0.1,
-                  // Gravity force (constant)
-                  gravity: 0.25,
-                  // Maximum number of iterations to perform
-                  numIter: 2500,
-                  // For enabling tiling
-                  tile: true,
-                  // The function that specifies the criteria for comparing nodes while sorting them during tiling operation.
-                  // Takes the node id as a parameter and the default tiling operation is perfomed when this option is not set.
-                  tilingCompareBy: void 0,
-                  // Represents the amount of the vertical space to put between the zero degree members during the tiling operation(can also be a function)
-                  tilingPaddingVertical: 10,
-                  // Represents the amount of the horizontal space to put between the zero degree members during the tiling operation(can also be a function)
-                  tilingPaddingHorizontal: 10,
-                  // Gravity range (constant) for compounds
-                  gravityRangeCompound: 1.5,
-                  // Gravity force (constant) for compounds
-                  gravityCompound: 1,
-                  // Gravity range (constant)
-                  gravityRange: 3.8,
-                  // Initial cooling factor for incremental layout  
-                  initialEnergyOnIncremental: 0.3,
-                  /* constraint options */
-                  // Fix required nodes to predefined positions
-                  // [{nodeId: 'n1', position: {x: 100, y: 200}, {...}]
-                  fixedNodeConstraint: void 0,
-                  // Align required nodes in vertical/horizontal direction
-                  // {vertical: [['n1', 'n2')], ['n3', 'n4']], horizontal: ['n2', 'n4']}
-                  alignmentConstraint: void 0,
-                  // Place two nodes relatively in vertical/horizontal direction 
-                  // [{top: 'n1', bottom: 'n2', gap: 100}, {left: 'n3', right: 'n4', gap: 75}]
-                  relativePlacementConstraint: void 0,
-                  /* layout event callbacks */
-                  ready: function ready() {
-                  },
-                  // on layoutready
-                  stop: function stop() {
-                  }
-                  // on layoutstop
-                });
-                var Layout = (function() {
-                  function Layout2(options) {
-                    _classCallCheck(this, Layout2);
-                    this.options = assign({}, defaults, options);
-                  }
-                  _createClass(Layout2, [{
-                    key: "run",
-                    value: function run() {
-                      var layout = this;
-                      var options = this.options;
-                      var cy = options.cy;
-                      var eles = options.eles;
-                      var spectralResult = [];
-                      var coseResult = [];
-                      var components = void 0;
-                      var componentCenters = [];
-                      if (options.fixedNodeConstraint && (!Array.isArray(options.fixedNodeConstraint) || options.fixedNodeConstraint.length == 0)) {
-                        options.fixedNodeConstraint = void 0;
-                      }
-                      if (options.alignmentConstraint) {
-                        if (options.alignmentConstraint.vertical && (!Array.isArray(options.alignmentConstraint.vertical) || options.alignmentConstraint.vertical.length == 0)) {
-                          options.alignmentConstraint.vertical = void 0;
-                        }
-                        if (options.alignmentConstraint.horizontal && (!Array.isArray(options.alignmentConstraint.horizontal) || options.alignmentConstraint.horizontal.length == 0)) {
-                          options.alignmentConstraint.horizontal = void 0;
-                        }
-                      }
-                      if (options.relativePlacementConstraint && (!Array.isArray(options.relativePlacementConstraint) || options.relativePlacementConstraint.length == 0)) {
-                        options.relativePlacementConstraint = void 0;
-                      }
-                      var constraintExist = options.fixedNodeConstraint || options.alignmentConstraint || options.relativePlacementConstraint;
-                      if (constraintExist) {
-                        options.tile = false;
-                        options.packComponents = false;
-                      }
-                      var layUtil = void 0;
-                      var packingEnabled = false;
-                      if (cy.layoutUtilities && options.packComponents) {
-                        layUtil = cy.layoutUtilities("get");
-                        if (!layUtil) layUtil = cy.layoutUtilities();
-                        packingEnabled = true;
-                      }
-                      if (eles.nodes().length > 0) {
-                        if (!packingEnabled) {
-                          var boundingBox = options.eles.boundingBox();
-                          componentCenters.push({ x: boundingBox.x1 + boundingBox.w / 2, y: boundingBox.y1 + boundingBox.h / 2 });
-                          if (options.randomize) {
-                            var result = spectralLayout(options);
-                            spectralResult.push(result);
-                          }
-                          if (options.quality == "default" || options.quality == "proof") {
-                            coseResult.push(coseLayout(options, spectralResult[0]));
-                            aux.relocateComponent(componentCenters[0], coseResult[0], options);
-                          } else {
-                            aux.relocateComponent(componentCenters[0], spectralResult[0], options);
-                          }
-                        } else {
-                          var topMostNodes = aux.getTopMostNodes(options.eles.nodes());
-                          components = aux.connectComponents(cy, options.eles, topMostNodes);
-                          components.forEach(function(component) {
-                            var boundingBox2 = component.boundingBox();
-                            componentCenters.push({ x: boundingBox2.x1 + boundingBox2.w / 2, y: boundingBox2.y1 + boundingBox2.h / 2 });
-                          });
-                          if (options.randomize) {
-                            components.forEach(function(component) {
-                              options.eles = component;
-                              spectralResult.push(spectralLayout(options));
-                            });
-                          }
-                          if (options.quality == "default" || options.quality == "proof") {
-                            var toBeTiledNodes = cy.collection();
-                            if (options.tile) {
-                              var nodeIndexes = /* @__PURE__ */ new Map();
-                              var _xCoords = [];
-                              var _yCoords = [];
-                              var count = 0;
-                              var tempSpectralResult = { nodeIndexes, xCoords: _xCoords, yCoords: _yCoords };
-                              var indexesToBeDeleted = [];
-                              components.forEach(function(component, index) {
-                                if (component.edges().length == 0) {
-                                  component.nodes().forEach(function(node, i2) {
-                                    toBeTiledNodes.merge(component.nodes()[i2]);
-                                    if (!node.isParent()) {
-                                      tempSpectralResult.nodeIndexes.set(component.nodes()[i2].id(), count++);
-                                      tempSpectralResult.xCoords.push(component.nodes()[0].position().x);
-                                      tempSpectralResult.yCoords.push(component.nodes()[0].position().y);
-                                    }
-                                  });
-                                  indexesToBeDeleted.push(index);
-                                }
-                              });
-                              if (toBeTiledNodes.length > 1) {
-                                var _boundingBox = toBeTiledNodes.boundingBox();
-                                componentCenters.push({ x: _boundingBox.x1 + _boundingBox.w / 2, y: _boundingBox.y1 + _boundingBox.h / 2 });
-                                components.push(toBeTiledNodes);
-                                spectralResult.push(tempSpectralResult);
-                                for (var i = indexesToBeDeleted.length - 1; i >= 0; i--) {
-                                  components.splice(indexesToBeDeleted[i], 1);
-                                  spectralResult.splice(indexesToBeDeleted[i], 1);
-                                  componentCenters.splice(indexesToBeDeleted[i], 1);
-                                }
-                              }
-                            }
-                            components.forEach(function(component, index) {
-                              options.eles = component;
-                              coseResult.push(coseLayout(options, spectralResult[index]));
-                              aux.relocateComponent(componentCenters[index], coseResult[index], options);
-                            });
-                          } else {
-                            components.forEach(function(component, index) {
-                              aux.relocateComponent(componentCenters[index], spectralResult[index], options);
-                            });
-                          }
-                          var componentsEvaluated = /* @__PURE__ */ new Set();
-                          if (components.length > 1) {
-                            var subgraphs = [];
-                            var hiddenEles = eles.filter(function(ele) {
-                              return ele.css("display") == "none";
-                            });
-                            components.forEach(function(component, index) {
-                              var nodeIndexes2 = void 0;
-                              if (options.quality == "draft") {
-                                nodeIndexes2 = spectralResult[index].nodeIndexes;
-                              }
-                              if (component.nodes().not(hiddenEles).length > 0) {
-                                var subgraph = {};
-                                subgraph.edges = [];
-                                subgraph.nodes = [];
-                                var nodeIndex = void 0;
-                                component.nodes().not(hiddenEles).forEach(function(node) {
-                                  if (options.quality == "draft") {
-                                    if (!node.isParent()) {
-                                      nodeIndex = nodeIndexes2.get(node.id());
-                                      subgraph.nodes.push({ x: spectralResult[index].xCoords[nodeIndex] - node.boundingbox().w / 2, y: spectralResult[index].yCoords[nodeIndex] - node.boundingbox().h / 2, width: node.boundingbox().w, height: node.boundingbox().h });
-                                    } else {
-                                      var parentInfo = aux.calcBoundingBox(node, spectralResult[index].xCoords, spectralResult[index].yCoords, nodeIndexes2);
-                                      subgraph.nodes.push({ x: parentInfo.topLeftX, y: parentInfo.topLeftY, width: parentInfo.width, height: parentInfo.height });
-                                    }
-                                  } else {
-                                    if (coseResult[index][node.id()]) {
-                                      subgraph.nodes.push({ x: coseResult[index][node.id()].getLeft(), y: coseResult[index][node.id()].getTop(), width: coseResult[index][node.id()].getWidth(), height: coseResult[index][node.id()].getHeight() });
-                                    }
-                                  }
-                                });
-                                component.edges().forEach(function(edge) {
-                                  var source = edge.source();
-                                  var target = edge.target();
-                                  if (source.css("display") != "none" && target.css("display") != "none") {
-                                    if (options.quality == "draft") {
-                                      var sourceNodeIndex = nodeIndexes2.get(source.id());
-                                      var targetNodeIndex = nodeIndexes2.get(target.id());
-                                      var sourceCenter = [];
-                                      var targetCenter = [];
-                                      if (source.isParent()) {
-                                        var parentInfo = aux.calcBoundingBox(source, spectralResult[index].xCoords, spectralResult[index].yCoords, nodeIndexes2);
-                                        sourceCenter.push(parentInfo.topLeftX + parentInfo.width / 2);
-                                        sourceCenter.push(parentInfo.topLeftY + parentInfo.height / 2);
-                                      } else {
-                                        sourceCenter.push(spectralResult[index].xCoords[sourceNodeIndex]);
-                                        sourceCenter.push(spectralResult[index].yCoords[sourceNodeIndex]);
-                                      }
-                                      if (target.isParent()) {
-                                        var _parentInfo = aux.calcBoundingBox(target, spectralResult[index].xCoords, spectralResult[index].yCoords, nodeIndexes2);
-                                        targetCenter.push(_parentInfo.topLeftX + _parentInfo.width / 2);
-                                        targetCenter.push(_parentInfo.topLeftY + _parentInfo.height / 2);
-                                      } else {
-                                        targetCenter.push(spectralResult[index].xCoords[targetNodeIndex]);
-                                        targetCenter.push(spectralResult[index].yCoords[targetNodeIndex]);
-                                      }
-                                      subgraph.edges.push({ startX: sourceCenter[0], startY: sourceCenter[1], endX: targetCenter[0], endY: targetCenter[1] });
-                                    } else {
-                                      if (coseResult[index][source.id()] && coseResult[index][target.id()]) {
-                                        subgraph.edges.push({ startX: coseResult[index][source.id()].getCenterX(), startY: coseResult[index][source.id()].getCenterY(), endX: coseResult[index][target.id()].getCenterX(), endY: coseResult[index][target.id()].getCenterY() });
-                                      }
-                                    }
-                                  }
-                                });
-                                if (subgraph.nodes.length > 0) {
-                                  subgraphs.push(subgraph);
-                                  componentsEvaluated.add(index);
-                                }
-                              }
-                            });
-                            var shiftResult = layUtil.packComponents(subgraphs, options.randomize).shifts;
-                            if (options.quality == "draft") {
-                              spectralResult.forEach(function(result2, index) {
-                                var newXCoords = result2.xCoords.map(function(x) {
-                                  return x + shiftResult[index].dx;
-                                });
-                                var newYCoords = result2.yCoords.map(function(y) {
-                                  return y + shiftResult[index].dy;
-                                });
-                                result2.xCoords = newXCoords;
-                                result2.yCoords = newYCoords;
-                              });
-                            } else {
-                              var _count = 0;
-                              componentsEvaluated.forEach(function(index) {
-                                Object.keys(coseResult[index]).forEach(function(item) {
-                                  var nodeRectangle = coseResult[index][item];
-                                  nodeRectangle.setCenter(nodeRectangle.getCenterX() + shiftResult[_count].dx, nodeRectangle.getCenterY() + shiftResult[_count].dy);
-                                });
-                                _count++;
-                              });
-                            }
-                          }
-                        }
-                      }
-                      var getPositions = function getPositions2(ele, i2) {
-                        if (options.quality == "default" || options.quality == "proof") {
-                          if (typeof ele === "number") {
-                            ele = i2;
-                          }
-                          var pos = void 0;
-                          var node = void 0;
-                          var theId = ele.data("id");
-                          coseResult.forEach(function(result2) {
-                            if (theId in result2) {
-                              pos = { x: result2[theId].getRect().getCenterX(), y: result2[theId].getRect().getCenterY() };
-                              node = result2[theId];
-                            }
-                          });
-                          if (options.nodeDimensionsIncludeLabels) {
-                            if (node.labelWidth) {
-                              if (node.labelPosHorizontal == "left") {
-                                pos.x += node.labelWidth / 2;
-                              } else if (node.labelPosHorizontal == "right") {
-                                pos.x -= node.labelWidth / 2;
-                              }
-                            }
-                            if (node.labelHeight) {
-                              if (node.labelPosVertical == "top") {
-                                pos.y += node.labelHeight / 2;
-                              } else if (node.labelPosVertical == "bottom") {
-                                pos.y -= node.labelHeight / 2;
-                              }
-                            }
-                          }
-                          if (pos == void 0) pos = { x: ele.position("x"), y: ele.position("y") };
-                          return {
-                            x: pos.x,
-                            y: pos.y
-                          };
-                        } else {
-                          var _pos = void 0;
-                          spectralResult.forEach(function(result2) {
-                            var index = result2.nodeIndexes.get(ele.id());
-                            if (index != void 0) {
-                              _pos = { x: result2.xCoords[index], y: result2.yCoords[index] };
-                            }
-                          });
-                          if (_pos == void 0) _pos = { x: ele.position("x"), y: ele.position("y") };
-                          return {
-                            x: _pos.x,
-                            y: _pos.y
-                          };
-                        }
-                      };
-                      if (options.quality == "default" || options.quality == "proof" || options.randomize) {
-                        var parentsWithoutChildren = aux.calcParentsWithoutChildren(cy, eles);
-                        var _hiddenEles = eles.filter(function(ele) {
-                          return ele.css("display") == "none";
-                        });
-                        options.eles = eles.not(_hiddenEles);
-                        eles.nodes().not(":parent").not(_hiddenEles).layoutPositions(layout, options, getPositions);
-                        if (parentsWithoutChildren.length > 0) {
-                          parentsWithoutChildren.forEach(function(ele) {
-                            ele.position(getPositions(ele));
-                          });
-                        }
-                      } else {
-                        console.log("If randomize option is set to false, then quality option must be 'default' or 'proof'.");
-                      }
-                    }
-                  }]);
-                  return Layout2;
-                })();
-                module2.exports = Layout;
-              })
-            ),
-            /***/
-            657: (
-              /***/
-              ((module2, __unused_webpack_exports, __webpack_require__2) => {
-                var aux = __webpack_require__2(548);
-                var Matrix = __webpack_require__2(140).layoutBase.Matrix;
-                var SVD = __webpack_require__2(140).layoutBase.SVD;
-                var spectralLayout = function spectralLayout2(options) {
-                  var cy = options.cy;
-                  var eles = options.eles;
-                  var nodes = eles.nodes();
-                  var parentNodes = eles.nodes(":parent");
-                  var dummyNodes = /* @__PURE__ */ new Map();
-                  var nodeIndexes = /* @__PURE__ */ new Map();
-                  var parentChildMap = /* @__PURE__ */ new Map();
-                  var allNodesNeighborhood = [];
-                  var xCoords = [];
-                  var yCoords = [];
-                  var samplesColumn = [];
-                  var minDistancesColumn = [];
-                  var C = [];
-                  var PHI = [];
-                  var INV = [];
-                  var nodeSize = void 0;
-                  var infinity = 1e8;
-                  var small = 1e-9;
-                  var piTol = options.piTol;
-                  var samplingType = options.samplingType;
-                  var nodeSeparation = options.nodeSeparation;
-                  var sampleSize = void 0;
-                  var randomSampleCR = function randomSampleCR2() {
-                    var sample2 = 0;
-                    var count = 0;
-                    var flag = false;
-                    while (count < sampleSize) {
-                      sample2 = Math.floor(Math.random() * nodeSize);
-                      flag = false;
-                      for (var i2 = 0; i2 < count; i2++) {
-                        if (samplesColumn[i2] == sample2) {
-                          flag = true;
-                          break;
-                        }
-                      }
-                      if (!flag) {
-                        samplesColumn[count] = sample2;
-                        count++;
-                      } else {
-                        continue;
-                      }
-                    }
-                  };
-                  var BFS = function BFS2(pivot, index2, samplingMethod) {
-                    var path = [];
-                    var front = 0;
-                    var back = 0;
-                    var current = 0;
-                    var temp = void 0;
-                    var distance = [];
-                    var max_dist = 0;
-                    var max_ind = 1;
-                    for (var i2 = 0; i2 < nodeSize; i2++) {
-                      distance[i2] = infinity;
-                    }
-                    path[back] = pivot;
-                    distance[pivot] = 0;
-                    while (back >= front) {
-                      current = path[front++];
-                      var neighbors = allNodesNeighborhood[current];
-                      for (var _i = 0; _i < neighbors.length; _i++) {
-                        temp = nodeIndexes.get(neighbors[_i]);
-                        if (distance[temp] == infinity) {
-                          distance[temp] = distance[current] + 1;
-                          path[++back] = temp;
-                        }
-                      }
-                      C[current][index2] = distance[current] * nodeSeparation;
-                    }
-                    if (samplingMethod) {
-                      for (var _i2 = 0; _i2 < nodeSize; _i2++) {
-                        if (C[_i2][index2] < minDistancesColumn[_i2]) minDistancesColumn[_i2] = C[_i2][index2];
-                      }
-                      for (var _i3 = 0; _i3 < nodeSize; _i3++) {
-                        if (minDistancesColumn[_i3] > max_dist) {
-                          max_dist = minDistancesColumn[_i3];
-                          max_ind = _i3;
-                        }
-                      }
-                    }
-                    return max_ind;
-                  };
-                  var allBFS = function allBFS2(samplingMethod) {
-                    var sample2 = void 0;
-                    if (!samplingMethod) {
-                      randomSampleCR();
-                      for (var i2 = 0; i2 < sampleSize; i2++) {
-                        BFS(samplesColumn[i2], i2, samplingMethod);
-                      }
-                    } else {
-                      sample2 = Math.floor(Math.random() * nodeSize);
-                      for (var _i4 = 0; _i4 < nodeSize; _i4++) {
-                        minDistancesColumn[_i4] = infinity;
-                      }
-                      for (var _i5 = 0; _i5 < sampleSize; _i5++) {
-                        samplesColumn[_i5] = sample2;
-                        sample2 = BFS(sample2, _i5, samplingMethod);
-                      }
-                    }
-                    for (var _i6 = 0; _i6 < nodeSize; _i6++) {
-                      for (var j = 0; j < sampleSize; j++) {
-                        C[_i6][j] *= C[_i6][j];
-                      }
-                    }
-                    for (var _i7 = 0; _i7 < sampleSize; _i7++) {
-                      PHI[_i7] = [];
-                    }
-                    for (var _i8 = 0; _i8 < sampleSize; _i8++) {
-                      for (var _j = 0; _j < sampleSize; _j++) {
-                        PHI[_i8][_j] = C[samplesColumn[_j]][_i8];
-                      }
-                    }
-                  };
-                  var sample = function sample2() {
-                    var SVDResult = SVD.svd(PHI);
-                    var a_q = SVDResult.S;
-                    var a_u = SVDResult.U;
-                    var a_v = SVDResult.V;
-                    var max_s = a_q[0] * a_q[0] * a_q[0];
-                    var a_Sig = [];
-                    for (var i2 = 0; i2 < sampleSize; i2++) {
-                      a_Sig[i2] = [];
-                      for (var j = 0; j < sampleSize; j++) {
-                        a_Sig[i2][j] = 0;
-                        if (i2 == j) {
-                          a_Sig[i2][j] = a_q[i2] / (a_q[i2] * a_q[i2] + max_s / (a_q[i2] * a_q[i2]));
-                        }
-                      }
-                    }
-                    INV = Matrix.multMat(Matrix.multMat(a_v, a_Sig), Matrix.transpose(a_u));
-                  };
-                  var powerIteration = function powerIteration2() {
-                    var theta1 = void 0;
-                    var theta2 = void 0;
-                    var Y1 = [];
-                    var Y2 = [];
-                    var V1 = [];
-                    var V2 = [];
-                    for (var i2 = 0; i2 < nodeSize; i2++) {
-                      Y1[i2] = Math.random();
-                      Y2[i2] = Math.random();
-                    }
-                    Y1 = Matrix.normalize(Y1);
-                    Y2 = Matrix.normalize(Y2);
-                    var current = small;
-                    var previous = small;
-                    var temp = void 0;
-                    while (true) {
-                      for (var _i9 = 0; _i9 < nodeSize; _i9++) {
-                        V1[_i9] = Y1[_i9];
-                      }
-                      Y1 = Matrix.multGamma(Matrix.multL(Matrix.multGamma(V1), C, INV));
-                      theta1 = Matrix.dotProduct(V1, Y1);
-                      Y1 = Matrix.normalize(Y1);
-                      current = Matrix.dotProduct(V1, Y1);
-                      temp = Math.abs(current / previous);
-                      if (temp <= 1 + piTol && temp >= 1) {
-                        break;
-                      }
-                      previous = current;
-                    }
-                    for (var _i10 = 0; _i10 < nodeSize; _i10++) {
-                      V1[_i10] = Y1[_i10];
-                    }
-                    previous = small;
-                    while (true) {
-                      for (var _i11 = 0; _i11 < nodeSize; _i11++) {
-                        V2[_i11] = Y2[_i11];
-                      }
-                      V2 = Matrix.minusOp(V2, Matrix.multCons(V1, Matrix.dotProduct(V1, V2)));
-                      Y2 = Matrix.multGamma(Matrix.multL(Matrix.multGamma(V2), C, INV));
-                      theta2 = Matrix.dotProduct(V2, Y2);
-                      Y2 = Matrix.normalize(Y2);
-                      current = Matrix.dotProduct(V2, Y2);
-                      temp = Math.abs(current / previous);
-                      if (temp <= 1 + piTol && temp >= 1) {
-                        break;
-                      }
-                      previous = current;
-                    }
-                    for (var _i12 = 0; _i12 < nodeSize; _i12++) {
-                      V2[_i12] = Y2[_i12];
-                    }
-                    xCoords = Matrix.multCons(V1, Math.sqrt(Math.abs(theta1)));
-                    yCoords = Matrix.multCons(V2, Math.sqrt(Math.abs(theta2)));
-                  };
-                  aux.connectComponents(cy, eles, aux.getTopMostNodes(nodes), dummyNodes);
-                  parentNodes.forEach(function(ele) {
-                    aux.connectComponents(cy, eles, aux.getTopMostNodes(ele.descendants().intersection(eles)), dummyNodes);
-                  });
-                  var index = 0;
-                  for (var i = 0; i < nodes.length; i++) {
-                    if (!nodes[i].isParent()) {
-                      nodeIndexes.set(nodes[i].id(), index++);
-                    }
-                  }
-                  var _iteratorNormalCompletion = true;
-                  var _didIteratorError = false;
-                  var _iteratorError = void 0;
-                  try {
-                    for (var _iterator = dummyNodes.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                      var key = _step.value;
-                      nodeIndexes.set(key, index++);
-                    }
-                  } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                  } finally {
-                    try {
-                      if (!_iteratorNormalCompletion && _iterator.return) {
-                        _iterator.return();
-                      }
-                    } finally {
-                      if (_didIteratorError) {
-                        throw _iteratorError;
-                      }
-                    }
-                  }
-                  for (var _i13 = 0; _i13 < nodeIndexes.size; _i13++) {
-                    allNodesNeighborhood[_i13] = [];
-                  }
-                  parentNodes.forEach(function(ele) {
-                    var children = ele.children().intersection(eles);
-                    while (children.nodes(":childless").length == 0) {
-                      children = children.nodes()[0].children().intersection(eles);
-                    }
-                    var index2 = 0;
-                    var min = children.nodes(":childless")[0].connectedEdges().length;
-                    children.nodes(":childless").forEach(function(ele2, i2) {
-                      if (ele2.connectedEdges().length < min) {
-                        min = ele2.connectedEdges().length;
-                        index2 = i2;
-                      }
-                    });
-                    parentChildMap.set(ele.id(), children.nodes(":childless")[index2].id());
-                  });
-                  nodes.forEach(function(ele) {
-                    var eleIndex = void 0;
-                    if (ele.isParent()) eleIndex = nodeIndexes.get(parentChildMap.get(ele.id()));
-                    else eleIndex = nodeIndexes.get(ele.id());
-                    ele.neighborhood().nodes().forEach(function(node) {
-                      if (eles.intersection(ele.edgesWith(node)).length > 0) {
-                        if (node.isParent()) allNodesNeighborhood[eleIndex].push(parentChildMap.get(node.id()));
-                        else allNodesNeighborhood[eleIndex].push(node.id());
-                      }
-                    });
-                  });
-                  var _loop = function _loop2(_key2) {
-                    var eleIndex = nodeIndexes.get(_key2);
-                    var disconnectedId = void 0;
-                    dummyNodes.get(_key2).forEach(function(id) {
-                      if (cy.getElementById(id).isParent()) disconnectedId = parentChildMap.get(id);
-                      else disconnectedId = id;
-                      allNodesNeighborhood[eleIndex].push(disconnectedId);
-                      allNodesNeighborhood[nodeIndexes.get(disconnectedId)].push(_key2);
-                    });
-                  };
-                  var _iteratorNormalCompletion2 = true;
-                  var _didIteratorError2 = false;
-                  var _iteratorError2 = void 0;
-                  try {
-                    for (var _iterator2 = dummyNodes.keys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-                      var _key = _step2.value;
-                      _loop(_key);
-                    }
-                  } catch (err) {
-                    _didIteratorError2 = true;
-                    _iteratorError2 = err;
-                  } finally {
-                    try {
-                      if (!_iteratorNormalCompletion2 && _iterator2.return) {
-                        _iterator2.return();
-                      }
-                    } finally {
-                      if (_didIteratorError2) {
-                        throw _iteratorError2;
-                      }
-                    }
-                  }
-                  nodeSize = nodeIndexes.size;
-                  var spectralResult = void 0;
-                  if (nodeSize > 2) {
-                    sampleSize = nodeSize < options.sampleSize ? nodeSize : options.sampleSize;
-                    for (var _i14 = 0; _i14 < nodeSize; _i14++) {
-                      C[_i14] = [];
-                    }
-                    for (var _i15 = 0; _i15 < sampleSize; _i15++) {
-                      INV[_i15] = [];
-                    }
-                    if (options.quality == "draft" || options.step == "all") {
-                      allBFS(samplingType);
-                      sample();
-                      powerIteration();
-                      spectralResult = { nodeIndexes, xCoords, yCoords };
-                    } else {
-                      nodeIndexes.forEach(function(value, key2) {
-                        xCoords.push(cy.getElementById(key2).position("x"));
-                        yCoords.push(cy.getElementById(key2).position("y"));
-                      });
-                      spectralResult = { nodeIndexes, xCoords, yCoords };
-                    }
-                    return spectralResult;
-                  } else {
-                    var iterator = nodeIndexes.keys();
-                    var firstNode = cy.getElementById(iterator.next().value);
-                    var firstNodePos = firstNode.position();
-                    var firstNodeWidth = firstNode.outerWidth();
-                    xCoords.push(firstNodePos.x);
-                    yCoords.push(firstNodePos.y);
-                    if (nodeSize == 2) {
-                      var secondNode = cy.getElementById(iterator.next().value);
-                      var secondNodeWidth = secondNode.outerWidth();
-                      xCoords.push(firstNodePos.x + firstNodeWidth / 2 + secondNodeWidth / 2 + options.idealEdgeLength);
-                      yCoords.push(firstNodePos.y);
-                    }
-                    spectralResult = { nodeIndexes, xCoords, yCoords };
-                    return spectralResult;
-                  }
-                };
-                module2.exports = { spectralLayout };
-              })
-            ),
-            /***/
-            579: (
-              /***/
-              ((module2, __unused_webpack_exports, __webpack_require__2) => {
-                var impl = __webpack_require__2(212);
-                var register = function register2(cytoscape2) {
-                  if (!cytoscape2) {
-                    return;
-                  }
-                  cytoscape2("layout", "fcose", impl);
-                };
-                if (typeof cytoscape !== "undefined") {
-                  register(cytoscape);
-                }
-                module2.exports = register;
-              })
-            ),
-            /***/
-            140: (
-              /***/
-              ((module2) => {
-                module2.exports = __WEBPACK_EXTERNAL_MODULE__140__;
-              })
-            )
-            /******/
-          };
-          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__(579);
-          return __webpack_exports__;
-        })()
-      );
-    });
-  })(cytoscapeFcose$1);
-  return cytoscapeFcose$1.exports;
-}
-export {
-  requireCytoscapeFcose as __require
-};
-//# sourceMappingURL=cytoscape-fcose.mjs.map