@kong-ui-public/documentation 1.7.3-pr.3596.41e70338d.0 → 1.7.3

package/dist/architectureDiagram-3BPJPVTR-By_DXDyu-U3MSLbOU.js

@@ -0,0 +1,4065 @@
+import { p as gt, a0 as Ue, au as Xe, g as _e, Z as ce, aD as ue, b6 as de, c as ze, q as Be, I as Ve, U as We, W as je, f as $e, i as qe, K as Ze, G as Ke, H as Je, s as Qe, o as ti, F as ei, u as ii, M as fe, b7 as ri, b8 as oi } from "./index-DfVKdDwj.js";
+import { t as ni } from "./chunk-4BX2VUAB-C_NnimAy--QQ0Db2V.js";
+import { r as ai } from "./wardley-L42UT6IY-BjAkE_cs-C-giFqos.js";
+import { K as xe } from "./cytoscape.esm-BDIiOYYO-C1jMBhD8.js";
+var Ae = /* @__PURE__ */ fe(((M, _) => {
+  (function(A, D) {
+    typeof M == "object" && typeof _ == "object" ? _.exports = D() : typeof define == "function" && define.amd ? define([], D) : typeof M == "object" ? M.layoutBase = D() : A.layoutBase = D();
+  })(M, function() {
+    return (function(A) {
+      var D = {};
+      function N(f) {
+        if (D[f]) return D[f].exports;
+        var o = D[f] = {
+          i: f,
+          l: !1,
+          exports: {}
+        };
+        return A[f].call(o.exports, o, o.exports, N), o.l = !0, o.exports;
+      }
+      return N.m = A, N.c = D, N.i = function(f) {
+        return f;
+      }, N.d = function(f, o, r) {
+        N.o(f, o) || Object.defineProperty(f, o, {
+          configurable: !1,
+          enumerable: !0,
+          get: r
+        });
+      }, N.n = function(f) {
+        var o = f && f.__esModule ? function() {
+          return f.default;
+        } : function() {
+          return f;
+        };
+        return N.d(o, "a", o), o;
+      }, N.o = function(f, o) {
+        return Object.prototype.hasOwnProperty.call(f, o);
+      }, N.p = "", N(N.s = 28);
+    })([
+      (function(A, D, N) {
+        function f() {
+        }
+        f.QUALITY = 1, f.DEFAULT_CREATE_BENDS_AS_NEEDED = !1, f.DEFAULT_INCREMENTAL = !1, f.DEFAULT_ANIMATION_ON_LAYOUT = !0, f.DEFAULT_ANIMATION_DURING_LAYOUT = !1, f.DEFAULT_ANIMATION_PERIOD = 50, f.DEFAULT_UNIFORM_LEAF_NODE_SIZES = !1, f.DEFAULT_GRAPH_MARGIN = 15, f.NODE_DIMENSIONS_INCLUDE_LABELS = !1, f.SIMPLE_NODE_SIZE = 40, f.SIMPLE_NODE_HALF_SIZE = f.SIMPLE_NODE_SIZE / 2, f.EMPTY_COMPOUND_NODE_SIZE = 40, f.MIN_EDGE_LENGTH = 1, f.WORLD_BOUNDARY = 1e6, f.INITIAL_WORLD_BOUNDARY = f.WORLD_BOUNDARY / 1e3, f.WORLD_CENTER_X = 1200, f.WORLD_CENTER_Y = 900, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = N(2), o = N(8), r = N(9);
+        function t(l, i, p) {
+          f.call(this, p), this.isOverlapingSourceAndTarget = !1, this.vGraphObject = p, this.bendpoints = [], this.source = l, this.target = i;
+        }
+        for (var e in t.prototype = Object.create(f.prototype), f) t[e] = f[e];
+        t.prototype.getSource = function() {
+          return this.source;
+        }, t.prototype.getTarget = function() {
+          return this.target;
+        }, t.prototype.isInterGraph = function() {
+          return this.isInterGraph;
+        }, t.prototype.getLength = function() {
+          return this.length;
+        }, t.prototype.isOverlapingSourceAndTarget = function() {
+          return this.isOverlapingSourceAndTarget;
+        }, t.prototype.getBendpoints = function() {
+          return this.bendpoints;
+        }, t.prototype.getLca = function() {
+          return this.lca;
+        }, t.prototype.getSourceInLca = function() {
+          return this.sourceInLca;
+        }, t.prototype.getTargetInLca = function() {
+          return this.targetInLca;
+        }, t.prototype.getOtherEnd = function(l) {
+          if (this.source === l) return this.target;
+          if (this.target === l) return this.source;
+          throw "Node is not incident with this edge";
+        }, t.prototype.getOtherEndInGraph = function(l, i) {
+          for (var p = this.getOtherEnd(l), a = i.getGraphManager().getRoot(); ; ) {
+            if (p.getOwner() == i) return p;
+            if (p.getOwner() == a) break;
+            p = p.getOwner().getParent();
+          }
+          return null;
+        }, t.prototype.updateLength = function() {
+          var l = [
+            ,
+            ,
+            ,
+            ,
+          ];
+          this.isOverlapingSourceAndTarget = o.getIntersection(this.target.getRect(), this.source.getRect(), l), this.isOverlapingSourceAndTarget || (this.lengthX = l[0] - l[2], this.lengthY = l[1] - l[3], Math.abs(this.lengthX) < 1 && (this.lengthX = r.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = r.sign(this.lengthY)), this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY));
+        }, t.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 = r.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = r.sign(this.lengthY)), this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+        }, A.exports = t;
+      }),
+      (function(A, D, N) {
+        function f(o) {
+          this.vGraphObject = o;
+        }
+        A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = N(2), o = N(10), r = N(13), t = N(0), e = N(16), l = N(5);
+        function i(a, n, g, h) {
+          g == null && h == null && (h = n), f.call(this, h), a.graphManager != null && (a = a.graphManager), this.estimatedSize = o.MIN_VALUE, this.inclusionTreeDepth = o.MAX_VALUE, this.vGraphObject = h, this.edges = [], this.graphManager = a, g != null && n != null ? this.rect = new r(n.x, n.y, g.width, g.height) : this.rect = new r();
+        }
+        for (var p in i.prototype = Object.create(f.prototype), f) i[p] = f[p];
+        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(a) {
+          this.rect.width = a;
+        }, i.prototype.getHeight = function() {
+          return this.rect.height;
+        }, i.prototype.setHeight = function(a) {
+          this.rect.height = a;
+        }, 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 l(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2);
+        }, i.prototype.getLocation = function() {
+          return new l(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(a, n) {
+          this.rect.x = a.x, this.rect.y = a.y, this.rect.width = n.width, this.rect.height = n.height;
+        }, i.prototype.setCenter = function(a, n) {
+          this.rect.x = a - this.rect.width / 2, this.rect.y = n - this.rect.height / 2;
+        }, i.prototype.setLocation = function(a, n) {
+          this.rect.x = a, this.rect.y = n;
+        }, i.prototype.moveBy = function(a, n) {
+          this.rect.x += a, this.rect.y += n;
+        }, i.prototype.getEdgeListToNode = function(a) {
+          var n = [], g = this;
+          return g.edges.forEach(function(h) {
+            if (h.target == a) {
+              if (h.source != g) throw "Incorrect edge source!";
+              n.push(h);
+            }
+          }), n;
+        }, i.prototype.getEdgesBetween = function(a) {
+          var n = [], g = this;
+          return g.edges.forEach(function(h) {
+            if (!(h.source == g || h.target == g)) throw "Incorrect edge source and/or target";
+            (h.target == a || h.source == a) && n.push(h);
+          }), n;
+        }, i.prototype.getNeighborsList = function() {
+          var a = /* @__PURE__ */ new Set(), n = this;
+          return n.edges.forEach(function(g) {
+            if (g.source == n) a.add(g.target);
+            else {
+              if (g.target != n) throw "Incorrect incidency!";
+              a.add(g.source);
+            }
+          }), a;
+        }, i.prototype.withChildren = function() {
+          var a = /* @__PURE__ */ new Set(), n, g;
+          if (a.add(this), this.child != null) for (var h = this.child.getNodes(), c = 0; c < h.length; c++) n = h[c], g = n.withChildren(), g.forEach(function(d) {
+            a.add(d);
+          });
+          return a;
+        }, i.prototype.getNoOfChildren = function() {
+          var a = 0, n;
+          if (this.child == null) a = 1;
+          else for (var g = this.child.getNodes(), h = 0; h < g.length; h++) n = g[h], a += n.getNoOfChildren();
+          return a == 0 && (a = 1), a;
+        }, i.prototype.getEstimatedSize = function() {
+          if (this.estimatedSize == o.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 a, n, g = -t.INITIAL_WORLD_BOUNDARY, h = t.INITIAL_WORLD_BOUNDARY;
+          a = t.WORLD_CENTER_X + e.nextDouble() * (h - g) + g;
+          var c = -t.INITIAL_WORLD_BOUNDARY, d = t.INITIAL_WORLD_BOUNDARY;
+          n = t.WORLD_CENTER_Y + e.nextDouble() * (d - c) + c, this.rect.x = a, this.rect.y = n;
+        }, i.prototype.updateBounds = function() {
+          if (this.getChild() == null) throw "assert failed";
+          if (this.getChild().getNodes().length != 0) {
+            var a = this.getChild();
+            if (a.updateBounds(!0), this.rect.x = a.getLeft(), this.rect.y = a.getTop(), this.setWidth(a.getRight() - a.getLeft()), this.setHeight(a.getBottom() - a.getTop()), t.NODE_DIMENSIONS_INCLUDE_LABELS) {
+              var n = a.getRight() - a.getLeft(), g = a.getBottom() - a.getTop();
+              this.labelWidth && (this.labelPosHorizontal == "left" ? (this.rect.x -= this.labelWidth, this.setWidth(n + this.labelWidth)) : this.labelPosHorizontal == "center" && this.labelWidth > n ? (this.rect.x -= (this.labelWidth - n) / 2, this.setWidth(this.labelWidth)) : this.labelPosHorizontal == "right" && this.setWidth(n + this.labelWidth)), this.labelHeight && (this.labelPosVertical == "top" ? (this.rect.y -= this.labelHeight, this.setHeight(g + this.labelHeight)) : this.labelPosVertical == "center" && this.labelHeight > g ? (this.rect.y -= (this.labelHeight - g) / 2, this.setHeight(this.labelHeight)) : this.labelPosVertical == "bottom" && this.setHeight(g + this.labelHeight));
+            }
+          }
+        }, i.prototype.getInclusionTreeDepth = function() {
+          if (this.inclusionTreeDepth == o.MAX_VALUE) throw "assert failed";
+          return this.inclusionTreeDepth;
+        }, i.prototype.transform = function(a) {
+          var n = this.rect.x;
+          n > t.WORLD_BOUNDARY ? n = t.WORLD_BOUNDARY : n < -t.WORLD_BOUNDARY && (n = -t.WORLD_BOUNDARY);
+          var g = this.rect.y;
+          g > t.WORLD_BOUNDARY ? g = t.WORLD_BOUNDARY : g < -t.WORLD_BOUNDARY && (g = -t.WORLD_BOUNDARY);
+          var h = new l(n, g), c = a.inverseTransformPoint(h);
+          this.setLocation(c.x, c.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();
+        }, A.exports = i;
+      }),
+      (function(A, D, N) {
+        var f = N(0);
+        function o() {
+        }
+        for (var r in f) o[r] = f[r];
+        o.MAX_ITERATIONS = 2500, o.DEFAULT_EDGE_LENGTH = 50, o.DEFAULT_SPRING_STRENGTH = 0.45, o.DEFAULT_REPULSION_STRENGTH = 4500, o.DEFAULT_GRAVITY_STRENGTH = 0.4, o.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1, o.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8, o.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5, o.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = !0, o.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = !0, o.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3, o.COOLING_ADAPTATION_FACTOR = 0.33, o.ADAPTATION_LOWER_NODE_LIMIT = 1e3, o.ADAPTATION_UPPER_NODE_LIMIT = 5e3, o.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100, o.MAX_NODE_DISPLACEMENT = o.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3, o.MIN_REPULSION_DIST = o.DEFAULT_EDGE_LENGTH / 10, o.CONVERGENCE_CHECK_PERIOD = 100, o.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1, o.MIN_EDGE_LENGTH = 1, o.GRID_CALCULATION_CHECK_PERIOD = 10, A.exports = o;
+      }),
+      (function(A, D, N) {
+        function f(o, r) {
+          o == null && r == null ? (this.x = 0, this.y = 0) : (this.x = o, this.y = r);
+        }
+        f.prototype.getX = function() {
+          return this.x;
+        }, f.prototype.getY = function() {
+          return this.y;
+        }, f.prototype.setX = function(o) {
+          this.x = o;
+        }, f.prototype.setY = function(o) {
+          this.y = o;
+        }, f.prototype.getDifference = function(o) {
+          return new DimensionD(this.x - o.x, this.y - o.y);
+        }, f.prototype.getCopy = function() {
+          return new f(this.x, this.y);
+        }, f.prototype.translate = function(o) {
+          return this.x += o.width, this.y += o.height, this;
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = N(2), o = N(10), r = N(0), t = N(7), e = N(3), l = N(1), i = N(13), p = N(12), a = N(11);
+        function n(h, c, d) {
+          f.call(this, d), this.estimatedSize = o.MIN_VALUE, this.margin = r.DEFAULT_GRAPH_MARGIN, this.edges = [], this.nodes = [], this.isConnected = !1, this.parent = h, c != null && c instanceof t ? this.graphManager = c : c != null && c instanceof Layout && (this.graphManager = c.graphManager);
+        }
+        for (var g in n.prototype = Object.create(f.prototype), f) n[g] = f[g];
+        n.prototype.getNodes = function() {
+          return this.nodes;
+        }, n.prototype.getEdges = function() {
+          return this.edges;
+        }, n.prototype.getGraphManager = function() {
+          return this.graphManager;
+        }, n.prototype.getParent = function() {
+          return this.parent;
+        }, n.prototype.getLeft = function() {
+          return this.left;
+        }, n.prototype.getRight = function() {
+          return this.right;
+        }, n.prototype.getTop = function() {
+          return this.top;
+        }, n.prototype.getBottom = function() {
+          return this.bottom;
+        }, n.prototype.isConnected = function() {
+          return this.isConnected;
+        }, n.prototype.add = function(h, c, d) {
+          if (c == null && d == null) {
+            var v = h;
+            if (this.graphManager == null) throw "Graph has no graph mgr!";
+            if (this.getNodes().indexOf(v) > -1) throw "Node already in graph!";
+            return v.owner = this, this.getNodes().push(v), v;
+          } else {
+            var T = h;
+            if (!(this.getNodes().indexOf(c) > -1 && this.getNodes().indexOf(d) > -1)) throw "Source or target not in graph!";
+            if (!(c.owner == d.owner && c.owner == this)) throw "Both owners must be this graph!";
+            return c.owner == d.owner ? (T.source = c, T.target = d, T.isInterGraph = !1, this.getEdges().push(T), c.edges.push(T), d != c && d.edges.push(T), T) : null;
+          }
+        }, n.prototype.remove = function(h) {
+          var c = h;
+          if (h instanceof e) {
+            if (c == null) throw "Node is null!";
+            if (!(c.owner != null && c.owner == this)) throw "Owner graph is invalid!";
+            if (this.graphManager == null) throw "Owner graph manager is invalid!";
+            for (var d = c.edges.slice(), v, T = d.length, L = 0; L < T; L++) v = d[L], v.isInterGraph ? this.graphManager.remove(v) : v.source.owner.remove(v);
+            var F = this.nodes.indexOf(c);
+            if (F == -1) throw "Node not in owner node list!";
+            this.nodes.splice(F, 1);
+          } else if (h instanceof l) {
+            var v = h;
+            if (v == null) throw "Edge is null!";
+            if (!(v.source != null && v.target != null)) throw "Source and/or target is null!";
+            if (!(v.source.owner != null && v.target.owner != null && v.source.owner == this && v.target.owner == this)) throw "Source and/or target owner is invalid!";
+            var S = v.source.edges.indexOf(v), P = v.target.edges.indexOf(v);
+            if (!(S > -1 && P > -1)) throw "Source and/or target doesn't know this edge!";
+            v.source.edges.splice(S, 1), v.target != v.source && v.target.edges.splice(P, 1);
+            var F = v.source.owner.getEdges().indexOf(v);
+            if (F == -1) throw "Not in owner's edge list!";
+            v.source.owner.getEdges().splice(F, 1);
+          }
+        }, n.prototype.updateLeftTop = function() {
+          for (var h = o.MAX_VALUE, c = o.MAX_VALUE, d, v, T, L = this.getNodes(), F = L.length, S = 0; S < F; S++) {
+            var P = L[S];
+            d = P.getTop(), v = P.getLeft(), h > d && (h = d), c > v && (c = v);
+          }
+          return h == o.MAX_VALUE ? null : (T = L[0].getParent().paddingLeft == null ? this.margin : L[0].getParent().paddingLeft, this.left = c - T, this.top = h - T, new p(this.left, this.top));
+        }, n.prototype.updateBounds = function(h) {
+          for (var c = o.MAX_VALUE, d = -o.MAX_VALUE, v = o.MAX_VALUE, T = -o.MAX_VALUE, L, F, S, P, U, Z = this.nodes, x = Z.length, K = 0; K < x; K++) {
+            var s = Z[K];
+            h && s.child != null && s.updateBounds(), L = s.getLeft(), F = s.getRight(), S = s.getTop(), P = s.getBottom(), c > L && (c = L), d < F && (d = F), v > S && (v = S), T < P && (T = P);
+          }
+          var E = new i(c, v, d - c, T - v);
+          c == o.MAX_VALUE && (this.left = this.parent.getLeft(), this.right = this.parent.getRight(), this.top = this.parent.getTop(), this.bottom = this.parent.getBottom()), U = Z[0].getParent().paddingLeft == null ? this.margin : Z[0].getParent().paddingLeft, this.left = E.x - U, this.right = E.x + E.width + U, this.top = E.y - U, this.bottom = E.y + E.height + U;
+        }, n.calculateBounds = function(h) {
+          for (var c = o.MAX_VALUE, d = -o.MAX_VALUE, v = o.MAX_VALUE, T = -o.MAX_VALUE, L, F, S, P, U = h.length, Z = 0; Z < U; Z++) {
+            var x = h[Z];
+            L = x.getLeft(), F = x.getRight(), S = x.getTop(), P = x.getBottom(), c > L && (c = L), d < F && (d = F), v > S && (v = S), T < P && (T = P);
+          }
+          return new i(c, v, d - c, T - v);
+        }, n.prototype.getInclusionTreeDepth = function() {
+          return this == this.graphManager.getRoot() ? 1 : this.parent.getInclusionTreeDepth();
+        }, n.prototype.getEstimatedSize = function() {
+          if (this.estimatedSize == o.MIN_VALUE) throw "assert failed";
+          return this.estimatedSize;
+        }, n.prototype.calcEstimatedSize = function() {
+          for (var h = 0, c = this.nodes, d = c.length, v = 0; v < d; v++) {
+            var T = c[v];
+            h += T.calcEstimatedSize();
+          }
+          return h == 0 ? this.estimatedSize = r.EMPTY_COMPOUND_NODE_SIZE : this.estimatedSize = h / Math.sqrt(this.nodes.length), this.estimatedSize;
+        }, n.prototype.updateConnected = function() {
+          var h = this;
+          if (this.nodes.length == 0) {
+            this.isConnected = !0;
+            return;
+          }
+          var c = new a(), d = /* @__PURE__ */ new Set(), v = this.nodes[0], T, L;
+          for (v.withChildren().forEach(function(U) {
+            c.push(U), d.add(U);
+          }); c.length !== 0; ) {
+            v = c.shift(), T = v.getEdges();
+            for (var F = T.length, S = 0; S < F; S++) L = T[S].getOtherEndInGraph(v, this), L != null && !d.has(L) && L.withChildren().forEach(function(U) {
+              c.push(U), d.add(U);
+            });
+          }
+          if (this.isConnected = !1, d.size >= this.nodes.length) {
+            var P = 0;
+            d.forEach(function(U) {
+              U.owner == h && P++;
+            }), P == this.nodes.length && (this.isConnected = !0);
+          }
+        }, A.exports = n;
+      }),
+      (function(A, D, N) {
+        var f, o = N(1);
+        function r(t) {
+          f = N(6), this.layout = t, this.graphs = [], this.edges = [];
+        }
+        r.prototype.addRoot = function() {
+          var t = this.layout.newGraph(), e = this.layout.newNode(null), l = this.add(t, e);
+          return this.setRootGraph(l), this.rootGraph;
+        }, r.prototype.add = function(t, e, l, i, p) {
+          if (l == null && i == null && p == null) {
+            if (t == null) throw "Graph is null!";
+            if (e == null) throw "Parent node is null!";
+            if (this.graphs.indexOf(t) > -1) throw "Graph already in this graph mgr!";
+            if (this.graphs.push(t), t.parent != null) throw "Already has a parent!";
+            if (e.child != null) throw "Already has a child!";
+            return t.parent = e, e.child = t, t;
+          } else {
+            p = l, i = e, l = t;
+            var a = i.getOwner(), n = p.getOwner();
+            if (!(a != null && a.getGraphManager() == this)) throw "Source not in this graph mgr!";
+            if (!(n != null && n.getGraphManager() == this)) throw "Target not in this graph mgr!";
+            if (a == n) return l.isInterGraph = !1, a.add(l, i, p);
+            if (l.isInterGraph = !0, l.source = i, l.target = p, this.edges.indexOf(l) > -1) throw "Edge already in inter-graph edge list!";
+            if (this.edges.push(l), !(l.source != null && l.target != null)) throw "Edge source and/or target is null!";
+            if (!(l.source.edges.indexOf(l) == -1 && l.target.edges.indexOf(l) == -1)) throw "Edge already in source and/or target incidency list!";
+            return l.source.edges.push(l), l.target.edges.push(l), l;
+          }
+        }, r.prototype.remove = function(t) {
+          if (t instanceof f) {
+            var e = t;
+            if (e.getGraphManager() != this) throw "Graph not in this graph mgr";
+            if (!(e == this.rootGraph || e.parent != null && e.parent.graphManager == this)) throw "Invalid parent node!";
+            var l = [];
+            l = l.concat(e.getEdges());
+            for (var i, p = l.length, a = 0; a < p; a++) i = l[a], e.remove(i);
+            var n = [];
+            n = n.concat(e.getNodes());
+            var g;
+            p = n.length;
+            for (var a = 0; a < p; a++) g = n[a], e.remove(g);
+            e == this.rootGraph && this.setRootGraph(null);
+            var h = this.graphs.indexOf(e);
+            this.graphs.splice(h, 1), e.parent = null;
+          } else if (t instanceof o) {
+            if (i = t, 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 h = i.source.edges.indexOf(i);
+            if (i.source.edges.splice(h, 1), h = i.target.edges.indexOf(i), i.target.edges.splice(h, 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 h = i.source.owner.getGraphManager().edges.indexOf(i);
+            i.source.owner.getGraphManager().edges.splice(h, 1);
+          }
+        }, r.prototype.updateBounds = function() {
+          this.rootGraph.updateBounds(!0);
+        }, r.prototype.getGraphs = function() {
+          return this.graphs;
+        }, r.prototype.getAllNodes = function() {
+          if (this.allNodes == null) {
+            for (var t = [], e = this.getGraphs(), l = e.length, i = 0; i < l; i++) t = t.concat(e[i].getNodes());
+            this.allNodes = t;
+          }
+          return this.allNodes;
+        }, r.prototype.resetAllNodes = function() {
+          this.allNodes = null;
+        }, r.prototype.resetAllEdges = function() {
+          this.allEdges = null;
+        }, r.prototype.resetAllNodesToApplyGravitation = function() {
+          this.allNodesToApplyGravitation = null;
+        }, r.prototype.getAllEdges = function() {
+          if (this.allEdges == null) {
+            var t = [], e = this.getGraphs();
+            e.length;
+            for (var l = 0; l < e.length; l++) t = t.concat(e[l].getEdges());
+            t = t.concat(this.edges), this.allEdges = t;
+          }
+          return this.allEdges;
+        }, r.prototype.getAllNodesToApplyGravitation = function() {
+          return this.allNodesToApplyGravitation;
+        }, r.prototype.setAllNodesToApplyGravitation = function(t) {
+          if (this.allNodesToApplyGravitation != null) throw "assert failed";
+          this.allNodesToApplyGravitation = t;
+        }, r.prototype.getRoot = function() {
+          return this.rootGraph;
+        }, r.prototype.setRootGraph = function(t) {
+          if (t.getGraphManager() != this) throw "Root not in this graph mgr!";
+          this.rootGraph = t, t.parent ??= this.layout.newNode("Root node");
+        }, r.prototype.getLayout = function() {
+          return this.layout;
+        }, r.prototype.isOneAncestorOfOther = function(t, e) {
+          if (!(t != null && e != null)) throw "assert failed";
+          if (t == e) return !0;
+          var l = t.getOwner(), i;
+          do {
+            if (i = l.getParent(), i == null) break;
+            if (i == e) return !0;
+            if (l = i.getOwner(), l == null) break;
+          } while (!0);
+          l = e.getOwner();
+          do {
+            if (i = l.getParent(), i == null) break;
+            if (i == t) return !0;
+            if (l = i.getOwner(), l == null) break;
+          } while (!0);
+          return !1;
+        }, r.prototype.calcLowestCommonAncestors = function() {
+          for (var t, e, l, i, p, a = this.getAllEdges(), n = a.length, g = 0; g < n; g++) {
+            if (t = a[g], e = t.source, l = t.target, t.lca = null, t.sourceInLca = e, t.targetInLca = l, e == l) {
+              t.lca = e.getOwner();
+              continue;
+            }
+            for (i = e.getOwner(); t.lca == null; ) {
+              for (t.targetInLca = l, p = l.getOwner(); t.lca == null; ) {
+                if (p == i) {
+                  t.lca = p;
+                  break;
+                }
+                if (p == this.rootGraph) break;
+                if (t.lca != null) throw "assert failed";
+                t.targetInLca = p.getParent(), p = t.targetInLca.getOwner();
+              }
+              if (i == this.rootGraph) break;
+              t.lca ?? (t.sourceInLca = i.getParent(), i = t.sourceInLca.getOwner());
+            }
+            if (t.lca == null) throw "assert failed";
+          }
+        }, r.prototype.calcLowestCommonAncestor = function(t, e) {
+          if (t == e) return t.getOwner();
+          var l = t.getOwner();
+          do {
+            if (l == null) break;
+            var i = e.getOwner();
+            do {
+              if (i == null) break;
+              if (i == l) return i;
+              i = i.getParent().getOwner();
+            } while (!0);
+            l = l.getParent().getOwner();
+          } while (!0);
+          return l;
+        }, r.prototype.calcInclusionTreeDepths = function(t, e) {
+          t == null && e == null && (t = this.rootGraph, e = 1);
+          for (var l, i = t.getNodes(), p = i.length, a = 0; a < p; a++) l = i[a], l.inclusionTreeDepth = e, l.child != null && this.calcInclusionTreeDepths(l.child, e + 1);
+        }, r.prototype.includesInvalidEdge = function() {
+          for (var t, e = [], l = this.edges.length, i = 0; i < l; i++) t = this.edges[i], this.isOneAncestorOfOther(t.source, t.target) && e.push(t);
+          for (var i = 0; i < e.length; i++) this.remove(e[i]);
+          return !1;
+        }, A.exports = r;
+      }),
+      (function(A, D, N) {
+        var f = N(12);
+        function o() {
+        }
+        o.calcSeparationAmount = function(r, t, e, l) {
+          if (!r.intersects(t)) throw "assert failed";
+          var i = [, ,];
+          this.decideDirectionsForOverlappingNodes(r, t, i), e[0] = Math.min(r.getRight(), t.getRight()) - Math.max(r.x, t.x), e[1] = Math.min(r.getBottom(), t.getBottom()) - Math.max(r.y, t.y), r.getX() <= t.getX() && r.getRight() >= t.getRight() ? e[0] += Math.min(t.getX() - r.getX(), r.getRight() - t.getRight()) : t.getX() <= r.getX() && t.getRight() >= r.getRight() && (e[0] += Math.min(r.getX() - t.getX(), t.getRight() - r.getRight())), r.getY() <= t.getY() && r.getBottom() >= t.getBottom() ? e[1] += Math.min(t.getY() - r.getY(), r.getBottom() - t.getBottom()) : t.getY() <= r.getY() && t.getBottom() >= r.getBottom() && (e[1] += Math.min(r.getY() - t.getY(), t.getBottom() - r.getBottom()));
+          var p = Math.abs((t.getCenterY() - r.getCenterY()) / (t.getCenterX() - r.getCenterX()));
+          t.getCenterY() === r.getCenterY() && t.getCenterX() === r.getCenterX() && (p = 1);
+          var a = p * e[0], n = e[1] / p;
+          e[0] < n ? n = e[0] : a = e[1], e[0] = -1 * i[0] * (n / 2 + l), e[1] = -1 * i[1] * (a / 2 + l);
+        }, o.decideDirectionsForOverlappingNodes = function(r, t, e) {
+          r.getCenterX() < t.getCenterX() ? e[0] = -1 : e[0] = 1, r.getCenterY() < t.getCenterY() ? e[1] = -1 : e[1] = 1;
+        }, o.getIntersection2 = function(r, t, e) {
+          var l = r.getCenterX(), i = r.getCenterY(), p = t.getCenterX(), a = t.getCenterY();
+          if (r.intersects(t)) return e[0] = l, e[1] = i, e[2] = p, e[3] = a, !0;
+          var n = r.getX(), g = r.getY(), h = r.getRight(), c = r.getX(), d = r.getBottom(), v = r.getRight(), T = r.getWidthHalf(), L = r.getHeightHalf(), F = t.getX(), S = t.getY(), P = t.getRight(), U = t.getX(), Z = t.getBottom(), x = t.getRight(), K = t.getWidthHalf(), s = t.getHeightHalf(), E = !1, u = !1;
+          if (l === p) {
+            if (i > a) return e[0] = l, e[1] = g, e[2] = p, e[3] = Z, !1;
+            if (i < a) return e[0] = l, e[1] = d, e[2] = p, e[3] = S, !1;
+          } else if (i === a) {
+            if (l > p) return e[0] = n, e[1] = i, e[2] = P, e[3] = a, !1;
+            if (l < p) return e[0] = h, e[1] = i, e[2] = F, e[3] = a, !1;
+          } else {
+            var m = r.height / r.width, y = t.height / t.width, C = (a - i) / (p - l), w = void 0, R = void 0, G = void 0, b = void 0, k = void 0, W = void 0;
+            if (-m === C ? l > p ? (e[0] = c, e[1] = d, E = !0) : (e[0] = h, e[1] = g, E = !0) : m === C && (l > p ? (e[0] = n, e[1] = g, E = !0) : (e[0] = v, e[1] = d, E = !0)), -y === C ? p > l ? (e[2] = U, e[3] = Z, u = !0) : (e[2] = P, e[3] = S, u = !0) : y === C && (p > l ? (e[2] = F, e[3] = S, u = !0) : (e[2] = x, e[3] = Z, u = !0)), E && u) return !1;
+            if (l > p ? i > a ? (w = this.getCardinalDirection(m, C, 4), R = this.getCardinalDirection(y, C, 2)) : (w = this.getCardinalDirection(-m, C, 3), R = this.getCardinalDirection(-y, C, 1)) : i > a ? (w = this.getCardinalDirection(-m, C, 1), R = this.getCardinalDirection(-y, C, 3)) : (w = this.getCardinalDirection(m, C, 2), R = this.getCardinalDirection(y, C, 4)), !E) switch (w) {
+              case 1:
+                b = g, G = l + -L / C, e[0] = G, e[1] = b;
+                break;
+              case 2:
+                G = v, b = i + T * C, e[0] = G, e[1] = b;
+                break;
+              case 3:
+                b = d, G = l + L / C, e[0] = G, e[1] = b;
+                break;
+              case 4:
+                G = c, b = i + -T * C, e[0] = G, e[1] = b;
+                break;
+            }
+            if (!u) switch (R) {
+              case 1:
+                W = S, k = p + -s / C, e[2] = k, e[3] = W;
+                break;
+              case 2:
+                k = x, W = a + K * C, e[2] = k, e[3] = W;
+                break;
+              case 3:
+                W = Z, k = p + s / C, e[2] = k, e[3] = W;
+                break;
+              case 4:
+                k = U, W = a + -K * C, e[2] = k, e[3] = W;
+                break;
+            }
+          }
+          return !1;
+        }, o.getCardinalDirection = function(r, t, e) {
+          return r > t ? e : 1 + e % 4;
+        }, o.getIntersection = function(r, t, e, l) {
+          if (l == null) return this.getIntersection2(r, t, e);
+          var i = r.x, p = r.y, a = t.x, n = t.y, g = e.x, h = e.y, c = l.x, d = l.y, v = void 0, T = void 0, L = void 0, F = void 0, S = void 0, P = void 0, U = void 0, Z = void 0, x = void 0;
+          return L = n - p, S = i - a, U = a * p - i * n, F = d - h, P = g - c, Z = c * h - g * d, x = L * P - F * S, x === 0 ? null : (v = (S * Z - P * U) / x, T = (F * U - L * Z) / x, new f(v, T));
+        }, o.angleOfVector = function(r, t, e, l) {
+          var i = void 0;
+          return r === e ? i = l < t ? this.ONE_AND_HALF_PI : this.HALF_PI : (i = Math.atan((l - t) / (e - r)), e < r ? i += Math.PI : l < t && (i += this.TWO_PI)), i;
+        }, o.doIntersect = function(r, t, e, l) {
+          var i = r.x, p = r.y, a = t.x, n = t.y, g = e.x, h = e.y, c = l.x, d = l.y, v = (a - i) * (d - h) - (c - g) * (n - p);
+          if (v === 0) return !1;
+          var T = ((d - h) * (c - i) + (g - c) * (d - p)) / v, L = ((p - n) * (c - i) + (a - i) * (d - p)) / v;
+          return 0 < T && T < 1 && 0 < L && L < 1;
+        }, o.findCircleLineIntersections = function(r, t, e, l, i, p, a) {
+          var n = (e - r) * (e - r) + (l - t) * (l - t), g = 2 * ((r - i) * (e - r) + (t - p) * (l - t)), h = (r - i) * (r - i) + (t - p) * (t - p) - a * a;
+          if (g * g - 4 * n * h >= 0) {
+            var c = (-g + Math.sqrt(g * g - 4 * n * h)) / (2 * n), d = (-g - Math.sqrt(g * g - 4 * n * h)) / (2 * n);
+            return c >= 0 && c <= 1 ? [c] : d >= 0 && d <= 1 ? [d] : null;
+          } else return null;
+        }, o.HALF_PI = 0.5 * Math.PI, o.ONE_AND_HALF_PI = 1.5 * Math.PI, o.TWO_PI = 2 * Math.PI, o.THREE_PI = 3 * Math.PI, A.exports = o;
+      }),
+      (function(A, D, N) {
+        function f() {
+        }
+        f.sign = function(o) {
+          return o > 0 ? 1 : o < 0 ? -1 : 0;
+        }, f.floor = function(o) {
+          return o < 0 ? Math.ceil(o) : Math.floor(o);
+        }, f.ceil = function(o) {
+          return o < 0 ? Math.floor(o) : Math.ceil(o);
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        function f() {
+        }
+        f.MAX_VALUE = 2147483647, f.MIN_VALUE = -2147483648, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = /* @__PURE__ */ (function() {
+          function l(i, p) {
+            for (var a = 0; a < p.length; a++) {
+              var n = p[a];
+              n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(i, n.key, n);
+            }
+          }
+          return function(i, p, a) {
+            return p && l(i.prototype, p), a && l(i, a), i;
+          };
+        })();
+        function o(l, i) {
+          if (!(l instanceof i)) throw TypeError("Cannot call a class as a function");
+        }
+        var r = function(l) {
+          return {
+            value: l,
+            next: null,
+            prev: null
+          };
+        }, t = function(l, i, p, a) {
+          return l === null ? a.head = i : l.next = i, p === null ? a.tail = i : p.prev = i, i.prev = l, i.next = p, a.length++, i;
+        }, e = function(l, i) {
+          var p = l.prev, a = l.next;
+          return p === null ? i.head = a : p.next = a, a === null ? i.tail = p : a.prev = p, l.prev = l.next = null, i.length--, l;
+        };
+        A.exports = (function() {
+          function l(i) {
+            var p = this;
+            o(this, l), this.length = 0, this.head = null, this.tail = null, i?.forEach(function(a) {
+              return p.push(a);
+            });
+          }
+          return f(l, [
+            {
+              key: "size",
+              value: function() {
+                return this.length;
+              }
+            },
+            {
+              key: "insertBefore",
+              value: function(i, p) {
+                return t(p.prev, r(i), p, this);
+              }
+            },
+            {
+              key: "insertAfter",
+              value: function(i, p) {
+                return t(p, r(i), p.next, this);
+              }
+            },
+            {
+              key: "insertNodeBefore",
+              value: function(i, p) {
+                return t(p.prev, i, p, this);
+              }
+            },
+            {
+              key: "insertNodeAfter",
+              value: function(i, p) {
+                return t(p, i, p.next, this);
+              }
+            },
+            {
+              key: "push",
+              value: function(i) {
+                return t(this.tail, r(i), null, this);
+              }
+            },
+            {
+              key: "unshift",
+              value: function(i) {
+                return t(null, r(i), this.head, this);
+              }
+            },
+            {
+              key: "remove",
+              value: function(i) {
+                return e(i, this);
+              }
+            },
+            {
+              key: "pop",
+              value: function() {
+                return e(this.tail, this).value;
+              }
+            },
+            {
+              key: "popNode",
+              value: function() {
+                return e(this.tail, this);
+              }
+            },
+            {
+              key: "shift",
+              value: function() {
+                return e(this.head, this).value;
+              }
+            },
+            {
+              key: "shiftNode",
+              value: function() {
+                return e(this.head, this);
+              }
+            },
+            {
+              key: "get_object_at",
+              value: function(i) {
+                if (i <= this.length()) {
+                  for (var p = 1, a = this.head; p < i; ) a = a.next, p++;
+                  return a.value;
+                }
+              }
+            },
+            {
+              key: "set_object_at",
+              value: function(i, p) {
+                if (i <= this.length()) {
+                  for (var a = 1, n = this.head; a < i; ) n = n.next, a++;
+                  n.value = p;
+                }
+              }
+            }
+          ]), l;
+        })();
+      }),
+      (function(A, D, N) {
+        function f(o, r, t) {
+          this.x = null, this.y = null, o == null && r == null && t == null ? (this.x = 0, this.y = 0) : typeof o == "number" && typeof r == "number" && t == null ? (this.x = o, this.y = r) : o.constructor.name == "Point" && r == null && t == null && (t = o, this.x = t.x, this.y = t.y);
+        }
+        f.prototype.getX = function() {
+          return this.x;
+        }, f.prototype.getY = function() {
+          return this.y;
+        }, f.prototype.getLocation = function() {
+          return new f(this.x, this.y);
+        }, f.prototype.setLocation = function(o, r, t) {
+          o.constructor.name == "Point" && r == null && t == null ? (t = o, this.setLocation(t.x, t.y)) : typeof o == "number" && typeof r == "number" && t == null && (parseInt(o) == o && parseInt(r) == r ? this.move(o, r) : (this.x = Math.floor(o + 0.5), this.y = Math.floor(r + 0.5)));
+        }, f.prototype.move = function(o, r) {
+          this.x = o, this.y = r;
+        }, f.prototype.translate = function(o, r) {
+          this.x += o, this.y += r;
+        }, f.prototype.equals = function(o) {
+          if (o.constructor.name == "Point") {
+            var r = o;
+            return this.x == r.x && this.y == r.y;
+          }
+          return this == o;
+        }, f.prototype.toString = function() {
+          return new f().constructor.name + "[x=" + this.x + ",y=" + this.y + "]";
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        function f(o, r, t, e) {
+          this.x = 0, this.y = 0, this.width = 0, this.height = 0, o != null && r != null && t != null && e != null && (this.x = o, this.y = r, this.width = t, this.height = e);
+        }
+        f.prototype.getX = function() {
+          return this.x;
+        }, f.prototype.setX = function(o) {
+          this.x = o;
+        }, f.prototype.getY = function() {
+          return this.y;
+        }, f.prototype.setY = function(o) {
+          this.y = o;
+        }, f.prototype.getWidth = function() {
+          return this.width;
+        }, f.prototype.setWidth = function(o) {
+          this.width = o;
+        }, f.prototype.getHeight = function() {
+          return this.height;
+        }, f.prototype.setHeight = function(o) {
+          this.height = o;
+        }, f.prototype.getRight = function() {
+          return this.x + this.width;
+        }, f.prototype.getBottom = function() {
+          return this.y + this.height;
+        }, f.prototype.intersects = function(o) {
+          return !(this.getRight() < o.x || this.getBottom() < o.y || o.getRight() < this.x || o.getBottom() < this.y);
+        }, f.prototype.getCenterX = function() {
+          return this.x + this.width / 2;
+        }, f.prototype.getMinX = function() {
+          return this.getX();
+        }, f.prototype.getMaxX = function() {
+          return this.getX() + this.width;
+        }, f.prototype.getCenterY = function() {
+          return this.y + this.height / 2;
+        }, f.prototype.getMinY = function() {
+          return this.getY();
+        }, f.prototype.getMaxY = function() {
+          return this.getY() + this.height;
+        }, f.prototype.getWidthHalf = function() {
+          return this.width / 2;
+        }, f.prototype.getHeightHalf = function() {
+          return this.height / 2;
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+          return typeof r;
+        } : function(r) {
+          return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+        };
+        function o() {
+        }
+        o.lastID = 0, o.createID = function(r) {
+          return o.isPrimitive(r) ? r : (r.uniqueID == null && (r.uniqueID = o.getString(), o.lastID++), r.uniqueID);
+        }, o.getString = function(r) {
+          return r ??= o.lastID, "Object#" + r;
+        }, o.isPrimitive = function(r) {
+          var t = r === void 0 ? "undefined" : f(r);
+          return r == null || t != "object" && t != "function";
+        }, A.exports = o;
+      }),
+      (function(A, D, N) {
+        function f(g) {
+          if (Array.isArray(g)) {
+            for (var h = 0, c = Array(g.length); h < g.length; h++) c[h] = g[h];
+            return c;
+          } else return Array.from(g);
+        }
+        var o = N(0), r = N(7), t = N(3), e = N(1), l = N(6), i = N(5), p = N(17), a = N(29);
+        function n(g) {
+          a.call(this), this.layoutQuality = o.QUALITY, this.createBendsAsNeeded = o.DEFAULT_CREATE_BENDS_AS_NEEDED, this.incremental = o.DEFAULT_INCREMENTAL, this.animationOnLayout = o.DEFAULT_ANIMATION_ON_LAYOUT, this.animationDuringLayout = o.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = o.DEFAULT_ANIMATION_PERIOD, this.uniformLeafNodeSizes = o.DEFAULT_UNIFORM_LEAF_NODE_SIZES, this.edgeToDummyNodes = /* @__PURE__ */ new Map(), this.graphManager = new r(this), this.isLayoutFinished = !1, this.isSubLayout = !1, this.isRemoteUse = !1, g != null && (this.isRemoteUse = g);
+        }
+        n.RANDOM_SEED = 1, n.prototype = Object.create(a.prototype), n.prototype.getGraphManager = function() {
+          return this.graphManager;
+        }, n.prototype.getAllNodes = function() {
+          return this.graphManager.getAllNodes();
+        }, n.prototype.getAllEdges = function() {
+          return this.graphManager.getAllEdges();
+        }, n.prototype.getAllNodesToApplyGravitation = function() {
+          return this.graphManager.getAllNodesToApplyGravitation();
+        }, n.prototype.newGraphManager = function() {
+          var g = new r(this);
+          return this.graphManager = g, g;
+        }, n.prototype.newGraph = function(g) {
+          return new l(null, this.graphManager, g);
+        }, n.prototype.newNode = function(g) {
+          return new t(this.graphManager, g);
+        }, n.prototype.newEdge = function(g) {
+          return new e(null, null, g);
+        }, n.prototype.checkLayoutSuccess = function() {
+          return this.graphManager.getRoot() == null || this.graphManager.getRoot().getNodes().length == 0 || this.graphManager.includesInvalidEdge();
+        }, n.prototype.runLayout = function() {
+          this.isLayoutFinished = !1, this.tilingPreLayout && this.tilingPreLayout(), this.initParameters();
+          var g = this.checkLayoutSuccess() ? !1 : this.layout();
+          return o.ANIMATE === "during" ? !1 : (g && (this.isSubLayout || this.doPostLayout()), this.tilingPostLayout && this.tilingPostLayout(), this.isLayoutFinished = !0, g);
+        }, n.prototype.doPostLayout = function() {
+          this.incremental || this.transform(), this.update();
+        }, n.prototype.update2 = function() {
+          if (this.createBendsAsNeeded && (this.createBendpointsFromDummyNodes(), this.graphManager.resetAllEdges()), !this.isRemoteUse) {
+            for (var g = this.graphManager.getAllEdges(), h = 0; h < g.length; h++) g[h];
+            for (var c = this.graphManager.getRoot().getNodes(), h = 0; h < c.length; h++) c[h];
+            this.update(this.graphManager.getRoot());
+          }
+        }, n.prototype.update = function(g) {
+          if (g == null) this.update2();
+          else if (g instanceof t) {
+            var h = g;
+            if (h.getChild() != null) for (var c = h.getChild().getNodes(), d = 0; d < c.length; d++) update(c[d]);
+            h.vGraphObject != null && h.vGraphObject.update(h);
+          } else if (g instanceof e) {
+            var v = g;
+            v.vGraphObject != null && v.vGraphObject.update(v);
+          } else if (g instanceof l) {
+            var T = g;
+            T.vGraphObject != null && T.vGraphObject.update(T);
+          }
+        }, n.prototype.initParameters = function() {
+          this.isSubLayout || (this.layoutQuality = o.QUALITY, this.animationDuringLayout = o.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = o.DEFAULT_ANIMATION_PERIOD, this.animationOnLayout = o.DEFAULT_ANIMATION_ON_LAYOUT, this.incremental = o.DEFAULT_INCREMENTAL, this.createBendsAsNeeded = o.DEFAULT_CREATE_BENDS_AS_NEEDED, this.uniformLeafNodeSizes = o.DEFAULT_UNIFORM_LEAF_NODE_SIZES), this.animationDuringLayout && (this.animationOnLayout = !1);
+        }, n.prototype.transform = function(g) {
+          if (g == null) this.transform(new i(0, 0));
+          else {
+            var h = new p(), c = this.graphManager.getRoot().updateLeftTop();
+            if (c != null) {
+              h.setWorldOrgX(g.x), h.setWorldOrgY(g.y), h.setDeviceOrgX(c.x), h.setDeviceOrgY(c.y);
+              for (var d = this.getAllNodes(), v, T = 0; T < d.length; T++) v = d[T], v.transform(h);
+            }
+          }
+        }, n.prototype.positionNodesRandomly = function(g) {
+          if (g == null) this.positionNodesRandomly(this.getGraphManager().getRoot()), this.getGraphManager().getRoot().updateBounds(!0);
+          else for (var h, c, d = g.getNodes(), v = 0; v < d.length; v++) h = d[v], c = h.getChild(), c == null || c.getNodes().length == 0 ? h.scatter() : (this.positionNodesRandomly(c), h.updateBounds());
+        }, n.prototype.getFlatForest = function() {
+          for (var g = [], h = !0, c = this.graphManager.getRoot().getNodes(), d = !0, v = 0; v < c.length; v++) c[v].getChild() != null && (d = !1);
+          if (!d) return g;
+          var T = /* @__PURE__ */ new Set(), L = [], F = /* @__PURE__ */ new Map(), S = [];
+          for (S = S.concat(c); S.length > 0 && h; ) {
+            for (L.push(S[0]); L.length > 0 && h; ) {
+              var P = L[0];
+              L.splice(0, 1), T.add(P);
+              for (var U = P.getEdges(), v = 0; v < U.length; v++) {
+                var Z = U[v].getOtherEnd(P);
+                if (F.get(P) != Z) if (!T.has(Z)) L.push(Z), F.set(Z, P);
+                else {
+                  h = !1;
+                  break;
+                }
+              }
+            }
+            if (!h) g = [];
+            else {
+              var x = [].concat(f(T));
+              g.push(x);
+              for (var v = 0; v < x.length; v++) {
+                var K = x[v], s = S.indexOf(K);
+                s > -1 && S.splice(s, 1);
+              }
+              T = /* @__PURE__ */ new Set(), F = /* @__PURE__ */ new Map();
+            }
+          }
+          return g;
+        }, n.prototype.createDummyNodesForBendpoints = function(g) {
+          for (var h = [], c = g.source, d = this.graphManager.calcLowestCommonAncestor(g.source, g.target), v = 0; v < g.bendpoints.length; v++) {
+            var T = this.newNode(null);
+            T.setRect(new Point(0, 0), new Dimension(1, 1)), d.add(T);
+            var L = this.newEdge(null);
+            this.graphManager.add(L, c, T), h.add(T), c = T;
+          }
+          var L = this.newEdge(null);
+          return this.graphManager.add(L, c, g.target), this.edgeToDummyNodes.set(g, h), g.isInterGraph() ? this.graphManager.remove(g) : d.remove(g), h;
+        }, n.prototype.createBendpointsFromDummyNodes = function() {
+          var g = [];
+          g = g.concat(this.graphManager.getAllEdges()), g = [].concat(f(this.edgeToDummyNodes.keys()), g);
+          for (var h = 0; h < g.length; h++) {
+            var c = g[h];
+            if (c.bendpoints.length > 0) {
+              for (var d = this.edgeToDummyNodes.get(c), v = 0; v < d.length; v++) {
+                var T = d[v], L = new i(T.getCenterX(), T.getCenterY()), F = c.bendpoints.get(v);
+                F.x = L.x, F.y = L.y, T.getOwner().remove(T);
+              }
+              this.graphManager.add(c, c.source, c.target);
+            }
+          }
+        }, n.transform = function(g, h, c, d) {
+          if (c != null && d != null) {
+            var v = h;
+            if (g <= 50) {
+              var T = h / c;
+              v -= (h - T) / 50 * (50 - g);
+            } else {
+              var L = h * d;
+              v += (L - h) / 50 * (g - 50);
+            }
+            return v;
+          } else {
+            var F, S;
+            return g <= 50 ? (F = 9 * h / 500, S = h / 10) : (F = 9 * h / 50, S = -8 * h), F * g + S;
+          }
+        }, n.findCenterOfTree = function(g) {
+          var h = [];
+          h = h.concat(g);
+          var c = [], d = /* @__PURE__ */ new Map(), v = !1, T = null;
+          (h.length == 1 || h.length == 2) && (v = !0, T = h[0]);
+          for (var L = 0; L < h.length; L++) {
+            var F = h[L], S = F.getNeighborsList().size;
+            d.set(F, F.getNeighborsList().size), S == 1 && c.push(F);
+          }
+          var P = [];
+          for (P = P.concat(c); !v; ) {
+            var U = [];
+            U = U.concat(P), P = [];
+            for (var L = 0; L < h.length; L++) {
+              var F = h[L], Z = h.indexOf(F);
+              Z >= 0 && h.splice(Z, 1), F.getNeighborsList().forEach(function(s) {
+                if (c.indexOf(s) < 0) {
+                  var E = d.get(s) - 1;
+                  E == 1 && P.push(s), d.set(s, E);
+                }
+              });
+            }
+            c = c.concat(P), (h.length == 1 || h.length == 2) && (v = !0, T = h[0]);
+          }
+          return T;
+        }, n.prototype.setGraphManager = function(g) {
+          this.graphManager = g;
+        }, A.exports = n;
+      }),
+      (function(A, D, N) {
+        function f() {
+        }
+        f.seed = 1, f.x = 0, f.nextDouble = function() {
+          return f.x = Math.sin(f.seed++) * 1e4, f.x - Math.floor(f.x);
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = N(5);
+        function o(r, t) {
+          this.lworldOrgX = 0, this.lworldOrgY = 0, this.ldeviceOrgX = 0, this.ldeviceOrgY = 0, this.lworldExtX = 1, this.lworldExtY = 1, this.ldeviceExtX = 1, this.ldeviceExtY = 1;
+        }
+        o.prototype.getWorldOrgX = function() {
+          return this.lworldOrgX;
+        }, o.prototype.setWorldOrgX = function(r) {
+          this.lworldOrgX = r;
+        }, o.prototype.getWorldOrgY = function() {
+          return this.lworldOrgY;
+        }, o.prototype.setWorldOrgY = function(r) {
+          this.lworldOrgY = r;
+        }, o.prototype.getWorldExtX = function() {
+          return this.lworldExtX;
+        }, o.prototype.setWorldExtX = function(r) {
+          this.lworldExtX = r;
+        }, o.prototype.getWorldExtY = function() {
+          return this.lworldExtY;
+        }, o.prototype.setWorldExtY = function(r) {
+          this.lworldExtY = r;
+        }, o.prototype.getDeviceOrgX = function() {
+          return this.ldeviceOrgX;
+        }, o.prototype.setDeviceOrgX = function(r) {
+          this.ldeviceOrgX = r;
+        }, o.prototype.getDeviceOrgY = function() {
+          return this.ldeviceOrgY;
+        }, o.prototype.setDeviceOrgY = function(r) {
+          this.ldeviceOrgY = r;
+        }, o.prototype.getDeviceExtX = function() {
+          return this.ldeviceExtX;
+        }, o.prototype.setDeviceExtX = function(r) {
+          this.ldeviceExtX = r;
+        }, o.prototype.getDeviceExtY = function() {
+          return this.ldeviceExtY;
+        }, o.prototype.setDeviceExtY = function(r) {
+          this.ldeviceExtY = r;
+        }, o.prototype.transformX = function(r) {
+          var t = 0, e = this.lworldExtX;
+          return e != 0 && (t = this.ldeviceOrgX + (r - this.lworldOrgX) * this.ldeviceExtX / e), t;
+        }, o.prototype.transformY = function(r) {
+          var t = 0, e = this.lworldExtY;
+          return e != 0 && (t = this.ldeviceOrgY + (r - this.lworldOrgY) * this.ldeviceExtY / e), t;
+        }, o.prototype.inverseTransformX = function(r) {
+          var t = 0, e = this.ldeviceExtX;
+          return e != 0 && (t = this.lworldOrgX + (r - this.ldeviceOrgX) * this.lworldExtX / e), t;
+        }, o.prototype.inverseTransformY = function(r) {
+          var t = 0, e = this.ldeviceExtY;
+          return e != 0 && (t = this.lworldOrgY + (r - this.ldeviceOrgY) * this.lworldExtY / e), t;
+        }, o.prototype.inverseTransformPoint = function(r) {
+          return new f(this.inverseTransformX(r.x), this.inverseTransformY(r.y));
+        }, A.exports = o;
+      }),
+      (function(A, D, N) {
+        function f(a) {
+          if (Array.isArray(a)) {
+            for (var n = 0, g = Array(a.length); n < a.length; n++) g[n] = a[n];
+            return g;
+          } else return Array.from(a);
+        }
+        var o = N(15), r = N(4), t = N(0), e = N(8), l = N(9);
+        function i() {
+          o.call(this), this.useSmartIdealEdgeLengthCalculation = r.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.gravityConstant = r.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = r.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = r.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = r.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.displacementThresholdPerNode = 3 * r.DEFAULT_EDGE_LENGTH / 100, this.coolingFactor = r.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.initialCoolingFactor = r.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.totalDisplacement = 0, this.oldTotalDisplacement = 0, this.maxIterations = r.MAX_ITERATIONS;
+        }
+        for (var p in i.prototype = Object.create(o.prototype), o) i[p] = o[p];
+        i.prototype.initParameters = function() {
+          o.prototype.initParameters.call(this, arguments), this.totalIterations = 0, this.notAnimatedIterations = 0, this.useFRGridVariant = r.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION, this.grid = [];
+        }, i.prototype.calcIdealEdgeLengths = function() {
+          for (var a, n, g, h, c, d, v, T = this.getGraphManager().getAllEdges(), L = 0; L < T.length; L++) a = T[L], n = a.idealLength, a.isInterGraph && (h = a.getSource(), c = a.getTarget(), d = a.getSourceInLca().getEstimatedSize(), v = a.getTargetInLca().getEstimatedSize(), this.useSmartIdealEdgeLengthCalculation && (a.idealLength += d + v - 2 * t.SIMPLE_NODE_SIZE), g = a.getLca().getInclusionTreeDepth(), a.idealLength += n * r.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (h.getInclusionTreeDepth() + c.getInclusionTreeDepth() - 2 * g));
+        }, i.prototype.initSpringEmbedder = function() {
+          var a = this.getAllNodes().length;
+          this.incremental ? (a > r.ADAPTATION_LOWER_NODE_LIMIT && (this.coolingFactor = Math.max(this.coolingFactor * r.COOLING_ADAPTATION_FACTOR, this.coolingFactor - (a - r.ADAPTATION_LOWER_NODE_LIMIT) / (r.ADAPTATION_UPPER_NODE_LIMIT - r.ADAPTATION_LOWER_NODE_LIMIT) * this.coolingFactor * (1 - r.COOLING_ADAPTATION_FACTOR))), this.maxNodeDisplacement = r.MAX_NODE_DISPLACEMENT_INCREMENTAL) : (a > r.ADAPTATION_LOWER_NODE_LIMIT ? this.coolingFactor = Math.max(r.COOLING_ADAPTATION_FACTOR, 1 - (a - r.ADAPTATION_LOWER_NODE_LIMIT) / (r.ADAPTATION_UPPER_NODE_LIMIT - r.ADAPTATION_LOWER_NODE_LIMIT) * (1 - r.COOLING_ADAPTATION_FACTOR)) : this.coolingFactor = 1, this.initialCoolingFactor = this.coolingFactor, this.maxNodeDisplacement = r.MAX_NODE_DISPLACEMENT), this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations), this.displacementThresholdPerNode = 3 * r.DEFAULT_EDGE_LENGTH / 100, this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length, this.repulsionRange = this.calcRepulsionRange();
+        }, i.prototype.calcSpringForces = function() {
+          for (var a = this.getAllEdges(), n, g = 0; g < a.length; g++) n = a[g], this.calcSpringForce(n, n.idealLength);
+        }, i.prototype.calcRepulsionForces = function() {
+          var a = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0, n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1, g, h, c, d, v = this.getAllNodes(), T;
+          if (this.useFRGridVariant) for (this.totalIterations % r.GRID_CALCULATION_CHECK_PERIOD == 1 && a && this.updateGrid(), T = /* @__PURE__ */ new Set(), g = 0; g < v.length; g++) c = v[g], this.calculateRepulsionForceOfANode(c, T, a, n), T.add(c);
+          else for (g = 0; g < v.length; g++) for (c = v[g], h = g + 1; h < v.length; h++) d = v[h], c.getOwner() == d.getOwner() && this.calcRepulsionForce(c, d);
+        }, i.prototype.calcGravitationalForces = function() {
+          for (var a, n = this.getAllNodesToApplyGravitation(), g = 0; g < n.length; g++) a = n[g], this.calcGravitationalForce(a);
+        }, i.prototype.moveNodes = function() {
+          for (var a = this.getAllNodes(), n, g = 0; g < a.length; g++) n = a[g], n.move();
+        }, i.prototype.calcSpringForce = function(a, n) {
+          var g = a.getSource(), h = a.getTarget(), c, d, v, T;
+          if (this.uniformLeafNodeSizes && g.getChild() == null && h.getChild() == null) a.updateLengthSimple();
+          else if (a.updateLength(), a.isOverlapingSourceAndTarget) return;
+          c = a.getLength(), c != 0 && (d = a.edgeElasticity * (c - n), v = d * (a.lengthX / c), T = d * (a.lengthY / c), g.springForceX += v, g.springForceY += T, h.springForceX -= v, h.springForceY -= T);
+        }, i.prototype.calcRepulsionForce = function(a, n) {
+          var g = a.getRect(), h = n.getRect(), c = [, ,], d = [
+            ,
+            ,
+            ,
+            ,
+          ], v, T, L, F, S, P, U;
+          if (g.intersects(h)) {
+            e.calcSeparationAmount(g, h, c, r.DEFAULT_EDGE_LENGTH / 2), P = 2 * c[0], U = 2 * c[1];
+            var Z = a.noOfChildren * n.noOfChildren / (a.noOfChildren + n.noOfChildren);
+            a.repulsionForceX -= Z * P, a.repulsionForceY -= Z * U, n.repulsionForceX += Z * P, n.repulsionForceY += Z * U;
+          } else this.uniformLeafNodeSizes && a.getChild() == null && n.getChild() == null ? (v = h.getCenterX() - g.getCenterX(), T = h.getCenterY() - g.getCenterY()) : (e.getIntersection(g, h, d), v = d[2] - d[0], T = d[3] - d[1]), Math.abs(v) < r.MIN_REPULSION_DIST && (v = l.sign(v) * r.MIN_REPULSION_DIST), Math.abs(T) < r.MIN_REPULSION_DIST && (T = l.sign(T) * r.MIN_REPULSION_DIST), L = v * v + T * T, F = Math.sqrt(L), S = (a.nodeRepulsion / 2 + n.nodeRepulsion / 2) * a.noOfChildren * n.noOfChildren / L, P = S * v / F, U = S * T / F, a.repulsionForceX -= P, a.repulsionForceY -= U, n.repulsionForceX += P, n.repulsionForceY += U;
+        }, i.prototype.calcGravitationalForce = function(a) {
+          var n = a.getOwner(), g = (n.getRight() + n.getLeft()) / 2, h = (n.getTop() + n.getBottom()) / 2, c = a.getCenterX() - g, d = a.getCenterY() - h, v = Math.abs(c) + a.getWidth() / 2, T = Math.abs(d) + a.getHeight() / 2, L;
+          a.getOwner() == this.graphManager.getRoot() ? (L = n.getEstimatedSize() * this.gravityRangeFactor, (v > L || T > L) && (a.gravitationForceX = -this.gravityConstant * c, a.gravitationForceY = -this.gravityConstant * d)) : (L = n.getEstimatedSize() * this.compoundGravityRangeFactor, (v > L || T > L) && (a.gravitationForceX = -this.gravityConstant * c * this.compoundGravityConstant, a.gravitationForceY = -this.gravityConstant * d * this.compoundGravityConstant));
+        }, i.prototype.isConverged = function() {
+          var a, n = !1;
+          return this.totalIterations > this.maxIterations / 3 && (n = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2), a = this.totalDisplacement < this.totalDisplacementThreshold, this.oldTotalDisplacement = this.totalDisplacement, a || n;
+        }, 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 a, n = this.graphManager.getAllNodes(), g = 0; g < n.length; g++) a = n[g], a.noOfChildren = a.getNoOfChildren();
+        }, i.prototype.calcGrid = function(a) {
+          var n = 0, g = 0;
+          n = parseInt(Math.ceil((a.getRight() - a.getLeft()) / this.repulsionRange)), g = parseInt(Math.ceil((a.getBottom() - a.getTop()) / this.repulsionRange));
+          for (var h = Array(n), c = 0; c < n; c++) h[c] = Array(g);
+          for (var c = 0; c < n; c++) for (var d = 0; d < g; d++) h[c][d] = [];
+          return h;
+        }, i.prototype.addNodeToGrid = function(a, n, g) {
+          var h = 0, c = 0, d = 0, v = 0;
+          h = parseInt(Math.floor((a.getRect().x - n) / this.repulsionRange)), c = parseInt(Math.floor((a.getRect().width + a.getRect().x - n) / this.repulsionRange)), d = parseInt(Math.floor((a.getRect().y - g) / this.repulsionRange)), v = parseInt(Math.floor((a.getRect().height + a.getRect().y - g) / this.repulsionRange));
+          for (var T = h; T <= c; T++) for (var L = d; L <= v; L++) this.grid[T][L].push(a), a.setGridCoordinates(h, c, d, v);
+        }, i.prototype.updateGrid = function() {
+          var a, n, g = this.getAllNodes();
+          for (this.grid = this.calcGrid(this.graphManager.getRoot()), a = 0; a < g.length; a++) n = g[a], this.addNodeToGrid(n, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop());
+        }, i.prototype.calculateRepulsionForceOfANode = function(a, n, g, h) {
+          if (this.totalIterations % r.GRID_CALCULATION_CHECK_PERIOD == 1 && g || h) {
+            var c = /* @__PURE__ */ new Set();
+            a.surrounding = [];
+            for (var d, v = this.grid, T = a.startX - 1; T < a.finishX + 2; T++) for (var L = a.startY - 1; L < a.finishY + 2; L++) if (!(T < 0 || L < 0 || T >= v.length || L >= v[0].length)) {
+              for (var F = 0; F < v[T][L].length; F++) if (d = v[T][L][F], !(a.getOwner() != d.getOwner() || a == d) && !n.has(d) && !c.has(d)) {
+                var S = Math.abs(a.getCenterX() - d.getCenterX()) - (a.getWidth() / 2 + d.getWidth() / 2), P = Math.abs(a.getCenterY() - d.getCenterY()) - (a.getHeight() / 2 + d.getHeight() / 2);
+                S <= this.repulsionRange && P <= this.repulsionRange && c.add(d);
+              }
+            }
+            a.surrounding = [].concat(f(c));
+          }
+          for (T = 0; T < a.surrounding.length; T++) this.calcRepulsionForce(a, a.surrounding[T]);
+        }, i.prototype.calcRepulsionRange = function() {
+          return 0;
+        }, A.exports = i;
+      }),
+      (function(A, D, N) {
+        var f = N(1), o = N(4);
+        function r(e, l, i) {
+          f.call(this, e, l, i), this.idealLength = o.DEFAULT_EDGE_LENGTH, this.edgeElasticity = o.DEFAULT_SPRING_STRENGTH;
+        }
+        for (var t in r.prototype = Object.create(f.prototype), f) r[t] = f[t];
+        A.exports = r;
+      }),
+      (function(A, D, N) {
+        var f = N(3), o = N(4);
+        function r(e, l, i, p) {
+          f.call(this, e, l, i, p), this.nodeRepulsion = o.DEFAULT_REPULSION_STRENGTH, this.springForceX = 0, this.springForceY = 0, this.repulsionForceX = 0, this.repulsionForceY = 0, this.gravitationForceX = 0, this.gravitationForceY = 0, this.displacementX = 0, this.displacementY = 0, this.startX = 0, this.finishX = 0, this.startY = 0, this.finishY = 0, this.surrounding = [];
+        }
+        for (var t in r.prototype = Object.create(f.prototype), f) r[t] = f[t];
+        r.prototype.setGridCoordinates = function(e, l, i, p) {
+          this.startX = e, this.finishX = l, this.startY = i, this.finishY = p;
+        }, A.exports = r;
+      }),
+      (function(A, D, N) {
+        function f(o, r) {
+          this.width = 0, this.height = 0, o !== null && r !== null && (this.height = r, this.width = o);
+        }
+        f.prototype.getWidth = function() {
+          return this.width;
+        }, f.prototype.setWidth = function(o) {
+          this.width = o;
+        }, f.prototype.getHeight = function() {
+          return this.height;
+        }, f.prototype.setHeight = function(o) {
+          this.height = o;
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = N(14);
+        function o() {
+          this.map = {}, this.keys = [];
+        }
+        o.prototype.put = function(r, t) {
+          var e = f.createID(r);
+          this.contains(e) || (this.map[e] = t, this.keys.push(r));
+        }, o.prototype.contains = function(r) {
+          return f.createID(r), this.map[r] != null;
+        }, o.prototype.get = function(r) {
+          var t = f.createID(r);
+          return this.map[t];
+        }, o.prototype.keySet = function() {
+          return this.keys;
+        }, A.exports = o;
+      }),
+      (function(A, D, N) {
+        var f = N(14);
+        function o() {
+          this.set = {};
+        }
+        o.prototype.add = function(r) {
+          var t = f.createID(r);
+          this.contains(t) || (this.set[t] = r);
+        }, o.prototype.remove = function(r) {
+          delete this.set[f.createID(r)];
+        }, o.prototype.clear = function() {
+          this.set = {};
+        }, o.prototype.contains = function(r) {
+          return this.set[f.createID(r)] == r;
+        }, o.prototype.isEmpty = function() {
+          return this.size() === 0;
+        }, o.prototype.size = function() {
+          return Object.keys(this.set).length;
+        }, o.prototype.addAllTo = function(r) {
+          for (var t = Object.keys(this.set), e = t.length, l = 0; l < e; l++) r.push(this.set[t[l]]);
+        }, o.prototype.size = function() {
+          return Object.keys(this.set).length;
+        }, o.prototype.addAll = function(r) {
+          for (var t = r.length, e = 0; e < t; e++) {
+            var l = r[e];
+            this.add(l);
+          }
+        }, A.exports = o;
+      }),
+      (function(A, D, N) {
+        function f() {
+        }
+        f.multMat = function(o, r) {
+          for (var t = [], e = 0; e < o.length; e++) {
+            t[e] = [];
+            for (var l = 0; l < r[0].length; l++) {
+              t[e][l] = 0;
+              for (var i = 0; i < o[0].length; i++) t[e][l] += o[e][i] * r[i][l];
+            }
+          }
+          return t;
+        }, f.transpose = function(o) {
+          for (var r = [], t = 0; t < o[0].length; t++) {
+            r[t] = [];
+            for (var e = 0; e < o.length; e++) r[t][e] = o[e][t];
+          }
+          return r;
+        }, f.multCons = function(o, r) {
+          for (var t = [], e = 0; e < o.length; e++) t[e] = o[e] * r;
+          return t;
+        }, f.minusOp = function(o, r) {
+          for (var t = [], e = 0; e < o.length; e++) t[e] = o[e] - r[e];
+          return t;
+        }, f.dotProduct = function(o, r) {
+          for (var t = 0, e = 0; e < o.length; e++) t += o[e] * r[e];
+          return t;
+        }, f.mag = function(o) {
+          return Math.sqrt(this.dotProduct(o, o));
+        }, f.normalize = function(o) {
+          for (var r = [], t = this.mag(o), e = 0; e < o.length; e++) r[e] = o[e] / t;
+          return r;
+        }, f.multGamma = function(o) {
+          for (var r = [], t = 0, e = 0; e < o.length; e++) t += o[e];
+          t *= -1 / o.length;
+          for (var l = 0; l < o.length; l++) r[l] = t + o[l];
+          return r;
+        }, f.multL = function(o, r, t) {
+          for (var e = [], l = [], i = [], p = 0; p < r[0].length; p++) {
+            for (var a = 0, n = 0; n < r.length; n++) a += -0.5 * r[n][p] * o[n];
+            l[p] = a;
+          }
+          for (var g = 0; g < t.length; g++) {
+            for (var h = 0, c = 0; c < t.length; c++) h += t[g][c] * l[c];
+            i[g] = h;
+          }
+          for (var d = 0; d < r.length; d++) {
+            for (var v = 0, T = 0; T < r[0].length; T++) v += r[d][T] * i[T];
+            e[d] = v;
+          }
+          return e;
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = /* @__PURE__ */ (function() {
+          function t(e, l) {
+            for (var i = 0; i < l.length; i++) {
+              var p = l[i];
+              p.enumerable = p.enumerable || !1, p.configurable = !0, "value" in p && (p.writable = !0), Object.defineProperty(e, p.key, p);
+            }
+          }
+          return function(e, l, i) {
+            return l && t(e.prototype, l), i && t(e, i), e;
+          };
+        })();
+        function o(t, e) {
+          if (!(t instanceof e)) throw TypeError("Cannot call a class as a function");
+        }
+        var r = N(11);
+        A.exports = (function() {
+          function t(e, l) {
+            o(this, t), (l !== null || l !== void 0) && (this.compareFunction = this._defaultCompareFunction);
+            var i = void 0;
+            i = e instanceof r ? e.size() : e.length, this._quicksort(e, 0, i - 1);
+          }
+          return f(t, [
+            {
+              key: "_quicksort",
+              value: function(e, l, i) {
+                if (l < i) {
+                  var p = this._partition(e, l, i);
+                  this._quicksort(e, l, p), this._quicksort(e, p + 1, i);
+                }
+              }
+            },
+            {
+              key: "_partition",
+              value: function(e, l, i) {
+                for (var p = this._get(e, l), a = l, n = i; ; ) {
+                  for (; this.compareFunction(p, this._get(e, n)); ) n--;
+                  for (; this.compareFunction(this._get(e, a), p); ) a++;
+                  if (a < n) this._swap(e, a, n), a++, n--;
+                  else return n;
+                }
+              }
+            },
+            {
+              key: "_get",
+              value: function(e, l) {
+                return e instanceof r ? e.get_object_at(l) : e[l];
+              }
+            },
+            {
+              key: "_set",
+              value: function(e, l, i) {
+                e instanceof r ? e.set_object_at(l, i) : e[l] = i;
+              }
+            },
+            {
+              key: "_swap",
+              value: function(e, l, i) {
+                var p = this._get(e, l);
+                this._set(e, l, this._get(e, i)), this._set(e, i, p);
+              }
+            },
+            {
+              key: "_defaultCompareFunction",
+              value: function(e, l) {
+                return l > e;
+              }
+            }
+          ]), t;
+        })();
+      }),
+      (function(A, D, N) {
+        function f() {
+        }
+        f.svd = function(o) {
+          this.U = null, this.V = null, this.s = null, this.m = 0, this.n = 0, this.m = o.length, this.n = o[0].length;
+          var r = Math.min(this.m, this.n);
+          this.s = (function(Tt) {
+            for (var Nt = []; Tt-- > 0; ) Nt.push(0);
+            return Nt;
+          })(Math.min(this.m + 1, this.n)), this.U = (function(Tt) {
+            return (function Nt(Mt) {
+              if (Mt.length == 0) return 0;
+              for (var Pt = [], Xt = 0; Xt < Mt[0]; Xt++) Pt.push(Nt(Mt.slice(1)));
+              return Pt;
+            })(Tt);
+          })([this.m, r]), this.V = (function(Tt) {
+            return (function Nt(Mt) {
+              if (Mt.length == 0) return 0;
+              for (var Pt = [], Xt = 0; Xt < Mt[0]; Xt++) Pt.push(Nt(Mt.slice(1)));
+              return Pt;
+            })(Tt);
+          })([this.n, this.n]);
+          for (var t = (function(Tt) {
+            for (var Nt = []; Tt-- > 0; ) Nt.push(0);
+            return Nt;
+          })(this.n), e = (function(Tt) {
+            for (var Nt = []; Tt-- > 0; ) Nt.push(0);
+            return Nt;
+          })(this.m), l = !0, i = !0, p = Math.min(this.m - 1, this.n), a = Math.max(0, Math.min(this.n - 2, this.m)), n = 0; n < Math.max(p, a); n++) {
+            if (n < p) {
+              this.s[n] = 0;
+              for (var g = n; g < this.m; g++) this.s[n] = f.hypot(this.s[n], o[g][n]);
+              if (this.s[n] !== 0) {
+                o[n][n] < 0 && (this.s[n] = -this.s[n]);
+                for (var h = n; h < this.m; h++) o[h][n] /= this.s[n];
+                o[n][n] += 1;
+              }
+              this.s[n] = -this.s[n];
+            }
+            for (var c = n + 1; c < this.n; c++) {
+              if (/* @__PURE__ */ (function(Tt, Nt) {
+                return Tt && Nt;
+              })(n < p, this.s[n] !== 0)) {
+                for (var d = 0, v = n; v < this.m; v++) d += o[v][n] * o[v][c];
+                d = -d / o[n][n];
+                for (var T = n; T < this.m; T++) o[T][c] += d * o[T][n];
+              }
+              t[c] = o[n][c];
+            }
+            if (/* @__PURE__ */ (function(Tt, Nt) {
+              return Tt && Nt;
+            })(l, n < p)) for (var L = n; L < this.m; L++) this.U[L][n] = o[L][n];
+            if (n < a) {
+              t[n] = 0;
+              for (var F = n + 1; F < this.n; F++) t[n] = f.hypot(t[n], t[F]);
+              if (t[n] !== 0) {
+                t[n + 1] < 0 && (t[n] = -t[n]);
+                for (var S = n + 1; S < this.n; S++) t[S] /= t[n];
+                t[n + 1] += 1;
+              }
+              if (t[n] = -t[n], /* @__PURE__ */ (function(Tt, Nt) {
+                return Tt && Nt;
+              })(n + 1 < this.m, t[n] !== 0)) {
+                for (var P = n + 1; P < this.m; P++) e[P] = 0;
+                for (var U = n + 1; U < this.n; U++) for (var Z = n + 1; Z < this.m; Z++) e[Z] += t[U] * o[Z][U];
+                for (var x = n + 1; x < this.n; x++) for (var K = -t[x] / t[n + 1], s = n + 1; s < this.m; s++) o[s][x] += K * e[s];
+              }
+              if (i) for (var E = n + 1; E < this.n; E++) this.V[E][n] = t[E];
+            }
+          }
+          var u = Math.min(this.n, this.m + 1);
+          if (p < this.n && (this.s[p] = o[p][p]), this.m < u && (this.s[u - 1] = 0), a + 1 < u && (t[a] = o[a][u - 1]), t[u - 1] = 0, l) {
+            for (var m = p; m < r; m++) {
+              for (var y = 0; y < this.m; y++) this.U[y][m] = 0;
+              this.U[m][m] = 1;
+            }
+            for (var C = p - 1; C >= 0; C--) if (this.s[C] !== 0) {
+              for (var w = C + 1; w < r; w++) {
+                for (var R = 0, G = C; G < this.m; G++) R += this.U[G][C] * this.U[G][w];
+                R = -R / this.U[C][C];
+                for (var b = C; b < this.m; b++) this.U[b][w] += R * this.U[b][C];
+              }
+              for (var k = C; k < this.m; k++) this.U[k][C] = -this.U[k][C];
+              this.U[C][C] = 1 + this.U[C][C];
+              for (var W = 0; W < C - 1; W++) this.U[W][C] = 0;
+            } else {
+              for (var J = 0; J < this.m; J++) this.U[J][C] = 0;
+              this.U[C][C] = 1;
+            }
+          }
+          if (i) for (var H = this.n - 1; H >= 0; H--) {
+            if (/* @__PURE__ */ (function(Tt, Nt) {
+              return Tt && Nt;
+            })(H < a, t[H] !== 0)) for (var z = H + 1; z < r; z++) {
+              for (var O = 0, B = H + 1; B < this.n; B++) O += this.V[B][H] * this.V[B][z];
+              O = -O / this.V[H + 1][H];
+              for (var et = H + 1; et < this.n; et++) this.V[et][z] += O * this.V[et][H];
+            }
+            for (var X = 0; X < this.n; X++) this.V[X][H] = 0;
+            this.V[H][H] = 1;
+          }
+          for (var V = u - 1, lt = 0, at = 2 ** -52, Lt = 2 ** -966; u > 0; ) {
+            var j = void 0, pt = void 0;
+            for (j = u - 2; j >= -1 && j !== -1; j--) if (Math.abs(t[j]) <= Lt + at * (Math.abs(this.s[j]) + Math.abs(this.s[j + 1]))) {
+              t[j] = 0;
+              break;
+            }
+            if (j === u - 2) pt = 4;
+            else {
+              var yt = void 0;
+              for (yt = u - 1; yt >= j && yt !== j; yt--) {
+                var Bt = (yt === u ? 0 : Math.abs(t[yt])) + (yt === j + 1 ? 0 : Math.abs(t[yt - 1]));
+                if (Math.abs(this.s[yt]) <= Lt + at * Bt) {
+                  this.s[yt] = 0;
+                  break;
+                }
+              }
+              yt === j ? pt = 3 : yt === u - 1 ? pt = 1 : (pt = 2, j = yt);
+            }
+            switch (j++, pt) {
+              case 1:
+                var Yt = t[u - 2];
+                t[u - 2] = 0;
+                for (var _t = u - 2; _t >= j; _t--) {
+                  var xt = f.hypot(this.s[_t], Yt), kt = this.s[_t] / xt, Ut = Yt / xt;
+                  if (this.s[_t] = xt, _t !== j && (Yt = -Ut * t[_t - 1], t[_t - 1] = kt * t[_t - 1]), i) for (var Rt = 0; Rt < this.n; Rt++) xt = kt * this.V[Rt][_t] + Ut * this.V[Rt][u - 1], this.V[Rt][u - 1] = -Ut * this.V[Rt][_t] + kt * this.V[Rt][u - 1], this.V[Rt][_t] = xt;
+                }
+                break;
+              case 2:
+                var Vt = t[j - 1];
+                t[j - 1] = 0;
+                for (var Gt = j; Gt < u; Gt++) {
+                  var st = f.hypot(this.s[Gt], Vt), ot = this.s[Gt] / st, ct = Vt / st;
+                  if (this.s[Gt] = st, Vt = -ct * t[Gt], t[Gt] = ot * t[Gt], l) for (var I = 0; I < this.m; I++) st = ot * this.U[I][Gt] + ct * this.U[I][j - 1], this.U[I][j - 1] = -ct * this.U[I][Gt] + ot * this.U[I][j - 1], this.U[I][Gt] = st;
+                }
+                break;
+              case 3:
+                var Y = Math.max(Math.max(Math.max(Math.max(Math.abs(this.s[u - 1]), Math.abs(this.s[u - 2])), Math.abs(t[u - 2])), Math.abs(this.s[j])), Math.abs(t[j])), q = this.s[u - 1] / Y, $ = this.s[u - 2] / Y, tt = t[u - 2] / Y, Et = this.s[j] / Y, mt = t[j] / Y, it = (($ + q) * ($ - q) + tt * tt) / 2, ft = q * tt * (q * tt), It = 0;
+                /* @__PURE__ */ (function(Tt, Nt) {
+                  return Tt || Nt;
+                })(it !== 0, ft !== 0) && (It = Math.sqrt(it * it + ft), it < 0 && (It = -It), It = ft / (it + It));
+                for (var wt = (Et + q) * (Et - q) + It, vt = Et * mt, ht = j; ht < u - 1; ht++) {
+                  var dt = f.hypot(wt, vt), Q = wt / dt, ut = vt / dt;
+                  if (ht !== j && (t[ht - 1] = dt), wt = Q * this.s[ht] + ut * t[ht], t[ht] = Q * t[ht] - ut * this.s[ht], vt = ut * this.s[ht + 1], this.s[ht + 1] = Q * this.s[ht + 1], i) for (var At = 0; At < this.n; At++) dt = Q * this.V[At][ht] + ut * this.V[At][ht + 1], this.V[At][ht + 1] = -ut * this.V[At][ht] + Q * this.V[At][ht + 1], this.V[At][ht] = dt;
+                  if (dt = f.hypot(wt, vt), Q = wt / dt, ut = vt / dt, this.s[ht] = dt, wt = Q * t[ht] + ut * this.s[ht + 1], this.s[ht + 1] = -ut * t[ht] + Q * this.s[ht + 1], vt = ut * t[ht + 1], t[ht + 1] = Q * t[ht + 1], l && ht < this.m - 1) for (var rt = 0; rt < this.m; rt++) dt = Q * this.U[rt][ht] + ut * this.U[rt][ht + 1], this.U[rt][ht + 1] = -ut * this.U[rt][ht] + Q * this.U[rt][ht + 1], this.U[rt][ht] = dt;
+                }
+                t[u - 2] = wt, lt += 1;
+                break;
+              case 4:
+                if (this.s[j] <= 0 && (this.s[j] = this.s[j] < 0 ? -this.s[j] : 0, i)) for (var bt = 0; bt <= V; bt++) this.V[bt][j] = -this.V[bt][j];
+                for (; j < V && !(this.s[j] >= this.s[j + 1]); ) {
+                  var Ot = this.s[j];
+                  if (this.s[j] = this.s[j + 1], this.s[j + 1] = Ot, i && j < this.n - 1) for (var Dt = 0; Dt < this.n; Dt++) Ot = this.V[Dt][j + 1], this.V[Dt][j + 1] = this.V[Dt][j], this.V[Dt][j] = Ot;
+                  if (l && j < this.m - 1) for (var Ft = 0; Ft < this.m; Ft++) Ot = this.U[Ft][j + 1], this.U[Ft][j + 1] = this.U[Ft][j], this.U[Ft][j] = Ot;
+                  j++;
+                }
+                lt = 0, u--;
+                break;
+            }
+          }
+          return {
+            U: this.U,
+            V: this.V,
+            S: this.s
+          };
+        }, f.hypot = function(o, r) {
+          var t = void 0;
+          return Math.abs(o) > Math.abs(r) ? (t = r / o, t = Math.abs(o) * Math.sqrt(1 + t * t)) : r == 0 ? t = 0 : (t = o / r, t = Math.abs(r) * Math.sqrt(1 + t * t)), t;
+        }, A.exports = f;
+      }),
+      (function(A, D, N) {
+        var f = /* @__PURE__ */ (function() {
+          function r(t, e) {
+            for (var l = 0; l < e.length; l++) {
+              var i = e[l];
+              i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(t, i.key, i);
+            }
+          }
+          return function(t, e, l) {
+            return e && r(t.prototype, e), l && r(t, l), t;
+          };
+        })();
+        function o(r, t) {
+          if (!(r instanceof t)) throw TypeError("Cannot call a class as a function");
+        }
+        A.exports = (function() {
+          function r(t, e) {
+            var l = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1, i = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : -1, p = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : -1;
+            o(this, r), this.sequence1 = t, this.sequence2 = e, this.match_score = l, this.mismatch_penalty = i, this.gap_penalty = p, this.iMax = t.length + 1, this.jMax = e.length + 1, this.grid = Array(this.iMax);
+            for (var a = 0; a < this.iMax; a++) {
+              this.grid[a] = Array(this.jMax);
+              for (var n = 0; n < this.jMax; n++) this.grid[a][n] = 0;
+            }
+            this.tracebackGrid = Array(this.iMax);
+            for (var g = 0; g < this.iMax; g++) {
+              this.tracebackGrid[g] = Array(this.jMax);
+              for (var h = 0; h < this.jMax; h++) this.tracebackGrid[g][h] = [
+                null,
+                null,
+                null
+              ];
+            }
+            this.alignments = [], this.score = -1, this.computeGrids();
+          }
+          return f(r, [
+            {
+              key: "getScore",
+              value: function() {
+                return this.score;
+              }
+            },
+            {
+              key: "getAlignments",
+              value: function() {
+                return this.alignments;
+              }
+            },
+            {
+              key: "computeGrids",
+              value: function() {
+                for (var t = 1; t < this.jMax; t++) this.grid[0][t] = this.grid[0][t - 1] + this.gap_penalty, this.tracebackGrid[0][t] = [
+                  !1,
+                  !1,
+                  !0
+                ];
+                for (var e = 1; e < this.iMax; e++) this.grid[e][0] = this.grid[e - 1][0] + this.gap_penalty, this.tracebackGrid[e][0] = [
+                  !1,
+                  !0,
+                  !1
+                ];
+                for (var l = 1; l < this.iMax; l++) for (var i = 1; i < this.jMax; i++) {
+                  var p = void 0;
+                  p = this.sequence1[l - 1] === this.sequence2[i - 1] ? this.grid[l - 1][i - 1] + this.match_score : this.grid[l - 1][i - 1] + this.mismatch_penalty;
+                  var a = this.grid[l - 1][i] + this.gap_penalty, n = this.grid[l][i - 1] + this.gap_penalty, g = [
+                    p,
+                    a,
+                    n
+                  ], h = this.arrayAllMaxIndexes(g);
+                  this.grid[l][i] = g[h[0]], this.tracebackGrid[l][i] = [
+                    h.includes(0),
+                    h.includes(1),
+                    h.includes(2)
+                  ];
+                }
+                this.score = this.grid[this.iMax - 1][this.jMax - 1];
+              }
+            },
+            {
+              key: "alignmentTraceback",
+              value: function() {
+                var t = [];
+                for (t.push({
+                  pos: [this.sequence1.length, this.sequence2.length],
+                  seq1: "",
+                  seq2: ""
+                }); t[0]; ) {
+                  var e = t[0], l = this.tracebackGrid[e.pos[0]][e.pos[1]];
+                  l[0] && t.push({
+                    pos: [e.pos[0] - 1, e.pos[1] - 1],
+                    seq1: this.sequence1[e.pos[0] - 1] + e.seq1,
+                    seq2: this.sequence2[e.pos[1] - 1] + e.seq2
+                  }), l[1] && t.push({
+                    pos: [e.pos[0] - 1, e.pos[1]],
+                    seq1: this.sequence1[e.pos[0] - 1] + e.seq1,
+                    seq2: "-" + e.seq2
+                  }), l[2] && t.push({
+                    pos: [e.pos[0], e.pos[1] - 1],
+                    seq1: "-" + e.seq1,
+                    seq2: this.sequence2[e.pos[1] - 1] + e.seq2
+                  }), e.pos[0] === 0 && e.pos[1] === 0 && this.alignments.push({
+                    sequence1: e.seq1,
+                    sequence2: e.seq2
+                  }), t.shift();
+                }
+                return this.alignments;
+              }
+            },
+            {
+              key: "getAllIndexes",
+              value: function(t, e) {
+                for (var l = [], i = -1; (i = t.indexOf(e, i + 1)) !== -1; ) l.push(i);
+                return l;
+              }
+            },
+            {
+              key: "arrayAllMaxIndexes",
+              value: function(t) {
+                return this.getAllIndexes(t, Math.max.apply(null, t));
+              }
+            }
+          ]), r;
+        })();
+      }),
+      (function(A, D, N) {
+        var f = function() {
+        };
+        f.FDLayout = N(18), f.FDLayoutConstants = N(4), f.FDLayoutEdge = N(19), f.FDLayoutNode = N(20), f.DimensionD = N(21), f.HashMap = N(22), f.HashSet = N(23), f.IGeometry = N(8), f.IMath = N(9), f.Integer = N(10), f.Point = N(12), f.PointD = N(5), f.RandomSeed = N(16), f.RectangleD = N(13), f.Transform = N(17), f.UniqueIDGeneretor = N(14), f.Quicksort = N(25), f.LinkedList = N(11), f.LGraphObject = N(2), f.LGraph = N(6), f.LEdge = N(1), f.LGraphManager = N(7), f.LNode = N(3), f.Layout = N(15), f.LayoutConstants = N(0), f.NeedlemanWunsch = N(27), f.Matrix = N(24), f.SVD = N(26), A.exports = f;
+      }),
+      (function(A, D, N) {
+        function f() {
+          this.listeners = [];
+        }
+        var o = f.prototype;
+        o.addListener = function(r, t) {
+          this.listeners.push({
+            event: r,
+            callback: t
+          });
+        }, o.removeListener = function(r, t) {
+          for (var e = this.listeners.length; e >= 0; e--) {
+            var l = this.listeners[e];
+            l.event === r && l.callback === t && this.listeners.splice(e, 1);
+          }
+        }, o.emit = function(r, t) {
+          for (var e = 0; e < this.listeners.length; e++) {
+            var l = this.listeners[e];
+            r === l.event && l.callback(t);
+          }
+        }, A.exports = f;
+      })
+    ]);
+  });
+})), Ce = /* @__PURE__ */ fe(((M, _) => {
+  (function(A, D) {
+    typeof M == "object" && typeof _ == "object" ? _.exports = D(Ae()) : typeof define == "function" && define.amd ? define(["layout-base"], D) : typeof M == "object" ? M.coseBase = D(Ae()) : A.coseBase = D(A.layoutBase);
+  })(M, function(A) {
+    return (() => {
+      var D = {
+        45: ((o, r, t) => {
+          var e = {};
+          e.layoutBase = t(551), e.CoSEConstants = t(806), e.CoSEEdge = t(767), e.CoSEGraph = t(880), e.CoSEGraphManager = t(578), e.CoSELayout = t(765), e.CoSENode = t(991), e.ConstraintHandler = t(902), o.exports = e;
+        }),
+        806: ((o, r, t) => {
+          var e = t(551).FDLayoutConstants;
+          function l() {
+          }
+          for (var i in e) l[i] = e[i];
+          l.DEFAULT_USE_MULTI_LEVEL_SCALING = !1, l.DEFAULT_RADIAL_SEPARATION = e.DEFAULT_EDGE_LENGTH, l.DEFAULT_COMPONENT_SEPERATION = 60, l.TILE = !0, l.TILING_PADDING_VERTICAL = 10, l.TILING_PADDING_HORIZONTAL = 10, l.TRANSFORM_ON_CONSTRAINT_HANDLING = !0, l.ENFORCE_CONSTRAINTS = !0, l.APPLY_LAYOUT = !0, l.RELAX_MOVEMENT_ON_CONSTRAINTS = !0, l.TREE_REDUCTION_ON_INCREMENTAL = !0, l.PURE_INCREMENTAL = l.DEFAULT_INCREMENTAL, o.exports = l;
+        }),
+        767: ((o, r, t) => {
+          var e = t(551).FDLayoutEdge;
+          function l(p, a, n) {
+            e.call(this, p, a, n);
+          }
+          for (var i in l.prototype = Object.create(e.prototype), e) l[i] = e[i];
+          o.exports = l;
+        }),
+        880: ((o, r, t) => {
+          var e = t(551).LGraph;
+          function l(p, a, n) {
+            e.call(this, p, a, n);
+          }
+          for (var i in l.prototype = Object.create(e.prototype), e) l[i] = e[i];
+          o.exports = l;
+        }),
+        578: ((o, r, t) => {
+          var e = t(551).LGraphManager;
+          function l(p) {
+            e.call(this, p);
+          }
+          for (var i in l.prototype = Object.create(e.prototype), e) l[i] = e[i];
+          o.exports = l;
+        }),
+        765: ((o, r, t) => {
+          var e = t(551).FDLayout, l = t(578), i = t(880), p = t(991), a = t(767), n = t(806), g = t(902), h = t(551).FDLayoutConstants, c = t(551).LayoutConstants, d = t(551).Point, v = t(551).PointD, T = t(551).DimensionD, L = t(551).Layout, F = t(551).Integer, S = t(551).IGeometry, P = t(551).LGraph, U = t(551).Transform, Z = t(551).LinkedList;
+          function x() {
+            e.call(this), this.toBeTiled = {}, this.constraints = {};
+          }
+          for (var K in x.prototype = Object.create(e.prototype), e) x[K] = e[K];
+          x.prototype.newGraphManager = function() {
+            var s = new l(this);
+            return this.graphManager = s, s;
+          }, x.prototype.newGraph = function(s) {
+            return new i(null, this.graphManager, s);
+          }, x.prototype.newNode = function(s) {
+            return new p(this.graphManager, s);
+          }, x.prototype.newEdge = function(s) {
+            return new a(null, null, s);
+          }, x.prototype.initParameters = function() {
+            e.prototype.initParameters.call(this, arguments), this.isSubLayout || (n.DEFAULT_EDGE_LENGTH < 10 ? this.idealEdgeLength = 10 : this.idealEdgeLength = n.DEFAULT_EDGE_LENGTH, this.useSmartIdealEdgeLengthCalculation = n.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.gravityConstant = h.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = h.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = h.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = h.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.prunedNodesAll = [], this.growTreeIterations = 0, this.afterGrowthIterations = 0, this.isTreeGrowing = !1, this.isGrowthFinished = !1);
+          }, x.prototype.initSpringEmbedder = function() {
+            e.prototype.initSpringEmbedder.call(this), this.coolingCycle = 0, this.maxCoolingCycle = this.maxIterations / h.CONVERGENCE_CHECK_PERIOD, this.finalTemperature = 0.04, this.coolingAdjuster = 1;
+          }, x.prototype.layout = function() {
+            return c.DEFAULT_CREATE_BENDS_AS_NEEDED && (this.createBendpoints(), this.graphManager.resetAllEdges()), this.level = 0, this.classicLayout();
+          }, x.prototype.classicLayout = function() {
+            if (this.nodesWithGravity = this.calculateNodesToApplyGravitationTo(), this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity), this.calcNoOfChildrenForAllNodes(), this.graphManager.calcLowestCommonAncestors(), this.graphManager.calcInclusionTreeDepths(), this.graphManager.getRoot().calcEstimatedSize(), this.calcIdealEdgeLengths(), !this.incremental) {
+              var s = this.getFlatForest();
+              if (s.length > 0) this.positionNodesRadially(s);
+              else {
+                this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+                var E = new Set(this.getAllNodes()), u = this.nodesWithGravity.filter(function(m) {
+                  return E.has(m);
+                });
+                this.graphManager.setAllNodesToApplyGravitation(u), this.positionNodesRandomly();
+              }
+            } else if (n.TREE_REDUCTION_ON_INCREMENTAL) {
+              this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+              var E = new Set(this.getAllNodes()), u = this.nodesWithGravity.filter(function(C) {
+                return E.has(C);
+              });
+              this.graphManager.setAllNodesToApplyGravitation(u);
+            }
+            return Object.keys(this.constraints).length > 0 && (g.handleConstraints(this), this.initConstraintVariables()), this.initSpringEmbedder(), n.APPLY_LAYOUT && this.runSpringEmbedder(), !0;
+          }, x.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 % h.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) {
+              if (this.isConverged()) if (this.prunedNodesAll.length > 0) this.isTreeGrowing = !0;
+              else return !0;
+              this.coolingCycle++, this.layoutQuality == 0 ? this.coolingAdjuster = this.coolingCycle : this.layoutQuality == 1 && (this.coolingAdjuster = this.coolingCycle / 3), this.coolingFactor = Math.max(this.initialCoolingFactor - this.coolingCycle ** +(Math.log(100 * (this.initialCoolingFactor - this.finalTemperature)) / Math.log(this.maxCoolingCycle)) / 100 * this.coolingAdjuster, this.finalTemperature), this.animationPeriod = Math.ceil(this.initialAnimationPeriod * Math.sqrt(this.coolingFactor));
+            }
+            if (this.isTreeGrowing) {
+              if (this.growTreeIterations % 10 == 0) if (this.prunedNodesAll.length > 0) {
+                this.graphManager.updateBounds(), this.updateGrid(), this.growTree(this.prunedNodesAll), this.graphManager.resetAllNodesToApplyGravitation();
+                var s = new Set(this.getAllNodes()), E = this.nodesWithGravity.filter(function(y) {
+                  return s.has(y);
+                });
+                this.graphManager.setAllNodesToApplyGravitation(E), this.graphManager.updateBounds(), this.updateGrid(), n.PURE_INCREMENTAL ? this.coolingFactor = h.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2 : this.coolingFactor = h.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()), n.PURE_INCREMENTAL ? this.coolingFactor = h.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2 * ((100 - this.afterGrowthIterations) / 100) : this.coolingFactor = h.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100), this.afterGrowthIterations++;
+            }
+            var u = !this.isTreeGrowing && !this.isGrowthFinished, m = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished;
+            return this.totalDisplacement = 0, this.graphManager.updateBounds(), this.calcSpringForces(), this.calcRepulsionForces(u, m), this.calcGravitationalForces(), this.moveNodes(), this.animate(), !1;
+          }, x.prototype.getPositionsData = function() {
+            for (var s = this.graphManager.getAllNodes(), E = {}, u = 0; u < s.length; u++) {
+              var m = s[u].rect, y = s[u].id;
+              E[y] = {
+                id: y,
+                x: m.getCenterX(),
+                y: m.getCenterY(),
+                w: m.width,
+                h: m.height
+              };
+            }
+            return E;
+          }, x.prototype.runSpringEmbedder = function() {
+            this.initialAnimationPeriod = 25, this.animationPeriod = this.initialAnimationPeriod;
+            var s = !1;
+            if (h.ANIMATE === "during") this.emit("layoutstarted");
+            else {
+              for (; !s; ) s = this.tick();
+              this.graphManager.updateBounds();
+            }
+          }, x.prototype.moveNodes = function() {
+            for (var s = this.getAllNodes(), E, u = 0; u < s.length; u++) E = s[u], E.calculateDisplacement();
+            Object.keys(this.constraints).length > 0 && this.updateDisplacements();
+            for (var u = 0; u < s.length; u++) E = s[u], E.move();
+          }, x.prototype.initConstraintVariables = function() {
+            var s = this;
+            this.idToNodeMap = /* @__PURE__ */ new Map(), this.fixedNodeSet = /* @__PURE__ */ new Set();
+            for (var E = this.graphManager.getAllNodes(), u = 0; u < E.length; u++) {
+              var m = E[u];
+              this.idToNodeMap.set(m.id, m);
+            }
+            var y = function O(B) {
+              for (var et = B.getChild().getNodes(), X, V = 0, lt = 0; lt < et.length; lt++) X = et[lt], X.getChild() == null ? s.fixedNodeSet.has(X.id) && (V += 100) : V += O(X);
+              return V;
+            };
+            if (this.constraints.fixedNodeConstraint) {
+              this.constraints.fixedNodeConstraint.forEach(function(O) {
+                s.fixedNodeSet.add(O.nodeId);
+              });
+              for (var E = this.graphManager.getAllNodes(), m, u = 0; u < E.length; u++) if (m = E[u], m.getChild() != null) {
+                var C = y(m);
+                C > 0 && (m.fixedNodeWeight = C);
+              }
+            }
+            if (this.constraints.relativePlacementConstraint) {
+              var w = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map();
+              if (this.dummyToNodeForVerticalAlignment = /* @__PURE__ */ new Map(), this.dummyToNodeForHorizontalAlignment = /* @__PURE__ */ new Map(), this.fixedNodesOnHorizontal = /* @__PURE__ */ new Set(), this.fixedNodesOnVertical = /* @__PURE__ */ new Set(), this.fixedNodeSet.forEach(function(O) {
+                s.fixedNodesOnHorizontal.add(O), s.fixedNodesOnVertical.add(O);
+              }), this.constraints.alignmentConstraint) {
+                if (this.constraints.alignmentConstraint.vertical) for (var G = this.constraints.alignmentConstraint.vertical, u = 0; u < G.length; u++) this.dummyToNodeForVerticalAlignment.set("dummy" + u, []), G[u].forEach(function(B) {
+                  w.set(B, "dummy" + u), s.dummyToNodeForVerticalAlignment.get("dummy" + u).push(B), s.fixedNodeSet.has(B) && s.fixedNodesOnHorizontal.add("dummy" + u);
+                });
+                if (this.constraints.alignmentConstraint.horizontal) for (var b = this.constraints.alignmentConstraint.horizontal, u = 0; u < b.length; u++) this.dummyToNodeForHorizontalAlignment.set("dummy" + u, []), b[u].forEach(function(B) {
+                  R.set(B, "dummy" + u), s.dummyToNodeForHorizontalAlignment.get("dummy" + u).push(B), s.fixedNodeSet.has(B) && s.fixedNodesOnVertical.add("dummy" + u);
+                });
+              }
+              if (n.RELAX_MOVEMENT_ON_CONSTRAINTS) this.shuffle = function(O) {
+                var B, et, X;
+                for (X = O.length - 1; X >= 2 * O.length / 3; X--) B = Math.floor(Math.random() * (X + 1)), et = O[X], O[X] = O[B], O[B] = et;
+                return O;
+              }, this.nodesInRelativeHorizontal = [], this.nodesInRelativeVertical = [], this.nodeToRelativeConstraintMapHorizontal = /* @__PURE__ */ new Map(), this.nodeToRelativeConstraintMapVertical = /* @__PURE__ */ new Map(), this.nodeToTempPositionMapHorizontal = /* @__PURE__ */ new Map(), this.nodeToTempPositionMapVertical = /* @__PURE__ */ new Map(), this.constraints.relativePlacementConstraint.forEach(function(O) {
+                if (O.left) {
+                  var B = w.has(O.left) ? w.get(O.left) : O.left, et = w.has(O.right) ? w.get(O.right) : O.right;
+                  s.nodesInRelativeHorizontal.includes(B) || (s.nodesInRelativeHorizontal.push(B), s.nodeToRelativeConstraintMapHorizontal.set(B, []), s.dummyToNodeForVerticalAlignment.has(B) ? s.nodeToTempPositionMapHorizontal.set(B, s.idToNodeMap.get(s.dummyToNodeForVerticalAlignment.get(B)[0]).getCenterX()) : s.nodeToTempPositionMapHorizontal.set(B, s.idToNodeMap.get(B).getCenterX())), s.nodesInRelativeHorizontal.includes(et) || (s.nodesInRelativeHorizontal.push(et), s.nodeToRelativeConstraintMapHorizontal.set(et, []), s.dummyToNodeForVerticalAlignment.has(et) ? s.nodeToTempPositionMapHorizontal.set(et, s.idToNodeMap.get(s.dummyToNodeForVerticalAlignment.get(et)[0]).getCenterX()) : s.nodeToTempPositionMapHorizontal.set(et, s.idToNodeMap.get(et).getCenterX())), s.nodeToRelativeConstraintMapHorizontal.get(B).push({
+                    right: et,
+                    gap: O.gap
+                  }), s.nodeToRelativeConstraintMapHorizontal.get(et).push({
+                    left: B,
+                    gap: O.gap
+                  });
+                } else {
+                  var X = R.has(O.top) ? R.get(O.top) : O.top, V = R.has(O.bottom) ? R.get(O.bottom) : O.bottom;
+                  s.nodesInRelativeVertical.includes(X) || (s.nodesInRelativeVertical.push(X), s.nodeToRelativeConstraintMapVertical.set(X, []), s.dummyToNodeForHorizontalAlignment.has(X) ? s.nodeToTempPositionMapVertical.set(X, s.idToNodeMap.get(s.dummyToNodeForHorizontalAlignment.get(X)[0]).getCenterY()) : s.nodeToTempPositionMapVertical.set(X, s.idToNodeMap.get(X).getCenterY())), s.nodesInRelativeVertical.includes(V) || (s.nodesInRelativeVertical.push(V), s.nodeToRelativeConstraintMapVertical.set(V, []), s.dummyToNodeForHorizontalAlignment.has(V) ? s.nodeToTempPositionMapVertical.set(V, s.idToNodeMap.get(s.dummyToNodeForHorizontalAlignment.get(V)[0]).getCenterY()) : s.nodeToTempPositionMapVertical.set(V, s.idToNodeMap.get(V).getCenterY())), s.nodeToRelativeConstraintMapVertical.get(X).push({
+                    bottom: V,
+                    gap: O.gap
+                  }), s.nodeToRelativeConstraintMapVertical.get(V).push({
+                    top: X,
+                    gap: O.gap
+                  });
+                }
+              });
+              else {
+                var k = /* @__PURE__ */ new Map(), W = /* @__PURE__ */ new Map();
+                this.constraints.relativePlacementConstraint.forEach(function(O) {
+                  if (O.left) {
+                    var B = w.has(O.left) ? w.get(O.left) : O.left, et = w.has(O.right) ? w.get(O.right) : O.right;
+                    k.has(B) ? k.get(B).push(et) : k.set(B, [et]), k.has(et) ? k.get(et).push(B) : k.set(et, [B]);
+                  } else {
+                    var X = R.has(O.top) ? R.get(O.top) : O.top, V = R.has(O.bottom) ? R.get(O.bottom) : O.bottom;
+                    W.has(X) ? W.get(X).push(V) : W.set(X, [V]), W.has(V) ? W.get(V).push(X) : W.set(V, [X]);
+                  }
+                });
+                var J = function(O, B) {
+                  var et = [], X = [], V = new Z(), lt = /* @__PURE__ */ new Set(), at = 0;
+                  return O.forEach(function(Lt, j) {
+                    if (!lt.has(j)) {
+                      et[at] = [], X[at] = !1;
+                      var pt = j;
+                      for (V.push(pt), lt.add(pt), et[at].push(pt); V.length != 0; ) pt = V.shift(), B.has(pt) && (X[at] = !0), O.get(pt).forEach(function(yt) {
+                        lt.has(yt) || (V.push(yt), lt.add(yt), et[at].push(yt));
+                      });
+                      at++;
+                    }
+                  }), {
+                    components: et,
+                    isFixed: X
+                  };
+                }, H = J(k, s.fixedNodesOnHorizontal);
+                this.componentsOnHorizontal = H.components, this.fixedComponentsOnHorizontal = H.isFixed;
+                var z = J(W, s.fixedNodesOnVertical);
+                this.componentsOnVertical = z.components, this.fixedComponentsOnVertical = z.isFixed;
+              }
+            }
+          }, x.prototype.updateDisplacements = function() {
+            var s = this;
+            if (this.constraints.fixedNodeConstraint && this.constraints.fixedNodeConstraint.forEach(function(z) {
+              var O = s.idToNodeMap.get(z.nodeId);
+              O.displacementX = 0, O.displacementY = 0;
+            }), this.constraints.alignmentConstraint) {
+              if (this.constraints.alignmentConstraint.vertical) for (var E = this.constraints.alignmentConstraint.vertical, u = 0; u < E.length; u++) {
+                for (var m = 0, y = 0; y < E[u].length; y++) {
+                  if (this.fixedNodeSet.has(E[u][y])) {
+                    m = 0;
+                    break;
+                  }
+                  m += this.idToNodeMap.get(E[u][y]).displacementX;
+                }
+                for (var C = m / E[u].length, y = 0; y < E[u].length; y++) this.idToNodeMap.get(E[u][y]).displacementX = C;
+              }
+              if (this.constraints.alignmentConstraint.horizontal) for (var w = this.constraints.alignmentConstraint.horizontal, u = 0; u < w.length; u++) {
+                for (var R = 0, y = 0; y < w[u].length; y++) {
+                  if (this.fixedNodeSet.has(w[u][y])) {
+                    R = 0;
+                    break;
+                  }
+                  R += this.idToNodeMap.get(w[u][y]).displacementY;
+                }
+                for (var G = R / w[u].length, y = 0; y < w[u].length; y++) this.idToNodeMap.get(w[u][y]).displacementY = G;
+              }
+            }
+            if (this.constraints.relativePlacementConstraint) if (n.RELAX_MOVEMENT_ON_CONSTRAINTS) this.totalIterations % 10 == 0 && (this.shuffle(this.nodesInRelativeHorizontal), this.shuffle(this.nodesInRelativeVertical)), this.nodesInRelativeHorizontal.forEach(function(z) {
+              if (!s.fixedNodesOnHorizontal.has(z)) {
+                var O = 0;
+                O = s.dummyToNodeForVerticalAlignment.has(z) ? s.idToNodeMap.get(s.dummyToNodeForVerticalAlignment.get(z)[0]).displacementX : s.idToNodeMap.get(z).displacementX, s.nodeToRelativeConstraintMapHorizontal.get(z).forEach(function(B) {
+                  if (B.right) {
+                    var et = s.nodeToTempPositionMapHorizontal.get(B.right) - s.nodeToTempPositionMapHorizontal.get(z) - O;
+                    et < B.gap && (O -= B.gap - et);
+                  } else {
+                    var et = s.nodeToTempPositionMapHorizontal.get(z) - s.nodeToTempPositionMapHorizontal.get(B.left) + O;
+                    et < B.gap && (O += B.gap - et);
+                  }
+                }), s.nodeToTempPositionMapHorizontal.set(z, s.nodeToTempPositionMapHorizontal.get(z) + O), s.dummyToNodeForVerticalAlignment.has(z) ? s.dummyToNodeForVerticalAlignment.get(z).forEach(function(B) {
+                  s.idToNodeMap.get(B).displacementX = O;
+                }) : s.idToNodeMap.get(z).displacementX = O;
+              }
+            }), this.nodesInRelativeVertical.forEach(function(z) {
+              if (!s.fixedNodesOnHorizontal.has(z)) {
+                var O = 0;
+                O = s.dummyToNodeForHorizontalAlignment.has(z) ? s.idToNodeMap.get(s.dummyToNodeForHorizontalAlignment.get(z)[0]).displacementY : s.idToNodeMap.get(z).displacementY, s.nodeToRelativeConstraintMapVertical.get(z).forEach(function(B) {
+                  if (B.bottom) {
+                    var et = s.nodeToTempPositionMapVertical.get(B.bottom) - s.nodeToTempPositionMapVertical.get(z) - O;
+                    et < B.gap && (O -= B.gap - et);
+                  } else {
+                    var et = s.nodeToTempPositionMapVertical.get(z) - s.nodeToTempPositionMapVertical.get(B.top) + O;
+                    et < B.gap && (O += B.gap - et);
+                  }
+                }), s.nodeToTempPositionMapVertical.set(z, s.nodeToTempPositionMapVertical.get(z) + O), s.dummyToNodeForHorizontalAlignment.has(z) ? s.dummyToNodeForHorizontalAlignment.get(z).forEach(function(B) {
+                  s.idToNodeMap.get(B).displacementY = O;
+                }) : s.idToNodeMap.get(z).displacementY = O;
+              }
+            });
+            else {
+              for (var u = 0; u < this.componentsOnHorizontal.length; u++) {
+                var b = this.componentsOnHorizontal[u];
+                if (this.fixedComponentsOnHorizontal[u]) for (var y = 0; y < b.length; y++) this.dummyToNodeForVerticalAlignment.has(b[y]) ? this.dummyToNodeForVerticalAlignment.get(b[y]).forEach(function(B) {
+                  s.idToNodeMap.get(B).displacementX = 0;
+                }) : this.idToNodeMap.get(b[y]).displacementX = 0;
+                else {
+                  for (var k = 0, W = 0, y = 0; y < b.length; y++) if (this.dummyToNodeForVerticalAlignment.has(b[y])) {
+                    var J = this.dummyToNodeForVerticalAlignment.get(b[y]);
+                    k += J.length * this.idToNodeMap.get(J[0]).displacementX, W += J.length;
+                  } else k += this.idToNodeMap.get(b[y]).displacementX, W++;
+                  for (var H = k / W, y = 0; y < b.length; y++) this.dummyToNodeForVerticalAlignment.has(b[y]) ? this.dummyToNodeForVerticalAlignment.get(b[y]).forEach(function(B) {
+                    s.idToNodeMap.get(B).displacementX = H;
+                  }) : this.idToNodeMap.get(b[y]).displacementX = H;
+                }
+              }
+              for (var u = 0; u < this.componentsOnVertical.length; u++) {
+                var b = this.componentsOnVertical[u];
+                if (this.fixedComponentsOnVertical[u]) for (var y = 0; y < b.length; y++) this.dummyToNodeForHorizontalAlignment.has(b[y]) ? this.dummyToNodeForHorizontalAlignment.get(b[y]).forEach(function(et) {
+                  s.idToNodeMap.get(et).displacementY = 0;
+                }) : this.idToNodeMap.get(b[y]).displacementY = 0;
+                else {
+                  for (var k = 0, W = 0, y = 0; y < b.length; y++) if (this.dummyToNodeForHorizontalAlignment.has(b[y])) {
+                    var J = this.dummyToNodeForHorizontalAlignment.get(b[y]);
+                    k += J.length * this.idToNodeMap.get(J[0]).displacementY, W += J.length;
+                  } else k += this.idToNodeMap.get(b[y]).displacementY, W++;
+                  for (var H = k / W, y = 0; y < b.length; y++) this.dummyToNodeForHorizontalAlignment.has(b[y]) ? this.dummyToNodeForHorizontalAlignment.get(b[y]).forEach(function(X) {
+                    s.idToNodeMap.get(X).displacementY = H;
+                  }) : this.idToNodeMap.get(b[y]).displacementY = H;
+                }
+              }
+            }
+          }, x.prototype.calculateNodesToApplyGravitationTo = function() {
+            var s = [], E, u = this.graphManager.getGraphs(), m = u.length, y;
+            for (y = 0; y < m; y++) E = u[y], E.updateConnected(), E.isConnected || (s = s.concat(E.getNodes()));
+            return s;
+          }, x.prototype.createBendpoints = function() {
+            var s = [];
+            s = s.concat(this.graphManager.getAllEdges());
+            var E = /* @__PURE__ */ new Set(), u;
+            for (u = 0; u < s.length; u++) {
+              var m = s[u];
+              if (!E.has(m)) {
+                var y = m.getSource(), C = m.getTarget();
+                if (y == C) m.getBendpoints().push(new v()), m.getBendpoints().push(new v()), this.createDummyNodesForBendpoints(m), E.add(m);
+                else {
+                  var w = [];
+                  if (w = w.concat(y.getEdgeListToNode(C)), w = w.concat(C.getEdgeListToNode(y)), !E.has(w[0])) {
+                    if (w.length > 1) {
+                      var R;
+                      for (R = 0; R < w.length; R++) {
+                        var G = w[R];
+                        G.getBendpoints().push(new v()), this.createDummyNodesForBendpoints(G);
+                      }
+                    }
+                    w.forEach(function(b) {
+                      E.add(b);
+                    });
+                  }
+                }
+              }
+              if (E.size == s.length) break;
+            }
+          }, x.prototype.positionNodesRadially = function(s) {
+            for (var E = new d(0, 0), u = Math.ceil(Math.sqrt(s.length)), m = 0, y = 0, C = 0, w = new v(0, 0), R = 0; R < s.length; R++) {
+              R % u == 0 && (C = 0, y = m, R != 0 && (y += n.DEFAULT_COMPONENT_SEPERATION), m = 0);
+              var G = s[R], b = L.findCenterOfTree(G);
+              E.x = C, E.y = y, w = x.radialLayout(G, b, E), w.y > m && (m = Math.floor(w.y)), C = Math.floor(w.x + n.DEFAULT_COMPONENT_SEPERATION);
+            }
+            this.transform(new v(c.WORLD_CENTER_X - w.x / 2, c.WORLD_CENTER_Y - w.y / 2));
+          }, x.radialLayout = function(s, E, u) {
+            var m = Math.max(this.maxDiagonalInTree(s), n.DEFAULT_RADIAL_SEPARATION);
+            x.branchRadialLayout(E, null, 0, 359, 0, m);
+            var y = P.calculateBounds(s), C = new U();
+            C.setDeviceOrgX(y.getMinX()), C.setDeviceOrgY(y.getMinY()), C.setWorldOrgX(u.x), C.setWorldOrgY(u.y);
+            for (var w = 0; w < s.length; w++) s[w].transform(C);
+            var R = new v(y.getMaxX(), y.getMaxY());
+            return C.inverseTransformPoint(R);
+          }, x.branchRadialLayout = function(s, E, u, m, y, C) {
+            var w = (m - u + 1) / 2;
+            w < 0 && (w += 180);
+            var R = (w + u) % 360 * S.TWO_PI / 360, G = y * Math.cos(R), b = y * Math.sin(R);
+            s.setCenter(G, b);
+            var k = [];
+            k = k.concat(s.getEdges());
+            var W = k.length;
+            E != null && W--;
+            for (var J = 0, H = k.length, z, O = s.getEdgesBetween(E); O.length > 1; ) {
+              var B = O[0];
+              O.splice(0, 1);
+              var et = k.indexOf(B);
+              et >= 0 && k.splice(et, 1), H--, W--;
+            }
+            z = E == null ? 0 : (k.indexOf(O[0]) + 1) % H;
+            for (var X = Math.abs(m - u) / W, V = z; J != W; V = ++V % H) {
+              var lt = k[V].getOtherEnd(s);
+              if (lt != E) {
+                var at = (u + J * X) % 360, Lt = (at + X) % 360;
+                x.branchRadialLayout(lt, s, at, Lt, y + C, C), J++;
+              }
+            }
+          }, x.maxDiagonalInTree = function(s) {
+            for (var E = F.MIN_VALUE, u = 0; u < s.length; u++) {
+              var m = s[u].getDiagonal();
+              m > E && (E = m);
+            }
+            return E;
+          }, x.prototype.calcRepulsionRange = function() {
+            return 2 * (this.level + 1) * this.idealEdgeLength;
+          }, x.prototype.groupZeroDegreeMembers = function() {
+            var s = this, E = {};
+            this.memberGroups = {}, this.idToDummyNode = {};
+            for (var u = [], m = this.graphManager.getAllNodes(), y = 0; y < m.length; y++) {
+              var C = m[y], w = C.getParent();
+              this.getNodeDegreeWithChildren(C) === 0 && (w.id == null || !this.getToBeTiled(w)) && u.push(C);
+            }
+            for (var y = 0; y < u.length; y++) {
+              var C = u[y], R = C.getParent().id;
+              E[R] === void 0 && (E[R] = []), E[R] = E[R].concat(C);
+            }
+            Object.keys(E).forEach(function(G) {
+              if (E[G].length > 1) {
+                var b = "DummyCompound_" + G;
+                s.memberGroups[b] = E[G];
+                var k = E[G][0].getParent(), W = new p(s.graphManager);
+                W.id = b, W.paddingLeft = k.paddingLeft || 0, W.paddingRight = k.paddingRight || 0, W.paddingBottom = k.paddingBottom || 0, W.paddingTop = k.paddingTop || 0, s.idToDummyNode[b] = W;
+                var J = s.getGraphManager().add(s.newGraph(), W), H = k.getChild();
+                H.add(W);
+                for (var z = 0; z < E[G].length; z++) {
+                  var O = E[G][z];
+                  H.remove(O), J.add(O);
+                }
+              }
+            });
+          }, x.prototype.clearCompounds = function() {
+            var s = {}, E = {};
+            this.performDFSOnCompounds();
+            for (var u = 0; u < this.compoundOrder.length; u++) E[this.compoundOrder[u].id] = this.compoundOrder[u], s[this.compoundOrder[u].id] = [].concat(this.compoundOrder[u].getChild().getNodes()), this.graphManager.remove(this.compoundOrder[u].getChild()), this.compoundOrder[u].child = null;
+            this.graphManager.resetAllNodes(), this.tileCompoundMembers(s, E);
+          }, x.prototype.clearZeroDegreeMembers = function() {
+            var s = this, E = this.tiledZeroDegreePack = [];
+            Object.keys(this.memberGroups).forEach(function(u) {
+              var m = s.idToDummyNode[u];
+              if (E[u] = s.tileNodes(s.memberGroups[u], m.paddingLeft + m.paddingRight), m.rect.width = E[u].width, m.rect.height = E[u].height, m.setCenter(E[u].centerX, E[u].centerY), m.labelMarginLeft = 0, m.labelMarginTop = 0, n.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                var y = m.rect.width, C = m.rect.height;
+                m.labelWidth && (m.labelPosHorizontal == "left" ? (m.rect.x -= m.labelWidth, m.setWidth(y + m.labelWidth), m.labelMarginLeft = m.labelWidth) : m.labelPosHorizontal == "center" && m.labelWidth > y ? (m.rect.x -= (m.labelWidth - y) / 2, m.setWidth(m.labelWidth), m.labelMarginLeft = (m.labelWidth - y) / 2) : m.labelPosHorizontal == "right" && m.setWidth(y + m.labelWidth)), m.labelHeight && (m.labelPosVertical == "top" ? (m.rect.y -= m.labelHeight, m.setHeight(C + m.labelHeight), m.labelMarginTop = m.labelHeight) : m.labelPosVertical == "center" && m.labelHeight > C ? (m.rect.y -= (m.labelHeight - C) / 2, m.setHeight(m.labelHeight), m.labelMarginTop = (m.labelHeight - C) / 2) : m.labelPosVertical == "bottom" && m.setHeight(C + m.labelHeight));
+              }
+            });
+          }, x.prototype.repopulateCompounds = function() {
+            for (var s = this.compoundOrder.length - 1; s >= 0; s--) {
+              var E = this.compoundOrder[s], u = E.id, m = E.paddingLeft, y = E.paddingTop, C = E.labelMarginLeft, w = E.labelMarginTop;
+              this.adjustLocations(this.tiledMemberPack[u], E.rect.x, E.rect.y, m, y, C, w);
+            }
+          }, x.prototype.repopulateZeroDegreeMembers = function() {
+            var s = this, E = this.tiledZeroDegreePack;
+            Object.keys(E).forEach(function(u) {
+              var m = s.idToDummyNode[u], y = m.paddingLeft, C = m.paddingTop, w = m.labelMarginLeft, R = m.labelMarginTop;
+              s.adjustLocations(E[u], m.rect.x, m.rect.y, y, C, w, R);
+            });
+          }, x.prototype.getToBeTiled = function(s) {
+            var E = s.id;
+            if (this.toBeTiled[E] != null) return this.toBeTiled[E];
+            var u = s.getChild();
+            if (u == null) return this.toBeTiled[E] = !1, !1;
+            for (var m = u.getNodes(), y = 0; y < m.length; y++) {
+              var C = m[y];
+              if (this.getNodeDegree(C) > 0) return this.toBeTiled[E] = !1, !1;
+              if (C.getChild() == null) {
+                this.toBeTiled[C.id] = !1;
+                continue;
+              }
+              if (!this.getToBeTiled(C)) return this.toBeTiled[E] = !1, !1;
+            }
+            return this.toBeTiled[E] = !0, !0;
+          }, x.prototype.getNodeDegree = function(s) {
+            s.id;
+            for (var E = s.getEdges(), u = 0, m = 0; m < E.length; m++) {
+              var y = E[m];
+              y.getSource().id !== y.getTarget().id && (u += 1);
+            }
+            return u;
+          }, x.prototype.getNodeDegreeWithChildren = function(s) {
+            var E = this.getNodeDegree(s);
+            if (s.getChild() == null) return E;
+            for (var u = s.getChild().getNodes(), m = 0; m < u.length; m++) {
+              var y = u[m];
+              E += this.getNodeDegreeWithChildren(y);
+            }
+            return E;
+          }, x.prototype.performDFSOnCompounds = function() {
+            this.compoundOrder = [], this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes());
+          }, x.prototype.fillCompexOrderByDFS = function(s) {
+            for (var E = 0; E < s.length; E++) {
+              var u = s[E];
+              u.getChild() != null && this.fillCompexOrderByDFS(u.getChild().getNodes()), this.getToBeTiled(u) && this.compoundOrder.push(u);
+            }
+          }, x.prototype.adjustLocations = function(s, E, u, m, y, C, w) {
+            E += m + C, u += y + w;
+            for (var R = E, G = 0; G < s.rows.length; G++) {
+              var b = s.rows[G];
+              E = R;
+              for (var k = 0, W = 0; W < b.length; W++) {
+                var J = b[W];
+                J.rect.x = E, J.rect.y = u, E += J.rect.width + s.horizontalPadding, J.rect.height > k && (k = J.rect.height);
+              }
+              u += k + s.verticalPadding;
+            }
+          }, x.prototype.tileCompoundMembers = function(s, E) {
+            var u = this;
+            this.tiledMemberPack = [], Object.keys(s).forEach(function(m) {
+              var y = E[m];
+              if (u.tiledMemberPack[m] = u.tileNodes(s[m], y.paddingLeft + y.paddingRight), y.rect.width = u.tiledMemberPack[m].width, y.rect.height = u.tiledMemberPack[m].height, y.setCenter(u.tiledMemberPack[m].centerX, u.tiledMemberPack[m].centerY), y.labelMarginLeft = 0, y.labelMarginTop = 0, n.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                var C = y.rect.width, w = y.rect.height;
+                y.labelWidth && (y.labelPosHorizontal == "left" ? (y.rect.x -= y.labelWidth, y.setWidth(C + y.labelWidth), y.labelMarginLeft = y.labelWidth) : y.labelPosHorizontal == "center" && y.labelWidth > C ? (y.rect.x -= (y.labelWidth - C) / 2, y.setWidth(y.labelWidth), y.labelMarginLeft = (y.labelWidth - C) / 2) : y.labelPosHorizontal == "right" && y.setWidth(C + y.labelWidth)), y.labelHeight && (y.labelPosVertical == "top" ? (y.rect.y -= y.labelHeight, y.setHeight(w + y.labelHeight), y.labelMarginTop = y.labelHeight) : y.labelPosVertical == "center" && y.labelHeight > w ? (y.rect.y -= (y.labelHeight - w) / 2, y.setHeight(y.labelHeight), y.labelMarginTop = (y.labelHeight - w) / 2) : y.labelPosVertical == "bottom" && y.setHeight(w + y.labelHeight));
+              }
+            });
+          }, x.prototype.tileNodes = function(s, E) {
+            var u = this.tileNodesByFavoringDim(s, E, !0), m = this.tileNodesByFavoringDim(s, E, !1), y = this.getOrgRatio(u);
+            return this.getOrgRatio(m) < y ? m : u;
+          }, x.prototype.getOrgRatio = function(s) {
+            var E = s.width / s.height;
+            return E < 1 && (E = 1 / E), E;
+          }, x.prototype.calcIdealRowWidth = function(s, E) {
+            var u = n.TILING_PADDING_VERTICAL, m = n.TILING_PADDING_HORIZONTAL, y = s.length, C = 0, w = 0, R = 0;
+            s.forEach(function(z) {
+              C += z.getWidth(), w += z.getHeight(), z.getWidth() > R && (R = z.getWidth());
+            });
+            var G = C / y, b = w / y, k = (u - m) ** 2 + 4 * (G + m) * (b + u) * y, W = (m - u + Math.sqrt(k)) / (2 * (G + m)), J;
+            E ? (J = Math.ceil(W), J == W && J++) : J = Math.floor(W);
+            var H = J * (G + m) - m;
+            return R > H && (H = R), H += m * 2, H;
+          }, x.prototype.tileNodesByFavoringDim = function(s, E, u) {
+            var m = n.TILING_PADDING_VERTICAL, y = n.TILING_PADDING_HORIZONTAL, C = n.TILING_COMPARE_BY, w = {
+              rows: [],
+              rowWidth: [],
+              rowHeight: [],
+              width: 0,
+              height: E,
+              verticalPadding: m,
+              horizontalPadding: y,
+              centerX: 0,
+              centerY: 0
+            };
+            C && (w.idealRowWidth = this.calcIdealRowWidth(s, u));
+            var R = function(z) {
+              return z.rect.width * z.rect.height;
+            }, G = function(z, O) {
+              return R(O) - R(z);
+            };
+            s.sort(function(z, O) {
+              var B = G;
+              return w.idealRowWidth ? (B = C, B(z.id, O.id)) : B(z, O);
+            });
+            for (var b = 0, k = 0, W = 0; W < s.length; W++) {
+              var J = s[W];
+              b += J.getCenterX(), k += J.getCenterY();
+            }
+            w.centerX = b / s.length, w.centerY = k / s.length;
+            for (var W = 0; W < s.length; W++) {
+              var J = s[W];
+              if (w.rows.length == 0) this.insertNodeToRow(w, J, 0, E);
+              else if (this.canAddHorizontal(w, J.rect.width, J.rect.height)) {
+                var H = w.rows.length - 1;
+                w.idealRowWidth || (H = this.getShortestRowIndex(w)), this.insertNodeToRow(w, J, H, E);
+              } else this.insertNodeToRow(w, J, w.rows.length, E);
+              this.shiftToLastRow(w);
+            }
+            return w;
+          }, x.prototype.insertNodeToRow = function(s, E, u, m) {
+            var y = m;
+            u == s.rows.length && (s.rows.push([]), s.rowWidth.push(y), s.rowHeight.push(0));
+            var C = s.rowWidth[u] + E.rect.width;
+            s.rows[u].length > 0 && (C += s.horizontalPadding), s.rowWidth[u] = C, s.width < C && (s.width = C);
+            var w = E.rect.height;
+            u > 0 && (w += s.verticalPadding);
+            var R = 0;
+            w > s.rowHeight[u] && (R = s.rowHeight[u], s.rowHeight[u] = w, R = s.rowHeight[u] - R), s.height += R, s.rows[u].push(E);
+          }, x.prototype.getShortestRowIndex = function(s) {
+            for (var E = -1, u = Number.MAX_VALUE, m = 0; m < s.rows.length; m++) s.rowWidth[m] < u && (E = m, u = s.rowWidth[m]);
+            return E;
+          }, x.prototype.getLongestRowIndex = function(s) {
+            for (var E = -1, u = Number.MIN_VALUE, m = 0; m < s.rows.length; m++) s.rowWidth[m] > u && (E = m, u = s.rowWidth[m]);
+            return E;
+          }, x.prototype.canAddHorizontal = function(s, E, u) {
+            if (s.idealRowWidth) {
+              var m = s.rows.length - 1;
+              return s.rowWidth[m] + E + s.horizontalPadding <= s.idealRowWidth;
+            }
+            var y = this.getShortestRowIndex(s);
+            if (y < 0) return !0;
+            var C = s.rowWidth[y];
+            if (C + s.horizontalPadding + E <= s.width) return !0;
+            var w = 0;
+            s.rowHeight[y] < u && y > 0 && (w = u + s.verticalPadding - s.rowHeight[y]);
+            var R = s.width - C >= E + s.horizontalPadding ? (s.height + w) / (C + E + s.horizontalPadding) : (s.height + w) / s.width;
+            w = u + s.verticalPadding;
+            var G = s.width < E ? (s.height + w) / E : (s.height + w) / s.width;
+            return G < 1 && (G = 1 / G), R < 1 && (R = 1 / R), R < G;
+          }, x.prototype.shiftToLastRow = function(s) {
+            var E = this.getLongestRowIndex(s), u = s.rowWidth.length - 1, m = s.rows[E], y = m[m.length - 1], C = y.width + s.horizontalPadding;
+            if (s.width - s.rowWidth[u] > C && E != u) {
+              m.splice(-1, 1), s.rows[u].push(y), s.rowWidth[E] = s.rowWidth[E] - C, s.rowWidth[u] = s.rowWidth[u] + C, s.width = s.rowWidth[instance.getLongestRowIndex(s)];
+              for (var w = Number.MIN_VALUE, R = 0; R < m.length; R++) m[R].height > w && (w = m[R].height);
+              E > 0 && (w += s.verticalPadding);
+              var G = s.rowHeight[E] + s.rowHeight[u];
+              s.rowHeight[E] = w, s.rowHeight[u] < y.height + s.verticalPadding && (s.rowHeight[u] = y.height + s.verticalPadding);
+              var b = s.rowHeight[E] + s.rowHeight[u];
+              s.height += b - G, this.shiftToLastRow(s);
+            }
+          }, x.prototype.tilingPreLayout = function() {
+            n.TILE && (this.groupZeroDegreeMembers(), this.clearCompounds(), this.clearZeroDegreeMembers());
+          }, x.prototype.tilingPostLayout = function() {
+            n.TILE && (this.repopulateZeroDegreeMembers(), this.repopulateCompounds());
+          }, x.prototype.reduceTrees = function() {
+            for (var s = [], E = !0, u; E; ) {
+              var m = this.graphManager.getAllNodes(), y = [];
+              E = !1;
+              for (var C = 0; C < m.length; C++) if (u = m[C], u.getEdges().length == 1 && !u.getEdges()[0].isInterGraph && u.getChild() == null) {
+                if (n.PURE_INCREMENTAL) {
+                  var w = u.getEdges()[0].getOtherEnd(u), R = new T(u.getCenterX() - w.getCenterX(), u.getCenterY() - w.getCenterY());
+                  y.push([
+                    u,
+                    u.getEdges()[0],
+                    u.getOwner(),
+                    R
+                  ]);
+                } else y.push([
+                  u,
+                  u.getEdges()[0],
+                  u.getOwner()
+                ]);
+                E = !0;
+              }
+              if (E == 1) {
+                for (var G = [], b = 0; b < y.length; b++) y[b][0].getEdges().length == 1 && (G.push(y[b]), y[b][0].getOwner().remove(y[b][0]));
+                s.push(G), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+              }
+            }
+            this.prunedNodesAll = s;
+          }, x.prototype.growTree = function(s) {
+            for (var E = s[s.length - 1], u, m = 0; m < E.length; m++) u = E[m], this.findPlaceforPrunedNode(u), u[2].add(u[0]), u[2].add(u[1], u[1].source, u[1].target);
+            s.splice(s.length - 1, 1), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+          }, x.prototype.findPlaceforPrunedNode = function(s) {
+            var E, u, m = s[0];
+            if (u = m == s[1].source ? s[1].target : s[1].source, n.PURE_INCREMENTAL) m.setCenter(u.getCenterX() + s[3].getWidth(), u.getCenterY() + s[3].getHeight());
+            else {
+              var y = u.startX, C = u.finishX, w = u.startY, R = u.finishY, G = [
+                0,
+                0,
+                0,
+                0
+              ];
+              if (w > 0) for (var b = y; b <= C; b++) G[0] += this.grid[b][w - 1].length + this.grid[b][w].length - 1;
+              if (C < this.grid.length - 1) for (var b = w; b <= R; b++) G[1] += this.grid[C + 1][b].length + this.grid[C][b].length - 1;
+              if (R < this.grid[0].length - 1) for (var b = y; b <= C; b++) G[2] += this.grid[b][R + 1].length + this.grid[b][R].length - 1;
+              if (y > 0) for (var b = w; b <= R; b++) G[3] += this.grid[y - 1][b].length + this.grid[y][b].length - 1;
+              for (var k = F.MAX_VALUE, W, J, H = 0; H < G.length; H++) G[H] < k ? (k = G[H], W = 1, J = H) : G[H] == k && W++;
+              if (W == 3 && k == 0) G[0] == 0 && G[1] == 0 && G[2] == 0 ? E = 1 : G[0] == 0 && G[1] == 0 && G[3] == 0 ? E = 0 : G[0] == 0 && G[2] == 0 && G[3] == 0 ? E = 3 : G[1] == 0 && G[2] == 0 && G[3] == 0 && (E = 2);
+              else if (W == 2 && k == 0) {
+                var z = Math.floor(Math.random() * 2);
+                E = G[0] == 0 && G[1] == 0 ? z == 0 ? 0 : 1 : G[0] == 0 && G[2] == 0 ? z == 0 ? 0 : 2 : G[0] == 0 && G[3] == 0 ? z == 0 ? 0 : 3 : G[1] == 0 && G[2] == 0 ? z == 0 ? 1 : 2 : G[1] == 0 && G[3] == 0 ? z == 0 ? 1 : 3 : z == 0 ? 2 : 3;
+              } else if (W == 4 && k == 0) {
+                var z = Math.floor(Math.random() * 4);
+                E = z;
+              } else E = J;
+              E == 0 ? m.setCenter(u.getCenterX(), u.getCenterY() - u.getHeight() / 2 - h.DEFAULT_EDGE_LENGTH - m.getHeight() / 2) : E == 1 ? m.setCenter(u.getCenterX() + u.getWidth() / 2 + h.DEFAULT_EDGE_LENGTH + m.getWidth() / 2, u.getCenterY()) : E == 2 ? m.setCenter(u.getCenterX(), u.getCenterY() + u.getHeight() / 2 + h.DEFAULT_EDGE_LENGTH + m.getHeight() / 2) : m.setCenter(u.getCenterX() - u.getWidth() / 2 - h.DEFAULT_EDGE_LENGTH - m.getWidth() / 2, u.getCenterY());
+            }
+          }, o.exports = x;
+        }),
+        991: ((o, r, t) => {
+          var e = t(551).FDLayoutNode, l = t(551).IMath;
+          function i(a, n, g, h) {
+            e.call(this, a, n, g, h);
+          }
+          for (var p in i.prototype = Object.create(e.prototype), e) i[p] = e[p];
+          i.prototype.calculateDisplacement = function() {
+            var a = this.graphManager.getLayout();
+            this.getChild() != null && this.fixedNodeWeight ? (this.displacementX += a.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.fixedNodeWeight, this.displacementY += a.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.fixedNodeWeight) : (this.displacementX += a.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren, this.displacementY += a.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren), Math.abs(this.displacementX) > a.coolingFactor * a.maxNodeDisplacement && (this.displacementX = a.coolingFactor * a.maxNodeDisplacement * l.sign(this.displacementX)), Math.abs(this.displacementY) > a.coolingFactor * a.maxNodeDisplacement && (this.displacementY = a.coolingFactor * a.maxNodeDisplacement * l.sign(this.displacementY)), this.child && this.child.getNodes().length > 0 && this.propogateDisplacementToChildren(this.displacementX, this.displacementY);
+          }, i.prototype.propogateDisplacementToChildren = function(a, n) {
+            for (var g = this.getChild().getNodes(), h, c = 0; c < g.length; c++) h = g[c], h.getChild() == null ? (h.displacementX += a, h.displacementY += n) : h.propogateDisplacementToChildren(a, n);
+          }, i.prototype.move = function() {
+            var a = this.graphManager.getLayout();
+            (this.child == null || this.child.getNodes().length == 0) && (this.moveBy(this.displacementX, this.displacementY), a.totalDisplacement += Math.abs(this.displacementX) + Math.abs(this.displacementY)), this.springForceX = 0, this.springForceY = 0, this.repulsionForceX = 0, this.repulsionForceY = 0, this.gravitationForceX = 0, this.gravitationForceY = 0, this.displacementX = 0, this.displacementY = 0;
+          }, i.prototype.setPred1 = function(a) {
+            this.pred1 = a;
+          }, i.prototype.getPred1 = function() {
+            return pred1;
+          }, i.prototype.getPred2 = function() {
+            return pred2;
+          }, i.prototype.setNext = function(a) {
+            this.next = a;
+          }, i.prototype.getNext = function() {
+            return next;
+          }, i.prototype.setProcessed = function(a) {
+            this.processed = a;
+          }, i.prototype.isProcessed = function() {
+            return processed;
+          }, o.exports = i;
+        }),
+        902: ((o, r, t) => {
+          function e(g) {
+            if (Array.isArray(g)) {
+              for (var h = 0, c = Array(g.length); h < g.length; h++) c[h] = g[h];
+              return c;
+            } else return Array.from(g);
+          }
+          var l = t(806), i = t(551).LinkedList, p = t(551).Matrix, a = t(551).SVD;
+          function n() {
+          }
+          n.handleConstraints = function(g) {
+            var h = {};
+            h.fixedNodeConstraint = g.constraints.fixedNodeConstraint, h.alignmentConstraint = g.constraints.alignmentConstraint, h.relativePlacementConstraint = g.constraints.relativePlacementConstraint;
+            for (var c = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), v = [], T = [], L = g.getAllNodes(), F = 0, S = 0; S < L.length; S++) {
+              var P = L[S];
+              P.getChild() ?? (d.set(P.id, F++), v.push(P.getCenterX()), T.push(P.getCenterY()), c.set(P.id, P));
+            }
+            h.relativePlacementConstraint && h.relativePlacementConstraint.forEach(function(I) {
+              !I.gap && I.gap != 0 && (I.left ? I.gap = l.DEFAULT_EDGE_LENGTH + c.get(I.left).getWidth() / 2 + c.get(I.right).getWidth() / 2 : I.gap = l.DEFAULT_EDGE_LENGTH + c.get(I.top).getHeight() / 2 + c.get(I.bottom).getHeight() / 2);
+            });
+            var U = function(I, Y) {
+              return {
+                x: I.x - Y.x,
+                y: I.y - Y.y
+              };
+            }, Z = function(I) {
+              var Y = 0, q = 0;
+              return I.forEach(function($) {
+                Y += v[d.get($)], q += T[d.get($)];
+              }), {
+                x: Y / I.size,
+                y: q / I.size
+              };
+            }, x = function(I, Y, q, $, tt) {
+              function Et(dt, Q) {
+                var ut = new Set(dt), At = !0, rt = !1, bt = void 0;
+                try {
+                  for (var Ot = Q[Symbol.iterator](), Dt; !(At = (Dt = Ot.next()).done); At = !0) {
+                    var Ft = Dt.value;
+                    ut.add(Ft);
+                  }
+                } catch (Tt) {
+                  rt = !0, bt = Tt;
+                } finally {
+                  try {
+                    !At && Ot.return && Ot.return();
+                  } finally {
+                    if (rt) throw bt;
+                  }
+                }
+                return ut;
+              }
+              var mt = /* @__PURE__ */ new Map();
+              I.forEach(function(dt, Q) {
+                mt.set(Q, 0);
+              }), I.forEach(function(dt, Q) {
+                dt.forEach(function(ut) {
+                  mt.set(ut.id, mt.get(ut.id) + 1);
+                });
+              });
+              var it = /* @__PURE__ */ new Map(), ft = /* @__PURE__ */ new Map(), It = new i();
+              mt.forEach(function(dt, Q) {
+                dt == 0 ? (It.push(Q), q || (Y == "horizontal" ? it.set(Q, d.has(Q) ? v[d.get(Q)] : $.get(Q)) : it.set(Q, d.has(Q) ? T[d.get(Q)] : $.get(Q)))) : it.set(Q, -1 / 0), q && ft.set(Q, /* @__PURE__ */ new Set([Q]));
+              }), q && tt.forEach(function(dt) {
+                var Q = [];
+                if (dt.forEach(function(rt) {
+                  q.has(rt) && Q.push(rt);
+                }), Q.length > 0) {
+                  var ut = 0;
+                  Q.forEach(function(rt) {
+                    Y == "horizontal" ? (it.set(rt, d.has(rt) ? v[d.get(rt)] : $.get(rt)), ut += it.get(rt)) : (it.set(rt, d.has(rt) ? T[d.get(rt)] : $.get(rt)), ut += it.get(rt));
+                  }), ut /= Q.length, dt.forEach(function(rt) {
+                    q.has(rt) || it.set(rt, ut);
+                  });
+                } else {
+                  var At = 0;
+                  dt.forEach(function(rt) {
+                    Y == "horizontal" ? At += d.has(rt) ? v[d.get(rt)] : $.get(rt) : At += d.has(rt) ? T[d.get(rt)] : $.get(rt);
+                  }), At /= dt.length, dt.forEach(function(rt) {
+                    it.set(rt, At);
+                  });
+                }
+              });
+              for (var wt = function() {
+                var dt = It.shift();
+                I.get(dt).forEach(function(Q) {
+                  if (it.get(Q.id) < it.get(dt) + Q.gap) if (q && q.has(Q.id)) {
+                    var ut = void 0;
+                    if (ut = Y == "horizontal" ? d.has(Q.id) ? v[d.get(Q.id)] : $.get(Q.id) : d.has(Q.id) ? T[d.get(Q.id)] : $.get(Q.id), it.set(Q.id, ut), ut < it.get(dt) + Q.gap) {
+                      var At = it.get(dt) + Q.gap - ut;
+                      ft.get(dt).forEach(function(rt) {
+                        it.set(rt, it.get(rt) - At);
+                      });
+                    }
+                  } else it.set(Q.id, it.get(dt) + Q.gap);
+                  mt.set(Q.id, mt.get(Q.id) - 1), mt.get(Q.id) == 0 && It.push(Q.id), q && ft.set(Q.id, Et(ft.get(dt), ft.get(Q.id)));
+                });
+              }; It.length != 0; ) wt();
+              if (q) {
+                var vt = /* @__PURE__ */ new Set();
+                I.forEach(function(dt, Q) {
+                  dt.length == 0 && vt.add(Q);
+                });
+                var ht = [];
+                ft.forEach(function(dt, Q) {
+                  if (vt.has(Q)) {
+                    var ut = !1, At = !0, rt = !1, bt = void 0;
+                    try {
+                      for (var Ot = dt[Symbol.iterator](), Dt; !(At = (Dt = Ot.next()).done); At = !0) {
+                        var Ft = Dt.value;
+                        q.has(Ft) && (ut = !0);
+                      }
+                    } catch (Mt) {
+                      rt = !0, bt = Mt;
+                    } finally {
+                      try {
+                        !At && Ot.return && Ot.return();
+                      } finally {
+                        if (rt) throw bt;
+                      }
+                    }
+                    if (!ut) {
+                      var Tt = !1, Nt = void 0;
+                      ht.forEach(function(Mt, Pt) {
+                        Mt.has([].concat(e(dt))[0]) && (Tt = !0, Nt = Pt);
+                      }), Tt ? dt.forEach(function(Mt) {
+                        ht[Nt].add(Mt);
+                      }) : ht.push(new Set(dt));
+                    }
+                  }
+                }), ht.forEach(function(dt, Q) {
+                  var ut = 1 / 0, At = 1 / 0, rt = -1 / 0, bt = -1 / 0, Ot = !0, Dt = !1, Ft = void 0;
+                  try {
+                    for (var Tt = dt[Symbol.iterator](), Nt; !(Ot = (Nt = Tt.next()).done); Ot = !0) {
+                      var Mt = Nt.value, Pt = void 0;
+                      Pt = Y == "horizontal" ? d.has(Mt) ? v[d.get(Mt)] : $.get(Mt) : d.has(Mt) ? T[d.get(Mt)] : $.get(Mt);
+                      var Xt = it.get(Mt);
+                      Pt < ut && (ut = Pt), Pt > rt && (rt = Pt), Xt < At && (At = Xt), Xt > bt && (bt = Xt);
+                    }
+                  } catch ($t) {
+                    Dt = !0, Ft = $t;
+                  } finally {
+                    try {
+                      !Ot && Tt.return && Tt.return();
+                    } finally {
+                      if (Dt) throw Ft;
+                    }
+                  }
+                  var ne = (ut + rt) / 2 - (At + bt) / 2, ee = !0, qt = !1, Zt = void 0;
+                  try {
+                    for (var jt = dt[Symbol.iterator](), Kt; !(ee = (Kt = jt.next()).done); ee = !0) {
+                      var re = Kt.value;
+                      it.set(re, it.get(re) + ne);
+                    }
+                  } catch ($t) {
+                    qt = !0, Zt = $t;
+                  } finally {
+                    try {
+                      !ee && jt.return && jt.return();
+                    } finally {
+                      if (qt) throw Zt;
+                    }
+                  }
+                });
+              }
+              return it;
+            }, K = function(I) {
+              var Y = 0, q = 0, $ = 0, tt = 0;
+              if (I.forEach(function(ft) {
+                ft.left ? v[d.get(ft.left)] - v[d.get(ft.right)] >= 0 ? Y++ : q++ : T[d.get(ft.top)] - T[d.get(ft.bottom)] >= 0 ? $++ : tt++;
+              }), Y > q && $ > tt) for (var Et = 0; Et < d.size; Et++) v[Et] = -1 * v[Et], T[Et] = -1 * T[Et];
+              else if (Y > q) for (var mt = 0; mt < d.size; mt++) v[mt] = -1 * v[mt];
+              else if ($ > tt) for (var it = 0; it < d.size; it++) T[it] = -1 * T[it];
+            }, s = function(I) {
+              var Y = [], q = new i(), $ = /* @__PURE__ */ new Set(), tt = 0;
+              return I.forEach(function(Et, mt) {
+                if (!$.has(mt)) {
+                  Y[tt] = [];
+                  var it = mt;
+                  for (q.push(it), $.add(it), Y[tt].push(it); q.length != 0; ) it = q.shift(), I.get(it).forEach(function(ft) {
+                    $.has(ft.id) || (q.push(ft.id), $.add(ft.id), Y[tt].push(ft.id));
+                  });
+                  tt++;
+                }
+              }), Y;
+            }, E = function(I) {
+              var Y = /* @__PURE__ */ new Map();
+              return I.forEach(function(q, $) {
+                Y.set($, []);
+              }), I.forEach(function(q, $) {
+                q.forEach(function(tt) {
+                  Y.get($).push(tt), Y.get(tt.id).push({
+                    id: $,
+                    gap: tt.gap,
+                    direction: tt.direction
+                  });
+                });
+              }), Y;
+            }, u = function(I) {
+              var Y = /* @__PURE__ */ new Map();
+              return I.forEach(function(q, $) {
+                Y.set($, []);
+              }), I.forEach(function(q, $) {
+                q.forEach(function(tt) {
+                  Y.get(tt.id).push({
+                    id: $,
+                    gap: tt.gap,
+                    direction: tt.direction
+                  });
+                });
+              }), Y;
+            }, m = [], y = [], C = !1, w = !1, R = /* @__PURE__ */ new Set(), G = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), k = [];
+            if (h.fixedNodeConstraint && h.fixedNodeConstraint.forEach(function(I) {
+              R.add(I.nodeId);
+            }), h.relativePlacementConstraint && (h.relativePlacementConstraint.forEach(function(I) {
+              I.left ? (G.has(I.left) ? G.get(I.left).push({
+                id: I.right,
+                gap: I.gap,
+                direction: "horizontal"
+              }) : G.set(I.left, [{
+                id: I.right,
+                gap: I.gap,
+                direction: "horizontal"
+              }]), G.has(I.right) || G.set(I.right, [])) : (G.has(I.top) ? G.get(I.top).push({
+                id: I.bottom,
+                gap: I.gap,
+                direction: "vertical"
+              }) : G.set(I.top, [{
+                id: I.bottom,
+                gap: I.gap,
+                direction: "vertical"
+              }]), G.has(I.bottom) || G.set(I.bottom, []));
+            }), b = E(G), k = s(b)), l.TRANSFORM_ON_CONSTRAINT_HANDLING) {
+              if (h.fixedNodeConstraint && h.fixedNodeConstraint.length > 1) h.fixedNodeConstraint.forEach(function(I, Y) {
+                m[Y] = [I.position.x, I.position.y], y[Y] = [v[d.get(I.nodeId)], T[d.get(I.nodeId)]];
+              }), C = !0;
+              else if (h.alignmentConstraint) (function() {
+                var I = 0;
+                if (h.alignmentConstraint.vertical) {
+                  for (var Y = h.alignmentConstraint.vertical, q = function(it) {
+                    var ft = /* @__PURE__ */ new Set();
+                    Y[it].forEach(function(vt) {
+                      ft.add(vt);
+                    });
+                    var It = new Set([].concat(e(ft)).filter(function(vt) {
+                      return R.has(vt);
+                    })), wt = void 0;
+                    wt = It.size > 0 ? v[d.get(It.values().next().value)] : Z(ft).x, Y[it].forEach(function(vt) {
+                      m[I] = [wt, T[d.get(vt)]], y[I] = [v[d.get(vt)], T[d.get(vt)]], I++;
+                    });
+                  }, $ = 0; $ < Y.length; $++) q($);
+                  C = !0;
+                }
+                if (h.alignmentConstraint.horizontal) {
+                  for (var tt = h.alignmentConstraint.horizontal, Et = function(it) {
+                    var ft = /* @__PURE__ */ new Set();
+                    tt[it].forEach(function(vt) {
+                      ft.add(vt);
+                    });
+                    var It = new Set([].concat(e(ft)).filter(function(vt) {
+                      return R.has(vt);
+                    })), wt = void 0;
+                    wt = It.size > 0 ? v[d.get(It.values().next().value)] : Z(ft).y, tt[it].forEach(function(vt) {
+                      m[I] = [v[d.get(vt)], wt], y[I] = [v[d.get(vt)], T[d.get(vt)]], I++;
+                    });
+                  }, mt = 0; mt < tt.length; mt++) Et(mt);
+                  C = !0;
+                }
+                h.relativePlacementConstraint && (w = !0);
+              })();
+              else if (h.relativePlacementConstraint) {
+                for (var W = 0, J = 0, H = 0; H < k.length; H++) k[H].length > W && (W = k[H].length, J = H);
+                if (W < b.size / 2) K(h.relativePlacementConstraint), C = !1, w = !1;
+                else {
+                  var z = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), B = [];
+                  k[J].forEach(function(I) {
+                    G.get(I).forEach(function(Y) {
+                      Y.direction == "horizontal" ? (z.has(I) ? z.get(I).push(Y) : z.set(I, [Y]), z.has(Y.id) || z.set(Y.id, []), B.push({
+                        left: I,
+                        right: Y.id
+                      })) : (O.has(I) ? O.get(I).push(Y) : O.set(I, [Y]), O.has(Y.id) || O.set(Y.id, []), B.push({
+                        top: I,
+                        bottom: Y.id
+                      }));
+                    });
+                  }), K(B), w = !1;
+                  var et = x(z, "horizontal"), X = x(O, "vertical");
+                  k[J].forEach(function(I, Y) {
+                    y[Y] = [v[d.get(I)], T[d.get(I)]], m[Y] = [], et.has(I) ? m[Y][0] = et.get(I) : m[Y][0] = v[d.get(I)], X.has(I) ? m[Y][1] = X.get(I) : m[Y][1] = T[d.get(I)];
+                  }), C = !0;
+                }
+              }
+              if (C) {
+                for (var V = void 0, lt = p.transpose(m), at = p.transpose(y), Lt = 0; Lt < lt.length; Lt++) lt[Lt] = p.multGamma(lt[Lt]), at[Lt] = p.multGamma(at[Lt]);
+                var j = p.multMat(lt, p.transpose(at)), pt = a.svd(j);
+                V = p.multMat(pt.V, p.transpose(pt.U));
+                for (var yt = 0; yt < d.size; yt++) {
+                  var Bt = [v[yt], T[yt]], Yt = [V[0][0], V[1][0]], _t = [V[0][1], V[1][1]];
+                  v[yt] = p.dotProduct(Bt, Yt), T[yt] = p.dotProduct(Bt, _t);
+                }
+                w && K(h.relativePlacementConstraint);
+              }
+            }
+            if (l.ENFORCE_CONSTRAINTS) {
+              if (h.fixedNodeConstraint && h.fixedNodeConstraint.length > 0) {
+                var xt = {
+                  x: 0,
+                  y: 0
+                };
+                h.fixedNodeConstraint.forEach(function(I, Y) {
+                  var q = {
+                    x: v[d.get(I.nodeId)],
+                    y: T[d.get(I.nodeId)]
+                  }, $ = I.position, tt = U($, q);
+                  xt.x += tt.x, xt.y += tt.y;
+                }), xt.x /= h.fixedNodeConstraint.length, xt.y /= h.fixedNodeConstraint.length, v.forEach(function(I, Y) {
+                  v[Y] += xt.x;
+                }), T.forEach(function(I, Y) {
+                  T[Y] += xt.y;
+                }), h.fixedNodeConstraint.forEach(function(I) {
+                  v[d.get(I.nodeId)] = I.position.x, T[d.get(I.nodeId)] = I.position.y;
+                });
+              }
+              if (h.alignmentConstraint) {
+                if (h.alignmentConstraint.vertical) for (var kt = h.alignmentConstraint.vertical, Ut = function(I) {
+                  var Y = /* @__PURE__ */ new Set();
+                  kt[I].forEach(function(tt) {
+                    Y.add(tt);
+                  });
+                  var q = new Set([].concat(e(Y)).filter(function(tt) {
+                    return R.has(tt);
+                  })), $ = void 0;
+                  $ = q.size > 0 ? v[d.get(q.values().next().value)] : Z(Y).x, Y.forEach(function(tt) {
+                    R.has(tt) || (v[d.get(tt)] = $);
+                  });
+                }, Rt = 0; Rt < kt.length; Rt++) Ut(Rt);
+                if (h.alignmentConstraint.horizontal) for (var Vt = h.alignmentConstraint.horizontal, Gt = function(I) {
+                  var Y = /* @__PURE__ */ new Set();
+                  Vt[I].forEach(function(tt) {
+                    Y.add(tt);
+                  });
+                  var q = new Set([].concat(e(Y)).filter(function(tt) {
+                    return R.has(tt);
+                  })), $ = void 0;
+                  $ = q.size > 0 ? T[d.get(q.values().next().value)] : Z(Y).y, Y.forEach(function(tt) {
+                    R.has(tt) || (T[d.get(tt)] = $);
+                  });
+                }, st = 0; st < Vt.length; st++) Gt(st);
+              }
+              h.relativePlacementConstraint && (function() {
+                var I = /* @__PURE__ */ new Map(), Y = /* @__PURE__ */ new Map(), q = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new Map(), tt = /* @__PURE__ */ new Map(), Et = /* @__PURE__ */ new Map(), mt = /* @__PURE__ */ new Set(), it = /* @__PURE__ */ new Set();
+                if (R.forEach(function(nt) {
+                  mt.add(nt), it.add(nt);
+                }), h.alignmentConstraint) {
+                  if (h.alignmentConstraint.vertical) for (var ft = h.alignmentConstraint.vertical, It = function(nt) {
+                    q.set("dummy" + nt, []), ft[nt].forEach(function(Ct) {
+                      I.set(Ct, "dummy" + nt), q.get("dummy" + nt).push(Ct), R.has(Ct) && mt.add("dummy" + nt);
+                    }), tt.set("dummy" + nt, v[d.get(ft[nt][0])]);
+                  }, wt = 0; wt < ft.length; wt++) It(wt);
+                  if (h.alignmentConstraint.horizontal) for (var vt = h.alignmentConstraint.horizontal, ht = function(nt) {
+                    $.set("dummy" + nt, []), vt[nt].forEach(function(Ct) {
+                      Y.set(Ct, "dummy" + nt), $.get("dummy" + nt).push(Ct), R.has(Ct) && it.add("dummy" + nt);
+                    }), Et.set("dummy" + nt, T[d.get(vt[nt][0])]);
+                  }, dt = 0; dt < vt.length; dt++) ht(dt);
+                }
+                var Q = /* @__PURE__ */ new Map(), ut = /* @__PURE__ */ new Map(), At = function(nt) {
+                  G.get(nt).forEach(function(Ct) {
+                    var Ht = void 0, zt = void 0;
+                    Ct.direction == "horizontal" ? (Ht = I.get(nt) ? I.get(nt) : nt, zt = I.get(Ct.id) ? {
+                      id: I.get(Ct.id),
+                      gap: Ct.gap,
+                      direction: Ct.direction
+                    } : Ct, Q.has(Ht) ? Q.get(Ht).push(zt) : Q.set(Ht, [zt]), Q.has(zt.id) || Q.set(zt.id, [])) : (Ht = Y.get(nt) ? Y.get(nt) : nt, zt = Y.get(Ct.id) ? {
+                      id: Y.get(Ct.id),
+                      gap: Ct.gap,
+                      direction: Ct.direction
+                    } : Ct, ut.has(Ht) ? ut.get(Ht).push(zt) : ut.set(Ht, [zt]), ut.has(zt.id) || ut.set(zt.id, []));
+                  });
+                }, rt = !0, bt = !1, Ot = void 0;
+                try {
+                  for (var Dt = G.keys()[Symbol.iterator](), Ft; !(rt = (Ft = Dt.next()).done); rt = !0) {
+                    var Tt = Ft.value;
+                    At(Tt);
+                  }
+                } catch (nt) {
+                  bt = !0, Ot = nt;
+                } finally {
+                  try {
+                    !rt && Dt.return && Dt.return();
+                  } finally {
+                    if (bt) throw Ot;
+                  }
+                }
+                var Nt = E(Q), Mt = E(ut), Pt = s(Nt), Xt = s(Mt), ne = u(Q), ee = u(ut), qt = [], Zt = [];
+                Pt.forEach(function(nt, Ct) {
+                  qt[Ct] = [], nt.forEach(function(Ht) {
+                    ne.get(Ht).length == 0 && qt[Ct].push(Ht);
+                  });
+                }), Xt.forEach(function(nt, Ct) {
+                  Zt[Ct] = [], nt.forEach(function(Ht) {
+                    ee.get(Ht).length == 0 && Zt[Ct].push(Ht);
+                  });
+                });
+                var jt = x(Q, "horizontal", mt, tt, qt), Kt = x(ut, "vertical", it, Et, Zt), re = function(nt) {
+                  q.get(nt) ? q.get(nt).forEach(function(Ct) {
+                    v[d.get(Ct)] = jt.get(nt);
+                  }) : v[d.get(nt)] = jt.get(nt);
+                }, $t = !0, ve = !1, ye = void 0;
+                try {
+                  for (var ae = jt.keys()[Symbol.iterator](), me; !($t = (me = ae.next()).done); $t = !0) {
+                    var se = me.value;
+                    re(se);
+                  }
+                } catch (nt) {
+                  ve = !0, ye = nt;
+                } finally {
+                  try {
+                    !$t && ae.return && ae.return();
+                  } finally {
+                    if (ve) throw ye;
+                  }
+                }
+                var He = function(nt) {
+                  $.get(nt) ? $.get(nt).forEach(function(Ct) {
+                    T[d.get(Ct)] = Kt.get(nt);
+                  }) : T[d.get(nt)] = Kt.get(nt);
+                }, he = !0, Ee = !1, Te = void 0;
+                try {
+                  for (var le = Kt.keys()[Symbol.iterator](), Ne; !(he = (Ne = le.next()).done); he = !0) {
+                    var se = Ne.value;
+                    He(se);
+                  }
+                } catch (nt) {
+                  Ee = !0, Te = nt;
+                } finally {
+                  try {
+                    !he && le.return && le.return();
+                  } finally {
+                    if (Ee) throw Te;
+                  }
+                }
+              })();
+            }
+            for (var ot = 0; ot < L.length; ot++) {
+              var ct = L[ot];
+              ct.getChild() ?? ct.setCenter(v[d.get(ct.id)], T[d.get(ct.id)]);
+            }
+          }, o.exports = n;
+        }),
+        551: ((o) => {
+          o.exports = A;
+        })
+      }, N = {};
+      function f(o) {
+        var r = N[o];
+        if (r !== void 0) return r.exports;
+        var t = N[o] = { exports: {} };
+        return D[o](t, t.exports, f), t.exports;
+      }
+      return f(45);
+    })();
+  });
+})), si = /* @__PURE__ */ ii((/* @__PURE__ */ fe(((M, _) => {
+  (function(A, D) {
+    typeof M == "object" && typeof _ == "object" ? _.exports = D(Ce()) : typeof define == "function" && define.amd ? define(["cose-base"], D) : typeof M == "object" ? M.cytoscapeFcose = D(Ce()) : A.cytoscapeFcose = D(A.coseBase);
+  })(M, function(A) {
+    return (() => {
+      var D = {
+        658: ((o) => {
+          o.exports = Object.assign == null ? function(r) {
+            return [...arguments].slice(1).forEach(function(t) {
+              Object.keys(t).forEach(function(e) {
+                return r[e] = t[e];
+              });
+            }), r;
+          } : Object.assign.bind(Object);
+        }),
+        548: ((o, r, t) => {
+          var e = /* @__PURE__ */ (function() {
+            function p(a, n) {
+              var g = [], h = !0, c = !1, d = void 0;
+              try {
+                for (var v = a[Symbol.iterator](), T; !(h = (T = v.next()).done) && (g.push(T.value), !(n && g.length === n)); h = !0) ;
+              } catch (L) {
+                c = !0, d = L;
+              } finally {
+                try {
+                  !h && v.return && v.return();
+                } finally {
+                  if (c) throw d;
+                }
+              }
+              return g;
+            }
+            return function(a, n) {
+              if (Array.isArray(a)) return a;
+              if (Symbol.iterator in Object(a)) return p(a, n);
+              throw TypeError("Invalid attempt to destructure non-iterable instance");
+            };
+          })(), l = t(140).layoutBase.LinkedList, i = {};
+          i.getTopMostNodes = function(p) {
+            for (var a = {}, n = 0; n < p.length; n++) a[p[n].id()] = !0;
+            return p.filter(function(g, h) {
+              typeof g == "number" && (g = h);
+              for (var c = g.parent()[0]; c != null; ) {
+                if (a[c.id()]) return !1;
+                c = c.parent()[0];
+              }
+              return !0;
+            });
+          }, i.connectComponents = function(p, a, n, g) {
+            var h = new l(), c = /* @__PURE__ */ new Set(), d = [], v = void 0, T = void 0, L = void 0, F = !1, S = 1, P = [], U = [], Z = function() {
+              var x = p.collection();
+              U.push(x);
+              var K = n[0], s = p.collection();
+              s.merge(K).merge(K.descendants().intersection(a)), d.push(K), s.forEach(function(m) {
+                h.push(m), c.add(m), x.merge(m);
+              });
+              for (var E = function() {
+                K = h.shift();
+                var m = p.collection();
+                K.neighborhood().nodes().forEach(function(w) {
+                  a.intersection(K.edgesWith(w)).length > 0 && m.merge(w);
+                });
+                for (var y = 0; y < m.length; y++) {
+                  var C = m[y];
+                  v = n.intersection(C.union(C.ancestors())), v != null && !c.has(v[0]) && v.union(v.descendants()).forEach(function(w) {
+                    h.push(w), c.add(w), x.merge(w), n.has(w) && d.push(w);
+                  });
+                }
+              }; h.length != 0; ) E();
+              if (x.forEach(function(m) {
+                a.intersection(m.connectedEdges()).forEach(function(y) {
+                  x.has(y.source()) && x.has(y.target()) && x.merge(y);
+                });
+              }), d.length == n.length && (F = !0), !F || F && S > 1) {
+                T = d[0], L = T.connectedEdges().length, d.forEach(function(m) {
+                  m.connectedEdges().length < L && (L = m.connectedEdges().length, T = m);
+                }), P.push(T.id());
+                var u = p.collection();
+                u.merge(d[0]), d.forEach(function(m) {
+                  u.merge(m);
+                }), d = [], n = n.difference(u), S++;
+              }
+            };
+            do
+              Z();
+            while (!F);
+            return g && P.length > 0 && g.set("dummy" + (g.size + 1), P), U;
+          }, i.relocateComponent = function(p, a, n) {
+            if (!n.fixedNodeConstraint) {
+              var g = 1 / 0, h = -1 / 0, c = 1 / 0, d = -1 / 0;
+              if (n.quality == "draft") {
+                var v = !0, T = !1, L = void 0;
+                try {
+                  for (var F = a.nodeIndexes[Symbol.iterator](), S; !(v = (S = F.next()).done); v = !0) {
+                    var P = S.value, U = e(P, 2), Z = U[0], x = U[1], K = n.cy.getElementById(Z);
+                    if (K) {
+                      var s = K.boundingBox(), E = a.xCoords[x] - s.w / 2, u = a.xCoords[x] + s.w / 2, m = a.yCoords[x] - s.h / 2, y = a.yCoords[x] + s.h / 2;
+                      E < g && (g = E), u > h && (h = u), m < c && (c = m), y > d && (d = y);
+                    }
+                  }
+                } catch (b) {
+                  T = !0, L = b;
+                } finally {
+                  try {
+                    !v && F.return && F.return();
+                  } finally {
+                    if (T) throw L;
+                  }
+                }
+                var C = p.x - (h + g) / 2, w = p.y - (d + c) / 2;
+                a.xCoords = a.xCoords.map(function(b) {
+                  return b + C;
+                }), a.yCoords = a.yCoords.map(function(b) {
+                  return b + w;
+                });
+              } else {
+                Object.keys(a).forEach(function(b) {
+                  var k = a[b], W = k.getRect().x, J = k.getRect().x + k.getRect().width, H = k.getRect().y, z = k.getRect().y + k.getRect().height;
+                  W < g && (g = W), J > h && (h = J), H < c && (c = H), z > d && (d = z);
+                });
+                var R = p.x - (h + g) / 2, G = p.y - (d + c) / 2;
+                Object.keys(a).forEach(function(b) {
+                  var k = a[b];
+                  k.setCenter(k.getCenterX() + R, k.getCenterY() + G);
+                });
+              }
+            }
+          }, i.calcBoundingBox = function(p, a, n, g) {
+            for (var h = 9007199254740991, c = -9007199254740991, d = 9007199254740991, v = -9007199254740991, T = void 0, L = void 0, F = void 0, S = void 0, P = p.descendants().not(":parent"), U = P.length, Z = 0; Z < U; Z++) {
+              var x = P[Z];
+              T = a[g.get(x.id())] - x.width() / 2, L = a[g.get(x.id())] + x.width() / 2, F = n[g.get(x.id())] - x.height() / 2, S = n[g.get(x.id())] + x.height() / 2, h > T && (h = T), c < L && (c = L), d > F && (d = F), v < S && (v = S);
+            }
+            var K = {};
+            return K.topLeftX = h, K.topLeftY = d, K.width = c - h, K.height = v - d, K;
+          }, i.calcParentsWithoutChildren = function(p, a) {
+            var n = p.collection();
+            return a.nodes(":parent").forEach(function(g) {
+              var h = !1;
+              g.children().forEach(function(c) {
+                c.css("display") != "none" && (h = !0);
+              }), h || n.merge(g);
+            }), n;
+          }, o.exports = i;
+        }),
+        816: ((o, r, t) => {
+          var e = t(548), l = t(140).CoSELayout, i = t(140).CoSENode, p = t(140).layoutBase.PointD, a = t(140).layoutBase.DimensionD, n = t(140).layoutBase.LayoutConstants, g = t(140).layoutBase.FDLayoutConstants, h = t(140).CoSEConstants;
+          o.exports = { coseLayout: function(c, d) {
+            var v = c.cy, T = c.eles, L = T.nodes(), F = T.edges(), S = void 0, P = void 0, U = void 0, Z = {};
+            c.randomize && (S = d.nodeIndexes, P = d.xCoords, U = d.yCoords);
+            var x = function(w) {
+              return typeof w == "function";
+            }, K = function(w, R) {
+              return x(w) ? w(R) : w;
+            }, s = e.calcParentsWithoutChildren(v, T), E = function w(R, G, b, k) {
+              for (var W = G.length, J = 0; J < W; J++) {
+                var H = G[J], z = null;
+                H.intersection(s).length == 0 && (z = H.children());
+                var O = void 0, B = H.layoutDimensions({ nodeDimensionsIncludeLabels: k.nodeDimensionsIncludeLabels });
+                if (H.outerWidth() != null && H.outerHeight() != null) if (k.randomize) if (!H.isParent()) O = R.add(new i(b.graphManager, new p(P[S.get(H.id())] - B.w / 2, U[S.get(H.id())] - B.h / 2), new a(parseFloat(B.w), parseFloat(B.h))));
+                else {
+                  var et = e.calcBoundingBox(H, P, U, S);
+                  O = H.intersection(s).length == 0 ? R.add(new i(b.graphManager, new p(et.topLeftX, et.topLeftY), new a(et.width, et.height))) : R.add(new i(b.graphManager, new p(et.topLeftX, et.topLeftY), new a(parseFloat(B.w), parseFloat(B.h))));
+                }
+                else O = R.add(new i(b.graphManager, new p(H.position("x") - B.w / 2, H.position("y") - B.h / 2), new a(parseFloat(B.w), parseFloat(B.h))));
+                else O = R.add(new i(this.graphManager));
+                if (O.id = H.data("id"), O.nodeRepulsion = K(k.nodeRepulsion, H), O.paddingLeft = parseInt(H.css("padding")), O.paddingTop = parseInt(H.css("padding")), O.paddingRight = parseInt(H.css("padding")), O.paddingBottom = parseInt(H.css("padding")), k.nodeDimensionsIncludeLabels && (O.labelWidth = H.boundingBox({
+                  includeLabels: !0,
+                  includeNodes: !1,
+                  includeOverlays: !1
+                }).w, O.labelHeight = H.boundingBox({
+                  includeLabels: !0,
+                  includeNodes: !1,
+                  includeOverlays: !1
+                }).h, O.labelPosVertical = H.css("text-valign"), O.labelPosHorizontal = H.css("text-halign")), Z[H.data("id")] = O, isNaN(O.rect.x) && (O.rect.x = 0), isNaN(O.rect.y) && (O.rect.y = 0), z != null && z.length > 0) {
+                  var X = void 0;
+                  X = b.getGraphManager().add(b.newGraph(), O), w(X, z, b, k);
+                }
+              }
+            }, u = function(w, R, G) {
+              for (var b = 0, k = 0, W = 0; W < G.length; W++) {
+                var J = G[W], H = Z[J.data("source")], z = Z[J.data("target")];
+                if (H && z && H !== z && H.getEdgesBetween(z).length == 0) {
+                  var O = R.add(w.newEdge(), H, z);
+                  O.id = J.id(), O.idealLength = K(c.idealEdgeLength, J), O.edgeElasticity = K(c.edgeElasticity, J), b += O.idealLength, k++;
+                }
+              }
+              c.idealEdgeLength != null && (k > 0 ? h.DEFAULT_EDGE_LENGTH = g.DEFAULT_EDGE_LENGTH = b / k : x(c.idealEdgeLength) ? h.DEFAULT_EDGE_LENGTH = g.DEFAULT_EDGE_LENGTH = 50 : h.DEFAULT_EDGE_LENGTH = g.DEFAULT_EDGE_LENGTH = c.idealEdgeLength, h.MIN_REPULSION_DIST = g.MIN_REPULSION_DIST = g.DEFAULT_EDGE_LENGTH / 10, h.DEFAULT_RADIAL_SEPARATION = g.DEFAULT_EDGE_LENGTH);
+            }, m = function(w, R) {
+              R.fixedNodeConstraint && (w.constraints.fixedNodeConstraint = R.fixedNodeConstraint), R.alignmentConstraint && (w.constraints.alignmentConstraint = R.alignmentConstraint), R.relativePlacementConstraint && (w.constraints.relativePlacementConstraint = R.relativePlacementConstraint);
+            };
+            c.nestingFactor != null && (h.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = g.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = c.nestingFactor), c.gravity != null && (h.DEFAULT_GRAVITY_STRENGTH = g.DEFAULT_GRAVITY_STRENGTH = c.gravity), c.numIter != null && (h.MAX_ITERATIONS = g.MAX_ITERATIONS = c.numIter), c.gravityRange != null && (h.DEFAULT_GRAVITY_RANGE_FACTOR = g.DEFAULT_GRAVITY_RANGE_FACTOR = c.gravityRange), c.gravityCompound != null && (h.DEFAULT_COMPOUND_GRAVITY_STRENGTH = g.DEFAULT_COMPOUND_GRAVITY_STRENGTH = c.gravityCompound), c.gravityRangeCompound != null && (h.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = g.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = c.gravityRangeCompound), c.initialEnergyOnIncremental != null && (h.DEFAULT_COOLING_FACTOR_INCREMENTAL = g.DEFAULT_COOLING_FACTOR_INCREMENTAL = c.initialEnergyOnIncremental), c.tilingCompareBy != null && (h.TILING_COMPARE_BY = c.tilingCompareBy), c.quality == "proof" ? n.QUALITY = 2 : n.QUALITY = 0, h.NODE_DIMENSIONS_INCLUDE_LABELS = g.NODE_DIMENSIONS_INCLUDE_LABELS = n.NODE_DIMENSIONS_INCLUDE_LABELS = c.nodeDimensionsIncludeLabels, h.DEFAULT_INCREMENTAL = g.DEFAULT_INCREMENTAL = n.DEFAULT_INCREMENTAL = !c.randomize, h.ANIMATE = g.ANIMATE = n.ANIMATE = c.animate, h.TILE = c.tile, h.TILING_PADDING_VERTICAL = typeof c.tilingPaddingVertical == "function" ? c.tilingPaddingVertical.call() : c.tilingPaddingVertical, h.TILING_PADDING_HORIZONTAL = typeof c.tilingPaddingHorizontal == "function" ? c.tilingPaddingHorizontal.call() : c.tilingPaddingHorizontal, h.DEFAULT_INCREMENTAL = g.DEFAULT_INCREMENTAL = n.DEFAULT_INCREMENTAL = !0, h.PURE_INCREMENTAL = !c.randomize, n.DEFAULT_UNIFORM_LEAF_NODE_SIZES = c.uniformNodeDimensions, c.step == "transformed" && (h.TRANSFORM_ON_CONSTRAINT_HANDLING = !0, h.ENFORCE_CONSTRAINTS = !1, h.APPLY_LAYOUT = !1), c.step == "enforced" && (h.TRANSFORM_ON_CONSTRAINT_HANDLING = !1, h.ENFORCE_CONSTRAINTS = !0, h.APPLY_LAYOUT = !1), c.step == "cose" && (h.TRANSFORM_ON_CONSTRAINT_HANDLING = !1, h.ENFORCE_CONSTRAINTS = !1, h.APPLY_LAYOUT = !0), c.step == "all" && (c.randomize ? h.TRANSFORM_ON_CONSTRAINT_HANDLING = !0 : h.TRANSFORM_ON_CONSTRAINT_HANDLING = !1, h.ENFORCE_CONSTRAINTS = !0, h.APPLY_LAYOUT = !0), c.fixedNodeConstraint || c.alignmentConstraint || c.relativePlacementConstraint ? h.TREE_REDUCTION_ON_INCREMENTAL = !1 : h.TREE_REDUCTION_ON_INCREMENTAL = !0;
+            var y = new l(), C = y.newGraphManager();
+            return E(C.addRoot(), e.getTopMostNodes(L), y, c), u(y, C, F), m(y, c), y.runLayout(), Z;
+          } };
+        }),
+        212: ((o, r, t) => {
+          var e = /* @__PURE__ */ (function() {
+            function h(c, d) {
+              for (var v = 0; v < d.length; v++) {
+                var T = d[v];
+                T.enumerable = T.enumerable || !1, T.configurable = !0, "value" in T && (T.writable = !0), Object.defineProperty(c, T.key, T);
+              }
+            }
+            return function(c, d, v) {
+              return d && h(c.prototype, d), v && h(c, v), c;
+            };
+          })();
+          function l(h, c) {
+            if (!(h instanceof c)) throw TypeError("Cannot call a class as a function");
+          }
+          var i = t(658), p = t(548), a = t(657).spectralLayout, n = t(816).coseLayout, g = Object.freeze({
+            quality: "default",
+            randomize: !0,
+            animate: !0,
+            animationDuration: 1e3,
+            animationEasing: void 0,
+            fit: !0,
+            padding: 30,
+            nodeDimensionsIncludeLabels: !1,
+            uniformNodeDimensions: !1,
+            packComponents: !0,
+            step: "all",
+            samplingType: !0,
+            sampleSize: 25,
+            nodeSeparation: 75,
+            piTol: 1e-7,
+            nodeRepulsion: function(h) {
+              return 4500;
+            },
+            idealEdgeLength: function(h) {
+              return 50;
+            },
+            edgeElasticity: function(h) {
+              return 0.45;
+            },
+            nestingFactor: 0.1,
+            gravity: 0.25,
+            numIter: 2500,
+            tile: !0,
+            tilingCompareBy: void 0,
+            tilingPaddingVertical: 10,
+            tilingPaddingHorizontal: 10,
+            gravityRangeCompound: 1.5,
+            gravityCompound: 1,
+            gravityRange: 3.8,
+            initialEnergyOnIncremental: 0.3,
+            fixedNodeConstraint: void 0,
+            alignmentConstraint: void 0,
+            relativePlacementConstraint: void 0,
+            ready: function() {
+            },
+            stop: function() {
+            }
+          });
+          o.exports = (function() {
+            function h(c) {
+              l(this, h), this.options = i({}, g, c);
+            }
+            return e(h, [{
+              key: "run",
+              value: function() {
+                var c = this, d = this.options, v = d.cy, T = d.eles, L = [], F = [], S = void 0, P = [];
+                d.fixedNodeConstraint && (!Array.isArray(d.fixedNodeConstraint) || d.fixedNodeConstraint.length == 0) && (d.fixedNodeConstraint = void 0), d.alignmentConstraint && (d.alignmentConstraint.vertical && (!Array.isArray(d.alignmentConstraint.vertical) || d.alignmentConstraint.vertical.length == 0) && (d.alignmentConstraint.vertical = void 0), d.alignmentConstraint.horizontal && (!Array.isArray(d.alignmentConstraint.horizontal) || d.alignmentConstraint.horizontal.length == 0) && (d.alignmentConstraint.horizontal = void 0)), d.relativePlacementConstraint && (!Array.isArray(d.relativePlacementConstraint) || d.relativePlacementConstraint.length == 0) && (d.relativePlacementConstraint = void 0), (d.fixedNodeConstraint || d.alignmentConstraint || d.relativePlacementConstraint) && (d.tile = !1, d.packComponents = !1);
+                var U = void 0, Z = !1;
+                if (v.layoutUtilities && d.packComponents && (U = v.layoutUtilities("get"), U ||= v.layoutUtilities(), Z = !0), T.nodes().length > 0) if (Z) {
+                  var x = p.getTopMostNodes(d.eles.nodes());
+                  if (S = p.connectComponents(v, d.eles, x), S.forEach(function(X) {
+                    var V = X.boundingBox();
+                    P.push({
+                      x: V.x1 + V.w / 2,
+                      y: V.y1 + V.h / 2
+                    });
+                  }), d.randomize && S.forEach(function(X) {
+                    d.eles = X, L.push(a(d));
+                  }), d.quality == "default" || d.quality == "proof") {
+                    var K = v.collection();
+                    if (d.tile) {
+                      var s = /* @__PURE__ */ new Map(), E = [], u = [], m = 0, y = {
+                        nodeIndexes: s,
+                        xCoords: E,
+                        yCoords: u
+                      }, C = [];
+                      if (S.forEach(function(X, V) {
+                        X.edges().length == 0 && (X.nodes().forEach(function(lt, at) {
+                          K.merge(X.nodes()[at]), lt.isParent() || (y.nodeIndexes.set(X.nodes()[at].id(), m++), y.xCoords.push(X.nodes()[0].position().x), y.yCoords.push(X.nodes()[0].position().y));
+                        }), C.push(V));
+                      }), K.length > 1) {
+                        var w = K.boundingBox();
+                        P.push({
+                          x: w.x1 + w.w / 2,
+                          y: w.y1 + w.h / 2
+                        }), S.push(K), L.push(y);
+                        for (var R = C.length - 1; R >= 0; R--) S.splice(C[R], 1), L.splice(C[R], 1), P.splice(C[R], 1);
+                      }
+                    }
+                    S.forEach(function(X, V) {
+                      d.eles = X, F.push(n(d, L[V])), p.relocateComponent(P[V], F[V], d);
+                    });
+                  } else S.forEach(function(X, V) {
+                    p.relocateComponent(P[V], L[V], d);
+                  });
+                  var G = /* @__PURE__ */ new Set();
+                  if (S.length > 1) {
+                    var b = [], k = T.filter(function(X) {
+                      return X.css("display") == "none";
+                    });
+                    S.forEach(function(X, V) {
+                      var lt = void 0;
+                      if (d.quality == "draft" && (lt = L[V].nodeIndexes), X.nodes().not(k).length > 0) {
+                        var at = {};
+                        at.edges = [], at.nodes = [];
+                        var Lt = void 0;
+                        X.nodes().not(k).forEach(function(j) {
+                          if (d.quality == "draft") if (!j.isParent()) Lt = lt.get(j.id()), at.nodes.push({
+                            x: L[V].xCoords[Lt] - j.boundingbox().w / 2,
+                            y: L[V].yCoords[Lt] - j.boundingbox().h / 2,
+                            width: j.boundingbox().w,
+                            height: j.boundingbox().h
+                          });
+                          else {
+                            var pt = p.calcBoundingBox(j, L[V].xCoords, L[V].yCoords, lt);
+                            at.nodes.push({
+                              x: pt.topLeftX,
+                              y: pt.topLeftY,
+                              width: pt.width,
+                              height: pt.height
+                            });
+                          }
+                          else F[V][j.id()] && at.nodes.push({
+                            x: F[V][j.id()].getLeft(),
+                            y: F[V][j.id()].getTop(),
+                            width: F[V][j.id()].getWidth(),
+                            height: F[V][j.id()].getHeight()
+                          });
+                        }), X.edges().forEach(function(j) {
+                          var pt = j.source(), yt = j.target();
+                          if (pt.css("display") != "none" && yt.css("display") != "none") if (d.quality == "draft") {
+                            var Bt = lt.get(pt.id()), Yt = lt.get(yt.id()), _t = [], xt = [];
+                            if (pt.isParent()) {
+                              var kt = p.calcBoundingBox(pt, L[V].xCoords, L[V].yCoords, lt);
+                              _t.push(kt.topLeftX + kt.width / 2), _t.push(kt.topLeftY + kt.height / 2);
+                            } else _t.push(L[V].xCoords[Bt]), _t.push(L[V].yCoords[Bt]);
+                            if (yt.isParent()) {
+                              var Ut = p.calcBoundingBox(yt, L[V].xCoords, L[V].yCoords, lt);
+                              xt.push(Ut.topLeftX + Ut.width / 2), xt.push(Ut.topLeftY + Ut.height / 2);
+                            } else xt.push(L[V].xCoords[Yt]), xt.push(L[V].yCoords[Yt]);
+                            at.edges.push({
+                              startX: _t[0],
+                              startY: _t[1],
+                              endX: xt[0],
+                              endY: xt[1]
+                            });
+                          } else F[V][pt.id()] && F[V][yt.id()] && at.edges.push({
+                            startX: F[V][pt.id()].getCenterX(),
+                            startY: F[V][pt.id()].getCenterY(),
+                            endX: F[V][yt.id()].getCenterX(),
+                            endY: F[V][yt.id()].getCenterY()
+                          });
+                        }), at.nodes.length > 0 && (b.push(at), G.add(V));
+                      }
+                    });
+                    var W = U.packComponents(b, d.randomize).shifts;
+                    if (d.quality == "draft") L.forEach(function(X, V) {
+                      var lt = X.xCoords.map(function(Lt) {
+                        return Lt + W[V].dx;
+                      }), at = X.yCoords.map(function(Lt) {
+                        return Lt + W[V].dy;
+                      });
+                      X.xCoords = lt, X.yCoords = at;
+                    });
+                    else {
+                      var J = 0;
+                      G.forEach(function(X) {
+                        Object.keys(F[X]).forEach(function(V) {
+                          var lt = F[X][V];
+                          lt.setCenter(lt.getCenterX() + W[J].dx, lt.getCenterY() + W[J].dy);
+                        }), J++;
+                      });
+                    }
+                  }
+                } else {
+                  var H = d.eles.boundingBox();
+                  if (P.push({
+                    x: H.x1 + H.w / 2,
+                    y: H.y1 + H.h / 2
+                  }), d.randomize) {
+                    var z = a(d);
+                    L.push(z);
+                  }
+                  d.quality == "default" || d.quality == "proof" ? (F.push(n(d, L[0])), p.relocateComponent(P[0], F[0], d)) : p.relocateComponent(P[0], L[0], d);
+                }
+                var O = function(X, V) {
+                  if (d.quality == "default" || d.quality == "proof") {
+                    typeof X == "number" && (X = V);
+                    var lt = void 0, at = void 0, Lt = X.data("id");
+                    return F.forEach(function(pt) {
+                      Lt in pt && (lt = {
+                        x: pt[Lt].getRect().getCenterX(),
+                        y: pt[Lt].getRect().getCenterY()
+                      }, at = pt[Lt]);
+                    }), d.nodeDimensionsIncludeLabels && (at.labelWidth && (at.labelPosHorizontal == "left" ? lt.x += at.labelWidth / 2 : at.labelPosHorizontal == "right" && (lt.x -= at.labelWidth / 2)), at.labelHeight && (at.labelPosVertical == "top" ? lt.y += at.labelHeight / 2 : at.labelPosVertical == "bottom" && (lt.y -= at.labelHeight / 2))), lt ??= {
+                      x: X.position("x"),
+                      y: X.position("y")
+                    }, {
+                      x: lt.x,
+                      y: lt.y
+                    };
+                  } else {
+                    var j = void 0;
+                    return L.forEach(function(pt) {
+                      var yt = pt.nodeIndexes.get(X.id());
+                      yt != null && (j = {
+                        x: pt.xCoords[yt],
+                        y: pt.yCoords[yt]
+                      });
+                    }), j ??= {
+                      x: X.position("x"),
+                      y: X.position("y")
+                    }, {
+                      x: j.x,
+                      y: j.y
+                    };
+                  }
+                };
+                if (d.quality == "default" || d.quality == "proof" || d.randomize) {
+                  var B = p.calcParentsWithoutChildren(v, T), et = T.filter(function(X) {
+                    return X.css("display") == "none";
+                  });
+                  d.eles = T.not(et), T.nodes().not(":parent").not(et).layoutPositions(c, d, O), B.length > 0 && B.forEach(function(X) {
+                    X.position(O(X));
+                  });
+                } else console.log("If randomize option is set to false, then quality option must be 'default' or 'proof'.");
+              }
+            }]), h;
+          })();
+        }),
+        657: ((o, r, t) => {
+          var e = t(548), l = t(140).layoutBase.Matrix, i = t(140).layoutBase.SVD;
+          o.exports = { spectralLayout: function(p) {
+            var a = p.cy, n = p.eles, g = n.nodes(), h = n.nodes(":parent"), c = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), T = [], L = [], F = [], S = [], P = [], U = [], Z = [], x = [], K = void 0, s = 1e8, E = 1e-9, u = p.piTol, m = p.samplingType, y = p.nodeSeparation, C = void 0, w = function() {
+              for (var st = 0, ot = 0, ct = !1; ot < C; ) {
+                st = Math.floor(Math.random() * K), ct = !1;
+                for (var I = 0; I < ot; I++) if (S[I] == st) {
+                  ct = !0;
+                  break;
+                }
+                if (!ct) S[ot] = st, ot++;
+                else continue;
+              }
+            }, R = function(st, ot, ct) {
+              for (var I = [], Y = 0, q = 0, $ = 0, tt = void 0, Et = [], mt = 0, it = 1, ft = 0; ft < K; ft++) Et[ft] = s;
+              for (I[q] = st, Et[st] = 0; q >= Y; ) {
+                $ = I[Y++];
+                for (var It = T[$], wt = 0; wt < It.length; wt++) tt = d.get(It[wt]), Et[tt] == s && (Et[tt] = Et[$] + 1, I[++q] = tt);
+                U[$][ot] = Et[$] * y;
+              }
+              if (ct) {
+                for (var vt = 0; vt < K; vt++) U[vt][ot] < P[vt] && (P[vt] = U[vt][ot]);
+                for (var ht = 0; ht < K; ht++) P[ht] > mt && (mt = P[ht], it = ht);
+              }
+              return it;
+            }, G = function(st) {
+              var ot = void 0;
+              if (st) {
+                ot = Math.floor(Math.random() * K);
+                for (var ct = 0; ct < K; ct++) P[ct] = s;
+                for (var I = 0; I < C; I++) S[I] = ot, ot = R(ot, I, st);
+              } else {
+                w();
+                for (var Y = 0; Y < C; Y++) R(S[Y], Y, st);
+              }
+              for (var q = 0; q < K; q++) for (var $ = 0; $ < C; $++) U[q][$] *= U[q][$];
+              for (var tt = 0; tt < C; tt++) Z[tt] = [];
+              for (var Et = 0; Et < C; Et++) for (var mt = 0; mt < C; mt++) Z[Et][mt] = U[S[mt]][Et];
+            }, b = function() {
+              for (var st = i.svd(Z), ot = st.S, ct = st.U, I = st.V, Y = ot[0] * ot[0] * ot[0], q = [], $ = 0; $ < C; $++) {
+                q[$] = [];
+                for (var tt = 0; tt < C; tt++) q[$][tt] = 0, $ == tt && (q[$][tt] = ot[$] / (ot[$] * ot[$] + Y / (ot[$] * ot[$])));
+              }
+              x = l.multMat(l.multMat(I, q), l.transpose(ct));
+            }, k = function() {
+              for (var st = void 0, ot = void 0, ct = [], I = [], Y = [], q = [], $ = 0; $ < K; $++) ct[$] = Math.random(), I[$] = Math.random();
+              ct = l.normalize(ct), I = l.normalize(I);
+              for (var tt = 0, Et = E, mt = E, it = void 0; ; ) {
+                tt++;
+                for (var ft = 0; ft < K; ft++) Y[ft] = ct[ft];
+                if (ct = l.multGamma(l.multL(l.multGamma(Y), U, x)), st = l.dotProduct(Y, ct), ct = l.normalize(ct), Et = l.dotProduct(Y, ct), it = Math.abs(Et / mt), it <= 1 + u && it >= 1) break;
+                mt = Et;
+              }
+              for (var It = 0; It < K; It++) Y[It] = ct[It];
+              for (tt = 0, mt = E; ; ) {
+                tt++;
+                for (var wt = 0; wt < K; wt++) q[wt] = I[wt];
+                if (q = l.minusOp(q, l.multCons(Y, l.dotProduct(Y, q))), I = l.multGamma(l.multL(l.multGamma(q), U, x)), ot = l.dotProduct(q, I), I = l.normalize(I), Et = l.dotProduct(q, I), it = Math.abs(Et / mt), it <= 1 + u && it >= 1) break;
+                mt = Et;
+              }
+              for (var vt = 0; vt < K; vt++) q[vt] = I[vt];
+              L = l.multCons(Y, Math.sqrt(Math.abs(st))), F = l.multCons(q, Math.sqrt(Math.abs(ot)));
+            };
+            e.connectComponents(a, n, e.getTopMostNodes(g), c), h.forEach(function(st) {
+              e.connectComponents(a, n, e.getTopMostNodes(st.descendants().intersection(n)), c);
+            });
+            for (var W = 0, J = 0; J < g.length; J++) g[J].isParent() || d.set(g[J].id(), W++);
+            var H = !0, z = !1, O = void 0;
+            try {
+              for (var B = c.keys()[Symbol.iterator](), et; !(H = (et = B.next()).done); H = !0) {
+                var X = et.value;
+                d.set(X, W++);
+              }
+            } catch (st) {
+              z = !0, O = st;
+            } finally {
+              try {
+                !H && B.return && B.return();
+              } finally {
+                if (z) throw O;
+              }
+            }
+            for (var V = 0; V < d.size; V++) T[V] = [];
+            h.forEach(function(st) {
+              for (var ot = st.children().intersection(n); ot.nodes(":childless").length == 0; ) ot = ot.nodes()[0].children().intersection(n);
+              var ct = 0, I = ot.nodes(":childless")[0].connectedEdges().length;
+              ot.nodes(":childless").forEach(function(Y, q) {
+                Y.connectedEdges().length < I && (I = Y.connectedEdges().length, ct = q);
+              }), v.set(st.id(), ot.nodes(":childless")[ct].id());
+            }), g.forEach(function(st) {
+              var ot = void 0;
+              ot = st.isParent() ? d.get(v.get(st.id())) : d.get(st.id()), st.neighborhood().nodes().forEach(function(ct) {
+                n.intersection(st.edgesWith(ct)).length > 0 && (ct.isParent() ? T[ot].push(v.get(ct.id())) : T[ot].push(ct.id()));
+              });
+            });
+            var lt = function(st) {
+              var ot = d.get(st), ct = void 0;
+              c.get(st).forEach(function(I) {
+                ct = a.getElementById(I).isParent() ? v.get(I) : I, T[ot].push(ct), T[d.get(ct)].push(st);
+              });
+            }, at = !0, Lt = !1, j = void 0;
+            try {
+              for (var pt = c.keys()[Symbol.iterator](), yt; !(at = (yt = pt.next()).done); at = !0) {
+                var Bt = yt.value;
+                lt(Bt);
+              }
+            } catch (st) {
+              Lt = !0, j = st;
+            } finally {
+              try {
+                !at && pt.return && pt.return();
+              } finally {
+                if (Lt) throw j;
+              }
+            }
+            K = d.size;
+            var Yt = void 0;
+            if (K > 2) {
+              C = K < p.sampleSize ? K : p.sampleSize;
+              for (var _t = 0; _t < K; _t++) U[_t] = [];
+              for (var xt = 0; xt < C; xt++) x[xt] = [];
+              return p.quality == "draft" || p.step == "all" ? (G(m), b(), k(), Yt = {
+                nodeIndexes: d,
+                xCoords: L,
+                yCoords: F
+              }) : (d.forEach(function(st, ot) {
+                L.push(a.getElementById(ot).position("x")), F.push(a.getElementById(ot).position("y"));
+              }), Yt = {
+                nodeIndexes: d,
+                xCoords: L,
+                yCoords: F
+              }), Yt;
+            } else {
+              var kt = d.keys(), Ut = a.getElementById(kt.next().value), Rt = Ut.position(), Vt = Ut.outerWidth();
+              if (L.push(Rt.x), F.push(Rt.y), K == 2) {
+                var Gt = a.getElementById(kt.next().value).outerWidth();
+                L.push(Rt.x + Vt / 2 + Gt / 2 + p.idealEdgeLength), F.push(Rt.y);
+              }
+              return Yt = {
+                nodeIndexes: d,
+                xCoords: L,
+                yCoords: F
+              }, Yt;
+            }
+          } };
+        }),
+        579: ((o, r, t) => {
+          var e = t(212), l = function(i) {
+            i && i("layout", "fcose", e);
+          };
+          typeof cytoscape < "u" && l(cytoscape), o.exports = l;
+        }),
+        140: ((o) => {
+          o.exports = A;
+        })
+      }, N = {};
+      function f(o) {
+        var r = N[o];
+        if (r !== void 0) return r.exports;
+        var t = N[o] = { exports: {} };
+        return D[o](t, t.exports, f), t.exports;
+      }
+      return f(579);
+    })();
+  });
+})))()), Le = {
+  L: "left",
+  R: "right",
+  T: "top",
+  B: "bottom"
+}, we = {
+  L: /* @__PURE__ */ gt((M) => `${M},${M / 2} 0,${M} 0,0`, "L"),
+  R: /* @__PURE__ */ gt((M) => `0,${M / 2} ${M},0 ${M},${M}`, "R"),
+  T: /* @__PURE__ */ gt((M) => `0,0 ${M},0 ${M / 2},${M}`, "T"),
+  B: /* @__PURE__ */ gt((M) => `${M / 2},0 ${M},${M} 0,${M}`, "B")
+}, oe = {
+  L: /* @__PURE__ */ gt((M, _) => M - _ + 2, "L"),
+  R: /* @__PURE__ */ gt((M, _) => M - 2, "R"),
+  T: /* @__PURE__ */ gt((M, _) => M - _ + 2, "T"),
+  B: /* @__PURE__ */ gt((M, _) => M - 2, "B")
+}, hi = /* @__PURE__ */ gt(function(M) {
+  return St(M) ? M === "L" ? "R" : "L" : M === "T" ? "B" : "T";
+}, "getOppositeArchitectureDirection"), Ie = /* @__PURE__ */ gt(function(M) {
+  let _ = M;
+  return _ === "L" || _ === "R" || _ === "T" || _ === "B";
+}, "isArchitectureDirection"), St = /* @__PURE__ */ gt(function(M) {
+  let _ = M;
+  return _ === "L" || _ === "R";
+}, "isArchitectureDirectionX"), Wt = /* @__PURE__ */ gt(function(M) {
+  let _ = M;
+  return _ === "T" || _ === "B";
+}, "isArchitectureDirectionY"), pe = /* @__PURE__ */ gt(function(M, _) {
+  let A = St(M) && Wt(_), D = Wt(M) && St(_);
+  return A || D;
+}, "isArchitectureDirectionXY"), li = /* @__PURE__ */ gt(function(M) {
+  let _ = M[0], A = M[1], D = St(_) && Wt(A), N = Wt(_) && St(A);
+  return D || N;
+}, "isArchitecturePairXY"), di = /* @__PURE__ */ gt(function(M) {
+  return M !== "LL" && M !== "RR" && M !== "TT" && M !== "BB";
+}, "isValidArchitectureDirectionPair"), ge = /* @__PURE__ */ gt(function(M, _) {
+  let A = `${M}${_}`;
+  return di(A) ? A : void 0;
+}, "getArchitectureDirectionPair"), gi = /* @__PURE__ */ gt(function([M, _], A) {
+  let D = A[0], N = A[1];
+  return St(D) ? Wt(N) ? [M + (D === "L" ? -1 : 1), _ + (N === "T" ? 1 : -1)] : [M + (D === "L" ? -1 : 1), _] : St(N) ? [M + (N === "L" ? 1 : -1), _ + (D === "T" ? 1 : -1)] : [M, _ + (D === "T" ? 1 : -1)];
+}, "shiftPositionByArchitectureDirectionPair"), ci = /* @__PURE__ */ gt(function(M) {
+  return M === "LT" || M === "TL" ? [1, 1] : M === "BL" || M === "LB" ? [1, -1] : M === "BR" || M === "RB" ? [-1, -1] : [-1, 1];
+}, "getArchitectureDirectionXYFactors"), ui = /* @__PURE__ */ gt(function(M, _) {
+  return pe(M, _) ? "bend" : St(M) ? "horizontal" : "vertical";
+}, "getArchitectureDirectionAlignment"), fi = /* @__PURE__ */ gt(function(M) {
+  return M.type === "service";
+}, "isArchitectureService"), pi = /* @__PURE__ */ gt(function(M) {
+  return M.type === "junction";
+}, "isArchitectureJunction"), Me = /* @__PURE__ */ gt((M) => M.data(), "edgeData"), Qt = /* @__PURE__ */ gt((M) => M.data(), "nodeData"), vi = ei.architecture, te, Oe = (te = class {
+  constructor() {
+    this.nodes = {}, this.groups = {}, this.edges = [], this.registeredIds = {}, this.elements = {}, this.diagramId = "", this.setAccTitle = We, this.getAccTitle = je, this.setDiagramTitle = $e, this.getDiagramTitle = qe, this.getAccDescription = Ze, this.setAccDescription = Ke, this.clear();
+  }
+  setDiagramId(_) {
+    this.diagramId = _;
+  }
+  getDiagramId() {
+    return this.diagramId;
+  }
+  clear() {
+    this.nodes = {}, this.groups = {}, this.edges = [], this.registeredIds = {}, this.dataStructures = void 0, this.elements = {}, this.diagramId = "", Je();
+  }
+  addService({ id: _, icon: A, in: D, title: N, iconText: f }) {
+    if (this.registeredIds[_] !== void 0) throw Error(`The service id [${_}] is already in use by another ${this.registeredIds[_]}`);
+    if (D !== void 0) {
+      if (_ === D) throw Error(`The service [${_}] cannot be placed within itself`);
+      if (this.registeredIds[D] === void 0) throw Error(`The service [${_}]'s parent does not exist. Please make sure the parent is created before this service`);
+      if (this.registeredIds[D] === "node") throw Error(`The service [${_}]'s parent is not a group`);
+    }
+    this.registeredIds[_] = "node", this.nodes[_] = {
+      id: _,
+      type: "service",
+      icon: A,
+      iconText: f,
+      title: N,
+      edges: [],
+      in: D
+    };
+  }
+  getServices() {
+    return Object.values(this.nodes).filter(fi);
+  }
+  addJunction({ id: _, in: A }) {
+    if (this.registeredIds[_] !== void 0) throw Error(`The junction id [${_}] is already in use by another ${this.registeredIds[_]}`);
+    if (A !== void 0) {
+      if (_ === A) throw Error(`The junction [${_}] cannot be placed within itself`);
+      if (this.registeredIds[A] === void 0) throw Error(`The junction [${_}]'s parent does not exist. Please make sure the parent is created before this junction`);
+      if (this.registeredIds[A] === "node") throw Error(`The junction [${_}]'s parent is not a group`);
+    }
+    this.registeredIds[_] = "node", this.nodes[_] = {
+      id: _,
+      type: "junction",
+      edges: [],
+      in: A
+    };
+  }
+  getJunctions() {
+    return Object.values(this.nodes).filter(pi);
+  }
+  getNodes() {
+    return Object.values(this.nodes);
+  }
+  getNode(_) {
+    return this.nodes[_] ?? null;
+  }
+  addGroup({ id: _, icon: A, in: D, title: N }) {
+    if (this.registeredIds?.[_] !== void 0) throw Error(`The group id [${_}] is already in use by another ${this.registeredIds[_]}`);
+    if (D !== void 0) {
+      if (_ === D) throw Error(`The group [${_}] cannot be placed within itself`);
+      if (this.registeredIds?.[D] === void 0) throw Error(`The group [${_}]'s parent does not exist. Please make sure the parent is created before this group`);
+      if (this.registeredIds?.[D] === "node") throw Error(`The group [${_}]'s parent is not a group`);
+    }
+    this.registeredIds[_] = "group", this.groups[_] = {
+      id: _,
+      icon: A,
+      title: N,
+      in: D
+    };
+  }
+  getGroups() {
+    return Object.values(this.groups);
+  }
+  addEdge({ lhsId: _, rhsId: A, lhsDir: D, rhsDir: N, lhsInto: f, rhsInto: o, lhsGroup: r, rhsGroup: t, title: e }) {
+    if (!Ie(D)) throw Error(`Invalid direction given for left hand side of edge ${_}--${A}. Expected (L,R,T,B) got ${String(D)}`);
+    if (!Ie(N)) throw Error(`Invalid direction given for right hand side of edge ${_}--${A}. Expected (L,R,T,B) got ${String(N)}`);
+    if (this.nodes[_] === void 0 && this.groups[_] === void 0) throw Error(`The left-hand id [${_}] does not yet exist. Please create the service/group before declaring an edge to it.`);
+    if (this.nodes[A] === void 0 && this.groups[A] === void 0) throw Error(`The right-hand id [${A}] does not yet exist. Please create the service/group before declaring an edge to it.`);
+    let l = this.nodes[_].in, i = this.nodes[A].in;
+    if (r && l && i && l == i) throw Error(`The left-hand id [${_}] is modified to traverse the group boundary, but the edge does not pass through two groups.`);
+    if (t && l && i && l == i) throw Error(`The right-hand id [${A}] is modified to traverse the group boundary, but the edge does not pass through two groups.`);
+    let p = {
+      lhsId: _,
+      lhsDir: D,
+      lhsInto: f,
+      lhsGroup: r,
+      rhsId: A,
+      rhsDir: N,
+      rhsInto: o,
+      rhsGroup: t,
+      title: e
+    };
+    this.edges.push(p), this.nodes[_] && this.nodes[A] && (this.nodes[_].edges.push(this.edges[this.edges.length - 1]), this.nodes[A].edges.push(this.edges[this.edges.length - 1]));
+  }
+  getEdges() {
+    return this.edges;
+  }
+  getDataStructures() {
+    if (this.dataStructures === void 0) {
+      let _ = {}, A = Object.entries(this.nodes).reduce((t, [e, l]) => (t[e] = l.edges.reduce((i, p) => {
+        let a = this.getNode(p.lhsId)?.in, n = this.getNode(p.rhsId)?.in;
+        if (a && n && a !== n) {
+          let g = ui(p.lhsDir, p.rhsDir);
+          g !== "bend" && (_[a] ??= {}, _[a][n] = g, _[n] ??= {}, _[n][a] = g);
+        }
+        if (p.lhsId === e) {
+          let g = ge(p.lhsDir, p.rhsDir);
+          g && (i[g] = p.rhsId);
+        } else {
+          let g = ge(p.rhsDir, p.lhsDir);
+          g && (i[g] = p.lhsId);
+        }
+        return i;
+      }, {}), t), {}), D = Object.keys(A)[0], N = { [D]: 1 }, f = Object.keys(A).reduce((t, e) => e === D ? t : {
+        ...t,
+        [e]: 1
+      }, {}), o = /* @__PURE__ */ gt((t) => {
+        let e = { [t]: [0, 0] }, l = [t];
+        for (; l.length > 0; ) {
+          let i = l.shift();
+          if (i) {
+            N[i] = 1, delete f[i];
+            let p = A[i], [a, n] = e[i];
+            Object.entries(p).forEach(([g, h]) => {
+              N[h] || (e[h] = gi([a, n], g), l.push(h));
+            });
+          }
+        }
+        return e;
+      }, "BFS"), r = [o(D)];
+      for (; Object.keys(f).length > 0; ) r.push(o(Object.keys(f)[0]));
+      this.dataStructures = {
+        adjList: A,
+        spatialMaps: r,
+        groupAlignments: _
+      };
+    }
+    return this.dataStructures;
+  }
+  setElementForId(_, A) {
+    this.elements[_] = A;
+  }
+  getElementById(_) {
+    return this.elements[_];
+  }
+  getConfig() {
+    return Qe({
+      ...vi,
+      ...ti().architecture
+    });
+  }
+  getConfigField(_) {
+    return this.getConfig()[_];
+  }
+}, gt(te, "ArchitectureDB"), te), yi = /* @__PURE__ */ gt((M, _) => {
+  ni(M, _), M.groups.map((A) => _.addGroup(A)), M.services.map((A) => _.addService({
+    ...A,
+    type: "service"
+  })), M.junctions.map((A) => _.addJunction({
+    ...A,
+    type: "junction"
+  })), M.edges.map((A) => _.addEdge(A));
+}, "populateDb"), De = {
+  parser: { yy: void 0 },
+  parse: /* @__PURE__ */ gt(async (M) => {
+    let _ = await ai("architecture", M);
+    _e.debug(_);
+    let A = De.parser?.yy;
+    if (!(A instanceof Oe)) throw Error("parser.parser?.yy was not a ArchitectureDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues.");
+    yi(_, A);
+  }, "parse")
+}, mi = /* @__PURE__ */ gt((M) => `
+  .edge {
+    stroke-width: ${M.archEdgeWidth};
+    stroke: ${M.archEdgeColor};
+    fill: none;
+  }
+
+  .arrow {
+    fill: ${M.archEdgeArrowColor};
+  }
+
+  .node-bkg {
+    fill: none;
+    stroke: ${M.archGroupBorderColor};
+    stroke-width: ${M.archGroupBorderWidth};
+    stroke-dasharray: 8;
+  }
+  .node-icon-text {
+    display: flex; 
+    align-items: center;
+  }
+  
+  .node-icon-text > div {
+    color: #fff;
+    margin: 1px;
+    height: fit-content;
+    text-align: center;
+    overflow: hidden;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+  }
+`, "getStyles"), Jt = /* @__PURE__ */ gt((M) => `<g><rect width="80" height="80" style="fill: #087ebf; stroke-width: 0px;"/>${M}</g>`, "wrapIcon"), ie = {
+  prefix: "mermaid-architecture",
+  height: 80,
+  width: 80,
+  icons: {
+    database: { body: Jt('<path id="b" data-name="4" d="m20,57.86c0,3.94,8.95,7.14,20,7.14s20-3.2,20-7.14" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><path id="c" data-name="3" d="m20,45.95c0,3.94,8.95,7.14,20,7.14s20-3.2,20-7.14" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><path id="d" data-name="2" d="m20,34.05c0,3.94,8.95,7.14,20,7.14s20-3.2,20-7.14" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><ellipse id="e" data-name="1" cx="40" cy="22.14" rx="20" ry="7.14" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="20" y1="57.86" x2="20" y2="22.14" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="60" y1="57.86" x2="60" y2="22.14" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/>') },
+    server: { body: Jt('<rect x="17.5" y="17.5" width="45" height="45" rx="2" ry="2" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="17.5" y1="32.5" x2="62.5" y2="32.5" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="17.5" y1="47.5" x2="62.5" y2="47.5" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><g><path d="m56.25,25c0,.27-.45.5-1,.5h-10.5c-.55,0-1-.23-1-.5s.45-.5,1-.5h10.5c.55,0,1,.23,1,.5Z" style="fill: #fff; stroke-width: 0px;"/><path d="m56.25,25c0,.27-.45.5-1,.5h-10.5c-.55,0-1-.23-1-.5s.45-.5,1-.5h10.5c.55,0,1,.23,1,.5Z" style="fill: none; stroke: #fff; stroke-miterlimit: 10;"/></g><g><path d="m56.25,40c0,.27-.45.5-1,.5h-10.5c-.55,0-1-.23-1-.5s.45-.5,1-.5h10.5c.55,0,1,.23,1,.5Z" style="fill: #fff; stroke-width: 0px;"/><path d="m56.25,40c0,.27-.45.5-1,.5h-10.5c-.55,0-1-.23-1-.5s.45-.5,1-.5h10.5c.55,0,1,.23,1,.5Z" style="fill: none; stroke: #fff; stroke-miterlimit: 10;"/></g><g><path d="m56.25,55c0,.27-.45.5-1,.5h-10.5c-.55,0-1-.23-1-.5s.45-.5,1-.5h10.5c.55,0,1,.23,1,.5Z" style="fill: #fff; stroke-width: 0px;"/><path d="m56.25,55c0,.27-.45.5-1,.5h-10.5c-.55,0-1-.23-1-.5s.45-.5,1-.5h10.5c.55,0,1,.23,1,.5Z" style="fill: none; stroke: #fff; stroke-miterlimit: 10;"/></g><g><circle cx="32.5" cy="25" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/><circle cx="27.5" cy="25" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/><circle cx="22.5" cy="25" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/></g><g><circle cx="32.5" cy="40" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/><circle cx="27.5" cy="40" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/><circle cx="22.5" cy="40" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/></g><g><circle cx="32.5" cy="55" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/><circle cx="27.5" cy="55" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/><circle cx="22.5" cy="55" r=".75" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10;"/></g>') },
+    disk: { body: Jt('<rect x="20" y="15" width="40" height="50" rx="1" ry="1" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><ellipse cx="24" cy="19.17" rx=".8" ry=".83" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><ellipse cx="56" cy="19.17" rx=".8" ry=".83" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><ellipse cx="24" cy="60.83" rx=".8" ry=".83" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><ellipse cx="56" cy="60.83" rx=".8" ry=".83" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><ellipse cx="40" cy="33.75" rx="14" ry="14.58" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><ellipse cx="40" cy="33.75" rx="4" ry="4.17" style="fill: #fff; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><path d="m37.51,42.52l-4.83,13.22c-.26.71-1.1,1.02-1.76.64l-4.18-2.42c-.66-.38-.81-1.26-.33-1.84l9.01-10.8c.88-1.05,2.56-.08,2.09,1.2Z" style="fill: #fff; stroke-width: 0px;"/>') },
+    internet: { body: Jt('<circle cx="40" cy="40" r="22.5" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="40" y1="17.5" x2="40" y2="62.5" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="17.5" y1="40" x2="62.5" y2="40" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><path d="m39.99,17.51c-15.28,11.1-15.28,33.88,0,44.98" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><path d="m40.01,17.51c15.28,11.1,15.28,33.88,0,44.98" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="19.75" y1="30.1" x2="60.25" y2="30.1" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/><line x1="19.75" y1="49.9" x2="60.25" y2="49.9" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/>') },
+    cloud: { body: Jt('<path d="m65,47.5c0,2.76-2.24,5-5,5H20c-2.76,0-5-2.24-5-5,0-1.87,1.03-3.51,2.56-4.36-.04-.21-.06-.42-.06-.64,0-2.6,2.48-4.74,5.65-4.97,1.65-4.51,6.34-7.76,11.85-7.76.86,0,1.69.08,2.5.23,2.09-1.57,4.69-2.5,7.5-2.5,6.1,0,11.19,4.38,12.28,10.17,2.14.56,3.72,2.51,3.72,4.83,0,.03,0,.07-.01.1,2.29.46,4.01,2.48,4.01,4.9Z" style="fill: none; stroke: #fff; stroke-miterlimit: 10; stroke-width: 2px;"/>') },
+    unknown: oi,
+    blank: { body: Jt("") }
+  }
+}, Ei = /* @__PURE__ */ gt(async function(M, _, A, D) {
+  let N = A.getConfigField("padding"), f = A.getConfigField("iconSize"), o = f / 2, r = f / 6, t = r / 2;
+  await Promise.all(_.edges().map(async (e) => {
+    let { source: l, sourceDir: i, sourceArrow: p, sourceGroup: a, target: n, targetDir: g, targetArrow: h, targetGroup: c, label: d } = Me(e), { x: v, y: T } = e[0].sourceEndpoint(), { x: L, y: F } = e[0].midpoint(), { x: S, y: P } = e[0].targetEndpoint(), U = N + 4;
+    if (a && (St(i) ? v += i === "L" ? -U : U : T += i === "T" ? -U : U + 18), c && (St(g) ? S += g === "L" ? -U : U : P += g === "T" ? -U : U + 18), !a && A.getNode(l)?.type === "junction" && (St(i) ? v += i === "L" ? o : -o : T += i === "T" ? o : -o), !c && A.getNode(n)?.type === "junction" && (St(g) ? S += g === "L" ? o : -o : P += g === "T" ? o : -o), e[0]._private.rscratch) {
+      let Z = M.insert("g");
+      if (Z.insert("path").attr("d", `M ${v},${T} L ${L},${F} L${S},${P} `).attr("class", "edge").attr("id", `${D}-${Ve(l, n, { prefix: "L" })}`), p) {
+        let x = St(i) ? oe[i](v, r) : v - t, K = Wt(i) ? oe[i](T, r) : T - t;
+        Z.insert("polygon").attr("points", we[i](r)).attr("transform", `translate(${x},${K})`).attr("class", "arrow");
+      }
+      if (h) {
+        let x = St(g) ? oe[g](S, r) : S - t, K = Wt(g) ? oe[g](P, r) : P - t;
+        Z.insert("polygon").attr("points", we[g](r)).attr("transform", `translate(${x},${K})`).attr("class", "arrow");
+      }
+      if (d) {
+        let x = pe(i, g) ? "XY" : St(i) ? "X" : "Y", K = 0;
+        K = x === "X" ? Math.abs(v - S) : x === "Y" ? Math.abs(T - P) / 1.5 : Math.abs(v - S) / 2;
+        let s = Z.append("g");
+        if (await ue(s, d, {
+          useHtmlLabels: !1,
+          width: K,
+          classes: "architecture-service-label"
+        }, ce()), s.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "middle").attr("text-anchor", "middle"), x === "X") s.attr("transform", "translate(" + L + ", " + F + ")");
+        else if (x === "Y") s.attr("transform", "translate(" + L + ", " + F + ") rotate(-90)");
+        else if (x === "XY") {
+          let E = ge(i, g);
+          if (E && li(E)) {
+            let u = s.node().getBoundingClientRect(), [m, y] = ci(E);
+            s.attr("dominant-baseline", "auto").attr("transform", `rotate(${-1 * m * y * 45})`);
+            let C = s.node().getBoundingClientRect();
+            s.attr("transform", `
+                translate(${L}, ${F - u.height / 2})
+                translate(${m * C.width / 2}, ${y * C.height / 2})
+                rotate(${-1 * m * y * 45}, 0, ${u.height / 2})
+              `);
+          }
+        }
+      }
+    }
+  }));
+}, "drawEdges"), Ti = /* @__PURE__ */ gt(async function(M, _, A, D) {
+  let N = A.getConfigField("padding") * 0.75, f = A.getConfigField("fontSize"), o = A.getConfigField("iconSize") / 2;
+  await Promise.all(_.nodes().map(async (r) => {
+    let t = Qt(r);
+    if (t.type === "group") {
+      let { h: e, w: l, x1: i, y1: p } = r.boundingBox(), a = M.append("rect");
+      a.attr("id", `${D}-group-${t.id}`).attr("x", i + o).attr("y", p + o).attr("width", l).attr("height", e).attr("class", "node-bkg");
+      let n = M.append("g"), g = i, h = p;
+      if (t.icon) {
+        let c = n.append("g");
+        c.html(`<g>${await de(t.icon, {
+          height: N,
+          width: N,
+          fallbackPrefix: ie.prefix
+        })}</g>`), c.attr("transform", "translate(" + (g + o + 1) + ", " + (h + o + 1) + ")"), g += N, h += f / 2 - 1 - 2;
+      }
+      if (t.label) {
+        let c = n.append("g");
+        await ue(c, t.label, {
+          useHtmlLabels: !1,
+          width: l,
+          classes: "architecture-service-label"
+        }, ce()), c.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "start").attr("text-anchor", "start"), c.attr("transform", "translate(" + (g + o + 4) + ", " + (h + o + 2) + ")");
+      }
+      A.setElementForId(t.id, a);
+    }
+  }));
+}, "drawGroups"), Ni = /* @__PURE__ */ gt(async function(M, _, A, D) {
+  let N = ce();
+  for (let f of A) {
+    let o = _.append("g"), r = M.getConfigField("iconSize");
+    if (f.title) {
+      let i = o.append("g");
+      await ue(i, f.title, {
+        useHtmlLabels: !1,
+        width: r * 1.5,
+        classes: "architecture-service-label"
+      }, N), i.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "middle").attr("text-anchor", "middle"), i.attr("transform", "translate(" + r / 2 + ", " + r + ")");
+    }
+    let t = o.append("g");
+    if (f.icon) t.html(`<g>${await de(f.icon, {
+      height: r,
+      width: r,
+      fallbackPrefix: ie.prefix
+    })}</g>`);
+    else if (f.iconText) {
+      t.html(`<g>${await de("blank", {
+        height: r,
+        width: r,
+        fallbackPrefix: ie.prefix
+      })}</g>`);
+      let i = t.append("g").append("foreignObject").attr("width", r).attr("height", r).append("div").attr("class", "node-icon-text").attr("style", `height: ${r}px;`).append("div").html(ze(f.iconText, N)), p = parseInt(window.getComputedStyle(i.node(), null).getPropertyValue("font-size").replace(/\D/g, "")) ?? 16;
+      i.attr("style", `-webkit-line-clamp: ${Math.floor((r - 2) / p)};`);
+    } else t.append("path").attr("class", "node-bkg").attr("id", `${D}-node-${f.id}`).attr("d", `M0,${r} V5 Q0,0 5,0 H${r - 5} Q${r},0 ${r},5 V${r} Z`);
+    o.attr("id", `${D}-service-${f.id}`).attr("class", "architecture-service");
+    let { width: e, height: l } = o.node().getBBox();
+    f.width = e, f.height = l, M.setElementForId(f.id, o);
+  }
+  return 0;
+}, "drawServices"), Ai = /* @__PURE__ */ gt(function(M, _, A, D) {
+  A.forEach((N) => {
+    let f = _.append("g"), o = M.getConfigField("iconSize");
+    f.append("g").append("rect").attr("id", `${D}-node-${N.id}`).attr("fill-opacity", "0").attr("width", o).attr("height", o), f.attr("class", "architecture-junction");
+    let { width: r, height: t } = f._groups[0][0].getBBox();
+    f.width = r, f.height = t, M.setElementForId(N.id, f);
+  });
+}, "drawJunctions");
+ri([{
+  name: ie.prefix,
+  icons: ie
+}]), xe.use(si.default);
+function Re(M, _, A) {
+  M.forEach((D) => {
+    _.add({
+      group: "nodes",
+      data: {
+        type: "service",
+        id: D.id,
+        icon: D.icon,
+        label: D.title,
+        parent: D.in,
+        width: A.getConfigField("iconSize"),
+        height: A.getConfigField("iconSize")
+      },
+      classes: "node-service"
+    });
+  });
+}
+gt(Re, "addServices");
+function be(M, _, A) {
+  M.forEach((D) => {
+    _.add({
+      group: "nodes",
+      data: {
+        type: "junction",
+        id: D.id,
+        parent: D.in,
+        width: A.getConfigField("iconSize"),
+        height: A.getConfigField("iconSize")
+      },
+      classes: "node-junction"
+    });
+  });
+}
+gt(be, "addJunctions");
+function Fe(M, _) {
+  _.nodes().map((A) => {
+    let D = Qt(A);
+    D.type !== "group" && (D.x = A.position().x, D.y = A.position().y, M.getElementById(D.id).attr("transform", "translate(" + (D.x || 0) + "," + (D.y || 0) + ")"));
+  });
+}
+gt(Fe, "positionNodes");
+function Ge(M, _) {
+  M.forEach((A) => {
+    _.add({
+      group: "nodes",
+      data: {
+        type: "group",
+        id: A.id,
+        icon: A.icon,
+        label: A.title,
+        parent: A.in
+      },
+      classes: "node-group"
+    });
+  });
+}
+gt(Ge, "addGroups");
+function Pe(M, _) {
+  M.forEach((A) => {
+    let { lhsId: D, rhsId: N, lhsInto: f, lhsGroup: o, rhsInto: r, lhsDir: t, rhsDir: e, rhsGroup: l, title: i } = A, p = pe(A.lhsDir, A.rhsDir) ? "segments" : "straight", a = {
+      id: `${D}-${N}`,
+      label: i,
+      source: D,
+      sourceDir: t,
+      sourceArrow: f,
+      sourceGroup: o,
+      sourceEndpoint: t === "L" ? "0 50%" : t === "R" ? "100% 50%" : t === "T" ? "50% 0" : "50% 100%",
+      target: N,
+      targetDir: e,
+      targetArrow: r,
+      targetGroup: l,
+      targetEndpoint: e === "L" ? "0 50%" : e === "R" ? "100% 50%" : e === "T" ? "50% 0" : "50% 100%"
+    };
+    _.add({
+      group: "edges",
+      data: a,
+      classes: p
+    });
+  });
+}
+gt(Pe, "addEdges");
+function Se(M, _, A) {
+  let D = /* @__PURE__ */ gt((o, r) => Object.entries(o).reduce((t, [e, l]) => {
+    let i = 0, p = Object.entries(l);
+    if (p.length === 1) return t[e] = p[0][1], t;
+    for (let a = 0; a < p.length - 1; a++) for (let n = a + 1; n < p.length; n++) {
+      let [g, h] = p[a], [c, d] = p[n];
+      if (A[g]?.[c] === r) t[e] ??= [], t[e] = [
+        ...t[e],
+        ...h,
+        ...d
+      ];
+      else if (g === "default" || c === "default") t[e] ??= [], t[e] = [
+        ...t[e],
+        ...h,
+        ...d
+      ];
+      else {
+        let v = `${e}-${i++}`;
+        t[v] = h;
+        let T = `${e}-${i++}`;
+        t[T] = d;
+      }
+    }
+    return t;
+  }, {}), "flattenAlignments"), [N, f] = _.map((o) => {
+    let r = {}, t = {};
+    return Object.entries(o).forEach(([e, [l, i]]) => {
+      let p = M.getNode(e)?.in ?? "default";
+      r[i] ??= {}, r[i][p] ??= [], r[i][p].push(e), t[l] ??= {}, t[l][p] ??= [], t[l][p].push(e);
+    }), {
+      horiz: Object.values(D(r, "horizontal")).filter((e) => e.length > 1),
+      vert: Object.values(D(t, "vertical")).filter((e) => e.length > 1)
+    };
+  }).reduce(([o, r], { horiz: t, vert: e }) => [[...o, ...t], [...r, ...e]], [[], []]);
+  return {
+    horizontal: N,
+    vertical: f
+  };
+}
+gt(Se, "getAlignments");
+function Ye(M, _) {
+  let A = [], D = /* @__PURE__ */ gt((f) => `${f[0]},${f[1]}`, "posToStr"), N = /* @__PURE__ */ gt((f) => f.split(",").map((o) => parseInt(o)), "strToPos");
+  return M.forEach((f) => {
+    let o = Object.fromEntries(Object.entries(f).map(([l, i]) => [D(i), l])), r = [D([0, 0])], t = {}, e = {
+      L: [-1, 0],
+      R: [1, 0],
+      T: [0, 1],
+      B: [0, -1]
+    };
+    for (; r.length > 0; ) {
+      let l = r.shift();
+      if (l) {
+        t[l] = 1;
+        let i = o[l];
+        if (i) {
+          let p = N(l);
+          Object.entries(e).forEach(([a, n]) => {
+            let g = D([p[0] + n[0], p[1] + n[1]]), h = o[g];
+            h && !t[g] && (r.push(g), A.push({
+              [Le[a]]: h,
+              [Le[hi(a)]]: i,
+              gap: 1.5 * _.getConfigField("iconSize")
+            }));
+          });
+        }
+      }
+    }
+  }), A;
+}
+gt(Ye, "getRelativeConstraints");
+function ke(M, _, A, D, N, { spatialMaps: f, groupAlignments: o }) {
+  return new Promise((r) => {
+    let t = Be("body").append("div").attr("id", "cy").attr("style", "display:none"), e = xe({
+      container: document.getElementById("cy"),
+      style: [
+        {
+          selector: "edge",
+          style: {
+            "curve-style": "straight",
+            "source-endpoint": "data(sourceEndpoint)",
+            "target-endpoint": "data(targetEndpoint)"
+          }
+        },
+        {
+          selector: "edge[label]",
+          style: { label: "data(label)" }
+        },
+        {
+          selector: "edge.segments",
+          style: {
+            "curve-style": "segments",
+            "segment-weights": "0",
+            "segment-distances": [0.5],
+            "edge-distances": "endpoints",
+            "source-endpoint": "data(sourceEndpoint)",
+            "target-endpoint": "data(targetEndpoint)"
+          }
+        },
+        {
+          selector: "node",
+          style: { "compound-sizing-wrt-labels": "include" }
+        },
+        {
+          selector: "node[label]",
+          style: {
+            "text-valign": "bottom",
+            "text-halign": "center",
+            "font-size": `${N.getConfigField("fontSize")}px`
+          }
+        },
+        {
+          selector: ".node-service",
+          style: {
+            label: "data(label)",
+            width: "data(width)",
+            height: "data(height)"
+          }
+        },
+        {
+          selector: ".node-junction",
+          style: {
+            width: "data(width)",
+            height: "data(height)"
+          }
+        },
+        {
+          selector: ".node-group",
+          style: { padding: `${N.getConfigField("padding")}px` }
+        }
+      ],
+      layout: {
+        name: "grid",
+        boundingBox: {
+          x1: 0,
+          x2: 100,
+          y1: 0,
+          y2: 100
+        }
+      }
+    });
+    t.remove(), Ge(A, e), Re(M, e, N), be(_, e, N), Pe(D, e);
+    let l = Se(N, f, o), i = Ye(f, N), p = N.getConfigField("iconSize"), a = N.getConfigField("idealEdgeLengthMultiplier") * p, n = 0.5 * p, g = N.getConfigField("edgeElasticity"), h = e.layout({
+      name: "fcose",
+      quality: "proof",
+      randomize: N.getConfigField("randomize"),
+      nodeSeparation: N.getConfigField("nodeSeparation"),
+      numIter: N.getConfigField("numIter"),
+      styleEnabled: !1,
+      animate: !1,
+      nodeDimensionsIncludeLabels: !1,
+      idealEdgeLength(c) {
+        let [d, v] = c.connectedNodes(), { parent: T } = Qt(d), { parent: L } = Qt(v);
+        return T === L ? a : n;
+      },
+      edgeElasticity(c) {
+        let [d, v] = c.connectedNodes(), { parent: T } = Qt(d), { parent: L } = Qt(v);
+        return T === L ? g : 1e-3;
+      },
+      alignmentConstraint: l,
+      relativePlacementConstraint: i
+    });
+    h.one("layoutstop", () => {
+      function c(d, v, T, L) {
+        let F, S, { x: P, y: U } = d, { x: Z, y: x } = v;
+        S = (L - U + (P - T) * (U - x) / (P - Z)) / Math.sqrt(1 + ((U - x) / (P - Z)) ** 2), F = Math.sqrt((L - U) ** 2 + (T - P) ** 2 - S ** 2);
+        let K = Math.sqrt((Z - P) ** 2 + (x - U) ** 2);
+        F /= K;
+        let s = (Z - P) * (L - U) - (x - U) * (T - P);
+        switch (!0) {
+          case s >= 0:
+            s = 1;
+            break;
+          case s < 0:
+            s = -1;
+            break;
+        }
+        let E = (Z - P) * (T - P) + (x - U) * (L - U);
+        switch (!0) {
+          case E >= 0:
+            E = 1;
+            break;
+          case E < 0:
+            E = -1;
+            break;
+        }
+        return S = Math.abs(S) * s, F *= E, {
+          distances: S,
+          weights: F
+        };
+      }
+      gt(c, "getSegmentWeights"), e.startBatch();
+      for (let d of Object.values(e.edges())) if (d.data?.()) {
+        let { x: v, y: T } = d.source().position(), { x: L, y: F } = d.target().position();
+        if (v !== L && T !== F) {
+          let S = d.sourceEndpoint(), P = d.targetEndpoint(), { sourceDir: U } = Me(d), [Z, x] = Wt(U) ? [S.x, P.y] : [P.x, S.y], { weights: K, distances: s } = c(S, P, Z, x);
+          d.style("segment-distances", s), d.style("segment-weights", K);
+        }
+      }
+      e.endBatch(), h.run();
+    }), h.run(), e.ready((c) => {
+      _e.info("Ready", c), r(e);
+    });
+  });
+}
+gt(ke, "layoutArchitecture");
+var _i = {
+  parser: De,
+  get db() {
+    return new Oe();
+  },
+  renderer: { draw: /* @__PURE__ */ gt(async (M, _, A, D) => {
+    let N = D.db;
+    N.setDiagramId(_);
+    let f = N.getServices(), o = N.getJunctions(), r = N.getGroups(), t = N.getEdges(), e = N.getDataStructures(), l = Ue(_), i = l.append("g");
+    i.attr("class", "architecture-edges");
+    let p = l.append("g");
+    p.attr("class", "architecture-services");
+    let a = l.append("g");
+    a.attr("class", "architecture-groups"), await Ni(N, p, f, _), Ai(N, p, o, _);
+    let n = await ke(f, o, r, t, N, e);
+    await Ei(i, n, N, _), await Ti(a, n, N, _), Fe(N, n), Xe(void 0, l, N.getConfigField("padding"), N.getConfigField("useMaxWidth"));
+  }, "draw") },
+  styles: mi
+};
+export {
+  _i as diagram
+};