@kong-ui-public/documentation 1.5.10 → 1.5.11

package/dist/architectureDiagram-Q4EWVU46-DqiP7Rm1-CBe5jt7q.js

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