@ucap-llm/ai-ui 1.1.13 → 1.1.15

package/architectureDiagram-IEHRJDOE-BRVAVUEE-c068faae.mjs

@@ -0,0 +1,4641 @@
+import { A as $e, v as rt, b3 as je, b4 as qe, $ as Ze, i as Ke, k as Qe, j as Je, G as ti, Y as ei, K as ii, l as he, J as Ge, e as ri, r as ni, a3 as oi, aD as ai, aU as Ne, b5 as fe } from "./index-433e2395.mjs";
+import { m as si } from "./chunk-4BMEZGHF-btTOjzEX-c9c5432c.mjs";
+import { e as hi } from "./chunk-XZIHB7SX-CCrbsG0u-f30e4124.mjs";
+import { u as li } from "./mermaid-parser.core-BTS3sfcL-8c80284a.mjs";
+import { J as Pe } from "./cytoscape.esm-Swd9B-1A-3101f241.mjs";
+import "vue";
+import "./_baseUniq-DPnX6tpB-5eb6efbd.mjs";
+import "./_basePickBy-DMehTBs0-8955b30b.mjs";
+import "./clone-Csc9uFbU-6c4f28bd.mjs";
+var pe = { exports: {} }, ve = { exports: {} }, me = { exports: {} }, ci = me.exports, xe;
+function di() {
+  return xe || (xe = 1, function(A, X) {
+    (function(L, U) {
+      A.exports = U();
+    })(ci, function() {
+      return (
+        /******/
+        function(L) {
+          var U = {};
+          function T(u) {
+            if (U[u])
+              return U[u].exports;
+            var l = U[u] = {
+              /******/
+              i: u,
+              /******/
+              l: !1,
+              /******/
+              exports: {}
+              /******/
+            };
+            return L[u].call(l.exports, l, l.exports, T), l.l = !0, l.exports;
+          }
+          return T.m = L, T.c = U, T.i = function(u) {
+            return u;
+          }, T.d = function(u, l, o) {
+            T.o(u, l) || Object.defineProperty(u, l, {
+              /******/
+              configurable: !1,
+              /******/
+              enumerable: !0,
+              /******/
+              get: o
+              /******/
+            });
+          }, T.n = function(u) {
+            var l = u && u.__esModule ? (
+              /******/
+              function() {
+                return u.default;
+              }
+            ) : (
+              /******/
+              function() {
+                return u;
+              }
+            );
+            return T.d(l, "a", l), l;
+          }, T.o = function(u, l) {
+            return Object.prototype.hasOwnProperty.call(u, l);
+          }, T.p = "", T(T.s = 28);
+        }([
+          /* 0 */
+          /***/
+          function(L, U, T) {
+            function u() {
+            }
+            u.QUALITY = 1, u.DEFAULT_CREATE_BENDS_AS_NEEDED = !1, u.DEFAULT_INCREMENTAL = !1, u.DEFAULT_ANIMATION_ON_LAYOUT = !0, u.DEFAULT_ANIMATION_DURING_LAYOUT = !1, u.DEFAULT_ANIMATION_PERIOD = 50, u.DEFAULT_UNIFORM_LEAF_NODE_SIZES = !1, u.DEFAULT_GRAPH_MARGIN = 15, u.NODE_DIMENSIONS_INCLUDE_LABELS = !1, u.SIMPLE_NODE_SIZE = 40, u.SIMPLE_NODE_HALF_SIZE = u.SIMPLE_NODE_SIZE / 2, u.EMPTY_COMPOUND_NODE_SIZE = 40, u.MIN_EDGE_LENGTH = 1, u.WORLD_BOUNDARY = 1e6, u.INITIAL_WORLD_BOUNDARY = u.WORLD_BOUNDARY / 1e3, u.WORLD_CENTER_X = 1200, u.WORLD_CENTER_Y = 900, L.exports = u;
+          },
+          /* 1 */
+          /***/
+          function(L, U, T) {
+            var u = T(2), l = T(8), o = T(9);
+            function i(h, r, f) {
+              u.call(this, f), this.isOverlapingSourceAndTarget = !1, this.vGraphObject = f, this.bendpoints = [], this.source = h, this.target = r;
+            }
+            i.prototype = Object.create(u.prototype);
+            for (var t in u)
+              i[t] = u[t];
+            i.prototype.getSource = function() {
+              return this.source;
+            }, i.prototype.getTarget = function() {
+              return this.target;
+            }, i.prototype.isInterGraph = function() {
+              return this.isInterGraph;
+            }, i.prototype.getLength = function() {
+              return this.length;
+            }, i.prototype.isOverlapingSourceAndTarget = function() {
+              return this.isOverlapingSourceAndTarget;
+            }, i.prototype.getBendpoints = function() {
+              return this.bendpoints;
+            }, i.prototype.getLca = function() {
+              return this.lca;
+            }, i.prototype.getSourceInLca = function() {
+              return this.sourceInLca;
+            }, i.prototype.getTargetInLca = function() {
+              return this.targetInLca;
+            }, i.prototype.getOtherEnd = function(h) {
+              if (this.source === h)
+                return this.target;
+              if (this.target === h)
+                return this.source;
+              throw "Node is not incident with this edge";
+            }, i.prototype.getOtherEndInGraph = function(h, r) {
+              for (var f = this.getOtherEnd(h), e = r.getGraphManager().getRoot(); ; ) {
+                if (f.getOwner() == r)
+                  return f;
+                if (f.getOwner() == e)
+                  break;
+                f = f.getOwner().getParent();
+              }
+              return null;
+            }, i.prototype.updateLength = function() {
+              var h = new Array(4);
+              this.isOverlapingSourceAndTarget = l.getIntersection(this.target.getRect(), this.source.getRect(), h), this.isOverlapingSourceAndTarget || (this.lengthX = h[0] - h[2], this.lengthY = h[1] - h[3], Math.abs(this.lengthX) < 1 && (this.lengthX = o.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = o.sign(this.lengthY)), this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY));
+            }, i.prototype.updateLengthSimple = function() {
+              this.lengthX = this.target.getCenterX() - this.source.getCenterX(), this.lengthY = this.target.getCenterY() - this.source.getCenterY(), Math.abs(this.lengthX) < 1 && (this.lengthX = o.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = o.sign(this.lengthY)), this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+            }, L.exports = i;
+          },
+          /* 2 */
+          /***/
+          function(L, U, T) {
+            function u(l) {
+              this.vGraphObject = l;
+            }
+            L.exports = u;
+          },
+          /* 3 */
+          /***/
+          function(L, U, T) {
+            var u = T(2), l = T(10), o = T(13), i = T(0), t = T(16), h = T(5);
+            function r(e, s, a, g) {
+              a == null && g == null && (g = s), u.call(this, g), e.graphManager != null && (e = e.graphManager), this.estimatedSize = l.MIN_VALUE, this.inclusionTreeDepth = l.MAX_VALUE, this.vGraphObject = g, this.edges = [], this.graphManager = e, a != null && s != null ? this.rect = new o(s.x, s.y, a.width, a.height) : this.rect = new o();
+            }
+            r.prototype = Object.create(u.prototype);
+            for (var f in u)
+              r[f] = u[f];
+            r.prototype.getEdges = function() {
+              return this.edges;
+            }, r.prototype.getChild = function() {
+              return this.child;
+            }, r.prototype.getOwner = function() {
+              return this.owner;
+            }, r.prototype.getWidth = function() {
+              return this.rect.width;
+            }, r.prototype.setWidth = function(e) {
+              this.rect.width = e;
+            }, r.prototype.getHeight = function() {
+              return this.rect.height;
+            }, r.prototype.setHeight = function(e) {
+              this.rect.height = e;
+            }, r.prototype.getCenterX = function() {
+              return this.rect.x + this.rect.width / 2;
+            }, r.prototype.getCenterY = function() {
+              return this.rect.y + this.rect.height / 2;
+            }, r.prototype.getCenter = function() {
+              return new h(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2);
+            }, r.prototype.getLocation = function() {
+              return new h(this.rect.x, this.rect.y);
+            }, r.prototype.getRect = function() {
+              return this.rect;
+            }, r.prototype.getDiagonal = function() {
+              return Math.sqrt(this.rect.width * this.rect.width + this.rect.height * this.rect.height);
+            }, r.prototype.getHalfTheDiagonal = function() {
+              return Math.sqrt(this.rect.height * this.rect.height + this.rect.width * this.rect.width) / 2;
+            }, r.prototype.setRect = function(e, s) {
+              this.rect.x = e.x, this.rect.y = e.y, this.rect.width = s.width, this.rect.height = s.height;
+            }, r.prototype.setCenter = function(e, s) {
+              this.rect.x = e - this.rect.width / 2, this.rect.y = s - this.rect.height / 2;
+            }, r.prototype.setLocation = function(e, s) {
+              this.rect.x = e, this.rect.y = s;
+            }, r.prototype.moveBy = function(e, s) {
+              this.rect.x += e, this.rect.y += s;
+            }, r.prototype.getEdgeListToNode = function(e) {
+              var s = [], a = this;
+              return a.edges.forEach(function(g) {
+                if (g.target == e) {
+                  if (g.source != a)
+                    throw "Incorrect edge source!";
+                  s.push(g);
+                }
+              }), s;
+            }, r.prototype.getEdgesBetween = function(e) {
+              var s = [], a = this;
+              return a.edges.forEach(function(g) {
+                if (!(g.source == a || g.target == a))
+                  throw "Incorrect edge source and/or target";
+                (g.target == e || g.source == e) && s.push(g);
+              }), s;
+            }, r.prototype.getNeighborsList = function() {
+              var e = /* @__PURE__ */ new Set(), s = this;
+              return s.edges.forEach(function(a) {
+                if (a.source == s)
+                  e.add(a.target);
+                else {
+                  if (a.target != s)
+                    throw "Incorrect incidency!";
+                  e.add(a.source);
+                }
+              }), e;
+            }, r.prototype.withChildren = function() {
+              var e = /* @__PURE__ */ new Set(), s, a;
+              if (e.add(this), this.child != null)
+                for (var g = this.child.getNodes(), c = 0; c < g.length; c++)
+                  s = g[c], a = s.withChildren(), a.forEach(function(N) {
+                    e.add(N);
+                  });
+              return e;
+            }, r.prototype.getNoOfChildren = function() {
+              var e = 0, s;
+              if (this.child == null)
+                e = 1;
+              else
+                for (var a = this.child.getNodes(), g = 0; g < a.length; g++)
+                  s = a[g], e += s.getNoOfChildren();
+              return e == 0 && (e = 1), e;
+            }, r.prototype.getEstimatedSize = function() {
+              if (this.estimatedSize == l.MIN_VALUE)
+                throw "assert failed";
+              return this.estimatedSize;
+            }, r.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);
+            }, r.prototype.scatter = function() {
+              var e, s, a = -i.INITIAL_WORLD_BOUNDARY, g = i.INITIAL_WORLD_BOUNDARY;
+              e = i.WORLD_CENTER_X + t.nextDouble() * (g - a) + a;
+              var c = -i.INITIAL_WORLD_BOUNDARY, N = i.INITIAL_WORLD_BOUNDARY;
+              s = i.WORLD_CENTER_Y + t.nextDouble() * (N - c) + c, this.rect.x = e, this.rect.y = s;
+            }, r.prototype.updateBounds = function() {
+              if (this.getChild() == null)
+                throw "assert failed";
+              if (this.getChild().getNodes().length != 0) {
+                var e = this.getChild();
+                if (e.updateBounds(!0), this.rect.x = e.getLeft(), this.rect.y = e.getTop(), this.setWidth(e.getRight() - e.getLeft()), this.setHeight(e.getBottom() - e.getTop()), i.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                  var s = e.getRight() - e.getLeft(), a = e.getBottom() - e.getTop();
+                  this.labelWidth && (this.labelPosHorizontal == "left" ? (this.rect.x -= this.labelWidth, this.setWidth(s + this.labelWidth)) : this.labelPosHorizontal == "center" && this.labelWidth > s ? (this.rect.x -= (this.labelWidth - s) / 2, this.setWidth(this.labelWidth)) : this.labelPosHorizontal == "right" && this.setWidth(s + this.labelWidth)), this.labelHeight && (this.labelPosVertical == "top" ? (this.rect.y -= this.labelHeight, this.setHeight(a + this.labelHeight)) : this.labelPosVertical == "center" && this.labelHeight > a ? (this.rect.y -= (this.labelHeight - a) / 2, this.setHeight(this.labelHeight)) : this.labelPosVertical == "bottom" && this.setHeight(a + this.labelHeight));
+                }
+              }
+            }, r.prototype.getInclusionTreeDepth = function() {
+              if (this.inclusionTreeDepth == l.MAX_VALUE)
+                throw "assert failed";
+              return this.inclusionTreeDepth;
+            }, r.prototype.transform = function(e) {
+              var s = this.rect.x;
+              s > i.WORLD_BOUNDARY ? s = i.WORLD_BOUNDARY : s < -i.WORLD_BOUNDARY && (s = -i.WORLD_BOUNDARY);
+              var a = this.rect.y;
+              a > i.WORLD_BOUNDARY ? a = i.WORLD_BOUNDARY : a < -i.WORLD_BOUNDARY && (a = -i.WORLD_BOUNDARY);
+              var g = new h(s, a), c = e.inverseTransformPoint(g);
+              this.setLocation(c.x, c.y);
+            }, r.prototype.getLeft = function() {
+              return this.rect.x;
+            }, r.prototype.getRight = function() {
+              return this.rect.x + this.rect.width;
+            }, r.prototype.getTop = function() {
+              return this.rect.y;
+            }, r.prototype.getBottom = function() {
+              return this.rect.y + this.rect.height;
+            }, r.prototype.getParent = function() {
+              return this.owner == null ? null : this.owner.getParent();
+            }, L.exports = r;
+          },
+          /* 4 */
+          /***/
+          function(L, U, T) {
+            var u = T(0);
+            function l() {
+            }
+            for (var o in u)
+              l[o] = u[o];
+            l.MAX_ITERATIONS = 2500, l.DEFAULT_EDGE_LENGTH = 50, l.DEFAULT_SPRING_STRENGTH = 0.45, l.DEFAULT_REPULSION_STRENGTH = 4500, l.DEFAULT_GRAVITY_STRENGTH = 0.4, l.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1, l.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8, l.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5, l.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = !0, l.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = !0, l.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3, l.COOLING_ADAPTATION_FACTOR = 0.33, l.ADAPTATION_LOWER_NODE_LIMIT = 1e3, l.ADAPTATION_UPPER_NODE_LIMIT = 5e3, l.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100, l.MAX_NODE_DISPLACEMENT = l.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3, l.MIN_REPULSION_DIST = l.DEFAULT_EDGE_LENGTH / 10, l.CONVERGENCE_CHECK_PERIOD = 100, l.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1, l.MIN_EDGE_LENGTH = 1, l.GRID_CALCULATION_CHECK_PERIOD = 10, L.exports = l;
+          },
+          /* 5 */
+          /***/
+          function(L, U, T) {
+            function u(l, o) {
+              l == null && o == null ? (this.x = 0, this.y = 0) : (this.x = l, this.y = o);
+            }
+            u.prototype.getX = function() {
+              return this.x;
+            }, u.prototype.getY = function() {
+              return this.y;
+            }, u.prototype.setX = function(l) {
+              this.x = l;
+            }, u.prototype.setY = function(l) {
+              this.y = l;
+            }, u.prototype.getDifference = function(l) {
+              return new DimensionD(this.x - l.x, this.y - l.y);
+            }, u.prototype.getCopy = function() {
+              return new u(this.x, this.y);
+            }, u.prototype.translate = function(l) {
+              return this.x += l.width, this.y += l.height, this;
+            }, L.exports = u;
+          },
+          /* 6 */
+          /***/
+          function(L, U, T) {
+            var u = T(2), l = T(10), o = T(0), i = T(7), t = T(3), h = T(1), r = T(13), f = T(12), e = T(11);
+            function s(g, c, N) {
+              u.call(this, N), this.estimatedSize = l.MIN_VALUE, this.margin = o.DEFAULT_GRAPH_MARGIN, this.edges = [], this.nodes = [], this.isConnected = !1, this.parent = g, c != null && c instanceof i ? this.graphManager = c : c != null && c instanceof Layout && (this.graphManager = c.graphManager);
+            }
+            s.prototype = Object.create(u.prototype);
+            for (var a in u)
+              s[a] = u[a];
+            s.prototype.getNodes = function() {
+              return this.nodes;
+            }, s.prototype.getEdges = function() {
+              return this.edges;
+            }, s.prototype.getGraphManager = function() {
+              return this.graphManager;
+            }, s.prototype.getParent = function() {
+              return this.parent;
+            }, s.prototype.getLeft = function() {
+              return this.left;
+            }, s.prototype.getRight = function() {
+              return this.right;
+            }, s.prototype.getTop = function() {
+              return this.top;
+            }, s.prototype.getBottom = function() {
+              return this.bottom;
+            }, s.prototype.isConnected = function() {
+              return this.isConnected;
+            }, s.prototype.add = function(g, c, N) {
+              if (c == null && N == null) {
+                var d = g;
+                if (this.graphManager == null)
+                  throw "Graph has no graph mgr!";
+                if (this.getNodes().indexOf(d) > -1)
+                  throw "Node already in graph!";
+                return d.owner = this, this.getNodes().push(d), d;
+              } else {
+                var y = g;
+                if (!(this.getNodes().indexOf(c) > -1 && this.getNodes().indexOf(N) > -1))
+                  throw "Source or target not in graph!";
+                if (!(c.owner == N.owner && c.owner == this))
+                  throw "Both owners must be this graph!";
+                return c.owner != N.owner ? null : (y.source = c, y.target = N, y.isInterGraph = !1, this.getEdges().push(y), c.edges.push(y), N != c && N.edges.push(y), y);
+              }
+            }, s.prototype.remove = function(g) {
+              var c = g;
+              if (g instanceof t) {
+                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 N = c.edges.slice(), d, y = N.length, w = 0; w < y; w++)
+                  d = N[w], d.isInterGraph ? this.graphManager.remove(d) : d.source.owner.remove(d);
+                var M = this.nodes.indexOf(c);
+                if (M == -1)
+                  throw "Node not in owner node list!";
+                this.nodes.splice(M, 1);
+              } else if (g instanceof h) {
+                var d = g;
+                if (d == null)
+                  throw "Edge is null!";
+                if (!(d.source != null && d.target != null))
+                  throw "Source and/or target is null!";
+                if (!(d.source.owner != null && d.target.owner != null && d.source.owner == this && d.target.owner == this))
+                  throw "Source and/or target owner is invalid!";
+                var P = d.source.edges.indexOf(d), S = d.target.edges.indexOf(d);
+                if (!(P > -1 && S > -1))
+                  throw "Source and/or target doesn't know this edge!";
+                d.source.edges.splice(P, 1), d.target != d.source && d.target.edges.splice(S, 1);
+                var M = d.source.owner.getEdges().indexOf(d);
+                if (M == -1)
+                  throw "Not in owner's edge list!";
+                d.source.owner.getEdges().splice(M, 1);
+              }
+            }, s.prototype.updateLeftTop = function() {
+              for (var g = l.MAX_VALUE, c = l.MAX_VALUE, N, d, y, w = this.getNodes(), M = w.length, P = 0; P < M; P++) {
+                var S = w[P];
+                N = S.getTop(), d = S.getLeft(), g > N && (g = N), c > d && (c = d);
+              }
+              return g == l.MAX_VALUE ? null : (w[0].getParent().paddingLeft != null ? y = w[0].getParent().paddingLeft : y = this.margin, this.left = c - y, this.top = g - y, new f(this.left, this.top));
+            }, s.prototype.updateBounds = function(g) {
+              for (var c = l.MAX_VALUE, N = -l.MAX_VALUE, d = l.MAX_VALUE, y = -l.MAX_VALUE, w, M, P, S, Y, W = this.nodes, B = W.length, x = 0; x < B; x++) {
+                var nt = W[x];
+                g && nt.child != null && nt.updateBounds(), w = nt.getLeft(), M = nt.getRight(), P = nt.getTop(), S = nt.getBottom(), c > w && (c = w), N < M && (N = M), d > P && (d = P), y < S && (y = S);
+              }
+              var n = new r(c, d, N - c, y - d);
+              c == l.MAX_VALUE && (this.left = this.parent.getLeft(), this.right = this.parent.getRight(), this.top = this.parent.getTop(), this.bottom = this.parent.getBottom()), W[0].getParent().paddingLeft != null ? Y = W[0].getParent().paddingLeft : Y = this.margin, this.left = n.x - Y, this.right = n.x + n.width + Y, this.top = n.y - Y, this.bottom = n.y + n.height + Y;
+            }, s.calculateBounds = function(g) {
+              for (var c = l.MAX_VALUE, N = -l.MAX_VALUE, d = l.MAX_VALUE, y = -l.MAX_VALUE, w, M, P, S, Y = g.length, W = 0; W < Y; W++) {
+                var B = g[W];
+                w = B.getLeft(), M = B.getRight(), P = B.getTop(), S = B.getBottom(), c > w && (c = w), N < M && (N = M), d > P && (d = P), y < S && (y = S);
+              }
+              var x = new r(c, d, N - c, y - d);
+              return x;
+            }, s.prototype.getInclusionTreeDepth = function() {
+              return this == this.graphManager.getRoot() ? 1 : this.parent.getInclusionTreeDepth();
+            }, s.prototype.getEstimatedSize = function() {
+              if (this.estimatedSize == l.MIN_VALUE)
+                throw "assert failed";
+              return this.estimatedSize;
+            }, s.prototype.calcEstimatedSize = function() {
+              for (var g = 0, c = this.nodes, N = c.length, d = 0; d < N; d++) {
+                var y = c[d];
+                g += y.calcEstimatedSize();
+              }
+              return g == 0 ? this.estimatedSize = o.EMPTY_COMPOUND_NODE_SIZE : this.estimatedSize = g / Math.sqrt(this.nodes.length), this.estimatedSize;
+            }, s.prototype.updateConnected = function() {
+              var g = this;
+              if (this.nodes.length == 0) {
+                this.isConnected = !0;
+                return;
+              }
+              var c = new e(), N = /* @__PURE__ */ new Set(), d = this.nodes[0], y, w, M = d.withChildren();
+              for (M.forEach(function(x) {
+                c.push(x), N.add(x);
+              }); c.length !== 0; ) {
+                d = c.shift(), y = d.getEdges();
+                for (var P = y.length, S = 0; S < P; S++) {
+                  var Y = y[S];
+                  if (w = Y.getOtherEndInGraph(d, this), w != null && !N.has(w)) {
+                    var W = w.withChildren();
+                    W.forEach(function(x) {
+                      c.push(x), N.add(x);
+                    });
+                  }
+                }
+              }
+              if (this.isConnected = !1, N.size >= this.nodes.length) {
+                var B = 0;
+                N.forEach(function(x) {
+                  x.owner == g && B++;
+                }), B == this.nodes.length && (this.isConnected = !0);
+              }
+            }, L.exports = s;
+          },
+          /* 7 */
+          /***/
+          function(L, U, T) {
+            var u, l = T(1);
+            function o(i) {
+              u = T(6), this.layout = i, this.graphs = [], this.edges = [];
+            }
+            o.prototype.addRoot = function() {
+              var i = this.layout.newGraph(), t = this.layout.newNode(null), h = this.add(i, t);
+              return this.setRootGraph(h), this.rootGraph;
+            }, o.prototype.add = function(i, t, h, r, f) {
+              if (h == null && r == null && f == null) {
+                if (i == null)
+                  throw "Graph is null!";
+                if (t == null)
+                  throw "Parent node is null!";
+                if (this.graphs.indexOf(i) > -1)
+                  throw "Graph already in this graph mgr!";
+                if (this.graphs.push(i), i.parent != null)
+                  throw "Already has a parent!";
+                if (t.child != null)
+                  throw "Already has a child!";
+                return i.parent = t, t.child = i, i;
+              } else {
+                f = h, r = t, h = i;
+                var e = r.getOwner(), s = f.getOwner();
+                if (!(e != null && e.getGraphManager() == this))
+                  throw "Source not in this graph mgr!";
+                if (!(s != null && s.getGraphManager() == this))
+                  throw "Target not in this graph mgr!";
+                if (e == s)
+                  return h.isInterGraph = !1, e.add(h, r, f);
+                if (h.isInterGraph = !0, h.source = r, h.target = f, this.edges.indexOf(h) > -1)
+                  throw "Edge already in inter-graph edge list!";
+                if (this.edges.push(h), !(h.source != null && h.target != null))
+                  throw "Edge source and/or target is null!";
+                if (!(h.source.edges.indexOf(h) == -1 && h.target.edges.indexOf(h) == -1))
+                  throw "Edge already in source and/or target incidency list!";
+                return h.source.edges.push(h), h.target.edges.push(h), h;
+              }
+            }, o.prototype.remove = function(i) {
+              if (i instanceof u) {
+                var t = i;
+                if (t.getGraphManager() != this)
+                  throw "Graph not in this graph mgr";
+                if (!(t == this.rootGraph || t.parent != null && t.parent.graphManager == this))
+                  throw "Invalid parent node!";
+                var h = [];
+                h = h.concat(t.getEdges());
+                for (var r, f = h.length, e = 0; e < f; e++)
+                  r = h[e], t.remove(r);
+                var s = [];
+                s = s.concat(t.getNodes());
+                var a;
+                f = s.length;
+                for (var e = 0; e < f; e++)
+                  a = s[e], t.remove(a);
+                t == this.rootGraph && this.setRootGraph(null);
+                var g = this.graphs.indexOf(t);
+                this.graphs.splice(g, 1), t.parent = null;
+              } else if (i instanceof l) {
+                if (r = i, r == null)
+                  throw "Edge is null!";
+                if (!r.isInterGraph)
+                  throw "Not an inter-graph edge!";
+                if (!(r.source != null && r.target != null))
+                  throw "Source and/or target is null!";
+                if (!(r.source.edges.indexOf(r) != -1 && r.target.edges.indexOf(r) != -1))
+                  throw "Source and/or target doesn't know this edge!";
+                var g = r.source.edges.indexOf(r);
+                if (r.source.edges.splice(g, 1), g = r.target.edges.indexOf(r), r.target.edges.splice(g, 1), !(r.source.owner != null && r.source.owner.getGraphManager() != null))
+                  throw "Edge owner graph or owner graph manager is null!";
+                if (r.source.owner.getGraphManager().edges.indexOf(r) == -1)
+                  throw "Not in owner graph manager's edge list!";
+                var g = r.source.owner.getGraphManager().edges.indexOf(r);
+                r.source.owner.getGraphManager().edges.splice(g, 1);
+              }
+            }, o.prototype.updateBounds = function() {
+              this.rootGraph.updateBounds(!0);
+            }, o.prototype.getGraphs = function() {
+              return this.graphs;
+            }, o.prototype.getAllNodes = function() {
+              if (this.allNodes == null) {
+                for (var i = [], t = this.getGraphs(), h = t.length, r = 0; r < h; r++)
+                  i = i.concat(t[r].getNodes());
+                this.allNodes = i;
+              }
+              return this.allNodes;
+            }, o.prototype.resetAllNodes = function() {
+              this.allNodes = null;
+            }, o.prototype.resetAllEdges = function() {
+              this.allEdges = null;
+            }, o.prototype.resetAllNodesToApplyGravitation = function() {
+              this.allNodesToApplyGravitation = null;
+            }, o.prototype.getAllEdges = function() {
+              if (this.allEdges == null) {
+                var i = [], t = this.getGraphs();
+                t.length;
+                for (var h = 0; h < t.length; h++)
+                  i = i.concat(t[h].getEdges());
+                i = i.concat(this.edges), this.allEdges = i;
+              }
+              return this.allEdges;
+            }, o.prototype.getAllNodesToApplyGravitation = function() {
+              return this.allNodesToApplyGravitation;
+            }, o.prototype.setAllNodesToApplyGravitation = function(i) {
+              if (this.allNodesToApplyGravitation != null)
+                throw "assert failed";
+              this.allNodesToApplyGravitation = i;
+            }, o.prototype.getRoot = function() {
+              return this.rootGraph;
+            }, o.prototype.setRootGraph = function(i) {
+              if (i.getGraphManager() != this)
+                throw "Root not in this graph mgr!";
+              this.rootGraph = i, i.parent == null && (i.parent = this.layout.newNode("Root node"));
+            }, o.prototype.getLayout = function() {
+              return this.layout;
+            }, o.prototype.isOneAncestorOfOther = function(i, t) {
+              if (!(i != null && t != null))
+                throw "assert failed";
+              if (i == t)
+                return !0;
+              var h = i.getOwner(), r;
+              do {
+                if (r = h.getParent(), r == null)
+                  break;
+                if (r == t)
+                  return !0;
+                if (h = r.getOwner(), h == null)
+                  break;
+              } while (!0);
+              h = t.getOwner();
+              do {
+                if (r = h.getParent(), r == null)
+                  break;
+                if (r == i)
+                  return !0;
+                if (h = r.getOwner(), h == null)
+                  break;
+              } while (!0);
+              return !1;
+            }, o.prototype.calcLowestCommonAncestors = function() {
+              for (var i, t, h, r, f, e = this.getAllEdges(), s = e.length, a = 0; a < s; a++) {
+                if (i = e[a], t = i.source, h = i.target, i.lca = null, i.sourceInLca = t, i.targetInLca = h, t == h) {
+                  i.lca = t.getOwner();
+                  continue;
+                }
+                for (r = t.getOwner(); i.lca == null; ) {
+                  for (i.targetInLca = h, f = h.getOwner(); i.lca == null; ) {
+                    if (f == r) {
+                      i.lca = f;
+                      break;
+                    }
+                    if (f == this.rootGraph)
+                      break;
+                    if (i.lca != null)
+                      throw "assert failed";
+                    i.targetInLca = f.getParent(), f = i.targetInLca.getOwner();
+                  }
+                  if (r == this.rootGraph)
+                    break;
+                  i.lca == null && (i.sourceInLca = r.getParent(), r = i.sourceInLca.getOwner());
+                }
+                if (i.lca == null)
+                  throw "assert failed";
+              }
+            }, o.prototype.calcLowestCommonAncestor = function(i, t) {
+              if (i == t)
+                return i.getOwner();
+              var h = i.getOwner();
+              do {
+                if (h == null)
+                  break;
+                var r = t.getOwner();
+                do {
+                  if (r == null)
+                    break;
+                  if (r == h)
+                    return r;
+                  r = r.getParent().getOwner();
+                } while (!0);
+                h = h.getParent().getOwner();
+              } while (!0);
+              return h;
+            }, o.prototype.calcInclusionTreeDepths = function(i, t) {
+              i == null && t == null && (i = this.rootGraph, t = 1);
+              for (var h, r = i.getNodes(), f = r.length, e = 0; e < f; e++)
+                h = r[e], h.inclusionTreeDepth = t, h.child != null && this.calcInclusionTreeDepths(h.child, t + 1);
+            }, o.prototype.includesInvalidEdge = function() {
+              for (var i, t = [], h = this.edges.length, r = 0; r < h; r++)
+                i = this.edges[r], this.isOneAncestorOfOther(i.source, i.target) && t.push(i);
+              for (var r = 0; r < t.length; r++)
+                this.remove(t[r]);
+              return !1;
+            }, L.exports = o;
+          },
+          /* 8 */
+          /***/
+          function(L, U, T) {
+            var u = T(12);
+            function l() {
+            }
+            l.calcSeparationAmount = function(o, i, t, h) {
+              if (!o.intersects(i))
+                throw "assert failed";
+              var r = new Array(2);
+              this.decideDirectionsForOverlappingNodes(o, i, r), t[0] = Math.min(o.getRight(), i.getRight()) - Math.max(o.x, i.x), t[1] = Math.min(o.getBottom(), i.getBottom()) - Math.max(o.y, i.y), o.getX() <= i.getX() && o.getRight() >= i.getRight() ? t[0] += Math.min(i.getX() - o.getX(), o.getRight() - i.getRight()) : i.getX() <= o.getX() && i.getRight() >= o.getRight() && (t[0] += Math.min(o.getX() - i.getX(), i.getRight() - o.getRight())), o.getY() <= i.getY() && o.getBottom() >= i.getBottom() ? t[1] += Math.min(i.getY() - o.getY(), o.getBottom() - i.getBottom()) : i.getY() <= o.getY() && i.getBottom() >= o.getBottom() && (t[1] += Math.min(o.getY() - i.getY(), i.getBottom() - o.getBottom()));
+              var f = Math.abs((i.getCenterY() - o.getCenterY()) / (i.getCenterX() - o.getCenterX()));
+              i.getCenterY() === o.getCenterY() && i.getCenterX() === o.getCenterX() && (f = 1);
+              var e = f * t[0], s = t[1] / f;
+              t[0] < s ? s = t[0] : e = t[1], t[0] = -1 * r[0] * (s / 2 + h), t[1] = -1 * r[1] * (e / 2 + h);
+            }, l.decideDirectionsForOverlappingNodes = function(o, i, t) {
+              o.getCenterX() < i.getCenterX() ? t[0] = -1 : t[0] = 1, o.getCenterY() < i.getCenterY() ? t[1] = -1 : t[1] = 1;
+            }, l.getIntersection2 = function(o, i, t) {
+              var h = o.getCenterX(), r = o.getCenterY(), f = i.getCenterX(), e = i.getCenterY();
+              if (o.intersects(i))
+                return t[0] = h, t[1] = r, t[2] = f, t[3] = e, !0;
+              var s = o.getX(), a = o.getY(), g = o.getRight(), c = o.getX(), N = o.getBottom(), d = o.getRight(), y = o.getWidthHalf(), w = o.getHeightHalf(), M = i.getX(), P = i.getY(), S = i.getRight(), Y = i.getX(), W = i.getBottom(), B = i.getRight(), x = i.getWidthHalf(), nt = i.getHeightHalf(), n = !1, E = !1;
+              if (h === f) {
+                if (r > e)
+                  return t[0] = h, t[1] = a, t[2] = f, t[3] = W, !1;
+                if (r < e)
+                  return t[0] = h, t[1] = N, t[2] = f, t[3] = P, !1;
+              } else if (r === e) {
+                if (h > f)
+                  return t[0] = s, t[1] = r, t[2] = S, t[3] = e, !1;
+                if (h < f)
+                  return t[0] = g, t[1] = r, t[2] = M, t[3] = e, !1;
+              } else {
+                var p = o.height / o.width, v = i.height / i.width, m = (e - r) / (f - h), O = void 0, _ = void 0, C = void 0, F = void 0, k = void 0, V = void 0;
+                if (-p === m ? h > f ? (t[0] = c, t[1] = N, n = !0) : (t[0] = g, t[1] = a, n = !0) : p === m && (h > f ? (t[0] = s, t[1] = a, n = !0) : (t[0] = d, t[1] = N, n = !0)), -v === m ? f > h ? (t[2] = Y, t[3] = W, E = !0) : (t[2] = S, t[3] = P, E = !0) : v === m && (f > h ? (t[2] = M, t[3] = P, E = !0) : (t[2] = B, t[3] = W, E = !0)), n && E)
+                  return !1;
+                if (h > f ? r > e ? (O = this.getCardinalDirection(p, m, 4), _ = this.getCardinalDirection(v, m, 2)) : (O = this.getCardinalDirection(-p, m, 3), _ = this.getCardinalDirection(-v, m, 1)) : r > e ? (O = this.getCardinalDirection(-p, m, 1), _ = this.getCardinalDirection(-v, m, 3)) : (O = this.getCardinalDirection(p, m, 2), _ = this.getCardinalDirection(v, m, 4)), !n)
+                  switch (O) {
+                    case 1:
+                      F = a, C = h + -w / m, t[0] = C, t[1] = F;
+                      break;
+                    case 2:
+                      C = d, F = r + y * m, t[0] = C, t[1] = F;
+                      break;
+                    case 3:
+                      F = N, C = h + w / m, t[0] = C, t[1] = F;
+                      break;
+                    case 4:
+                      C = c, F = r + -y * m, t[0] = C, t[1] = F;
+                      break;
+                  }
+                if (!E)
+                  switch (_) {
+                    case 1:
+                      V = P, k = f + -nt / m, t[2] = k, t[3] = V;
+                      break;
+                    case 2:
+                      k = B, V = e + x * m, t[2] = k, t[3] = V;
+                      break;
+                    case 3:
+                      V = W, k = f + nt / m, t[2] = k, t[3] = V;
+                      break;
+                    case 4:
+                      k = Y, V = e + -x * m, t[2] = k, t[3] = V;
+                      break;
+                  }
+              }
+              return !1;
+            }, l.getCardinalDirection = function(o, i, t) {
+              return o > i ? t : 1 + t % 4;
+            }, l.getIntersection = function(o, i, t, h) {
+              if (h == null)
+                return this.getIntersection2(o, i, t);
+              var r = o.x, f = o.y, e = i.x, s = i.y, a = t.x, g = t.y, c = h.x, N = h.y, d = void 0, y = void 0, w = void 0, M = void 0, P = void 0, S = void 0, Y = void 0, W = void 0, B = void 0;
+              return w = s - f, P = r - e, Y = e * f - r * s, M = N - g, S = a - c, W = c * g - a * N, B = w * S - M * P, B === 0 ? null : (d = (P * W - S * Y) / B, y = (M * Y - w * W) / B, new u(d, y));
+            }, l.angleOfVector = function(o, i, t, h) {
+              var r = void 0;
+              return o !== t ? (r = Math.atan((h - i) / (t - o)), t < o ? r += Math.PI : h < i && (r += this.TWO_PI)) : h < i ? r = this.ONE_AND_HALF_PI : r = this.HALF_PI, r;
+            }, l.doIntersect = function(o, i, t, h) {
+              var r = o.x, f = o.y, e = i.x, s = i.y, a = t.x, g = t.y, c = h.x, N = h.y, d = (e - r) * (N - g) - (c - a) * (s - f);
+              if (d === 0)
+                return !1;
+              var y = ((N - g) * (c - r) + (a - c) * (N - f)) / d, w = ((f - s) * (c - r) + (e - r) * (N - f)) / d;
+              return 0 < y && y < 1 && 0 < w && w < 1;
+            }, l.findCircleLineIntersections = function(o, i, t, h, r, f, e) {
+              var s = (t - o) * (t - o) + (h - i) * (h - i), a = 2 * ((o - r) * (t - o) + (i - f) * (h - i)), g = (o - r) * (o - r) + (i - f) * (i - f) - e * e, c = a * a - 4 * s * g;
+              if (c >= 0) {
+                var N = (-a + Math.sqrt(a * a - 4 * s * g)) / (2 * s), d = (-a - Math.sqrt(a * a - 4 * s * g)) / (2 * s), y = null;
+                return N >= 0 && N <= 1 ? [N] : d >= 0 && d <= 1 ? [d] : y;
+              } else
+                return null;
+            }, l.HALF_PI = 0.5 * Math.PI, l.ONE_AND_HALF_PI = 1.5 * Math.PI, l.TWO_PI = 2 * Math.PI, l.THREE_PI = 3 * Math.PI, L.exports = l;
+          },
+          /* 9 */
+          /***/
+          function(L, U, T) {
+            function u() {
+            }
+            u.sign = function(l) {
+              return l > 0 ? 1 : l < 0 ? -1 : 0;
+            }, u.floor = function(l) {
+              return l < 0 ? Math.ceil(l) : Math.floor(l);
+            }, u.ceil = function(l) {
+              return l < 0 ? Math.floor(l) : Math.ceil(l);
+            }, L.exports = u;
+          },
+          /* 10 */
+          /***/
+          function(L, U, T) {
+            function u() {
+            }
+            u.MAX_VALUE = 2147483647, u.MIN_VALUE = -2147483648, L.exports = u;
+          },
+          /* 11 */
+          /***/
+          function(L, U, T) {
+            var u = /* @__PURE__ */ function() {
+              function r(f, e) {
+                for (var s = 0; s < e.length; s++) {
+                  var a = e[s];
+                  a.enumerable = a.enumerable || !1, a.configurable = !0, "value" in a && (a.writable = !0), Object.defineProperty(f, a.key, a);
+                }
+              }
+              return function(f, e, s) {
+                return e && r(f.prototype, e), s && r(f, s), f;
+              };
+            }();
+            function l(r, f) {
+              if (!(r instanceof f))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            var o = function(r) {
+              return { value: r, next: null, prev: null };
+            }, i = function(r, f, e, s) {
+              return r !== null ? r.next = f : s.head = f, e !== null ? e.prev = f : s.tail = f, f.prev = r, f.next = e, s.length++, f;
+            }, t = function(r, f) {
+              var e = r.prev, s = r.next;
+              return e !== null ? e.next = s : f.head = s, s !== null ? s.prev = e : f.tail = e, r.prev = r.next = null, f.length--, r;
+            }, h = function() {
+              function r(f) {
+                var e = this;
+                l(this, r), this.length = 0, this.head = null, this.tail = null, f != null && f.forEach(function(s) {
+                  return e.push(s);
+                });
+              }
+              return u(r, [{
+                key: "size",
+                value: function() {
+                  return this.length;
+                }
+              }, {
+                key: "insertBefore",
+                value: function(f, e) {
+                  return i(e.prev, o(f), e, this);
+                }
+              }, {
+                key: "insertAfter",
+                value: function(f, e) {
+                  return i(e, o(f), e.next, this);
+                }
+              }, {
+                key: "insertNodeBefore",
+                value: function(f, e) {
+                  return i(e.prev, f, e, this);
+                }
+              }, {
+                key: "insertNodeAfter",
+                value: function(f, e) {
+                  return i(e, f, e.next, this);
+                }
+              }, {
+                key: "push",
+                value: function(f) {
+                  return i(this.tail, o(f), null, this);
+                }
+              }, {
+                key: "unshift",
+                value: function(f) {
+                  return i(null, o(f), this.head, this);
+                }
+              }, {
+                key: "remove",
+                value: function(f) {
+                  return t(f, this);
+                }
+              }, {
+                key: "pop",
+                value: function() {
+                  return t(this.tail, this).value;
+                }
+              }, {
+                key: "popNode",
+                value: function() {
+                  return t(this.tail, this);
+                }
+              }, {
+                key: "shift",
+                value: function() {
+                  return t(this.head, this).value;
+                }
+              }, {
+                key: "shiftNode",
+                value: function() {
+                  return t(this.head, this);
+                }
+              }, {
+                key: "get_object_at",
+                value: function(f) {
+                  if (f <= this.length()) {
+                    for (var e = 1, s = this.head; e < f; )
+                      s = s.next, e++;
+                    return s.value;
+                  }
+                }
+              }, {
+                key: "set_object_at",
+                value: function(f, e) {
+                  if (f <= this.length()) {
+                    for (var s = 1, a = this.head; s < f; )
+                      a = a.next, s++;
+                    a.value = e;
+                  }
+                }
+              }]), r;
+            }();
+            L.exports = h;
+          },
+          /* 12 */
+          /***/
+          function(L, U, T) {
+            function u(l, o, i) {
+              this.x = null, this.y = null, l == null && o == null && i == null ? (this.x = 0, this.y = 0) : typeof l == "number" && typeof o == "number" && i == null ? (this.x = l, this.y = o) : l.constructor.name == "Point" && o == null && i == null && (i = l, this.x = i.x, this.y = i.y);
+            }
+            u.prototype.getX = function() {
+              return this.x;
+            }, u.prototype.getY = function() {
+              return this.y;
+            }, u.prototype.getLocation = function() {
+              return new u(this.x, this.y);
+            }, u.prototype.setLocation = function(l, o, i) {
+              l.constructor.name == "Point" && o == null && i == null ? (i = l, this.setLocation(i.x, i.y)) : typeof l == "number" && typeof o == "number" && i == null && (parseInt(l) == l && parseInt(o) == o ? this.move(l, o) : (this.x = Math.floor(l + 0.5), this.y = Math.floor(o + 0.5)));
+            }, u.prototype.move = function(l, o) {
+              this.x = l, this.y = o;
+            }, u.prototype.translate = function(l, o) {
+              this.x += l, this.y += o;
+            }, u.prototype.equals = function(l) {
+              if (l.constructor.name == "Point") {
+                var o = l;
+                return this.x == o.x && this.y == o.y;
+              }
+              return this == l;
+            }, u.prototype.toString = function() {
+              return new u().constructor.name + "[x=" + this.x + ",y=" + this.y + "]";
+            }, L.exports = u;
+          },
+          /* 13 */
+          /***/
+          function(L, U, T) {
+            function u(l, o, i, t) {
+              this.x = 0, this.y = 0, this.width = 0, this.height = 0, l != null && o != null && i != null && t != null && (this.x = l, this.y = o, this.width = i, this.height = t);
+            }
+            u.prototype.getX = function() {
+              return this.x;
+            }, u.prototype.setX = function(l) {
+              this.x = l;
+            }, u.prototype.getY = function() {
+              return this.y;
+            }, u.prototype.setY = function(l) {
+              this.y = l;
+            }, u.prototype.getWidth = function() {
+              return this.width;
+            }, u.prototype.setWidth = function(l) {
+              this.width = l;
+            }, u.prototype.getHeight = function() {
+              return this.height;
+            }, u.prototype.setHeight = function(l) {
+              this.height = l;
+            }, u.prototype.getRight = function() {
+              return this.x + this.width;
+            }, u.prototype.getBottom = function() {
+              return this.y + this.height;
+            }, u.prototype.intersects = function(l) {
+              return !(this.getRight() < l.x || this.getBottom() < l.y || l.getRight() < this.x || l.getBottom() < this.y);
+            }, u.prototype.getCenterX = function() {
+              return this.x + this.width / 2;
+            }, u.prototype.getMinX = function() {
+              return this.getX();
+            }, u.prototype.getMaxX = function() {
+              return this.getX() + this.width;
+            }, u.prototype.getCenterY = function() {
+              return this.y + this.height / 2;
+            }, u.prototype.getMinY = function() {
+              return this.getY();
+            }, u.prototype.getMaxY = function() {
+              return this.getY() + this.height;
+            }, u.prototype.getWidthHalf = function() {
+              return this.width / 2;
+            }, u.prototype.getHeightHalf = function() {
+              return this.height / 2;
+            }, L.exports = u;
+          },
+          /* 14 */
+          /***/
+          function(L, U, T) {
+            var u = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+              return typeof o;
+            } : function(o) {
+              return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+            };
+            function l() {
+            }
+            l.lastID = 0, l.createID = function(o) {
+              return l.isPrimitive(o) ? o : (o.uniqueID != null || (o.uniqueID = l.getString(), l.lastID++), o.uniqueID);
+            }, l.getString = function(o) {
+              return o == null && (o = l.lastID), "Object#" + o;
+            }, l.isPrimitive = function(o) {
+              var i = typeof o > "u" ? "undefined" : u(o);
+              return o == null || i != "object" && i != "function";
+            }, L.exports = l;
+          },
+          /* 15 */
+          /***/
+          function(L, U, T) {
+            function u(a) {
+              if (Array.isArray(a)) {
+                for (var g = 0, c = Array(a.length); g < a.length; g++)
+                  c[g] = a[g];
+                return c;
+              } else
+                return Array.from(a);
+            }
+            var l = T(0), o = T(7), i = T(3), t = T(1), h = T(6), r = T(5), f = T(17), e = T(29);
+            function s(a) {
+              e.call(this), this.layoutQuality = l.QUALITY, this.createBendsAsNeeded = l.DEFAULT_CREATE_BENDS_AS_NEEDED, this.incremental = l.DEFAULT_INCREMENTAL, this.animationOnLayout = l.DEFAULT_ANIMATION_ON_LAYOUT, this.animationDuringLayout = l.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = l.DEFAULT_ANIMATION_PERIOD, this.uniformLeafNodeSizes = l.DEFAULT_UNIFORM_LEAF_NODE_SIZES, this.edgeToDummyNodes = /* @__PURE__ */ new Map(), this.graphManager = new o(this), this.isLayoutFinished = !1, this.isSubLayout = !1, this.isRemoteUse = !1, a != null && (this.isRemoteUse = a);
+            }
+            s.RANDOM_SEED = 1, s.prototype = Object.create(e.prototype), s.prototype.getGraphManager = function() {
+              return this.graphManager;
+            }, s.prototype.getAllNodes = function() {
+              return this.graphManager.getAllNodes();
+            }, s.prototype.getAllEdges = function() {
+              return this.graphManager.getAllEdges();
+            }, s.prototype.getAllNodesToApplyGravitation = function() {
+              return this.graphManager.getAllNodesToApplyGravitation();
+            }, s.prototype.newGraphManager = function() {
+              var a = new o(this);
+              return this.graphManager = a, a;
+            }, s.prototype.newGraph = function(a) {
+              return new h(null, this.graphManager, a);
+            }, s.prototype.newNode = function(a) {
+              return new i(this.graphManager, a);
+            }, s.prototype.newEdge = function(a) {
+              return new t(null, null, a);
+            }, s.prototype.checkLayoutSuccess = function() {
+              return this.graphManager.getRoot() == null || this.graphManager.getRoot().getNodes().length == 0 || this.graphManager.includesInvalidEdge();
+            }, s.prototype.runLayout = function() {
+              this.isLayoutFinished = !1, this.tilingPreLayout && this.tilingPreLayout(), this.initParameters();
+              var a;
+              return this.checkLayoutSuccess() ? a = !1 : a = this.layout(), l.ANIMATE === "during" ? !1 : (a && (this.isSubLayout || this.doPostLayout()), this.tilingPostLayout && this.tilingPostLayout(), this.isLayoutFinished = !0, a);
+            }, s.prototype.doPostLayout = function() {
+              this.incremental || this.transform(), this.update();
+            }, s.prototype.update2 = function() {
+              if (this.createBendsAsNeeded && (this.createBendpointsFromDummyNodes(), this.graphManager.resetAllEdges()), !this.isRemoteUse) {
+                for (var a = this.graphManager.getAllEdges(), g = 0; g < a.length; g++)
+                  a[g];
+                for (var c = this.graphManager.getRoot().getNodes(), g = 0; g < c.length; g++)
+                  c[g];
+                this.update(this.graphManager.getRoot());
+              }
+            }, s.prototype.update = function(a) {
+              if (a == null)
+                this.update2();
+              else if (a instanceof i) {
+                var g = a;
+                if (g.getChild() != null)
+                  for (var c = g.getChild().getNodes(), N = 0; N < c.length; N++)
+                    update(c[N]);
+                if (g.vGraphObject != null) {
+                  var d = g.vGraphObject;
+                  d.update(g);
+                }
+              } else if (a instanceof t) {
+                var y = a;
+                if (y.vGraphObject != null) {
+                  var w = y.vGraphObject;
+                  w.update(y);
+                }
+              } else if (a instanceof h) {
+                var M = a;
+                if (M.vGraphObject != null) {
+                  var P = M.vGraphObject;
+                  P.update(M);
+                }
+              }
+            }, s.prototype.initParameters = function() {
+              this.isSubLayout || (this.layoutQuality = l.QUALITY, this.animationDuringLayout = l.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = l.DEFAULT_ANIMATION_PERIOD, this.animationOnLayout = l.DEFAULT_ANIMATION_ON_LAYOUT, this.incremental = l.DEFAULT_INCREMENTAL, this.createBendsAsNeeded = l.DEFAULT_CREATE_BENDS_AS_NEEDED, this.uniformLeafNodeSizes = l.DEFAULT_UNIFORM_LEAF_NODE_SIZES), this.animationDuringLayout && (this.animationOnLayout = !1);
+            }, s.prototype.transform = function(a) {
+              if (a == null)
+                this.transform(new r(0, 0));
+              else {
+                var g = new f(), c = this.graphManager.getRoot().updateLeftTop();
+                if (c != null) {
+                  g.setWorldOrgX(a.x), g.setWorldOrgY(a.y), g.setDeviceOrgX(c.x), g.setDeviceOrgY(c.y);
+                  for (var N = this.getAllNodes(), d, y = 0; y < N.length; y++)
+                    d = N[y], d.transform(g);
+                }
+              }
+            }, s.prototype.positionNodesRandomly = function(a) {
+              if (a == null)
+                this.positionNodesRandomly(this.getGraphManager().getRoot()), this.getGraphManager().getRoot().updateBounds(!0);
+              else
+                for (var g, c, N = a.getNodes(), d = 0; d < N.length; d++)
+                  g = N[d], c = g.getChild(), c == null || c.getNodes().length == 0 ? g.scatter() : (this.positionNodesRandomly(c), g.updateBounds());
+            }, s.prototype.getFlatForest = function() {
+              for (var a = [], g = !0, c = this.graphManager.getRoot().getNodes(), N = !0, d = 0; d < c.length; d++)
+                c[d].getChild() != null && (N = !1);
+              if (!N)
+                return a;
+              var y = /* @__PURE__ */ new Set(), w = [], M = /* @__PURE__ */ new Map(), P = [];
+              for (P = P.concat(c); P.length > 0 && g; ) {
+                for (w.push(P[0]); w.length > 0 && g; ) {
+                  var S = w[0];
+                  w.splice(0, 1), y.add(S);
+                  for (var Y = S.getEdges(), d = 0; d < Y.length; d++) {
+                    var W = Y[d].getOtherEnd(S);
+                    if (M.get(S) != W)
+                      if (!y.has(W))
+                        w.push(W), M.set(W, S);
+                      else {
+                        g = !1;
+                        break;
+                      }
+                  }
+                }
+                if (!g)
+                  a = [];
+                else {
+                  var B = [].concat(u(y));
+                  a.push(B);
+                  for (var d = 0; d < B.length; d++) {
+                    var x = B[d], nt = P.indexOf(x);
+                    nt > -1 && P.splice(nt, 1);
+                  }
+                  y = /* @__PURE__ */ new Set(), M = /* @__PURE__ */ new Map();
+                }
+              }
+              return a;
+            }, s.prototype.createDummyNodesForBendpoints = function(a) {
+              for (var g = [], c = a.source, N = this.graphManager.calcLowestCommonAncestor(a.source, a.target), d = 0; d < a.bendpoints.length; d++) {
+                var y = this.newNode(null);
+                y.setRect(new Point(0, 0), new Dimension(1, 1)), N.add(y);
+                var w = this.newEdge(null);
+                this.graphManager.add(w, c, y), g.add(y), c = y;
+              }
+              var w = this.newEdge(null);
+              return this.graphManager.add(w, c, a.target), this.edgeToDummyNodes.set(a, g), a.isInterGraph() ? this.graphManager.remove(a) : N.remove(a), g;
+            }, s.prototype.createBendpointsFromDummyNodes = function() {
+              var a = [];
+              a = a.concat(this.graphManager.getAllEdges()), a = [].concat(u(this.edgeToDummyNodes.keys())).concat(a);
+              for (var g = 0; g < a.length; g++) {
+                var c = a[g];
+                if (c.bendpoints.length > 0) {
+                  for (var N = this.edgeToDummyNodes.get(c), d = 0; d < N.length; d++) {
+                    var y = N[d], w = new r(y.getCenterX(), y.getCenterY()), M = c.bendpoints.get(d);
+                    M.x = w.x, M.y = w.y, y.getOwner().remove(y);
+                  }
+                  this.graphManager.add(c, c.source, c.target);
+                }
+              }
+            }, s.transform = function(a, g, c, N) {
+              if (c != null && N != null) {
+                var d = g;
+                if (a <= 50) {
+                  var y = g / c;
+                  d -= (g - y) / 50 * (50 - a);
+                } else {
+                  var w = g * N;
+                  d += (w - g) / 50 * (a - 50);
+                }
+                return d;
+              } else {
+                var M, P;
+                return a <= 50 ? (M = 9 * g / 500, P = g / 10) : (M = 9 * g / 50, P = -8 * g), M * a + P;
+              }
+            }, s.findCenterOfTree = function(a) {
+              var g = [];
+              g = g.concat(a);
+              var c = [], N = /* @__PURE__ */ new Map(), d = !1, y = null;
+              (g.length == 1 || g.length == 2) && (d = !0, y = g[0]);
+              for (var w = 0; w < g.length; w++) {
+                var M = g[w], P = M.getNeighborsList().size;
+                N.set(M, M.getNeighborsList().size), P == 1 && c.push(M);
+              }
+              var S = [];
+              for (S = S.concat(c); !d; ) {
+                var Y = [];
+                Y = Y.concat(S), S = [];
+                for (var w = 0; w < g.length; w++) {
+                  var M = g[w], W = g.indexOf(M);
+                  W >= 0 && g.splice(W, 1);
+                  var B = M.getNeighborsList();
+                  B.forEach(function(n) {
+                    if (c.indexOf(n) < 0) {
+                      var E = N.get(n), p = E - 1;
+                      p == 1 && S.push(n), N.set(n, p);
+                    }
+                  });
+                }
+                c = c.concat(S), (g.length == 1 || g.length == 2) && (d = !0, y = g[0]);
+              }
+              return y;
+            }, s.prototype.setGraphManager = function(a) {
+              this.graphManager = a;
+            }, L.exports = s;
+          },
+          /* 16 */
+          /***/
+          function(L, U, T) {
+            function u() {
+            }
+            u.seed = 1, u.x = 0, u.nextDouble = function() {
+              return u.x = Math.sin(u.seed++) * 1e4, u.x - Math.floor(u.x);
+            }, L.exports = u;
+          },
+          /* 17 */
+          /***/
+          function(L, U, T) {
+            var u = T(5);
+            function l(o, i) {
+              this.lworldOrgX = 0, this.lworldOrgY = 0, this.ldeviceOrgX = 0, this.ldeviceOrgY = 0, this.lworldExtX = 1, this.lworldExtY = 1, this.ldeviceExtX = 1, this.ldeviceExtY = 1;
+            }
+            l.prototype.getWorldOrgX = function() {
+              return this.lworldOrgX;
+            }, l.prototype.setWorldOrgX = function(o) {
+              this.lworldOrgX = o;
+            }, l.prototype.getWorldOrgY = function() {
+              return this.lworldOrgY;
+            }, l.prototype.setWorldOrgY = function(o) {
+              this.lworldOrgY = o;
+            }, l.prototype.getWorldExtX = function() {
+              return this.lworldExtX;
+            }, l.prototype.setWorldExtX = function(o) {
+              this.lworldExtX = o;
+            }, l.prototype.getWorldExtY = function() {
+              return this.lworldExtY;
+            }, l.prototype.setWorldExtY = function(o) {
+              this.lworldExtY = o;
+            }, l.prototype.getDeviceOrgX = function() {
+              return this.ldeviceOrgX;
+            }, l.prototype.setDeviceOrgX = function(o) {
+              this.ldeviceOrgX = o;
+            }, l.prototype.getDeviceOrgY = function() {
+              return this.ldeviceOrgY;
+            }, l.prototype.setDeviceOrgY = function(o) {
+              this.ldeviceOrgY = o;
+            }, l.prototype.getDeviceExtX = function() {
+              return this.ldeviceExtX;
+            }, l.prototype.setDeviceExtX = function(o) {
+              this.ldeviceExtX = o;
+            }, l.prototype.getDeviceExtY = function() {
+              return this.ldeviceExtY;
+            }, l.prototype.setDeviceExtY = function(o) {
+              this.ldeviceExtY = o;
+            }, l.prototype.transformX = function(o) {
+              var i = 0, t = this.lworldExtX;
+              return t != 0 && (i = this.ldeviceOrgX + (o - this.lworldOrgX) * this.ldeviceExtX / t), i;
+            }, l.prototype.transformY = function(o) {
+              var i = 0, t = this.lworldExtY;
+              return t != 0 && (i = this.ldeviceOrgY + (o - this.lworldOrgY) * this.ldeviceExtY / t), i;
+            }, l.prototype.inverseTransformX = function(o) {
+              var i = 0, t = this.ldeviceExtX;
+              return t != 0 && (i = this.lworldOrgX + (o - this.ldeviceOrgX) * this.lworldExtX / t), i;
+            }, l.prototype.inverseTransformY = function(o) {
+              var i = 0, t = this.ldeviceExtY;
+              return t != 0 && (i = this.lworldOrgY + (o - this.ldeviceOrgY) * this.lworldExtY / t), i;
+            }, l.prototype.inverseTransformPoint = function(o) {
+              var i = new u(this.inverseTransformX(o.x), this.inverseTransformY(o.y));
+              return i;
+            }, L.exports = l;
+          },
+          /* 18 */
+          /***/
+          function(L, U, T) {
+            function u(e) {
+              if (Array.isArray(e)) {
+                for (var s = 0, a = Array(e.length); s < e.length; s++)
+                  a[s] = e[s];
+                return a;
+              } else
+                return Array.from(e);
+            }
+            var l = T(15), o = T(4), i = T(0), t = T(8), h = T(9);
+            function r() {
+              l.call(this), this.useSmartIdealEdgeLengthCalculation = o.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.gravityConstant = o.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = o.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = o.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = o.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.displacementThresholdPerNode = 3 * o.DEFAULT_EDGE_LENGTH / 100, this.coolingFactor = o.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.initialCoolingFactor = o.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.totalDisplacement = 0, this.oldTotalDisplacement = 0, this.maxIterations = o.MAX_ITERATIONS;
+            }
+            r.prototype = Object.create(l.prototype);
+            for (var f in l)
+              r[f] = l[f];
+            r.prototype.initParameters = function() {
+              l.prototype.initParameters.call(this, arguments), this.totalIterations = 0, this.notAnimatedIterations = 0, this.useFRGridVariant = o.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION, this.grid = [];
+            }, r.prototype.calcIdealEdgeLengths = function() {
+              for (var e, s, a, g, c, N, d, y = this.getGraphManager().getAllEdges(), w = 0; w < y.length; w++)
+                e = y[w], s = e.idealLength, e.isInterGraph && (g = e.getSource(), c = e.getTarget(), N = e.getSourceInLca().getEstimatedSize(), d = e.getTargetInLca().getEstimatedSize(), this.useSmartIdealEdgeLengthCalculation && (e.idealLength += N + d - 2 * i.SIMPLE_NODE_SIZE), a = e.getLca().getInclusionTreeDepth(), e.idealLength += s * o.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (g.getInclusionTreeDepth() + c.getInclusionTreeDepth() - 2 * a));
+            }, r.prototype.initSpringEmbedder = function() {
+              var e = this.getAllNodes().length;
+              this.incremental ? (e > o.ADAPTATION_LOWER_NODE_LIMIT && (this.coolingFactor = Math.max(this.coolingFactor * o.COOLING_ADAPTATION_FACTOR, this.coolingFactor - (e - o.ADAPTATION_LOWER_NODE_LIMIT) / (o.ADAPTATION_UPPER_NODE_LIMIT - o.ADAPTATION_LOWER_NODE_LIMIT) * this.coolingFactor * (1 - o.COOLING_ADAPTATION_FACTOR))), this.maxNodeDisplacement = o.MAX_NODE_DISPLACEMENT_INCREMENTAL) : (e > o.ADAPTATION_LOWER_NODE_LIMIT ? this.coolingFactor = Math.max(o.COOLING_ADAPTATION_FACTOR, 1 - (e - o.ADAPTATION_LOWER_NODE_LIMIT) / (o.ADAPTATION_UPPER_NODE_LIMIT - o.ADAPTATION_LOWER_NODE_LIMIT) * (1 - o.COOLING_ADAPTATION_FACTOR)) : this.coolingFactor = 1, this.initialCoolingFactor = this.coolingFactor, this.maxNodeDisplacement = o.MAX_NODE_DISPLACEMENT), this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations), this.displacementThresholdPerNode = 3 * o.DEFAULT_EDGE_LENGTH / 100, this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length, this.repulsionRange = this.calcRepulsionRange();
+            }, r.prototype.calcSpringForces = function() {
+              for (var e = this.getAllEdges(), s, a = 0; a < e.length; a++)
+                s = e[a], this.calcSpringForce(s, s.idealLength);
+            }, r.prototype.calcRepulsionForces = function() {
+              var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0, s = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1, a, g, c, N, d = this.getAllNodes(), y;
+              if (this.useFRGridVariant)
+                for (this.totalIterations % o.GRID_CALCULATION_CHECK_PERIOD == 1 && e && this.updateGrid(), y = /* @__PURE__ */ new Set(), a = 0; a < d.length; a++)
+                  c = d[a], this.calculateRepulsionForceOfANode(c, y, e, s), y.add(c);
+              else
+                for (a = 0; a < d.length; a++)
+                  for (c = d[a], g = a + 1; g < d.length; g++)
+                    N = d[g], c.getOwner() == N.getOwner() && this.calcRepulsionForce(c, N);
+            }, r.prototype.calcGravitationalForces = function() {
+              for (var e, s = this.getAllNodesToApplyGravitation(), a = 0; a < s.length; a++)
+                e = s[a], this.calcGravitationalForce(e);
+            }, r.prototype.moveNodes = function() {
+              for (var e = this.getAllNodes(), s, a = 0; a < e.length; a++)
+                s = e[a], s.move();
+            }, r.prototype.calcSpringForce = function(e, s) {
+              var a = e.getSource(), g = e.getTarget(), c, N, d, y;
+              if (this.uniformLeafNodeSizes && a.getChild() == null && g.getChild() == null)
+                e.updateLengthSimple();
+              else if (e.updateLength(), e.isOverlapingSourceAndTarget)
+                return;
+              c = e.getLength(), c != 0 && (N = e.edgeElasticity * (c - s), d = N * (e.lengthX / c), y = N * (e.lengthY / c), a.springForceX += d, a.springForceY += y, g.springForceX -= d, g.springForceY -= y);
+            }, r.prototype.calcRepulsionForce = function(e, s) {
+              var a = e.getRect(), g = s.getRect(), c = new Array(2), N = new Array(4), d, y, w, M, P, S, Y;
+              if (a.intersects(g)) {
+                t.calcSeparationAmount(a, g, c, o.DEFAULT_EDGE_LENGTH / 2), S = 2 * c[0], Y = 2 * c[1];
+                var W = e.noOfChildren * s.noOfChildren / (e.noOfChildren + s.noOfChildren);
+                e.repulsionForceX -= W * S, e.repulsionForceY -= W * Y, s.repulsionForceX += W * S, s.repulsionForceY += W * Y;
+              } else
+                this.uniformLeafNodeSizes && e.getChild() == null && s.getChild() == null ? (d = g.getCenterX() - a.getCenterX(), y = g.getCenterY() - a.getCenterY()) : (t.getIntersection(a, g, N), d = N[2] - N[0], y = N[3] - N[1]), Math.abs(d) < o.MIN_REPULSION_DIST && (d = h.sign(d) * o.MIN_REPULSION_DIST), Math.abs(y) < o.MIN_REPULSION_DIST && (y = h.sign(y) * o.MIN_REPULSION_DIST), w = d * d + y * y, M = Math.sqrt(w), P = (e.nodeRepulsion / 2 + s.nodeRepulsion / 2) * e.noOfChildren * s.noOfChildren / w, S = P * d / M, Y = P * y / M, e.repulsionForceX -= S, e.repulsionForceY -= Y, s.repulsionForceX += S, s.repulsionForceY += Y;
+            }, r.prototype.calcGravitationalForce = function(e) {
+              var s, a, g, c, N, d, y, w;
+              s = e.getOwner(), a = (s.getRight() + s.getLeft()) / 2, g = (s.getTop() + s.getBottom()) / 2, c = e.getCenterX() - a, N = e.getCenterY() - g, d = Math.abs(c) + e.getWidth() / 2, y = Math.abs(N) + e.getHeight() / 2, e.getOwner() == this.graphManager.getRoot() ? (w = s.getEstimatedSize() * this.gravityRangeFactor, (d > w || y > w) && (e.gravitationForceX = -this.gravityConstant * c, e.gravitationForceY = -this.gravityConstant * N)) : (w = s.getEstimatedSize() * this.compoundGravityRangeFactor, (d > w || y > w) && (e.gravitationForceX = -this.gravityConstant * c * this.compoundGravityConstant, e.gravitationForceY = -this.gravityConstant * N * this.compoundGravityConstant));
+            }, r.prototype.isConverged = function() {
+              var e, s = !1;
+              return this.totalIterations > this.maxIterations / 3 && (s = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2), e = this.totalDisplacement < this.totalDisplacementThreshold, this.oldTotalDisplacement = this.totalDisplacement, e || s;
+            }, r.prototype.animate = function() {
+              this.animationDuringLayout && !this.isSubLayout && (this.notAnimatedIterations == this.animationPeriod ? (this.update(), this.notAnimatedIterations = 0) : this.notAnimatedIterations++);
+            }, r.prototype.calcNoOfChildrenForAllNodes = function() {
+              for (var e, s = this.graphManager.getAllNodes(), a = 0; a < s.length; a++)
+                e = s[a], e.noOfChildren = e.getNoOfChildren();
+            }, r.prototype.calcGrid = function(e) {
+              var s = 0, a = 0;
+              s = parseInt(Math.ceil((e.getRight() - e.getLeft()) / this.repulsionRange)), a = parseInt(Math.ceil((e.getBottom() - e.getTop()) / this.repulsionRange));
+              for (var g = new Array(s), c = 0; c < s; c++)
+                g[c] = new Array(a);
+              for (var c = 0; c < s; c++)
+                for (var N = 0; N < a; N++)
+                  g[c][N] = new Array();
+              return g;
+            }, r.prototype.addNodeToGrid = function(e, s, a) {
+              var g = 0, c = 0, N = 0, d = 0;
+              g = parseInt(Math.floor((e.getRect().x - s) / this.repulsionRange)), c = parseInt(Math.floor((e.getRect().width + e.getRect().x - s) / this.repulsionRange)), N = parseInt(Math.floor((e.getRect().y - a) / this.repulsionRange)), d = parseInt(Math.floor((e.getRect().height + e.getRect().y - a) / this.repulsionRange));
+              for (var y = g; y <= c; y++)
+                for (var w = N; w <= d; w++)
+                  this.grid[y][w].push(e), e.setGridCoordinates(g, c, N, d);
+            }, r.prototype.updateGrid = function() {
+              var e, s, a = this.getAllNodes();
+              for (this.grid = this.calcGrid(this.graphManager.getRoot()), e = 0; e < a.length; e++)
+                s = a[e], this.addNodeToGrid(s, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop());
+            }, r.prototype.calculateRepulsionForceOfANode = function(e, s, a, g) {
+              if (this.totalIterations % o.GRID_CALCULATION_CHECK_PERIOD == 1 && a || g) {
+                var c = /* @__PURE__ */ new Set();
+                e.surrounding = new Array();
+                for (var N, d = this.grid, y = e.startX - 1; y < e.finishX + 2; y++)
+                  for (var w = e.startY - 1; w < e.finishY + 2; w++)
+                    if (!(y < 0 || w < 0 || y >= d.length || w >= d[0].length)) {
+                      for (var M = 0; M < d[y][w].length; M++)
+                        if (N = d[y][w][M], !(e.getOwner() != N.getOwner() || e == N) && !s.has(N) && !c.has(N)) {
+                          var P = Math.abs(e.getCenterX() - N.getCenterX()) - (e.getWidth() / 2 + N.getWidth() / 2), S = Math.abs(e.getCenterY() - N.getCenterY()) - (e.getHeight() / 2 + N.getHeight() / 2);
+                          P <= this.repulsionRange && S <= this.repulsionRange && c.add(N);
+                        }
+                    }
+                e.surrounding = [].concat(u(c));
+              }
+              for (y = 0; y < e.surrounding.length; y++)
+                this.calcRepulsionForce(e, e.surrounding[y]);
+            }, r.prototype.calcRepulsionRange = function() {
+              return 0;
+            }, L.exports = r;
+          },
+          /* 19 */
+          /***/
+          function(L, U, T) {
+            var u = T(1), l = T(4);
+            function o(t, h, r) {
+              u.call(this, t, h, r), this.idealLength = l.DEFAULT_EDGE_LENGTH, this.edgeElasticity = l.DEFAULT_SPRING_STRENGTH;
+            }
+            o.prototype = Object.create(u.prototype);
+            for (var i in u)
+              o[i] = u[i];
+            L.exports = o;
+          },
+          /* 20 */
+          /***/
+          function(L, U, T) {
+            var u = T(3), l = T(4);
+            function o(t, h, r, f) {
+              u.call(this, t, h, r, f), this.nodeRepulsion = l.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 = [];
+            }
+            o.prototype = Object.create(u.prototype);
+            for (var i in u)
+              o[i] = u[i];
+            o.prototype.setGridCoordinates = function(t, h, r, f) {
+              this.startX = t, this.finishX = h, this.startY = r, this.finishY = f;
+            }, L.exports = o;
+          },
+          /* 21 */
+          /***/
+          function(L, U, T) {
+            function u(l, o) {
+              this.width = 0, this.height = 0, l !== null && o !== null && (this.height = o, this.width = l);
+            }
+            u.prototype.getWidth = function() {
+              return this.width;
+            }, u.prototype.setWidth = function(l) {
+              this.width = l;
+            }, u.prototype.getHeight = function() {
+              return this.height;
+            }, u.prototype.setHeight = function(l) {
+              this.height = l;
+            }, L.exports = u;
+          },
+          /* 22 */
+          /***/
+          function(L, U, T) {
+            var u = T(14);
+            function l() {
+              this.map = {}, this.keys = [];
+            }
+            l.prototype.put = function(o, i) {
+              var t = u.createID(o);
+              this.contains(t) || (this.map[t] = i, this.keys.push(o));
+            }, l.prototype.contains = function(o) {
+              return u.createID(o), this.map[o] != null;
+            }, l.prototype.get = function(o) {
+              var i = u.createID(o);
+              return this.map[i];
+            }, l.prototype.keySet = function() {
+              return this.keys;
+            }, L.exports = l;
+          },
+          /* 23 */
+          /***/
+          function(L, U, T) {
+            var u = T(14);
+            function l() {
+              this.set = {};
+            }
+            l.prototype.add = function(o) {
+              var i = u.createID(o);
+              this.contains(i) || (this.set[i] = o);
+            }, l.prototype.remove = function(o) {
+              delete this.set[u.createID(o)];
+            }, l.prototype.clear = function() {
+              this.set = {};
+            }, l.prototype.contains = function(o) {
+              return this.set[u.createID(o)] == o;
+            }, l.prototype.isEmpty = function() {
+              return this.size() === 0;
+            }, l.prototype.size = function() {
+              return Object.keys(this.set).length;
+            }, l.prototype.addAllTo = function(o) {
+              for (var i = Object.keys(this.set), t = i.length, h = 0; h < t; h++)
+                o.push(this.set[i[h]]);
+            }, l.prototype.size = function() {
+              return Object.keys(this.set).length;
+            }, l.prototype.addAll = function(o) {
+              for (var i = o.length, t = 0; t < i; t++) {
+                var h = o[t];
+                this.add(h);
+              }
+            }, L.exports = l;
+          },
+          /* 24 */
+          /***/
+          function(L, U, T) {
+            function u() {
+            }
+            u.multMat = function(l, o) {
+              for (var i = [], t = 0; t < l.length; t++) {
+                i[t] = [];
+                for (var h = 0; h < o[0].length; h++) {
+                  i[t][h] = 0;
+                  for (var r = 0; r < l[0].length; r++)
+                    i[t][h] += l[t][r] * o[r][h];
+                }
+              }
+              return i;
+            }, u.transpose = function(l) {
+              for (var o = [], i = 0; i < l[0].length; i++) {
+                o[i] = [];
+                for (var t = 0; t < l.length; t++)
+                  o[i][t] = l[t][i];
+              }
+              return o;
+            }, u.multCons = function(l, o) {
+              for (var i = [], t = 0; t < l.length; t++)
+                i[t] = l[t] * o;
+              return i;
+            }, u.minusOp = function(l, o) {
+              for (var i = [], t = 0; t < l.length; t++)
+                i[t] = l[t] - o[t];
+              return i;
+            }, u.dotProduct = function(l, o) {
+              for (var i = 0, t = 0; t < l.length; t++)
+                i += l[t] * o[t];
+              return i;
+            }, u.mag = function(l) {
+              return Math.sqrt(this.dotProduct(l, l));
+            }, u.normalize = function(l) {
+              for (var o = [], i = this.mag(l), t = 0; t < l.length; t++)
+                o[t] = l[t] / i;
+              return o;
+            }, u.multGamma = function(l) {
+              for (var o = [], i = 0, t = 0; t < l.length; t++)
+                i += l[t];
+              i *= -1 / l.length;
+              for (var h = 0; h < l.length; h++)
+                o[h] = i + l[h];
+              return o;
+            }, u.multL = function(l, o, i) {
+              for (var t = [], h = [], r = [], f = 0; f < o[0].length; f++) {
+                for (var e = 0, s = 0; s < o.length; s++)
+                  e += -0.5 * o[s][f] * l[s];
+                h[f] = e;
+              }
+              for (var a = 0; a < i.length; a++) {
+                for (var g = 0, c = 0; c < i.length; c++)
+                  g += i[a][c] * h[c];
+                r[a] = g;
+              }
+              for (var N = 0; N < o.length; N++) {
+                for (var d = 0, y = 0; y < o[0].length; y++)
+                  d += o[N][y] * r[y];
+                t[N] = d;
+              }
+              return t;
+            }, L.exports = u;
+          },
+          /* 25 */
+          /***/
+          function(L, U, T) {
+            var u = /* @__PURE__ */ function() {
+              function t(h, r) {
+                for (var f = 0; f < r.length; f++) {
+                  var e = r[f];
+                  e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(h, e.key, e);
+                }
+              }
+              return function(h, r, f) {
+                return r && t(h.prototype, r), f && t(h, f), h;
+              };
+            }();
+            function l(t, h) {
+              if (!(t instanceof h))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            var o = T(11), i = function() {
+              function t(h, r) {
+                l(this, t), (r !== null || r !== void 0) && (this.compareFunction = this._defaultCompareFunction);
+                var f = void 0;
+                h instanceof o ? f = h.size() : f = h.length, this._quicksort(h, 0, f - 1);
+              }
+              return u(t, [{
+                key: "_quicksort",
+                value: function(h, r, f) {
+                  if (r < f) {
+                    var e = this._partition(h, r, f);
+                    this._quicksort(h, r, e), this._quicksort(h, e + 1, f);
+                  }
+                }
+              }, {
+                key: "_partition",
+                value: function(h, r, f) {
+                  for (var e = this._get(h, r), s = r, a = f; ; ) {
+                    for (; this.compareFunction(e, this._get(h, a)); )
+                      a--;
+                    for (; this.compareFunction(this._get(h, s), e); )
+                      s++;
+                    if (s < a)
+                      this._swap(h, s, a), s++, a--;
+                    else
+                      return a;
+                  }
+                }
+              }, {
+                key: "_get",
+                value: function(h, r) {
+                  return h instanceof o ? h.get_object_at(r) : h[r];
+                }
+              }, {
+                key: "_set",
+                value: function(h, r, f) {
+                  h instanceof o ? h.set_object_at(r, f) : h[r] = f;
+                }
+              }, {
+                key: "_swap",
+                value: function(h, r, f) {
+                  var e = this._get(h, r);
+                  this._set(h, r, this._get(h, f)), this._set(h, f, e);
+                }
+              }, {
+                key: "_defaultCompareFunction",
+                value: function(h, r) {
+                  return r > h;
+                }
+              }]), t;
+            }();
+            L.exports = i;
+          },
+          /* 26 */
+          /***/
+          function(L, U, T) {
+            function u() {
+            }
+            u.svd = function(l) {
+              this.U = null, this.V = null, this.s = null, this.m = 0, this.n = 0, this.m = l.length, this.n = l[0].length;
+              var o = Math.min(this.m, this.n);
+              this.s = function(It) {
+                for (var At = []; It-- > 0; )
+                  At.push(0);
+                return At;
+              }(Math.min(this.m + 1, this.n)), this.U = function(It) {
+                var At = function Ht(Yt) {
+                  if (Yt.length == 0)
+                    return 0;
+                  for (var Rt = [], Ut = 0; Ut < Yt[0]; Ut++)
+                    Rt.push(Ht(Yt.slice(1)));
+                  return Rt;
+                };
+                return At(It);
+              }([this.m, o]), this.V = function(It) {
+                var At = function Ht(Yt) {
+                  if (Yt.length == 0)
+                    return 0;
+                  for (var Rt = [], Ut = 0; Ut < Yt[0]; Ut++)
+                    Rt.push(Ht(Yt.slice(1)));
+                  return Rt;
+                };
+                return At(It);
+              }([this.n, this.n]);
+              for (var i = function(It) {
+                for (var At = []; It-- > 0; )
+                  At.push(0);
+                return At;
+              }(this.n), t = function(It) {
+                for (var At = []; It-- > 0; )
+                  At.push(0);
+                return At;
+              }(this.m), h = !0, r = Math.min(this.m - 1, this.n), f = Math.max(0, Math.min(this.n - 2, this.m)), e = 0; e < Math.max(r, f); e++) {
+                if (e < r) {
+                  this.s[e] = 0;
+                  for (var s = e; s < this.m; s++)
+                    this.s[e] = u.hypot(this.s[e], l[s][e]);
+                  if (this.s[e] !== 0) {
+                    l[e][e] < 0 && (this.s[e] = -this.s[e]);
+                    for (var a = e; a < this.m; a++)
+                      l[a][e] /= this.s[e];
+                    l[e][e] += 1;
+                  }
+                  this.s[e] = -this.s[e];
+                }
+                for (var g = e + 1; g < this.n; g++) {
+                  if (/* @__PURE__ */ function(It, At) {
+                    return It && At;
+                  }(e < r, this.s[e] !== 0)) {
+                    for (var c = 0, N = e; N < this.m; N++)
+                      c += l[N][e] * l[N][g];
+                    c = -c / l[e][e];
+                    for (var d = e; d < this.m; d++)
+                      l[d][g] += c * l[d][e];
+                  }
+                  i[g] = l[e][g];
+                }
+                if (/* @__PURE__ */ function(It, At) {
+                  return At;
+                }(h, e < r))
+                  for (var y = e; y < this.m; y++)
+                    this.U[y][e] = l[y][e];
+                if (e < f) {
+                  i[e] = 0;
+                  for (var w = e + 1; w < this.n; w++)
+                    i[e] = u.hypot(i[e], i[w]);
+                  if (i[e] !== 0) {
+                    i[e + 1] < 0 && (i[e] = -i[e]);
+                    for (var M = e + 1; M < this.n; M++)
+                      i[M] /= i[e];
+                    i[e + 1] += 1;
+                  }
+                  if (i[e] = -i[e], /* @__PURE__ */ function(It, At) {
+                    return It && At;
+                  }(e + 1 < this.m, i[e] !== 0)) {
+                    for (var P = e + 1; P < this.m; P++)
+                      t[P] = 0;
+                    for (var S = e + 1; S < this.n; S++)
+                      for (var Y = e + 1; Y < this.m; Y++)
+                        t[Y] += i[S] * l[Y][S];
+                    for (var W = e + 1; W < this.n; W++)
+                      for (var B = -i[W] / i[e + 1], x = e + 1; x < this.m; x++)
+                        l[x][W] += B * t[x];
+                  }
+                  for (var nt = e + 1; nt < this.n; nt++)
+                    this.V[nt][e] = i[nt];
+                }
+              }
+              var n = Math.min(this.n, this.m + 1);
+              r < this.n && (this.s[r] = l[r][r]), this.m < n && (this.s[n - 1] = 0), f + 1 < n && (i[f] = l[f][n - 1]), i[n - 1] = 0;
+              {
+                for (var E = r; E < o; E++) {
+                  for (var p = 0; p < this.m; p++)
+                    this.U[p][E] = 0;
+                  this.U[E][E] = 1;
+                }
+                for (var v = r - 1; v >= 0; v--)
+                  if (this.s[v] !== 0) {
+                    for (var m = v + 1; m < o; m++) {
+                      for (var O = 0, _ = v; _ < this.m; _++)
+                        O += this.U[_][v] * this.U[_][m];
+                      O = -O / this.U[v][v];
+                      for (var C = v; C < this.m; C++)
+                        this.U[C][m] += O * this.U[C][v];
+                    }
+                    for (var F = v; F < this.m; F++)
+                      this.U[F][v] = -this.U[F][v];
+                    this.U[v][v] = 1 + this.U[v][v];
+                    for (var k = 0; k < v - 1; k++)
+                      this.U[k][v] = 0;
+                  } else {
+                    for (var V = 0; V < this.m; V++)
+                      this.U[V][v] = 0;
+                    this.U[v][v] = 1;
+                  }
+              }
+              for (var z = this.n - 1; z >= 0; z--) {
+                if (/* @__PURE__ */ function(It, At) {
+                  return It && At;
+                }(z < f, i[z] !== 0))
+                  for (var H = z + 1; H < o; H++) {
+                    for (var Z = 0, G = z + 1; G < this.n; G++)
+                      Z += this.V[G][z] * this.V[G][H];
+                    Z = -Z / this.V[z + 1][z];
+                    for (var D = z + 1; D < this.n; D++)
+                      this.V[D][H] += Z * this.V[D][z];
+                  }
+                for (var b = 0; b < this.n; b++)
+                  this.V[b][z] = 0;
+                this.V[z][z] = 1;
+              }
+              for (var q = n - 1, et = Math.pow(2, -52), vt = Math.pow(2, -966); n > 0; ) {
+                var j = void 0, Dt = void 0;
+                for (j = n - 2; j >= -1 && j !== -1; j--)
+                  if (Math.abs(i[j]) <= vt + et * (Math.abs(this.s[j]) + Math.abs(this.s[j + 1]))) {
+                    i[j] = 0;
+                    break;
+                  }
+                if (j === n - 2)
+                  Dt = 4;
+                else {
+                  var J = void 0;
+                  for (J = n - 1; J >= j && J !== j; J--) {
+                    var ot = (J !== n ? Math.abs(i[J]) : 0) + (J !== j + 1 ? Math.abs(i[J - 1]) : 0);
+                    if (Math.abs(this.s[J]) <= vt + et * ot) {
+                      this.s[J] = 0;
+                      break;
+                    }
+                  }
+                  J === j ? Dt = 3 : J === n - 1 ? Dt = 1 : (Dt = 2, j = J);
+                }
+                switch (j++, Dt) {
+                  case 1:
+                    {
+                      var mt = i[n - 2];
+                      i[n - 2] = 0;
+                      for (var ht = n - 2; ht >= j; ht--) {
+                        var Lt = u.hypot(this.s[ht], mt), _t = this.s[ht] / Lt, Tt = mt / Lt;
+                        this.s[ht] = Lt, ht !== j && (mt = -Tt * i[ht - 1], i[ht - 1] = _t * i[ht - 1]);
+                        for (var wt = 0; wt < this.n; wt++)
+                          Lt = _t * this.V[wt][ht] + Tt * this.V[wt][n - 1], this.V[wt][n - 1] = -Tt * this.V[wt][ht] + _t * this.V[wt][n - 1], this.V[wt][ht] = Lt;
+                      }
+                    }
+                    break;
+                  case 2:
+                    {
+                      var zt = i[j - 1];
+                      i[j - 1] = 0;
+                      for (var bt = j; bt < n; bt++) {
+                        var Gt = u.hypot(this.s[bt], zt), Ft = this.s[bt] / Gt, Vt = zt / Gt;
+                        this.s[bt] = Gt, zt = -Vt * i[bt], i[bt] = Ft * i[bt];
+                        for (var Pt = 0; Pt < this.m; Pt++)
+                          Gt = Ft * this.U[Pt][bt] + Vt * this.U[Pt][j - 1], this.U[Pt][j - 1] = -Vt * this.U[Pt][bt] + Ft * this.U[Pt][j - 1], this.U[Pt][bt] = Gt;
+                      }
+                    }
+                    break;
+                  case 3:
+                    {
+                      var $t = Math.max(Math.max(Math.max(Math.max(Math.abs(this.s[n - 1]), Math.abs(this.s[n - 2])), Math.abs(i[n - 2])), Math.abs(this.s[j])), Math.abs(i[j])), dt = this.s[n - 1] / $t, I = this.s[n - 2] / $t, R = i[n - 2] / $t, $ = this.s[j] / $t, Q = i[j] / $t, K = ((I + dt) * (I - dt) + R * R) / 2, pt = dt * R * (dt * R), lt = 0;
+                      /* @__PURE__ */ (function(It, At) {
+                        return It || At;
+                      })(K !== 0, pt !== 0) && (lt = Math.sqrt(K * K + pt), K < 0 && (lt = -lt), lt = pt / (K + lt));
+                      for (var tt = ($ + dt) * ($ - dt) + lt, gt = $ * Q, it = j; it < n - 1; it++) {
+                        var Nt = u.hypot(tt, gt), yt = tt / Nt, Ct = gt / Nt;
+                        it !== j && (i[it - 1] = Nt), tt = yt * this.s[it] + Ct * i[it], i[it] = yt * i[it] - Ct * this.s[it], gt = Ct * this.s[it + 1], this.s[it + 1] = yt * this.s[it + 1];
+                        for (var ct = 0; ct < this.n; ct++)
+                          Nt = yt * this.V[ct][it] + Ct * this.V[ct][it + 1], this.V[ct][it + 1] = -Ct * this.V[ct][it] + yt * this.V[ct][it + 1], this.V[ct][it] = Nt;
+                        if (Nt = u.hypot(tt, gt), yt = tt / Nt, Ct = gt / Nt, this.s[it] = Nt, tt = yt * i[it] + Ct * this.s[it + 1], this.s[it + 1] = -Ct * i[it] + yt * this.s[it + 1], gt = Ct * i[it + 1], i[it + 1] = yt * i[it + 1], it < this.m - 1)
+                          for (var at = 0; at < this.m; at++)
+                            Nt = yt * this.U[at][it] + Ct * this.U[at][it + 1], this.U[at][it + 1] = -Ct * this.U[at][it] + yt * this.U[at][it + 1], this.U[at][it] = Nt;
+                      }
+                      i[n - 2] = tt;
+                    }
+                    break;
+                  case 4:
+                    {
+                      if (this.s[j] <= 0) {
+                        this.s[j] = this.s[j] < 0 ? -this.s[j] : 0;
+                        for (var st = 0; st <= q; st++)
+                          this.V[st][j] = -this.V[st][j];
+                      }
+                      for (; j < q && !(this.s[j] >= this.s[j + 1]); ) {
+                        var Mt = this.s[j];
+                        if (this.s[j] = this.s[j + 1], this.s[j + 1] = Mt, j < this.n - 1)
+                          for (var ut = 0; ut < this.n; ut++)
+                            Mt = this.V[ut][j + 1], this.V[ut][j + 1] = this.V[ut][j], this.V[ut][j] = Mt;
+                        if (j < this.m - 1)
+                          for (var Ot = 0; Ot < this.m; Ot++)
+                            Mt = this.U[Ot][j + 1], this.U[Ot][j + 1] = this.U[Ot][j], this.U[Ot][j] = Mt;
+                        j++;
+                      }
+                      n--;
+                    }
+                    break;
+                }
+              }
+              var kt = { U: this.U, V: this.V, S: this.s };
+              return kt;
+            }, u.hypot = function(l, o) {
+              var i = void 0;
+              return Math.abs(l) > Math.abs(o) ? (i = o / l, i = Math.abs(l) * Math.sqrt(1 + i * i)) : o != 0 ? (i = l / o, i = Math.abs(o) * Math.sqrt(1 + i * i)) : i = 0, i;
+            }, L.exports = u;
+          },
+          /* 27 */
+          /***/
+          function(L, U, T) {
+            var u = /* @__PURE__ */ function() {
+              function i(t, h) {
+                for (var r = 0; r < h.length; r++) {
+                  var f = h[r];
+                  f.enumerable = f.enumerable || !1, f.configurable = !0, "value" in f && (f.writable = !0), Object.defineProperty(t, f.key, f);
+                }
+              }
+              return function(t, h, r) {
+                return h && i(t.prototype, h), r && i(t, r), t;
+              };
+            }();
+            function l(i, t) {
+              if (!(i instanceof t))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            var o = function() {
+              function i(t, h) {
+                var r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1, f = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : -1, e = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : -1;
+                l(this, i), this.sequence1 = t, this.sequence2 = h, this.match_score = r, this.mismatch_penalty = f, this.gap_penalty = e, this.iMax = t.length + 1, this.jMax = h.length + 1, this.grid = new Array(this.iMax);
+                for (var s = 0; s < this.iMax; s++) {
+                  this.grid[s] = new Array(this.jMax);
+                  for (var a = 0; a < this.jMax; a++)
+                    this.grid[s][a] = 0;
+                }
+                this.tracebackGrid = new Array(this.iMax);
+                for (var g = 0; g < this.iMax; g++) {
+                  this.tracebackGrid[g] = new Array(this.jMax);
+                  for (var c = 0; c < this.jMax; c++)
+                    this.tracebackGrid[g][c] = [null, null, null];
+                }
+                this.alignments = [], this.score = -1, this.computeGrids();
+              }
+              return u(i, [{
+                key: "getScore",
+                value: function() {
+                  return this.score;
+                }
+              }, {
+                key: "getAlignments",
+                value: function() {
+                  return this.alignments;
+                }
+                // Main dynamic programming procedure
+              }, {
+                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 h = 1; h < this.iMax; h++)
+                    this.grid[h][0] = this.grid[h - 1][0] + this.gap_penalty, this.tracebackGrid[h][0] = [!1, !0, !1];
+                  for (var r = 1; r < this.iMax; r++)
+                    for (var f = 1; f < this.jMax; f++) {
+                      var e = void 0;
+                      this.sequence1[r - 1] === this.sequence2[f - 1] ? e = this.grid[r - 1][f - 1] + this.match_score : e = this.grid[r - 1][f - 1] + this.mismatch_penalty;
+                      var s = this.grid[r - 1][f] + this.gap_penalty, a = this.grid[r][f - 1] + this.gap_penalty, g = [e, s, a], c = this.arrayAllMaxIndexes(g);
+                      this.grid[r][f] = g[c[0]], this.tracebackGrid[r][f] = [c.includes(0), c.includes(1), c.includes(2)];
+                    }
+                  this.score = this.grid[this.iMax - 1][this.jMax - 1];
+                }
+                // Gets all possible valid sequence combinations
+              }, {
+                key: "alignmentTraceback",
+                value: function() {
+                  var t = [];
+                  for (t.push({
+                    pos: [this.sequence1.length, this.sequence2.length],
+                    seq1: "",
+                    seq2: ""
+                  }); t[0]; ) {
+                    var h = t[0], r = this.tracebackGrid[h.pos[0]][h.pos[1]];
+                    r[0] && t.push({
+                      pos: [h.pos[0] - 1, h.pos[1] - 1],
+                      seq1: this.sequence1[h.pos[0] - 1] + h.seq1,
+                      seq2: this.sequence2[h.pos[1] - 1] + h.seq2
+                    }), r[1] && t.push({
+                      pos: [h.pos[0] - 1, h.pos[1]],
+                      seq1: this.sequence1[h.pos[0] - 1] + h.seq1,
+                      seq2: "-" + h.seq2
+                    }), r[2] && t.push({
+                      pos: [h.pos[0], h.pos[1] - 1],
+                      seq1: "-" + h.seq1,
+                      seq2: this.sequence2[h.pos[1] - 1] + h.seq2
+                    }), h.pos[0] === 0 && h.pos[1] === 0 && this.alignments.push({
+                      sequence1: h.seq1,
+                      sequence2: h.seq2
+                    }), t.shift();
+                  }
+                  return this.alignments;
+                }
+                // Helper Functions
+              }, {
+                key: "getAllIndexes",
+                value: function(t, h) {
+                  for (var r = [], f = -1; (f = t.indexOf(h, f + 1)) !== -1; )
+                    r.push(f);
+                  return r;
+                }
+              }, {
+                key: "arrayAllMaxIndexes",
+                value: function(t) {
+                  return this.getAllIndexes(t, Math.max.apply(null, t));
+                }
+              }]), i;
+            }();
+            L.exports = o;
+          },
+          /* 28 */
+          /***/
+          function(L, U, T) {
+            var u = function() {
+            };
+            u.FDLayout = T(18), u.FDLayoutConstants = T(4), u.FDLayoutEdge = T(19), u.FDLayoutNode = T(20), u.DimensionD = T(21), u.HashMap = T(22), u.HashSet = T(23), u.IGeometry = T(8), u.IMath = T(9), u.Integer = T(10), u.Point = T(12), u.PointD = T(5), u.RandomSeed = T(16), u.RectangleD = T(13), u.Transform = T(17), u.UniqueIDGeneretor = T(14), u.Quicksort = T(25), u.LinkedList = T(11), u.LGraphObject = T(2), u.LGraph = T(6), u.LEdge = T(1), u.LGraphManager = T(7), u.LNode = T(3), u.Layout = T(15), u.LayoutConstants = T(0), u.NeedlemanWunsch = T(27), u.Matrix = T(24), u.SVD = T(26), L.exports = u;
+          },
+          /* 29 */
+          /***/
+          function(L, U, T) {
+            function u() {
+              this.listeners = [];
+            }
+            var l = u.prototype;
+            l.addListener = function(o, i) {
+              this.listeners.push({
+                event: o,
+                callback: i
+              });
+            }, l.removeListener = function(o, i) {
+              for (var t = this.listeners.length; t >= 0; t--) {
+                var h = this.listeners[t];
+                h.event === o && h.callback === i && this.listeners.splice(t, 1);
+              }
+            }, l.emit = function(o, i) {
+              for (var t = 0; t < this.listeners.length; t++) {
+                var h = this.listeners[t];
+                o === h.event && h.callback(i);
+              }
+            }, L.exports = u;
+          }
+          /******/
+        ])
+      );
+    });
+  }(me)), me.exports;
+}
+var gi = ve.exports, Ce;
+function ui() {
+  return Ce || (Ce = 1, function(A, X) {
+    (function(L, U) {
+      A.exports = U(di());
+    })(gi, function(L) {
+      return (
+        /******/
+        (() => {
+          var U = {
+            /***/
+            45: (
+              /***/
+              (o, i, t) => {
+                var h = {};
+                h.layoutBase = t(551), h.CoSEConstants = t(806), h.CoSEEdge = t(767), h.CoSEGraph = t(880), h.CoSEGraphManager = t(578), h.CoSELayout = t(765), h.CoSENode = t(991), h.ConstraintHandler = t(902), o.exports = h;
+              }
+            ),
+            /***/
+            806: (
+              /***/
+              (o, i, t) => {
+                var h = t(551).FDLayoutConstants;
+                function r() {
+                }
+                for (var f in h)
+                  r[f] = h[f];
+                r.DEFAULT_USE_MULTI_LEVEL_SCALING = !1, r.DEFAULT_RADIAL_SEPARATION = h.DEFAULT_EDGE_LENGTH, r.DEFAULT_COMPONENT_SEPERATION = 60, r.TILE = !0, r.TILING_PADDING_VERTICAL = 10, r.TILING_PADDING_HORIZONTAL = 10, r.TRANSFORM_ON_CONSTRAINT_HANDLING = !0, r.ENFORCE_CONSTRAINTS = !0, r.APPLY_LAYOUT = !0, r.RELAX_MOVEMENT_ON_CONSTRAINTS = !0, r.TREE_REDUCTION_ON_INCREMENTAL = !0, r.PURE_INCREMENTAL = r.DEFAULT_INCREMENTAL, o.exports = r;
+              }
+            ),
+            /***/
+            767: (
+              /***/
+              (o, i, t) => {
+                var h = t(551).FDLayoutEdge;
+                function r(e, s, a) {
+                  h.call(this, e, s, a);
+                }
+                r.prototype = Object.create(h.prototype);
+                for (var f in h)
+                  r[f] = h[f];
+                o.exports = r;
+              }
+            ),
+            /***/
+            880: (
+              /***/
+              (o, i, t) => {
+                var h = t(551).LGraph;
+                function r(e, s, a) {
+                  h.call(this, e, s, a);
+                }
+                r.prototype = Object.create(h.prototype);
+                for (var f in h)
+                  r[f] = h[f];
+                o.exports = r;
+              }
+            ),
+            /***/
+            578: (
+              /***/
+              (o, i, t) => {
+                var h = t(551).LGraphManager;
+                function r(e) {
+                  h.call(this, e);
+                }
+                r.prototype = Object.create(h.prototype);
+                for (var f in h)
+                  r[f] = h[f];
+                o.exports = r;
+              }
+            ),
+            /***/
+            765: (
+              /***/
+              (o, i, t) => {
+                var h = t(551).FDLayout, r = t(578), f = t(880), e = t(991), s = t(767), a = t(806), g = t(902), c = t(551).FDLayoutConstants, N = t(551).LayoutConstants, d = t(551).Point, y = t(551).PointD, w = t(551).DimensionD, M = t(551).Layout, P = t(551).Integer, S = t(551).IGeometry, Y = t(551).LGraph, W = t(551).Transform, B = t(551).LinkedList;
+                function x() {
+                  h.call(this), this.toBeTiled = {}, this.constraints = {};
+                }
+                x.prototype = Object.create(h.prototype);
+                for (var nt in h)
+                  x[nt] = h[nt];
+                x.prototype.newGraphManager = function() {
+                  var n = new r(this);
+                  return this.graphManager = n, n;
+                }, x.prototype.newGraph = function(n) {
+                  return new f(null, this.graphManager, n);
+                }, x.prototype.newNode = function(n) {
+                  return new e(this.graphManager, n);
+                }, x.prototype.newEdge = function(n) {
+                  return new s(null, null, n);
+                }, x.prototype.initParameters = function() {
+                  h.prototype.initParameters.call(this, arguments), this.isSubLayout || (a.DEFAULT_EDGE_LENGTH < 10 ? this.idealEdgeLength = 10 : this.idealEdgeLength = a.DEFAULT_EDGE_LENGTH, this.useSmartIdealEdgeLengthCalculation = a.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.gravityConstant = c.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = c.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = c.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = c.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.prunedNodesAll = [], this.growTreeIterations = 0, this.afterGrowthIterations = 0, this.isTreeGrowing = !1, this.isGrowthFinished = !1);
+                }, x.prototype.initSpringEmbedder = function() {
+                  h.prototype.initSpringEmbedder.call(this), this.coolingCycle = 0, this.maxCoolingCycle = this.maxIterations / c.CONVERGENCE_CHECK_PERIOD, this.finalTemperature = 0.04, this.coolingAdjuster = 1;
+                }, x.prototype.layout = function() {
+                  var n = N.DEFAULT_CREATE_BENDS_AS_NEEDED;
+                  return n && (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) {
+                    if (a.TREE_REDUCTION_ON_INCREMENTAL) {
+                      this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+                      var n = new Set(this.getAllNodes()), E = this.nodesWithGravity.filter(function(v) {
+                        return n.has(v);
+                      });
+                      this.graphManager.setAllNodesToApplyGravitation(E);
+                    }
+                  } else {
+                    var p = this.getFlatForest();
+                    if (p.length > 0)
+                      this.positionNodesRadially(p);
+                    else {
+                      this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+                      var n = new Set(this.getAllNodes()), E = this.nodesWithGravity.filter(function(O) {
+                        return n.has(O);
+                      });
+                      this.graphManager.setAllNodesToApplyGravitation(E), this.positionNodesRandomly();
+                    }
+                  }
+                  return Object.keys(this.constraints).length > 0 && (g.handleConstraints(this), this.initConstraintVariables()), this.initSpringEmbedder(), a.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 % c.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) {
+                    if (this.isConverged())
+                      if (this.prunedNodesAll.length > 0)
+                        this.isTreeGrowing = !0;
+                      else
+                        return !0;
+                    this.coolingCycle++, this.layoutQuality == 0 ? this.coolingAdjuster = this.coolingCycle : this.layoutQuality == 1 && (this.coolingAdjuster = this.coolingCycle / 3), this.coolingFactor = Math.max(this.initialCoolingFactor - Math.pow(this.coolingCycle, Math.log(100 * (this.initialCoolingFactor - this.finalTemperature)) / Math.log(this.maxCoolingCycle)) / 100 * this.coolingAdjuster, this.finalTemperature), this.animationPeriod = Math.ceil(this.initialAnimationPeriod * Math.sqrt(this.coolingFactor));
+                  }
+                  if (this.isTreeGrowing) {
+                    if (this.growTreeIterations % 10 == 0)
+                      if (this.prunedNodesAll.length > 0) {
+                        this.graphManager.updateBounds(), this.updateGrid(), this.growTree(this.prunedNodesAll), this.graphManager.resetAllNodesToApplyGravitation();
+                        var n = new Set(this.getAllNodes()), E = this.nodesWithGravity.filter(function(m) {
+                          return n.has(m);
+                        });
+                        this.graphManager.setAllNodesToApplyGravitation(E), this.graphManager.updateBounds(), this.updateGrid(), a.PURE_INCREMENTAL ? this.coolingFactor = c.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2 : this.coolingFactor = c.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()), a.PURE_INCREMENTAL ? this.coolingFactor = c.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2 * ((100 - this.afterGrowthIterations) / 100) : this.coolingFactor = c.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100), this.afterGrowthIterations++;
+                  }
+                  var p = !this.isTreeGrowing && !this.isGrowthFinished, v = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished;
+                  return this.totalDisplacement = 0, this.graphManager.updateBounds(), this.calcSpringForces(), this.calcRepulsionForces(p, v), this.calcGravitationalForces(), this.moveNodes(), this.animate(), !1;
+                }, x.prototype.getPositionsData = function() {
+                  for (var n = this.graphManager.getAllNodes(), E = {}, p = 0; p < n.length; p++) {
+                    var v = n[p].rect, m = n[p].id;
+                    E[m] = {
+                      id: m,
+                      x: v.getCenterX(),
+                      y: v.getCenterY(),
+                      w: v.width,
+                      h: v.height
+                    };
+                  }
+                  return E;
+                }, x.prototype.runSpringEmbedder = function() {
+                  this.initialAnimationPeriod = 25, this.animationPeriod = this.initialAnimationPeriod;
+                  var n = !1;
+                  if (c.ANIMATE === "during")
+                    this.emit("layoutstarted");
+                  else {
+                    for (; !n; )
+                      n = this.tick();
+                    this.graphManager.updateBounds();
+                  }
+                }, x.prototype.moveNodes = function() {
+                  for (var n = this.getAllNodes(), E, p = 0; p < n.length; p++)
+                    E = n[p], E.calculateDisplacement();
+                  Object.keys(this.constraints).length > 0 && this.updateDisplacements();
+                  for (var p = 0; p < n.length; p++)
+                    E = n[p], E.move();
+                }, x.prototype.initConstraintVariables = function() {
+                  var n = this;
+                  this.idToNodeMap = /* @__PURE__ */ new Map(), this.fixedNodeSet = /* @__PURE__ */ new Set();
+                  for (var E = this.graphManager.getAllNodes(), p = 0; p < E.length; p++) {
+                    var v = E[p];
+                    this.idToNodeMap.set(v.id, v);
+                  }
+                  var m = function D(b) {
+                    for (var q = b.getChild().getNodes(), et, vt = 0, j = 0; j < q.length; j++)
+                      et = q[j], et.getChild() == null ? n.fixedNodeSet.has(et.id) && (vt += 100) : vt += D(et);
+                    return vt;
+                  };
+                  if (this.constraints.fixedNodeConstraint) {
+                    this.constraints.fixedNodeConstraint.forEach(function(D) {
+                      n.fixedNodeSet.add(D.nodeId);
+                    });
+                    for (var E = this.graphManager.getAllNodes(), v, p = 0; p < E.length; p++)
+                      if (v = E[p], v.getChild() != null) {
+                        var O = m(v);
+                        O > 0 && (v.fixedNodeWeight = O);
+                      }
+                  }
+                  if (this.constraints.relativePlacementConstraint) {
+                    var _ = /* @__PURE__ */ new Map(), C = /* @__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(D) {
+                      n.fixedNodesOnHorizontal.add(D), n.fixedNodesOnVertical.add(D);
+                    }), this.constraints.alignmentConstraint) {
+                      if (this.constraints.alignmentConstraint.vertical)
+                        for (var F = this.constraints.alignmentConstraint.vertical, p = 0; p < F.length; p++)
+                          this.dummyToNodeForVerticalAlignment.set("dummy" + p, []), F[p].forEach(function(b) {
+                            _.set(b, "dummy" + p), n.dummyToNodeForVerticalAlignment.get("dummy" + p).push(b), n.fixedNodeSet.has(b) && n.fixedNodesOnHorizontal.add("dummy" + p);
+                          });
+                      if (this.constraints.alignmentConstraint.horizontal)
+                        for (var k = this.constraints.alignmentConstraint.horizontal, p = 0; p < k.length; p++)
+                          this.dummyToNodeForHorizontalAlignment.set("dummy" + p, []), k[p].forEach(function(b) {
+                            C.set(b, "dummy" + p), n.dummyToNodeForHorizontalAlignment.get("dummy" + p).push(b), n.fixedNodeSet.has(b) && n.fixedNodesOnVertical.add("dummy" + p);
+                          });
+                    }
+                    if (a.RELAX_MOVEMENT_ON_CONSTRAINTS)
+                      this.shuffle = function(D) {
+                        var b, q, et;
+                        for (et = D.length - 1; et >= 2 * D.length / 3; et--)
+                          b = Math.floor(Math.random() * (et + 1)), q = D[et], D[et] = D[b], D[b] = q;
+                        return D;
+                      }, 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(D) {
+                        if (D.left) {
+                          var b = _.has(D.left) ? _.get(D.left) : D.left, q = _.has(D.right) ? _.get(D.right) : D.right;
+                          n.nodesInRelativeHorizontal.includes(b) || (n.nodesInRelativeHorizontal.push(b), n.nodeToRelativeConstraintMapHorizontal.set(b, []), n.dummyToNodeForVerticalAlignment.has(b) ? n.nodeToTempPositionMapHorizontal.set(b, n.idToNodeMap.get(n.dummyToNodeForVerticalAlignment.get(b)[0]).getCenterX()) : n.nodeToTempPositionMapHorizontal.set(b, n.idToNodeMap.get(b).getCenterX())), n.nodesInRelativeHorizontal.includes(q) || (n.nodesInRelativeHorizontal.push(q), n.nodeToRelativeConstraintMapHorizontal.set(q, []), n.dummyToNodeForVerticalAlignment.has(q) ? n.nodeToTempPositionMapHorizontal.set(q, n.idToNodeMap.get(n.dummyToNodeForVerticalAlignment.get(q)[0]).getCenterX()) : n.nodeToTempPositionMapHorizontal.set(q, n.idToNodeMap.get(q).getCenterX())), n.nodeToRelativeConstraintMapHorizontal.get(b).push({ right: q, gap: D.gap }), n.nodeToRelativeConstraintMapHorizontal.get(q).push({ left: b, gap: D.gap });
+                        } else {
+                          var et = C.has(D.top) ? C.get(D.top) : D.top, vt = C.has(D.bottom) ? C.get(D.bottom) : D.bottom;
+                          n.nodesInRelativeVertical.includes(et) || (n.nodesInRelativeVertical.push(et), n.nodeToRelativeConstraintMapVertical.set(et, []), n.dummyToNodeForHorizontalAlignment.has(et) ? n.nodeToTempPositionMapVertical.set(et, n.idToNodeMap.get(n.dummyToNodeForHorizontalAlignment.get(et)[0]).getCenterY()) : n.nodeToTempPositionMapVertical.set(et, n.idToNodeMap.get(et).getCenterY())), n.nodesInRelativeVertical.includes(vt) || (n.nodesInRelativeVertical.push(vt), n.nodeToRelativeConstraintMapVertical.set(vt, []), n.dummyToNodeForHorizontalAlignment.has(vt) ? n.nodeToTempPositionMapVertical.set(vt, n.idToNodeMap.get(n.dummyToNodeForHorizontalAlignment.get(vt)[0]).getCenterY()) : n.nodeToTempPositionMapVertical.set(vt, n.idToNodeMap.get(vt).getCenterY())), n.nodeToRelativeConstraintMapVertical.get(et).push({ bottom: vt, gap: D.gap }), n.nodeToRelativeConstraintMapVertical.get(vt).push({ top: et, gap: D.gap });
+                        }
+                      });
+                    else {
+                      var V = /* @__PURE__ */ new Map(), z = /* @__PURE__ */ new Map();
+                      this.constraints.relativePlacementConstraint.forEach(function(D) {
+                        if (D.left) {
+                          var b = _.has(D.left) ? _.get(D.left) : D.left, q = _.has(D.right) ? _.get(D.right) : D.right;
+                          V.has(b) ? V.get(b).push(q) : V.set(b, [q]), V.has(q) ? V.get(q).push(b) : V.set(q, [b]);
+                        } else {
+                          var et = C.has(D.top) ? C.get(D.top) : D.top, vt = C.has(D.bottom) ? C.get(D.bottom) : D.bottom;
+                          z.has(et) ? z.get(et).push(vt) : z.set(et, [vt]), z.has(vt) ? z.get(vt).push(et) : z.set(vt, [et]);
+                        }
+                      });
+                      var H = function(D, b) {
+                        var q = [], et = [], vt = new B(), j = /* @__PURE__ */ new Set(), Dt = 0;
+                        return D.forEach(function(J, ot) {
+                          if (!j.has(ot)) {
+                            q[Dt] = [], et[Dt] = !1;
+                            var mt = ot;
+                            for (vt.push(mt), j.add(mt), q[Dt].push(mt); vt.length != 0; ) {
+                              mt = vt.shift(), b.has(mt) && (et[Dt] = !0);
+                              var ht = D.get(mt);
+                              ht.forEach(function(Lt) {
+                                j.has(Lt) || (vt.push(Lt), j.add(Lt), q[Dt].push(Lt));
+                              });
+                            }
+                            Dt++;
+                          }
+                        }), { components: q, isFixed: et };
+                      }, Z = H(V, n.fixedNodesOnHorizontal);
+                      this.componentsOnHorizontal = Z.components, this.fixedComponentsOnHorizontal = Z.isFixed;
+                      var G = H(z, n.fixedNodesOnVertical);
+                      this.componentsOnVertical = G.components, this.fixedComponentsOnVertical = G.isFixed;
+                    }
+                  }
+                }, x.prototype.updateDisplacements = function() {
+                  var n = this;
+                  if (this.constraints.fixedNodeConstraint && this.constraints.fixedNodeConstraint.forEach(function(G) {
+                    var D = n.idToNodeMap.get(G.nodeId);
+                    D.displacementX = 0, D.displacementY = 0;
+                  }), this.constraints.alignmentConstraint) {
+                    if (this.constraints.alignmentConstraint.vertical)
+                      for (var E = this.constraints.alignmentConstraint.vertical, p = 0; p < E.length; p++) {
+                        for (var v = 0, m = 0; m < E[p].length; m++) {
+                          if (this.fixedNodeSet.has(E[p][m])) {
+                            v = 0;
+                            break;
+                          }
+                          v += this.idToNodeMap.get(E[p][m]).displacementX;
+                        }
+                        for (var O = v / E[p].length, m = 0; m < E[p].length; m++)
+                          this.idToNodeMap.get(E[p][m]).displacementX = O;
+                      }
+                    if (this.constraints.alignmentConstraint.horizontal)
+                      for (var _ = this.constraints.alignmentConstraint.horizontal, p = 0; p < _.length; p++) {
+                        for (var C = 0, m = 0; m < _[p].length; m++) {
+                          if (this.fixedNodeSet.has(_[p][m])) {
+                            C = 0;
+                            break;
+                          }
+                          C += this.idToNodeMap.get(_[p][m]).displacementY;
+                        }
+                        for (var F = C / _[p].length, m = 0; m < _[p].length; m++)
+                          this.idToNodeMap.get(_[p][m]).displacementY = F;
+                      }
+                  }
+                  if (this.constraints.relativePlacementConstraint)
+                    if (a.RELAX_MOVEMENT_ON_CONSTRAINTS)
+                      this.totalIterations % 10 == 0 && (this.shuffle(this.nodesInRelativeHorizontal), this.shuffle(this.nodesInRelativeVertical)), this.nodesInRelativeHorizontal.forEach(function(G) {
+                        if (!n.fixedNodesOnHorizontal.has(G)) {
+                          var D = 0;
+                          n.dummyToNodeForVerticalAlignment.has(G) ? D = n.idToNodeMap.get(n.dummyToNodeForVerticalAlignment.get(G)[0]).displacementX : D = n.idToNodeMap.get(G).displacementX, n.nodeToRelativeConstraintMapHorizontal.get(G).forEach(function(b) {
+                            if (b.right) {
+                              var q = n.nodeToTempPositionMapHorizontal.get(b.right) - n.nodeToTempPositionMapHorizontal.get(G) - D;
+                              q < b.gap && (D -= b.gap - q);
+                            } else {
+                              var q = n.nodeToTempPositionMapHorizontal.get(G) - n.nodeToTempPositionMapHorizontal.get(b.left) + D;
+                              q < b.gap && (D += b.gap - q);
+                            }
+                          }), n.nodeToTempPositionMapHorizontal.set(G, n.nodeToTempPositionMapHorizontal.get(G) + D), n.dummyToNodeForVerticalAlignment.has(G) ? n.dummyToNodeForVerticalAlignment.get(G).forEach(function(b) {
+                            n.idToNodeMap.get(b).displacementX = D;
+                          }) : n.idToNodeMap.get(G).displacementX = D;
+                        }
+                      }), this.nodesInRelativeVertical.forEach(function(G) {
+                        if (!n.fixedNodesOnHorizontal.has(G)) {
+                          var D = 0;
+                          n.dummyToNodeForHorizontalAlignment.has(G) ? D = n.idToNodeMap.get(n.dummyToNodeForHorizontalAlignment.get(G)[0]).displacementY : D = n.idToNodeMap.get(G).displacementY, n.nodeToRelativeConstraintMapVertical.get(G).forEach(function(b) {
+                            if (b.bottom) {
+                              var q = n.nodeToTempPositionMapVertical.get(b.bottom) - n.nodeToTempPositionMapVertical.get(G) - D;
+                              q < b.gap && (D -= b.gap - q);
+                            } else {
+                              var q = n.nodeToTempPositionMapVertical.get(G) - n.nodeToTempPositionMapVertical.get(b.top) + D;
+                              q < b.gap && (D += b.gap - q);
+                            }
+                          }), n.nodeToTempPositionMapVertical.set(G, n.nodeToTempPositionMapVertical.get(G) + D), n.dummyToNodeForHorizontalAlignment.has(G) ? n.dummyToNodeForHorizontalAlignment.get(G).forEach(function(b) {
+                            n.idToNodeMap.get(b).displacementY = D;
+                          }) : n.idToNodeMap.get(G).displacementY = D;
+                        }
+                      });
+                    else {
+                      for (var p = 0; p < this.componentsOnHorizontal.length; p++) {
+                        var k = this.componentsOnHorizontal[p];
+                        if (this.fixedComponentsOnHorizontal[p])
+                          for (var m = 0; m < k.length; m++)
+                            this.dummyToNodeForVerticalAlignment.has(k[m]) ? this.dummyToNodeForVerticalAlignment.get(k[m]).forEach(function(b) {
+                              n.idToNodeMap.get(b).displacementX = 0;
+                            }) : this.idToNodeMap.get(k[m]).displacementX = 0;
+                        else {
+                          for (var V = 0, z = 0, m = 0; m < k.length; m++)
+                            if (this.dummyToNodeForVerticalAlignment.has(k[m])) {
+                              var H = this.dummyToNodeForVerticalAlignment.get(k[m]);
+                              V += H.length * this.idToNodeMap.get(H[0]).displacementX, z += H.length;
+                            } else
+                              V += this.idToNodeMap.get(k[m]).displacementX, z++;
+                          for (var Z = V / z, m = 0; m < k.length; m++)
+                            this.dummyToNodeForVerticalAlignment.has(k[m]) ? this.dummyToNodeForVerticalAlignment.get(k[m]).forEach(function(b) {
+                              n.idToNodeMap.get(b).displacementX = Z;
+                            }) : this.idToNodeMap.get(k[m]).displacementX = Z;
+                        }
+                      }
+                      for (var p = 0; p < this.componentsOnVertical.length; p++) {
+                        var k = this.componentsOnVertical[p];
+                        if (this.fixedComponentsOnVertical[p])
+                          for (var m = 0; m < k.length; m++)
+                            this.dummyToNodeForHorizontalAlignment.has(k[m]) ? this.dummyToNodeForHorizontalAlignment.get(k[m]).forEach(function(q) {
+                              n.idToNodeMap.get(q).displacementY = 0;
+                            }) : this.idToNodeMap.get(k[m]).displacementY = 0;
+                        else {
+                          for (var V = 0, z = 0, m = 0; m < k.length; m++)
+                            if (this.dummyToNodeForHorizontalAlignment.has(k[m])) {
+                              var H = this.dummyToNodeForHorizontalAlignment.get(k[m]);
+                              V += H.length * this.idToNodeMap.get(H[0]).displacementY, z += H.length;
+                            } else
+                              V += this.idToNodeMap.get(k[m]).displacementY, z++;
+                          for (var Z = V / z, m = 0; m < k.length; m++)
+                            this.dummyToNodeForHorizontalAlignment.has(k[m]) ? this.dummyToNodeForHorizontalAlignment.get(k[m]).forEach(function(et) {
+                              n.idToNodeMap.get(et).displacementY = Z;
+                            }) : this.idToNodeMap.get(k[m]).displacementY = Z;
+                        }
+                      }
+                    }
+                }, x.prototype.calculateNodesToApplyGravitationTo = function() {
+                  var n = [], E, p = this.graphManager.getGraphs(), v = p.length, m;
+                  for (m = 0; m < v; m++)
+                    E = p[m], E.updateConnected(), E.isConnected || (n = n.concat(E.getNodes()));
+                  return n;
+                }, x.prototype.createBendpoints = function() {
+                  var n = [];
+                  n = n.concat(this.graphManager.getAllEdges());
+                  var E = /* @__PURE__ */ new Set(), p;
+                  for (p = 0; p < n.length; p++) {
+                    var v = n[p];
+                    if (!E.has(v)) {
+                      var m = v.getSource(), O = v.getTarget();
+                      if (m == O)
+                        v.getBendpoints().push(new y()), v.getBendpoints().push(new y()), this.createDummyNodesForBendpoints(v), E.add(v);
+                      else {
+                        var _ = [];
+                        if (_ = _.concat(m.getEdgeListToNode(O)), _ = _.concat(O.getEdgeListToNode(m)), !E.has(_[0])) {
+                          if (_.length > 1) {
+                            var C;
+                            for (C = 0; C < _.length; C++) {
+                              var F = _[C];
+                              F.getBendpoints().push(new y()), this.createDummyNodesForBendpoints(F);
+                            }
+                          }
+                          _.forEach(function(k) {
+                            E.add(k);
+                          });
+                        }
+                      }
+                    }
+                    if (E.size == n.length)
+                      break;
+                  }
+                }, x.prototype.positionNodesRadially = function(n) {
+                  for (var E = new d(0, 0), p = Math.ceil(Math.sqrt(n.length)), v = 0, m = 0, O = 0, _ = new y(0, 0), C = 0; C < n.length; C++) {
+                    C % p == 0 && (O = 0, m = v, C != 0 && (m += a.DEFAULT_COMPONENT_SEPERATION), v = 0);
+                    var F = n[C], k = M.findCenterOfTree(F);
+                    E.x = O, E.y = m, _ = x.radialLayout(F, k, E), _.y > v && (v = Math.floor(_.y)), O = Math.floor(_.x + a.DEFAULT_COMPONENT_SEPERATION);
+                  }
+                  this.transform(new y(N.WORLD_CENTER_X - _.x / 2, N.WORLD_CENTER_Y - _.y / 2));
+                }, x.radialLayout = function(n, E, p) {
+                  var v = Math.max(this.maxDiagonalInTree(n), a.DEFAULT_RADIAL_SEPARATION);
+                  x.branchRadialLayout(E, null, 0, 359, 0, v);
+                  var m = Y.calculateBounds(n), O = new W();
+                  O.setDeviceOrgX(m.getMinX()), O.setDeviceOrgY(m.getMinY()), O.setWorldOrgX(p.x), O.setWorldOrgY(p.y);
+                  for (var _ = 0; _ < n.length; _++) {
+                    var C = n[_];
+                    C.transform(O);
+                  }
+                  var F = new y(m.getMaxX(), m.getMaxY());
+                  return O.inverseTransformPoint(F);
+                }, x.branchRadialLayout = function(n, E, p, v, m, O) {
+                  var _ = (v - p + 1) / 2;
+                  _ < 0 && (_ += 180);
+                  var C = (_ + p) % 360, F = C * S.TWO_PI / 360, k = m * Math.cos(F), V = m * Math.sin(F);
+                  n.setCenter(k, V);
+                  var z = [];
+                  z = z.concat(n.getEdges());
+                  var H = z.length;
+                  E != null && H--;
+                  for (var Z = 0, G = z.length, D, b = n.getEdgesBetween(E); b.length > 1; ) {
+                    var q = b[0];
+                    b.splice(0, 1);
+                    var et = z.indexOf(q);
+                    et >= 0 && z.splice(et, 1), G--, H--;
+                  }
+                  E != null ? D = (z.indexOf(b[0]) + 1) % G : D = 0;
+                  for (var vt = Math.abs(v - p) / H, j = D; Z != H; j = ++j % G) {
+                    var Dt = z[j].getOtherEnd(n);
+                    if (Dt != E) {
+                      var J = (p + Z * vt) % 360, ot = (J + vt) % 360;
+                      x.branchRadialLayout(Dt, n, J, ot, m + O, O), Z++;
+                    }
+                  }
+                }, x.maxDiagonalInTree = function(n) {
+                  for (var E = P.MIN_VALUE, p = 0; p < n.length; p++) {
+                    var v = n[p], m = v.getDiagonal();
+                    m > E && (E = m);
+                  }
+                  return E;
+                }, x.prototype.calcRepulsionRange = function() {
+                  return 2 * (this.level + 1) * this.idealEdgeLength;
+                }, x.prototype.groupZeroDegreeMembers = function() {
+                  var n = this, E = {};
+                  this.memberGroups = {}, this.idToDummyNode = {};
+                  for (var p = [], v = this.graphManager.getAllNodes(), m = 0; m < v.length; m++) {
+                    var O = v[m], _ = O.getParent();
+                    this.getNodeDegreeWithChildren(O) === 0 && (_.id == null || !this.getToBeTiled(_)) && p.push(O);
+                  }
+                  for (var m = 0; m < p.length; m++) {
+                    var O = p[m], C = O.getParent().id;
+                    typeof E[C] > "u" && (E[C] = []), E[C] = E[C].concat(O);
+                  }
+                  Object.keys(E).forEach(function(F) {
+                    if (E[F].length > 1) {
+                      var k = "DummyCompound_" + F;
+                      n.memberGroups[k] = E[F];
+                      var V = E[F][0].getParent(), z = new e(n.graphManager);
+                      z.id = k, z.paddingLeft = V.paddingLeft || 0, z.paddingRight = V.paddingRight || 0, z.paddingBottom = V.paddingBottom || 0, z.paddingTop = V.paddingTop || 0, n.idToDummyNode[k] = z;
+                      var H = n.getGraphManager().add(n.newGraph(), z), Z = V.getChild();
+                      Z.add(z);
+                      for (var G = 0; G < E[F].length; G++) {
+                        var D = E[F][G];
+                        Z.remove(D), H.add(D);
+                      }
+                    }
+                  });
+                }, x.prototype.clearCompounds = function() {
+                  var n = {}, E = {};
+                  this.performDFSOnCompounds();
+                  for (var p = 0; p < this.compoundOrder.length; p++)
+                    E[this.compoundOrder[p].id] = this.compoundOrder[p], n[this.compoundOrder[p].id] = [].concat(this.compoundOrder[p].getChild().getNodes()), this.graphManager.remove(this.compoundOrder[p].getChild()), this.compoundOrder[p].child = null;
+                  this.graphManager.resetAllNodes(), this.tileCompoundMembers(n, E);
+                }, x.prototype.clearZeroDegreeMembers = function() {
+                  var n = this, E = this.tiledZeroDegreePack = [];
+                  Object.keys(this.memberGroups).forEach(function(p) {
+                    var v = n.idToDummyNode[p];
+                    if (E[p] = n.tileNodes(n.memberGroups[p], v.paddingLeft + v.paddingRight), v.rect.width = E[p].width, v.rect.height = E[p].height, v.setCenter(E[p].centerX, E[p].centerY), v.labelMarginLeft = 0, v.labelMarginTop = 0, a.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                      var m = v.rect.width, O = v.rect.height;
+                      v.labelWidth && (v.labelPosHorizontal == "left" ? (v.rect.x -= v.labelWidth, v.setWidth(m + v.labelWidth), v.labelMarginLeft = v.labelWidth) : v.labelPosHorizontal == "center" && v.labelWidth > m ? (v.rect.x -= (v.labelWidth - m) / 2, v.setWidth(v.labelWidth), v.labelMarginLeft = (v.labelWidth - m) / 2) : v.labelPosHorizontal == "right" && v.setWidth(m + v.labelWidth)), v.labelHeight && (v.labelPosVertical == "top" ? (v.rect.y -= v.labelHeight, v.setHeight(O + v.labelHeight), v.labelMarginTop = v.labelHeight) : v.labelPosVertical == "center" && v.labelHeight > O ? (v.rect.y -= (v.labelHeight - O) / 2, v.setHeight(v.labelHeight), v.labelMarginTop = (v.labelHeight - O) / 2) : v.labelPosVertical == "bottom" && v.setHeight(O + v.labelHeight));
+                    }
+                  });
+                }, x.prototype.repopulateCompounds = function() {
+                  for (var n = this.compoundOrder.length - 1; n >= 0; n--) {
+                    var E = this.compoundOrder[n], p = E.id, v = E.paddingLeft, m = E.paddingTop, O = E.labelMarginLeft, _ = E.labelMarginTop;
+                    this.adjustLocations(this.tiledMemberPack[p], E.rect.x, E.rect.y, v, m, O, _);
+                  }
+                }, x.prototype.repopulateZeroDegreeMembers = function() {
+                  var n = this, E = this.tiledZeroDegreePack;
+                  Object.keys(E).forEach(function(p) {
+                    var v = n.idToDummyNode[p], m = v.paddingLeft, O = v.paddingTop, _ = v.labelMarginLeft, C = v.labelMarginTop;
+                    n.adjustLocations(E[p], v.rect.x, v.rect.y, m, O, _, C);
+                  });
+                }, x.prototype.getToBeTiled = function(n) {
+                  var E = n.id;
+                  if (this.toBeTiled[E] != null)
+                    return this.toBeTiled[E];
+                  var p = n.getChild();
+                  if (p == null)
+                    return this.toBeTiled[E] = !1, !1;
+                  for (var v = p.getNodes(), m = 0; m < v.length; m++) {
+                    var O = v[m];
+                    if (this.getNodeDegree(O) > 0)
+                      return this.toBeTiled[E] = !1, !1;
+                    if (O.getChild() == null) {
+                      this.toBeTiled[O.id] = !1;
+                      continue;
+                    }
+                    if (!this.getToBeTiled(O))
+                      return this.toBeTiled[E] = !1, !1;
+                  }
+                  return this.toBeTiled[E] = !0, !0;
+                }, x.prototype.getNodeDegree = function(n) {
+                  n.id;
+                  for (var E = n.getEdges(), p = 0, v = 0; v < E.length; v++) {
+                    var m = E[v];
+                    m.getSource().id !== m.getTarget().id && (p = p + 1);
+                  }
+                  return p;
+                }, x.prototype.getNodeDegreeWithChildren = function(n) {
+                  var E = this.getNodeDegree(n);
+                  if (n.getChild() == null)
+                    return E;
+                  for (var p = n.getChild().getNodes(), v = 0; v < p.length; v++) {
+                    var m = p[v];
+                    E += this.getNodeDegreeWithChildren(m);
+                  }
+                  return E;
+                }, x.prototype.performDFSOnCompounds = function() {
+                  this.compoundOrder = [], this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes());
+                }, x.prototype.fillCompexOrderByDFS = function(n) {
+                  for (var E = 0; E < n.length; E++) {
+                    var p = n[E];
+                    p.getChild() != null && this.fillCompexOrderByDFS(p.getChild().getNodes()), this.getToBeTiled(p) && this.compoundOrder.push(p);
+                  }
+                }, x.prototype.adjustLocations = function(n, E, p, v, m, O, _) {
+                  E += v + O, p += m + _;
+                  for (var C = E, F = 0; F < n.rows.length; F++) {
+                    var k = n.rows[F];
+                    E = C;
+                    for (var V = 0, z = 0; z < k.length; z++) {
+                      var H = k[z];
+                      H.rect.x = E, H.rect.y = p, E += H.rect.width + n.horizontalPadding, H.rect.height > V && (V = H.rect.height);
+                    }
+                    p += V + n.verticalPadding;
+                  }
+                }, x.prototype.tileCompoundMembers = function(n, E) {
+                  var p = this;
+                  this.tiledMemberPack = [], Object.keys(n).forEach(function(v) {
+                    var m = E[v];
+                    if (p.tiledMemberPack[v] = p.tileNodes(n[v], m.paddingLeft + m.paddingRight), m.rect.width = p.tiledMemberPack[v].width, m.rect.height = p.tiledMemberPack[v].height, m.setCenter(p.tiledMemberPack[v].centerX, p.tiledMemberPack[v].centerY), m.labelMarginLeft = 0, m.labelMarginTop = 0, a.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                      var O = m.rect.width, _ = m.rect.height;
+                      m.labelWidth && (m.labelPosHorizontal == "left" ? (m.rect.x -= m.labelWidth, m.setWidth(O + m.labelWidth), m.labelMarginLeft = m.labelWidth) : m.labelPosHorizontal == "center" && m.labelWidth > O ? (m.rect.x -= (m.labelWidth - O) / 2, m.setWidth(m.labelWidth), m.labelMarginLeft = (m.labelWidth - O) / 2) : m.labelPosHorizontal == "right" && m.setWidth(O + m.labelWidth)), m.labelHeight && (m.labelPosVertical == "top" ? (m.rect.y -= m.labelHeight, m.setHeight(_ + m.labelHeight), m.labelMarginTop = m.labelHeight) : m.labelPosVertical == "center" && m.labelHeight > _ ? (m.rect.y -= (m.labelHeight - _) / 2, m.setHeight(m.labelHeight), m.labelMarginTop = (m.labelHeight - _) / 2) : m.labelPosVertical == "bottom" && m.setHeight(_ + m.labelHeight));
+                    }
+                  });
+                }, x.prototype.tileNodes = function(n, E) {
+                  var p = this.tileNodesByFavoringDim(n, E, !0), v = this.tileNodesByFavoringDim(n, E, !1), m = this.getOrgRatio(p), O = this.getOrgRatio(v), _;
+                  return O < m ? _ = v : _ = p, _;
+                }, x.prototype.getOrgRatio = function(n) {
+                  var E = n.width, p = n.height, v = E / p;
+                  return v < 1 && (v = 1 / v), v;
+                }, x.prototype.calcIdealRowWidth = function(n, E) {
+                  var p = a.TILING_PADDING_VERTICAL, v = a.TILING_PADDING_HORIZONTAL, m = n.length, O = 0, _ = 0, C = 0;
+                  n.forEach(function(G) {
+                    O += G.getWidth(), _ += G.getHeight(), G.getWidth() > C && (C = G.getWidth());
+                  });
+                  var F = O / m, k = _ / m, V = Math.pow(p - v, 2) + 4 * (F + v) * (k + p) * m, z = (v - p + Math.sqrt(V)) / (2 * (F + v)), H;
+                  E ? (H = Math.ceil(z), H == z && H++) : H = Math.floor(z);
+                  var Z = H * (F + v) - v;
+                  return C > Z && (Z = C), Z += v * 2, Z;
+                }, x.prototype.tileNodesByFavoringDim = function(n, E, p) {
+                  var v = a.TILING_PADDING_VERTICAL, m = a.TILING_PADDING_HORIZONTAL, O = a.TILING_COMPARE_BY, _ = {
+                    rows: [],
+                    rowWidth: [],
+                    rowHeight: [],
+                    width: 0,
+                    height: E,
+                    // assume minHeight equals to minWidth
+                    verticalPadding: v,
+                    horizontalPadding: m,
+                    centerX: 0,
+                    centerY: 0
+                  };
+                  O && (_.idealRowWidth = this.calcIdealRowWidth(n, p));
+                  var C = function(G) {
+                    return G.rect.width * G.rect.height;
+                  }, F = function(G, D) {
+                    return C(D) - C(G);
+                  };
+                  n.sort(function(G, D) {
+                    var b = F;
+                    return _.idealRowWidth ? (b = O, b(G.id, D.id)) : b(G, D);
+                  });
+                  for (var k = 0, V = 0, z = 0; z < n.length; z++) {
+                    var H = n[z];
+                    k += H.getCenterX(), V += H.getCenterY();
+                  }
+                  _.centerX = k / n.length, _.centerY = V / n.length;
+                  for (var z = 0; z < n.length; z++) {
+                    var H = n[z];
+                    if (_.rows.length == 0)
+                      this.insertNodeToRow(_, H, 0, E);
+                    else if (this.canAddHorizontal(_, H.rect.width, H.rect.height)) {
+                      var Z = _.rows.length - 1;
+                      _.idealRowWidth || (Z = this.getShortestRowIndex(_)), this.insertNodeToRow(_, H, Z, E);
+                    } else
+                      this.insertNodeToRow(_, H, _.rows.length, E);
+                    this.shiftToLastRow(_);
+                  }
+                  return _;
+                }, x.prototype.insertNodeToRow = function(n, E, p, v) {
+                  var m = v;
+                  if (p == n.rows.length) {
+                    var O = [];
+                    n.rows.push(O), n.rowWidth.push(m), n.rowHeight.push(0);
+                  }
+                  var _ = n.rowWidth[p] + E.rect.width;
+                  n.rows[p].length > 0 && (_ += n.horizontalPadding), n.rowWidth[p] = _, n.width < _ && (n.width = _);
+                  var C = E.rect.height;
+                  p > 0 && (C += n.verticalPadding);
+                  var F = 0;
+                  C > n.rowHeight[p] && (F = n.rowHeight[p], n.rowHeight[p] = C, F = n.rowHeight[p] - F), n.height += F, n.rows[p].push(E);
+                }, x.prototype.getShortestRowIndex = function(n) {
+                  for (var E = -1, p = Number.MAX_VALUE, v = 0; v < n.rows.length; v++)
+                    n.rowWidth[v] < p && (E = v, p = n.rowWidth[v]);
+                  return E;
+                }, x.prototype.getLongestRowIndex = function(n) {
+                  for (var E = -1, p = Number.MIN_VALUE, v = 0; v < n.rows.length; v++)
+                    n.rowWidth[v] > p && (E = v, p = n.rowWidth[v]);
+                  return E;
+                }, x.prototype.canAddHorizontal = function(n, E, p) {
+                  if (n.idealRowWidth) {
+                    var v = n.rows.length - 1, m = n.rowWidth[v];
+                    return m + E + n.horizontalPadding <= n.idealRowWidth;
+                  }
+                  var O = this.getShortestRowIndex(n);
+                  if (O < 0)
+                    return !0;
+                  var _ = n.rowWidth[O];
+                  if (_ + n.horizontalPadding + E <= n.width)
+                    return !0;
+                  var C = 0;
+                  n.rowHeight[O] < p && O > 0 && (C = p + n.verticalPadding - n.rowHeight[O]);
+                  var F;
+                  n.width - _ >= E + n.horizontalPadding ? F = (n.height + C) / (_ + E + n.horizontalPadding) : F = (n.height + C) / n.width, C = p + n.verticalPadding;
+                  var k;
+                  return n.width < E ? k = (n.height + C) / E : k = (n.height + C) / n.width, k < 1 && (k = 1 / k), F < 1 && (F = 1 / F), F < k;
+                }, x.prototype.shiftToLastRow = function(n) {
+                  var E = this.getLongestRowIndex(n), p = n.rowWidth.length - 1, v = n.rows[E], m = v[v.length - 1], O = m.width + n.horizontalPadding;
+                  if (n.width - n.rowWidth[p] > O && E != p) {
+                    v.splice(-1, 1), n.rows[p].push(m), n.rowWidth[E] = n.rowWidth[E] - O, n.rowWidth[p] = n.rowWidth[p] + O, n.width = n.rowWidth[instance.getLongestRowIndex(n)];
+                    for (var _ = Number.MIN_VALUE, C = 0; C < v.length; C++)
+                      v[C].height > _ && (_ = v[C].height);
+                    E > 0 && (_ += n.verticalPadding);
+                    var F = n.rowHeight[E] + n.rowHeight[p];
+                    n.rowHeight[E] = _, n.rowHeight[p] < m.height + n.verticalPadding && (n.rowHeight[p] = m.height + n.verticalPadding);
+                    var k = n.rowHeight[E] + n.rowHeight[p];
+                    n.height += k - F, this.shiftToLastRow(n);
+                  }
+                }, x.prototype.tilingPreLayout = function() {
+                  a.TILE && (this.groupZeroDegreeMembers(), this.clearCompounds(), this.clearZeroDegreeMembers());
+                }, x.prototype.tilingPostLayout = function() {
+                  a.TILE && (this.repopulateZeroDegreeMembers(), this.repopulateCompounds());
+                }, x.prototype.reduceTrees = function() {
+                  for (var n = [], E = !0, p; E; ) {
+                    var v = this.graphManager.getAllNodes(), m = [];
+                    E = !1;
+                    for (var O = 0; O < v.length; O++)
+                      if (p = v[O], p.getEdges().length == 1 && !p.getEdges()[0].isInterGraph && p.getChild() == null) {
+                        if (a.PURE_INCREMENTAL) {
+                          var _ = p.getEdges()[0].getOtherEnd(p), C = new w(p.getCenterX() - _.getCenterX(), p.getCenterY() - _.getCenterY());
+                          m.push([p, p.getEdges()[0], p.getOwner(), C]);
+                        } else
+                          m.push([p, p.getEdges()[0], p.getOwner()]);
+                        E = !0;
+                      }
+                    if (E == !0) {
+                      for (var F = [], k = 0; k < m.length; k++)
+                        m[k][0].getEdges().length == 1 && (F.push(m[k]), m[k][0].getOwner().remove(m[k][0]));
+                      n.push(F), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+                    }
+                  }
+                  this.prunedNodesAll = n;
+                }, x.prototype.growTree = function(n) {
+                  for (var E = n.length, p = n[E - 1], v, m = 0; m < p.length; m++)
+                    v = p[m], this.findPlaceforPrunedNode(v), v[2].add(v[0]), v[2].add(v[1], v[1].source, v[1].target);
+                  n.splice(n.length - 1, 1), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+                }, x.prototype.findPlaceforPrunedNode = function(n) {
+                  var E, p, v = n[0];
+                  if (v == n[1].source ? p = n[1].target : p = n[1].source, a.PURE_INCREMENTAL)
+                    v.setCenter(p.getCenterX() + n[3].getWidth(), p.getCenterY() + n[3].getHeight());
+                  else {
+                    var m = p.startX, O = p.finishX, _ = p.startY, C = p.finishY, F = 0, k = 0, V = 0, z = 0, H = [F, V, k, z];
+                    if (_ > 0)
+                      for (var Z = m; Z <= O; Z++)
+                        H[0] += this.grid[Z][_ - 1].length + this.grid[Z][_].length - 1;
+                    if (O < this.grid.length - 1)
+                      for (var Z = _; Z <= C; Z++)
+                        H[1] += this.grid[O + 1][Z].length + this.grid[O][Z].length - 1;
+                    if (C < this.grid[0].length - 1)
+                      for (var Z = m; Z <= O; Z++)
+                        H[2] += this.grid[Z][C + 1].length + this.grid[Z][C].length - 1;
+                    if (m > 0)
+                      for (var Z = _; Z <= C; Z++)
+                        H[3] += this.grid[m - 1][Z].length + this.grid[m][Z].length - 1;
+                    for (var G = P.MAX_VALUE, D, b, q = 0; q < H.length; q++)
+                      H[q] < G ? (G = H[q], D = 1, b = q) : H[q] == G && D++;
+                    if (D == 3 && G == 0)
+                      H[0] == 0 && H[1] == 0 && H[2] == 0 ? E = 1 : H[0] == 0 && H[1] == 0 && H[3] == 0 ? E = 0 : H[0] == 0 && H[2] == 0 && H[3] == 0 ? E = 3 : H[1] == 0 && H[2] == 0 && H[3] == 0 && (E = 2);
+                    else if (D == 2 && G == 0) {
+                      var et = Math.floor(Math.random() * 2);
+                      H[0] == 0 && H[1] == 0 ? et == 0 ? E = 0 : E = 1 : H[0] == 0 && H[2] == 0 ? et == 0 ? E = 0 : E = 2 : H[0] == 0 && H[3] == 0 ? et == 0 ? E = 0 : E = 3 : H[1] == 0 && H[2] == 0 ? et == 0 ? E = 1 : E = 2 : H[1] == 0 && H[3] == 0 ? et == 0 ? E = 1 : E = 3 : et == 0 ? E = 2 : E = 3;
+                    } else if (D == 4 && G == 0) {
+                      var et = Math.floor(Math.random() * 4);
+                      E = et;
+                    } else
+                      E = b;
+                    E == 0 ? v.setCenter(p.getCenterX(), p.getCenterY() - p.getHeight() / 2 - c.DEFAULT_EDGE_LENGTH - v.getHeight() / 2) : E == 1 ? v.setCenter(p.getCenterX() + p.getWidth() / 2 + c.DEFAULT_EDGE_LENGTH + v.getWidth() / 2, p.getCenterY()) : E == 2 ? v.setCenter(p.getCenterX(), p.getCenterY() + p.getHeight() / 2 + c.DEFAULT_EDGE_LENGTH + v.getHeight() / 2) : v.setCenter(p.getCenterX() - p.getWidth() / 2 - c.DEFAULT_EDGE_LENGTH - v.getWidth() / 2, p.getCenterY());
+                  }
+                }, o.exports = x;
+              }
+            ),
+            /***/
+            991: (
+              /***/
+              (o, i, t) => {
+                var h = t(551).FDLayoutNode, r = t(551).IMath;
+                function f(s, a, g, c) {
+                  h.call(this, s, a, g, c);
+                }
+                f.prototype = Object.create(h.prototype);
+                for (var e in h)
+                  f[e] = h[e];
+                f.prototype.calculateDisplacement = function() {
+                  var s = this.graphManager.getLayout();
+                  this.getChild() != null && this.fixedNodeWeight ? (this.displacementX += s.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.fixedNodeWeight, this.displacementY += s.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.fixedNodeWeight) : (this.displacementX += s.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren, this.displacementY += s.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren), Math.abs(this.displacementX) > s.coolingFactor * s.maxNodeDisplacement && (this.displacementX = s.coolingFactor * s.maxNodeDisplacement * r.sign(this.displacementX)), Math.abs(this.displacementY) > s.coolingFactor * s.maxNodeDisplacement && (this.displacementY = s.coolingFactor * s.maxNodeDisplacement * r.sign(this.displacementY)), this.child && this.child.getNodes().length > 0 && this.propogateDisplacementToChildren(this.displacementX, this.displacementY);
+                }, f.prototype.propogateDisplacementToChildren = function(s, a) {
+                  for (var g = this.getChild().getNodes(), c, N = 0; N < g.length; N++)
+                    c = g[N], c.getChild() == null ? (c.displacementX += s, c.displacementY += a) : c.propogateDisplacementToChildren(s, a);
+                }, f.prototype.move = function() {
+                  var s = this.graphManager.getLayout();
+                  (this.child == null || this.child.getNodes().length == 0) && (this.moveBy(this.displacementX, this.displacementY), s.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;
+                }, f.prototype.setPred1 = function(s) {
+                  this.pred1 = s;
+                }, f.prototype.getPred1 = function() {
+                  return pred1;
+                }, f.prototype.getPred2 = function() {
+                  return pred2;
+                }, f.prototype.setNext = function(s) {
+                  this.next = s;
+                }, f.prototype.getNext = function() {
+                  return next;
+                }, f.prototype.setProcessed = function(s) {
+                  this.processed = s;
+                }, f.prototype.isProcessed = function() {
+                  return processed;
+                }, o.exports = f;
+              }
+            ),
+            /***/
+            902: (
+              /***/
+              (o, i, t) => {
+                function h(g) {
+                  if (Array.isArray(g)) {
+                    for (var c = 0, N = Array(g.length); c < g.length; c++)
+                      N[c] = g[c];
+                    return N;
+                  } else
+                    return Array.from(g);
+                }
+                var r = t(806), f = t(551).LinkedList, e = t(551).Matrix, s = t(551).SVD;
+                function a() {
+                }
+                a.handleConstraints = function(g) {
+                  var c = {};
+                  c.fixedNodeConstraint = g.constraints.fixedNodeConstraint, c.alignmentConstraint = g.constraints.alignmentConstraint, c.relativePlacementConstraint = g.constraints.relativePlacementConstraint;
+                  for (var N = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), y = [], w = [], M = g.getAllNodes(), P = 0, S = 0; S < M.length; S++) {
+                    var Y = M[S];
+                    Y.getChild() == null && (d.set(Y.id, P++), y.push(Y.getCenterX()), w.push(Y.getCenterY()), N.set(Y.id, Y));
+                  }
+                  c.relativePlacementConstraint && c.relativePlacementConstraint.forEach(function(I) {
+                    !I.gap && I.gap != 0 && (I.left ? I.gap = r.DEFAULT_EDGE_LENGTH + N.get(I.left).getWidth() / 2 + N.get(I.right).getWidth() / 2 : I.gap = r.DEFAULT_EDGE_LENGTH + N.get(I.top).getHeight() / 2 + N.get(I.bottom).getHeight() / 2);
+                  });
+                  var W = function(I, R) {
+                    return { x: I.x - R.x, y: I.y - R.y };
+                  }, B = function(I) {
+                    var R = 0, $ = 0;
+                    return I.forEach(function(Q) {
+                      R += y[d.get(Q)], $ += w[d.get(Q)];
+                    }), { x: R / I.size, y: $ / I.size };
+                  }, x = function(I, R, $, Q, K) {
+                    function pt(ct, at) {
+                      var st = new Set(ct), Mt = !0, ut = !1, Ot = void 0;
+                      try {
+                        for (var kt = at[Symbol.iterator](), It; !(Mt = (It = kt.next()).done); Mt = !0) {
+                          var At = It.value;
+                          st.add(At);
+                        }
+                      } catch (Ht) {
+                        ut = !0, Ot = Ht;
+                      } finally {
+                        try {
+                          !Mt && kt.return && kt.return();
+                        } finally {
+                          if (ut)
+                            throw Ot;
+                        }
+                      }
+                      return st;
+                    }
+                    var lt = /* @__PURE__ */ new Map();
+                    I.forEach(function(ct, at) {
+                      lt.set(at, 0);
+                    }), I.forEach(function(ct, at) {
+                      ct.forEach(function(st) {
+                        lt.set(st.id, lt.get(st.id) + 1);
+                      });
+                    });
+                    var tt = /* @__PURE__ */ new Map(), gt = /* @__PURE__ */ new Map(), it = new f();
+                    lt.forEach(function(ct, at) {
+                      ct == 0 ? (it.push(at), $ || (R == "horizontal" ? tt.set(at, d.has(at) ? y[d.get(at)] : Q.get(at)) : tt.set(at, d.has(at) ? w[d.get(at)] : Q.get(at)))) : tt.set(at, Number.NEGATIVE_INFINITY), $ && gt.set(at, /* @__PURE__ */ new Set([at]));
+                    }), $ && K.forEach(function(ct) {
+                      var at = [];
+                      if (ct.forEach(function(ut) {
+                        $.has(ut) && at.push(ut);
+                      }), at.length > 0) {
+                        var st = 0;
+                        at.forEach(function(ut) {
+                          R == "horizontal" ? (tt.set(ut, d.has(ut) ? y[d.get(ut)] : Q.get(ut)), st += tt.get(ut)) : (tt.set(ut, d.has(ut) ? w[d.get(ut)] : Q.get(ut)), st += tt.get(ut));
+                        }), st = st / at.length, ct.forEach(function(ut) {
+                          $.has(ut) || tt.set(ut, st);
+                        });
+                      } else {
+                        var Mt = 0;
+                        ct.forEach(function(ut) {
+                          R == "horizontal" ? Mt += d.has(ut) ? y[d.get(ut)] : Q.get(ut) : Mt += d.has(ut) ? w[d.get(ut)] : Q.get(ut);
+                        }), Mt = Mt / ct.length, ct.forEach(function(ut) {
+                          tt.set(ut, Mt);
+                        });
+                      }
+                    });
+                    for (var Nt = function() {
+                      var ct = it.shift(), at = I.get(ct);
+                      at.forEach(function(st) {
+                        if (tt.get(st.id) < tt.get(ct) + st.gap)
+                          if ($ && $.has(st.id)) {
+                            var Mt = void 0;
+                            if (R == "horizontal" ? Mt = d.has(st.id) ? y[d.get(st.id)] : Q.get(st.id) : Mt = d.has(st.id) ? w[d.get(st.id)] : Q.get(st.id), tt.set(st.id, Mt), Mt < tt.get(ct) + st.gap) {
+                              var ut = tt.get(ct) + st.gap - Mt;
+                              gt.get(ct).forEach(function(Ot) {
+                                tt.set(Ot, tt.get(Ot) - ut);
+                              });
+                            }
+                          } else
+                            tt.set(st.id, tt.get(ct) + st.gap);
+                        lt.set(st.id, lt.get(st.id) - 1), lt.get(st.id) == 0 && it.push(st.id), $ && gt.set(st.id, pt(gt.get(ct), gt.get(st.id)));
+                      });
+                    }; it.length != 0; )
+                      Nt();
+                    if ($) {
+                      var yt = /* @__PURE__ */ new Set();
+                      I.forEach(function(ct, at) {
+                        ct.length == 0 && yt.add(at);
+                      });
+                      var Ct = [];
+                      gt.forEach(function(ct, at) {
+                        if (yt.has(at)) {
+                          var st = !1, Mt = !0, ut = !1, Ot = void 0;
+                          try {
+                            for (var kt = ct[Symbol.iterator](), It; !(Mt = (It = kt.next()).done); Mt = !0) {
+                              var At = It.value;
+                              $.has(At) && (st = !0);
+                            }
+                          } catch (Rt) {
+                            ut = !0, Ot = Rt;
+                          } finally {
+                            try {
+                              !Mt && kt.return && kt.return();
+                            } finally {
+                              if (ut)
+                                throw Ot;
+                            }
+                          }
+                          if (!st) {
+                            var Ht = !1, Yt = void 0;
+                            Ct.forEach(function(Rt, Ut) {
+                              Rt.has([].concat(h(ct))[0]) && (Ht = !0, Yt = Ut);
+                            }), Ht ? ct.forEach(function(Rt) {
+                              Ct[Yt].add(Rt);
+                            }) : Ct.push(new Set(ct));
+                          }
+                        }
+                      }), Ct.forEach(function(ct, at) {
+                        var st = Number.POSITIVE_INFINITY, Mt = Number.POSITIVE_INFINITY, ut = Number.NEGATIVE_INFINITY, Ot = Number.NEGATIVE_INFINITY, kt = !0, It = !1, At = void 0;
+                        try {
+                          for (var Ht = ct[Symbol.iterator](), Yt; !(kt = (Yt = Ht.next()).done); kt = !0) {
+                            var Rt = Yt.value, Ut = void 0;
+                            R == "horizontal" ? Ut = d.has(Rt) ? y[d.get(Rt)] : Q.get(Rt) : Ut = d.has(Rt) ? w[d.get(Rt)] : Q.get(Rt);
+                            var Kt = tt.get(Rt);
+                            Ut < st && (st = Ut), Ut > ut && (ut = Ut), Kt < Mt && (Mt = Kt), Kt > Ot && (Ot = Kt);
+                          }
+                        } catch (Zt) {
+                          It = !0, At = Zt;
+                        } finally {
+                          try {
+                            !kt && Ht.return && Ht.return();
+                          } finally {
+                            if (It)
+                              throw At;
+                          }
+                        }
+                        var le = (st + ut) / 2 - (Mt + Ot) / 2, re = !0, Qt = !1, Jt = void 0;
+                        try {
+                          for (var qt = ct[Symbol.iterator](), te; !(re = (te = qt.next()).done); re = !0) {
+                            var oe = te.value;
+                            tt.set(oe, tt.get(oe) + le);
+                          }
+                        } catch (Zt) {
+                          Qt = !0, Jt = Zt;
+                        } finally {
+                          try {
+                            !re && qt.return && qt.return();
+                          } finally {
+                            if (Qt)
+                              throw Jt;
+                          }
+                        }
+                      });
+                    }
+                    return tt;
+                  }, nt = function(I) {
+                    var R = 0, $ = 0, Q = 0, K = 0;
+                    if (I.forEach(function(gt) {
+                      gt.left ? y[d.get(gt.left)] - y[d.get(gt.right)] >= 0 ? R++ : $++ : w[d.get(gt.top)] - w[d.get(gt.bottom)] >= 0 ? Q++ : K++;
+                    }), R > $ && Q > K)
+                      for (var pt = 0; pt < d.size; pt++)
+                        y[pt] = -1 * y[pt], w[pt] = -1 * w[pt];
+                    else if (R > $)
+                      for (var lt = 0; lt < d.size; lt++)
+                        y[lt] = -1 * y[lt];
+                    else if (Q > K)
+                      for (var tt = 0; tt < d.size; tt++)
+                        w[tt] = -1 * w[tt];
+                  }, n = function(I) {
+                    var R = [], $ = new f(), Q = /* @__PURE__ */ new Set(), K = 0;
+                    return I.forEach(function(pt, lt) {
+                      if (!Q.has(lt)) {
+                        R[K] = [];
+                        var tt = lt;
+                        for ($.push(tt), Q.add(tt), R[K].push(tt); $.length != 0; ) {
+                          tt = $.shift();
+                          var gt = I.get(tt);
+                          gt.forEach(function(it) {
+                            Q.has(it.id) || ($.push(it.id), Q.add(it.id), R[K].push(it.id));
+                          });
+                        }
+                        K++;
+                      }
+                    }), R;
+                  }, E = function(I) {
+                    var R = /* @__PURE__ */ new Map();
+                    return I.forEach(function($, Q) {
+                      R.set(Q, []);
+                    }), I.forEach(function($, Q) {
+                      $.forEach(function(K) {
+                        R.get(Q).push(K), R.get(K.id).push({ id: Q, gap: K.gap, direction: K.direction });
+                      });
+                    }), R;
+                  }, p = function(I) {
+                    var R = /* @__PURE__ */ new Map();
+                    return I.forEach(function($, Q) {
+                      R.set(Q, []);
+                    }), I.forEach(function($, Q) {
+                      $.forEach(function(K) {
+                        R.get(K.id).push({ id: Q, gap: K.gap, direction: K.direction });
+                      });
+                    }), R;
+                  }, v = [], m = [], O = !1, _ = !1, C = /* @__PURE__ */ new Set(), F = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), V = [];
+                  if (c.fixedNodeConstraint && c.fixedNodeConstraint.forEach(function(I) {
+                    C.add(I.nodeId);
+                  }), c.relativePlacementConstraint && (c.relativePlacementConstraint.forEach(function(I) {
+                    I.left ? (F.has(I.left) ? F.get(I.left).push({ id: I.right, gap: I.gap, direction: "horizontal" }) : F.set(I.left, [{ id: I.right, gap: I.gap, direction: "horizontal" }]), F.has(I.right) || F.set(I.right, [])) : (F.has(I.top) ? F.get(I.top).push({ id: I.bottom, gap: I.gap, direction: "vertical" }) : F.set(I.top, [{ id: I.bottom, gap: I.gap, direction: "vertical" }]), F.has(I.bottom) || F.set(I.bottom, []));
+                  }), k = E(F), V = n(k)), r.TRANSFORM_ON_CONSTRAINT_HANDLING) {
+                    if (c.fixedNodeConstraint && c.fixedNodeConstraint.length > 1)
+                      c.fixedNodeConstraint.forEach(function(I, R) {
+                        v[R] = [I.position.x, I.position.y], m[R] = [y[d.get(I.nodeId)], w[d.get(I.nodeId)]];
+                      }), O = !0;
+                    else if (c.alignmentConstraint)
+                      (function() {
+                        var I = 0;
+                        if (c.alignmentConstraint.vertical) {
+                          for (var R = c.alignmentConstraint.vertical, $ = function(tt) {
+                            var gt = /* @__PURE__ */ new Set();
+                            R[tt].forEach(function(yt) {
+                              gt.add(yt);
+                            });
+                            var it = new Set([].concat(h(gt)).filter(function(yt) {
+                              return C.has(yt);
+                            })), Nt = void 0;
+                            it.size > 0 ? Nt = y[d.get(it.values().next().value)] : Nt = B(gt).x, R[tt].forEach(function(yt) {
+                              v[I] = [Nt, w[d.get(yt)]], m[I] = [y[d.get(yt)], w[d.get(yt)]], I++;
+                            });
+                          }, Q = 0; Q < R.length; Q++)
+                            $(Q);
+                          O = !0;
+                        }
+                        if (c.alignmentConstraint.horizontal) {
+                          for (var K = c.alignmentConstraint.horizontal, pt = function(tt) {
+                            var gt = /* @__PURE__ */ new Set();
+                            K[tt].forEach(function(yt) {
+                              gt.add(yt);
+                            });
+                            var it = new Set([].concat(h(gt)).filter(function(yt) {
+                              return C.has(yt);
+                            })), Nt = void 0;
+                            it.size > 0 ? Nt = y[d.get(it.values().next().value)] : Nt = B(gt).y, K[tt].forEach(function(yt) {
+                              v[I] = [y[d.get(yt)], Nt], m[I] = [y[d.get(yt)], w[d.get(yt)]], I++;
+                            });
+                          }, lt = 0; lt < K.length; lt++)
+                            pt(lt);
+                          O = !0;
+                        }
+                        c.relativePlacementConstraint && (_ = !0);
+                      })();
+                    else if (c.relativePlacementConstraint) {
+                      for (var z = 0, H = 0, Z = 0; Z < V.length; Z++)
+                        V[Z].length > z && (z = V[Z].length, H = Z);
+                      if (z < k.size / 2)
+                        nt(c.relativePlacementConstraint), O = !1, _ = !1;
+                      else {
+                        var G = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Map(), b = [];
+                        V[H].forEach(function(I) {
+                          F.get(I).forEach(function(R) {
+                            R.direction == "horizontal" ? (G.has(I) ? G.get(I).push(R) : G.set(I, [R]), G.has(R.id) || G.set(R.id, []), b.push({ left: I, right: R.id })) : (D.has(I) ? D.get(I).push(R) : D.set(I, [R]), D.has(R.id) || D.set(R.id, []), b.push({ top: I, bottom: R.id }));
+                          });
+                        }), nt(b), _ = !1;
+                        var q = x(G, "horizontal"), et = x(D, "vertical");
+                        V[H].forEach(function(I, R) {
+                          m[R] = [y[d.get(I)], w[d.get(I)]], v[R] = [], q.has(I) ? v[R][0] = q.get(I) : v[R][0] = y[d.get(I)], et.has(I) ? v[R][1] = et.get(I) : v[R][1] = w[d.get(I)];
+                        }), O = !0;
+                      }
+                    }
+                    if (O) {
+                      for (var vt = void 0, j = e.transpose(v), Dt = e.transpose(m), J = 0; J < j.length; J++)
+                        j[J] = e.multGamma(j[J]), Dt[J] = e.multGamma(Dt[J]);
+                      var ot = e.multMat(j, e.transpose(Dt)), mt = s.svd(ot);
+                      vt = e.multMat(mt.V, e.transpose(mt.U));
+                      for (var ht = 0; ht < d.size; ht++) {
+                        var Lt = [y[ht], w[ht]], _t = [vt[0][0], vt[1][0]], Tt = [vt[0][1], vt[1][1]];
+                        y[ht] = e.dotProduct(Lt, _t), w[ht] = e.dotProduct(Lt, Tt);
+                      }
+                      _ && nt(c.relativePlacementConstraint);
+                    }
+                  }
+                  if (r.ENFORCE_CONSTRAINTS) {
+                    if (c.fixedNodeConstraint && c.fixedNodeConstraint.length > 0) {
+                      var wt = { x: 0, y: 0 };
+                      c.fixedNodeConstraint.forEach(function(I, R) {
+                        var $ = { x: y[d.get(I.nodeId)], y: w[d.get(I.nodeId)] }, Q = I.position, K = W(Q, $);
+                        wt.x += K.x, wt.y += K.y;
+                      }), wt.x /= c.fixedNodeConstraint.length, wt.y /= c.fixedNodeConstraint.length, y.forEach(function(I, R) {
+                        y[R] += wt.x;
+                      }), w.forEach(function(I, R) {
+                        w[R] += wt.y;
+                      }), c.fixedNodeConstraint.forEach(function(I) {
+                        y[d.get(I.nodeId)] = I.position.x, w[d.get(I.nodeId)] = I.position.y;
+                      });
+                    }
+                    if (c.alignmentConstraint) {
+                      if (c.alignmentConstraint.vertical)
+                        for (var zt = c.alignmentConstraint.vertical, bt = function(I) {
+                          var R = /* @__PURE__ */ new Set();
+                          zt[I].forEach(function(K) {
+                            R.add(K);
+                          });
+                          var $ = new Set([].concat(h(R)).filter(function(K) {
+                            return C.has(K);
+                          })), Q = void 0;
+                          $.size > 0 ? Q = y[d.get($.values().next().value)] : Q = B(R).x, R.forEach(function(K) {
+                            C.has(K) || (y[d.get(K)] = Q);
+                          });
+                        }, Gt = 0; Gt < zt.length; Gt++)
+                          bt(Gt);
+                      if (c.alignmentConstraint.horizontal)
+                        for (var Ft = c.alignmentConstraint.horizontal, Vt = function(I) {
+                          var R = /* @__PURE__ */ new Set();
+                          Ft[I].forEach(function(K) {
+                            R.add(K);
+                          });
+                          var $ = new Set([].concat(h(R)).filter(function(K) {
+                            return C.has(K);
+                          })), Q = void 0;
+                          $.size > 0 ? Q = w[d.get($.values().next().value)] : Q = B(R).y, R.forEach(function(K) {
+                            C.has(K) || (w[d.get(K)] = Q);
+                          });
+                        }, Pt = 0; Pt < Ft.length; Pt++)
+                          Vt(Pt);
+                    }
+                    c.relativePlacementConstraint && function() {
+                      var I = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map(), K = /* @__PURE__ */ new Map(), pt = /* @__PURE__ */ new Map(), lt = /* @__PURE__ */ new Set(), tt = /* @__PURE__ */ new Set();
+                      if (C.forEach(function(ft) {
+                        lt.add(ft), tt.add(ft);
+                      }), c.alignmentConstraint) {
+                        if (c.alignmentConstraint.vertical)
+                          for (var gt = c.alignmentConstraint.vertical, it = function(ft) {
+                            $.set("dummy" + ft, []), gt[ft].forEach(function(xt) {
+                              I.set(xt, "dummy" + ft), $.get("dummy" + ft).push(xt), C.has(xt) && lt.add("dummy" + ft);
+                            }), K.set("dummy" + ft, y[d.get(gt[ft][0])]);
+                          }, Nt = 0; Nt < gt.length; Nt++)
+                            it(Nt);
+                        if (c.alignmentConstraint.horizontal)
+                          for (var yt = c.alignmentConstraint.horizontal, Ct = function(ft) {
+                            Q.set("dummy" + ft, []), yt[ft].forEach(function(xt) {
+                              R.set(xt, "dummy" + ft), Q.get("dummy" + ft).push(xt), C.has(xt) && tt.add("dummy" + ft);
+                            }), pt.set("dummy" + ft, w[d.get(yt[ft][0])]);
+                          }, ct = 0; ct < yt.length; ct++)
+                            Ct(ct);
+                      }
+                      var at = /* @__PURE__ */ new Map(), st = /* @__PURE__ */ new Map(), Mt = function(ft) {
+                        F.get(ft).forEach(function(xt) {
+                          var Wt = void 0, Bt = void 0;
+                          xt.direction == "horizontal" ? (Wt = I.get(ft) ? I.get(ft) : ft, I.get(xt.id) ? Bt = { id: I.get(xt.id), gap: xt.gap, direction: xt.direction } : Bt = xt, at.has(Wt) ? at.get(Wt).push(Bt) : at.set(Wt, [Bt]), at.has(Bt.id) || at.set(Bt.id, [])) : (Wt = R.get(ft) ? R.get(ft) : ft, R.get(xt.id) ? Bt = { id: R.get(xt.id), gap: xt.gap, direction: xt.direction } : Bt = xt, st.has(Wt) ? st.get(Wt).push(Bt) : st.set(Wt, [Bt]), st.has(Bt.id) || st.set(Bt.id, []));
+                        });
+                      }, ut = !0, Ot = !1, kt = void 0;
+                      try {
+                        for (var It = F.keys()[Symbol.iterator](), At; !(ut = (At = It.next()).done); ut = !0) {
+                          var Ht = At.value;
+                          Mt(Ht);
+                        }
+                      } catch (ft) {
+                        Ot = !0, kt = ft;
+                      } finally {
+                        try {
+                          !ut && It.return && It.return();
+                        } finally {
+                          if (Ot)
+                            throw kt;
+                        }
+                      }
+                      var Yt = E(at), Rt = E(st), Ut = n(Yt), Kt = n(Rt), le = p(at), re = p(st), Qt = [], Jt = [];
+                      Ut.forEach(function(ft, xt) {
+                        Qt[xt] = [], ft.forEach(function(Wt) {
+                          le.get(Wt).length == 0 && Qt[xt].push(Wt);
+                        });
+                      }), Kt.forEach(function(ft, xt) {
+                        Jt[xt] = [], ft.forEach(function(Wt) {
+                          re.get(Wt).length == 0 && Jt[xt].push(Wt);
+                        });
+                      });
+                      var qt = x(at, "horizontal", lt, K, Qt), te = x(st, "vertical", tt, pt, Jt), oe = function(ft) {
+                        $.get(ft) ? $.get(ft).forEach(function(xt) {
+                          y[d.get(xt)] = qt.get(ft);
+                        }) : y[d.get(ft)] = qt.get(ft);
+                      }, Zt = !0, Ae = !1, we = void 0;
+                      try {
+                        for (var ce = qt.keys()[Symbol.iterator](), Me; !(Zt = (Me = ce.next()).done); Zt = !0) {
+                          var de = Me.value;
+                          oe(de);
+                        }
+                      } catch (ft) {
+                        Ae = !0, we = ft;
+                      } finally {
+                        try {
+                          !Zt && ce.return && ce.return();
+                        } finally {
+                          if (Ae)
+                            throw we;
+                        }
+                      }
+                      var Be = function(ft) {
+                        Q.get(ft) ? Q.get(ft).forEach(function(xt) {
+                          w[d.get(xt)] = te.get(ft);
+                        }) : w[d.get(ft)] = te.get(ft);
+                      }, ge = !0, Ie = !1, Le = void 0;
+                      try {
+                        for (var ue = te.keys()[Symbol.iterator](), _e; !(ge = (_e = ue.next()).done); ge = !0) {
+                          var de = _e.value;
+                          Be(de);
+                        }
+                      } catch (ft) {
+                        Ie = !0, Le = ft;
+                      } finally {
+                        try {
+                          !ge && ue.return && ue.return();
+                        } finally {
+                          if (Ie)
+                            throw Le;
+                        }
+                      }
+                    }();
+                  }
+                  for (var $t = 0; $t < M.length; $t++) {
+                    var dt = M[$t];
+                    dt.getChild() == null && dt.setCenter(y[d.get(dt.id)], w[d.get(dt.id)]);
+                  }
+                }, o.exports = a;
+              }
+            ),
+            /***/
+            551: (
+              /***/
+              (o) => {
+                o.exports = L;
+              }
+            )
+            /******/
+          }, T = {};
+          function u(o) {
+            var i = T[o];
+            if (i !== void 0)
+              return i.exports;
+            var t = T[o] = {
+              /******/
+              // no module.id needed
+              /******/
+              // no module.loaded needed
+              /******/
+              exports: {}
+              /******/
+            };
+            return U[o](t, t.exports, u), t.exports;
+          }
+          var l = u(45);
+          return l;
+        })()
+      );
+    });
+  }(ve)), ve.exports;
+}
+var fi = pe.exports, De;
+function pi() {
+  return De || (De = 1, function(A, X) {
+    (function(L, U) {
+      A.exports = U(ui());
+    })(fi, function(L) {
+      return (
+        /******/
+        (() => {
+          var U = {
+            /***/
+            658: (
+              /***/
+              (o) => {
+                o.exports = Object.assign != null ? Object.assign.bind(Object) : function(i) {
+                  for (var t = arguments.length, h = Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++)
+                    h[r - 1] = arguments[r];
+                  return h.forEach(function(f) {
+                    Object.keys(f).forEach(function(e) {
+                      return i[e] = f[e];
+                    });
+                  }), i;
+                };
+              }
+            ),
+            /***/
+            548: (
+              /***/
+              (o, i, t) => {
+                var h = /* @__PURE__ */ function() {
+                  function e(s, a) {
+                    var g = [], c = !0, N = !1, d = void 0;
+                    try {
+                      for (var y = s[Symbol.iterator](), w; !(c = (w = y.next()).done) && (g.push(w.value), !(a && g.length === a)); c = !0)
+                        ;
+                    } catch (M) {
+                      N = !0, d = M;
+                    } finally {
+                      try {
+                        !c && y.return && y.return();
+                      } finally {
+                        if (N)
+                          throw d;
+                      }
+                    }
+                    return g;
+                  }
+                  return function(s, a) {
+                    if (Array.isArray(s))
+                      return s;
+                    if (Symbol.iterator in Object(s))
+                      return e(s, a);
+                    throw new TypeError("Invalid attempt to destructure non-iterable instance");
+                  };
+                }(), r = t(140).layoutBase.LinkedList, f = {};
+                f.getTopMostNodes = function(e) {
+                  for (var s = {}, a = 0; a < e.length; a++)
+                    s[e[a].id()] = !0;
+                  var g = e.filter(function(c, N) {
+                    typeof c == "number" && (c = N);
+                    for (var d = c.parent()[0]; d != null; ) {
+                      if (s[d.id()])
+                        return !1;
+                      d = d.parent()[0];
+                    }
+                    return !0;
+                  });
+                  return g;
+                }, f.connectComponents = function(e, s, a, g) {
+                  var c = new r(), N = /* @__PURE__ */ new Set(), d = [], y = void 0, w = void 0, M = void 0, P = !1, S = 1, Y = [], W = [], B = function() {
+                    var x = e.collection();
+                    W.push(x);
+                    var nt = a[0], n = e.collection();
+                    n.merge(nt).merge(nt.descendants().intersection(s)), d.push(nt), n.forEach(function(v) {
+                      c.push(v), N.add(v), x.merge(v);
+                    });
+                    for (var E = function() {
+                      nt = c.shift();
+                      var v = e.collection();
+                      nt.neighborhood().nodes().forEach(function(C) {
+                        s.intersection(nt.edgesWith(C)).length > 0 && v.merge(C);
+                      });
+                      for (var m = 0; m < v.length; m++) {
+                        var O = v[m];
+                        if (y = a.intersection(O.union(O.ancestors())), y != null && !N.has(y[0])) {
+                          var _ = y.union(y.descendants());
+                          _.forEach(function(C) {
+                            c.push(C), N.add(C), x.merge(C), a.has(C) && d.push(C);
+                          });
+                        }
+                      }
+                    }; c.length != 0; )
+                      E();
+                    if (x.forEach(function(v) {
+                      s.intersection(v.connectedEdges()).forEach(function(m) {
+                        x.has(m.source()) && x.has(m.target()) && x.merge(m);
+                      });
+                    }), d.length == a.length && (P = !0), !P || P && S > 1) {
+                      w = d[0], M = w.connectedEdges().length, d.forEach(function(v) {
+                        v.connectedEdges().length < M && (M = v.connectedEdges().length, w = v);
+                      }), Y.push(w.id());
+                      var p = e.collection();
+                      p.merge(d[0]), d.forEach(function(v) {
+                        p.merge(v);
+                      }), d = [], a = a.difference(p), S++;
+                    }
+                  };
+                  do
+                    B();
+                  while (!P);
+                  return g && Y.length > 0 && g.set("dummy" + (g.size + 1), Y), W;
+                }, f.relocateComponent = function(e, s, a) {
+                  if (!a.fixedNodeConstraint) {
+                    var g = Number.POSITIVE_INFINITY, c = Number.NEGATIVE_INFINITY, N = Number.POSITIVE_INFINITY, d = Number.NEGATIVE_INFINITY;
+                    if (a.quality == "draft") {
+                      var y = !0, w = !1, M = void 0;
+                      try {
+                        for (var P = s.nodeIndexes[Symbol.iterator](), S; !(y = (S = P.next()).done); y = !0) {
+                          var Y = S.value, W = h(Y, 2), B = W[0], x = W[1], nt = a.cy.getElementById(B);
+                          if (nt) {
+                            var n = nt.boundingBox(), E = s.xCoords[x] - n.w / 2, p = s.xCoords[x] + n.w / 2, v = s.yCoords[x] - n.h / 2, m = s.yCoords[x] + n.h / 2;
+                            E < g && (g = E), p > c && (c = p), v < N && (N = v), m > d && (d = m);
+                          }
+                        }
+                      } catch (k) {
+                        w = !0, M = k;
+                      } finally {
+                        try {
+                          !y && P.return && P.return();
+                        } finally {
+                          if (w)
+                            throw M;
+                        }
+                      }
+                      var O = e.x - (c + g) / 2, _ = e.y - (d + N) / 2;
+                      s.xCoords = s.xCoords.map(function(k) {
+                        return k + O;
+                      }), s.yCoords = s.yCoords.map(function(k) {
+                        return k + _;
+                      });
+                    } else {
+                      Object.keys(s).forEach(function(k) {
+                        var V = s[k], z = V.getRect().x, H = V.getRect().x + V.getRect().width, Z = V.getRect().y, G = V.getRect().y + V.getRect().height;
+                        z < g && (g = z), H > c && (c = H), Z < N && (N = Z), G > d && (d = G);
+                      });
+                      var C = e.x - (c + g) / 2, F = e.y - (d + N) / 2;
+                      Object.keys(s).forEach(function(k) {
+                        var V = s[k];
+                        V.setCenter(V.getCenterX() + C, V.getCenterY() + F);
+                      });
+                    }
+                  }
+                }, f.calcBoundingBox = function(e, s, a, g) {
+                  for (var c = Number.MAX_SAFE_INTEGER, N = Number.MIN_SAFE_INTEGER, d = Number.MAX_SAFE_INTEGER, y = Number.MIN_SAFE_INTEGER, w = void 0, M = void 0, P = void 0, S = void 0, Y = e.descendants().not(":parent"), W = Y.length, B = 0; B < W; B++) {
+                    var x = Y[B];
+                    w = s[g.get(x.id())] - x.width() / 2, M = s[g.get(x.id())] + x.width() / 2, P = a[g.get(x.id())] - x.height() / 2, S = a[g.get(x.id())] + x.height() / 2, c > w && (c = w), N < M && (N = M), d > P && (d = P), y < S && (y = S);
+                  }
+                  var nt = {};
+                  return nt.topLeftX = c, nt.topLeftY = d, nt.width = N - c, nt.height = y - d, nt;
+                }, f.calcParentsWithoutChildren = function(e, s) {
+                  var a = e.collection();
+                  return s.nodes(":parent").forEach(function(g) {
+                    var c = !1;
+                    g.children().forEach(function(N) {
+                      N.css("display") != "none" && (c = !0);
+                    }), c || a.merge(g);
+                  }), a;
+                }, o.exports = f;
+              }
+            ),
+            /***/
+            816: (
+              /***/
+              (o, i, t) => {
+                var h = t(548), r = t(140).CoSELayout, f = t(140).CoSENode, e = t(140).layoutBase.PointD, s = t(140).layoutBase.DimensionD, a = t(140).layoutBase.LayoutConstants, g = t(140).layoutBase.FDLayoutConstants, c = t(140).CoSEConstants, N = function(d, y) {
+                  var w = d.cy, M = d.eles, P = M.nodes(), S = M.edges(), Y = void 0, W = void 0, B = void 0, x = {};
+                  d.randomize && (Y = y.nodeIndexes, W = y.xCoords, B = y.yCoords);
+                  var nt = function(C) {
+                    return typeof C == "function";
+                  }, n = function(C, F) {
+                    return nt(C) ? C(F) : C;
+                  }, E = h.calcParentsWithoutChildren(w, M), p = function C(F, k, V, z) {
+                    for (var H = k.length, Z = 0; Z < H; Z++) {
+                      var G = k[Z], D = null;
+                      G.intersection(E).length == 0 && (D = G.children());
+                      var b = void 0, q = G.layoutDimensions({
+                        nodeDimensionsIncludeLabels: z.nodeDimensionsIncludeLabels
+                      });
+                      if (G.outerWidth() != null && G.outerHeight() != null)
+                        if (z.randomize)
+                          if (!G.isParent())
+                            b = F.add(new f(V.graphManager, new e(W[Y.get(G.id())] - q.w / 2, B[Y.get(G.id())] - q.h / 2), new s(parseFloat(q.w), parseFloat(q.h))));
+                          else {
+                            var et = h.calcBoundingBox(G, W, B, Y);
+                            G.intersection(E).length == 0 ? b = F.add(new f(V.graphManager, new e(et.topLeftX, et.topLeftY), new s(et.width, et.height))) : b = F.add(new f(V.graphManager, new e(et.topLeftX, et.topLeftY), new s(parseFloat(q.w), parseFloat(q.h))));
+                          }
+                        else
+                          b = F.add(new f(V.graphManager, new e(G.position("x") - q.w / 2, G.position("y") - q.h / 2), new s(parseFloat(q.w), parseFloat(q.h))));
+                      else
+                        b = F.add(new f(this.graphManager));
+                      if (b.id = G.data("id"), b.nodeRepulsion = n(z.nodeRepulsion, G), b.paddingLeft = parseInt(G.css("padding")), b.paddingTop = parseInt(G.css("padding")), b.paddingRight = parseInt(G.css("padding")), b.paddingBottom = parseInt(G.css("padding")), z.nodeDimensionsIncludeLabels && (b.labelWidth = G.boundingBox({ includeLabels: !0, includeNodes: !1, includeOverlays: !1 }).w, b.labelHeight = G.boundingBox({ includeLabels: !0, includeNodes: !1, includeOverlays: !1 }).h, b.labelPosVertical = G.css("text-valign"), b.labelPosHorizontal = G.css("text-halign")), x[G.data("id")] = b, isNaN(b.rect.x) && (b.rect.x = 0), isNaN(b.rect.y) && (b.rect.y = 0), D != null && D.length > 0) {
+                        var vt = void 0;
+                        vt = V.getGraphManager().add(V.newGraph(), b), C(vt, D, V, z);
+                      }
+                    }
+                  }, v = function(C, F, k) {
+                    for (var V = 0, z = 0, H = 0; H < k.length; H++) {
+                      var Z = k[H], G = x[Z.data("source")], D = x[Z.data("target")];
+                      if (G && D && G !== D && G.getEdgesBetween(D).length == 0) {
+                        var b = F.add(C.newEdge(), G, D);
+                        b.id = Z.id(), b.idealLength = n(d.idealEdgeLength, Z), b.edgeElasticity = n(d.edgeElasticity, Z), V += b.idealLength, z++;
+                      }
+                    }
+                    d.idealEdgeLength != null && (z > 0 ? c.DEFAULT_EDGE_LENGTH = g.DEFAULT_EDGE_LENGTH = V / z : nt(d.idealEdgeLength) ? c.DEFAULT_EDGE_LENGTH = g.DEFAULT_EDGE_LENGTH = 50 : c.DEFAULT_EDGE_LENGTH = g.DEFAULT_EDGE_LENGTH = d.idealEdgeLength, c.MIN_REPULSION_DIST = g.MIN_REPULSION_DIST = g.DEFAULT_EDGE_LENGTH / 10, c.DEFAULT_RADIAL_SEPARATION = g.DEFAULT_EDGE_LENGTH);
+                  }, m = function(C, F) {
+                    F.fixedNodeConstraint && (C.constraints.fixedNodeConstraint = F.fixedNodeConstraint), F.alignmentConstraint && (C.constraints.alignmentConstraint = F.alignmentConstraint), F.relativePlacementConstraint && (C.constraints.relativePlacementConstraint = F.relativePlacementConstraint);
+                  };
+                  d.nestingFactor != null && (c.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = g.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = d.nestingFactor), d.gravity != null && (c.DEFAULT_GRAVITY_STRENGTH = g.DEFAULT_GRAVITY_STRENGTH = d.gravity), d.numIter != null && (c.MAX_ITERATIONS = g.MAX_ITERATIONS = d.numIter), d.gravityRange != null && (c.DEFAULT_GRAVITY_RANGE_FACTOR = g.DEFAULT_GRAVITY_RANGE_FACTOR = d.gravityRange), d.gravityCompound != null && (c.DEFAULT_COMPOUND_GRAVITY_STRENGTH = g.DEFAULT_COMPOUND_GRAVITY_STRENGTH = d.gravityCompound), d.gravityRangeCompound != null && (c.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = g.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = d.gravityRangeCompound), d.initialEnergyOnIncremental != null && (c.DEFAULT_COOLING_FACTOR_INCREMENTAL = g.DEFAULT_COOLING_FACTOR_INCREMENTAL = d.initialEnergyOnIncremental), d.tilingCompareBy != null && (c.TILING_COMPARE_BY = d.tilingCompareBy), d.quality == "proof" ? a.QUALITY = 2 : a.QUALITY = 0, c.NODE_DIMENSIONS_INCLUDE_LABELS = g.NODE_DIMENSIONS_INCLUDE_LABELS = a.NODE_DIMENSIONS_INCLUDE_LABELS = d.nodeDimensionsIncludeLabels, c.DEFAULT_INCREMENTAL = g.DEFAULT_INCREMENTAL = a.DEFAULT_INCREMENTAL = !d.randomize, c.ANIMATE = g.ANIMATE = a.ANIMATE = d.animate, c.TILE = d.tile, c.TILING_PADDING_VERTICAL = typeof d.tilingPaddingVertical == "function" ? d.tilingPaddingVertical.call() : d.tilingPaddingVertical, c.TILING_PADDING_HORIZONTAL = typeof d.tilingPaddingHorizontal == "function" ? d.tilingPaddingHorizontal.call() : d.tilingPaddingHorizontal, c.DEFAULT_INCREMENTAL = g.DEFAULT_INCREMENTAL = a.DEFAULT_INCREMENTAL = !0, c.PURE_INCREMENTAL = !d.randomize, a.DEFAULT_UNIFORM_LEAF_NODE_SIZES = d.uniformNodeDimensions, d.step == "transformed" && (c.TRANSFORM_ON_CONSTRAINT_HANDLING = !0, c.ENFORCE_CONSTRAINTS = !1, c.APPLY_LAYOUT = !1), d.step == "enforced" && (c.TRANSFORM_ON_CONSTRAINT_HANDLING = !1, c.ENFORCE_CONSTRAINTS = !0, c.APPLY_LAYOUT = !1), d.step == "cose" && (c.TRANSFORM_ON_CONSTRAINT_HANDLING = !1, c.ENFORCE_CONSTRAINTS = !1, c.APPLY_LAYOUT = !0), d.step == "all" && (d.randomize ? c.TRANSFORM_ON_CONSTRAINT_HANDLING = !0 : c.TRANSFORM_ON_CONSTRAINT_HANDLING = !1, c.ENFORCE_CONSTRAINTS = !0, c.APPLY_LAYOUT = !0), d.fixedNodeConstraint || d.alignmentConstraint || d.relativePlacementConstraint ? c.TREE_REDUCTION_ON_INCREMENTAL = !1 : c.TREE_REDUCTION_ON_INCREMENTAL = !0;
+                  var O = new r(), _ = O.newGraphManager();
+                  return p(_.addRoot(), h.getTopMostNodes(P), O, d), v(O, _, S), m(O, d), O.runLayout(), x;
+                };
+                o.exports = { coseLayout: N };
+              }
+            ),
+            /***/
+            212: (
+              /***/
+              (o, i, t) => {
+                var h = /* @__PURE__ */ function() {
+                  function y(w, M) {
+                    for (var P = 0; P < M.length; P++) {
+                      var S = M[P];
+                      S.enumerable = S.enumerable || !1, S.configurable = !0, "value" in S && (S.writable = !0), Object.defineProperty(w, S.key, S);
+                    }
+                  }
+                  return function(w, M, P) {
+                    return M && y(w.prototype, M), P && y(w, P), w;
+                  };
+                }();
+                function r(y, w) {
+                  if (!(y instanceof w))
+                    throw new TypeError("Cannot call a class as a function");
+                }
+                var f = t(658), e = t(548), s = t(657), a = s.spectralLayout, g = t(816), c = g.coseLayout, N = Object.freeze({
+                  // 'draft', 'default' or 'proof' 
+                  // - 'draft' only applies spectral layout 
+                  // - 'default' improves the quality with subsequent CoSE layout (fast cooling rate)
+                  // - 'proof' improves the quality with subsequent CoSE layout (slow cooling rate) 
+                  quality: "default",
+                  // Use random node positions at beginning of layout
+                  // if this is set to false, then quality option must be "proof"
+                  randomize: !0,
+                  // Whether or not to animate the layout
+                  animate: !0,
+                  // Duration of animation in ms, if enabled
+                  animationDuration: 1e3,
+                  // Easing of animation, if enabled
+                  animationEasing: void 0,
+                  // Fit the viewport to the repositioned nodes
+                  fit: !0,
+                  // Padding around layout
+                  padding: 30,
+                  // Whether to include labels in node dimensions. Valid in "proof" quality
+                  nodeDimensionsIncludeLabels: !1,
+                  // Whether or not simple nodes (non-compound nodes) are of uniform dimensions
+                  uniformNodeDimensions: !1,
+                  // Whether to pack disconnected components - valid only if randomize: true
+                  packComponents: !0,
+                  // Layout step - all, transformed, enforced, cose - for debug purpose only
+                  step: "all",
+                  /* spectral layout options */
+                  // False for random, true for greedy
+                  samplingType: !0,
+                  // Sample size to construct distance matrix
+                  sampleSize: 25,
+                  // Separation amount between nodes
+                  nodeSeparation: 75,
+                  // Power iteration tolerance
+                  piTol: 1e-7,
+                  /* CoSE layout options */
+                  // Node repulsion (non overlapping) multiplier
+                  nodeRepulsion: function(y) {
+                    return 4500;
+                  },
+                  // Ideal edge (non nested) length
+                  idealEdgeLength: function(y) {
+                    return 50;
+                  },
+                  // Divisor to compute edge forces
+                  edgeElasticity: function(y) {
+                    return 0.45;
+                  },
+                  // Nesting factor (multiplier) to compute ideal edge length for nested edges
+                  nestingFactor: 0.1,
+                  // Gravity force (constant)
+                  gravity: 0.25,
+                  // Maximum number of iterations to perform
+                  numIter: 2500,
+                  // For enabling tiling
+                  tile: !0,
+                  // The function that specifies the criteria for comparing nodes while sorting them during tiling operation.
+                  // Takes the node id as a parameter and the default tiling operation is perfomed when this option is not set.
+                  tilingCompareBy: void 0,
+                  // Represents the amount of the vertical space to put between the zero degree members during the tiling operation(can also be a function)
+                  tilingPaddingVertical: 10,
+                  // Represents the amount of the horizontal space to put between the zero degree members during the tiling operation(can also be a function)
+                  tilingPaddingHorizontal: 10,
+                  // Gravity range (constant) for compounds
+                  gravityRangeCompound: 1.5,
+                  // Gravity force (constant) for compounds
+                  gravityCompound: 1,
+                  // Gravity range (constant)
+                  gravityRange: 3.8,
+                  // Initial cooling factor for incremental layout  
+                  initialEnergyOnIncremental: 0.3,
+                  /* constraint options */
+                  // Fix required nodes to predefined positions
+                  // [{nodeId: 'n1', position: {x: 100, y: 200}, {...}]
+                  fixedNodeConstraint: void 0,
+                  // Align required nodes in vertical/horizontal direction
+                  // {vertical: [['n1', 'n2')], ['n3', 'n4']], horizontal: ['n2', 'n4']}
+                  alignmentConstraint: void 0,
+                  // Place two nodes relatively in vertical/horizontal direction 
+                  // [{top: 'n1', bottom: 'n2', gap: 100}, {left: 'n3', right: 'n4', gap: 75}]
+                  relativePlacementConstraint: void 0,
+                  /* layout event callbacks */
+                  ready: function() {
+                  },
+                  // on layoutready
+                  stop: function() {
+                  }
+                  // on layoutstop
+                }), d = function() {
+                  function y(w) {
+                    r(this, y), this.options = f({}, N, w);
+                  }
+                  return h(y, [{
+                    key: "run",
+                    value: function() {
+                      var w = this, M = this.options, P = M.cy, S = M.eles, Y = [], W = [], B = void 0, x = [];
+                      M.fixedNodeConstraint && (!Array.isArray(M.fixedNodeConstraint) || M.fixedNodeConstraint.length == 0) && (M.fixedNodeConstraint = void 0), M.alignmentConstraint && (M.alignmentConstraint.vertical && (!Array.isArray(M.alignmentConstraint.vertical) || M.alignmentConstraint.vertical.length == 0) && (M.alignmentConstraint.vertical = void 0), M.alignmentConstraint.horizontal && (!Array.isArray(M.alignmentConstraint.horizontal) || M.alignmentConstraint.horizontal.length == 0) && (M.alignmentConstraint.horizontal = void 0)), M.relativePlacementConstraint && (!Array.isArray(M.relativePlacementConstraint) || M.relativePlacementConstraint.length == 0) && (M.relativePlacementConstraint = void 0);
+                      var nt = M.fixedNodeConstraint || M.alignmentConstraint || M.relativePlacementConstraint;
+                      nt && (M.tile = !1, M.packComponents = !1);
+                      var n = void 0, E = !1;
+                      if (P.layoutUtilities && M.packComponents && (n = P.layoutUtilities("get"), n || (n = P.layoutUtilities()), E = !0), S.nodes().length > 0)
+                        if (E) {
+                          var p = e.getTopMostNodes(M.eles.nodes());
+                          if (B = e.connectComponents(P, M.eles, p), B.forEach(function(J) {
+                            var ot = J.boundingBox();
+                            x.push({ x: ot.x1 + ot.w / 2, y: ot.y1 + ot.h / 2 });
+                          }), M.randomize && B.forEach(function(J) {
+                            M.eles = J, Y.push(a(M));
+                          }), M.quality == "default" || M.quality == "proof") {
+                            var v = P.collection();
+                            if (M.tile) {
+                              var m = /* @__PURE__ */ new Map(), O = [], _ = [], C = 0, F = { nodeIndexes: m, xCoords: O, yCoords: _ }, k = [];
+                              if (B.forEach(function(J, ot) {
+                                J.edges().length == 0 && (J.nodes().forEach(function(mt, ht) {
+                                  v.merge(J.nodes()[ht]), mt.isParent() || (F.nodeIndexes.set(J.nodes()[ht].id(), C++), F.xCoords.push(J.nodes()[0].position().x), F.yCoords.push(J.nodes()[0].position().y));
+                                }), k.push(ot));
+                              }), v.length > 1) {
+                                var V = v.boundingBox();
+                                x.push({ x: V.x1 + V.w / 2, y: V.y1 + V.h / 2 }), B.push(v), Y.push(F);
+                                for (var z = k.length - 1; z >= 0; z--)
+                                  B.splice(k[z], 1), Y.splice(k[z], 1), x.splice(k[z], 1);
+                              }
+                            }
+                            B.forEach(function(J, ot) {
+                              M.eles = J, W.push(c(M, Y[ot])), e.relocateComponent(x[ot], W[ot], M);
+                            });
+                          } else
+                            B.forEach(function(J, ot) {
+                              e.relocateComponent(x[ot], Y[ot], M);
+                            });
+                          var H = /* @__PURE__ */ new Set();
+                          if (B.length > 1) {
+                            var Z = [], G = S.filter(function(J) {
+                              return J.css("display") == "none";
+                            });
+                            B.forEach(function(J, ot) {
+                              var mt = void 0;
+                              if (M.quality == "draft" && (mt = Y[ot].nodeIndexes), J.nodes().not(G).length > 0) {
+                                var ht = {};
+                                ht.edges = [], ht.nodes = [];
+                                var Lt = void 0;
+                                J.nodes().not(G).forEach(function(_t) {
+                                  if (M.quality == "draft")
+                                    if (!_t.isParent())
+                                      Lt = mt.get(_t.id()), ht.nodes.push({ x: Y[ot].xCoords[Lt] - _t.boundingbox().w / 2, y: Y[ot].yCoords[Lt] - _t.boundingbox().h / 2, width: _t.boundingbox().w, height: _t.boundingbox().h });
+                                    else {
+                                      var Tt = e.calcBoundingBox(_t, Y[ot].xCoords, Y[ot].yCoords, mt);
+                                      ht.nodes.push({ x: Tt.topLeftX, y: Tt.topLeftY, width: Tt.width, height: Tt.height });
+                                    }
+                                  else
+                                    W[ot][_t.id()] && ht.nodes.push({ x: W[ot][_t.id()].getLeft(), y: W[ot][_t.id()].getTop(), width: W[ot][_t.id()].getWidth(), height: W[ot][_t.id()].getHeight() });
+                                }), J.edges().forEach(function(_t) {
+                                  var Tt = _t.source(), wt = _t.target();
+                                  if (Tt.css("display") != "none" && wt.css("display") != "none")
+                                    if (M.quality == "draft") {
+                                      var zt = mt.get(Tt.id()), bt = mt.get(wt.id()), Gt = [], Ft = [];
+                                      if (Tt.isParent()) {
+                                        var Vt = e.calcBoundingBox(Tt, Y[ot].xCoords, Y[ot].yCoords, mt);
+                                        Gt.push(Vt.topLeftX + Vt.width / 2), Gt.push(Vt.topLeftY + Vt.height / 2);
+                                      } else
+                                        Gt.push(Y[ot].xCoords[zt]), Gt.push(Y[ot].yCoords[zt]);
+                                      if (wt.isParent()) {
+                                        var Pt = e.calcBoundingBox(wt, Y[ot].xCoords, Y[ot].yCoords, mt);
+                                        Ft.push(Pt.topLeftX + Pt.width / 2), Ft.push(Pt.topLeftY + Pt.height / 2);
+                                      } else
+                                        Ft.push(Y[ot].xCoords[bt]), Ft.push(Y[ot].yCoords[bt]);
+                                      ht.edges.push({ startX: Gt[0], startY: Gt[1], endX: Ft[0], endY: Ft[1] });
+                                    } else
+                                      W[ot][Tt.id()] && W[ot][wt.id()] && ht.edges.push({ startX: W[ot][Tt.id()].getCenterX(), startY: W[ot][Tt.id()].getCenterY(), endX: W[ot][wt.id()].getCenterX(), endY: W[ot][wt.id()].getCenterY() });
+                                }), ht.nodes.length > 0 && (Z.push(ht), H.add(ot));
+                              }
+                            });
+                            var D = n.packComponents(Z, M.randomize).shifts;
+                            if (M.quality == "draft")
+                              Y.forEach(function(J, ot) {
+                                var mt = J.xCoords.map(function(Lt) {
+                                  return Lt + D[ot].dx;
+                                }), ht = J.yCoords.map(function(Lt) {
+                                  return Lt + D[ot].dy;
+                                });
+                                J.xCoords = mt, J.yCoords = ht;
+                              });
+                            else {
+                              var b = 0;
+                              H.forEach(function(J) {
+                                Object.keys(W[J]).forEach(function(ot) {
+                                  var mt = W[J][ot];
+                                  mt.setCenter(mt.getCenterX() + D[b].dx, mt.getCenterY() + D[b].dy);
+                                }), b++;
+                              });
+                            }
+                          }
+                        } else {
+                          var q = M.eles.boundingBox();
+                          if (x.push({ x: q.x1 + q.w / 2, y: q.y1 + q.h / 2 }), M.randomize) {
+                            var et = a(M);
+                            Y.push(et);
+                          }
+                          M.quality == "default" || M.quality == "proof" ? (W.push(c(M, Y[0])), e.relocateComponent(x[0], W[0], M)) : e.relocateComponent(x[0], Y[0], M);
+                        }
+                      var vt = function(J, ot) {
+                        if (M.quality == "default" || M.quality == "proof") {
+                          typeof J == "number" && (J = ot);
+                          var mt = void 0, ht = void 0, Lt = J.data("id");
+                          return W.forEach(function(Tt) {
+                            Lt in Tt && (mt = { x: Tt[Lt].getRect().getCenterX(), y: Tt[Lt].getRect().getCenterY() }, ht = Tt[Lt]);
+                          }), M.nodeDimensionsIncludeLabels && (ht.labelWidth && (ht.labelPosHorizontal == "left" ? mt.x += ht.labelWidth / 2 : ht.labelPosHorizontal == "right" && (mt.x -= ht.labelWidth / 2)), ht.labelHeight && (ht.labelPosVertical == "top" ? mt.y += ht.labelHeight / 2 : ht.labelPosVertical == "bottom" && (mt.y -= ht.labelHeight / 2))), mt == null && (mt = { x: J.position("x"), y: J.position("y") }), {
+                            x: mt.x,
+                            y: mt.y
+                          };
+                        } else {
+                          var _t = void 0;
+                          return Y.forEach(function(Tt) {
+                            var wt = Tt.nodeIndexes.get(J.id());
+                            wt != null && (_t = { x: Tt.xCoords[wt], y: Tt.yCoords[wt] });
+                          }), _t == null && (_t = { x: J.position("x"), y: J.position("y") }), {
+                            x: _t.x,
+                            y: _t.y
+                          };
+                        }
+                      };
+                      if (M.quality == "default" || M.quality == "proof" || M.randomize) {
+                        var j = e.calcParentsWithoutChildren(P, S), Dt = S.filter(function(J) {
+                          return J.css("display") == "none";
+                        });
+                        M.eles = S.not(Dt), S.nodes().not(":parent").not(Dt).layoutPositions(w, M, vt), j.length > 0 && j.forEach(function(J) {
+                          J.position(vt(J));
+                        });
+                      } else
+                        console.log("If randomize option is set to false, then quality option must be 'default' or 'proof'.");
+                    }
+                  }]), y;
+                }();
+                o.exports = d;
+              }
+            ),
+            /***/
+            657: (
+              /***/
+              (o, i, t) => {
+                var h = t(548), r = t(140).layoutBase.Matrix, f = t(140).layoutBase.SVD, e = function(s) {
+                  var a = s.cy, g = s.eles, c = g.nodes(), N = g.nodes(":parent"), d = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), M = [], P = [], S = [], Y = [], W = [], B = [], x = [], nt = [], n = void 0, E = 1e8, p = 1e-9, v = s.piTol, m = s.samplingType, O = s.nodeSeparation, _ = void 0, C = function() {
+                    for (var dt = 0, I = 0, R = !1; I < _; ) {
+                      dt = Math.floor(Math.random() * n), R = !1;
+                      for (var $ = 0; $ < I; $++)
+                        if (Y[$] == dt) {
+                          R = !0;
+                          break;
+                        }
+                      if (!R)
+                        Y[I] = dt, I++;
+                      else
+                        continue;
+                    }
+                  }, F = function(dt, I, R) {
+                    for (var $ = [], Q = 0, K = 0, pt = 0, lt = void 0, tt = [], gt = 0, it = 1, Nt = 0; Nt < n; Nt++)
+                      tt[Nt] = E;
+                    for ($[K] = dt, tt[dt] = 0; K >= Q; ) {
+                      pt = $[Q++];
+                      for (var yt = M[pt], Ct = 0; Ct < yt.length; Ct++)
+                        lt = y.get(yt[Ct]), tt[lt] == E && (tt[lt] = tt[pt] + 1, $[++K] = lt);
+                      B[pt][I] = tt[pt] * O;
+                    }
+                    if (R) {
+                      for (var ct = 0; ct < n; ct++)
+                        B[ct][I] < W[ct] && (W[ct] = B[ct][I]);
+                      for (var at = 0; at < n; at++)
+                        W[at] > gt && (gt = W[at], it = at);
+                    }
+                    return it;
+                  }, k = function(dt) {
+                    var I = void 0;
+                    if (dt) {
+                      I = Math.floor(Math.random() * n);
+                      for (var R = 0; R < n; R++)
+                        W[R] = E;
+                      for (var $ = 0; $ < _; $++)
+                        Y[$] = I, I = F(I, $, dt);
+                    } else {
+                      C();
+                      for (var Q = 0; Q < _; Q++)
+                        F(Y[Q], Q, dt);
+                    }
+                    for (var K = 0; K < n; K++)
+                      for (var pt = 0; pt < _; pt++)
+                        B[K][pt] *= B[K][pt];
+                    for (var lt = 0; lt < _; lt++)
+                      x[lt] = [];
+                    for (var tt = 0; tt < _; tt++)
+                      for (var gt = 0; gt < _; gt++)
+                        x[tt][gt] = B[Y[gt]][tt];
+                  }, V = function() {
+                    for (var dt = f.svd(x), I = dt.S, R = dt.U, $ = dt.V, Q = I[0] * I[0] * I[0], K = [], pt = 0; pt < _; pt++) {
+                      K[pt] = [];
+                      for (var lt = 0; lt < _; lt++)
+                        K[pt][lt] = 0, pt == lt && (K[pt][lt] = I[pt] / (I[pt] * I[pt] + Q / (I[pt] * I[pt])));
+                    }
+                    nt = r.multMat(r.multMat($, K), r.transpose(R));
+                  }, z = function() {
+                    for (var dt = void 0, I = void 0, R = [], $ = [], Q = [], K = [], pt = 0; pt < n; pt++)
+                      R[pt] = Math.random(), $[pt] = Math.random();
+                    R = r.normalize(R), $ = r.normalize($);
+                    for (var lt = p, tt = p, gt = void 0; ; ) {
+                      for (var it = 0; it < n; it++)
+                        Q[it] = R[it];
+                      if (R = r.multGamma(r.multL(r.multGamma(Q), B, nt)), dt = r.dotProduct(Q, R), R = r.normalize(R), lt = r.dotProduct(Q, R), gt = Math.abs(lt / tt), gt <= 1 + v && gt >= 1)
+                        break;
+                      tt = lt;
+                    }
+                    for (var Nt = 0; Nt < n; Nt++)
+                      Q[Nt] = R[Nt];
+                    for (tt = p; ; ) {
+                      for (var yt = 0; yt < n; yt++)
+                        K[yt] = $[yt];
+                      if (K = r.minusOp(K, r.multCons(Q, r.dotProduct(Q, K))), $ = r.multGamma(r.multL(r.multGamma(K), B, nt)), I = r.dotProduct(K, $), $ = r.normalize($), lt = r.dotProduct(K, $), gt = Math.abs(lt / tt), gt <= 1 + v && gt >= 1)
+                        break;
+                      tt = lt;
+                    }
+                    for (var Ct = 0; Ct < n; Ct++)
+                      K[Ct] = $[Ct];
+                    P = r.multCons(Q, Math.sqrt(Math.abs(dt))), S = r.multCons(K, Math.sqrt(Math.abs(I)));
+                  };
+                  h.connectComponents(a, g, h.getTopMostNodes(c), d), N.forEach(function(dt) {
+                    h.connectComponents(a, g, h.getTopMostNodes(dt.descendants().intersection(g)), d);
+                  });
+                  for (var H = 0, Z = 0; Z < c.length; Z++)
+                    c[Z].isParent() || y.set(c[Z].id(), H++);
+                  var G = !0, D = !1, b = void 0;
+                  try {
+                    for (var q = d.keys()[Symbol.iterator](), et; !(G = (et = q.next()).done); G = !0) {
+                      var vt = et.value;
+                      y.set(vt, H++);
+                    }
+                  } catch (dt) {
+                    D = !0, b = dt;
+                  } finally {
+                    try {
+                      !G && q.return && q.return();
+                    } finally {
+                      if (D)
+                        throw b;
+                    }
+                  }
+                  for (var j = 0; j < y.size; j++)
+                    M[j] = [];
+                  N.forEach(function(dt) {
+                    for (var I = dt.children().intersection(g); I.nodes(":childless").length == 0; )
+                      I = I.nodes()[0].children().intersection(g);
+                    var R = 0, $ = I.nodes(":childless")[0].connectedEdges().length;
+                    I.nodes(":childless").forEach(function(Q, K) {
+                      Q.connectedEdges().length < $ && ($ = Q.connectedEdges().length, R = K);
+                    }), w.set(dt.id(), I.nodes(":childless")[R].id());
+                  }), c.forEach(function(dt) {
+                    var I = void 0;
+                    dt.isParent() ? I = y.get(w.get(dt.id())) : I = y.get(dt.id()), dt.neighborhood().nodes().forEach(function(R) {
+                      g.intersection(dt.edgesWith(R)).length > 0 && (R.isParent() ? M[I].push(w.get(R.id())) : M[I].push(R.id()));
+                    });
+                  });
+                  var Dt = function(dt) {
+                    var I = y.get(dt), R = void 0;
+                    d.get(dt).forEach(function($) {
+                      a.getElementById($).isParent() ? R = w.get($) : R = $, M[I].push(R), M[y.get(R)].push(dt);
+                    });
+                  }, J = !0, ot = !1, mt = void 0;
+                  try {
+                    for (var ht = d.keys()[Symbol.iterator](), Lt; !(J = (Lt = ht.next()).done); J = !0) {
+                      var _t = Lt.value;
+                      Dt(_t);
+                    }
+                  } catch (dt) {
+                    ot = !0, mt = dt;
+                  } finally {
+                    try {
+                      !J && ht.return && ht.return();
+                    } finally {
+                      if (ot)
+                        throw mt;
+                    }
+                  }
+                  n = y.size;
+                  var Tt = void 0;
+                  if (n > 2) {
+                    _ = n < s.sampleSize ? n : s.sampleSize;
+                    for (var wt = 0; wt < n; wt++)
+                      B[wt] = [];
+                    for (var zt = 0; zt < _; zt++)
+                      nt[zt] = [];
+                    return s.quality == "draft" || s.step == "all" ? (k(m), V(), z(), Tt = { nodeIndexes: y, xCoords: P, yCoords: S }) : (y.forEach(function(dt, I) {
+                      P.push(a.getElementById(I).position("x")), S.push(a.getElementById(I).position("y"));
+                    }), Tt = { nodeIndexes: y, xCoords: P, yCoords: S }), Tt;
+                  } else {
+                    var bt = y.keys(), Gt = a.getElementById(bt.next().value), Ft = Gt.position(), Vt = Gt.outerWidth();
+                    if (P.push(Ft.x), S.push(Ft.y), n == 2) {
+                      var Pt = a.getElementById(bt.next().value), $t = Pt.outerWidth();
+                      P.push(Ft.x + Vt / 2 + $t / 2 + s.idealEdgeLength), S.push(Ft.y);
+                    }
+                    return Tt = { nodeIndexes: y, xCoords: P, yCoords: S }, Tt;
+                  }
+                };
+                o.exports = { spectralLayout: e };
+              }
+            ),
+            /***/
+            579: (
+              /***/
+              (o, i, t) => {
+                var h = t(212), r = function(f) {
+                  f && f("layout", "fcose", h);
+                };
+                typeof cytoscape < "u" && r(cytoscape), o.exports = r;
+              }
+            ),
+            /***/
+            140: (
+              /***/
+              (o) => {
+                o.exports = L;
+              }
+            )
+            /******/
+          }, T = {};
+          function u(o) {
+            var i = T[o];
+            if (i !== void 0)
+              return i.exports;
+            var t = T[o] = {
+              /******/
+              // no module.id needed
+              /******/
+              // no module.loaded needed
+              /******/
+              exports: {}
+              /******/
+            };
+            return U[o](t, t.exports, u), t.exports;
+          }
+          var l = u(579);
+          return l;
+        })()
+      );
+    });
+  }(pe)), pe.exports;
+}
+var vi = pi();
+const mi = /* @__PURE__ */ Ze(vi);
+var Oe = {
+  L: "left",
+  R: "right",
+  T: "top",
+  B: "bottom"
+}, Re = {
+  L: /* @__PURE__ */ rt((A) => `${A},${A / 2} 0,${A} 0,0`, "L"),
+  R: /* @__PURE__ */ rt((A) => `0,${A / 2} ${A},0 ${A},${A}`, "R"),
+  T: /* @__PURE__ */ rt((A) => `0,0 ${A},0 ${A / 2},${A}`, "T"),
+  B: /* @__PURE__ */ rt((A) => `${A / 2},0 ${A},${A} 0,${A}`, "B")
+}, ae = {
+  L: /* @__PURE__ */ rt((A, X) => A - X + 2, "L"),
+  R: /* @__PURE__ */ rt((A, X) => A - 2, "R"),
+  T: /* @__PURE__ */ rt((A, X) => A - X + 2, "T"),
+  B: /* @__PURE__ */ rt((A, X) => A - 2, "B")
+}, yi = /* @__PURE__ */ rt(function(A) {
+  return Xt(A) ? A === "L" ? "R" : "L" : A === "T" ? "B" : "T";
+}, "getOppositeArchitectureDirection"), be = /* @__PURE__ */ rt(function(A) {
+  const X = A;
+  return X === "L" || X === "R" || X === "T" || X === "B";
+}, "isArchitectureDirection"), Xt = /* @__PURE__ */ rt(function(A) {
+  const X = A;
+  return X === "L" || X === "R";
+}, "isArchitectureDirectionX"), jt = /* @__PURE__ */ rt(function(A) {
+  const X = A;
+  return X === "T" || X === "B";
+}, "isArchitectureDirectionY"), Te = /* @__PURE__ */ rt(function(A, X) {
+  const L = Xt(A) && jt(X), U = jt(A) && Xt(X);
+  return L || U;
+}, "isArchitectureDirectionXY"), Ei = /* @__PURE__ */ rt(function(A) {
+  const X = A[0], L = A[1], U = Xt(X) && jt(L), T = jt(X) && Xt(L);
+  return U || T;
+}, "isArchitecturePairXY"), Ni = /* @__PURE__ */ rt(function(A) {
+  return A !== "LL" && A !== "RR" && A !== "TT" && A !== "BB";
+}, "isValidArchitectureDirectionPair"), ye = /* @__PURE__ */ rt(function(A, X) {
+  const L = `${A}${X}`;
+  return Ni(L) ? L : void 0;
+}, "getArchitectureDirectionPair"), Ti = /* @__PURE__ */ rt(function([A, X], L) {
+  const U = L[0], T = L[1];
+  return Xt(U) ? jt(T) ? [A + (U === "L" ? -1 : 1), X + (T === "T" ? 1 : -1)] : [A + (U === "L" ? -1 : 1), X] : Xt(T) ? [A + (T === "L" ? 1 : -1), X + (U === "T" ? 1 : -1)] : [A, X + (U === "T" ? 1 : -1)];
+}, "shiftPositionByArchitectureDirectionPair"), Ai = /* @__PURE__ */ rt(function(A) {
+  return A === "LT" || A === "TL" ? [1, 1] : A === "BL" || A === "LB" ? [1, -1] : A === "BR" || A === "RB" ? [-1, -1] : [-1, 1];
+}, "getArchitectureDirectionXYFactors"), wi = /* @__PURE__ */ rt(function(A, X) {
+  return Te(A, X) ? "bend" : Xt(A) ? "horizontal" : "vertical";
+}, "getArchitectureDirectionAlignment"), Mi = /* @__PURE__ */ rt(function(A) {
+  return A.type === "service";
+}, "isArchitectureService"), Ii = /* @__PURE__ */ rt(function(A) {
+  return A.type === "junction";
+}, "isArchitectureJunction"), Se = /* @__PURE__ */ rt((A) => A.data(), "edgeData"), ie = /* @__PURE__ */ rt((A) => A.data(), "nodeData"), Fe = $e.architecture, Et = new hi(() => ({
+  nodes: {},
+  groups: {},
+  edges: [],
+  registeredIds: {},
+  config: Fe,
+  dataStructures: void 0,
+  elements: {}
+})), Li = /* @__PURE__ */ rt(() => {
+  Et.reset(), ni();
+}, "clear"), _i = /* @__PURE__ */ rt(function({
+  id: A,
+  icon: X,
+  in: L,
+  title: U,
+  iconText: T
+}) {
+  if (Et.records.registeredIds[A] !== void 0)
+    throw new Error(
+      `The service id [${A}] is already in use by another ${Et.records.registeredIds[A]}`
+    );
+  if (L !== void 0) {
+    if (A === L)
+      throw new Error(`The service [${A}] cannot be placed within itself`);
+    if (Et.records.registeredIds[L] === void 0)
+      throw new Error(
+        `The service [${A}]'s parent does not exist. Please make sure the parent is created before this service`
+      );
+    if (Et.records.registeredIds[L] === "node")
+      throw new Error(`The service [${A}]'s parent is not a group`);
+  }
+  Et.records.registeredIds[A] = "node", Et.records.nodes[A] = {
+    id: A,
+    type: "service",
+    icon: X,
+    iconText: T,
+    title: U,
+    edges: [],
+    in: L
+  };
+}, "addService"), xi = /* @__PURE__ */ rt(() => Object.values(Et.records.nodes).filter(Mi), "getServices"), Ci = /* @__PURE__ */ rt(function({ id: A, in: X }) {
+  Et.records.registeredIds[A] = "node", Et.records.nodes[A] = {
+    id: A,
+    type: "junction",
+    edges: [],
+    in: X
+  };
+}, "addJunction"), Di = /* @__PURE__ */ rt(() => Object.values(Et.records.nodes).filter(Ii), "getJunctions"), Oi = /* @__PURE__ */ rt(() => Object.values(Et.records.nodes), "getNodes"), Ee = /* @__PURE__ */ rt((A) => Et.records.nodes[A], "getNode"), Ri = /* @__PURE__ */ rt(function({ id: A, icon: X, in: L, title: U }) {
+  if (Et.records.registeredIds[A] !== void 0)
+    throw new Error(
+      `The group id [${A}] is already in use by another ${Et.records.registeredIds[A]}`
+    );
+  if (L !== void 0) {
+    if (A === L)
+      throw new Error(`The group [${A}] cannot be placed within itself`);
+    if (Et.records.registeredIds[L] === void 0)
+      throw new Error(
+        `The group [${A}]'s parent does not exist. Please make sure the parent is created before this group`
+      );
+    if (Et.records.registeredIds[L] === "node")
+      throw new Error(`The group [${A}]'s parent is not a group`);
+  }
+  Et.records.registeredIds[A] = "group", Et.records.groups[A] = {
+    id: A,
+    icon: X,
+    title: U,
+    in: L
+  };
+}, "addGroup"), bi = /* @__PURE__ */ rt(() => Object.values(Et.records.groups), "getGroups"), Gi = /* @__PURE__ */ rt(function({
+  lhsId: A,
+  rhsId: X,
+  lhsDir: L,
+  rhsDir: U,
+  lhsInto: T,
+  rhsInto: u,
+  lhsGroup: l,
+  rhsGroup: o,
+  title: i
+}) {
+  if (!be(L))
+    throw new Error(
+      `Invalid direction given for left hand side of edge ${A}--${X}. Expected (L,R,T,B) got ${L}`
+    );
+  if (!be(U))
+    throw new Error(
+      `Invalid direction given for right hand side of edge ${A}--${X}. Expected (L,R,T,B) got ${U}`
+    );
+  if (Et.records.nodes[A] === void 0 && Et.records.groups[A] === void 0)
+    throw new Error(
+      `The left-hand id [${A}] does not yet exist. Please create the service/group before declaring an edge to it.`
+    );
+  if (Et.records.nodes[X] === void 0 && Et.records.groups[A] === void 0)
+    throw new Error(
+      `The right-hand id [${X}] does not yet exist. Please create the service/group before declaring an edge to it.`
+    );
+  const t = Et.records.nodes[A].in, h = Et.records.nodes[X].in;
+  if (l && t && h && t == h)
+    throw new Error(
+      `The left-hand id [${A}] is modified to traverse the group boundary, but the edge does not pass through two groups.`
+    );
+  if (o && t && h && t == h)
+    throw new Error(
+      `The right-hand id [${X}] is modified to traverse the group boundary, but the edge does not pass through two groups.`
+    );
+  const r = {
+    lhsId: A,
+    lhsDir: L,
+    lhsInto: T,
+    lhsGroup: l,
+    rhsId: X,
+    rhsDir: U,
+    rhsInto: u,
+    rhsGroup: o,
+    title: i
+  };
+  Et.records.edges.push(r), Et.records.nodes[A] && Et.records.nodes[X] && (Et.records.nodes[A].edges.push(Et.records.edges[Et.records.edges.length - 1]), Et.records.nodes[X].edges.push(Et.records.edges[Et.records.edges.length - 1]));
+}, "addEdge"), Pi = /* @__PURE__ */ rt(() => Et.records.edges, "getEdges"), Si = /* @__PURE__ */ rt(() => {
+  if (Et.records.dataStructures === void 0) {
+    const A = {}, X = Object.entries(Et.records.nodes).reduce((o, [i, t]) => (o[i] = t.edges.reduce((h, r) => {
+      var f, e;
+      const s = (f = Ee(r.lhsId)) == null ? void 0 : f.in, a = (e = Ee(r.rhsId)) == null ? void 0 : e.in;
+      if (s && a && s !== a) {
+        const g = wi(r.lhsDir, r.rhsDir);
+        g !== "bend" && (A[s] ?? (A[s] = {}), A[s][a] = g, A[a] ?? (A[a] = {}), A[a][s] = g);
+      }
+      if (r.lhsId === i) {
+        const g = ye(r.lhsDir, r.rhsDir);
+        g && (h[g] = r.rhsId);
+      } else {
+        const g = ye(r.rhsDir, r.lhsDir);
+        g && (h[g] = r.lhsId);
+      }
+      return h;
+    }, {}), o), {}), L = Object.keys(X)[0], U = { [L]: 1 }, T = Object.keys(X).reduce(
+      (o, i) => i === L ? o : { ...o, [i]: 1 },
+      {}
+    ), u = /* @__PURE__ */ rt((o) => {
+      const i = { [o]: [0, 0] }, t = [o];
+      for (; t.length > 0; ) {
+        const h = t.shift();
+        if (h) {
+          U[h] = 1, delete T[h];
+          const r = X[h], [f, e] = i[h];
+          Object.entries(r).forEach(([s, a]) => {
+            U[a] || (i[a] = Ti(
+              [f, e],
+              s
+            ), t.push(a));
+          });
+        }
+      }
+      return i;
+    }, "BFS"), l = [u(L)];
+    for (; Object.keys(T).length > 0; )
+      l.push(u(Object.keys(T)[0]));
+    Et.records.dataStructures = {
+      adjList: X,
+      spatialMaps: l,
+      groupAlignments: A
+    };
+  }
+  return Et.records.dataStructures;
+}, "getDataStructures"), Fi = /* @__PURE__ */ rt((A, X) => {
+  Et.records.elements[A] = X;
+}, "setElementForId"), ki = /* @__PURE__ */ rt((A) => Et.records.elements[A], "getElementById"), se = {
+  clear: Li,
+  setDiagramTitle: Ke,
+  getDiagramTitle: Qe,
+  setAccTitle: Je,
+  getAccTitle: ti,
+  setAccDescription: ei,
+  getAccDescription: ii,
+  addService: _i,
+  getServices: xi,
+  addJunction: Ci,
+  getJunctions: Di,
+  getNodes: Oi,
+  getNode: Ee,
+  addGroup: Ri,
+  getGroups: bi,
+  addEdge: Gi,
+  getEdges: Pi,
+  setElementForId: Fi,
+  getElementById: ki,
+  getDataStructures: Si
+};
+function St(A) {
+  const X = he().architecture;
+  return X != null && X[A] ? X[A] : Fe[A];
+}
+rt(St, "getConfigField");
+var Ui = /* @__PURE__ */ rt((A, X) => {
+  si(A, X), A.groups.map(X.addGroup), A.services.map((L) => X.addService({ ...L, type: "service" })), A.junctions.map((L) => X.addJunction({ ...L, type: "junction" })), A.edges.map(X.addEdge);
+}, "populateDb"), Yi = {
+  parse: /* @__PURE__ */ rt(async (A) => {
+    const X = await li("architecture", A);
+    Ge.debug(X), Ui(X, se);
+  }, "parse")
+}, Xi = /* @__PURE__ */ rt((A) => `
+  .edge {
+    stroke-width: ${A.archEdgeWidth};
+    stroke: ${A.archEdgeColor};
+    fill: none;
+  }
+
+  .arrow {
+    fill: ${A.archEdgeArrowColor};
+  }
+
+  .node-bkg {
+    fill: none;
+    stroke: ${A.archGroupBorderColor};
+    stroke-width: ${A.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"), Hi = Xi, ee = /* @__PURE__ */ rt((A) => `<g><rect width="80" height="80" style="fill: #087ebf; stroke-width: 0px;"/>${A}</g>`, "wrapIcon"), ne = {
+  prefix: "mermaid-architecture",
+  height: 80,
+  width: 80,
+  icons: {
+    database: {
+      body: ee(
+        '<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: ee(
+        '<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: ee(
+        '<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: ee(
+        '<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: ee(
+        '<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: je,
+    blank: {
+      body: ee("")
+    }
+  }
+}, Wi = /* @__PURE__ */ rt(async function(A, X) {
+  const L = St("padding"), U = St("iconSize"), T = U / 2, u = U / 6, l = u / 2;
+  await Promise.all(
+    X.edges().map(async (o) => {
+      var i, t;
+      const {
+        source: h,
+        sourceDir: r,
+        sourceArrow: f,
+        sourceGroup: e,
+        target: s,
+        targetDir: a,
+        targetArrow: g,
+        targetGroup: c,
+        label: N
+      } = Se(o);
+      let { x: d, y } = o[0].sourceEndpoint();
+      const { x: w, y: M } = o[0].midpoint();
+      let { x: P, y: S } = o[0].targetEndpoint();
+      const Y = L + 4;
+      if (e && (Xt(r) ? d += r === "L" ? -Y : Y : y += r === "T" ? -Y : Y + 18), c && (Xt(a) ? P += a === "L" ? -Y : Y : S += a === "T" ? -Y : Y + 18), !e && ((i = se.getNode(h)) == null ? void 0 : i.type) === "junction" && (Xt(r) ? d += r === "L" ? T : -T : y += r === "T" ? T : -T), !c && ((t = se.getNode(s)) == null ? void 0 : t.type) === "junction" && (Xt(a) ? P += a === "L" ? T : -T : S += a === "T" ? T : -T), o[0]._private.rscratch) {
+        const W = A.insert("g");
+        if (W.insert("path").attr("d", `M ${d},${y} L ${w},${M} L${P},${S} `).attr("class", "edge"), f) {
+          const B = Xt(r) ? ae[r](d, u) : d - l, x = jt(r) ? ae[r](y, u) : y - l;
+          W.insert("polygon").attr("points", Re[r](u)).attr("transform", `translate(${B},${x})`).attr("class", "arrow");
+        }
+        if (g) {
+          const B = Xt(a) ? ae[a](P, u) : P - l, x = jt(a) ? ae[a](S, u) : S - l;
+          W.insert("polygon").attr("points", Re[a](u)).attr("transform", `translate(${B},${x})`).attr("class", "arrow");
+        }
+        if (N) {
+          const B = Te(r, a) ? "XY" : Xt(r) ? "X" : "Y";
+          let x = 0;
+          B === "X" ? x = Math.abs(d - P) : B === "Y" ? x = Math.abs(y - S) / 1.5 : x = Math.abs(d - P) / 2;
+          const nt = W.append("g");
+          if (await Ne(
+            nt,
+            N,
+            {
+              useHtmlLabels: !1,
+              width: x,
+              classes: "architecture-service-label"
+            },
+            he()
+          ), nt.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "middle").attr("text-anchor", "middle"), B === "X")
+            nt.attr("transform", "translate(" + w + ", " + M + ")");
+          else if (B === "Y")
+            nt.attr("transform", "translate(" + w + ", " + M + ") rotate(-90)");
+          else if (B === "XY") {
+            const n = ye(r, a);
+            if (n && Ei(n)) {
+              const E = nt.node().getBoundingClientRect(), [p, v] = Ai(n);
+              nt.attr("dominant-baseline", "auto").attr("transform", `rotate(${-1 * p * v * 45})`);
+              const m = nt.node().getBoundingClientRect();
+              nt.attr(
+                "transform",
+                `
+                translate(${w}, ${M - E.height / 2})
+                translate(${p * m.width / 2}, ${v * m.height / 2})
+                rotate(${-1 * p * v * 45}, 0, ${E.height / 2})
+              `
+              );
+            }
+          }
+        }
+      }
+    })
+  );
+}, "drawEdges"), zi = /* @__PURE__ */ rt(async function(A, X) {
+  const L = St("padding") * 0.75, U = St("fontSize"), T = St("iconSize") / 2;
+  await Promise.all(
+    X.nodes().map(async (u) => {
+      const l = ie(u);
+      if (l.type === "group") {
+        const { h: o, w: i, x1: t, y1: h } = u.boundingBox();
+        A.append("rect").attr("x", t + T).attr("y", h + T).attr("width", i).attr("height", o).attr("class", "node-bkg");
+        const r = A.append("g");
+        let f = t, e = h;
+        if (l.icon) {
+          const s = r.append("g");
+          s.html(
+            `<g>${await fe(l.icon, { height: L, width: L, fallbackPrefix: ne.prefix })}</g>`
+          ), s.attr(
+            "transform",
+            "translate(" + (f + T + 1) + ", " + (e + T + 1) + ")"
+          ), f += L, e += U / 2 - 1 - 2;
+        }
+        if (l.label) {
+          const s = r.append("g");
+          await Ne(
+            s,
+            l.label,
+            {
+              useHtmlLabels: !1,
+              width: i,
+              classes: "architecture-service-label"
+            },
+            he()
+          ), s.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "start").attr("text-anchor", "start"), s.attr(
+            "transform",
+            "translate(" + (f + T + 4) + ", " + (e + T + 2) + ")"
+          );
+        }
+      }
+    })
+  );
+}, "drawGroups"), Vi = /* @__PURE__ */ rt(async function(A, X, L) {
+  for (const U of L) {
+    const T = X.append("g"), u = St("iconSize");
+    if (U.title) {
+      const t = T.append("g");
+      await Ne(
+        t,
+        U.title,
+        {
+          useHtmlLabels: !1,
+          width: u * 1.5,
+          classes: "architecture-service-label"
+        },
+        he()
+      ), t.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "middle").attr("text-anchor", "middle"), t.attr("transform", "translate(" + u / 2 + ", " + u + ")");
+    }
+    const l = T.append("g");
+    if (U.icon)
+      l.html(
+        `<g>${await fe(U.icon, { height: u, width: u, fallbackPrefix: ne.prefix })}</g>`
+      );
+    else if (U.iconText) {
+      l.html(
+        `<g>${await fe("blank", { height: u, width: u, fallbackPrefix: ne.prefix })}</g>`
+      );
+      const t = l.append("g").append("foreignObject").attr("width", u).attr("height", u).append("div").attr("class", "node-icon-text").attr("style", `height: ${u}px;`).append("div").html(U.iconText), h = parseInt(
+        window.getComputedStyle(t.node(), null).getPropertyValue("font-size").replace(/\D/g, "")
+      ) ?? 16;
+      t.attr("style", `-webkit-line-clamp: ${Math.floor((u - 2) / h)};`);
+    } else
+      l.append("path").attr("class", "node-bkg").attr("id", "node-" + U.id).attr(
+        "d",
+        `M0 ${u} v${-u} q0,-5 5,-5 h${u} q5,0 5,5 v${u} H0 Z`
+      );
+    T.attr("class", "architecture-service");
+    const { width: o, height: i } = T._groups[0][0].getBBox();
+    U.width = o, U.height = i, A.setElementForId(U.id, T);
+  }
+  return 0;
+}, "drawServices"), Bi = /* @__PURE__ */ rt(function(A, X, L) {
+  L.forEach((U) => {
+    const T = X.append("g"), u = St("iconSize");
+    T.append("g").append("rect").attr("id", "node-" + U.id).attr("fill-opacity", "0").attr("width", u).attr("height", u), T.attr("class", "architecture-junction");
+    const { width: l, height: o } = T._groups[0][0].getBBox();
+    T.width = l, T.height = o, A.setElementForId(U.id, T);
+  });
+}, "drawJunctions");
+qe([
+  {
+    name: ne.prefix,
+    icons: ne
+  }
+]);
+Pe.use(mi);
+function ke(A, X) {
+  A.forEach((L) => {
+    X.add({
+      group: "nodes",
+      data: {
+        type: "service",
+        id: L.id,
+        icon: L.icon,
+        label: L.title,
+        parent: L.in,
+        width: St("iconSize"),
+        height: St("iconSize")
+      },
+      classes: "node-service"
+    });
+  });
+}
+rt(ke, "addServices");
+function Ue(A, X) {
+  A.forEach((L) => {
+    X.add({
+      group: "nodes",
+      data: {
+        type: "junction",
+        id: L.id,
+        parent: L.in,
+        width: St("iconSize"),
+        height: St("iconSize")
+      },
+      classes: "node-junction"
+    });
+  });
+}
+rt(Ue, "addJunctions");
+function Ye(A, X) {
+  X.nodes().map((L) => {
+    const U = ie(L);
+    U.type !== "group" && (U.x = L.position().x, U.y = L.position().y, A.getElementById(U.id).attr("transform", "translate(" + (U.x || 0) + "," + (U.y || 0) + ")"));
+  });
+}
+rt(Ye, "positionNodes");
+function Xe(A, X) {
+  A.forEach((L) => {
+    X.add({
+      group: "nodes",
+      data: {
+        type: "group",
+        id: L.id,
+        icon: L.icon,
+        label: L.title,
+        parent: L.in
+      },
+      classes: "node-group"
+    });
+  });
+}
+rt(Xe, "addGroups");
+function He(A, X) {
+  A.forEach((L) => {
+    const { lhsId: U, rhsId: T, lhsInto: u, lhsGroup: l, rhsInto: o, lhsDir: i, rhsDir: t, rhsGroup: h, title: r } = L, f = Te(L.lhsDir, L.rhsDir) ? "segments" : "straight", e = {
+      id: `${U}-${T}`,
+      label: r,
+      source: U,
+      sourceDir: i,
+      sourceArrow: u,
+      sourceGroup: l,
+      sourceEndpoint: i === "L" ? "0 50%" : i === "R" ? "100% 50%" : i === "T" ? "50% 0" : "50% 100%",
+      target: T,
+      targetDir: t,
+      targetArrow: o,
+      targetGroup: h,
+      targetEndpoint: t === "L" ? "0 50%" : t === "R" ? "100% 50%" : t === "T" ? "50% 0" : "50% 100%"
+    };
+    X.add({
+      group: "edges",
+      data: e,
+      classes: f
+    });
+  });
+}
+rt(He, "addEdges");
+function We(A, X, L) {
+  const U = /* @__PURE__ */ rt((o, i) => Object.entries(o).reduce(
+    (t, [h, r]) => {
+      var f;
+      let e = 0;
+      const s = Object.entries(r);
+      if (s.length === 1)
+        return t[h] = s[0][1], t;
+      for (let a = 0; a < s.length - 1; a++)
+        for (let g = a + 1; g < s.length; g++) {
+          const [c, N] = s[a], [d, y] = s[g];
+          if (((f = L[c]) == null ? void 0 : f[d]) === i)
+            t[h] ?? (t[h] = []), t[h] = [...t[h], ...N, ...y];
+          else if (c === "default" || d === "default")
+            t[h] ?? (t[h] = []), t[h] = [...t[h], ...N, ...y];
+          else {
+            const w = `${h}-${e++}`;
+            t[w] = N;
+            const M = `${h}-${e++}`;
+            t[M] = y;
+          }
+        }
+      return t;
+    },
+    {}
+  ), "flattenAlignments"), T = X.map((o) => {
+    const i = {}, t = {};
+    return Object.entries(o).forEach(([h, [r, f]]) => {
+      var e, s, a;
+      const g = ((e = A.getNode(h)) == null ? void 0 : e.in) ?? "default";
+      i[f] ?? (i[f] = {}), (s = i[f])[g] ?? (s[g] = []), i[f][g].push(h), t[r] ?? (t[r] = {}), (a = t[r])[g] ?? (a[g] = []), t[r][g].push(h);
+    }), {
+      horiz: Object.values(U(i, "horizontal")).filter(
+        (h) => h.length > 1
+      ),
+      vert: Object.values(U(t, "vertical")).filter(
+        (h) => h.length > 1
+      )
+    };
+  }), [u, l] = T.reduce(
+    ([o, i], { horiz: t, vert: h }) => [
+      [...o, ...t],
+      [...i, ...h]
+    ],
+    [[], []]
+  );
+  return {
+    horizontal: u,
+    vertical: l
+  };
+}
+rt(We, "getAlignments");
+function ze(A) {
+  const X = [], L = /* @__PURE__ */ rt((T) => `${T[0]},${T[1]}`, "posToStr"), U = /* @__PURE__ */ rt((T) => T.split(",").map((u) => parseInt(u)), "strToPos");
+  return A.forEach((T) => {
+    const u = Object.fromEntries(
+      Object.entries(T).map(([t, h]) => [L(h), t])
+    ), l = [L([0, 0])], o = {}, i = {
+      L: [-1, 0],
+      R: [1, 0],
+      T: [0, 1],
+      B: [0, -1]
+    };
+    for (; l.length > 0; ) {
+      const t = l.shift();
+      if (t) {
+        o[t] = 1;
+        const h = u[t];
+        if (h) {
+          const r = U(t);
+          Object.entries(i).forEach(([f, e]) => {
+            const s = L([r[0] + e[0], r[1] + e[1]]), a = u[s];
+            a && !o[s] && (l.push(s), X.push({
+              [Oe[f]]: a,
+              [Oe[yi(f)]]: h,
+              gap: 1.5 * St("iconSize")
+            }));
+          });
+        }
+      }
+    }
+  }), X;
+}
+rt(ze, "getRelativeConstraints");
+function Ve(A, X, L, U, T, { spatialMaps: u, groupAlignments: l }) {
+  return new Promise((o) => {
+    const i = ri("body").append("div").attr("id", "cy").attr("style", "display:none"), t = Pe({
+      container: document.getElementById("cy"),
+      style: [
+        {
+          selector: "edge",
+          style: {
+            "curve-style": "straight",
+            label: "data(label)",
+            "source-endpoint": "data(sourceEndpoint)",
+            "target-endpoint": "data(targetEndpoint)"
+          }
+        },
+        {
+          selector: "edge.segments",
+          style: {
+            "curve-style": "segments",
+            "segment-weights": "0",
+            "segment-distances": [0.5],
+            // @ts-ignore Incorrect library types
+            "edge-distances": "endpoints",
+            "source-endpoint": "data(sourceEndpoint)",
+            "target-endpoint": "data(targetEndpoint)"
+          }
+        },
+        {
+          selector: "node",
+          style: {
+            // @ts-ignore Incorrect library types
+            "compound-sizing-wrt-labels": "include"
+          }
+        },
+        {
+          selector: "node[label]",
+          style: {
+            "text-valign": "bottom",
+            "text-halign": "center",
+            "font-size": `${St("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: {
+            // @ts-ignore Incorrect library types
+            padding: `${St("padding")}px`
+          }
+        }
+      ]
+    });
+    i.remove(), Xe(L, t), ke(A, t), Ue(X, t), He(U, t);
+    const h = We(T, u, l), r = ze(u), f = t.layout({
+      name: "fcose",
+      quality: "proof",
+      styleEnabled: !1,
+      animate: !1,
+      nodeDimensionsIncludeLabels: !1,
+      // Adjust the edge parameters if it passes through the border of a group
+      // Hacky fix for: https://github.com/iVis-at-Bilkent/cytoscape.js-fcose/issues/67
+      idealEdgeLength(e) {
+        const [s, a] = e.connectedNodes(), { parent: g } = ie(s), { parent: c } = ie(a);
+        return g === c ? 1.5 * St("iconSize") : 0.5 * St("iconSize");
+      },
+      edgeElasticity(e) {
+        const [s, a] = e.connectedNodes(), { parent: g } = ie(s), { parent: c } = ie(a);
+        return g === c ? 0.45 : 1e-3;
+      },
+      alignmentConstraint: h,
+      relativePlacementConstraint: r
+    });
+    f.one("layoutstop", () => {
+      var e;
+      function s(a, g, c, N) {
+        let d, y;
+        const { x: w, y: M } = a, { x: P, y: S } = g;
+        y = (N - M + (w - c) * (M - S) / (w - P)) / Math.sqrt(1 + Math.pow((M - S) / (w - P), 2)), d = Math.sqrt(Math.pow(N - M, 2) + Math.pow(c - w, 2) - Math.pow(y, 2));
+        const Y = Math.sqrt(Math.pow(P - w, 2) + Math.pow(S - M, 2));
+        d = d / Y;
+        let W = (P - w) * (N - M) - (S - M) * (c - w);
+        switch (!0) {
+          case W >= 0:
+            W = 1;
+            break;
+          case W < 0:
+            W = -1;
+            break;
+        }
+        let B = (P - w) * (c - w) + (S - M) * (N - M);
+        switch (!0) {
+          case B >= 0:
+            B = 1;
+            break;
+          case B < 0:
+            B = -1;
+            break;
+        }
+        return y = Math.abs(y) * W, d = d * B, {
+          distances: y,
+          weights: d
+        };
+      }
+      rt(s, "getSegmentWeights"), t.startBatch();
+      for (const a of Object.values(t.edges()))
+        if ((e = a.data) != null && e.call(a)) {
+          const { x: g, y: c } = a.source().position(), { x: N, y: d } = a.target().position();
+          if (g !== N && c !== d) {
+            const y = a.sourceEndpoint(), w = a.targetEndpoint(), { sourceDir: M } = Se(a), [P, S] = jt(M) ? [y.x, w.y] : [w.x, y.y], { weights: Y, distances: W } = s(y, w, P, S);
+            a.style("segment-distances", W), a.style("segment-weights", Y);
+          }
+        }
+      t.endBatch(), f.run();
+    }), f.run(), t.ready((e) => {
+      Ge.info("Ready", e), o(t);
+    });
+  });
+}
+rt(Ve, "layoutArchitecture");
+var $i = /* @__PURE__ */ rt(async (A, X, L, U) => {
+  const T = U.db, u = T.getServices(), l = T.getJunctions(), o = T.getGroups(), i = T.getEdges(), t = T.getDataStructures(), h = oi(X), r = h.append("g");
+  r.attr("class", "architecture-edges");
+  const f = h.append("g");
+  f.attr("class", "architecture-services");
+  const e = h.append("g");
+  e.attr("class", "architecture-groups"), await Vi(T, f, u), Bi(T, f, l);
+  const s = await Ve(u, l, o, i, T, t);
+  await Wi(r, s), await zi(e, s), Ye(T, s), ai(void 0, h, St("padding"), St("useMaxWidth"));
+}, "draw"), ji = { draw: $i }, nr = {
+  parser: Yi,
+  db: se,
+  renderer: ji,
+  styles: Hi
+};
+export {
+  nr as diagram
+};