@kong-ui-public/documentation 1.7.40-pr.3869.e876c8c8a.0 → 1.7.40

package/dist/cose-bilkent-S5V4N54A-0ZumbVgj-0z7CQbIH.js

@@ -0,0 +1,2260 @@
+import { p as k, g as j, q as nt, u as st, M as V } from "./index-DfVKdDwj.js";
+import { K as $ } from "./cytoscape.esm-BDIiOYYO-C1jMBhD8.js";
+var z = /* @__PURE__ */ V(((C, P) => {
+  (function(L, m) {
+    typeof C == "object" && typeof P == "object" ? P.exports = m() : typeof define == "function" && define.amd ? define([], m) : typeof C == "object" ? C.layoutBase = m() : L.layoutBase = m();
+  })(C, function() {
+    return (function(L) {
+      var m = {};
+      function A(n) {
+        if (m[n]) return m[n].exports;
+        var e = m[n] = {
+          i: n,
+          l: !1,
+          exports: {}
+        };
+        return L[n].call(e.exports, e, e.exports, A), e.l = !0, e.exports;
+      }
+      return A.m = L, A.c = m, A.i = function(n) {
+        return n;
+      }, A.d = function(n, e, t) {
+        A.o(n, e) || Object.defineProperty(n, e, {
+          configurable: !1,
+          enumerable: !0,
+          get: t
+        });
+      }, A.n = function(n) {
+        var e = n && n.__esModule ? function() {
+          return n.default;
+        } : function() {
+          return n;
+        };
+        return A.d(e, "a", e), e;
+      }, A.o = function(n, e) {
+        return Object.prototype.hasOwnProperty.call(n, e);
+      }, A.p = "", A(A.s = 26);
+    })([
+      (function(L, m, A) {
+        function n() {
+        }
+        n.QUALITY = 1, n.DEFAULT_CREATE_BENDS_AS_NEEDED = !1, n.DEFAULT_INCREMENTAL = !1, n.DEFAULT_ANIMATION_ON_LAYOUT = !0, n.DEFAULT_ANIMATION_DURING_LAYOUT = !1, n.DEFAULT_ANIMATION_PERIOD = 50, n.DEFAULT_UNIFORM_LEAF_NODE_SIZES = !1, n.DEFAULT_GRAPH_MARGIN = 15, n.NODE_DIMENSIONS_INCLUDE_LABELS = !1, n.SIMPLE_NODE_SIZE = 40, n.SIMPLE_NODE_HALF_SIZE = n.SIMPLE_NODE_SIZE / 2, n.EMPTY_COMPOUND_NODE_SIZE = 40, n.MIN_EDGE_LENGTH = 1, n.WORLD_BOUNDARY = 1e6, n.INITIAL_WORLD_BOUNDARY = n.WORLD_BOUNDARY / 1e3, n.WORLD_CENTER_X = 1200, n.WORLD_CENTER_Y = 900, L.exports = n;
+      }),
+      (function(L, m, A) {
+        var n = A(2), e = A(8), t = A(9);
+        function i(h, o, N) {
+          n.call(this, N), this.isOverlapingSourceAndTarget = !1, this.vGraphObject = N, this.bendpoints = [], this.source = h, this.target = o;
+        }
+        for (var r in i.prototype = Object.create(n.prototype), n) i[r] = n[r];
+        i.prototype.getSource = function() {
+          return this.source;
+        }, i.prototype.getTarget = function() {
+          return this.target;
+        }, i.prototype.isInterGraph = function() {
+          return this.isInterGraph;
+        }, i.prototype.getLength = function() {
+          return this.length;
+        }, i.prototype.isOverlapingSourceAndTarget = function() {
+          return this.isOverlapingSourceAndTarget;
+        }, i.prototype.getBendpoints = function() {
+          return this.bendpoints;
+        }, i.prototype.getLca = function() {
+          return this.lca;
+        }, i.prototype.getSourceInLca = function() {
+          return this.sourceInLca;
+        }, i.prototype.getTargetInLca = function() {
+          return this.targetInLca;
+        }, i.prototype.getOtherEnd = function(h) {
+          if (this.source === h) return this.target;
+          if (this.target === h) return this.source;
+          throw "Node is not incident with this edge";
+        }, i.prototype.getOtherEndInGraph = function(h, o) {
+          for (var N = this.getOtherEnd(h), s = o.getGraphManager().getRoot(); ; ) {
+            if (N.getOwner() == o) return N;
+            if (N.getOwner() == s) break;
+            N = N.getOwner().getParent();
+          }
+          return null;
+        }, i.prototype.updateLength = function() {
+          var h = [
+            ,
+            ,
+            ,
+            ,
+          ];
+          this.isOverlapingSourceAndTarget = e.getIntersection(this.target.getRect(), this.source.getRect(), h), this.isOverlapingSourceAndTarget || (this.lengthX = h[0] - h[2], this.lengthY = h[1] - h[3], Math.abs(this.lengthX) < 1 && (this.lengthX = t.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = t.sign(this.lengthY)), this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY));
+        }, i.prototype.updateLengthSimple = function() {
+          this.lengthX = this.target.getCenterX() - this.source.getCenterX(), this.lengthY = this.target.getCenterY() - this.source.getCenterY(), Math.abs(this.lengthX) < 1 && (this.lengthX = t.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = t.sign(this.lengthY)), this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+        }, L.exports = i;
+      }),
+      (function(L, m, A) {
+        function n(e) {
+          this.vGraphObject = e;
+        }
+        L.exports = n;
+      }),
+      (function(L, m, A) {
+        var n = A(2), e = A(10), t = A(13), i = A(0), r = A(16), h = A(4);
+        function o(s, g, u, p) {
+          u == null && p == null && (p = g), n.call(this, p), s.graphManager != null && (s = s.graphManager), this.estimatedSize = e.MIN_VALUE, this.inclusionTreeDepth = e.MAX_VALUE, this.vGraphObject = p, this.edges = [], this.graphManager = s, u != null && g != null ? this.rect = new t(g.x, g.y, u.width, u.height) : this.rect = new t();
+        }
+        for (var N in o.prototype = Object.create(n.prototype), n) o[N] = n[N];
+        o.prototype.getEdges = function() {
+          return this.edges;
+        }, o.prototype.getChild = function() {
+          return this.child;
+        }, o.prototype.getOwner = function() {
+          return this.owner;
+        }, o.prototype.getWidth = function() {
+          return this.rect.width;
+        }, o.prototype.setWidth = function(s) {
+          this.rect.width = s;
+        }, o.prototype.getHeight = function() {
+          return this.rect.height;
+        }, o.prototype.setHeight = function(s) {
+          this.rect.height = s;
+        }, o.prototype.getCenterX = function() {
+          return this.rect.x + this.rect.width / 2;
+        }, o.prototype.getCenterY = function() {
+          return this.rect.y + this.rect.height / 2;
+        }, o.prototype.getCenter = function() {
+          return new h(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2);
+        }, o.prototype.getLocation = function() {
+          return new h(this.rect.x, this.rect.y);
+        }, o.prototype.getRect = function() {
+          return this.rect;
+        }, o.prototype.getDiagonal = function() {
+          return Math.sqrt(this.rect.width * this.rect.width + this.rect.height * this.rect.height);
+        }, o.prototype.getHalfTheDiagonal = function() {
+          return Math.sqrt(this.rect.height * this.rect.height + this.rect.width * this.rect.width) / 2;
+        }, o.prototype.setRect = function(s, g) {
+          this.rect.x = s.x, this.rect.y = s.y, this.rect.width = g.width, this.rect.height = g.height;
+        }, o.prototype.setCenter = function(s, g) {
+          this.rect.x = s - this.rect.width / 2, this.rect.y = g - this.rect.height / 2;
+        }, o.prototype.setLocation = function(s, g) {
+          this.rect.x = s, this.rect.y = g;
+        }, o.prototype.moveBy = function(s, g) {
+          this.rect.x += s, this.rect.y += g;
+        }, o.prototype.getEdgeListToNode = function(s) {
+          var g = [], u = this;
+          return u.edges.forEach(function(p) {
+            if (p.target == s) {
+              if (p.source != u) throw "Incorrect edge source!";
+              g.push(p);
+            }
+          }), g;
+        }, o.prototype.getEdgesBetween = function(s) {
+          var g = [], u = this;
+          return u.edges.forEach(function(p) {
+            if (!(p.source == u || p.target == u)) throw "Incorrect edge source and/or target";
+            (p.target == s || p.source == s) && g.push(p);
+          }), g;
+        }, o.prototype.getNeighborsList = function() {
+          var s = /* @__PURE__ */ new Set(), g = this;
+          return g.edges.forEach(function(u) {
+            if (u.source == g) s.add(u.target);
+            else {
+              if (u.target != g) throw "Incorrect incidency!";
+              s.add(u.source);
+            }
+          }), s;
+        }, o.prototype.withChildren = function() {
+          var s = /* @__PURE__ */ new Set(), g, u;
+          if (s.add(this), this.child != null) for (var p = this.child.getNodes(), y = 0; y < p.length; y++) g = p[y], u = g.withChildren(), u.forEach(function(c) {
+            s.add(c);
+          });
+          return s;
+        }, o.prototype.getNoOfChildren = function() {
+          var s = 0, g;
+          if (this.child == null) s = 1;
+          else for (var u = this.child.getNodes(), p = 0; p < u.length; p++) g = u[p], s += g.getNoOfChildren();
+          return s == 0 && (s = 1), s;
+        }, o.prototype.getEstimatedSize = function() {
+          if (this.estimatedSize == e.MIN_VALUE) throw "assert failed";
+          return this.estimatedSize;
+        }, o.prototype.calcEstimatedSize = function() {
+          return this.child == null ? this.estimatedSize = (this.rect.width + this.rect.height) / 2 : (this.estimatedSize = this.child.calcEstimatedSize(), this.rect.width = this.estimatedSize, this.rect.height = this.estimatedSize, this.estimatedSize);
+        }, o.prototype.scatter = function() {
+          var s, g, u = -i.INITIAL_WORLD_BOUNDARY, p = i.INITIAL_WORLD_BOUNDARY;
+          s = i.WORLD_CENTER_X + r.nextDouble() * (p - u) + u;
+          var y = -i.INITIAL_WORLD_BOUNDARY, c = i.INITIAL_WORLD_BOUNDARY;
+          g = i.WORLD_CENTER_Y + r.nextDouble() * (c - y) + y, this.rect.x = s, this.rect.y = g;
+        }, o.prototype.updateBounds = function() {
+          if (this.getChild() == null) throw "assert failed";
+          if (this.getChild().getNodes().length != 0) {
+            var s = this.getChild();
+            if (s.updateBounds(!0), this.rect.x = s.getLeft(), this.rect.y = s.getTop(), this.setWidth(s.getRight() - s.getLeft()), this.setHeight(s.getBottom() - s.getTop()), i.NODE_DIMENSIONS_INCLUDE_LABELS) {
+              var g = s.getRight() - s.getLeft(), u = s.getBottom() - s.getTop();
+              this.labelWidth > g && (this.rect.x -= (this.labelWidth - g) / 2, this.setWidth(this.labelWidth)), this.labelHeight > u && (this.labelPos == "center" ? this.rect.y -= (this.labelHeight - u) / 2 : this.labelPos == "top" && (this.rect.y -= this.labelHeight - u), this.setHeight(this.labelHeight));
+            }
+          }
+        }, o.prototype.getInclusionTreeDepth = function() {
+          if (this.inclusionTreeDepth == e.MAX_VALUE) throw "assert failed";
+          return this.inclusionTreeDepth;
+        }, o.prototype.transform = function(s) {
+          var g = this.rect.x;
+          g > i.WORLD_BOUNDARY ? g = i.WORLD_BOUNDARY : g < -i.WORLD_BOUNDARY && (g = -i.WORLD_BOUNDARY);
+          var u = this.rect.y;
+          u > i.WORLD_BOUNDARY ? u = i.WORLD_BOUNDARY : u < -i.WORLD_BOUNDARY && (u = -i.WORLD_BOUNDARY);
+          var p = new h(g, u), y = s.inverseTransformPoint(p);
+          this.setLocation(y.x, y.y);
+        }, o.prototype.getLeft = function() {
+          return this.rect.x;
+        }, o.prototype.getRight = function() {
+          return this.rect.x + this.rect.width;
+        }, o.prototype.getTop = function() {
+          return this.rect.y;
+        }, o.prototype.getBottom = function() {
+          return this.rect.y + this.rect.height;
+        }, o.prototype.getParent = function() {
+          return this.owner == null ? null : this.owner.getParent();
+        }, L.exports = o;
+      }),
+      (function(L, m, A) {
+        function n(e, t) {
+          e == null && t == null ? (this.x = 0, this.y = 0) : (this.x = e, this.y = t);
+        }
+        n.prototype.getX = function() {
+          return this.x;
+        }, n.prototype.getY = function() {
+          return this.y;
+        }, n.prototype.setX = function(e) {
+          this.x = e;
+        }, n.prototype.setY = function(e) {
+          this.y = e;
+        }, n.prototype.getDifference = function(e) {
+          return new DimensionD(this.x - e.x, this.y - e.y);
+        }, n.prototype.getCopy = function() {
+          return new n(this.x, this.y);
+        }, n.prototype.translate = function(e) {
+          return this.x += e.width, this.y += e.height, this;
+        }, L.exports = n;
+      }),
+      (function(L, m, A) {
+        var n = A(2), e = A(10), t = A(0), i = A(6), r = A(3), h = A(1), o = A(13), N = A(12), s = A(11);
+        function g(p, y, c) {
+          n.call(this, c), this.estimatedSize = e.MIN_VALUE, this.margin = t.DEFAULT_GRAPH_MARGIN, this.edges = [], this.nodes = [], this.isConnected = !1, this.parent = p, y != null && y instanceof i ? this.graphManager = y : y != null && y instanceof Layout && (this.graphManager = y.graphManager);
+        }
+        for (var u in g.prototype = Object.create(n.prototype), n) g[u] = n[u];
+        g.prototype.getNodes = function() {
+          return this.nodes;
+        }, g.prototype.getEdges = function() {
+          return this.edges;
+        }, g.prototype.getGraphManager = function() {
+          return this.graphManager;
+        }, g.prototype.getParent = function() {
+          return this.parent;
+        }, g.prototype.getLeft = function() {
+          return this.left;
+        }, g.prototype.getRight = function() {
+          return this.right;
+        }, g.prototype.getTop = function() {
+          return this.top;
+        }, g.prototype.getBottom = function() {
+          return this.bottom;
+        }, g.prototype.isConnected = function() {
+          return this.isConnected;
+        }, g.prototype.add = function(p, y, c) {
+          if (y == null && c == null) {
+            var f = p;
+            if (this.graphManager == null) throw "Graph has no graph mgr!";
+            if (this.getNodes().indexOf(f) > -1) throw "Node already in graph!";
+            return f.owner = this, this.getNodes().push(f), f;
+          } else {
+            var T = p;
+            if (!(this.getNodes().indexOf(y) > -1 && this.getNodes().indexOf(c) > -1)) throw "Source or target not in graph!";
+            if (!(y.owner == c.owner && y.owner == this)) throw "Both owners must be this graph!";
+            return y.owner == c.owner ? (T.source = y, T.target = c, T.isInterGraph = !1, this.getEdges().push(T), y.edges.push(T), c != y && c.edges.push(T), T) : null;
+          }
+        }, g.prototype.remove = function(p) {
+          var y = p;
+          if (p instanceof r) {
+            if (y == null) throw "Node is null!";
+            if (!(y.owner != null && y.owner == this)) throw "Owner graph is invalid!";
+            if (this.graphManager == null) throw "Owner graph manager is invalid!";
+            for (var c = y.edges.slice(), f, T = c.length, E = 0; E < T; E++) f = c[E], f.isInterGraph ? this.graphManager.remove(f) : f.source.owner.remove(f);
+            var O = this.nodes.indexOf(y);
+            if (O == -1) throw "Node not in owner node list!";
+            this.nodes.splice(O, 1);
+          } else if (p instanceof h) {
+            var f = p;
+            if (f == null) throw "Edge is null!";
+            if (!(f.source != null && f.target != null)) throw "Source and/or target is null!";
+            if (!(f.source.owner != null && f.target.owner != null && f.source.owner == this && f.target.owner == this)) throw "Source and/or target owner is invalid!";
+            var a = f.source.edges.indexOf(f), d = f.target.edges.indexOf(f);
+            if (!(a > -1 && d > -1)) throw "Source and/or target doesn't know this edge!";
+            f.source.edges.splice(a, 1), f.target != f.source && f.target.edges.splice(d, 1);
+            var O = f.source.owner.getEdges().indexOf(f);
+            if (O == -1) throw "Not in owner's edge list!";
+            f.source.owner.getEdges().splice(O, 1);
+          }
+        }, g.prototype.updateLeftTop = function() {
+          for (var p = e.MAX_VALUE, y = e.MAX_VALUE, c, f, T, E = this.getNodes(), O = E.length, a = 0; a < O; a++) {
+            var d = E[a];
+            c = d.getTop(), f = d.getLeft(), p > c && (p = c), y > f && (y = f);
+          }
+          return p == e.MAX_VALUE ? null : (T = E[0].getParent().paddingLeft == null ? this.margin : E[0].getParent().paddingLeft, this.left = y - T, this.top = p - T, new N(this.left, this.top));
+        }, g.prototype.updateBounds = function(p) {
+          for (var y = e.MAX_VALUE, c = -e.MAX_VALUE, f = e.MAX_VALUE, T = -e.MAX_VALUE, E, O, a, d, l, v = this.nodes, _ = v.length, D = 0; D < _; D++) {
+            var I = v[D];
+            p && I.child != null && I.updateBounds(), E = I.getLeft(), O = I.getRight(), a = I.getTop(), d = I.getBottom(), y > E && (y = E), c < O && (c = O), f > a && (f = a), T < d && (T = d);
+          }
+          var w = new o(y, f, c - y, T - f);
+          y == e.MAX_VALUE && (this.left = this.parent.getLeft(), this.right = this.parent.getRight(), this.top = this.parent.getTop(), this.bottom = this.parent.getBottom()), l = v[0].getParent().paddingLeft == null ? this.margin : v[0].getParent().paddingLeft, this.left = w.x - l, this.right = w.x + w.width + l, this.top = w.y - l, this.bottom = w.y + w.height + l;
+        }, g.calculateBounds = function(p) {
+          for (var y = e.MAX_VALUE, c = -e.MAX_VALUE, f = e.MAX_VALUE, T = -e.MAX_VALUE, E, O, a, d, l = p.length, v = 0; v < l; v++) {
+            var _ = p[v];
+            E = _.getLeft(), O = _.getRight(), a = _.getTop(), d = _.getBottom(), y > E && (y = E), c < O && (c = O), f > a && (f = a), T < d && (T = d);
+          }
+          return new o(y, f, c - y, T - f);
+        }, g.prototype.getInclusionTreeDepth = function() {
+          return this == this.graphManager.getRoot() ? 1 : this.parent.getInclusionTreeDepth();
+        }, g.prototype.getEstimatedSize = function() {
+          if (this.estimatedSize == e.MIN_VALUE) throw "assert failed";
+          return this.estimatedSize;
+        }, g.prototype.calcEstimatedSize = function() {
+          for (var p = 0, y = this.nodes, c = y.length, f = 0; f < c; f++) {
+            var T = y[f];
+            p += T.calcEstimatedSize();
+          }
+          return p == 0 ? this.estimatedSize = t.EMPTY_COMPOUND_NODE_SIZE : this.estimatedSize = p / Math.sqrt(this.nodes.length), this.estimatedSize;
+        }, g.prototype.updateConnected = function() {
+          var p = this;
+          if (this.nodes.length == 0) {
+            this.isConnected = !0;
+            return;
+          }
+          var y = new s(), c = /* @__PURE__ */ new Set(), f = this.nodes[0], T, E;
+          for (f.withChildren().forEach(function(l) {
+            y.push(l), c.add(l);
+          }); y.length !== 0; ) {
+            f = y.shift(), T = f.getEdges();
+            for (var O = T.length, a = 0; a < O; a++) E = T[a].getOtherEndInGraph(f, this), E != null && !c.has(E) && E.withChildren().forEach(function(l) {
+              y.push(l), c.add(l);
+            });
+          }
+          if (this.isConnected = !1, c.size >= this.nodes.length) {
+            var d = 0;
+            c.forEach(function(l) {
+              l.owner == p && d++;
+            }), d == this.nodes.length && (this.isConnected = !0);
+          }
+        }, L.exports = g;
+      }),
+      (function(L, m, A) {
+        var n, e = A(1);
+        function t(i) {
+          n = A(5), this.layout = i, this.graphs = [], this.edges = [];
+        }
+        t.prototype.addRoot = function() {
+          var i = this.layout.newGraph(), r = this.layout.newNode(null), h = this.add(i, r);
+          return this.setRootGraph(h), this.rootGraph;
+        }, t.prototype.add = function(i, r, h, o, N) {
+          if (h == null && o == null && N == null) {
+            if (i == null) throw "Graph is null!";
+            if (r == null) throw "Parent node is null!";
+            if (this.graphs.indexOf(i) > -1) throw "Graph already in this graph mgr!";
+            if (this.graphs.push(i), i.parent != null) throw "Already has a parent!";
+            if (r.child != null) throw "Already has a child!";
+            return i.parent = r, r.child = i, i;
+          } else {
+            N = h, o = r, h = i;
+            var s = o.getOwner(), g = N.getOwner();
+            if (!(s != null && s.getGraphManager() == this)) throw "Source not in this graph mgr!";
+            if (!(g != null && g.getGraphManager() == this)) throw "Target not in this graph mgr!";
+            if (s == g) return h.isInterGraph = !1, s.add(h, o, N);
+            if (h.isInterGraph = !0, h.source = o, h.target = N, this.edges.indexOf(h) > -1) throw "Edge already in inter-graph edge list!";
+            if (this.edges.push(h), !(h.source != null && h.target != null)) throw "Edge source and/or target is null!";
+            if (!(h.source.edges.indexOf(h) == -1 && h.target.edges.indexOf(h) == -1)) throw "Edge already in source and/or target incidency list!";
+            return h.source.edges.push(h), h.target.edges.push(h), h;
+          }
+        }, t.prototype.remove = function(i) {
+          if (i instanceof n) {
+            var r = i;
+            if (r.getGraphManager() != this) throw "Graph not in this graph mgr";
+            if (!(r == this.rootGraph || r.parent != null && r.parent.graphManager == this)) throw "Invalid parent node!";
+            var h = [];
+            h = h.concat(r.getEdges());
+            for (var o, N = h.length, s = 0; s < N; s++) o = h[s], r.remove(o);
+            var g = [];
+            g = g.concat(r.getNodes());
+            var u;
+            N = g.length;
+            for (var s = 0; s < N; s++) u = g[s], r.remove(u);
+            r == this.rootGraph && this.setRootGraph(null);
+            var p = this.graphs.indexOf(r);
+            this.graphs.splice(p, 1), r.parent = null;
+          } else if (i instanceof e) {
+            if (o = i, o == null) throw "Edge is null!";
+            if (!o.isInterGraph) throw "Not an inter-graph edge!";
+            if (!(o.source != null && o.target != null)) throw "Source and/or target is null!";
+            if (!(o.source.edges.indexOf(o) != -1 && o.target.edges.indexOf(o) != -1)) throw "Source and/or target doesn't know this edge!";
+            var p = o.source.edges.indexOf(o);
+            if (o.source.edges.splice(p, 1), p = o.target.edges.indexOf(o), o.target.edges.splice(p, 1), !(o.source.owner != null && o.source.owner.getGraphManager() != null)) throw "Edge owner graph or owner graph manager is null!";
+            if (o.source.owner.getGraphManager().edges.indexOf(o) == -1) throw "Not in owner graph manager's edge list!";
+            var p = o.source.owner.getGraphManager().edges.indexOf(o);
+            o.source.owner.getGraphManager().edges.splice(p, 1);
+          }
+        }, t.prototype.updateBounds = function() {
+          this.rootGraph.updateBounds(!0);
+        }, t.prototype.getGraphs = function() {
+          return this.graphs;
+        }, t.prototype.getAllNodes = function() {
+          if (this.allNodes == null) {
+            for (var i = [], r = this.getGraphs(), h = r.length, o = 0; o < h; o++) i = i.concat(r[o].getNodes());
+            this.allNodes = i;
+          }
+          return this.allNodes;
+        }, t.prototype.resetAllNodes = function() {
+          this.allNodes = null;
+        }, t.prototype.resetAllEdges = function() {
+          this.allEdges = null;
+        }, t.prototype.resetAllNodesToApplyGravitation = function() {
+          this.allNodesToApplyGravitation = null;
+        }, t.prototype.getAllEdges = function() {
+          if (this.allEdges == null) {
+            var i = [], r = this.getGraphs();
+            r.length;
+            for (var h = 0; h < r.length; h++) i = i.concat(r[h].getEdges());
+            i = i.concat(this.edges), this.allEdges = i;
+          }
+          return this.allEdges;
+        }, t.prototype.getAllNodesToApplyGravitation = function() {
+          return this.allNodesToApplyGravitation;
+        }, t.prototype.setAllNodesToApplyGravitation = function(i) {
+          if (this.allNodesToApplyGravitation != null) throw "assert failed";
+          this.allNodesToApplyGravitation = i;
+        }, t.prototype.getRoot = function() {
+          return this.rootGraph;
+        }, t.prototype.setRootGraph = function(i) {
+          if (i.getGraphManager() != this) throw "Root not in this graph mgr!";
+          this.rootGraph = i, i.parent ??= this.layout.newNode("Root node");
+        }, t.prototype.getLayout = function() {
+          return this.layout;
+        }, t.prototype.isOneAncestorOfOther = function(i, r) {
+          if (!(i != null && r != null)) throw "assert failed";
+          if (i == r) return !0;
+          var h = i.getOwner(), o;
+          do {
+            if (o = h.getParent(), o == null) break;
+            if (o == r) return !0;
+            if (h = o.getOwner(), h == null) break;
+          } while (!0);
+          h = r.getOwner();
+          do {
+            if (o = h.getParent(), o == null) break;
+            if (o == i) return !0;
+            if (h = o.getOwner(), h == null) break;
+          } while (!0);
+          return !1;
+        }, t.prototype.calcLowestCommonAncestors = function() {
+          for (var i, r, h, o, N, s = this.getAllEdges(), g = s.length, u = 0; u < g; u++) {
+            if (i = s[u], r = i.source, h = i.target, i.lca = null, i.sourceInLca = r, i.targetInLca = h, r == h) {
+              i.lca = r.getOwner();
+              continue;
+            }
+            for (o = r.getOwner(); i.lca == null; ) {
+              for (i.targetInLca = h, N = h.getOwner(); i.lca == null; ) {
+                if (N == o) {
+                  i.lca = N;
+                  break;
+                }
+                if (N == this.rootGraph) break;
+                if (i.lca != null) throw "assert failed";
+                i.targetInLca = N.getParent(), N = i.targetInLca.getOwner();
+              }
+              if (o == this.rootGraph) break;
+              i.lca ?? (i.sourceInLca = o.getParent(), o = i.sourceInLca.getOwner());
+            }
+            if (i.lca == null) throw "assert failed";
+          }
+        }, t.prototype.calcLowestCommonAncestor = function(i, r) {
+          if (i == r) return i.getOwner();
+          var h = i.getOwner();
+          do {
+            if (h == null) break;
+            var o = r.getOwner();
+            do {
+              if (o == null) break;
+              if (o == h) return o;
+              o = o.getParent().getOwner();
+            } while (!0);
+            h = h.getParent().getOwner();
+          } while (!0);
+          return h;
+        }, t.prototype.calcInclusionTreeDepths = function(i, r) {
+          i == null && r == null && (i = this.rootGraph, r = 1);
+          for (var h, o = i.getNodes(), N = o.length, s = 0; s < N; s++) h = o[s], h.inclusionTreeDepth = r, h.child != null && this.calcInclusionTreeDepths(h.child, r + 1);
+        }, t.prototype.includesInvalidEdge = function() {
+          for (var i, r = this.edges.length, h = 0; h < r; h++) if (i = this.edges[h], this.isOneAncestorOfOther(i.source, i.target)) return !0;
+          return !1;
+        }, L.exports = t;
+      }),
+      (function(L, m, A) {
+        var n = A(0);
+        function e() {
+        }
+        for (var t in n) e[t] = n[t];
+        e.MAX_ITERATIONS = 2500, e.DEFAULT_EDGE_LENGTH = 50, e.DEFAULT_SPRING_STRENGTH = 0.45, e.DEFAULT_REPULSION_STRENGTH = 4500, e.DEFAULT_GRAVITY_STRENGTH = 0.4, e.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1, e.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8, e.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5, e.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = !0, e.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = !0, e.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3, e.COOLING_ADAPTATION_FACTOR = 0.33, e.ADAPTATION_LOWER_NODE_LIMIT = 1e3, e.ADAPTATION_UPPER_NODE_LIMIT = 5e3, e.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100, e.MAX_NODE_DISPLACEMENT = e.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3, e.MIN_REPULSION_DIST = e.DEFAULT_EDGE_LENGTH / 10, e.CONVERGENCE_CHECK_PERIOD = 100, e.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1, e.MIN_EDGE_LENGTH = 1, e.GRID_CALCULATION_CHECK_PERIOD = 10, L.exports = e;
+      }),
+      (function(L, m, A) {
+        var n = A(12);
+        function e() {
+        }
+        e.calcSeparationAmount = function(t, i, r, h) {
+          if (!t.intersects(i)) throw "assert failed";
+          var o = [, ,];
+          this.decideDirectionsForOverlappingNodes(t, i, o), r[0] = Math.min(t.getRight(), i.getRight()) - Math.max(t.x, i.x), r[1] = Math.min(t.getBottom(), i.getBottom()) - Math.max(t.y, i.y), t.getX() <= i.getX() && t.getRight() >= i.getRight() ? r[0] += Math.min(i.getX() - t.getX(), t.getRight() - i.getRight()) : i.getX() <= t.getX() && i.getRight() >= t.getRight() && (r[0] += Math.min(t.getX() - i.getX(), i.getRight() - t.getRight())), t.getY() <= i.getY() && t.getBottom() >= i.getBottom() ? r[1] += Math.min(i.getY() - t.getY(), t.getBottom() - i.getBottom()) : i.getY() <= t.getY() && i.getBottom() >= t.getBottom() && (r[1] += Math.min(t.getY() - i.getY(), i.getBottom() - t.getBottom()));
+          var N = Math.abs((i.getCenterY() - t.getCenterY()) / (i.getCenterX() - t.getCenterX()));
+          i.getCenterY() === t.getCenterY() && i.getCenterX() === t.getCenterX() && (N = 1);
+          var s = N * r[0], g = r[1] / N;
+          r[0] < g ? g = r[0] : s = r[1], r[0] = -1 * o[0] * (g / 2 + h), r[1] = -1 * o[1] * (s / 2 + h);
+        }, e.decideDirectionsForOverlappingNodes = function(t, i, r) {
+          t.getCenterX() < i.getCenterX() ? r[0] = -1 : r[0] = 1, t.getCenterY() < i.getCenterY() ? r[1] = -1 : r[1] = 1;
+        }, e.getIntersection2 = function(t, i, r) {
+          var h = t.getCenterX(), o = t.getCenterY(), N = i.getCenterX(), s = i.getCenterY();
+          if (t.intersects(i)) return r[0] = h, r[1] = o, r[2] = N, r[3] = s, !0;
+          var g = t.getX(), u = t.getY(), p = t.getRight(), y = t.getX(), c = t.getBottom(), f = t.getRight(), T = t.getWidthHalf(), E = t.getHeightHalf(), O = i.getX(), a = i.getY(), d = i.getRight(), l = i.getX(), v = i.getBottom(), _ = i.getRight(), D = i.getWidthHalf(), I = i.getHeightHalf(), w = !1, R = !1;
+          if (h === N) {
+            if (o > s) return r[0] = h, r[1] = u, r[2] = N, r[3] = v, !1;
+            if (o < s) return r[0] = h, r[1] = c, r[2] = N, r[3] = a, !1;
+          } else if (o === s) {
+            if (h > N) return r[0] = g, r[1] = o, r[2] = d, r[3] = s, !1;
+            if (h < N) return r[0] = p, r[1] = o, r[2] = O, r[3] = s, !1;
+          } else {
+            var G = t.height / t.width, x = i.height / i.width, M = (s - o) / (N - h), U = void 0, b = void 0, F = void 0, S = void 0, Y = void 0, X = void 0;
+            if (-G === M ? h > N ? (r[0] = y, r[1] = c, w = !0) : (r[0] = p, r[1] = u, w = !0) : G === M && (h > N ? (r[0] = g, r[1] = u, w = !0) : (r[0] = f, r[1] = c, w = !0)), -x === M ? N > h ? (r[2] = l, r[3] = v, R = !0) : (r[2] = d, r[3] = a, R = !0) : x === M && (N > h ? (r[2] = O, r[3] = a, R = !0) : (r[2] = _, r[3] = v, R = !0)), w && R) return !1;
+            if (h > N ? o > s ? (U = this.getCardinalDirection(G, M, 4), b = this.getCardinalDirection(x, M, 2)) : (U = this.getCardinalDirection(-G, M, 3), b = this.getCardinalDirection(-x, M, 1)) : o > s ? (U = this.getCardinalDirection(-G, M, 1), b = this.getCardinalDirection(-x, M, 3)) : (U = this.getCardinalDirection(G, M, 2), b = this.getCardinalDirection(x, M, 4)), !w) switch (U) {
+              case 1:
+                S = u, F = h + -E / M, r[0] = F, r[1] = S;
+                break;
+              case 2:
+                F = f, S = o + T * M, r[0] = F, r[1] = S;
+                break;
+              case 3:
+                S = c, F = h + E / M, r[0] = F, r[1] = S;
+                break;
+              case 4:
+                F = y, S = o + -T * M, r[0] = F, r[1] = S;
+                break;
+            }
+            if (!R) switch (b) {
+              case 1:
+                X = a, Y = N + -I / M, r[2] = Y, r[3] = X;
+                break;
+              case 2:
+                Y = _, X = s + D * M, r[2] = Y, r[3] = X;
+                break;
+              case 3:
+                X = v, Y = N + I / M, r[2] = Y, r[3] = X;
+                break;
+              case 4:
+                Y = l, X = s + -D * M, r[2] = Y, r[3] = X;
+                break;
+            }
+          }
+          return !1;
+        }, e.getCardinalDirection = function(t, i, r) {
+          return t > i ? r : 1 + r % 4;
+        }, e.getIntersection = function(t, i, r, h) {
+          if (h == null) return this.getIntersection2(t, i, r);
+          var o = t.x, N = t.y, s = i.x, g = i.y, u = r.x, p = r.y, y = h.x, c = h.y, f = void 0, T = void 0, E = void 0, O = void 0, a = void 0, d = void 0, l = void 0, v = void 0, _ = void 0;
+          return E = g - N, a = o - s, l = s * N - o * g, O = c - p, d = u - y, v = y * p - u * c, _ = E * d - O * a, _ === 0 ? null : (f = (a * v - d * l) / _, T = (O * l - E * v) / _, new n(f, T));
+        }, e.angleOfVector = function(t, i, r, h) {
+          var o = void 0;
+          return t === r ? o = h < i ? this.ONE_AND_HALF_PI : this.HALF_PI : (o = Math.atan((h - i) / (r - t)), r < t ? o += Math.PI : h < i && (o += this.TWO_PI)), o;
+        }, e.doIntersect = function(t, i, r, h) {
+          var o = t.x, N = t.y, s = i.x, g = i.y, u = r.x, p = r.y, y = h.x, c = h.y, f = (s - o) * (c - p) - (y - u) * (g - N);
+          if (f === 0) return !1;
+          var T = ((c - p) * (y - o) + (u - y) * (c - N)) / f, E = ((N - g) * (y - o) + (s - o) * (c - N)) / f;
+          return 0 < T && T < 1 && 0 < E && E < 1;
+        }, e.HALF_PI = 0.5 * Math.PI, e.ONE_AND_HALF_PI = 1.5 * Math.PI, e.TWO_PI = 2 * Math.PI, e.THREE_PI = 3 * Math.PI, L.exports = e;
+      }),
+      (function(L, m, A) {
+        function n() {
+        }
+        n.sign = function(e) {
+          return e > 0 ? 1 : e < 0 ? -1 : 0;
+        }, n.floor = function(e) {
+          return e < 0 ? Math.ceil(e) : Math.floor(e);
+        }, n.ceil = function(e) {
+          return e < 0 ? Math.floor(e) : Math.ceil(e);
+        }, L.exports = n;
+      }),
+      (function(L, m, A) {
+        function n() {
+        }
+        n.MAX_VALUE = 2147483647, n.MIN_VALUE = -2147483648, L.exports = n;
+      }),
+      (function(L, m, A) {
+        var n = /* @__PURE__ */ (function() {
+          function h(o, N) {
+            for (var s = 0; s < N.length; s++) {
+              var g = N[s];
+              g.enumerable = g.enumerable || !1, g.configurable = !0, "value" in g && (g.writable = !0), Object.defineProperty(o, g.key, g);
+            }
+          }
+          return function(o, N, s) {
+            return N && h(o.prototype, N), s && h(o, s), o;
+          };
+        })();
+        function e(h, o) {
+          if (!(h instanceof o)) throw TypeError("Cannot call a class as a function");
+        }
+        var t = function(h) {
+          return {
+            value: h,
+            next: null,
+            prev: null
+          };
+        }, i = function(h, o, N, s) {
+          return h === null ? s.head = o : h.next = o, N === null ? s.tail = o : N.prev = o, o.prev = h, o.next = N, s.length++, o;
+        }, r = function(h, o) {
+          var N = h.prev, s = h.next;
+          return N === null ? o.head = s : N.next = s, s === null ? o.tail = N : s.prev = N, h.prev = h.next = null, o.length--, h;
+        };
+        L.exports = (function() {
+          function h(o) {
+            var N = this;
+            e(this, h), this.length = 0, this.head = null, this.tail = null, o?.forEach(function(s) {
+              return N.push(s);
+            });
+          }
+          return n(h, [
+            {
+              key: "size",
+              value: function() {
+                return this.length;
+              }
+            },
+            {
+              key: "insertBefore",
+              value: function(o, N) {
+                return i(N.prev, t(o), N, this);
+              }
+            },
+            {
+              key: "insertAfter",
+              value: function(o, N) {
+                return i(N, t(o), N.next, this);
+              }
+            },
+            {
+              key: "insertNodeBefore",
+              value: function(o, N) {
+                return i(N.prev, o, N, this);
+              }
+            },
+            {
+              key: "insertNodeAfter",
+              value: function(o, N) {
+                return i(N, o, N.next, this);
+              }
+            },
+            {
+              key: "push",
+              value: function(o) {
+                return i(this.tail, t(o), null, this);
+              }
+            },
+            {
+              key: "unshift",
+              value: function(o) {
+                return i(null, t(o), this.head, this);
+              }
+            },
+            {
+              key: "remove",
+              value: function(o) {
+                return r(o, this);
+              }
+            },
+            {
+              key: "pop",
+              value: function() {
+                return r(this.tail, this).value;
+              }
+            },
+            {
+              key: "popNode",
+              value: function() {
+                return r(this.tail, this);
+              }
+            },
+            {
+              key: "shift",
+              value: function() {
+                return r(this.head, this).value;
+              }
+            },
+            {
+              key: "shiftNode",
+              value: function() {
+                return r(this.head, this);
+              }
+            },
+            {
+              key: "get_object_at",
+              value: function(o) {
+                if (o <= this.length()) {
+                  for (var N = 1, s = this.head; N < o; ) s = s.next, N++;
+                  return s.value;
+                }
+              }
+            },
+            {
+              key: "set_object_at",
+              value: function(o, N) {
+                if (o <= this.length()) {
+                  for (var s = 1, g = this.head; s < o; ) g = g.next, s++;
+                  g.value = N;
+                }
+              }
+            }
+          ]), h;
+        })();
+      }),
+      (function(L, m, A) {
+        function n(e, t, i) {
+          this.x = null, this.y = null, e == null && t == null && i == null ? (this.x = 0, this.y = 0) : typeof e == "number" && typeof t == "number" && i == null ? (this.x = e, this.y = t) : e.constructor.name == "Point" && t == null && i == null && (i = e, this.x = i.x, this.y = i.y);
+        }
+        n.prototype.getX = function() {
+          return this.x;
+        }, n.prototype.getY = function() {
+          return this.y;
+        }, n.prototype.getLocation = function() {
+          return new n(this.x, this.y);
+        }, n.prototype.setLocation = function(e, t, i) {
+          e.constructor.name == "Point" && t == null && i == null ? (i = e, this.setLocation(i.x, i.y)) : typeof e == "number" && typeof t == "number" && i == null && (parseInt(e) == e && parseInt(t) == t ? this.move(e, t) : (this.x = Math.floor(e + 0.5), this.y = Math.floor(t + 0.5)));
+        }, n.prototype.move = function(e, t) {
+          this.x = e, this.y = t;
+        }, n.prototype.translate = function(e, t) {
+          this.x += e, this.y += t;
+        }, n.prototype.equals = function(e) {
+          if (e.constructor.name == "Point") {
+            var t = e;
+            return this.x == t.x && this.y == t.y;
+          }
+          return this == e;
+        }, n.prototype.toString = function() {
+          return new n().constructor.name + "[x=" + this.x + ",y=" + this.y + "]";
+        }, L.exports = n;
+      }),
+      (function(L, m, A) {
+        function n(e, t, i, r) {
+          this.x = 0, this.y = 0, this.width = 0, this.height = 0, e != null && t != null && i != null && r != null && (this.x = e, this.y = t, this.width = i, this.height = r);
+        }
+        n.prototype.getX = function() {
+          return this.x;
+        }, n.prototype.setX = function(e) {
+          this.x = e;
+        }, n.prototype.getY = function() {
+          return this.y;
+        }, n.prototype.setY = function(e) {
+          this.y = e;
+        }, n.prototype.getWidth = function() {
+          return this.width;
+        }, n.prototype.setWidth = function(e) {
+          this.width = e;
+        }, n.prototype.getHeight = function() {
+          return this.height;
+        }, n.prototype.setHeight = function(e) {
+          this.height = e;
+        }, n.prototype.getRight = function() {
+          return this.x + this.width;
+        }, n.prototype.getBottom = function() {
+          return this.y + this.height;
+        }, n.prototype.intersects = function(e) {
+          return !(this.getRight() < e.x || this.getBottom() < e.y || e.getRight() < this.x || e.getBottom() < this.y);
+        }, n.prototype.getCenterX = function() {
+          return this.x + this.width / 2;
+        }, n.prototype.getMinX = function() {
+          return this.getX();
+        }, n.prototype.getMaxX = function() {
+          return this.getX() + this.width;
+        }, n.prototype.getCenterY = function() {
+          return this.y + this.height / 2;
+        }, n.prototype.getMinY = function() {
+          return this.getY();
+        }, n.prototype.getMaxY = function() {
+          return this.getY() + this.height;
+        }, n.prototype.getWidthHalf = function() {
+          return this.width / 2;
+        }, n.prototype.getHeightHalf = function() {
+          return this.height / 2;
+        }, L.exports = n;
+      }),
+      (function(L, m, A) {
+        var n = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+          return typeof t;
+        } : function(t) {
+          return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+        };
+        function e() {
+        }
+        e.lastID = 0, e.createID = function(t) {
+          return e.isPrimitive(t) ? t : (t.uniqueID == null && (t.uniqueID = e.getString(), e.lastID++), t.uniqueID);
+        }, e.getString = function(t) {
+          return t ??= e.lastID, "Object#" + t;
+        }, e.isPrimitive = function(t) {
+          var i = t === void 0 ? "undefined" : n(t);
+          return t == null || i != "object" && i != "function";
+        }, L.exports = e;
+      }),
+      (function(L, m, A) {
+        function n(u) {
+          if (Array.isArray(u)) {
+            for (var p = 0, y = Array(u.length); p < u.length; p++) y[p] = u[p];
+            return y;
+          } else return Array.from(u);
+        }
+        var e = A(0), t = A(6), i = A(3), r = A(1), h = A(5), o = A(4), N = A(17), s = A(27);
+        function g(u) {
+          s.call(this), this.layoutQuality = e.QUALITY, this.createBendsAsNeeded = e.DEFAULT_CREATE_BENDS_AS_NEEDED, this.incremental = e.DEFAULT_INCREMENTAL, this.animationOnLayout = e.DEFAULT_ANIMATION_ON_LAYOUT, this.animationDuringLayout = e.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = e.DEFAULT_ANIMATION_PERIOD, this.uniformLeafNodeSizes = e.DEFAULT_UNIFORM_LEAF_NODE_SIZES, this.edgeToDummyNodes = /* @__PURE__ */ new Map(), this.graphManager = new t(this), this.isLayoutFinished = !1, this.isSubLayout = !1, this.isRemoteUse = !1, u != null && (this.isRemoteUse = u);
+        }
+        g.RANDOM_SEED = 1, g.prototype = Object.create(s.prototype), g.prototype.getGraphManager = function() {
+          return this.graphManager;
+        }, g.prototype.getAllNodes = function() {
+          return this.graphManager.getAllNodes();
+        }, g.prototype.getAllEdges = function() {
+          return this.graphManager.getAllEdges();
+        }, g.prototype.getAllNodesToApplyGravitation = function() {
+          return this.graphManager.getAllNodesToApplyGravitation();
+        }, g.prototype.newGraphManager = function() {
+          var u = new t(this);
+          return this.graphManager = u, u;
+        }, g.prototype.newGraph = function(u) {
+          return new h(null, this.graphManager, u);
+        }, g.prototype.newNode = function(u) {
+          return new i(this.graphManager, u);
+        }, g.prototype.newEdge = function(u) {
+          return new r(null, null, u);
+        }, g.prototype.checkLayoutSuccess = function() {
+          return this.graphManager.getRoot() == null || this.graphManager.getRoot().getNodes().length == 0 || this.graphManager.includesInvalidEdge();
+        }, g.prototype.runLayout = function() {
+          this.isLayoutFinished = !1, this.tilingPreLayout && this.tilingPreLayout(), this.initParameters();
+          var u = this.checkLayoutSuccess() ? !1 : this.layout();
+          return e.ANIMATE === "during" ? !1 : (u && (this.isSubLayout || this.doPostLayout()), this.tilingPostLayout && this.tilingPostLayout(), this.isLayoutFinished = !0, u);
+        }, g.prototype.doPostLayout = function() {
+          this.incremental || this.transform(), this.update();
+        }, g.prototype.update2 = function() {
+          if (this.createBendsAsNeeded && (this.createBendpointsFromDummyNodes(), this.graphManager.resetAllEdges()), !this.isRemoteUse) {
+            for (var u = this.graphManager.getAllEdges(), p = 0; p < u.length; p++) u[p];
+            for (var y = this.graphManager.getRoot().getNodes(), p = 0; p < y.length; p++) y[p];
+            this.update(this.graphManager.getRoot());
+          }
+        }, g.prototype.update = function(u) {
+          if (u == null) this.update2();
+          else if (u instanceof i) {
+            var p = u;
+            if (p.getChild() != null) for (var y = p.getChild().getNodes(), c = 0; c < y.length; c++) update(y[c]);
+            p.vGraphObject != null && p.vGraphObject.update(p);
+          } else if (u instanceof r) {
+            var f = u;
+            f.vGraphObject != null && f.vGraphObject.update(f);
+          } else if (u instanceof h) {
+            var T = u;
+            T.vGraphObject != null && T.vGraphObject.update(T);
+          }
+        }, g.prototype.initParameters = function() {
+          this.isSubLayout || (this.layoutQuality = e.QUALITY, this.animationDuringLayout = e.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = e.DEFAULT_ANIMATION_PERIOD, this.animationOnLayout = e.DEFAULT_ANIMATION_ON_LAYOUT, this.incremental = e.DEFAULT_INCREMENTAL, this.createBendsAsNeeded = e.DEFAULT_CREATE_BENDS_AS_NEEDED, this.uniformLeafNodeSizes = e.DEFAULT_UNIFORM_LEAF_NODE_SIZES), this.animationDuringLayout && (this.animationOnLayout = !1);
+        }, g.prototype.transform = function(u) {
+          if (u == null) this.transform(new o(0, 0));
+          else {
+            var p = new N(), y = this.graphManager.getRoot().updateLeftTop();
+            if (y != null) {
+              p.setWorldOrgX(u.x), p.setWorldOrgY(u.y), p.setDeviceOrgX(y.x), p.setDeviceOrgY(y.y);
+              for (var c = this.getAllNodes(), f, T = 0; T < c.length; T++) f = c[T], f.transform(p);
+            }
+          }
+        }, g.prototype.positionNodesRandomly = function(u) {
+          if (u == null) this.positionNodesRandomly(this.getGraphManager().getRoot()), this.getGraphManager().getRoot().updateBounds(!0);
+          else for (var p, y, c = u.getNodes(), f = 0; f < c.length; f++) p = c[f], y = p.getChild(), y == null || y.getNodes().length == 0 ? p.scatter() : (this.positionNodesRandomly(y), p.updateBounds());
+        }, g.prototype.getFlatForest = function() {
+          for (var u = [], p = !0, y = this.graphManager.getRoot().getNodes(), c = !0, f = 0; f < y.length; f++) y[f].getChild() != null && (c = !1);
+          if (!c) return u;
+          var T = /* @__PURE__ */ new Set(), E = [], O = /* @__PURE__ */ new Map(), a = [];
+          for (a = a.concat(y); a.length > 0 && p; ) {
+            for (E.push(a[0]); E.length > 0 && p; ) {
+              var d = E[0];
+              E.splice(0, 1), T.add(d);
+              for (var l = d.getEdges(), f = 0; f < l.length; f++) {
+                var v = l[f].getOtherEnd(d);
+                if (O.get(d) != v) if (!T.has(v)) E.push(v), O.set(v, d);
+                else {
+                  p = !1;
+                  break;
+                }
+              }
+            }
+            if (!p) u = [];
+            else {
+              var _ = [].concat(n(T));
+              u.push(_);
+              for (var f = 0; f < _.length; f++) {
+                var D = _[f], I = a.indexOf(D);
+                I > -1 && a.splice(I, 1);
+              }
+              T = /* @__PURE__ */ new Set(), O = /* @__PURE__ */ new Map();
+            }
+          }
+          return u;
+        }, g.prototype.createDummyNodesForBendpoints = function(u) {
+          for (var p = [], y = u.source, c = this.graphManager.calcLowestCommonAncestor(u.source, u.target), f = 0; f < u.bendpoints.length; f++) {
+            var T = this.newNode(null);
+            T.setRect(new Point(0, 0), new Dimension(1, 1)), c.add(T);
+            var E = this.newEdge(null);
+            this.graphManager.add(E, y, T), p.add(T), y = T;
+          }
+          var E = this.newEdge(null);
+          return this.graphManager.add(E, y, u.target), this.edgeToDummyNodes.set(u, p), u.isInterGraph() ? this.graphManager.remove(u) : c.remove(u), p;
+        }, g.prototype.createBendpointsFromDummyNodes = function() {
+          var u = [];
+          u = u.concat(this.graphManager.getAllEdges()), u = [].concat(n(this.edgeToDummyNodes.keys()), u);
+          for (var p = 0; p < u.length; p++) {
+            var y = u[p];
+            if (y.bendpoints.length > 0) {
+              for (var c = this.edgeToDummyNodes.get(y), f = 0; f < c.length; f++) {
+                var T = c[f], E = new o(T.getCenterX(), T.getCenterY()), O = y.bendpoints.get(f);
+                O.x = E.x, O.y = E.y, T.getOwner().remove(T);
+              }
+              this.graphManager.add(y, y.source, y.target);
+            }
+          }
+        }, g.transform = function(u, p, y, c) {
+          if (y != null && c != null) {
+            var f = p;
+            if (u <= 50) {
+              var T = p / y;
+              f -= (p - T) / 50 * (50 - u);
+            } else {
+              var E = p * c;
+              f += (E - p) / 50 * (u - 50);
+            }
+            return f;
+          } else {
+            var O, a;
+            return u <= 50 ? (O = 9 * p / 500, a = p / 10) : (O = 9 * p / 50, a = -8 * p), O * u + a;
+          }
+        }, g.findCenterOfTree = function(u) {
+          var p = [];
+          p = p.concat(u);
+          var y = [], c = /* @__PURE__ */ new Map(), f = !1, T = null;
+          (p.length == 1 || p.length == 2) && (f = !0, T = p[0]);
+          for (var E = 0; E < p.length; E++) {
+            var O = p[E], a = O.getNeighborsList().size;
+            c.set(O, O.getNeighborsList().size), a == 1 && y.push(O);
+          }
+          var d = [];
+          for (d = d.concat(y); !f; ) {
+            var l = [];
+            l = l.concat(d), d = [];
+            for (var E = 0; E < p.length; E++) {
+              var O = p[E], v = p.indexOf(O);
+              v >= 0 && p.splice(v, 1), O.getNeighborsList().forEach(function(I) {
+                if (y.indexOf(I) < 0) {
+                  var w = c.get(I) - 1;
+                  w == 1 && d.push(I), c.set(I, w);
+                }
+              });
+            }
+            y = y.concat(d), (p.length == 1 || p.length == 2) && (f = !0, T = p[0]);
+          }
+          return T;
+        }, g.prototype.setGraphManager = function(u) {
+          this.graphManager = u;
+        }, L.exports = g;
+      }),
+      (function(L, m, A) {
+        function n() {
+        }
+        n.seed = 1, n.x = 0, n.nextDouble = function() {
+          return n.x = Math.sin(n.seed++) * 1e4, n.x - Math.floor(n.x);
+        }, L.exports = n;
+      }),
+      (function(L, m, A) {
+        var n = A(4);
+        function e(t, i) {
+          this.lworldOrgX = 0, this.lworldOrgY = 0, this.ldeviceOrgX = 0, this.ldeviceOrgY = 0, this.lworldExtX = 1, this.lworldExtY = 1, this.ldeviceExtX = 1, this.ldeviceExtY = 1;
+        }
+        e.prototype.getWorldOrgX = function() {
+          return this.lworldOrgX;
+        }, e.prototype.setWorldOrgX = function(t) {
+          this.lworldOrgX = t;
+        }, e.prototype.getWorldOrgY = function() {
+          return this.lworldOrgY;
+        }, e.prototype.setWorldOrgY = function(t) {
+          this.lworldOrgY = t;
+        }, e.prototype.getWorldExtX = function() {
+          return this.lworldExtX;
+        }, e.prototype.setWorldExtX = function(t) {
+          this.lworldExtX = t;
+        }, e.prototype.getWorldExtY = function() {
+          return this.lworldExtY;
+        }, e.prototype.setWorldExtY = function(t) {
+          this.lworldExtY = t;
+        }, e.prototype.getDeviceOrgX = function() {
+          return this.ldeviceOrgX;
+        }, e.prototype.setDeviceOrgX = function(t) {
+          this.ldeviceOrgX = t;
+        }, e.prototype.getDeviceOrgY = function() {
+          return this.ldeviceOrgY;
+        }, e.prototype.setDeviceOrgY = function(t) {
+          this.ldeviceOrgY = t;
+        }, e.prototype.getDeviceExtX = function() {
+          return this.ldeviceExtX;
+        }, e.prototype.setDeviceExtX = function(t) {
+          this.ldeviceExtX = t;
+        }, e.prototype.getDeviceExtY = function() {
+          return this.ldeviceExtY;
+        }, e.prototype.setDeviceExtY = function(t) {
+          this.ldeviceExtY = t;
+        }, e.prototype.transformX = function(t) {
+          var i = 0, r = this.lworldExtX;
+          return r != 0 && (i = this.ldeviceOrgX + (t - this.lworldOrgX) * this.ldeviceExtX / r), i;
+        }, e.prototype.transformY = function(t) {
+          var i = 0, r = this.lworldExtY;
+          return r != 0 && (i = this.ldeviceOrgY + (t - this.lworldOrgY) * this.ldeviceExtY / r), i;
+        }, e.prototype.inverseTransformX = function(t) {
+          var i = 0, r = this.ldeviceExtX;
+          return r != 0 && (i = this.lworldOrgX + (t - this.ldeviceOrgX) * this.lworldExtX / r), i;
+        }, e.prototype.inverseTransformY = function(t) {
+          var i = 0, r = this.ldeviceExtY;
+          return r != 0 && (i = this.lworldOrgY + (t - this.ldeviceOrgY) * this.lworldExtY / r), i;
+        }, e.prototype.inverseTransformPoint = function(t) {
+          return new n(this.inverseTransformX(t.x), this.inverseTransformY(t.y));
+        }, L.exports = e;
+      }),
+      (function(L, m, A) {
+        function n(s) {
+          if (Array.isArray(s)) {
+            for (var g = 0, u = Array(s.length); g < s.length; g++) u[g] = s[g];
+            return u;
+          } else return Array.from(s);
+        }
+        var e = A(15), t = A(7), i = A(0), r = A(8), h = A(9);
+        function o() {
+          e.call(this), this.useSmartIdealEdgeLengthCalculation = t.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.idealEdgeLength = t.DEFAULT_EDGE_LENGTH, this.springConstant = t.DEFAULT_SPRING_STRENGTH, this.repulsionConstant = t.DEFAULT_REPULSION_STRENGTH, this.gravityConstant = t.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = t.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = t.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = t.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.displacementThresholdPerNode = 3 * t.DEFAULT_EDGE_LENGTH / 100, this.coolingFactor = t.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.initialCoolingFactor = t.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.totalDisplacement = 0, this.oldTotalDisplacement = 0, this.maxIterations = t.MAX_ITERATIONS;
+        }
+        for (var N in o.prototype = Object.create(e.prototype), e) o[N] = e[N];
+        o.prototype.initParameters = function() {
+          e.prototype.initParameters.call(this, arguments), this.totalIterations = 0, this.notAnimatedIterations = 0, this.useFRGridVariant = t.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION, this.grid = [];
+        }, o.prototype.calcIdealEdgeLengths = function() {
+          for (var s, g, u, p, y, c, f = this.getGraphManager().getAllEdges(), T = 0; T < f.length; T++) s = f[T], s.idealLength = this.idealEdgeLength, s.isInterGraph && (u = s.getSource(), p = s.getTarget(), y = s.getSourceInLca().getEstimatedSize(), c = s.getTargetInLca().getEstimatedSize(), this.useSmartIdealEdgeLengthCalculation && (s.idealLength += y + c - 2 * i.SIMPLE_NODE_SIZE), g = s.getLca().getInclusionTreeDepth(), s.idealLength += t.DEFAULT_EDGE_LENGTH * t.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (u.getInclusionTreeDepth() + p.getInclusionTreeDepth() - 2 * g));
+        }, o.prototype.initSpringEmbedder = function() {
+          var s = this.getAllNodes().length;
+          this.incremental ? (s > t.ADAPTATION_LOWER_NODE_LIMIT && (this.coolingFactor = Math.max(this.coolingFactor * t.COOLING_ADAPTATION_FACTOR, this.coolingFactor - (s - t.ADAPTATION_LOWER_NODE_LIMIT) / (t.ADAPTATION_UPPER_NODE_LIMIT - t.ADAPTATION_LOWER_NODE_LIMIT) * this.coolingFactor * (1 - t.COOLING_ADAPTATION_FACTOR))), this.maxNodeDisplacement = t.MAX_NODE_DISPLACEMENT_INCREMENTAL) : (s > t.ADAPTATION_LOWER_NODE_LIMIT ? this.coolingFactor = Math.max(t.COOLING_ADAPTATION_FACTOR, 1 - (s - t.ADAPTATION_LOWER_NODE_LIMIT) / (t.ADAPTATION_UPPER_NODE_LIMIT - t.ADAPTATION_LOWER_NODE_LIMIT) * (1 - t.COOLING_ADAPTATION_FACTOR)) : this.coolingFactor = 1, this.initialCoolingFactor = this.coolingFactor, this.maxNodeDisplacement = t.MAX_NODE_DISPLACEMENT), this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations), this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length, this.repulsionRange = this.calcRepulsionRange();
+        }, o.prototype.calcSpringForces = function() {
+          for (var s = this.getAllEdges(), g, u = 0; u < s.length; u++) g = s[u], this.calcSpringForce(g, g.idealLength);
+        }, o.prototype.calcRepulsionForces = function() {
+          var s = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0, g = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1, u, p, y, c, f = this.getAllNodes(), T;
+          if (this.useFRGridVariant) for (this.totalIterations % t.GRID_CALCULATION_CHECK_PERIOD == 1 && s && this.updateGrid(), T = /* @__PURE__ */ new Set(), u = 0; u < f.length; u++) y = f[u], this.calculateRepulsionForceOfANode(y, T, s, g), T.add(y);
+          else for (u = 0; u < f.length; u++) for (y = f[u], p = u + 1; p < f.length; p++) c = f[p], y.getOwner() == c.getOwner() && this.calcRepulsionForce(y, c);
+        }, o.prototype.calcGravitationalForces = function() {
+          for (var s, g = this.getAllNodesToApplyGravitation(), u = 0; u < g.length; u++) s = g[u], this.calcGravitationalForce(s);
+        }, o.prototype.moveNodes = function() {
+          for (var s = this.getAllNodes(), g, u = 0; u < s.length; u++) g = s[u], g.move();
+        }, o.prototype.calcSpringForce = function(s, g) {
+          var u = s.getSource(), p = s.getTarget(), y, c, f, T;
+          if (this.uniformLeafNodeSizes && u.getChild() == null && p.getChild() == null) s.updateLengthSimple();
+          else if (s.updateLength(), s.isOverlapingSourceAndTarget) return;
+          y = s.getLength(), y != 0 && (c = this.springConstant * (y - g), f = c * (s.lengthX / y), T = c * (s.lengthY / y), u.springForceX += f, u.springForceY += T, p.springForceX -= f, p.springForceY -= T);
+        }, o.prototype.calcRepulsionForce = function(s, g) {
+          var u = s.getRect(), p = g.getRect(), y = [, ,], c = [
+            ,
+            ,
+            ,
+            ,
+          ], f, T, E, O, a, d, l;
+          if (u.intersects(p)) {
+            r.calcSeparationAmount(u, p, y, t.DEFAULT_EDGE_LENGTH / 2), d = 2 * y[0], l = 2 * y[1];
+            var v = s.noOfChildren * g.noOfChildren / (s.noOfChildren + g.noOfChildren);
+            s.repulsionForceX -= v * d, s.repulsionForceY -= v * l, g.repulsionForceX += v * d, g.repulsionForceY += v * l;
+          } else this.uniformLeafNodeSizes && s.getChild() == null && g.getChild() == null ? (f = p.getCenterX() - u.getCenterX(), T = p.getCenterY() - u.getCenterY()) : (r.getIntersection(u, p, c), f = c[2] - c[0], T = c[3] - c[1]), Math.abs(f) < t.MIN_REPULSION_DIST && (f = h.sign(f) * t.MIN_REPULSION_DIST), Math.abs(T) < t.MIN_REPULSION_DIST && (T = h.sign(T) * t.MIN_REPULSION_DIST), E = f * f + T * T, O = Math.sqrt(E), a = this.repulsionConstant * s.noOfChildren * g.noOfChildren / E, d = a * f / O, l = a * T / O, s.repulsionForceX -= d, s.repulsionForceY -= l, g.repulsionForceX += d, g.repulsionForceY += l;
+        }, o.prototype.calcGravitationalForce = function(s) {
+          var g = s.getOwner(), u = (g.getRight() + g.getLeft()) / 2, p = (g.getTop() + g.getBottom()) / 2, y = s.getCenterX() - u, c = s.getCenterY() - p, f = Math.abs(y) + s.getWidth() / 2, T = Math.abs(c) + s.getHeight() / 2, E;
+          s.getOwner() == this.graphManager.getRoot() ? (E = g.getEstimatedSize() * this.gravityRangeFactor, (f > E || T > E) && (s.gravitationForceX = -this.gravityConstant * y, s.gravitationForceY = -this.gravityConstant * c)) : (E = g.getEstimatedSize() * this.compoundGravityRangeFactor, (f > E || T > E) && (s.gravitationForceX = -this.gravityConstant * y * this.compoundGravityConstant, s.gravitationForceY = -this.gravityConstant * c * this.compoundGravityConstant));
+        }, o.prototype.isConverged = function() {
+          var s, g = !1;
+          return this.totalIterations > this.maxIterations / 3 && (g = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2), s = this.totalDisplacement < this.totalDisplacementThreshold, this.oldTotalDisplacement = this.totalDisplacement, s || g;
+        }, o.prototype.animate = function() {
+          this.animationDuringLayout && !this.isSubLayout && (this.notAnimatedIterations == this.animationPeriod ? (this.update(), this.notAnimatedIterations = 0) : this.notAnimatedIterations++);
+        }, o.prototype.calcNoOfChildrenForAllNodes = function() {
+          for (var s, g = this.graphManager.getAllNodes(), u = 0; u < g.length; u++) s = g[u], s.noOfChildren = s.getNoOfChildren();
+        }, o.prototype.calcGrid = function(s) {
+          var g = 0, u = 0;
+          g = parseInt(Math.ceil((s.getRight() - s.getLeft()) / this.repulsionRange)), u = parseInt(Math.ceil((s.getBottom() - s.getTop()) / this.repulsionRange));
+          for (var p = Array(g), y = 0; y < g; y++) p[y] = Array(u);
+          for (var y = 0; y < g; y++) for (var c = 0; c < u; c++) p[y][c] = [];
+          return p;
+        }, o.prototype.addNodeToGrid = function(s, g, u) {
+          var p = 0, y = 0, c = 0, f = 0;
+          p = parseInt(Math.floor((s.getRect().x - g) / this.repulsionRange)), y = parseInt(Math.floor((s.getRect().width + s.getRect().x - g) / this.repulsionRange)), c = parseInt(Math.floor((s.getRect().y - u) / this.repulsionRange)), f = parseInt(Math.floor((s.getRect().height + s.getRect().y - u) / this.repulsionRange));
+          for (var T = p; T <= y; T++) for (var E = c; E <= f; E++) this.grid[T][E].push(s), s.setGridCoordinates(p, y, c, f);
+        }, o.prototype.updateGrid = function() {
+          var s, g, u = this.getAllNodes();
+          for (this.grid = this.calcGrid(this.graphManager.getRoot()), s = 0; s < u.length; s++) g = u[s], this.addNodeToGrid(g, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop());
+        }, o.prototype.calculateRepulsionForceOfANode = function(s, g, u, p) {
+          if (this.totalIterations % t.GRID_CALCULATION_CHECK_PERIOD == 1 && u || p) {
+            var y = /* @__PURE__ */ new Set();
+            s.surrounding = [];
+            for (var c, f = this.grid, T = s.startX - 1; T < s.finishX + 2; T++) for (var E = s.startY - 1; E < s.finishY + 2; E++) if (!(T < 0 || E < 0 || T >= f.length || E >= f[0].length)) {
+              for (var O = 0; O < f[T][E].length; O++) if (c = f[T][E][O], !(s.getOwner() != c.getOwner() || s == c) && !g.has(c) && !y.has(c)) {
+                var a = Math.abs(s.getCenterX() - c.getCenterX()) - (s.getWidth() / 2 + c.getWidth() / 2), d = Math.abs(s.getCenterY() - c.getCenterY()) - (s.getHeight() / 2 + c.getHeight() / 2);
+                a <= this.repulsionRange && d <= this.repulsionRange && y.add(c);
+              }
+            }
+            s.surrounding = [].concat(n(y));
+          }
+          for (T = 0; T < s.surrounding.length; T++) this.calcRepulsionForce(s, s.surrounding[T]);
+        }, o.prototype.calcRepulsionRange = function() {
+          return 0;
+        }, L.exports = o;
+      }),
+      (function(L, m, A) {
+        var n = A(1), e = A(7);
+        function t(r, h, o) {
+          n.call(this, r, h, o), this.idealLength = e.DEFAULT_EDGE_LENGTH;
+        }
+        for (var i in t.prototype = Object.create(n.prototype), n) t[i] = n[i];
+        L.exports = t;
+      }),
+      (function(L, m, A) {
+        var n = A(3);
+        function e(i, r, h, o) {
+          n.call(this, i, r, h, o), this.springForceX = 0, this.springForceY = 0, this.repulsionForceX = 0, this.repulsionForceY = 0, this.gravitationForceX = 0, this.gravitationForceY = 0, this.displacementX = 0, this.displacementY = 0, this.startX = 0, this.finishX = 0, this.startY = 0, this.finishY = 0, this.surrounding = [];
+        }
+        for (var t in e.prototype = Object.create(n.prototype), n) e[t] = n[t];
+        e.prototype.setGridCoordinates = function(i, r, h, o) {
+          this.startX = i, this.finishX = r, this.startY = h, this.finishY = o;
+        }, L.exports = e;
+      }),
+      (function(L, m, A) {
+        function n(e, t) {
+          this.width = 0, this.height = 0, e !== null && t !== null && (this.height = t, this.width = e);
+        }
+        n.prototype.getWidth = function() {
+          return this.width;
+        }, n.prototype.setWidth = function(e) {
+          this.width = e;
+        }, n.prototype.getHeight = function() {
+          return this.height;
+        }, n.prototype.setHeight = function(e) {
+          this.height = e;
+        }, L.exports = n;
+      }),
+      (function(L, m, A) {
+        var n = A(14);
+        function e() {
+          this.map = {}, this.keys = [];
+        }
+        e.prototype.put = function(t, i) {
+          var r = n.createID(t);
+          this.contains(r) || (this.map[r] = i, this.keys.push(t));
+        }, e.prototype.contains = function(t) {
+          return n.createID(t), this.map[t] != null;
+        }, e.prototype.get = function(t) {
+          var i = n.createID(t);
+          return this.map[i];
+        }, e.prototype.keySet = function() {
+          return this.keys;
+        }, L.exports = e;
+      }),
+      (function(L, m, A) {
+        var n = A(14);
+        function e() {
+          this.set = {};
+        }
+        e.prototype.add = function(t) {
+          var i = n.createID(t);
+          this.contains(i) || (this.set[i] = t);
+        }, e.prototype.remove = function(t) {
+          delete this.set[n.createID(t)];
+        }, e.prototype.clear = function() {
+          this.set = {};
+        }, e.prototype.contains = function(t) {
+          return this.set[n.createID(t)] == t;
+        }, e.prototype.isEmpty = function() {
+          return this.size() === 0;
+        }, e.prototype.size = function() {
+          return Object.keys(this.set).length;
+        }, e.prototype.addAllTo = function(t) {
+          for (var i = Object.keys(this.set), r = i.length, h = 0; h < r; h++) t.push(this.set[i[h]]);
+        }, e.prototype.size = function() {
+          return Object.keys(this.set).length;
+        }, e.prototype.addAll = function(t) {
+          for (var i = t.length, r = 0; r < i; r++) {
+            var h = t[r];
+            this.add(h);
+          }
+        }, L.exports = e;
+      }),
+      (function(L, m, A) {
+        var n = /* @__PURE__ */ (function() {
+          function i(r, h) {
+            for (var o = 0; o < h.length; o++) {
+              var N = h[o];
+              N.enumerable = N.enumerable || !1, N.configurable = !0, "value" in N && (N.writable = !0), Object.defineProperty(r, N.key, N);
+            }
+          }
+          return function(r, h, o) {
+            return h && i(r.prototype, h), o && i(r, o), r;
+          };
+        })();
+        function e(i, r) {
+          if (!(i instanceof r)) throw TypeError("Cannot call a class as a function");
+        }
+        var t = A(11);
+        L.exports = (function() {
+          function i(r, h) {
+            e(this, i), (h !== null || h !== void 0) && (this.compareFunction = this._defaultCompareFunction);
+            var o = void 0;
+            o = r instanceof t ? r.size() : r.length, this._quicksort(r, 0, o - 1);
+          }
+          return n(i, [
+            {
+              key: "_quicksort",
+              value: function(r, h, o) {
+                if (h < o) {
+                  var N = this._partition(r, h, o);
+                  this._quicksort(r, h, N), this._quicksort(r, N + 1, o);
+                }
+              }
+            },
+            {
+              key: "_partition",
+              value: function(r, h, o) {
+                for (var N = this._get(r, h), s = h, g = o; ; ) {
+                  for (; this.compareFunction(N, this._get(r, g)); ) g--;
+                  for (; this.compareFunction(this._get(r, s), N); ) s++;
+                  if (s < g) this._swap(r, s, g), s++, g--;
+                  else return g;
+                }
+              }
+            },
+            {
+              key: "_get",
+              value: function(r, h) {
+                return r instanceof t ? r.get_object_at(h) : r[h];
+              }
+            },
+            {
+              key: "_set",
+              value: function(r, h, o) {
+                r instanceof t ? r.set_object_at(h, o) : r[h] = o;
+              }
+            },
+            {
+              key: "_swap",
+              value: function(r, h, o) {
+                var N = this._get(r, h);
+                this._set(r, h, this._get(r, o)), this._set(r, o, N);
+              }
+            },
+            {
+              key: "_defaultCompareFunction",
+              value: function(r, h) {
+                return h > r;
+              }
+            }
+          ]), i;
+        })();
+      }),
+      (function(L, m, A) {
+        var n = /* @__PURE__ */ (function() {
+          function t(i, r) {
+            for (var h = 0; h < r.length; h++) {
+              var o = r[h];
+              o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(i, o.key, o);
+            }
+          }
+          return function(i, r, h) {
+            return r && t(i.prototype, r), h && t(i, h), i;
+          };
+        })();
+        function e(t, i) {
+          if (!(t instanceof i)) throw TypeError("Cannot call a class as a function");
+        }
+        L.exports = (function() {
+          function t(i, r) {
+            var h = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1, o = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : -1, N = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : -1;
+            e(this, t), this.sequence1 = i, this.sequence2 = r, this.match_score = h, this.mismatch_penalty = o, this.gap_penalty = N, this.iMax = i.length + 1, this.jMax = r.length + 1, this.grid = Array(this.iMax);
+            for (var s = 0; s < this.iMax; s++) {
+              this.grid[s] = Array(this.jMax);
+              for (var g = 0; g < this.jMax; g++) this.grid[s][g] = 0;
+            }
+            this.tracebackGrid = Array(this.iMax);
+            for (var u = 0; u < this.iMax; u++) {
+              this.tracebackGrid[u] = Array(this.jMax);
+              for (var p = 0; p < this.jMax; p++) this.tracebackGrid[u][p] = [
+                null,
+                null,
+                null
+              ];
+            }
+            this.alignments = [], this.score = -1, this.computeGrids();
+          }
+          return n(t, [
+            {
+              key: "getScore",
+              value: function() {
+                return this.score;
+              }
+            },
+            {
+              key: "getAlignments",
+              value: function() {
+                return this.alignments;
+              }
+            },
+            {
+              key: "computeGrids",
+              value: function() {
+                for (var i = 1; i < this.jMax; i++) this.grid[0][i] = this.grid[0][i - 1] + this.gap_penalty, this.tracebackGrid[0][i] = [
+                  !1,
+                  !1,
+                  !0
+                ];
+                for (var r = 1; r < this.iMax; r++) this.grid[r][0] = this.grid[r - 1][0] + this.gap_penalty, this.tracebackGrid[r][0] = [
+                  !1,
+                  !0,
+                  !1
+                ];
+                for (var h = 1; h < this.iMax; h++) for (var o = 1; o < this.jMax; o++) {
+                  var N = void 0;
+                  N = this.sequence1[h - 1] === this.sequence2[o - 1] ? this.grid[h - 1][o - 1] + this.match_score : this.grid[h - 1][o - 1] + this.mismatch_penalty;
+                  var s = this.grid[h - 1][o] + this.gap_penalty, g = this.grid[h][o - 1] + this.gap_penalty, u = [
+                    N,
+                    s,
+                    g
+                  ], p = this.arrayAllMaxIndexes(u);
+                  this.grid[h][o] = u[p[0]], this.tracebackGrid[h][o] = [
+                    p.includes(0),
+                    p.includes(1),
+                    p.includes(2)
+                  ];
+                }
+                this.score = this.grid[this.iMax - 1][this.jMax - 1];
+              }
+            },
+            {
+              key: "alignmentTraceback",
+              value: function() {
+                var i = [];
+                for (i.push({
+                  pos: [this.sequence1.length, this.sequence2.length],
+                  seq1: "",
+                  seq2: ""
+                }); i[0]; ) {
+                  var r = i[0], h = this.tracebackGrid[r.pos[0]][r.pos[1]];
+                  h[0] && i.push({
+                    pos: [r.pos[0] - 1, r.pos[1] - 1],
+                    seq1: this.sequence1[r.pos[0] - 1] + r.seq1,
+                    seq2: this.sequence2[r.pos[1] - 1] + r.seq2
+                  }), h[1] && i.push({
+                    pos: [r.pos[0] - 1, r.pos[1]],
+                    seq1: this.sequence1[r.pos[0] - 1] + r.seq1,
+                    seq2: "-" + r.seq2
+                  }), h[2] && i.push({
+                    pos: [r.pos[0], r.pos[1] - 1],
+                    seq1: "-" + r.seq1,
+                    seq2: this.sequence2[r.pos[1] - 1] + r.seq2
+                  }), r.pos[0] === 0 && r.pos[1] === 0 && this.alignments.push({
+                    sequence1: r.seq1,
+                    sequence2: r.seq2
+                  }), i.shift();
+                }
+                return this.alignments;
+              }
+            },
+            {
+              key: "getAllIndexes",
+              value: function(i, r) {
+                for (var h = [], o = -1; (o = i.indexOf(r, o + 1)) !== -1; ) h.push(o);
+                return h;
+              }
+            },
+            {
+              key: "arrayAllMaxIndexes",
+              value: function(i) {
+                return this.getAllIndexes(i, Math.max.apply(null, i));
+              }
+            }
+          ]), t;
+        })();
+      }),
+      (function(L, m, A) {
+        var n = function() {
+        };
+        n.FDLayout = A(18), n.FDLayoutConstants = A(7), n.FDLayoutEdge = A(19), n.FDLayoutNode = A(20), n.DimensionD = A(21), n.HashMap = A(22), n.HashSet = A(23), n.IGeometry = A(8), n.IMath = A(9), n.Integer = A(10), n.Point = A(12), n.PointD = A(4), n.RandomSeed = A(16), n.RectangleD = A(13), n.Transform = A(17), n.UniqueIDGeneretor = A(14), n.Quicksort = A(24), n.LinkedList = A(11), n.LGraphObject = A(2), n.LGraph = A(5), n.LEdge = A(1), n.LGraphManager = A(6), n.LNode = A(3), n.Layout = A(15), n.LayoutConstants = A(0), n.NeedlemanWunsch = A(25), L.exports = n;
+      }),
+      (function(L, m, A) {
+        function n() {
+          this.listeners = [];
+        }
+        var e = n.prototype;
+        e.addListener = function(t, i) {
+          this.listeners.push({
+            event: t,
+            callback: i
+          });
+        }, e.removeListener = function(t, i) {
+          for (var r = this.listeners.length; r >= 0; r--) {
+            var h = this.listeners[r];
+            h.event === t && h.callback === i && this.listeners.splice(r, 1);
+          }
+        }, e.emit = function(t, i) {
+          for (var r = 0; r < this.listeners.length; r++) {
+            var h = this.listeners[r];
+            t === h.event && h.callback(i);
+          }
+        }, L.exports = n;
+      })
+    ]);
+  });
+})), Z = /* @__PURE__ */ V(((C, P) => {
+  (function(L, m) {
+    typeof C == "object" && typeof P == "object" ? P.exports = m(z()) : typeof define == "function" && define.amd ? define(["layout-base"], m) : typeof C == "object" ? C.coseBase = m(z()) : L.coseBase = m(L.layoutBase);
+  })(C, function(L) {
+    return (function(m) {
+      var A = {};
+      function n(e) {
+        if (A[e]) return A[e].exports;
+        var t = A[e] = {
+          i: e,
+          l: !1,
+          exports: {}
+        };
+        return m[e].call(t.exports, t, t.exports, n), t.l = !0, t.exports;
+      }
+      return n.m = m, n.c = A, n.i = function(e) {
+        return e;
+      }, n.d = function(e, t, i) {
+        n.o(e, t) || Object.defineProperty(e, t, {
+          configurable: !1,
+          enumerable: !0,
+          get: i
+        });
+      }, n.n = function(e) {
+        var t = e && e.__esModule ? function() {
+          return e.default;
+        } : function() {
+          return e;
+        };
+        return n.d(t, "a", t), t;
+      }, n.o = function(e, t) {
+        return Object.prototype.hasOwnProperty.call(e, t);
+      }, n.p = "", n(n.s = 7);
+    })([
+      (function(m, A) {
+        m.exports = L;
+      }),
+      (function(m, A, n) {
+        var e = n(0).FDLayoutConstants;
+        function t() {
+        }
+        for (var i in e) t[i] = e[i];
+        t.DEFAULT_USE_MULTI_LEVEL_SCALING = !1, t.DEFAULT_RADIAL_SEPARATION = e.DEFAULT_EDGE_LENGTH, t.DEFAULT_COMPONENT_SEPERATION = 60, t.TILE = !0, t.TILING_PADDING_VERTICAL = 10, t.TILING_PADDING_HORIZONTAL = 10, t.TREE_REDUCTION_ON_INCREMENTAL = !1, m.exports = t;
+      }),
+      (function(m, A, n) {
+        var e = n(0).FDLayoutEdge;
+        function t(r, h, o) {
+          e.call(this, r, h, o);
+        }
+        for (var i in t.prototype = Object.create(e.prototype), e) t[i] = e[i];
+        m.exports = t;
+      }),
+      (function(m, A, n) {
+        var e = n(0).LGraph;
+        function t(r, h, o) {
+          e.call(this, r, h, o);
+        }
+        for (var i in t.prototype = Object.create(e.prototype), e) t[i] = e[i];
+        m.exports = t;
+      }),
+      (function(m, A, n) {
+        var e = n(0).LGraphManager;
+        function t(r) {
+          e.call(this, r);
+        }
+        for (var i in t.prototype = Object.create(e.prototype), e) t[i] = e[i];
+        m.exports = t;
+      }),
+      (function(m, A, n) {
+        var e = n(0).FDLayoutNode, t = n(0).IMath;
+        function i(h, o, N, s) {
+          e.call(this, h, o, N, s);
+        }
+        for (var r in i.prototype = Object.create(e.prototype), e) i[r] = e[r];
+        i.prototype.move = function() {
+          var h = this.graphManager.getLayout();
+          this.displacementX = h.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren, this.displacementY = h.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren, Math.abs(this.displacementX) > h.coolingFactor * h.maxNodeDisplacement && (this.displacementX = h.coolingFactor * h.maxNodeDisplacement * t.sign(this.displacementX)), Math.abs(this.displacementY) > h.coolingFactor * h.maxNodeDisplacement && (this.displacementY = h.coolingFactor * h.maxNodeDisplacement * t.sign(this.displacementY)), this.child == null || this.child.getNodes().length == 0 ? this.moveBy(this.displacementX, this.displacementY) : this.propogateDisplacementToChildren(this.displacementX, this.displacementY), h.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;
+        }, i.prototype.propogateDisplacementToChildren = function(h, o) {
+          for (var N = this.getChild().getNodes(), s, g = 0; g < N.length; g++) s = N[g], s.getChild() == null ? (s.moveBy(h, o), s.displacementX += h, s.displacementY += o) : s.propogateDisplacementToChildren(h, o);
+        }, i.prototype.setPred1 = function(h) {
+          this.pred1 = h;
+        }, i.prototype.getPred1 = function() {
+          return pred1;
+        }, i.prototype.getPred2 = function() {
+          return pred2;
+        }, i.prototype.setNext = function(h) {
+          this.next = h;
+        }, i.prototype.getNext = function() {
+          return next;
+        }, i.prototype.setProcessed = function(h) {
+          this.processed = h;
+        }, i.prototype.isProcessed = function() {
+          return processed;
+        }, m.exports = i;
+      }),
+      (function(m, A, n) {
+        var e = n(0).FDLayout, t = n(4), i = n(3), r = n(5), h = n(2), o = n(1), N = n(0).FDLayoutConstants, s = n(0).LayoutConstants, g = n(0).Point, u = n(0).PointD, p = n(0).Layout, y = n(0).Integer, c = n(0).IGeometry, f = n(0).LGraph, T = n(0).Transform;
+        function E() {
+          e.call(this), this.toBeTiled = {};
+        }
+        for (var O in E.prototype = Object.create(e.prototype), e) E[O] = e[O];
+        E.prototype.newGraphManager = function() {
+          var a = new t(this);
+          return this.graphManager = a, a;
+        }, E.prototype.newGraph = function(a) {
+          return new i(null, this.graphManager, a);
+        }, E.prototype.newNode = function(a) {
+          return new r(this.graphManager, a);
+        }, E.prototype.newEdge = function(a) {
+          return new h(null, null, a);
+        }, E.prototype.initParameters = function() {
+          e.prototype.initParameters.call(this, arguments), this.isSubLayout || (o.DEFAULT_EDGE_LENGTH < 10 ? this.idealEdgeLength = 10 : this.idealEdgeLength = o.DEFAULT_EDGE_LENGTH, this.useSmartIdealEdgeLengthCalculation = o.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.springConstant = N.DEFAULT_SPRING_STRENGTH, this.repulsionConstant = N.DEFAULT_REPULSION_STRENGTH, this.gravityConstant = N.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = N.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = N.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = N.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.prunedNodesAll = [], this.growTreeIterations = 0, this.afterGrowthIterations = 0, this.isTreeGrowing = !1, this.isGrowthFinished = !1, this.coolingCycle = 0, this.maxCoolingCycle = this.maxIterations / N.CONVERGENCE_CHECK_PERIOD, this.finalTemperature = N.CONVERGENCE_CHECK_PERIOD / this.maxIterations, this.coolingAdjuster = 1);
+        }, E.prototype.layout = function() {
+          return s.DEFAULT_CREATE_BENDS_AS_NEEDED && (this.createBendpoints(), this.graphManager.resetAllEdges()), this.level = 0, this.classicLayout();
+        }, E.prototype.classicLayout = function() {
+          if (this.nodesWithGravity = this.calculateNodesToApplyGravitationTo(), this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity), this.calcNoOfChildrenForAllNodes(), this.graphManager.calcLowestCommonAncestors(), this.graphManager.calcInclusionTreeDepths(), this.graphManager.getRoot().calcEstimatedSize(), this.calcIdealEdgeLengths(), !this.incremental) {
+            var a = this.getFlatForest();
+            if (a.length > 0) this.positionNodesRadially(a);
+            else {
+              this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+              var d = new Set(this.getAllNodes()), l = this.nodesWithGravity.filter(function(v) {
+                return d.has(v);
+              });
+              this.graphManager.setAllNodesToApplyGravitation(l), this.positionNodesRandomly();
+            }
+          } else if (o.TREE_REDUCTION_ON_INCREMENTAL) {
+            this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+            var d = new Set(this.getAllNodes()), l = this.nodesWithGravity.filter(function(D) {
+              return d.has(D);
+            });
+            this.graphManager.setAllNodesToApplyGravitation(l);
+          }
+          return this.initSpringEmbedder(), this.runSpringEmbedder(), !0;
+        }, E.prototype.tick = function() {
+          if (this.totalIterations++, this.totalIterations === this.maxIterations && !this.isTreeGrowing && !this.isGrowthFinished) if (this.prunedNodesAll.length > 0) this.isTreeGrowing = !0;
+          else return !0;
+          if (this.totalIterations % N.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) {
+            if (this.isConverged()) if (this.prunedNodesAll.length > 0) this.isTreeGrowing = !0;
+            else return !0;
+            this.coolingCycle++, this.layoutQuality == 0 ? this.coolingAdjuster = this.coolingCycle : this.layoutQuality == 1 && (this.coolingAdjuster = this.coolingCycle / 3), this.coolingFactor = Math.max(this.initialCoolingFactor - 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 a = new Set(this.getAllNodes()), d = this.nodesWithGravity.filter(function(_) {
+                return a.has(_);
+              });
+              this.graphManager.setAllNodesToApplyGravitation(d), this.graphManager.updateBounds(), this.updateGrid(), this.coolingFactor = N.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+            } else this.isTreeGrowing = !1, this.isGrowthFinished = !0;
+            this.growTreeIterations++;
+          }
+          if (this.isGrowthFinished) {
+            if (this.isConverged()) return !0;
+            this.afterGrowthIterations % 10 == 0 && (this.graphManager.updateBounds(), this.updateGrid()), this.coolingFactor = N.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100), this.afterGrowthIterations++;
+          }
+          var l = !this.isTreeGrowing && !this.isGrowthFinished, v = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished;
+          return this.totalDisplacement = 0, this.graphManager.updateBounds(), this.calcSpringForces(), this.calcRepulsionForces(l, v), this.calcGravitationalForces(), this.moveNodes(), this.animate(), !1;
+        }, E.prototype.getPositionsData = function() {
+          for (var a = this.graphManager.getAllNodes(), d = {}, l = 0; l < a.length; l++) {
+            var v = a[l].rect, _ = a[l].id;
+            d[_] = {
+              id: _,
+              x: v.getCenterX(),
+              y: v.getCenterY(),
+              w: v.width,
+              h: v.height
+            };
+          }
+          return d;
+        }, E.prototype.runSpringEmbedder = function() {
+          this.initialAnimationPeriod = 25, this.animationPeriod = this.initialAnimationPeriod;
+          var a = !1;
+          if (N.ANIMATE === "during") this.emit("layoutstarted");
+          else {
+            for (; !a; ) a = this.tick();
+            this.graphManager.updateBounds();
+          }
+        }, E.prototype.calculateNodesToApplyGravitationTo = function() {
+          var a = [], d, l = this.graphManager.getGraphs(), v = l.length, _;
+          for (_ = 0; _ < v; _++) d = l[_], d.updateConnected(), d.isConnected || (a = a.concat(d.getNodes()));
+          return a;
+        }, E.prototype.createBendpoints = function() {
+          var a = [];
+          a = a.concat(this.graphManager.getAllEdges());
+          var d = /* @__PURE__ */ new Set(), l;
+          for (l = 0; l < a.length; l++) {
+            var v = a[l];
+            if (!d.has(v)) {
+              var _ = v.getSource(), D = v.getTarget();
+              if (_ == D) v.getBendpoints().push(new u()), v.getBendpoints().push(new u()), this.createDummyNodesForBendpoints(v), d.add(v);
+              else {
+                var I = [];
+                if (I = I.concat(_.getEdgeListToNode(D)), I = I.concat(D.getEdgeListToNode(_)), !d.has(I[0])) {
+                  if (I.length > 1) {
+                    var w;
+                    for (w = 0; w < I.length; w++) {
+                      var R = I[w];
+                      R.getBendpoints().push(new u()), this.createDummyNodesForBendpoints(R);
+                    }
+                  }
+                  I.forEach(function(G) {
+                    d.add(G);
+                  });
+                }
+              }
+            }
+            if (d.size == a.length) break;
+          }
+        }, E.prototype.positionNodesRadially = function(a) {
+          for (var d = new g(0, 0), l = Math.ceil(Math.sqrt(a.length)), v = 0, _ = 0, D = 0, I = new u(0, 0), w = 0; w < a.length; w++) {
+            w % l == 0 && (D = 0, _ = v, w != 0 && (_ += o.DEFAULT_COMPONENT_SEPERATION), v = 0);
+            var R = a[w], G = p.findCenterOfTree(R);
+            d.x = D, d.y = _, I = E.radialLayout(R, G, d), I.y > v && (v = Math.floor(I.y)), D = Math.floor(I.x + o.DEFAULT_COMPONENT_SEPERATION);
+          }
+          this.transform(new u(s.WORLD_CENTER_X - I.x / 2, s.WORLD_CENTER_Y - I.y / 2));
+        }, E.radialLayout = function(a, d, l) {
+          var v = Math.max(this.maxDiagonalInTree(a), o.DEFAULT_RADIAL_SEPARATION);
+          E.branchRadialLayout(d, null, 0, 359, 0, v);
+          var _ = f.calculateBounds(a), D = new T();
+          D.setDeviceOrgX(_.getMinX()), D.setDeviceOrgY(_.getMinY()), D.setWorldOrgX(l.x), D.setWorldOrgY(l.y);
+          for (var I = 0; I < a.length; I++) a[I].transform(D);
+          var w = new u(_.getMaxX(), _.getMaxY());
+          return D.inverseTransformPoint(w);
+        }, E.branchRadialLayout = function(a, d, l, v, _, D) {
+          var I = (v - l + 1) / 2;
+          I < 0 && (I += 180);
+          var w = (I + l) % 360 * c.TWO_PI / 360, R = _ * Math.cos(w), G = _ * Math.sin(w);
+          a.setCenter(R, G);
+          var x = [];
+          x = x.concat(a.getEdges());
+          var M = x.length;
+          d != null && M--;
+          for (var U = 0, b = x.length, F, S = a.getEdgesBetween(d); S.length > 1; ) {
+            var Y = S[0];
+            S.splice(0, 1);
+            var X = x.indexOf(Y);
+            X >= 0 && x.splice(X, 1), b--, M--;
+          }
+          F = d == null ? 0 : (x.indexOf(S[0]) + 1) % b;
+          for (var W = Math.abs(v - l) / M, B = F; U != M; B = ++B % b) {
+            var H = x[B].getOtherEnd(a);
+            if (H != d) {
+              var q = (l + U * W) % 360, ot = (q + W) % 360;
+              E.branchRadialLayout(H, a, q, ot, _ + D, D), U++;
+            }
+          }
+        }, E.maxDiagonalInTree = function(a) {
+          for (var d = y.MIN_VALUE, l = 0; l < a.length; l++) {
+            var v = a[l].getDiagonal();
+            v > d && (d = v);
+          }
+          return d;
+        }, E.prototype.calcRepulsionRange = function() {
+          return 2 * (this.level + 1) * this.idealEdgeLength;
+        }, E.prototype.groupZeroDegreeMembers = function() {
+          var a = this, d = {};
+          this.memberGroups = {}, this.idToDummyNode = {};
+          for (var l = [], v = this.graphManager.getAllNodes(), _ = 0; _ < v.length; _++) {
+            var D = v[_], I = D.getParent();
+            this.getNodeDegreeWithChildren(D) === 0 && (I.id == null || !this.getToBeTiled(I)) && l.push(D);
+          }
+          for (var _ = 0; _ < l.length; _++) {
+            var D = l[_], w = D.getParent().id;
+            d[w] === void 0 && (d[w] = []), d[w] = d[w].concat(D);
+          }
+          Object.keys(d).forEach(function(R) {
+            if (d[R].length > 1) {
+              var G = "DummyCompound_" + R;
+              a.memberGroups[G] = d[R];
+              var x = d[R][0].getParent(), M = new r(a.graphManager);
+              M.id = G, M.paddingLeft = x.paddingLeft || 0, M.paddingRight = x.paddingRight || 0, M.paddingBottom = x.paddingBottom || 0, M.paddingTop = x.paddingTop || 0, a.idToDummyNode[G] = M;
+              var U = a.getGraphManager().add(a.newGraph(), M), b = x.getChild();
+              b.add(M);
+              for (var F = 0; F < d[R].length; F++) {
+                var S = d[R][F];
+                b.remove(S), U.add(S);
+              }
+            }
+          });
+        }, E.prototype.clearCompounds = function() {
+          var a = {}, d = {};
+          this.performDFSOnCompounds();
+          for (var l = 0; l < this.compoundOrder.length; l++) d[this.compoundOrder[l].id] = this.compoundOrder[l], a[this.compoundOrder[l].id] = [].concat(this.compoundOrder[l].getChild().getNodes()), this.graphManager.remove(this.compoundOrder[l].getChild()), this.compoundOrder[l].child = null;
+          this.graphManager.resetAllNodes(), this.tileCompoundMembers(a, d);
+        }, E.prototype.clearZeroDegreeMembers = function() {
+          var a = this, d = this.tiledZeroDegreePack = [];
+          Object.keys(this.memberGroups).forEach(function(l) {
+            var v = a.idToDummyNode[l];
+            d[l] = a.tileNodes(a.memberGroups[l], v.paddingLeft + v.paddingRight), v.rect.width = d[l].width, v.rect.height = d[l].height;
+          });
+        }, E.prototype.repopulateCompounds = function() {
+          for (var a = this.compoundOrder.length - 1; a >= 0; a--) {
+            var d = this.compoundOrder[a], l = d.id, v = d.paddingLeft, _ = d.paddingTop;
+            this.adjustLocations(this.tiledMemberPack[l], d.rect.x, d.rect.y, v, _);
+          }
+        }, E.prototype.repopulateZeroDegreeMembers = function() {
+          var a = this, d = this.tiledZeroDegreePack;
+          Object.keys(d).forEach(function(l) {
+            var v = a.idToDummyNode[l], _ = v.paddingLeft, D = v.paddingTop;
+            a.adjustLocations(d[l], v.rect.x, v.rect.y, _, D);
+          });
+        }, E.prototype.getToBeTiled = function(a) {
+          var d = a.id;
+          if (this.toBeTiled[d] != null) return this.toBeTiled[d];
+          var l = a.getChild();
+          if (l == null) return this.toBeTiled[d] = !1, !1;
+          for (var v = l.getNodes(), _ = 0; _ < v.length; _++) {
+            var D = v[_];
+            if (this.getNodeDegree(D) > 0) return this.toBeTiled[d] = !1, !1;
+            if (D.getChild() == null) {
+              this.toBeTiled[D.id] = !1;
+              continue;
+            }
+            if (!this.getToBeTiled(D)) return this.toBeTiled[d] = !1, !1;
+          }
+          return this.toBeTiled[d] = !0, !0;
+        }, E.prototype.getNodeDegree = function(a) {
+          a.id;
+          for (var d = a.getEdges(), l = 0, v = 0; v < d.length; v++) {
+            var _ = d[v];
+            _.getSource().id !== _.getTarget().id && (l += 1);
+          }
+          return l;
+        }, E.prototype.getNodeDegreeWithChildren = function(a) {
+          var d = this.getNodeDegree(a);
+          if (a.getChild() == null) return d;
+          for (var l = a.getChild().getNodes(), v = 0; v < l.length; v++) {
+            var _ = l[v];
+            d += this.getNodeDegreeWithChildren(_);
+          }
+          return d;
+        }, E.prototype.performDFSOnCompounds = function() {
+          this.compoundOrder = [], this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes());
+        }, E.prototype.fillCompexOrderByDFS = function(a) {
+          for (var d = 0; d < a.length; d++) {
+            var l = a[d];
+            l.getChild() != null && this.fillCompexOrderByDFS(l.getChild().getNodes()), this.getToBeTiled(l) && this.compoundOrder.push(l);
+          }
+        }, E.prototype.adjustLocations = function(a, d, l, v, _) {
+          d += v, l += _;
+          for (var D = d, I = 0; I < a.rows.length; I++) {
+            var w = a.rows[I];
+            d = D;
+            for (var R = 0, G = 0; G < w.length; G++) {
+              var x = w[G];
+              x.rect.x = d, x.rect.y = l, d += x.rect.width + a.horizontalPadding, x.rect.height > R && (R = x.rect.height);
+            }
+            l += R + a.verticalPadding;
+          }
+        }, E.prototype.tileCompoundMembers = function(a, d) {
+          var l = this;
+          this.tiledMemberPack = [], Object.keys(a).forEach(function(v) {
+            var _ = d[v];
+            l.tiledMemberPack[v] = l.tileNodes(a[v], _.paddingLeft + _.paddingRight), _.rect.width = l.tiledMemberPack[v].width, _.rect.height = l.tiledMemberPack[v].height;
+          });
+        }, E.prototype.tileNodes = function(a, d) {
+          var l = {
+            rows: [],
+            rowWidth: [],
+            rowHeight: [],
+            width: 0,
+            height: d,
+            verticalPadding: o.TILING_PADDING_VERTICAL,
+            horizontalPadding: o.TILING_PADDING_HORIZONTAL
+          };
+          a.sort(function(D, I) {
+            return D.rect.width * D.rect.height > I.rect.width * I.rect.height ? -1 : +(D.rect.width * D.rect.height < I.rect.width * I.rect.height);
+          });
+          for (var v = 0; v < a.length; v++) {
+            var _ = a[v];
+            l.rows.length == 0 ? this.insertNodeToRow(l, _, 0, d) : this.canAddHorizontal(l, _.rect.width, _.rect.height) ? this.insertNodeToRow(l, _, this.getShortestRowIndex(l), d) : this.insertNodeToRow(l, _, l.rows.length, d), this.shiftToLastRow(l);
+          }
+          return l;
+        }, E.prototype.insertNodeToRow = function(a, d, l, v) {
+          var _ = v;
+          l == a.rows.length && (a.rows.push([]), a.rowWidth.push(_), a.rowHeight.push(0));
+          var D = a.rowWidth[l] + d.rect.width;
+          a.rows[l].length > 0 && (D += a.horizontalPadding), a.rowWidth[l] = D, a.width < D && (a.width = D);
+          var I = d.rect.height;
+          l > 0 && (I += a.verticalPadding);
+          var w = 0;
+          I > a.rowHeight[l] && (w = a.rowHeight[l], a.rowHeight[l] = I, w = a.rowHeight[l] - w), a.height += w, a.rows[l].push(d);
+        }, E.prototype.getShortestRowIndex = function(a) {
+          for (var d = -1, l = Number.MAX_VALUE, v = 0; v < a.rows.length; v++) a.rowWidth[v] < l && (d = v, l = a.rowWidth[v]);
+          return d;
+        }, E.prototype.getLongestRowIndex = function(a) {
+          for (var d = -1, l = Number.MIN_VALUE, v = 0; v < a.rows.length; v++) a.rowWidth[v] > l && (d = v, l = a.rowWidth[v]);
+          return d;
+        }, E.prototype.canAddHorizontal = function(a, d, l) {
+          var v = this.getShortestRowIndex(a);
+          if (v < 0) return !0;
+          var _ = a.rowWidth[v];
+          if (_ + a.horizontalPadding + d <= a.width) return !0;
+          var D = 0;
+          a.rowHeight[v] < l && v > 0 && (D = l + a.verticalPadding - a.rowHeight[v]);
+          var I = a.width - _ >= d + a.horizontalPadding ? (a.height + D) / (_ + d + a.horizontalPadding) : (a.height + D) / a.width;
+          D = l + a.verticalPadding;
+          var w = a.width < d ? (a.height + D) / d : (a.height + D) / a.width;
+          return w < 1 && (w = 1 / w), I < 1 && (I = 1 / I), I < w;
+        }, E.prototype.shiftToLastRow = function(a) {
+          var d = this.getLongestRowIndex(a), l = a.rowWidth.length - 1, v = a.rows[d], _ = v[v.length - 1], D = _.width + a.horizontalPadding;
+          if (a.width - a.rowWidth[l] > D && d != l) {
+            v.splice(-1, 1), a.rows[l].push(_), a.rowWidth[d] = a.rowWidth[d] - D, a.rowWidth[l] = a.rowWidth[l] + D, a.width = a.rowWidth[instance.getLongestRowIndex(a)];
+            for (var I = Number.MIN_VALUE, w = 0; w < v.length; w++) v[w].height > I && (I = v[w].height);
+            d > 0 && (I += a.verticalPadding);
+            var R = a.rowHeight[d] + a.rowHeight[l];
+            a.rowHeight[d] = I, a.rowHeight[l] < _.height + a.verticalPadding && (a.rowHeight[l] = _.height + a.verticalPadding);
+            var G = a.rowHeight[d] + a.rowHeight[l];
+            a.height += G - R, this.shiftToLastRow(a);
+          }
+        }, E.prototype.tilingPreLayout = function() {
+          o.TILE && (this.groupZeroDegreeMembers(), this.clearCompounds(), this.clearZeroDegreeMembers());
+        }, E.prototype.tilingPostLayout = function() {
+          o.TILE && (this.repopulateZeroDegreeMembers(), this.repopulateCompounds());
+        }, E.prototype.reduceTrees = function() {
+          for (var a = [], d = !0, l; d; ) {
+            var v = this.graphManager.getAllNodes(), _ = [];
+            d = !1;
+            for (var D = 0; D < v.length; D++) l = v[D], l.getEdges().length == 1 && !l.getEdges()[0].isInterGraph && l.getChild() == null && (_.push([
+              l,
+              l.getEdges()[0],
+              l.getOwner()
+            ]), d = !0);
+            if (d == 1) {
+              for (var I = [], w = 0; w < _.length; w++) _[w][0].getEdges().length == 1 && (I.push(_[w]), _[w][0].getOwner().remove(_[w][0]));
+              a.push(I), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+            }
+          }
+          this.prunedNodesAll = a;
+        }, E.prototype.growTree = function(a) {
+          for (var d = a[a.length - 1], l, v = 0; v < d.length; v++) l = d[v], this.findPlaceforPrunedNode(l), l[2].add(l[0]), l[2].add(l[1], l[1].source, l[1].target);
+          a.splice(a.length - 1, 1), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+        }, E.prototype.findPlaceforPrunedNode = function(a) {
+          var d, l, v = a[0];
+          l = v == a[1].source ? a[1].target : a[1].source;
+          var _ = l.startX, D = l.finishX, I = l.startY, w = l.finishY, R = [
+            0,
+            0,
+            0,
+            0
+          ];
+          if (I > 0) for (var G = _; G <= D; G++) R[0] += this.grid[G][I - 1].length + this.grid[G][I].length - 1;
+          if (D < this.grid.length - 1) for (var G = I; G <= w; G++) R[1] += this.grid[D + 1][G].length + this.grid[D][G].length - 1;
+          if (w < this.grid[0].length - 1) for (var G = _; G <= D; G++) R[2] += this.grid[G][w + 1].length + this.grid[G][w].length - 1;
+          if (_ > 0) for (var G = I; G <= w; G++) R[3] += this.grid[_ - 1][G].length + this.grid[_][G].length - 1;
+          for (var x = y.MAX_VALUE, M, U, b = 0; b < R.length; b++) R[b] < x ? (x = R[b], M = 1, U = b) : R[b] == x && M++;
+          if (M == 3 && x == 0) R[0] == 0 && R[1] == 0 && R[2] == 0 ? d = 1 : R[0] == 0 && R[1] == 0 && R[3] == 0 ? d = 0 : R[0] == 0 && R[2] == 0 && R[3] == 0 ? d = 3 : R[1] == 0 && R[2] == 0 && R[3] == 0 && (d = 2);
+          else if (M == 2 && x == 0) {
+            var F = Math.floor(Math.random() * 2);
+            d = R[0] == 0 && R[1] == 0 ? F == 0 ? 0 : 1 : R[0] == 0 && R[2] == 0 ? F == 0 ? 0 : 2 : R[0] == 0 && R[3] == 0 ? F == 0 ? 0 : 3 : R[1] == 0 && R[2] == 0 ? F == 0 ? 1 : 2 : R[1] == 0 && R[3] == 0 ? F == 0 ? 1 : 3 : F == 0 ? 2 : 3;
+          } else if (M == 4 && x == 0) {
+            var F = Math.floor(Math.random() * 4);
+            d = F;
+          } else d = U;
+          d == 0 ? v.setCenter(l.getCenterX(), l.getCenterY() - l.getHeight() / 2 - N.DEFAULT_EDGE_LENGTH - v.getHeight() / 2) : d == 1 ? v.setCenter(l.getCenterX() + l.getWidth() / 2 + N.DEFAULT_EDGE_LENGTH + v.getWidth() / 2, l.getCenterY()) : d == 2 ? v.setCenter(l.getCenterX(), l.getCenterY() + l.getHeight() / 2 + N.DEFAULT_EDGE_LENGTH + v.getHeight() / 2) : v.setCenter(l.getCenterX() - l.getWidth() / 2 - N.DEFAULT_EDGE_LENGTH - v.getWidth() / 2, l.getCenterY());
+        }, m.exports = E;
+      }),
+      (function(m, A, n) {
+        var e = {};
+        e.layoutBase = n(0), e.CoSEConstants = n(1), e.CoSEEdge = n(2), e.CoSEGraph = n(3), e.CoSEGraphManager = n(4), e.CoSELayout = n(6), e.CoSENode = n(5), m.exports = e;
+      })
+    ]);
+  });
+})), at = /* @__PURE__ */ st((/* @__PURE__ */ V(((C, P) => {
+  (function(L, m) {
+    typeof C == "object" && typeof P == "object" ? P.exports = m(Z()) : typeof define == "function" && define.amd ? define(["cose-base"], m) : typeof C == "object" ? C.cytoscapeCoseBilkent = m(Z()) : L.cytoscapeCoseBilkent = m(L.coseBase);
+  })(C, function(L) {
+    return (function(m) {
+      var A = {};
+      function n(e) {
+        if (A[e]) return A[e].exports;
+        var t = A[e] = {
+          i: e,
+          l: !1,
+          exports: {}
+        };
+        return m[e].call(t.exports, t, t.exports, n), t.l = !0, t.exports;
+      }
+      return n.m = m, n.c = A, n.i = function(e) {
+        return e;
+      }, n.d = function(e, t, i) {
+        n.o(e, t) || Object.defineProperty(e, t, {
+          configurable: !1,
+          enumerable: !0,
+          get: i
+        });
+      }, n.n = function(e) {
+        var t = e && e.__esModule ? function() {
+          return e.default;
+        } : function() {
+          return e;
+        };
+        return n.d(t, "a", t), t;
+      }, n.o = function(e, t) {
+        return Object.prototype.hasOwnProperty.call(e, t);
+      }, n.p = "", n(n.s = 1);
+    })([(function(m, A) {
+      m.exports = L;
+    }), (function(m, A, n) {
+      var e = n(0).layoutBase.LayoutConstants, t = n(0).layoutBase.FDLayoutConstants, i = n(0).CoSEConstants, r = n(0).CoSELayout, h = n(0).CoSENode, o = n(0).layoutBase.PointD, N = n(0).layoutBase.DimensionD, s = {
+        ready: function() {
+        },
+        stop: function() {
+        },
+        quality: "default",
+        nodeDimensionsIncludeLabels: !1,
+        refresh: 30,
+        fit: !0,
+        padding: 10,
+        randomize: !0,
+        nodeRepulsion: 4500,
+        idealEdgeLength: 50,
+        edgeElasticity: 0.45,
+        nestingFactor: 0.1,
+        gravity: 0.25,
+        numIter: 2500,
+        tile: !0,
+        animate: "end",
+        animationDuration: 500,
+        tilingPaddingVertical: 10,
+        tilingPaddingHorizontal: 10,
+        gravityRangeCompound: 1.5,
+        gravityCompound: 1,
+        gravityRange: 3.8,
+        initialEnergyOnIncremental: 0.5
+      };
+      function g(c, f) {
+        var T = {};
+        for (var E in c) T[E] = c[E];
+        for (var E in f) T[E] = f[E];
+        return T;
+      }
+      function u(c) {
+        this.options = g(s, c), p(this.options);
+      }
+      var p = function(c) {
+        c.nodeRepulsion != null && (i.DEFAULT_REPULSION_STRENGTH = t.DEFAULT_REPULSION_STRENGTH = c.nodeRepulsion), c.idealEdgeLength != null && (i.DEFAULT_EDGE_LENGTH = t.DEFAULT_EDGE_LENGTH = c.idealEdgeLength), c.edgeElasticity != null && (i.DEFAULT_SPRING_STRENGTH = t.DEFAULT_SPRING_STRENGTH = c.edgeElasticity), c.nestingFactor != null && (i.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = t.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = c.nestingFactor), c.gravity != null && (i.DEFAULT_GRAVITY_STRENGTH = t.DEFAULT_GRAVITY_STRENGTH = c.gravity), c.numIter != null && (i.MAX_ITERATIONS = t.MAX_ITERATIONS = c.numIter), c.gravityRange != null && (i.DEFAULT_GRAVITY_RANGE_FACTOR = t.DEFAULT_GRAVITY_RANGE_FACTOR = c.gravityRange), c.gravityCompound != null && (i.DEFAULT_COMPOUND_GRAVITY_STRENGTH = t.DEFAULT_COMPOUND_GRAVITY_STRENGTH = c.gravityCompound), c.gravityRangeCompound != null && (i.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = t.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = c.gravityRangeCompound), c.initialEnergyOnIncremental != null && (i.DEFAULT_COOLING_FACTOR_INCREMENTAL = t.DEFAULT_COOLING_FACTOR_INCREMENTAL = c.initialEnergyOnIncremental), c.quality == "draft" ? e.QUALITY = 0 : c.quality == "proof" ? e.QUALITY = 2 : e.QUALITY = 1, i.NODE_DIMENSIONS_INCLUDE_LABELS = t.NODE_DIMENSIONS_INCLUDE_LABELS = e.NODE_DIMENSIONS_INCLUDE_LABELS = c.nodeDimensionsIncludeLabels, i.DEFAULT_INCREMENTAL = t.DEFAULT_INCREMENTAL = e.DEFAULT_INCREMENTAL = !c.randomize, i.ANIMATE = t.ANIMATE = e.ANIMATE = c.animate, i.TILE = c.tile, i.TILING_PADDING_VERTICAL = typeof c.tilingPaddingVertical == "function" ? c.tilingPaddingVertical.call() : c.tilingPaddingVertical, i.TILING_PADDING_HORIZONTAL = typeof c.tilingPaddingHorizontal == "function" ? c.tilingPaddingHorizontal.call() : c.tilingPaddingHorizontal;
+      };
+      u.prototype.run = function() {
+        var c, f, T = this.options;
+        this.idToLNode = {};
+        var E = this.layout = new r(), O = this;
+        O.stopped = !1, this.cy = this.options.cy, this.cy.trigger({
+          type: "layoutstart",
+          layout: this
+        });
+        var a = E.newGraphManager();
+        this.gm = a;
+        var d = this.options.eles.nodes(), l = this.options.eles.edges();
+        this.root = a.addRoot(), this.processChildrenList(this.root, this.getTopMostNodes(d), E);
+        for (var v = 0; v < l.length; v++) {
+          var _ = l[v], D = this.idToLNode[_.data("source")], I = this.idToLNode[_.data("target")];
+          if (D !== I && D.getEdgesBetween(I).length == 0) {
+            var w = a.add(E.newEdge(), D, I);
+            w.id = _.id();
+          }
+        }
+        var R = function(x, M) {
+          typeof x == "number" && (x = M);
+          var U = x.data("id"), b = O.idToLNode[U];
+          return {
+            x: b.getRect().getCenterX(),
+            y: b.getRect().getCenterY()
+          };
+        }, G = function x() {
+          for (var M = function() {
+            T.fit && T.cy.fit(T.eles, T.padding), c || (c = !0, O.cy.one("layoutready", T.ready), O.cy.trigger({
+              type: "layoutready",
+              layout: O
+            }));
+          }, U = O.options.refresh, b, F = 0; F < U && !b; F++) b = O.stopped || O.layout.tick();
+          if (b) {
+            E.checkLayoutSuccess() && !E.isSubLayout && E.doPostLayout(), E.tilingPostLayout && E.tilingPostLayout(), E.isLayoutFinished = !0, O.options.eles.nodes().positions(R), M(), O.cy.one("layoutstop", O.options.stop), O.cy.trigger({
+              type: "layoutstop",
+              layout: O
+            }), f && cancelAnimationFrame(f), c = !1;
+            return;
+          }
+          var S = O.layout.getPositionsData();
+          T.eles.nodes().positions(function(Y, X) {
+            if (typeof Y == "number" && (Y = X), !Y.isParent()) {
+              for (var W = Y.id(), B = S[W], H = Y; B == null && (B = S[H.data("parent")] || S["DummyCompound_" + H.data("parent")], S[W] = B, H = H.parent()[0], H != null); ) ;
+              return B == null ? {
+                x: Y.position("x"),
+                y: Y.position("y")
+              } : {
+                x: B.x,
+                y: B.y
+              };
+            }
+          }), M(), f = requestAnimationFrame(x);
+        };
+        return E.addListener("layoutstarted", function() {
+          O.options.animate === "during" && (f = requestAnimationFrame(G));
+        }), E.runLayout(), this.options.animate !== "during" && (O.options.eles.nodes().not(":parent").layoutPositions(O, O.options, R), c = !1), this;
+      }, u.prototype.getTopMostNodes = function(c) {
+        for (var f = {}, T = 0; T < c.length; T++) f[c[T].id()] = !0;
+        return c.filter(function(E, O) {
+          typeof E == "number" && (E = O);
+          for (var a = E.parent()[0]; a != null; ) {
+            if (f[a.id()]) return !1;
+            a = a.parent()[0];
+          }
+          return !0;
+        });
+      }, u.prototype.processChildrenList = function(c, f, T) {
+        for (var E = f.length, O = 0; O < E; O++) {
+          var a = f[O], d = a.children(), l, v = a.layoutDimensions({ nodeDimensionsIncludeLabels: this.options.nodeDimensionsIncludeLabels });
+          if (l = a.outerWidth() != null && a.outerHeight() != null ? c.add(new h(T.graphManager, new o(a.position("x") - v.w / 2, a.position("y") - v.h / 2), new N(parseFloat(v.w), parseFloat(v.h)))) : c.add(new h(this.graphManager)), l.id = a.data("id"), l.paddingLeft = parseInt(a.css("padding")), l.paddingTop = parseInt(a.css("padding")), l.paddingRight = parseInt(a.css("padding")), l.paddingBottom = parseInt(a.css("padding")), this.options.nodeDimensionsIncludeLabels && a.isParent()) {
+            var _ = a.boundingBox({
+              includeLabels: !0,
+              includeNodes: !1
+            }).w, D = a.boundingBox({
+              includeLabels: !0,
+              includeNodes: !1
+            }).h, I = a.css("text-halign");
+            l.labelWidth = _, l.labelHeight = D, l.labelPos = I;
+          }
+          if (this.idToLNode[a.data("id")] = l, isNaN(l.rect.x) && (l.rect.x = 0), isNaN(l.rect.y) && (l.rect.y = 0), d != null && d.length > 0) {
+            var w = T.getGraphManager().add(T.newGraph(), l);
+            this.processChildrenList(w, d, T);
+          }
+        }
+      }, u.prototype.stop = function() {
+        return this.stopped = !0, this;
+      };
+      var y = function(c) {
+        c("layout", "cose-bilkent", u);
+      };
+      typeof cytoscape < "u" && y(cytoscape), m.exports = y;
+    })]);
+  });
+})))());
+$.use(at.default);
+function Q(C, P) {
+  C.forEach((L) => {
+    let m = {
+      id: L.id,
+      labelText: L.label,
+      height: L.height,
+      width: L.width,
+      padding: L.padding ?? 0
+    };
+    Object.keys(L).forEach((A) => {
+      [
+        "id",
+        "label",
+        "height",
+        "width",
+        "padding",
+        "x",
+        "y"
+      ].includes(A) || (m[A] = L[A]);
+    }), P.add({
+      group: "nodes",
+      data: m,
+      position: {
+        x: L.x ?? 0,
+        y: L.y ?? 0
+      }
+    });
+  });
+}
+k(Q, "addNodes");
+function K(C, P) {
+  C.forEach((L) => {
+    let m = {
+      id: L.id,
+      source: L.start,
+      target: L.end
+    };
+    Object.keys(L).forEach((A) => {
+      [
+        "id",
+        "start",
+        "end"
+      ].includes(A) || (m[A] = L[A]);
+    }), P.add({
+      group: "edges",
+      data: m
+    });
+  });
+}
+k(K, "addEdges");
+function J(C) {
+  return new Promise((P) => {
+    let L = nt("body").append("div").attr("id", "cy").attr("style", "display:none"), m = $({
+      container: document.getElementById("cy"),
+      style: [{
+        selector: "edge",
+        style: { "curve-style": "bezier" }
+      }]
+    });
+    L.remove(), Q(C.nodes, m), K(C.edges, m), m.nodes().forEach(function(A) {
+      A.layoutDimensions = () => {
+        let n = A.data();
+        return {
+          w: n.width,
+          h: n.height
+        };
+      };
+    }), m.layout({
+      name: "cose-bilkent",
+      quality: "proof",
+      styleEnabled: !1,
+      animate: !1
+    }).run(), m.ready((A) => {
+      j.info("Cytoscape ready", A), P(m);
+    });
+  });
+}
+k(J, "createCytoscapeInstance");
+function tt(C) {
+  return C.nodes().map((P) => {
+    let L = P.data(), m = P.position(), A = {
+      id: L.id,
+      x: m.x,
+      y: m.y
+    };
+    return Object.keys(L).forEach((n) => {
+      n !== "id" && (A[n] = L[n]);
+    }), A;
+  });
+}
+k(tt, "extractPositionedNodes");
+function et(C) {
+  return C.edges().map((P) => {
+    let L = P.data(), m = P._private.rscratch, A = {
+      id: L.id,
+      source: L.source,
+      target: L.target,
+      startX: m.startX,
+      startY: m.startY,
+      midX: m.midX,
+      midY: m.midY,
+      endX: m.endX,
+      endY: m.endY
+    };
+    return Object.keys(L).forEach((n) => {
+      [
+        "id",
+        "source",
+        "target"
+      ].includes(n) || (A[n] = L[n]);
+    }), A;
+  });
+}
+k(et, "extractPositionedEdges");
+async function it(C, P) {
+  j.debug("Starting cose-bilkent layout algorithm");
+  try {
+    rt(C);
+    let L = await J(C), m = tt(L), A = et(L);
+    return j.debug(`Layout completed: ${m.length} nodes, ${A.length} edges`), {
+      nodes: m,
+      edges: A
+    };
+  } catch (L) {
+    throw j.error("Error in cose-bilkent layout algorithm:", L), L;
+  }
+}
+k(it, "executeCoseBilkentLayout");
+function rt(C) {
+  if (!C) throw Error("Layout data is required");
+  if (!C.config) throw Error("Configuration is required in layout data");
+  if (!C.rootNode) throw Error("Root node is required");
+  if (!C.nodes || !Array.isArray(C.nodes)) throw Error("No nodes found in layout data");
+  if (!Array.isArray(C.edges)) throw Error("Edges array is required in layout data");
+  return !0;
+}
+k(rt, "validateLayoutData");
+var gt = /* @__PURE__ */ k(async (C, P, { insertCluster: L, insertEdge: m, insertEdgeLabel: A, insertMarkers: n, insertNode: e, log: t, positionEdgeLabel: i }, { algorithm: r }) => {
+  let h = {}, o = {}, N = P.select("g");
+  n(N, C.markers, C.type, C.diagramId);
+  let s = N.insert("g").attr("class", "subgraphs"), g = N.insert("g").attr("class", "edgePaths"), u = N.insert("g").attr("class", "edgeLabels"), p = N.insert("g").attr("class", "nodes");
+  t.debug("Inserting nodes into DOM for dimension calculation"), await Promise.all(C.nodes.map(async (c) => {
+    if (c.isGroup) {
+      let f = { ...c };
+      o[c.id] = f, h[c.id] = f, await L(s, c);
+    } else {
+      let f = { ...c };
+      h[c.id] = f;
+      let T = await e(p, c, {
+        config: C.config,
+        dir: C.direction || "TB"
+      }), E = T.node().getBBox();
+      f.width = E.width, f.height = E.height, f.domId = T, t.debug(`Node ${c.id} dimensions: ${E.width}x${E.height}`);
+    }
+  })), t.debug("Running cose-bilkent layout algorithm");
+  let y = await it({
+    ...C,
+    nodes: C.nodes.map((c) => {
+      let f = h[c.id];
+      return {
+        ...c,
+        width: f.width,
+        height: f.height
+      };
+    })
+  }, C.config);
+  t.debug("Positioning nodes based on layout results"), y.nodes.forEach((c) => {
+    let f = h[c.id];
+    f?.domId && (f.domId.attr("transform", `translate(${c.x}, ${c.y})`), f.x = c.x, f.y = c.y, t.debug(`Positioned node ${f.id} at center (${c.x}, ${c.y})`));
+  }), y.edges.forEach((c) => {
+    let f = C.edges.find((T) => T.id === c.id);
+    f && (f.points = [
+      {
+        x: c.startX,
+        y: c.startY
+      },
+      {
+        x: c.midX,
+        y: c.midY
+      },
+      {
+        x: c.endX,
+        y: c.endY
+      }
+    ]);
+  }), t.debug("Inserting and positioning edges"), await Promise.all(C.edges.map(async (c) => {
+    await A(u, c);
+    let f = h[c.start ?? ""], T = h[c.end ?? ""];
+    if (f && T) {
+      let E = y.edges.find((O) => O.id === c.id);
+      if (E) {
+        t.debug("APA01 positionedEdge", E);
+        let O = { ...c };
+        i(O, m(g, O, o, C.type, f, T, C.diagramId));
+      } else {
+        let O = {
+          ...c,
+          points: [{
+            x: f.x || 0,
+            y: f.y || 0
+          }, {
+            x: T.x || 0,
+            y: T.y || 0
+          }]
+        };
+        i(O, m(g, O, o, C.type, f, T, C.diagramId));
+      }
+    }
+  })), t.debug("Cose-bilkent rendering completed");
+}, "render");
+export {
+  gt as render
+};