@kong-ui-public/documentation 0.8.27-pr.2132.c7fba69a4.0 → 0.8.27

package/dist/architectureDiagram-UYN6MBPD-Bg70hFZ--BirbHF75.js

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