ranui 0.2.1-alpha.1 → 0.2.1-alpha.3

package/dist/cose-bilkent-JH36ORCC-DTwvJlGw.js

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