@sourcegraph/amp 0.0.1749585689-g82b91d → 0.0.1749614780-g9a56bd

package/dist/mindmap-definition-TI5ONXTW-BNaRba4R.js

@@ -0,0 +1,3221 @@
+#!/usr/bin/env node
+import { c as ut } from "./chunk-COUQ6RZ3-qd4eG6tc.js";
+import { _ as N, A as z, y as nt, av as Et, bv as Lt, a6 as tt, I as et, bw as Tt, bx as mt, by as Nt, z as Dt, bA as At, ax as Ot, J as It, au as st } from "./console-CoE5Qzyz.js";
+var ct = st({
+  "../../node_modules/.pnpm/layout-base@1.0.2/node_modules/layout-base/layout-base.js"(O, x) {
+    (/* @__PURE__ */ N(function(A, d) {
+      typeof O == "object" && typeof x == "object" ? x.exports = d() : typeof define == "function" && define.amd ? define([], d) : typeof O == "object" ? O.layoutBase = d() : A.layoutBase = d();
+    }, "webpackUniversalModuleDefinition"))(O, function() {
+      return (
+        /******/
+        function(f) {
+          var A = {};
+          function d(r) {
+            if (A[r])
+              return A[r].exports;
+            var t = A[r] = {
+              /******/
+              i: r,
+              /******/
+              l: !1,
+              /******/
+              exports: {}
+              /******/
+            };
+            return f[r].call(t.exports, t, t.exports, d), t.l = !0, t.exports;
+          }
+          return N(d, "__webpack_require__"), d.m = f, d.c = A, d.i = function(r) {
+            return r;
+          }, d.d = function(r, t, e) {
+            d.o(r, t) || Object.defineProperty(r, t, {
+              /******/
+              configurable: !1,
+              /******/
+              enumerable: !0,
+              /******/
+              get: e
+              /******/
+            });
+          }, d.n = function(r) {
+            var t = r && r.__esModule ? (
+              /******/
+              /* @__PURE__ */ N(function() {
+                return r.default;
+              }, "getDefault")
+            ) : (
+              /******/
+              /* @__PURE__ */ N(function() {
+                return r;
+              }, "getModuleExports")
+            );
+            return d.d(t, "a", t), t;
+          }, d.o = function(r, t) {
+            return Object.prototype.hasOwnProperty.call(r, t);
+          }, d.p = "", d(d.s = 26);
+        }([
+          /* 0 */
+          /***/
+          function(f, A, d) {
+            function r() {
+            }
+            N(r, "LayoutConstants"), r.QUALITY = 1, r.DEFAULT_CREATE_BENDS_AS_NEEDED = !1, r.DEFAULT_INCREMENTAL = !1, r.DEFAULT_ANIMATION_ON_LAYOUT = !0, r.DEFAULT_ANIMATION_DURING_LAYOUT = !1, r.DEFAULT_ANIMATION_PERIOD = 50, r.DEFAULT_UNIFORM_LEAF_NODE_SIZES = !1, r.DEFAULT_GRAPH_MARGIN = 15, r.NODE_DIMENSIONS_INCLUDE_LABELS = !1, r.SIMPLE_NODE_SIZE = 40, r.SIMPLE_NODE_HALF_SIZE = r.SIMPLE_NODE_SIZE / 2, r.EMPTY_COMPOUND_NODE_SIZE = 40, r.MIN_EDGE_LENGTH = 1, r.WORLD_BOUNDARY = 1e6, r.INITIAL_WORLD_BOUNDARY = r.WORLD_BOUNDARY / 1e3, r.WORLD_CENTER_X = 1200, r.WORLD_CENTER_Y = 900, f.exports = r;
+          },
+          /* 1 */
+          /***/
+          function(f, A, d) {
+            var r = d(2), t = d(8), e = d(9);
+            function i(g, a, y) {
+              r.call(this, y), this.isOverlapingSourceAndTarget = !1, this.vGraphObject = y, this.bendpoints = [], this.source = g, this.target = a;
+            }
+            N(i, "LEdge"), i.prototype = Object.create(r.prototype);
+            for (var o in r)
+              i[o] = r[o];
+            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(g) {
+              if (this.source === g)
+                return this.target;
+              if (this.target === g)
+                return this.source;
+              throw "Node is not incident with this edge";
+            }, i.prototype.getOtherEndInGraph = function(g, a) {
+              for (var y = this.getOtherEnd(g), n = a.getGraphManager().getRoot(); ; ) {
+                if (y.getOwner() == a)
+                  return y;
+                if (y.getOwner() == n)
+                  break;
+                y = y.getOwner().getParent();
+              }
+              return null;
+            }, i.prototype.updateLength = function() {
+              var g = new Array(4);
+              this.isOverlapingSourceAndTarget = t.getIntersection(this.target.getRect(), this.source.getRect(), g), this.isOverlapingSourceAndTarget || (this.lengthX = g[0] - g[2], this.lengthY = g[1] - g[3], Math.abs(this.lengthX) < 1 && (this.lengthX = e.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = e.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 = e.sign(this.lengthX)), Math.abs(this.lengthY) < 1 && (this.lengthY = e.sign(this.lengthY)), this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+            }, f.exports = i;
+          },
+          /* 2 */
+          /***/
+          function(f, A, d) {
+            function r(t) {
+              this.vGraphObject = t;
+            }
+            N(r, "LGraphObject"), f.exports = r;
+          },
+          /* 3 */
+          /***/
+          function(f, A, d) {
+            var r = d(2), t = d(10), e = d(13), i = d(0), o = d(16), g = d(4);
+            function a(n, h, l, E) {
+              l == null && E == null && (E = h), r.call(this, E), n.graphManager != null && (n = n.graphManager), this.estimatedSize = t.MIN_VALUE, this.inclusionTreeDepth = t.MAX_VALUE, this.vGraphObject = E, this.edges = [], this.graphManager = n, l != null && h != null ? this.rect = new e(h.x, h.y, l.width, l.height) : this.rect = new e();
+            }
+            N(a, "LNode"), a.prototype = Object.create(r.prototype);
+            for (var y in r)
+              a[y] = r[y];
+            a.prototype.getEdges = function() {
+              return this.edges;
+            }, a.prototype.getChild = function() {
+              return this.child;
+            }, a.prototype.getOwner = function() {
+              return this.owner;
+            }, a.prototype.getWidth = function() {
+              return this.rect.width;
+            }, a.prototype.setWidth = function(n) {
+              this.rect.width = n;
+            }, a.prototype.getHeight = function() {
+              return this.rect.height;
+            }, a.prototype.setHeight = function(n) {
+              this.rect.height = n;
+            }, a.prototype.getCenterX = function() {
+              return this.rect.x + this.rect.width / 2;
+            }, a.prototype.getCenterY = function() {
+              return this.rect.y + this.rect.height / 2;
+            }, a.prototype.getCenter = function() {
+              return new g(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2);
+            }, a.prototype.getLocation = function() {
+              return new g(this.rect.x, this.rect.y);
+            }, a.prototype.getRect = function() {
+              return this.rect;
+            }, a.prototype.getDiagonal = function() {
+              return Math.sqrt(this.rect.width * this.rect.width + this.rect.height * this.rect.height);
+            }, a.prototype.getHalfTheDiagonal = function() {
+              return Math.sqrt(this.rect.height * this.rect.height + this.rect.width * this.rect.width) / 2;
+            }, a.prototype.setRect = function(n, h) {
+              this.rect.x = n.x, this.rect.y = n.y, this.rect.width = h.width, this.rect.height = h.height;
+            }, a.prototype.setCenter = function(n, h) {
+              this.rect.x = n - this.rect.width / 2, this.rect.y = h - this.rect.height / 2;
+            }, a.prototype.setLocation = function(n, h) {
+              this.rect.x = n, this.rect.y = h;
+            }, a.prototype.moveBy = function(n, h) {
+              this.rect.x += n, this.rect.y += h;
+            }, a.prototype.getEdgeListToNode = function(n) {
+              var h = [], l = this;
+              return l.edges.forEach(function(E) {
+                if (E.target == n) {
+                  if (E.source != l) throw "Incorrect edge source!";
+                  h.push(E);
+                }
+              }), h;
+            }, a.prototype.getEdgesBetween = function(n) {
+              var h = [], l = this;
+              return l.edges.forEach(function(E) {
+                if (!(E.source == l || E.target == l)) throw "Incorrect edge source and/or target";
+                (E.target == n || E.source == n) && h.push(E);
+              }), h;
+            }, a.prototype.getNeighborsList = function() {
+              var n = /* @__PURE__ */ new Set(), h = this;
+              return h.edges.forEach(function(l) {
+                if (l.source == h)
+                  n.add(l.target);
+                else {
+                  if (l.target != h)
+                    throw "Incorrect incidency!";
+                  n.add(l.source);
+                }
+              }), n;
+            }, a.prototype.withChildren = function() {
+              var n = /* @__PURE__ */ new Set(), h, l;
+              if (n.add(this), this.child != null)
+                for (var E = this.child.getNodes(), T = 0; T < E.length; T++)
+                  h = E[T], l = h.withChildren(), l.forEach(function(D) {
+                    n.add(D);
+                  });
+              return n;
+            }, a.prototype.getNoOfChildren = function() {
+              var n = 0, h;
+              if (this.child == null)
+                n = 1;
+              else
+                for (var l = this.child.getNodes(), E = 0; E < l.length; E++)
+                  h = l[E], n += h.getNoOfChildren();
+              return n == 0 && (n = 1), n;
+            }, a.prototype.getEstimatedSize = function() {
+              if (this.estimatedSize == t.MIN_VALUE)
+                throw "assert failed";
+              return this.estimatedSize;
+            }, a.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);
+            }, a.prototype.scatter = function() {
+              var n, h, l = -i.INITIAL_WORLD_BOUNDARY, E = i.INITIAL_WORLD_BOUNDARY;
+              n = i.WORLD_CENTER_X + o.nextDouble() * (E - l) + l;
+              var T = -i.INITIAL_WORLD_BOUNDARY, D = i.INITIAL_WORLD_BOUNDARY;
+              h = i.WORLD_CENTER_Y + o.nextDouble() * (D - T) + T, this.rect.x = n, this.rect.y = h;
+            }, a.prototype.updateBounds = function() {
+              if (this.getChild() == null)
+                throw "assert failed";
+              if (this.getChild().getNodes().length != 0) {
+                var n = this.getChild();
+                if (n.updateBounds(!0), this.rect.x = n.getLeft(), this.rect.y = n.getTop(), this.setWidth(n.getRight() - n.getLeft()), this.setHeight(n.getBottom() - n.getTop()), i.NODE_DIMENSIONS_INCLUDE_LABELS) {
+                  var h = n.getRight() - n.getLeft(), l = n.getBottom() - n.getTop();
+                  this.labelWidth > h && (this.rect.x -= (this.labelWidth - h) / 2, this.setWidth(this.labelWidth)), this.labelHeight > l && (this.labelPos == "center" ? this.rect.y -= (this.labelHeight - l) / 2 : this.labelPos == "top" && (this.rect.y -= this.labelHeight - l), this.setHeight(this.labelHeight));
+                }
+              }
+            }, a.prototype.getInclusionTreeDepth = function() {
+              if (this.inclusionTreeDepth == t.MAX_VALUE)
+                throw "assert failed";
+              return this.inclusionTreeDepth;
+            }, a.prototype.transform = function(n) {
+              var h = this.rect.x;
+              h > i.WORLD_BOUNDARY ? h = i.WORLD_BOUNDARY : h < -i.WORLD_BOUNDARY && (h = -i.WORLD_BOUNDARY);
+              var l = this.rect.y;
+              l > i.WORLD_BOUNDARY ? l = i.WORLD_BOUNDARY : l < -i.WORLD_BOUNDARY && (l = -i.WORLD_BOUNDARY);
+              var E = new g(h, l), T = n.inverseTransformPoint(E);
+              this.setLocation(T.x, T.y);
+            }, a.prototype.getLeft = function() {
+              return this.rect.x;
+            }, a.prototype.getRight = function() {
+              return this.rect.x + this.rect.width;
+            }, a.prototype.getTop = function() {
+              return this.rect.y;
+            }, a.prototype.getBottom = function() {
+              return this.rect.y + this.rect.height;
+            }, a.prototype.getParent = function() {
+              return this.owner == null ? null : this.owner.getParent();
+            }, f.exports = a;
+          },
+          /* 4 */
+          /***/
+          function(f, A, d) {
+            function r(t, e) {
+              t == null && e == null ? (this.x = 0, this.y = 0) : (this.x = t, this.y = e);
+            }
+            N(r, "PointD"), r.prototype.getX = function() {
+              return this.x;
+            }, r.prototype.getY = function() {
+              return this.y;
+            }, r.prototype.setX = function(t) {
+              this.x = t;
+            }, r.prototype.setY = function(t) {
+              this.y = t;
+            }, r.prototype.getDifference = function(t) {
+              return new DimensionD(this.x - t.x, this.y - t.y);
+            }, r.prototype.getCopy = function() {
+              return new r(this.x, this.y);
+            }, r.prototype.translate = function(t) {
+              return this.x += t.width, this.y += t.height, this;
+            }, f.exports = r;
+          },
+          /* 5 */
+          /***/
+          function(f, A, d) {
+            var r = d(2), t = d(10), e = d(0), i = d(6), o = d(3), g = d(1), a = d(13), y = d(12), n = d(11);
+            function h(E, T, D) {
+              r.call(this, D), this.estimatedSize = t.MIN_VALUE, this.margin = e.DEFAULT_GRAPH_MARGIN, this.edges = [], this.nodes = [], this.isConnected = !1, this.parent = E, T != null && T instanceof i ? this.graphManager = T : T != null && T instanceof Layout && (this.graphManager = T.graphManager);
+            }
+            N(h, "LGraph"), h.prototype = Object.create(r.prototype);
+            for (var l in r)
+              h[l] = r[l];
+            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(E, T, D) {
+              if (T == null && D == null) {
+                var L = E;
+                if (this.graphManager == null)
+                  throw "Graph has no graph mgr!";
+                if (this.getNodes().indexOf(L) > -1)
+                  throw "Node already in graph!";
+                return L.owner = this, this.getNodes().push(L), L;
+              } else {
+                var I = E;
+                if (!(this.getNodes().indexOf(T) > -1 && this.getNodes().indexOf(D) > -1))
+                  throw "Source or target not in graph!";
+                if (!(T.owner == D.owner && T.owner == this))
+                  throw "Both owners must be this graph!";
+                return T.owner != D.owner ? null : (I.source = T, I.target = D, I.isInterGraph = !1, this.getEdges().push(I), T.edges.push(I), D != T && D.edges.push(I), I);
+              }
+            }, h.prototype.remove = function(E) {
+              var T = E;
+              if (E instanceof o) {
+                if (T == null)
+                  throw "Node is null!";
+                if (!(T.owner != null && T.owner == this))
+                  throw "Owner graph is invalid!";
+                if (this.graphManager == null)
+                  throw "Owner graph manager is invalid!";
+                for (var D = T.edges.slice(), L, I = D.length, v = 0; v < I; v++)
+                  L = D[v], L.isInterGraph ? this.graphManager.remove(L) : L.source.owner.remove(L);
+                var m = this.nodes.indexOf(T);
+                if (m == -1)
+                  throw "Node not in owner node list!";
+                this.nodes.splice(m, 1);
+              } else if (E instanceof g) {
+                var L = E;
+                if (L == null)
+                  throw "Edge is null!";
+                if (!(L.source != null && L.target != null))
+                  throw "Source and/or target is null!";
+                if (!(L.source.owner != null && L.target.owner != null && L.source.owner == this && L.target.owner == this))
+                  throw "Source and/or target owner is invalid!";
+                var s = L.source.edges.indexOf(L), c = L.target.edges.indexOf(L);
+                if (!(s > -1 && c > -1))
+                  throw "Source and/or target doesn't know this edge!";
+                L.source.edges.splice(s, 1), L.target != L.source && L.target.edges.splice(c, 1);
+                var m = L.source.owner.getEdges().indexOf(L);
+                if (m == -1)
+                  throw "Not in owner's edge list!";
+                L.source.owner.getEdges().splice(m, 1);
+              }
+            }, h.prototype.updateLeftTop = function() {
+              for (var E = t.MAX_VALUE, T = t.MAX_VALUE, D, L, I, v = this.getNodes(), m = v.length, s = 0; s < m; s++) {
+                var c = v[s];
+                D = c.getTop(), L = c.getLeft(), E > D && (E = D), T > L && (T = L);
+              }
+              return E == t.MAX_VALUE ? null : (v[0].getParent().paddingLeft != null ? I = v[0].getParent().paddingLeft : I = this.margin, this.left = T - I, this.top = E - I, new y(this.left, this.top));
+            }, h.prototype.updateBounds = function(E) {
+              for (var T = t.MAX_VALUE, D = -t.MAX_VALUE, L = t.MAX_VALUE, I = -t.MAX_VALUE, v, m, s, c, u, p = this.nodes, C = p.length, R = 0; R < C; R++) {
+                var M = p[R];
+                E && M.child != null && M.updateBounds(), v = M.getLeft(), m = M.getRight(), s = M.getTop(), c = M.getBottom(), T > v && (T = v), D < m && (D = m), L > s && (L = s), I < c && (I = c);
+              }
+              var w = new a(T, L, D - T, I - L);
+              T == t.MAX_VALUE && (this.left = this.parent.getLeft(), this.right = this.parent.getRight(), this.top = this.parent.getTop(), this.bottom = this.parent.getBottom()), p[0].getParent().paddingLeft != null ? u = p[0].getParent().paddingLeft : u = this.margin, this.left = w.x - u, this.right = w.x + w.width + u, this.top = w.y - u, this.bottom = w.y + w.height + u;
+            }, h.calculateBounds = function(E) {
+              for (var T = t.MAX_VALUE, D = -t.MAX_VALUE, L = t.MAX_VALUE, I = -t.MAX_VALUE, v, m, s, c, u = E.length, p = 0; p < u; p++) {
+                var C = E[p];
+                v = C.getLeft(), m = C.getRight(), s = C.getTop(), c = C.getBottom(), T > v && (T = v), D < m && (D = m), L > s && (L = s), I < c && (I = c);
+              }
+              var R = new a(T, L, D - T, I - L);
+              return R;
+            }, h.prototype.getInclusionTreeDepth = function() {
+              return this == this.graphManager.getRoot() ? 1 : this.parent.getInclusionTreeDepth();
+            }, h.prototype.getEstimatedSize = function() {
+              if (this.estimatedSize == t.MIN_VALUE)
+                throw "assert failed";
+              return this.estimatedSize;
+            }, h.prototype.calcEstimatedSize = function() {
+              for (var E = 0, T = this.nodes, D = T.length, L = 0; L < D; L++) {
+                var I = T[L];
+                E += I.calcEstimatedSize();
+              }
+              return E == 0 ? this.estimatedSize = e.EMPTY_COMPOUND_NODE_SIZE : this.estimatedSize = E / Math.sqrt(this.nodes.length), this.estimatedSize;
+            }, h.prototype.updateConnected = function() {
+              var E = this;
+              if (this.nodes.length == 0) {
+                this.isConnected = !0;
+                return;
+              }
+              var T = new n(), D = /* @__PURE__ */ new Set(), L = this.nodes[0], I, v, m = L.withChildren();
+              for (m.forEach(function(R) {
+                T.push(R), D.add(R);
+              }); T.length !== 0; ) {
+                L = T.shift(), I = L.getEdges();
+                for (var s = I.length, c = 0; c < s; c++) {
+                  var u = I[c];
+                  if (v = u.getOtherEndInGraph(L, this), v != null && !D.has(v)) {
+                    var p = v.withChildren();
+                    p.forEach(function(R) {
+                      T.push(R), D.add(R);
+                    });
+                  }
+                }
+              }
+              if (this.isConnected = !1, D.size >= this.nodes.length) {
+                var C = 0;
+                D.forEach(function(R) {
+                  R.owner == E && C++;
+                }), C == this.nodes.length && (this.isConnected = !0);
+              }
+            }, f.exports = h;
+          },
+          /* 6 */
+          /***/
+          function(f, A, d) {
+            var r, t = d(1);
+            function e(i) {
+              r = d(5), this.layout = i, this.graphs = [], this.edges = [];
+            }
+            N(e, "LGraphManager"), e.prototype.addRoot = function() {
+              var i = this.layout.newGraph(), o = this.layout.newNode(null), g = this.add(i, o);
+              return this.setRootGraph(g), this.rootGraph;
+            }, e.prototype.add = function(i, o, g, a, y) {
+              if (g == null && a == null && y == null) {
+                if (i == null)
+                  throw "Graph is null!";
+                if (o == 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 (o.child != null)
+                  throw "Already has a child!";
+                return i.parent = o, o.child = i, i;
+              } else {
+                y = g, a = o, g = i;
+                var n = a.getOwner(), h = y.getOwner();
+                if (!(n != null && n.getGraphManager() == this))
+                  throw "Source not in this graph mgr!";
+                if (!(h != null && h.getGraphManager() == this))
+                  throw "Target not in this graph mgr!";
+                if (n == h)
+                  return g.isInterGraph = !1, n.add(g, a, y);
+                if (g.isInterGraph = !0, g.source = a, g.target = y, this.edges.indexOf(g) > -1)
+                  throw "Edge already in inter-graph edge list!";
+                if (this.edges.push(g), !(g.source != null && g.target != null))
+                  throw "Edge source and/or target is null!";
+                if (!(g.source.edges.indexOf(g) == -1 && g.target.edges.indexOf(g) == -1))
+                  throw "Edge already in source and/or target incidency list!";
+                return g.source.edges.push(g), g.target.edges.push(g), g;
+              }
+            }, e.prototype.remove = function(i) {
+              if (i instanceof r) {
+                var o = i;
+                if (o.getGraphManager() != this)
+                  throw "Graph not in this graph mgr";
+                if (!(o == this.rootGraph || o.parent != null && o.parent.graphManager == this))
+                  throw "Invalid parent node!";
+                var g = [];
+                g = g.concat(o.getEdges());
+                for (var a, y = g.length, n = 0; n < y; n++)
+                  a = g[n], o.remove(a);
+                var h = [];
+                h = h.concat(o.getNodes());
+                var l;
+                y = h.length;
+                for (var n = 0; n < y; n++)
+                  l = h[n], o.remove(l);
+                o == this.rootGraph && this.setRootGraph(null);
+                var E = this.graphs.indexOf(o);
+                this.graphs.splice(E, 1), o.parent = null;
+              } else if (i instanceof t) {
+                if (a = i, a == null)
+                  throw "Edge is null!";
+                if (!a.isInterGraph)
+                  throw "Not an inter-graph edge!";
+                if (!(a.source != null && a.target != null))
+                  throw "Source and/or target is null!";
+                if (!(a.source.edges.indexOf(a) != -1 && a.target.edges.indexOf(a) != -1))
+                  throw "Source and/or target doesn't know this edge!";
+                var E = a.source.edges.indexOf(a);
+                if (a.source.edges.splice(E, 1), E = a.target.edges.indexOf(a), a.target.edges.splice(E, 1), !(a.source.owner != null && a.source.owner.getGraphManager() != null))
+                  throw "Edge owner graph or owner graph manager is null!";
+                if (a.source.owner.getGraphManager().edges.indexOf(a) == -1)
+                  throw "Not in owner graph manager's edge list!";
+                var E = a.source.owner.getGraphManager().edges.indexOf(a);
+                a.source.owner.getGraphManager().edges.splice(E, 1);
+              }
+            }, e.prototype.updateBounds = function() {
+              this.rootGraph.updateBounds(!0);
+            }, e.prototype.getGraphs = function() {
+              return this.graphs;
+            }, e.prototype.getAllNodes = function() {
+              if (this.allNodes == null) {
+                for (var i = [], o = this.getGraphs(), g = o.length, a = 0; a < g; a++)
+                  i = i.concat(o[a].getNodes());
+                this.allNodes = i;
+              }
+              return this.allNodes;
+            }, e.prototype.resetAllNodes = function() {
+              this.allNodes = null;
+            }, e.prototype.resetAllEdges = function() {
+              this.allEdges = null;
+            }, e.prototype.resetAllNodesToApplyGravitation = function() {
+              this.allNodesToApplyGravitation = null;
+            }, e.prototype.getAllEdges = function() {
+              if (this.allEdges == null) {
+                var i = [], o = this.getGraphs();
+                o.length;
+                for (var g = 0; g < o.length; g++)
+                  i = i.concat(o[g].getEdges());
+                i = i.concat(this.edges), this.allEdges = i;
+              }
+              return this.allEdges;
+            }, e.prototype.getAllNodesToApplyGravitation = function() {
+              return this.allNodesToApplyGravitation;
+            }, e.prototype.setAllNodesToApplyGravitation = function(i) {
+              if (this.allNodesToApplyGravitation != null)
+                throw "assert failed";
+              this.allNodesToApplyGravitation = i;
+            }, e.prototype.getRoot = function() {
+              return this.rootGraph;
+            }, e.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"));
+            }, e.prototype.getLayout = function() {
+              return this.layout;
+            }, e.prototype.isOneAncestorOfOther = function(i, o) {
+              if (!(i != null && o != null))
+                throw "assert failed";
+              if (i == o)
+                return !0;
+              var g = i.getOwner(), a;
+              do {
+                if (a = g.getParent(), a == null)
+                  break;
+                if (a == o)
+                  return !0;
+                if (g = a.getOwner(), g == null)
+                  break;
+              } while (!0);
+              g = o.getOwner();
+              do {
+                if (a = g.getParent(), a == null)
+                  break;
+                if (a == i)
+                  return !0;
+                if (g = a.getOwner(), g == null)
+                  break;
+              } while (!0);
+              return !1;
+            }, e.prototype.calcLowestCommonAncestors = function() {
+              for (var i, o, g, a, y, n = this.getAllEdges(), h = n.length, l = 0; l < h; l++) {
+                if (i = n[l], o = i.source, g = i.target, i.lca = null, i.sourceInLca = o, i.targetInLca = g, o == g) {
+                  i.lca = o.getOwner();
+                  continue;
+                }
+                for (a = o.getOwner(); i.lca == null; ) {
+                  for (i.targetInLca = g, y = g.getOwner(); i.lca == null; ) {
+                    if (y == a) {
+                      i.lca = y;
+                      break;
+                    }
+                    if (y == this.rootGraph)
+                      break;
+                    if (i.lca != null)
+                      throw "assert failed";
+                    i.targetInLca = y.getParent(), y = i.targetInLca.getOwner();
+                  }
+                  if (a == this.rootGraph)
+                    break;
+                  i.lca == null && (i.sourceInLca = a.getParent(), a = i.sourceInLca.getOwner());
+                }
+                if (i.lca == null)
+                  throw "assert failed";
+              }
+            }, e.prototype.calcLowestCommonAncestor = function(i, o) {
+              if (i == o)
+                return i.getOwner();
+              var g = i.getOwner();
+              do {
+                if (g == null)
+                  break;
+                var a = o.getOwner();
+                do {
+                  if (a == null)
+                    break;
+                  if (a == g)
+                    return a;
+                  a = a.getParent().getOwner();
+                } while (!0);
+                g = g.getParent().getOwner();
+              } while (!0);
+              return g;
+            }, e.prototype.calcInclusionTreeDepths = function(i, o) {
+              i == null && o == null && (i = this.rootGraph, o = 1);
+              for (var g, a = i.getNodes(), y = a.length, n = 0; n < y; n++)
+                g = a[n], g.inclusionTreeDepth = o, g.child != null && this.calcInclusionTreeDepths(g.child, o + 1);
+            }, e.prototype.includesInvalidEdge = function() {
+              for (var i, o = this.edges.length, g = 0; g < o; g++)
+                if (i = this.edges[g], this.isOneAncestorOfOther(i.source, i.target))
+                  return !0;
+              return !1;
+            }, f.exports = e;
+          },
+          /* 7 */
+          /***/
+          function(f, A, d) {
+            var r = d(0);
+            function t() {
+            }
+            N(t, "FDLayoutConstants");
+            for (var e in r)
+              t[e] = r[e];
+            t.MAX_ITERATIONS = 2500, t.DEFAULT_EDGE_LENGTH = 50, t.DEFAULT_SPRING_STRENGTH = 0.45, t.DEFAULT_REPULSION_STRENGTH = 4500, t.DEFAULT_GRAVITY_STRENGTH = 0.4, t.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1, t.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8, t.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5, t.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = !0, t.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = !0, t.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3, t.COOLING_ADAPTATION_FACTOR = 0.33, t.ADAPTATION_LOWER_NODE_LIMIT = 1e3, t.ADAPTATION_UPPER_NODE_LIMIT = 5e3, t.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100, t.MAX_NODE_DISPLACEMENT = t.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3, t.MIN_REPULSION_DIST = t.DEFAULT_EDGE_LENGTH / 10, t.CONVERGENCE_CHECK_PERIOD = 100, t.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1, t.MIN_EDGE_LENGTH = 1, t.GRID_CALCULATION_CHECK_PERIOD = 10, f.exports = t;
+          },
+          /* 8 */
+          /***/
+          function(f, A, d) {
+            var r = d(12);
+            function t() {
+            }
+            N(t, "IGeometry"), t.calcSeparationAmount = function(e, i, o, g) {
+              if (!e.intersects(i))
+                throw "assert failed";
+              var a = new Array(2);
+              this.decideDirectionsForOverlappingNodes(e, i, a), o[0] = Math.min(e.getRight(), i.getRight()) - Math.max(e.x, i.x), o[1] = Math.min(e.getBottom(), i.getBottom()) - Math.max(e.y, i.y), e.getX() <= i.getX() && e.getRight() >= i.getRight() ? o[0] += Math.min(i.getX() - e.getX(), e.getRight() - i.getRight()) : i.getX() <= e.getX() && i.getRight() >= e.getRight() && (o[0] += Math.min(e.getX() - i.getX(), i.getRight() - e.getRight())), e.getY() <= i.getY() && e.getBottom() >= i.getBottom() ? o[1] += Math.min(i.getY() - e.getY(), e.getBottom() - i.getBottom()) : i.getY() <= e.getY() && i.getBottom() >= e.getBottom() && (o[1] += Math.min(e.getY() - i.getY(), i.getBottom() - e.getBottom()));
+              var y = Math.abs((i.getCenterY() - e.getCenterY()) / (i.getCenterX() - e.getCenterX()));
+              i.getCenterY() === e.getCenterY() && i.getCenterX() === e.getCenterX() && (y = 1);
+              var n = y * o[0], h = o[1] / y;
+              o[0] < h ? h = o[0] : n = o[1], o[0] = -1 * a[0] * (h / 2 + g), o[1] = -1 * a[1] * (n / 2 + g);
+            }, t.decideDirectionsForOverlappingNodes = function(e, i, o) {
+              e.getCenterX() < i.getCenterX() ? o[0] = -1 : o[0] = 1, e.getCenterY() < i.getCenterY() ? o[1] = -1 : o[1] = 1;
+            }, t.getIntersection2 = function(e, i, o) {
+              var g = e.getCenterX(), a = e.getCenterY(), y = i.getCenterX(), n = i.getCenterY();
+              if (e.intersects(i))
+                return o[0] = g, o[1] = a, o[2] = y, o[3] = n, !0;
+              var h = e.getX(), l = e.getY(), E = e.getRight(), T = e.getX(), D = e.getBottom(), L = e.getRight(), I = e.getWidthHalf(), v = e.getHeightHalf(), m = i.getX(), s = i.getY(), c = i.getRight(), u = i.getX(), p = i.getBottom(), C = i.getRight(), R = i.getWidthHalf(), M = i.getHeightHalf(), w = !1, G = !1;
+              if (g === y) {
+                if (a > n)
+                  return o[0] = g, o[1] = l, o[2] = y, o[3] = p, !1;
+                if (a < n)
+                  return o[0] = g, o[1] = D, o[2] = y, o[3] = s, !1;
+              } else if (a === n) {
+                if (g > y)
+                  return o[0] = h, o[1] = a, o[2] = c, o[3] = n, !1;
+                if (g < y)
+                  return o[0] = E, o[1] = a, o[2] = m, o[3] = n, !1;
+              } else {
+                var U = e.height / e.width, X = i.height / i.width, _ = (n - a) / (y - g), S = void 0, F = void 0, b = void 0, Y = void 0, k = void 0, H = void 0;
+                if (-U === _ ? g > y ? (o[0] = T, o[1] = D, w = !0) : (o[0] = E, o[1] = l, w = !0) : U === _ && (g > y ? (o[0] = h, o[1] = l, w = !0) : (o[0] = L, o[1] = D, w = !0)), -X === _ ? y > g ? (o[2] = u, o[3] = p, G = !0) : (o[2] = c, o[3] = s, G = !0) : X === _ && (y > g ? (o[2] = m, o[3] = s, G = !0) : (o[2] = C, o[3] = p, G = !0)), w && G)
+                  return !1;
+                if (g > y ? a > n ? (S = this.getCardinalDirection(U, _, 4), F = this.getCardinalDirection(X, _, 2)) : (S = this.getCardinalDirection(-U, _, 3), F = this.getCardinalDirection(-X, _, 1)) : a > n ? (S = this.getCardinalDirection(-U, _, 1), F = this.getCardinalDirection(-X, _, 3)) : (S = this.getCardinalDirection(U, _, 2), F = this.getCardinalDirection(X, _, 4)), !w)
+                  switch (S) {
+                    case 1:
+                      Y = l, b = g + -v / _, o[0] = b, o[1] = Y;
+                      break;
+                    case 2:
+                      b = L, Y = a + I * _, o[0] = b, o[1] = Y;
+                      break;
+                    case 3:
+                      Y = D, b = g + v / _, o[0] = b, o[1] = Y;
+                      break;
+                    case 4:
+                      b = T, Y = a + -I * _, o[0] = b, o[1] = Y;
+                      break;
+                  }
+                if (!G)
+                  switch (F) {
+                    case 1:
+                      H = s, k = y + -M / _, o[2] = k, o[3] = H;
+                      break;
+                    case 2:
+                      k = C, H = n + R * _, o[2] = k, o[3] = H;
+                      break;
+                    case 3:
+                      H = p, k = y + M / _, o[2] = k, o[3] = H;
+                      break;
+                    case 4:
+                      k = u, H = n + -R * _, o[2] = k, o[3] = H;
+                      break;
+                  }
+              }
+              return !1;
+            }, t.getCardinalDirection = function(e, i, o) {
+              return e > i ? o : 1 + o % 4;
+            }, t.getIntersection = function(e, i, o, g) {
+              if (g == null)
+                return this.getIntersection2(e, i, o);
+              var a = e.x, y = e.y, n = i.x, h = i.y, l = o.x, E = o.y, T = g.x, D = g.y, L = void 0, I = void 0, v = void 0, m = void 0, s = void 0, c = void 0, u = void 0, p = void 0, C = void 0;
+              return v = h - y, s = a - n, u = n * y - a * h, m = D - E, c = l - T, p = T * E - l * D, C = v * c - m * s, C === 0 ? null : (L = (s * p - c * u) / C, I = (m * u - v * p) / C, new r(L, I));
+            }, t.angleOfVector = function(e, i, o, g) {
+              var a = void 0;
+              return e !== o ? (a = Math.atan((g - i) / (o - e)), o < e ? a += Math.PI : g < i && (a += this.TWO_PI)) : g < i ? a = this.ONE_AND_HALF_PI : a = this.HALF_PI, a;
+            }, t.doIntersect = function(e, i, o, g) {
+              var a = e.x, y = e.y, n = i.x, h = i.y, l = o.x, E = o.y, T = g.x, D = g.y, L = (n - a) * (D - E) - (T - l) * (h - y);
+              if (L === 0)
+                return !1;
+              var I = ((D - E) * (T - a) + (l - T) * (D - y)) / L, v = ((y - h) * (T - a) + (n - a) * (D - y)) / L;
+              return 0 < I && I < 1 && 0 < v && v < 1;
+            }, t.HALF_PI = 0.5 * Math.PI, t.ONE_AND_HALF_PI = 1.5 * Math.PI, t.TWO_PI = 2 * Math.PI, t.THREE_PI = 3 * Math.PI, f.exports = t;
+          },
+          /* 9 */
+          /***/
+          function(f, A, d) {
+            function r() {
+            }
+            N(r, "IMath"), r.sign = function(t) {
+              return t > 0 ? 1 : t < 0 ? -1 : 0;
+            }, r.floor = function(t) {
+              return t < 0 ? Math.ceil(t) : Math.floor(t);
+            }, r.ceil = function(t) {
+              return t < 0 ? Math.floor(t) : Math.ceil(t);
+            }, f.exports = r;
+          },
+          /* 10 */
+          /***/
+          function(f, A, d) {
+            function r() {
+            }
+            N(r, "Integer"), r.MAX_VALUE = 2147483647, r.MIN_VALUE = -2147483648, f.exports = r;
+          },
+          /* 11 */
+          /***/
+          function(f, A, d) {
+            var r = /* @__PURE__ */ function() {
+              function a(y, n) {
+                for (var h = 0; h < n.length; h++) {
+                  var l = n[h];
+                  l.enumerable = l.enumerable || !1, l.configurable = !0, "value" in l && (l.writable = !0), Object.defineProperty(y, l.key, l);
+                }
+              }
+              return N(a, "defineProperties"), function(y, n, h) {
+                return n && a(y.prototype, n), h && a(y, h), y;
+              };
+            }();
+            function t(a, y) {
+              if (!(a instanceof y))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            N(t, "_classCallCheck");
+            var e = /* @__PURE__ */ N(function(y) {
+              return { value: y, next: null, prev: null };
+            }, "nodeFrom"), i = /* @__PURE__ */ N(function(y, n, h, l) {
+              return y !== null ? y.next = n : l.head = n, h !== null ? h.prev = n : l.tail = n, n.prev = y, n.next = h, l.length++, n;
+            }, "add"), o = /* @__PURE__ */ N(function(y, n) {
+              var h = y.prev, l = y.next;
+              return h !== null ? h.next = l : n.head = l, l !== null ? l.prev = h : n.tail = h, y.prev = y.next = null, n.length--, y;
+            }, "_remove"), g = function() {
+              function a(y) {
+                var n = this;
+                t(this, a), this.length = 0, this.head = null, this.tail = null, y?.forEach(function(h) {
+                  return n.push(h);
+                });
+              }
+              return N(a, "LinkedList"), r(a, [{
+                key: "size",
+                value: /* @__PURE__ */ N(function() {
+                  return this.length;
+                }, "size")
+              }, {
+                key: "insertBefore",
+                value: /* @__PURE__ */ N(function(n, h) {
+                  return i(h.prev, e(n), h, this);
+                }, "insertBefore")
+              }, {
+                key: "insertAfter",
+                value: /* @__PURE__ */ N(function(n, h) {
+                  return i(h, e(n), h.next, this);
+                }, "insertAfter")
+              }, {
+                key: "insertNodeBefore",
+                value: /* @__PURE__ */ N(function(n, h) {
+                  return i(h.prev, n, h, this);
+                }, "insertNodeBefore")
+              }, {
+                key: "insertNodeAfter",
+                value: /* @__PURE__ */ N(function(n, h) {
+                  return i(h, n, h.next, this);
+                }, "insertNodeAfter")
+              }, {
+                key: "push",
+                value: /* @__PURE__ */ N(function(n) {
+                  return i(this.tail, e(n), null, this);
+                }, "push")
+              }, {
+                key: "unshift",
+                value: /* @__PURE__ */ N(function(n) {
+                  return i(null, e(n), this.head, this);
+                }, "unshift")
+              }, {
+                key: "remove",
+                value: /* @__PURE__ */ N(function(n) {
+                  return o(n, this);
+                }, "remove")
+              }, {
+                key: "pop",
+                value: /* @__PURE__ */ N(function() {
+                  return o(this.tail, this).value;
+                }, "pop")
+              }, {
+                key: "popNode",
+                value: /* @__PURE__ */ N(function() {
+                  return o(this.tail, this);
+                }, "popNode")
+              }, {
+                key: "shift",
+                value: /* @__PURE__ */ N(function() {
+                  return o(this.head, this).value;
+                }, "shift")
+              }, {
+                key: "shiftNode",
+                value: /* @__PURE__ */ N(function() {
+                  return o(this.head, this);
+                }, "shiftNode")
+              }, {
+                key: "get_object_at",
+                value: /* @__PURE__ */ N(function(n) {
+                  if (n <= this.length()) {
+                    for (var h = 1, l = this.head; h < n; )
+                      l = l.next, h++;
+                    return l.value;
+                  }
+                }, "get_object_at")
+              }, {
+                key: "set_object_at",
+                value: /* @__PURE__ */ N(function(n, h) {
+                  if (n <= this.length()) {
+                    for (var l = 1, E = this.head; l < n; )
+                      E = E.next, l++;
+                    E.value = h;
+                  }
+                }, "set_object_at")
+              }]), a;
+            }();
+            f.exports = g;
+          },
+          /* 12 */
+          /***/
+          function(f, A, d) {
+            function r(t, e, i) {
+              this.x = null, this.y = null, t == null && e == null && i == null ? (this.x = 0, this.y = 0) : typeof t == "number" && typeof e == "number" && i == null ? (this.x = t, this.y = e) : t.constructor.name == "Point" && e == null && i == null && (i = t, this.x = i.x, this.y = i.y);
+            }
+            N(r, "Point"), r.prototype.getX = function() {
+              return this.x;
+            }, r.prototype.getY = function() {
+              return this.y;
+            }, r.prototype.getLocation = function() {
+              return new r(this.x, this.y);
+            }, r.prototype.setLocation = function(t, e, i) {
+              t.constructor.name == "Point" && e == null && i == null ? (i = t, this.setLocation(i.x, i.y)) : typeof t == "number" && typeof e == "number" && i == null && (parseInt(t) == t && parseInt(e) == e ? this.move(t, e) : (this.x = Math.floor(t + 0.5), this.y = Math.floor(e + 0.5)));
+            }, r.prototype.move = function(t, e) {
+              this.x = t, this.y = e;
+            }, r.prototype.translate = function(t, e) {
+              this.x += t, this.y += e;
+            }, r.prototype.equals = function(t) {
+              if (t.constructor.name == "Point") {
+                var e = t;
+                return this.x == e.x && this.y == e.y;
+              }
+              return this == t;
+            }, r.prototype.toString = function() {
+              return new r().constructor.name + "[x=" + this.x + ",y=" + this.y + "]";
+            }, f.exports = r;
+          },
+          /* 13 */
+          /***/
+          function(f, A, d) {
+            function r(t, e, i, o) {
+              this.x = 0, this.y = 0, this.width = 0, this.height = 0, t != null && e != null && i != null && o != null && (this.x = t, this.y = e, this.width = i, this.height = o);
+            }
+            N(r, "RectangleD"), r.prototype.getX = function() {
+              return this.x;
+            }, r.prototype.setX = function(t) {
+              this.x = t;
+            }, r.prototype.getY = function() {
+              return this.y;
+            }, r.prototype.setY = function(t) {
+              this.y = t;
+            }, r.prototype.getWidth = function() {
+              return this.width;
+            }, r.prototype.setWidth = function(t) {
+              this.width = t;
+            }, r.prototype.getHeight = function() {
+              return this.height;
+            }, r.prototype.setHeight = function(t) {
+              this.height = t;
+            }, r.prototype.getRight = function() {
+              return this.x + this.width;
+            }, r.prototype.getBottom = function() {
+              return this.y + this.height;
+            }, r.prototype.intersects = function(t) {
+              return !(this.getRight() < t.x || this.getBottom() < t.y || t.getRight() < this.x || t.getBottom() < this.y);
+            }, r.prototype.getCenterX = function() {
+              return this.x + this.width / 2;
+            }, r.prototype.getMinX = function() {
+              return this.getX();
+            }, r.prototype.getMaxX = function() {
+              return this.getX() + this.width;
+            }, r.prototype.getCenterY = function() {
+              return this.y + this.height / 2;
+            }, r.prototype.getMinY = function() {
+              return this.getY();
+            }, r.prototype.getMaxY = function() {
+              return this.getY() + this.height;
+            }, r.prototype.getWidthHalf = function() {
+              return this.width / 2;
+            }, r.prototype.getHeightHalf = function() {
+              return this.height / 2;
+            }, f.exports = r;
+          },
+          /* 14 */
+          /***/
+          function(f, A, d) {
+            var r = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+              return typeof e;
+            } : function(e) {
+              return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+            };
+            function t() {
+            }
+            N(t, "UniqueIDGeneretor"), t.lastID = 0, t.createID = function(e) {
+              return t.isPrimitive(e) ? e : (e.uniqueID != null || (e.uniqueID = t.getString(), t.lastID++), e.uniqueID);
+            }, t.getString = function(e) {
+              return e == null && (e = t.lastID), "Object#" + e;
+            }, t.isPrimitive = function(e) {
+              var i = typeof e > "u" ? "undefined" : r(e);
+              return e == null || i != "object" && i != "function";
+            }, f.exports = t;
+          },
+          /* 15 */
+          /***/
+          function(f, A, d) {
+            function r(l) {
+              if (Array.isArray(l)) {
+                for (var E = 0, T = Array(l.length); E < l.length; E++)
+                  T[E] = l[E];
+                return T;
+              } else
+                return Array.from(l);
+            }
+            N(r, "_toConsumableArray");
+            var t = d(0), e = d(6), i = d(3), o = d(1), g = d(5), a = d(4), y = d(17), n = d(27);
+            function h(l) {
+              n.call(this), this.layoutQuality = t.QUALITY, this.createBendsAsNeeded = t.DEFAULT_CREATE_BENDS_AS_NEEDED, this.incremental = t.DEFAULT_INCREMENTAL, this.animationOnLayout = t.DEFAULT_ANIMATION_ON_LAYOUT, this.animationDuringLayout = t.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = t.DEFAULT_ANIMATION_PERIOD, this.uniformLeafNodeSizes = t.DEFAULT_UNIFORM_LEAF_NODE_SIZES, this.edgeToDummyNodes = /* @__PURE__ */ new Map(), this.graphManager = new e(this), this.isLayoutFinished = !1, this.isSubLayout = !1, this.isRemoteUse = !1, l != null && (this.isRemoteUse = l);
+            }
+            N(h, "Layout"), h.RANDOM_SEED = 1, h.prototype = Object.create(n.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 l = new e(this);
+              return this.graphManager = l, l;
+            }, h.prototype.newGraph = function(l) {
+              return new g(null, this.graphManager, l);
+            }, h.prototype.newNode = function(l) {
+              return new i(this.graphManager, l);
+            }, h.prototype.newEdge = function(l) {
+              return new o(null, null, l);
+            }, 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 l;
+              return this.checkLayoutSuccess() ? l = !1 : l = this.layout(), t.ANIMATE === "during" ? !1 : (l && (this.isSubLayout || this.doPostLayout()), this.tilingPostLayout && this.tilingPostLayout(), this.isLayoutFinished = !0, l);
+            }, 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 l = this.graphManager.getAllEdges(), E = 0; E < l.length; E++)
+                  l[E];
+                for (var T = this.graphManager.getRoot().getNodes(), E = 0; E < T.length; E++)
+                  T[E];
+                this.update(this.graphManager.getRoot());
+              }
+            }, h.prototype.update = function(l) {
+              if (l == null)
+                this.update2();
+              else if (l instanceof i) {
+                var E = l;
+                if (E.getChild() != null)
+                  for (var T = E.getChild().getNodes(), D = 0; D < T.length; D++)
+                    update(T[D]);
+                if (E.vGraphObject != null) {
+                  var L = E.vGraphObject;
+                  L.update(E);
+                }
+              } else if (l instanceof o) {
+                var I = l;
+                if (I.vGraphObject != null) {
+                  var v = I.vGraphObject;
+                  v.update(I);
+                }
+              } else if (l instanceof g) {
+                var m = l;
+                if (m.vGraphObject != null) {
+                  var s = m.vGraphObject;
+                  s.update(m);
+                }
+              }
+            }, h.prototype.initParameters = function() {
+              this.isSubLayout || (this.layoutQuality = t.QUALITY, this.animationDuringLayout = t.DEFAULT_ANIMATION_DURING_LAYOUT, this.animationPeriod = t.DEFAULT_ANIMATION_PERIOD, this.animationOnLayout = t.DEFAULT_ANIMATION_ON_LAYOUT, this.incremental = t.DEFAULT_INCREMENTAL, this.createBendsAsNeeded = t.DEFAULT_CREATE_BENDS_AS_NEEDED, this.uniformLeafNodeSizes = t.DEFAULT_UNIFORM_LEAF_NODE_SIZES), this.animationDuringLayout && (this.animationOnLayout = !1);
+            }, h.prototype.transform = function(l) {
+              if (l == null)
+                this.transform(new a(0, 0));
+              else {
+                var E = new y(), T = this.graphManager.getRoot().updateLeftTop();
+                if (T != null) {
+                  E.setWorldOrgX(l.x), E.setWorldOrgY(l.y), E.setDeviceOrgX(T.x), E.setDeviceOrgY(T.y);
+                  for (var D = this.getAllNodes(), L, I = 0; I < D.length; I++)
+                    L = D[I], L.transform(E);
+                }
+              }
+            }, h.prototype.positionNodesRandomly = function(l) {
+              if (l == null)
+                this.positionNodesRandomly(this.getGraphManager().getRoot()), this.getGraphManager().getRoot().updateBounds(!0);
+              else
+                for (var E, T, D = l.getNodes(), L = 0; L < D.length; L++)
+                  E = D[L], T = E.getChild(), T == null || T.getNodes().length == 0 ? E.scatter() : (this.positionNodesRandomly(T), E.updateBounds());
+            }, h.prototype.getFlatForest = function() {
+              for (var l = [], E = !0, T = this.graphManager.getRoot().getNodes(), D = !0, L = 0; L < T.length; L++)
+                T[L].getChild() != null && (D = !1);
+              if (!D)
+                return l;
+              var I = /* @__PURE__ */ new Set(), v = [], m = /* @__PURE__ */ new Map(), s = [];
+              for (s = s.concat(T); s.length > 0 && E; ) {
+                for (v.push(s[0]); v.length > 0 && E; ) {
+                  var c = v[0];
+                  v.splice(0, 1), I.add(c);
+                  for (var u = c.getEdges(), L = 0; L < u.length; L++) {
+                    var p = u[L].getOtherEnd(c);
+                    if (m.get(c) != p)
+                      if (!I.has(p))
+                        v.push(p), m.set(p, c);
+                      else {
+                        E = !1;
+                        break;
+                      }
+                  }
+                }
+                if (!E)
+                  l = [];
+                else {
+                  var C = [].concat(r(I));
+                  l.push(C);
+                  for (var L = 0; L < C.length; L++) {
+                    var R = C[L], M = s.indexOf(R);
+                    M > -1 && s.splice(M, 1);
+                  }
+                  I = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Map();
+                }
+              }
+              return l;
+            }, h.prototype.createDummyNodesForBendpoints = function(l) {
+              for (var E = [], T = l.source, D = this.graphManager.calcLowestCommonAncestor(l.source, l.target), L = 0; L < l.bendpoints.length; L++) {
+                var I = this.newNode(null);
+                I.setRect(new Point(0, 0), new Dimension(1, 1)), D.add(I);
+                var v = this.newEdge(null);
+                this.graphManager.add(v, T, I), E.add(I), T = I;
+              }
+              var v = this.newEdge(null);
+              return this.graphManager.add(v, T, l.target), this.edgeToDummyNodes.set(l, E), l.isInterGraph() ? this.graphManager.remove(l) : D.remove(l), E;
+            }, h.prototype.createBendpointsFromDummyNodes = function() {
+              var l = [];
+              l = l.concat(this.graphManager.getAllEdges()), l = [].concat(r(this.edgeToDummyNodes.keys())).concat(l);
+              for (var E = 0; E < l.length; E++) {
+                var T = l[E];
+                if (T.bendpoints.length > 0) {
+                  for (var D = this.edgeToDummyNodes.get(T), L = 0; L < D.length; L++) {
+                    var I = D[L], v = new a(I.getCenterX(), I.getCenterY()), m = T.bendpoints.get(L);
+                    m.x = v.x, m.y = v.y, I.getOwner().remove(I);
+                  }
+                  this.graphManager.add(T, T.source, T.target);
+                }
+              }
+            }, h.transform = function(l, E, T, D) {
+              if (T != null && D != null) {
+                var L = E;
+                if (l <= 50) {
+                  var I = E / T;
+                  L -= (E - I) / 50 * (50 - l);
+                } else {
+                  var v = E * D;
+                  L += (v - E) / 50 * (l - 50);
+                }
+                return L;
+              } else {
+                var m, s;
+                return l <= 50 ? (m = 9 * E / 500, s = E / 10) : (m = 9 * E / 50, s = -8 * E), m * l + s;
+              }
+            }, h.findCenterOfTree = function(l) {
+              var E = [];
+              E = E.concat(l);
+              var T = [], D = /* @__PURE__ */ new Map(), L = !1, I = null;
+              (E.length == 1 || E.length == 2) && (L = !0, I = E[0]);
+              for (var v = 0; v < E.length; v++) {
+                var m = E[v], s = m.getNeighborsList().size;
+                D.set(m, m.getNeighborsList().size), s == 1 && T.push(m);
+              }
+              var c = [];
+              for (c = c.concat(T); !L; ) {
+                var u = [];
+                u = u.concat(c), c = [];
+                for (var v = 0; v < E.length; v++) {
+                  var m = E[v], p = E.indexOf(m);
+                  p >= 0 && E.splice(p, 1);
+                  var C = m.getNeighborsList();
+                  C.forEach(function(w) {
+                    if (T.indexOf(w) < 0) {
+                      var G = D.get(w), U = G - 1;
+                      U == 1 && c.push(w), D.set(w, U);
+                    }
+                  });
+                }
+                T = T.concat(c), (E.length == 1 || E.length == 2) && (L = !0, I = E[0]);
+              }
+              return I;
+            }, h.prototype.setGraphManager = function(l) {
+              this.graphManager = l;
+            }, f.exports = h;
+          },
+          /* 16 */
+          /***/
+          function(f, A, d) {
+            function r() {
+            }
+            N(r, "RandomSeed"), r.seed = 1, r.x = 0, r.nextDouble = function() {
+              return r.x = Math.sin(r.seed++) * 1e4, r.x - Math.floor(r.x);
+            }, f.exports = r;
+          },
+          /* 17 */
+          /***/
+          function(f, A, d) {
+            var r = d(4);
+            function t(e, 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;
+            }
+            N(t, "Transform"), t.prototype.getWorldOrgX = function() {
+              return this.lworldOrgX;
+            }, t.prototype.setWorldOrgX = function(e) {
+              this.lworldOrgX = e;
+            }, t.prototype.getWorldOrgY = function() {
+              return this.lworldOrgY;
+            }, t.prototype.setWorldOrgY = function(e) {
+              this.lworldOrgY = e;
+            }, t.prototype.getWorldExtX = function() {
+              return this.lworldExtX;
+            }, t.prototype.setWorldExtX = function(e) {
+              this.lworldExtX = e;
+            }, t.prototype.getWorldExtY = function() {
+              return this.lworldExtY;
+            }, t.prototype.setWorldExtY = function(e) {
+              this.lworldExtY = e;
+            }, t.prototype.getDeviceOrgX = function() {
+              return this.ldeviceOrgX;
+            }, t.prototype.setDeviceOrgX = function(e) {
+              this.ldeviceOrgX = e;
+            }, t.prototype.getDeviceOrgY = function() {
+              return this.ldeviceOrgY;
+            }, t.prototype.setDeviceOrgY = function(e) {
+              this.ldeviceOrgY = e;
+            }, t.prototype.getDeviceExtX = function() {
+              return this.ldeviceExtX;
+            }, t.prototype.setDeviceExtX = function(e) {
+              this.ldeviceExtX = e;
+            }, t.prototype.getDeviceExtY = function() {
+              return this.ldeviceExtY;
+            }, t.prototype.setDeviceExtY = function(e) {
+              this.ldeviceExtY = e;
+            }, t.prototype.transformX = function(e) {
+              var i = 0, o = this.lworldExtX;
+              return o != 0 && (i = this.ldeviceOrgX + (e - this.lworldOrgX) * this.ldeviceExtX / o), i;
+            }, t.prototype.transformY = function(e) {
+              var i = 0, o = this.lworldExtY;
+              return o != 0 && (i = this.ldeviceOrgY + (e - this.lworldOrgY) * this.ldeviceExtY / o), i;
+            }, t.prototype.inverseTransformX = function(e) {
+              var i = 0, o = this.ldeviceExtX;
+              return o != 0 && (i = this.lworldOrgX + (e - this.ldeviceOrgX) * this.lworldExtX / o), i;
+            }, t.prototype.inverseTransformY = function(e) {
+              var i = 0, o = this.ldeviceExtY;
+              return o != 0 && (i = this.lworldOrgY + (e - this.ldeviceOrgY) * this.lworldExtY / o), i;
+            }, t.prototype.inverseTransformPoint = function(e) {
+              var i = new r(this.inverseTransformX(e.x), this.inverseTransformY(e.y));
+              return i;
+            }, f.exports = t;
+          },
+          /* 18 */
+          /***/
+          function(f, A, d) {
+            function r(n) {
+              if (Array.isArray(n)) {
+                for (var h = 0, l = Array(n.length); h < n.length; h++)
+                  l[h] = n[h];
+                return l;
+              } else
+                return Array.from(n);
+            }
+            N(r, "_toConsumableArray");
+            var t = d(15), e = d(7), i = d(0), o = d(8), g = d(9);
+            function a() {
+              t.call(this), this.useSmartIdealEdgeLengthCalculation = e.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.idealEdgeLength = e.DEFAULT_EDGE_LENGTH, this.springConstant = e.DEFAULT_SPRING_STRENGTH, this.repulsionConstant = e.DEFAULT_REPULSION_STRENGTH, this.gravityConstant = e.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = e.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = e.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = e.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.displacementThresholdPerNode = 3 * e.DEFAULT_EDGE_LENGTH / 100, this.coolingFactor = e.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.initialCoolingFactor = e.DEFAULT_COOLING_FACTOR_INCREMENTAL, this.totalDisplacement = 0, this.oldTotalDisplacement = 0, this.maxIterations = e.MAX_ITERATIONS;
+            }
+            N(a, "FDLayout"), a.prototype = Object.create(t.prototype);
+            for (var y in t)
+              a[y] = t[y];
+            a.prototype.initParameters = function() {
+              t.prototype.initParameters.call(this, arguments), this.totalIterations = 0, this.notAnimatedIterations = 0, this.useFRGridVariant = e.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION, this.grid = [];
+            }, a.prototype.calcIdealEdgeLengths = function() {
+              for (var n, h, l, E, T, D, L = this.getGraphManager().getAllEdges(), I = 0; I < L.length; I++)
+                n = L[I], n.idealLength = this.idealEdgeLength, n.isInterGraph && (l = n.getSource(), E = n.getTarget(), T = n.getSourceInLca().getEstimatedSize(), D = n.getTargetInLca().getEstimatedSize(), this.useSmartIdealEdgeLengthCalculation && (n.idealLength += T + D - 2 * i.SIMPLE_NODE_SIZE), h = n.getLca().getInclusionTreeDepth(), n.idealLength += e.DEFAULT_EDGE_LENGTH * e.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (l.getInclusionTreeDepth() + E.getInclusionTreeDepth() - 2 * h));
+            }, a.prototype.initSpringEmbedder = function() {
+              var n = this.getAllNodes().length;
+              this.incremental ? (n > e.ADAPTATION_LOWER_NODE_LIMIT && (this.coolingFactor = Math.max(this.coolingFactor * e.COOLING_ADAPTATION_FACTOR, this.coolingFactor - (n - e.ADAPTATION_LOWER_NODE_LIMIT) / (e.ADAPTATION_UPPER_NODE_LIMIT - e.ADAPTATION_LOWER_NODE_LIMIT) * this.coolingFactor * (1 - e.COOLING_ADAPTATION_FACTOR))), this.maxNodeDisplacement = e.MAX_NODE_DISPLACEMENT_INCREMENTAL) : (n > e.ADAPTATION_LOWER_NODE_LIMIT ? this.coolingFactor = Math.max(e.COOLING_ADAPTATION_FACTOR, 1 - (n - e.ADAPTATION_LOWER_NODE_LIMIT) / (e.ADAPTATION_UPPER_NODE_LIMIT - e.ADAPTATION_LOWER_NODE_LIMIT) * (1 - e.COOLING_ADAPTATION_FACTOR)) : this.coolingFactor = 1, this.initialCoolingFactor = this.coolingFactor, this.maxNodeDisplacement = e.MAX_NODE_DISPLACEMENT), this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations), this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length, this.repulsionRange = this.calcRepulsionRange();
+            }, a.prototype.calcSpringForces = function() {
+              for (var n = this.getAllEdges(), h, l = 0; l < n.length; l++)
+                h = n[l], this.calcSpringForce(h, h.idealLength);
+            }, a.prototype.calcRepulsionForces = function() {
+              var n = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0, h = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1, l, E, T, D, L = this.getAllNodes(), I;
+              if (this.useFRGridVariant)
+                for (this.totalIterations % e.GRID_CALCULATION_CHECK_PERIOD == 1 && n && this.updateGrid(), I = /* @__PURE__ */ new Set(), l = 0; l < L.length; l++)
+                  T = L[l], this.calculateRepulsionForceOfANode(T, I, n, h), I.add(T);
+              else
+                for (l = 0; l < L.length; l++)
+                  for (T = L[l], E = l + 1; E < L.length; E++)
+                    D = L[E], T.getOwner() == D.getOwner() && this.calcRepulsionForce(T, D);
+            }, a.prototype.calcGravitationalForces = function() {
+              for (var n, h = this.getAllNodesToApplyGravitation(), l = 0; l < h.length; l++)
+                n = h[l], this.calcGravitationalForce(n);
+            }, a.prototype.moveNodes = function() {
+              for (var n = this.getAllNodes(), h, l = 0; l < n.length; l++)
+                h = n[l], h.move();
+            }, a.prototype.calcSpringForce = function(n, h) {
+              var l = n.getSource(), E = n.getTarget(), T, D, L, I;
+              if (this.uniformLeafNodeSizes && l.getChild() == null && E.getChild() == null)
+                n.updateLengthSimple();
+              else if (n.updateLength(), n.isOverlapingSourceAndTarget)
+                return;
+              T = n.getLength(), T != 0 && (D = this.springConstant * (T - h), L = D * (n.lengthX / T), I = D * (n.lengthY / T), l.springForceX += L, l.springForceY += I, E.springForceX -= L, E.springForceY -= I);
+            }, a.prototype.calcRepulsionForce = function(n, h) {
+              var l = n.getRect(), E = h.getRect(), T = new Array(2), D = new Array(4), L, I, v, m, s, c, u;
+              if (l.intersects(E)) {
+                o.calcSeparationAmount(l, E, T, e.DEFAULT_EDGE_LENGTH / 2), c = 2 * T[0], u = 2 * T[1];
+                var p = n.noOfChildren * h.noOfChildren / (n.noOfChildren + h.noOfChildren);
+                n.repulsionForceX -= p * c, n.repulsionForceY -= p * u, h.repulsionForceX += p * c, h.repulsionForceY += p * u;
+              } else
+                this.uniformLeafNodeSizes && n.getChild() == null && h.getChild() == null ? (L = E.getCenterX() - l.getCenterX(), I = E.getCenterY() - l.getCenterY()) : (o.getIntersection(l, E, D), L = D[2] - D[0], I = D[3] - D[1]), Math.abs(L) < e.MIN_REPULSION_DIST && (L = g.sign(L) * e.MIN_REPULSION_DIST), Math.abs(I) < e.MIN_REPULSION_DIST && (I = g.sign(I) * e.MIN_REPULSION_DIST), v = L * L + I * I, m = Math.sqrt(v), s = this.repulsionConstant * n.noOfChildren * h.noOfChildren / v, c = s * L / m, u = s * I / m, n.repulsionForceX -= c, n.repulsionForceY -= u, h.repulsionForceX += c, h.repulsionForceY += u;
+            }, a.prototype.calcGravitationalForce = function(n) {
+              var h, l, E, T, D, L, I, v;
+              h = n.getOwner(), l = (h.getRight() + h.getLeft()) / 2, E = (h.getTop() + h.getBottom()) / 2, T = n.getCenterX() - l, D = n.getCenterY() - E, L = Math.abs(T) + n.getWidth() / 2, I = Math.abs(D) + n.getHeight() / 2, n.getOwner() == this.graphManager.getRoot() ? (v = h.getEstimatedSize() * this.gravityRangeFactor, (L > v || I > v) && (n.gravitationForceX = -this.gravityConstant * T, n.gravitationForceY = -this.gravityConstant * D)) : (v = h.getEstimatedSize() * this.compoundGravityRangeFactor, (L > v || I > v) && (n.gravitationForceX = -this.gravityConstant * T * this.compoundGravityConstant, n.gravitationForceY = -this.gravityConstant * D * this.compoundGravityConstant));
+            }, a.prototype.isConverged = function() {
+              var n, h = !1;
+              return this.totalIterations > this.maxIterations / 3 && (h = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2), n = this.totalDisplacement < this.totalDisplacementThreshold, this.oldTotalDisplacement = this.totalDisplacement, n || h;
+            }, a.prototype.animate = function() {
+              this.animationDuringLayout && !this.isSubLayout && (this.notAnimatedIterations == this.animationPeriod ? (this.update(), this.notAnimatedIterations = 0) : this.notAnimatedIterations++);
+            }, a.prototype.calcNoOfChildrenForAllNodes = function() {
+              for (var n, h = this.graphManager.getAllNodes(), l = 0; l < h.length; l++)
+                n = h[l], n.noOfChildren = n.getNoOfChildren();
+            }, a.prototype.calcGrid = function(n) {
+              var h = 0, l = 0;
+              h = parseInt(Math.ceil((n.getRight() - n.getLeft()) / this.repulsionRange)), l = parseInt(Math.ceil((n.getBottom() - n.getTop()) / this.repulsionRange));
+              for (var E = new Array(h), T = 0; T < h; T++)
+                E[T] = new Array(l);
+              for (var T = 0; T < h; T++)
+                for (var D = 0; D < l; D++)
+                  E[T][D] = new Array();
+              return E;
+            }, a.prototype.addNodeToGrid = function(n, h, l) {
+              var E = 0, T = 0, D = 0, L = 0;
+              E = parseInt(Math.floor((n.getRect().x - h) / this.repulsionRange)), T = parseInt(Math.floor((n.getRect().width + n.getRect().x - h) / this.repulsionRange)), D = parseInt(Math.floor((n.getRect().y - l) / this.repulsionRange)), L = parseInt(Math.floor((n.getRect().height + n.getRect().y - l) / this.repulsionRange));
+              for (var I = E; I <= T; I++)
+                for (var v = D; v <= L; v++)
+                  this.grid[I][v].push(n), n.setGridCoordinates(E, T, D, L);
+            }, a.prototype.updateGrid = function() {
+              var n, h, l = this.getAllNodes();
+              for (this.grid = this.calcGrid(this.graphManager.getRoot()), n = 0; n < l.length; n++)
+                h = l[n], this.addNodeToGrid(h, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop());
+            }, a.prototype.calculateRepulsionForceOfANode = function(n, h, l, E) {
+              if (this.totalIterations % e.GRID_CALCULATION_CHECK_PERIOD == 1 && l || E) {
+                var T = /* @__PURE__ */ new Set();
+                n.surrounding = new Array();
+                for (var D, L = this.grid, I = n.startX - 1; I < n.finishX + 2; I++)
+                  for (var v = n.startY - 1; v < n.finishY + 2; v++)
+                    if (!(I < 0 || v < 0 || I >= L.length || v >= L[0].length)) {
+                      for (var m = 0; m < L[I][v].length; m++)
+                        if (D = L[I][v][m], !(n.getOwner() != D.getOwner() || n == D) && !h.has(D) && !T.has(D)) {
+                          var s = Math.abs(n.getCenterX() - D.getCenterX()) - (n.getWidth() / 2 + D.getWidth() / 2), c = Math.abs(n.getCenterY() - D.getCenterY()) - (n.getHeight() / 2 + D.getHeight() / 2);
+                          s <= this.repulsionRange && c <= this.repulsionRange && T.add(D);
+                        }
+                    }
+                n.surrounding = [].concat(r(T));
+              }
+              for (I = 0; I < n.surrounding.length; I++)
+                this.calcRepulsionForce(n, n.surrounding[I]);
+            }, a.prototype.calcRepulsionRange = function() {
+              return 0;
+            }, f.exports = a;
+          },
+          /* 19 */
+          /***/
+          function(f, A, d) {
+            var r = d(1), t = d(7);
+            function e(o, g, a) {
+              r.call(this, o, g, a), this.idealLength = t.DEFAULT_EDGE_LENGTH;
+            }
+            N(e, "FDLayoutEdge"), e.prototype = Object.create(r.prototype);
+            for (var i in r)
+              e[i] = r[i];
+            f.exports = e;
+          },
+          /* 20 */
+          /***/
+          function(f, A, d) {
+            var r = d(3);
+            function t(i, o, g, a) {
+              r.call(this, i, o, g, a), 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 = [];
+            }
+            N(t, "FDLayoutNode"), t.prototype = Object.create(r.prototype);
+            for (var e in r)
+              t[e] = r[e];
+            t.prototype.setGridCoordinates = function(i, o, g, a) {
+              this.startX = i, this.finishX = o, this.startY = g, this.finishY = a;
+            }, f.exports = t;
+          },
+          /* 21 */
+          /***/
+          function(f, A, d) {
+            function r(t, e) {
+              this.width = 0, this.height = 0, t !== null && e !== null && (this.height = e, this.width = t);
+            }
+            N(r, "DimensionD"), r.prototype.getWidth = function() {
+              return this.width;
+            }, r.prototype.setWidth = function(t) {
+              this.width = t;
+            }, r.prototype.getHeight = function() {
+              return this.height;
+            }, r.prototype.setHeight = function(t) {
+              this.height = t;
+            }, f.exports = r;
+          },
+          /* 22 */
+          /***/
+          function(f, A, d) {
+            var r = d(14);
+            function t() {
+              this.map = {}, this.keys = [];
+            }
+            N(t, "HashMap"), t.prototype.put = function(e, i) {
+              var o = r.createID(e);
+              this.contains(o) || (this.map[o] = i, this.keys.push(e));
+            }, t.prototype.contains = function(e) {
+              return r.createID(e), this.map[e] != null;
+            }, t.prototype.get = function(e) {
+              var i = r.createID(e);
+              return this.map[i];
+            }, t.prototype.keySet = function() {
+              return this.keys;
+            }, f.exports = t;
+          },
+          /* 23 */
+          /***/
+          function(f, A, d) {
+            var r = d(14);
+            function t() {
+              this.set = {};
+            }
+            N(t, "HashSet"), t.prototype.add = function(e) {
+              var i = r.createID(e);
+              this.contains(i) || (this.set[i] = e);
+            }, t.prototype.remove = function(e) {
+              delete this.set[r.createID(e)];
+            }, t.prototype.clear = function() {
+              this.set = {};
+            }, t.prototype.contains = function(e) {
+              return this.set[r.createID(e)] == e;
+            }, t.prototype.isEmpty = function() {
+              return this.size() === 0;
+            }, t.prototype.size = function() {
+              return Object.keys(this.set).length;
+            }, t.prototype.addAllTo = function(e) {
+              for (var i = Object.keys(this.set), o = i.length, g = 0; g < o; g++)
+                e.push(this.set[i[g]]);
+            }, t.prototype.size = function() {
+              return Object.keys(this.set).length;
+            }, t.prototype.addAll = function(e) {
+              for (var i = e.length, o = 0; o < i; o++) {
+                var g = e[o];
+                this.add(g);
+              }
+            }, f.exports = t;
+          },
+          /* 24 */
+          /***/
+          function(f, A, d) {
+            var r = /* @__PURE__ */ function() {
+              function o(g, a) {
+                for (var y = 0; y < a.length; y++) {
+                  var n = a[y];
+                  n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(g, n.key, n);
+                }
+              }
+              return N(o, "defineProperties"), function(g, a, y) {
+                return a && o(g.prototype, a), y && o(g, y), g;
+              };
+            }();
+            function t(o, g) {
+              if (!(o instanceof g))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            N(t, "_classCallCheck");
+            var e = d(11), i = function() {
+              function o(g, a) {
+                t(this, o), (a !== null || a !== void 0) && (this.compareFunction = this._defaultCompareFunction);
+                var y = void 0;
+                g instanceof e ? y = g.size() : y = g.length, this._quicksort(g, 0, y - 1);
+              }
+              return N(o, "Quicksort"), r(o, [{
+                key: "_quicksort",
+                value: /* @__PURE__ */ N(function(a, y, n) {
+                  if (y < n) {
+                    var h = this._partition(a, y, n);
+                    this._quicksort(a, y, h), this._quicksort(a, h + 1, n);
+                  }
+                }, "_quicksort")
+              }, {
+                key: "_partition",
+                value: /* @__PURE__ */ N(function(a, y, n) {
+                  for (var h = this._get(a, y), l = y, E = n; ; ) {
+                    for (; this.compareFunction(h, this._get(a, E)); )
+                      E--;
+                    for (; this.compareFunction(this._get(a, l), h); )
+                      l++;
+                    if (l < E)
+                      this._swap(a, l, E), l++, E--;
+                    else return E;
+                  }
+                }, "_partition")
+              }, {
+                key: "_get",
+                value: /* @__PURE__ */ N(function(a, y) {
+                  return a instanceof e ? a.get_object_at(y) : a[y];
+                }, "_get")
+              }, {
+                key: "_set",
+                value: /* @__PURE__ */ N(function(a, y, n) {
+                  a instanceof e ? a.set_object_at(y, n) : a[y] = n;
+                }, "_set")
+              }, {
+                key: "_swap",
+                value: /* @__PURE__ */ N(function(a, y, n) {
+                  var h = this._get(a, y);
+                  this._set(a, y, this._get(a, n)), this._set(a, n, h);
+                }, "_swap")
+              }, {
+                key: "_defaultCompareFunction",
+                value: /* @__PURE__ */ N(function(a, y) {
+                  return y > a;
+                }, "_defaultCompareFunction")
+              }]), o;
+            }();
+            f.exports = i;
+          },
+          /* 25 */
+          /***/
+          function(f, A, d) {
+            var r = /* @__PURE__ */ function() {
+              function i(o, g) {
+                for (var a = 0; a < g.length; a++) {
+                  var y = g[a];
+                  y.enumerable = y.enumerable || !1, y.configurable = !0, "value" in y && (y.writable = !0), Object.defineProperty(o, y.key, y);
+                }
+              }
+              return N(i, "defineProperties"), function(o, g, a) {
+                return g && i(o.prototype, g), a && i(o, a), o;
+              };
+            }();
+            function t(i, o) {
+              if (!(i instanceof o))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            N(t, "_classCallCheck");
+            var e = function() {
+              function i(o, g) {
+                var a = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1, y = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : -1, n = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : -1;
+                t(this, i), this.sequence1 = o, this.sequence2 = g, this.match_score = a, this.mismatch_penalty = y, this.gap_penalty = n, this.iMax = o.length + 1, this.jMax = g.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 l = 0; l < this.jMax; l++)
+                    this.grid[h][l] = 0;
+                }
+                this.tracebackGrid = new Array(this.iMax);
+                for (var E = 0; E < this.iMax; E++) {
+                  this.tracebackGrid[E] = new Array(this.jMax);
+                  for (var T = 0; T < this.jMax; T++)
+                    this.tracebackGrid[E][T] = [null, null, null];
+                }
+                this.alignments = [], this.score = -1, this.computeGrids();
+              }
+              return N(i, "NeedlemanWunsch"), r(i, [{
+                key: "getScore",
+                value: /* @__PURE__ */ N(function() {
+                  return this.score;
+                }, "getScore")
+              }, {
+                key: "getAlignments",
+                value: /* @__PURE__ */ N(function() {
+                  return this.alignments;
+                }, "getAlignments")
+                // Main dynamic programming procedure
+              }, {
+                key: "computeGrids",
+                value: /* @__PURE__ */ N(function() {
+                  for (var g = 1; g < this.jMax; g++)
+                    this.grid[0][g] = this.grid[0][g - 1] + this.gap_penalty, this.tracebackGrid[0][g] = [!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 y = 1; y < this.iMax; y++)
+                    for (var n = 1; n < this.jMax; n++) {
+                      var h = void 0;
+                      this.sequence1[y - 1] === this.sequence2[n - 1] ? h = this.grid[y - 1][n - 1] + this.match_score : h = this.grid[y - 1][n - 1] + this.mismatch_penalty;
+                      var l = this.grid[y - 1][n] + this.gap_penalty, E = this.grid[y][n - 1] + this.gap_penalty, T = [h, l, E], D = this.arrayAllMaxIndexes(T);
+                      this.grid[y][n] = T[D[0]], this.tracebackGrid[y][n] = [D.includes(0), D.includes(1), D.includes(2)];
+                    }
+                  this.score = this.grid[this.iMax - 1][this.jMax - 1];
+                }, "computeGrids")
+                // Gets all possible valid sequence combinations
+              }, {
+                key: "alignmentTraceback",
+                value: /* @__PURE__ */ N(function() {
+                  var g = [];
+                  for (g.push({
+                    pos: [this.sequence1.length, this.sequence2.length],
+                    seq1: "",
+                    seq2: ""
+                  }); g[0]; ) {
+                    var a = g[0], y = this.tracebackGrid[a.pos[0]][a.pos[1]];
+                    y[0] && g.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
+                    }), y[1] && g.push({
+                      pos: [a.pos[0] - 1, a.pos[1]],
+                      seq1: this.sequence1[a.pos[0] - 1] + a.seq1,
+                      seq2: "-" + a.seq2
+                    }), y[2] && g.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
+                    }), g.shift();
+                  }
+                  return this.alignments;
+                }, "alignmentTraceback")
+                // Helper Functions
+              }, {
+                key: "getAllIndexes",
+                value: /* @__PURE__ */ N(function(g, a) {
+                  for (var y = [], n = -1; (n = g.indexOf(a, n + 1)) !== -1; )
+                    y.push(n);
+                  return y;
+                }, "getAllIndexes")
+              }, {
+                key: "arrayAllMaxIndexes",
+                value: /* @__PURE__ */ N(function(g) {
+                  return this.getAllIndexes(g, Math.max.apply(null, g));
+                }, "arrayAllMaxIndexes")
+              }]), i;
+            }();
+            f.exports = e;
+          },
+          /* 26 */
+          /***/
+          function(f, A, d) {
+            var r = /* @__PURE__ */ N(function() {
+            }, "layoutBase");
+            r.FDLayout = d(18), r.FDLayoutConstants = d(7), r.FDLayoutEdge = d(19), r.FDLayoutNode = d(20), r.DimensionD = d(21), r.HashMap = d(22), r.HashSet = d(23), r.IGeometry = d(8), r.IMath = d(9), r.Integer = d(10), r.Point = d(12), r.PointD = d(4), r.RandomSeed = d(16), r.RectangleD = d(13), r.Transform = d(17), r.UniqueIDGeneretor = d(14), r.Quicksort = d(24), r.LinkedList = d(11), r.LGraphObject = d(2), r.LGraph = d(5), r.LEdge = d(1), r.LGraphManager = d(6), r.LNode = d(3), r.Layout = d(15), r.LayoutConstants = d(0), r.NeedlemanWunsch = d(25), f.exports = r;
+          },
+          /* 27 */
+          /***/
+          function(f, A, d) {
+            function r() {
+              this.listeners = [];
+            }
+            N(r, "Emitter");
+            var t = r.prototype;
+            t.addListener = function(e, i) {
+              this.listeners.push({
+                event: e,
+                callback: i
+              });
+            }, t.removeListener = function(e, i) {
+              for (var o = this.listeners.length; o >= 0; o--) {
+                var g = this.listeners[o];
+                g.event === e && g.callback === i && this.listeners.splice(o, 1);
+              }
+            }, t.emit = function(e, i) {
+              for (var o = 0; o < this.listeners.length; o++) {
+                var g = this.listeners[o];
+                e === g.event && g.callback(i);
+              }
+            }, f.exports = r;
+          }
+          /******/
+        ])
+      );
+    });
+  }
+}), gt = st({
+  "../../node_modules/.pnpm/cose-base@1.0.3/node_modules/cose-base/cose-base.js"(O, x) {
+    (/* @__PURE__ */ N(function(A, d) {
+      typeof O == "object" && typeof x == "object" ? x.exports = d(ct()) : typeof define == "function" && define.amd ? define(["layout-base"], d) : typeof O == "object" ? O.coseBase = d(ct()) : A.coseBase = d(A.layoutBase);
+    }, "webpackUniversalModuleDefinition"))(O, function(f) {
+      return (
+        /******/
+        function(A) {
+          var d = {};
+          function r(t) {
+            if (d[t])
+              return d[t].exports;
+            var e = d[t] = {
+              /******/
+              i: t,
+              /******/
+              l: !1,
+              /******/
+              exports: {}
+              /******/
+            };
+            return A[t].call(e.exports, e, e.exports, r), e.l = !0, e.exports;
+          }
+          return N(r, "__webpack_require__"), r.m = A, r.c = d, r.i = function(t) {
+            return t;
+          }, r.d = function(t, e, i) {
+            r.o(t, e) || Object.defineProperty(t, e, {
+              /******/
+              configurable: !1,
+              /******/
+              enumerable: !0,
+              /******/
+              get: i
+              /******/
+            });
+          }, r.n = function(t) {
+            var e = t && t.__esModule ? (
+              /******/
+              /* @__PURE__ */ N(function() {
+                return t.default;
+              }, "getDefault")
+            ) : (
+              /******/
+              /* @__PURE__ */ N(function() {
+                return t;
+              }, "getModuleExports")
+            );
+            return r.d(e, "a", e), e;
+          }, r.o = function(t, e) {
+            return Object.prototype.hasOwnProperty.call(t, e);
+          }, r.p = "", r(r.s = 7);
+        }([
+          /* 0 */
+          /***/
+          function(A, d) {
+            A.exports = f;
+          },
+          /* 1 */
+          /***/
+          function(A, d, r) {
+            var t = r(0).FDLayoutConstants;
+            function e() {
+            }
+            N(e, "CoSEConstants");
+            for (var i in t)
+              e[i] = t[i];
+            e.DEFAULT_USE_MULTI_LEVEL_SCALING = !1, e.DEFAULT_RADIAL_SEPARATION = t.DEFAULT_EDGE_LENGTH, e.DEFAULT_COMPONENT_SEPERATION = 60, e.TILE = !0, e.TILING_PADDING_VERTICAL = 10, e.TILING_PADDING_HORIZONTAL = 10, e.TREE_REDUCTION_ON_INCREMENTAL = !1, A.exports = e;
+          },
+          /* 2 */
+          /***/
+          function(A, d, r) {
+            var t = r(0).FDLayoutEdge;
+            function e(o, g, a) {
+              t.call(this, o, g, a);
+            }
+            N(e, "CoSEEdge"), e.prototype = Object.create(t.prototype);
+            for (var i in t)
+              e[i] = t[i];
+            A.exports = e;
+          },
+          /* 3 */
+          /***/
+          function(A, d, r) {
+            var t = r(0).LGraph;
+            function e(o, g, a) {
+              t.call(this, o, g, a);
+            }
+            N(e, "CoSEGraph"), e.prototype = Object.create(t.prototype);
+            for (var i in t)
+              e[i] = t[i];
+            A.exports = e;
+          },
+          /* 4 */
+          /***/
+          function(A, d, r) {
+            var t = r(0).LGraphManager;
+            function e(o) {
+              t.call(this, o);
+            }
+            N(e, "CoSEGraphManager"), e.prototype = Object.create(t.prototype);
+            for (var i in t)
+              e[i] = t[i];
+            A.exports = e;
+          },
+          /* 5 */
+          /***/
+          function(A, d, r) {
+            var t = r(0).FDLayoutNode, e = r(0).IMath;
+            function i(g, a, y, n) {
+              t.call(this, g, a, y, n);
+            }
+            N(i, "CoSENode"), i.prototype = Object.create(t.prototype);
+            for (var o in t)
+              i[o] = t[o];
+            i.prototype.move = function() {
+              var g = this.graphManager.getLayout();
+              this.displacementX = g.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren, this.displacementY = g.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren, Math.abs(this.displacementX) > g.coolingFactor * g.maxNodeDisplacement && (this.displacementX = g.coolingFactor * g.maxNodeDisplacement * e.sign(this.displacementX)), Math.abs(this.displacementY) > g.coolingFactor * g.maxNodeDisplacement && (this.displacementY = g.coolingFactor * g.maxNodeDisplacement * e.sign(this.displacementY)), this.child == null ? this.moveBy(this.displacementX, this.displacementY) : this.child.getNodes().length == 0 ? this.moveBy(this.displacementX, this.displacementY) : this.propogateDisplacementToChildren(this.displacementX, this.displacementY), g.totalDisplacement += Math.abs(this.displacementX) + Math.abs(this.displacementY), this.springForceX = 0, this.springForceY = 0, this.repulsionForceX = 0, this.repulsionForceY = 0, this.gravitationForceX = 0, this.gravitationForceY = 0, this.displacementX = 0, this.displacementY = 0;
+            }, i.prototype.propogateDisplacementToChildren = function(g, a) {
+              for (var y = this.getChild().getNodes(), n, h = 0; h < y.length; h++)
+                n = y[h], n.getChild() == null ? (n.moveBy(g, a), n.displacementX += g, n.displacementY += a) : n.propogateDisplacementToChildren(g, a);
+            }, i.prototype.setPred1 = function(g) {
+              this.pred1 = g;
+            }, i.prototype.getPred1 = function() {
+              return pred1;
+            }, i.prototype.getPred2 = function() {
+              return pred2;
+            }, i.prototype.setNext = function(g) {
+              this.next = g;
+            }, i.prototype.getNext = function() {
+              return next;
+            }, i.prototype.setProcessed = function(g) {
+              this.processed = g;
+            }, i.prototype.isProcessed = function() {
+              return processed;
+            }, A.exports = i;
+          },
+          /* 6 */
+          /***/
+          function(A, d, r) {
+            var t = r(0).FDLayout, e = r(4), i = r(3), o = r(5), g = r(2), a = r(1), y = r(0).FDLayoutConstants, n = r(0).LayoutConstants, h = r(0).Point, l = r(0).PointD, E = r(0).Layout, T = r(0).Integer, D = r(0).IGeometry, L = r(0).LGraph, I = r(0).Transform;
+            function v() {
+              t.call(this), this.toBeTiled = {};
+            }
+            N(v, "CoSELayout"), v.prototype = Object.create(t.prototype);
+            for (var m in t)
+              v[m] = t[m];
+            v.prototype.newGraphManager = function() {
+              var s = new e(this);
+              return this.graphManager = s, s;
+            }, v.prototype.newGraph = function(s) {
+              return new i(null, this.graphManager, s);
+            }, v.prototype.newNode = function(s) {
+              return new o(this.graphManager, s);
+            }, v.prototype.newEdge = function(s) {
+              return new g(null, null, s);
+            }, v.prototype.initParameters = function() {
+              t.prototype.initParameters.call(this, arguments), this.isSubLayout || (a.DEFAULT_EDGE_LENGTH < 10 ? this.idealEdgeLength = 10 : this.idealEdgeLength = a.DEFAULT_EDGE_LENGTH, this.useSmartIdealEdgeLengthCalculation = a.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION, this.springConstant = y.DEFAULT_SPRING_STRENGTH, this.repulsionConstant = y.DEFAULT_REPULSION_STRENGTH, this.gravityConstant = y.DEFAULT_GRAVITY_STRENGTH, this.compoundGravityConstant = y.DEFAULT_COMPOUND_GRAVITY_STRENGTH, this.gravityRangeFactor = y.DEFAULT_GRAVITY_RANGE_FACTOR, this.compoundGravityRangeFactor = y.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR, this.prunedNodesAll = [], this.growTreeIterations = 0, this.afterGrowthIterations = 0, this.isTreeGrowing = !1, this.isGrowthFinished = !1, this.coolingCycle = 0, this.maxCoolingCycle = this.maxIterations / y.CONVERGENCE_CHECK_PERIOD, this.finalTemperature = y.CONVERGENCE_CHECK_PERIOD / this.maxIterations, this.coolingAdjuster = 1);
+            }, v.prototype.layout = function() {
+              var s = n.DEFAULT_CREATE_BENDS_AS_NEEDED;
+              return s && (this.createBendpoints(), this.graphManager.resetAllEdges()), this.level = 0, this.classicLayout();
+            }, v.prototype.classicLayout = function() {
+              if (this.nodesWithGravity = this.calculateNodesToApplyGravitationTo(), this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity), this.calcNoOfChildrenForAllNodes(), this.graphManager.calcLowestCommonAncestors(), this.graphManager.calcInclusionTreeDepths(), this.graphManager.getRoot().calcEstimatedSize(), this.calcIdealEdgeLengths(), this.incremental) {
+                if (a.TREE_REDUCTION_ON_INCREMENTAL) {
+                  this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+                  var c = new Set(this.getAllNodes()), u = this.nodesWithGravity.filter(function(R) {
+                    return c.has(R);
+                  });
+                  this.graphManager.setAllNodesToApplyGravitation(u);
+                }
+              } else {
+                var s = this.getFlatForest();
+                if (s.length > 0)
+                  this.positionNodesRadially(s);
+                else {
+                  this.reduceTrees(), this.graphManager.resetAllNodesToApplyGravitation();
+                  var c = new Set(this.getAllNodes()), u = this.nodesWithGravity.filter(function(p) {
+                    return c.has(p);
+                  });
+                  this.graphManager.setAllNodesToApplyGravitation(u), this.positionNodesRandomly();
+                }
+              }
+              return this.initSpringEmbedder(), this.runSpringEmbedder(), !0;
+            }, v.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 % y.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 s = new Set(this.getAllNodes()), c = this.nodesWithGravity.filter(function(C) {
+                      return s.has(C);
+                    });
+                    this.graphManager.setAllNodesToApplyGravitation(c), this.graphManager.updateBounds(), this.updateGrid(), this.coolingFactor = y.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+                  } else
+                    this.isTreeGrowing = !1, this.isGrowthFinished = !0;
+                this.growTreeIterations++;
+              }
+              if (this.isGrowthFinished) {
+                if (this.isConverged())
+                  return !0;
+                this.afterGrowthIterations % 10 == 0 && (this.graphManager.updateBounds(), this.updateGrid()), this.coolingFactor = y.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100), this.afterGrowthIterations++;
+              }
+              var u = !this.isTreeGrowing && !this.isGrowthFinished, p = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished;
+              return this.totalDisplacement = 0, this.graphManager.updateBounds(), this.calcSpringForces(), this.calcRepulsionForces(u, p), this.calcGravitationalForces(), this.moveNodes(), this.animate(), !1;
+            }, v.prototype.getPositionsData = function() {
+              for (var s = this.graphManager.getAllNodes(), c = {}, u = 0; u < s.length; u++) {
+                var p = s[u].rect, C = s[u].id;
+                c[C] = {
+                  id: C,
+                  x: p.getCenterX(),
+                  y: p.getCenterY(),
+                  w: p.width,
+                  h: p.height
+                };
+              }
+              return c;
+            }, v.prototype.runSpringEmbedder = function() {
+              this.initialAnimationPeriod = 25, this.animationPeriod = this.initialAnimationPeriod;
+              var s = !1;
+              if (y.ANIMATE === "during")
+                this.emit("layoutstarted");
+              else {
+                for (; !s; )
+                  s = this.tick();
+                this.graphManager.updateBounds();
+              }
+            }, v.prototype.calculateNodesToApplyGravitationTo = function() {
+              var s = [], c, u = this.graphManager.getGraphs(), p = u.length, C;
+              for (C = 0; C < p; C++)
+                c = u[C], c.updateConnected(), c.isConnected || (s = s.concat(c.getNodes()));
+              return s;
+            }, v.prototype.createBendpoints = function() {
+              var s = [];
+              s = s.concat(this.graphManager.getAllEdges());
+              var c = /* @__PURE__ */ new Set(), u;
+              for (u = 0; u < s.length; u++) {
+                var p = s[u];
+                if (!c.has(p)) {
+                  var C = p.getSource(), R = p.getTarget();
+                  if (C == R)
+                    p.getBendpoints().push(new l()), p.getBendpoints().push(new l()), this.createDummyNodesForBendpoints(p), c.add(p);
+                  else {
+                    var M = [];
+                    if (M = M.concat(C.getEdgeListToNode(R)), M = M.concat(R.getEdgeListToNode(C)), !c.has(M[0])) {
+                      if (M.length > 1) {
+                        var w;
+                        for (w = 0; w < M.length; w++) {
+                          var G = M[w];
+                          G.getBendpoints().push(new l()), this.createDummyNodesForBendpoints(G);
+                        }
+                      }
+                      M.forEach(function(U) {
+                        c.add(U);
+                      });
+                    }
+                  }
+                }
+                if (c.size == s.length)
+                  break;
+              }
+            }, v.prototype.positionNodesRadially = function(s) {
+              for (var c = new h(0, 0), u = Math.ceil(Math.sqrt(s.length)), p = 0, C = 0, R = 0, M = new l(0, 0), w = 0; w < s.length; w++) {
+                w % u == 0 && (R = 0, C = p, w != 0 && (C += a.DEFAULT_COMPONENT_SEPERATION), p = 0);
+                var G = s[w], U = E.findCenterOfTree(G);
+                c.x = R, c.y = C, M = v.radialLayout(G, U, c), M.y > p && (p = Math.floor(M.y)), R = Math.floor(M.x + a.DEFAULT_COMPONENT_SEPERATION);
+              }
+              this.transform(new l(n.WORLD_CENTER_X - M.x / 2, n.WORLD_CENTER_Y - M.y / 2));
+            }, v.radialLayout = function(s, c, u) {
+              var p = Math.max(this.maxDiagonalInTree(s), a.DEFAULT_RADIAL_SEPARATION);
+              v.branchRadialLayout(c, null, 0, 359, 0, p);
+              var C = L.calculateBounds(s), R = new I();
+              R.setDeviceOrgX(C.getMinX()), R.setDeviceOrgY(C.getMinY()), R.setWorldOrgX(u.x), R.setWorldOrgY(u.y);
+              for (var M = 0; M < s.length; M++) {
+                var w = s[M];
+                w.transform(R);
+              }
+              var G = new l(C.getMaxX(), C.getMaxY());
+              return R.inverseTransformPoint(G);
+            }, v.branchRadialLayout = function(s, c, u, p, C, R) {
+              var M = (p - u + 1) / 2;
+              M < 0 && (M += 180);
+              var w = (M + u) % 360, G = w * D.TWO_PI / 360, U = C * Math.cos(G), X = C * Math.sin(G);
+              s.setCenter(U, X);
+              var _ = [];
+              _ = _.concat(s.getEdges());
+              var S = _.length;
+              c != null && S--;
+              for (var F = 0, b = _.length, Y, k = s.getEdgesBetween(c); k.length > 1; ) {
+                var H = k[0];
+                k.splice(0, 1);
+                var P = _.indexOf(H);
+                P >= 0 && _.splice(P, 1), b--, S--;
+              }
+              c != null ? Y = (_.indexOf(k[0]) + 1) % b : Y = 0;
+              for (var B = Math.abs(p - u) / S, $ = Y; F != S; $ = ++$ % b) {
+                var K = _[$].getOtherEnd(s);
+                if (K != c) {
+                  var j = (u + F * B) % 360, q = (j + B) % 360;
+                  v.branchRadialLayout(K, s, j, q, C + R, R), F++;
+                }
+              }
+            }, v.maxDiagonalInTree = function(s) {
+              for (var c = T.MIN_VALUE, u = 0; u < s.length; u++) {
+                var p = s[u], C = p.getDiagonal();
+                C > c && (c = C);
+              }
+              return c;
+            }, v.prototype.calcRepulsionRange = function() {
+              return 2 * (this.level + 1) * this.idealEdgeLength;
+            }, v.prototype.groupZeroDegreeMembers = function() {
+              var s = this, c = {};
+              this.memberGroups = {}, this.idToDummyNode = {};
+              for (var u = [], p = this.graphManager.getAllNodes(), C = 0; C < p.length; C++) {
+                var R = p[C], M = R.getParent();
+                this.getNodeDegreeWithChildren(R) === 0 && (M.id == null || !this.getToBeTiled(M)) && u.push(R);
+              }
+              for (var C = 0; C < u.length; C++) {
+                var R = u[C], w = R.getParent().id;
+                typeof c[w] > "u" && (c[w] = []), c[w] = c[w].concat(R);
+              }
+              Object.keys(c).forEach(function(G) {
+                if (c[G].length > 1) {
+                  var U = "DummyCompound_" + G;
+                  s.memberGroups[U] = c[G];
+                  var X = c[G][0].getParent(), _ = new o(s.graphManager);
+                  _.id = U, _.paddingLeft = X.paddingLeft || 0, _.paddingRight = X.paddingRight || 0, _.paddingBottom = X.paddingBottom || 0, _.paddingTop = X.paddingTop || 0, s.idToDummyNode[U] = _;
+                  var S = s.getGraphManager().add(s.newGraph(), _), F = X.getChild();
+                  F.add(_);
+                  for (var b = 0; b < c[G].length; b++) {
+                    var Y = c[G][b];
+                    F.remove(Y), S.add(Y);
+                  }
+                }
+              });
+            }, v.prototype.clearCompounds = function() {
+              var s = {}, c = {};
+              this.performDFSOnCompounds();
+              for (var u = 0; u < this.compoundOrder.length; u++)
+                c[this.compoundOrder[u].id] = this.compoundOrder[u], s[this.compoundOrder[u].id] = [].concat(this.compoundOrder[u].getChild().getNodes()), this.graphManager.remove(this.compoundOrder[u].getChild()), this.compoundOrder[u].child = null;
+              this.graphManager.resetAllNodes(), this.tileCompoundMembers(s, c);
+            }, v.prototype.clearZeroDegreeMembers = function() {
+              var s = this, c = this.tiledZeroDegreePack = [];
+              Object.keys(this.memberGroups).forEach(function(u) {
+                var p = s.idToDummyNode[u];
+                c[u] = s.tileNodes(s.memberGroups[u], p.paddingLeft + p.paddingRight), p.rect.width = c[u].width, p.rect.height = c[u].height;
+              });
+            }, v.prototype.repopulateCompounds = function() {
+              for (var s = this.compoundOrder.length - 1; s >= 0; s--) {
+                var c = this.compoundOrder[s], u = c.id, p = c.paddingLeft, C = c.paddingTop;
+                this.adjustLocations(this.tiledMemberPack[u], c.rect.x, c.rect.y, p, C);
+              }
+            }, v.prototype.repopulateZeroDegreeMembers = function() {
+              var s = this, c = this.tiledZeroDegreePack;
+              Object.keys(c).forEach(function(u) {
+                var p = s.idToDummyNode[u], C = p.paddingLeft, R = p.paddingTop;
+                s.adjustLocations(c[u], p.rect.x, p.rect.y, C, R);
+              });
+            }, v.prototype.getToBeTiled = function(s) {
+              var c = s.id;
+              if (this.toBeTiled[c] != null)
+                return this.toBeTiled[c];
+              var u = s.getChild();
+              if (u == null)
+                return this.toBeTiled[c] = !1, !1;
+              for (var p = u.getNodes(), C = 0; C < p.length; C++) {
+                var R = p[C];
+                if (this.getNodeDegree(R) > 0)
+                  return this.toBeTiled[c] = !1, !1;
+                if (R.getChild() == null) {
+                  this.toBeTiled[R.id] = !1;
+                  continue;
+                }
+                if (!this.getToBeTiled(R))
+                  return this.toBeTiled[c] = !1, !1;
+              }
+              return this.toBeTiled[c] = !0, !0;
+            }, v.prototype.getNodeDegree = function(s) {
+              s.id;
+              for (var c = s.getEdges(), u = 0, p = 0; p < c.length; p++) {
+                var C = c[p];
+                C.getSource().id !== C.getTarget().id && (u = u + 1);
+              }
+              return u;
+            }, v.prototype.getNodeDegreeWithChildren = function(s) {
+              var c = this.getNodeDegree(s);
+              if (s.getChild() == null)
+                return c;
+              for (var u = s.getChild().getNodes(), p = 0; p < u.length; p++) {
+                var C = u[p];
+                c += this.getNodeDegreeWithChildren(C);
+              }
+              return c;
+            }, v.prototype.performDFSOnCompounds = function() {
+              this.compoundOrder = [], this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes());
+            }, v.prototype.fillCompexOrderByDFS = function(s) {
+              for (var c = 0; c < s.length; c++) {
+                var u = s[c];
+                u.getChild() != null && this.fillCompexOrderByDFS(u.getChild().getNodes()), this.getToBeTiled(u) && this.compoundOrder.push(u);
+              }
+            }, v.prototype.adjustLocations = function(s, c, u, p, C) {
+              c += p, u += C;
+              for (var R = c, M = 0; M < s.rows.length; M++) {
+                var w = s.rows[M];
+                c = R;
+                for (var G = 0, U = 0; U < w.length; U++) {
+                  var X = w[U];
+                  X.rect.x = c, X.rect.y = u, c += X.rect.width + s.horizontalPadding, X.rect.height > G && (G = X.rect.height);
+                }
+                u += G + s.verticalPadding;
+              }
+            }, v.prototype.tileCompoundMembers = function(s, c) {
+              var u = this;
+              this.tiledMemberPack = [], Object.keys(s).forEach(function(p) {
+                var C = c[p];
+                u.tiledMemberPack[p] = u.tileNodes(s[p], C.paddingLeft + C.paddingRight), C.rect.width = u.tiledMemberPack[p].width, C.rect.height = u.tiledMemberPack[p].height;
+              });
+            }, v.prototype.tileNodes = function(s, c) {
+              var u = a.TILING_PADDING_VERTICAL, p = a.TILING_PADDING_HORIZONTAL, C = {
+                rows: [],
+                rowWidth: [],
+                rowHeight: [],
+                width: 0,
+                height: c,
+                // assume minHeight equals to minWidth
+                verticalPadding: u,
+                horizontalPadding: p
+              };
+              s.sort(function(w, G) {
+                return w.rect.width * w.rect.height > G.rect.width * G.rect.height ? -1 : w.rect.width * w.rect.height < G.rect.width * G.rect.height ? 1 : 0;
+              });
+              for (var R = 0; R < s.length; R++) {
+                var M = s[R];
+                C.rows.length == 0 ? this.insertNodeToRow(C, M, 0, c) : this.canAddHorizontal(C, M.rect.width, M.rect.height) ? this.insertNodeToRow(C, M, this.getShortestRowIndex(C), c) : this.insertNodeToRow(C, M, C.rows.length, c), this.shiftToLastRow(C);
+              }
+              return C;
+            }, v.prototype.insertNodeToRow = function(s, c, u, p) {
+              var C = p;
+              if (u == s.rows.length) {
+                var R = [];
+                s.rows.push(R), s.rowWidth.push(C), s.rowHeight.push(0);
+              }
+              var M = s.rowWidth[u] + c.rect.width;
+              s.rows[u].length > 0 && (M += s.horizontalPadding), s.rowWidth[u] = M, s.width < M && (s.width = M);
+              var w = c.rect.height;
+              u > 0 && (w += s.verticalPadding);
+              var G = 0;
+              w > s.rowHeight[u] && (G = s.rowHeight[u], s.rowHeight[u] = w, G = s.rowHeight[u] - G), s.height += G, s.rows[u].push(c);
+            }, v.prototype.getShortestRowIndex = function(s) {
+              for (var c = -1, u = Number.MAX_VALUE, p = 0; p < s.rows.length; p++)
+                s.rowWidth[p] < u && (c = p, u = s.rowWidth[p]);
+              return c;
+            }, v.prototype.getLongestRowIndex = function(s) {
+              for (var c = -1, u = Number.MIN_VALUE, p = 0; p < s.rows.length; p++)
+                s.rowWidth[p] > u && (c = p, u = s.rowWidth[p]);
+              return c;
+            }, v.prototype.canAddHorizontal = function(s, c, u) {
+              var p = this.getShortestRowIndex(s);
+              if (p < 0)
+                return !0;
+              var C = s.rowWidth[p];
+              if (C + s.horizontalPadding + c <= s.width) return !0;
+              var R = 0;
+              s.rowHeight[p] < u && p > 0 && (R = u + s.verticalPadding - s.rowHeight[p]);
+              var M;
+              s.width - C >= c + s.horizontalPadding ? M = (s.height + R) / (C + c + s.horizontalPadding) : M = (s.height + R) / s.width, R = u + s.verticalPadding;
+              var w;
+              return s.width < c ? w = (s.height + R) / c : w = (s.height + R) / s.width, w < 1 && (w = 1 / w), M < 1 && (M = 1 / M), M < w;
+            }, v.prototype.shiftToLastRow = function(s) {
+              var c = this.getLongestRowIndex(s), u = s.rowWidth.length - 1, p = s.rows[c], C = p[p.length - 1], R = C.width + s.horizontalPadding;
+              if (s.width - s.rowWidth[u] > R && c != u) {
+                p.splice(-1, 1), s.rows[u].push(C), s.rowWidth[c] = s.rowWidth[c] - R, s.rowWidth[u] = s.rowWidth[u] + R, s.width = s.rowWidth[instance.getLongestRowIndex(s)];
+                for (var M = Number.MIN_VALUE, w = 0; w < p.length; w++)
+                  p[w].height > M && (M = p[w].height);
+                c > 0 && (M += s.verticalPadding);
+                var G = s.rowHeight[c] + s.rowHeight[u];
+                s.rowHeight[c] = M, s.rowHeight[u] < C.height + s.verticalPadding && (s.rowHeight[u] = C.height + s.verticalPadding);
+                var U = s.rowHeight[c] + s.rowHeight[u];
+                s.height += U - G, this.shiftToLastRow(s);
+              }
+            }, v.prototype.tilingPreLayout = function() {
+              a.TILE && (this.groupZeroDegreeMembers(), this.clearCompounds(), this.clearZeroDegreeMembers());
+            }, v.prototype.tilingPostLayout = function() {
+              a.TILE && (this.repopulateZeroDegreeMembers(), this.repopulateCompounds());
+            }, v.prototype.reduceTrees = function() {
+              for (var s = [], c = !0, u; c; ) {
+                var p = this.graphManager.getAllNodes(), C = [];
+                c = !1;
+                for (var R = 0; R < p.length; R++)
+                  u = p[R], u.getEdges().length == 1 && !u.getEdges()[0].isInterGraph && u.getChild() == null && (C.push([u, u.getEdges()[0], u.getOwner()]), c = !0);
+                if (c == !0) {
+                  for (var M = [], w = 0; w < C.length; w++)
+                    C[w][0].getEdges().length == 1 && (M.push(C[w]), C[w][0].getOwner().remove(C[w][0]));
+                  s.push(M), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+                }
+              }
+              this.prunedNodesAll = s;
+            }, v.prototype.growTree = function(s) {
+              for (var c = s.length, u = s[c - 1], p, C = 0; C < u.length; C++)
+                p = u[C], this.findPlaceforPrunedNode(p), p[2].add(p[0]), p[2].add(p[1], p[1].source, p[1].target);
+              s.splice(s.length - 1, 1), this.graphManager.resetAllNodes(), this.graphManager.resetAllEdges();
+            }, v.prototype.findPlaceforPrunedNode = function(s) {
+              var c, u, p = s[0];
+              p == s[1].source ? u = s[1].target : u = s[1].source;
+              var C = u.startX, R = u.finishX, M = u.startY, w = u.finishY, G = 0, U = 0, X = 0, _ = 0, S = [G, X, U, _];
+              if (M > 0)
+                for (var F = C; F <= R; F++)
+                  S[0] += this.grid[F][M - 1].length + this.grid[F][M].length - 1;
+              if (R < this.grid.length - 1)
+                for (var F = M; F <= w; F++)
+                  S[1] += this.grid[R + 1][F].length + this.grid[R][F].length - 1;
+              if (w < this.grid[0].length - 1)
+                for (var F = C; F <= R; F++)
+                  S[2] += this.grid[F][w + 1].length + this.grid[F][w].length - 1;
+              if (C > 0)
+                for (var F = M; F <= w; F++)
+                  S[3] += this.grid[C - 1][F].length + this.grid[C][F].length - 1;
+              for (var b = T.MAX_VALUE, Y, k, H = 0; H < S.length; H++)
+                S[H] < b ? (b = S[H], Y = 1, k = H) : S[H] == b && Y++;
+              if (Y == 3 && b == 0)
+                S[0] == 0 && S[1] == 0 && S[2] == 0 ? c = 1 : S[0] == 0 && S[1] == 0 && S[3] == 0 ? c = 0 : S[0] == 0 && S[2] == 0 && S[3] == 0 ? c = 3 : S[1] == 0 && S[2] == 0 && S[3] == 0 && (c = 2);
+              else if (Y == 2 && b == 0) {
+                var P = Math.floor(Math.random() * 2);
+                S[0] == 0 && S[1] == 0 ? P == 0 ? c = 0 : c = 1 : S[0] == 0 && S[2] == 0 ? P == 0 ? c = 0 : c = 2 : S[0] == 0 && S[3] == 0 ? P == 0 ? c = 0 : c = 3 : S[1] == 0 && S[2] == 0 ? P == 0 ? c = 1 : c = 2 : S[1] == 0 && S[3] == 0 ? P == 0 ? c = 1 : c = 3 : P == 0 ? c = 2 : c = 3;
+              } else if (Y == 4 && b == 0) {
+                var P = Math.floor(Math.random() * 4);
+                c = P;
+              } else
+                c = k;
+              c == 0 ? p.setCenter(u.getCenterX(), u.getCenterY() - u.getHeight() / 2 - y.DEFAULT_EDGE_LENGTH - p.getHeight() / 2) : c == 1 ? p.setCenter(u.getCenterX() + u.getWidth() / 2 + y.DEFAULT_EDGE_LENGTH + p.getWidth() / 2, u.getCenterY()) : c == 2 ? p.setCenter(u.getCenterX(), u.getCenterY() + u.getHeight() / 2 + y.DEFAULT_EDGE_LENGTH + p.getHeight() / 2) : p.setCenter(u.getCenterX() - u.getWidth() / 2 - y.DEFAULT_EDGE_LENGTH - p.getWidth() / 2, u.getCenterY());
+            }, A.exports = v;
+          },
+          /* 7 */
+          /***/
+          function(A, d, r) {
+            var t = {};
+            t.layoutBase = r(0), t.CoSEConstants = r(1), t.CoSEEdge = r(2), t.CoSEGraph = r(3), t.CoSEGraphManager = r(4), t.CoSELayout = r(6), t.CoSENode = r(5), A.exports = t;
+          }
+          /******/
+        ])
+      );
+    });
+  }
+}), Ct = st({
+  "../../node_modules/.pnpm/cytoscape-cose-bilkent@4.1.0_cytoscape@3.31.0/node_modules/cytoscape-cose-bilkent/cytoscape-cose-bilkent.js"(O, x) {
+    (/* @__PURE__ */ N(function(A, d) {
+      typeof O == "object" && typeof x == "object" ? x.exports = d(gt()) : typeof define == "function" && define.amd ? define(["cose-base"], d) : typeof O == "object" ? O.cytoscapeCoseBilkent = d(gt()) : A.cytoscapeCoseBilkent = d(A.coseBase);
+    }, "webpackUniversalModuleDefinition"))(O, function(f) {
+      return (
+        /******/
+        function(A) {
+          var d = {};
+          function r(t) {
+            if (d[t])
+              return d[t].exports;
+            var e = d[t] = {
+              /******/
+              i: t,
+              /******/
+              l: !1,
+              /******/
+              exports: {}
+              /******/
+            };
+            return A[t].call(e.exports, e, e.exports, r), e.l = !0, e.exports;
+          }
+          return N(r, "__webpack_require__"), r.m = A, r.c = d, r.i = function(t) {
+            return t;
+          }, r.d = function(t, e, i) {
+            r.o(t, e) || Object.defineProperty(t, e, {
+              /******/
+              configurable: !1,
+              /******/
+              enumerable: !0,
+              /******/
+              get: i
+              /******/
+            });
+          }, r.n = function(t) {
+            var e = t && t.__esModule ? (
+              /******/
+              /* @__PURE__ */ N(function() {
+                return t.default;
+              }, "getDefault")
+            ) : (
+              /******/
+              /* @__PURE__ */ N(function() {
+                return t;
+              }, "getModuleExports")
+            );
+            return r.d(e, "a", e), e;
+          }, r.o = function(t, e) {
+            return Object.prototype.hasOwnProperty.call(t, e);
+          }, r.p = "", r(r.s = 1);
+        }([
+          /* 0 */
+          /***/
+          function(A, d) {
+            A.exports = f;
+          },
+          /* 1 */
+          /***/
+          function(A, d, r) {
+            var t = r(0).layoutBase.LayoutConstants, e = r(0).layoutBase.FDLayoutConstants, i = r(0).CoSEConstants, o = r(0).CoSELayout, g = r(0).CoSENode, a = r(0).layoutBase.PointD, y = r(0).layoutBase.DimensionD, n = {
+              // Called on `layoutready`
+              ready: /* @__PURE__ */ N(function() {
+              }, "ready"),
+              // Called on `layoutstop`
+              stop: /* @__PURE__ */ N(function() {
+              }, "stop"),
+              // 'draft', 'default' or 'proof" 
+              // - 'draft' fast cooling rate 
+              // - 'default' moderate cooling rate 
+              // - "proof" slow cooling rate
+              quality: "default",
+              // include labels in node dimensions
+              nodeDimensionsIncludeLabels: !1,
+              // number of ticks per frame; higher is faster but more jerky
+              refresh: 30,
+              // Whether to fit the network view after when done
+              fit: !0,
+              // Padding on fit
+              padding: 10,
+              // Whether to enable incremental mode
+              randomize: !0,
+              // Node repulsion (non overlapping) multiplier
+              nodeRepulsion: 4500,
+              // Ideal edge (non nested) length
+              idealEdgeLength: 50,
+              // Divisor to compute edge forces
+              edgeElasticity: 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,
+              // Type of layout animation. The option set is {'during', 'end', false}
+              animate: "end",
+              // Duration for animate:end
+              animationDuration: 500,
+              // 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.5
+            };
+            function h(D, L) {
+              var I = {};
+              for (var v in D)
+                I[v] = D[v];
+              for (var v in L)
+                I[v] = L[v];
+              return I;
+            }
+            N(h, "extend");
+            function l(D) {
+              this.options = h(n, D), E(this.options);
+            }
+            N(l, "_CoSELayout");
+            var E = /* @__PURE__ */ N(function(L) {
+              L.nodeRepulsion != null && (i.DEFAULT_REPULSION_STRENGTH = e.DEFAULT_REPULSION_STRENGTH = L.nodeRepulsion), L.idealEdgeLength != null && (i.DEFAULT_EDGE_LENGTH = e.DEFAULT_EDGE_LENGTH = L.idealEdgeLength), L.edgeElasticity != null && (i.DEFAULT_SPRING_STRENGTH = e.DEFAULT_SPRING_STRENGTH = L.edgeElasticity), L.nestingFactor != null && (i.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = e.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = L.nestingFactor), L.gravity != null && (i.DEFAULT_GRAVITY_STRENGTH = e.DEFAULT_GRAVITY_STRENGTH = L.gravity), L.numIter != null && (i.MAX_ITERATIONS = e.MAX_ITERATIONS = L.numIter), L.gravityRange != null && (i.DEFAULT_GRAVITY_RANGE_FACTOR = e.DEFAULT_GRAVITY_RANGE_FACTOR = L.gravityRange), L.gravityCompound != null && (i.DEFAULT_COMPOUND_GRAVITY_STRENGTH = e.DEFAULT_COMPOUND_GRAVITY_STRENGTH = L.gravityCompound), L.gravityRangeCompound != null && (i.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = e.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = L.gravityRangeCompound), L.initialEnergyOnIncremental != null && (i.DEFAULT_COOLING_FACTOR_INCREMENTAL = e.DEFAULT_COOLING_FACTOR_INCREMENTAL = L.initialEnergyOnIncremental), L.quality == "draft" ? t.QUALITY = 0 : L.quality == "proof" ? t.QUALITY = 2 : t.QUALITY = 1, i.NODE_DIMENSIONS_INCLUDE_LABELS = e.NODE_DIMENSIONS_INCLUDE_LABELS = t.NODE_DIMENSIONS_INCLUDE_LABELS = L.nodeDimensionsIncludeLabels, i.DEFAULT_INCREMENTAL = e.DEFAULT_INCREMENTAL = t.DEFAULT_INCREMENTAL = !L.randomize, i.ANIMATE = e.ANIMATE = t.ANIMATE = L.animate, i.TILE = L.tile, i.TILING_PADDING_VERTICAL = typeof L.tilingPaddingVertical == "function" ? L.tilingPaddingVertical.call() : L.tilingPaddingVertical, i.TILING_PADDING_HORIZONTAL = typeof L.tilingPaddingHorizontal == "function" ? L.tilingPaddingHorizontal.call() : L.tilingPaddingHorizontal;
+            }, "getUserOptions");
+            l.prototype.run = function() {
+              var D, L, I = this.options;
+              this.idToLNode = {};
+              var v = this.layout = new o(), m = this;
+              m.stopped = !1, this.cy = this.options.cy, this.cy.trigger({ type: "layoutstart", layout: this });
+              var s = v.newGraphManager();
+              this.gm = s;
+              var c = this.options.eles.nodes(), u = this.options.eles.edges();
+              this.root = s.addRoot(), this.processChildrenList(this.root, this.getTopMostNodes(c), v);
+              for (var p = 0; p < u.length; p++) {
+                var C = u[p], R = this.idToLNode[C.data("source")], M = this.idToLNode[C.data("target")];
+                if (R !== M && R.getEdgesBetween(M).length == 0) {
+                  var w = s.add(v.newEdge(), R, M);
+                  w.id = C.id();
+                }
+              }
+              var G = /* @__PURE__ */ N(function(_, S) {
+                typeof _ == "number" && (_ = S);
+                var F = _.data("id"), b = m.idToLNode[F];
+                return {
+                  x: b.getRect().getCenterX(),
+                  y: b.getRect().getCenterY()
+                };
+              }, "getPositions"), U = /* @__PURE__ */ N(function X() {
+                for (var _ = /* @__PURE__ */ N(function() {
+                  I.fit && I.cy.fit(I.eles, I.padding), D || (D = !0, m.cy.one("layoutready", I.ready), m.cy.trigger({ type: "layoutready", layout: m }));
+                }, "afterReposition"), S = m.options.refresh, F, b = 0; b < S && !F; b++)
+                  F = m.stopped || m.layout.tick();
+                if (F) {
+                  v.checkLayoutSuccess() && !v.isSubLayout && v.doPostLayout(), v.tilingPostLayout && v.tilingPostLayout(), v.isLayoutFinished = !0, m.options.eles.nodes().positions(G), _(), m.cy.one("layoutstop", m.options.stop), m.cy.trigger({ type: "layoutstop", layout: m }), L && cancelAnimationFrame(L), D = !1;
+                  return;
+                }
+                var Y = m.layout.getPositionsData();
+                I.eles.nodes().positions(function(k, H) {
+                  if (typeof k == "number" && (k = H), !k.isParent()) {
+                    for (var P = k.id(), B = Y[P], $ = k; B == null && (B = Y[$.data("parent")] || Y["DummyCompound_" + $.data("parent")], Y[P] = B, $ = $.parent()[0], $ != null); )
+                      ;
+                    return B != null ? {
+                      x: B.x,
+                      y: B.y
+                    } : {
+                      x: k.position("x"),
+                      y: k.position("y")
+                    };
+                  }
+                }), _(), L = requestAnimationFrame(X);
+              }, "iterateAnimated");
+              return v.addListener("layoutstarted", function() {
+                m.options.animate === "during" && (L = requestAnimationFrame(U));
+              }), v.runLayout(), this.options.animate !== "during" && (m.options.eles.nodes().not(":parent").layoutPositions(m, m.options, G), D = !1), this;
+            }, l.prototype.getTopMostNodes = function(D) {
+              for (var L = {}, I = 0; I < D.length; I++)
+                L[D[I].id()] = !0;
+              var v = D.filter(function(m, s) {
+                typeof m == "number" && (m = s);
+                for (var c = m.parent()[0]; c != null; ) {
+                  if (L[c.id()])
+                    return !1;
+                  c = c.parent()[0];
+                }
+                return !0;
+              });
+              return v;
+            }, l.prototype.processChildrenList = function(D, L, I) {
+              for (var v = L.length, m = 0; m < v; m++) {
+                var s = L[m], c = s.children(), u, p = s.layoutDimensions({
+                  nodeDimensionsIncludeLabels: this.options.nodeDimensionsIncludeLabels
+                });
+                if (s.outerWidth() != null && s.outerHeight() != null ? u = D.add(new g(I.graphManager, new a(s.position("x") - p.w / 2, s.position("y") - p.h / 2), new y(parseFloat(p.w), parseFloat(p.h)))) : u = D.add(new g(this.graphManager)), u.id = s.data("id"), u.paddingLeft = parseInt(s.css("padding")), u.paddingTop = parseInt(s.css("padding")), u.paddingRight = parseInt(s.css("padding")), u.paddingBottom = parseInt(s.css("padding")), this.options.nodeDimensionsIncludeLabels && s.isParent()) {
+                  var C = s.boundingBox({ includeLabels: !0, includeNodes: !1 }).w, R = s.boundingBox({ includeLabels: !0, includeNodes: !1 }).h, M = s.css("text-halign");
+                  u.labelWidth = C, u.labelHeight = R, u.labelPos = M;
+                }
+                if (this.idToLNode[s.data("id")] = u, isNaN(u.rect.x) && (u.rect.x = 0), isNaN(u.rect.y) && (u.rect.y = 0), c != null && c.length > 0) {
+                  var w;
+                  w = I.getGraphManager().add(I.newGraph(), u), this.processChildrenList(w, c, I);
+                }
+              }
+            }, l.prototype.stop = function() {
+              return this.stopped = !0, this;
+            };
+            var T = /* @__PURE__ */ N(function(L) {
+              L("layout", "cose-bilkent", l);
+            }, "register");
+            typeof cytoscape < "u" && T(cytoscape), A.exports = T;
+          }
+          /******/
+        ])
+      );
+    });
+  }
+}), it = function() {
+  var O = /* @__PURE__ */ N(function(I, v, m, s) {
+    for (m = m || {}, s = I.length; s--; m[I[s]] = v) ;
+    return m;
+  }, "o"), x = [1, 4], f = [1, 13], A = [1, 12], d = [1, 15], r = [1, 16], t = [1, 20], e = [1, 19], i = [6, 7, 8], o = [1, 26], g = [1, 24], a = [1, 25], y = [6, 7, 11], n = [1, 6, 13, 15, 16, 19, 22], h = [1, 33], l = [1, 34], E = [1, 6, 7, 11, 13, 15, 16, 19, 22], T = {
+    trace: /* @__PURE__ */ N(function() {
+    }, "trace"),
+    yy: {},
+    symbols_: { error: 2, start: 3, mindMap: 4, spaceLines: 5, SPACELINE: 6, NL: 7, MINDMAP: 8, document: 9, stop: 10, EOF: 11, statement: 12, SPACELIST: 13, node: 14, ICON: 15, CLASS: 16, nodeWithId: 17, nodeWithoutId: 18, NODE_DSTART: 19, NODE_DESCR: 20, NODE_DEND: 21, NODE_ID: 22, $accept: 0, $end: 1 },
+    terminals_: { 2: "error", 6: "SPACELINE", 7: "NL", 8: "MINDMAP", 11: "EOF", 13: "SPACELIST", 15: "ICON", 16: "CLASS", 19: "NODE_DSTART", 20: "NODE_DESCR", 21: "NODE_DEND", 22: "NODE_ID" },
+    productions_: [0, [3, 1], [3, 2], [5, 1], [5, 2], [5, 2], [4, 2], [4, 3], [10, 1], [10, 1], [10, 1], [10, 2], [10, 2], [9, 3], [9, 2], [12, 2], [12, 2], [12, 2], [12, 1], [12, 1], [12, 1], [12, 1], [12, 1], [14, 1], [14, 1], [18, 3], [17, 1], [17, 4]],
+    performAction: /* @__PURE__ */ N(function(v, m, s, c, u, p, C) {
+      var R = p.length - 1;
+      switch (u) {
+        case 6:
+        case 7:
+          return c;
+        case 8:
+          c.getLogger().trace("Stop NL ");
+          break;
+        case 9:
+          c.getLogger().trace("Stop EOF ");
+          break;
+        case 11:
+          c.getLogger().trace("Stop NL2 ");
+          break;
+        case 12:
+          c.getLogger().trace("Stop EOF2 ");
+          break;
+        case 15:
+          c.getLogger().info("Node: ", p[R].id), c.addNode(p[R - 1].length, p[R].id, p[R].descr, p[R].type);
+          break;
+        case 16:
+          c.getLogger().trace("Icon: ", p[R]), c.decorateNode({ icon: p[R] });
+          break;
+        case 17:
+        case 21:
+          c.decorateNode({ class: p[R] });
+          break;
+        case 18:
+          c.getLogger().trace("SPACELIST");
+          break;
+        case 19:
+          c.getLogger().trace("Node: ", p[R].id), c.addNode(0, p[R].id, p[R].descr, p[R].type);
+          break;
+        case 20:
+          c.decorateNode({ icon: p[R] });
+          break;
+        case 25:
+          c.getLogger().trace("node found ..", p[R - 2]), this.$ = { id: p[R - 1], descr: p[R - 1], type: c.getType(p[R - 2], p[R]) };
+          break;
+        case 26:
+          this.$ = { id: p[R], descr: p[R], type: c.nodeType.DEFAULT };
+          break;
+        case 27:
+          c.getLogger().trace("node found ..", p[R - 3]), this.$ = { id: p[R - 3], descr: p[R - 1], type: c.getType(p[R - 2], p[R]) };
+          break;
+      }
+    }, "anonymous"),
+    table: [{ 3: 1, 4: 2, 5: 3, 6: [1, 5], 8: x }, { 1: [3] }, { 1: [2, 1] }, { 4: 6, 6: [1, 7], 7: [1, 8], 8: x }, { 6: f, 7: [1, 10], 9: 9, 12: 11, 13: A, 14: 14, 15: d, 16: r, 17: 17, 18: 18, 19: t, 22: e }, O(i, [2, 3]), { 1: [2, 2] }, O(i, [2, 4]), O(i, [2, 5]), { 1: [2, 6], 6: f, 12: 21, 13: A, 14: 14, 15: d, 16: r, 17: 17, 18: 18, 19: t, 22: e }, { 6: f, 9: 22, 12: 11, 13: A, 14: 14, 15: d, 16: r, 17: 17, 18: 18, 19: t, 22: e }, { 6: o, 7: g, 10: 23, 11: a }, O(y, [2, 22], { 17: 17, 18: 18, 14: 27, 15: [1, 28], 16: [1, 29], 19: t, 22: e }), O(y, [2, 18]), O(y, [2, 19]), O(y, [2, 20]), O(y, [2, 21]), O(y, [2, 23]), O(y, [2, 24]), O(y, [2, 26], { 19: [1, 30] }), { 20: [1, 31] }, { 6: o, 7: g, 10: 32, 11: a }, { 1: [2, 7], 6: f, 12: 21, 13: A, 14: 14, 15: d, 16: r, 17: 17, 18: 18, 19: t, 22: e }, O(n, [2, 14], { 7: h, 11: l }), O(E, [2, 8]), O(E, [2, 9]), O(E, [2, 10]), O(y, [2, 15]), O(y, [2, 16]), O(y, [2, 17]), { 20: [1, 35] }, { 21: [1, 36] }, O(n, [2, 13], { 7: h, 11: l }), O(E, [2, 11]), O(E, [2, 12]), { 21: [1, 37] }, O(y, [2, 25]), O(y, [2, 27])],
+    defaultActions: { 2: [2, 1], 6: [2, 2] },
+    parseError: /* @__PURE__ */ N(function(v, m) {
+      if (m.recoverable)
+        this.trace(v);
+      else {
+        var s = new Error(v);
+        throw s.hash = m, s;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ N(function(v) {
+      var m = this, s = [0], c = [], u = [null], p = [], C = this.table, R = "", M = 0, w = 0, G = 2, U = 1, X = p.slice.call(arguments, 1), _ = Object.create(this.lexer), S = { yy: {} };
+      for (var F in this.yy)
+        Object.prototype.hasOwnProperty.call(this.yy, F) && (S.yy[F] = this.yy[F]);
+      _.setInput(v, S.yy), S.yy.lexer = _, S.yy.parser = this, typeof _.yylloc > "u" && (_.yylloc = {});
+      var b = _.yylloc;
+      p.push(b);
+      var Y = _.options && _.options.ranges;
+      typeof S.yy.parseError == "function" ? this.parseError = S.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function k(V) {
+        s.length = s.length - 2 * V, u.length = u.length - V, p.length = p.length - V;
+      }
+      N(k, "popStack");
+      function H() {
+        var V;
+        return V = c.pop() || _.lex() || U, typeof V != "number" && (V instanceof Array && (c = V, V = c.pop()), V = m.symbols_[V] || V), V;
+      }
+      N(H, "lex");
+      for (var P, B, $, K, j = {}, q, Q, lt, J; ; ) {
+        if (B = s[s.length - 1], this.defaultActions[B] ? $ = this.defaultActions[B] : ((P === null || typeof P > "u") && (P = H()), $ = C[B] && C[B][P]), typeof $ > "u" || !$.length || !$[0]) {
+          var rt = "";
+          J = [];
+          for (q in C[B])
+            this.terminals_[q] && q > G && J.push("'" + this.terminals_[q] + "'");
+          _.showPosition ? rt = "Parse error on line " + (M + 1) + `:
+` + _.showPosition() + `
+Expecting ` + J.join(", ") + ", got '" + (this.terminals_[P] || P) + "'" : rt = "Parse error on line " + (M + 1) + ": Unexpected " + (P == U ? "end of input" : "'" + (this.terminals_[P] || P) + "'"), this.parseError(rt, {
+            text: _.match,
+            token: this.terminals_[P] || P,
+            line: _.yylineno,
+            loc: b,
+            expected: J
+          });
+        }
+        if ($[0] instanceof Array && $.length > 1)
+          throw new Error("Parse Error: multiple actions possible at state: " + B + ", token: " + P);
+        switch ($[0]) {
+          case 1:
+            s.push(P), u.push(_.yytext), p.push(_.yylloc), s.push($[1]), P = null, w = _.yyleng, R = _.yytext, M = _.yylineno, b = _.yylloc;
+            break;
+          case 2:
+            if (Q = this.productions_[$[1]][1], j.$ = u[u.length - Q], j._$ = {
+              first_line: p[p.length - (Q || 1)].first_line,
+              last_line: p[p.length - 1].last_line,
+              first_column: p[p.length - (Q || 1)].first_column,
+              last_column: p[p.length - 1].last_column
+            }, Y && (j._$.range = [
+              p[p.length - (Q || 1)].range[0],
+              p[p.length - 1].range[1]
+            ]), K = this.performAction.apply(j, [
+              R,
+              w,
+              M,
+              S.yy,
+              $[1],
+              u,
+              p
+            ].concat(X)), typeof K < "u")
+              return K;
+            Q && (s = s.slice(0, -1 * Q * 2), u = u.slice(0, -1 * Q), p = p.slice(0, -1 * Q)), s.push(this.productions_[$[1]][0]), u.push(j.$), p.push(j._$), lt = C[s[s.length - 2]][s[s.length - 1]], s.push(lt);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }, "parse")
+  }, D = /* @__PURE__ */ function() {
+    var I = {
+      EOF: 1,
+      parseError: /* @__PURE__ */ N(function(m, s) {
+        if (this.yy.parser)
+          this.yy.parser.parseError(m, s);
+        else
+          throw new Error(m);
+      }, "parseError"),
+      // resets the lexer, sets new input
+      setInput: /* @__PURE__ */ N(function(v, m) {
+        return this.yy = m || this.yy || {}, this._input = v, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = ["INITIAL"], this.yylloc = {
+          first_line: 1,
+          first_column: 0,
+          last_line: 1,
+          last_column: 0
+        }, this.options.ranges && (this.yylloc.range = [0, 0]), this.offset = 0, this;
+      }, "setInput"),
+      // consumes and returns one char from the input
+      input: /* @__PURE__ */ N(function() {
+        var v = this._input[0];
+        this.yytext += v, this.yyleng++, this.offset++, this.match += v, this.matched += v;
+        var m = v.match(/(?:\r\n?|\n).*/g);
+        return m ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), v;
+      }, "input"),
+      // unshifts one char (or a string) into the input
+      unput: /* @__PURE__ */ N(function(v) {
+        var m = v.length, s = v.split(/(?:\r\n?|\n)/g);
+        this._input = v + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - m), this.offset -= m;
+        var c = this.match.split(/(?:\r\n?|\n)/g);
+        this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), s.length - 1 && (this.yylineno -= s.length - 1);
+        var u = this.yylloc.range;
+        return this.yylloc = {
+          first_line: this.yylloc.first_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.first_column,
+          last_column: s ? (s.length === c.length ? this.yylloc.first_column : 0) + c[c.length - s.length].length - s[0].length : this.yylloc.first_column - m
+        }, this.options.ranges && (this.yylloc.range = [u[0], u[0] + this.yyleng - m]), this.yyleng = this.yytext.length, this;
+      }, "unput"),
+      // When called from action, caches matched text and appends it on next action
+      more: /* @__PURE__ */ N(function() {
+        return this._more = !0, this;
+      }, "more"),
+      // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+      reject: /* @__PURE__ */ N(function() {
+        if (this.options.backtrack_lexer)
+          this._backtrack = !0;
+        else
+          return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+` + this.showPosition(), {
+            text: "",
+            token: null,
+            line: this.yylineno
+          });
+        return this;
+      }, "reject"),
+      // retain first n characters of the match
+      less: /* @__PURE__ */ N(function(v) {
+        this.unput(this.match.slice(v));
+      }, "less"),
+      // displays already matched input, i.e. for error messages
+      pastInput: /* @__PURE__ */ N(function() {
+        var v = this.matched.substr(0, this.matched.length - this.match.length);
+        return (v.length > 20 ? "..." : "") + v.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      // displays upcoming input, i.e. for error messages
+      upcomingInput: /* @__PURE__ */ N(function() {
+        var v = this.match;
+        return v.length < 20 && (v += this._input.substr(0, 20 - v.length)), (v.substr(0, 20) + (v.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      // displays the character position where the lexing error occurred, i.e. for error messages
+      showPosition: /* @__PURE__ */ N(function() {
+        var v = this.pastInput(), m = new Array(v.length + 1).join("-");
+        return v + this.upcomingInput() + `
+` + m + "^";
+      }, "showPosition"),
+      // test the lexed token: return FALSE when not a match, otherwise return token
+      test_match: /* @__PURE__ */ N(function(v, m) {
+        var s, c, u;
+        if (this.options.backtrack_lexer && (u = {
+          yylineno: this.yylineno,
+          yylloc: {
+            first_line: this.yylloc.first_line,
+            last_line: this.last_line,
+            first_column: this.yylloc.first_column,
+            last_column: this.yylloc.last_column
+          },
+          yytext: this.yytext,
+          match: this.match,
+          matches: this.matches,
+          matched: this.matched,
+          yyleng: this.yyleng,
+          offset: this.offset,
+          _more: this._more,
+          _input: this._input,
+          yy: this.yy,
+          conditionStack: this.conditionStack.slice(0),
+          done: this.done
+        }, this.options.ranges && (u.yylloc.range = this.yylloc.range.slice(0))), c = v[0].match(/(?:\r\n?|\n).*/g), c && (this.yylineno += c.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: c ? c[c.length - 1].length - c[c.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + v[0].length
+        }, this.yytext += v[0], this.match += v[0], this.matches = v, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(v[0].length), this.matched += v[0], s = this.performAction.call(this, this.yy, this, m, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), s)
+          return s;
+        if (this._backtrack) {
+          for (var p in u)
+            this[p] = u[p];
+          return !1;
+        }
+        return !1;
+      }, "test_match"),
+      // return next match in input
+      next: /* @__PURE__ */ N(function() {
+        if (this.done)
+          return this.EOF;
+        this._input || (this.done = !0);
+        var v, m, s, c;
+        this._more || (this.yytext = "", this.match = "");
+        for (var u = this._currentRules(), p = 0; p < u.length; p++)
+          if (s = this._input.match(this.rules[u[p]]), s && (!m || s[0].length > m[0].length)) {
+            if (m = s, c = p, this.options.backtrack_lexer) {
+              if (v = this.test_match(s, u[p]), v !== !1)
+                return v;
+              if (this._backtrack) {
+                m = !1;
+                continue;
+              } else
+                return !1;
+            } else if (!this.options.flex)
+              break;
+          }
+        return m ? (v = this.test_match(m, u[c]), v !== !1 ? v : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      }, "next"),
+      // return next match that has a token
+      lex: /* @__PURE__ */ N(function() {
+        var m = this.next();
+        return m || this.lex();
+      }, "lex"),
+      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+      begin: /* @__PURE__ */ N(function(m) {
+        this.conditionStack.push(m);
+      }, "begin"),
+      // pop the previously active lexer condition state off the condition stack
+      popState: /* @__PURE__ */ N(function() {
+        var m = this.conditionStack.length - 1;
+        return m > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      }, "popState"),
+      // produce the lexer rule set which is active for the currently active lexer condition state
+      _currentRules: /* @__PURE__ */ N(function() {
+        return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+      }, "_currentRules"),
+      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+      topState: /* @__PURE__ */ N(function(m) {
+        return m = this.conditionStack.length - 1 - Math.abs(m || 0), m >= 0 ? this.conditionStack[m] : "INITIAL";
+      }, "topState"),
+      // alias for begin(condition)
+      pushState: /* @__PURE__ */ N(function(m) {
+        this.begin(m);
+      }, "pushState"),
+      // return the number of states currently on the stack
+      stateStackSize: /* @__PURE__ */ N(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: { "case-insensitive": !0 },
+      performAction: /* @__PURE__ */ N(function(m, s, c, u) {
+        switch (c) {
+          case 0:
+            return m.getLogger().trace("Found comment", s.yytext), 6;
+          case 1:
+            return 8;
+          case 2:
+            this.begin("CLASS");
+            break;
+          case 3:
+            return this.popState(), 16;
+          case 4:
+            this.popState();
+            break;
+          case 5:
+            m.getLogger().trace("Begin icon"), this.begin("ICON");
+            break;
+          case 6:
+            return m.getLogger().trace("SPACELINE"), 6;
+          case 7:
+            return 7;
+          case 8:
+            return 15;
+          case 9:
+            m.getLogger().trace("end icon"), this.popState();
+            break;
+          case 10:
+            return m.getLogger().trace("Exploding node"), this.begin("NODE"), 19;
+          case 11:
+            return m.getLogger().trace("Cloud"), this.begin("NODE"), 19;
+          case 12:
+            return m.getLogger().trace("Explosion Bang"), this.begin("NODE"), 19;
+          case 13:
+            return m.getLogger().trace("Cloud Bang"), this.begin("NODE"), 19;
+          case 14:
+            return this.begin("NODE"), 19;
+          case 15:
+            return this.begin("NODE"), 19;
+          case 16:
+            return this.begin("NODE"), 19;
+          case 17:
+            return this.begin("NODE"), 19;
+          case 18:
+            return 13;
+          case 19:
+            return 22;
+          case 20:
+            return 11;
+          case 21:
+            this.begin("NSTR2");
+            break;
+          case 22:
+            return "NODE_DESCR";
+          case 23:
+            this.popState();
+            break;
+          case 24:
+            m.getLogger().trace("Starting NSTR"), this.begin("NSTR");
+            break;
+          case 25:
+            return m.getLogger().trace("description:", s.yytext), "NODE_DESCR";
+          case 26:
+            this.popState();
+            break;
+          case 27:
+            return this.popState(), m.getLogger().trace("node end ))"), "NODE_DEND";
+          case 28:
+            return this.popState(), m.getLogger().trace("node end )"), "NODE_DEND";
+          case 29:
+            return this.popState(), m.getLogger().trace("node end ...", s.yytext), "NODE_DEND";
+          case 30:
+            return this.popState(), m.getLogger().trace("node end (("), "NODE_DEND";
+          case 31:
+            return this.popState(), m.getLogger().trace("node end (-"), "NODE_DEND";
+          case 32:
+            return this.popState(), m.getLogger().trace("node end (-"), "NODE_DEND";
+          case 33:
+            return this.popState(), m.getLogger().trace("node end (("), "NODE_DEND";
+          case 34:
+            return this.popState(), m.getLogger().trace("node end (("), "NODE_DEND";
+          case 35:
+            return m.getLogger().trace("Long description:", s.yytext), 20;
+          case 36:
+            return m.getLogger().trace("Long description:", s.yytext), 20;
+        }
+      }, "anonymous"),
+      rules: [/^(?:\s*%%.*)/i, /^(?:mindmap\b)/i, /^(?::::)/i, /^(?:.+)/i, /^(?:\n)/i, /^(?:::icon\()/i, /^(?:[\s]+[\n])/i, /^(?:[\n]+)/i, /^(?:[^\)]+)/i, /^(?:\))/i, /^(?:-\))/i, /^(?:\(-)/i, /^(?:\)\))/i, /^(?:\))/i, /^(?:\(\()/i, /^(?:\{\{)/i, /^(?:\()/i, /^(?:\[)/i, /^(?:[\s]+)/i, /^(?:[^\(\[\n\)\{\}]+)/i, /^(?:$)/i, /^(?:["][`])/i, /^(?:[^`"]+)/i, /^(?:[`]["])/i, /^(?:["])/i, /^(?:[^"]+)/i, /^(?:["])/i, /^(?:[\)]\))/i, /^(?:[\)])/i, /^(?:[\]])/i, /^(?:\}\})/i, /^(?:\(-)/i, /^(?:-\))/i, /^(?:\(\()/i, /^(?:\()/i, /^(?:[^\)\]\(\}]+)/i, /^(?:.+(?!\(\())/i],
+      conditions: { CLASS: { rules: [3, 4], inclusive: !1 }, ICON: { rules: [8, 9], inclusive: !1 }, NSTR2: { rules: [22, 23], inclusive: !1 }, NSTR: { rules: [25, 26], inclusive: !1 }, NODE: { rules: [21, 24, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], inclusive: !1 }, INITIAL: { rules: [0, 1, 2, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], inclusive: !0 } }
+    };
+    return I;
+  }();
+  T.lexer = D;
+  function L() {
+    this.yy = {};
+  }
+  return N(L, "Parser"), L.prototype = T, T.Parser = L, new L();
+}();
+it.parser = it;
+var Rt = it, Z = [], ft = 0, at = {}, Mt = /* @__PURE__ */ N(() => {
+  Z = [], ft = 0, at = {};
+}, "clear"), wt = /* @__PURE__ */ N(function(O) {
+  for (let x = Z.length - 1; x >= 0; x--)
+    if (Z[x].level < O)
+      return Z[x];
+  return null;
+}, "getParent"), xt = /* @__PURE__ */ N(() => Z.length > 0 ? Z[0] : null, "getMindmap"), _t = /* @__PURE__ */ N((O, x, f, A) => {
+  z.info("addNode", O, x, f, A);
+  const d = nt();
+  let r = d.mindmap?.padding ?? tt.mindmap.padding;
+  switch (A) {
+    case W.ROUNDED_RECT:
+    case W.RECT:
+    case W.HEXAGON:
+      r *= 2;
+  }
+  const t = {
+    id: ft++,
+    nodeId: et(x, d),
+    level: O,
+    descr: et(f, d),
+    type: A,
+    children: [],
+    width: d.mindmap?.maxNodeWidth ?? tt.mindmap.maxNodeWidth,
+    padding: r
+  }, e = wt(O);
+  if (e)
+    e.children.push(t), Z.push(t);
+  else if (Z.length === 0)
+    Z.push(t);
+  else
+    throw new Error(
+      'There can be only one root. No parent could be found for ("' + t.descr + '")'
+    );
+}, "addNode"), W = {
+  DEFAULT: 0,
+  NO_BORDER: 0,
+  ROUNDED_RECT: 1,
+  RECT: 2,
+  CIRCLE: 3,
+  CLOUD: 4,
+  BANG: 5,
+  HEXAGON: 6
+}, St = /* @__PURE__ */ N((O, x) => {
+  switch (z.debug("In get type", O, x), O) {
+    case "[":
+      return W.RECT;
+    case "(":
+      return x === ")" ? W.ROUNDED_RECT : W.CLOUD;
+    case "((":
+      return W.CIRCLE;
+    case ")":
+      return W.CLOUD;
+    case "))":
+      return W.BANG;
+    case "{{":
+      return W.HEXAGON;
+    default:
+      return W.DEFAULT;
+  }
+}, "getType"), Gt = /* @__PURE__ */ N((O, x) => {
+  at[O] = x;
+}, "setElementForId"), Ft = /* @__PURE__ */ N((O) => {
+  if (!O)
+    return;
+  const x = nt(), f = Z[Z.length - 1];
+  O.icon && (f.icon = et(O.icon, x)), O.class && (f.class = et(O.class, x));
+}, "decorateNode"), bt = /* @__PURE__ */ N((O) => {
+  switch (O) {
+    case W.DEFAULT:
+      return "no-border";
+    case W.RECT:
+      return "rect";
+    case W.ROUNDED_RECT:
+      return "rounded-rect";
+    case W.CIRCLE:
+      return "circle";
+    case W.CLOUD:
+      return "cloud";
+    case W.BANG:
+      return "bang";
+    case W.HEXAGON:
+      return "hexgon";
+    // cspell: disable-line
+    default:
+      return "no-border";
+  }
+}, "type2Str"), Ut = /* @__PURE__ */ N(() => z, "getLogger"), Pt = /* @__PURE__ */ N((O) => at[O], "getElementById"), Yt = {
+  clear: Mt,
+  addNode: _t,
+  getMindmap: xt,
+  nodeType: W,
+  getType: St,
+  setElementForId: Gt,
+  decorateNode: Ft,
+  type2Str: bt,
+  getLogger: Ut,
+  getElementById: Pt
+}, Xt = Yt, kt = It(Ct()), Ht = 12, $t = /* @__PURE__ */ N(function(O, x, f, A) {
+  x.append("path").attr("id", "node-" + f.id).attr("class", "node-bkg node-" + O.type2Str(f.type)).attr(
+    "d",
+    `M0 ${f.height - 5} v${-f.height + 2 * 5} q0,-5 5,-5 h${f.width - 2 * 5} q5,0 5,5 v${f.height - 5} H0 Z`
+  ), x.append("line").attr("class", "node-line-" + A).attr("x1", 0).attr("y1", f.height).attr("x2", f.width).attr("y2", f.height);
+}, "defaultBkg"), Wt = /* @__PURE__ */ N(function(O, x, f) {
+  x.append("rect").attr("id", "node-" + f.id).attr("class", "node-bkg node-" + O.type2Str(f.type)).attr("height", f.height).attr("width", f.width);
+}, "rectBkg"), Bt = /* @__PURE__ */ N(function(O, x, f) {
+  const A = f.width, d = f.height, r = 0.15 * A, t = 0.25 * A, e = 0.35 * A, i = 0.2 * A;
+  x.append("path").attr("id", "node-" + f.id).attr("class", "node-bkg node-" + O.type2Str(f.type)).attr(
+    "d",
+    `M0 0 a${r},${r} 0 0,1 ${A * 0.25},${-1 * A * 0.1}
+      a${e},${e} 1 0,1 ${A * 0.4},${-1 * A * 0.1}
+      a${t},${t} 1 0,1 ${A * 0.35},${1 * A * 0.2}
+
+      a${r},${r} 1 0,1 ${A * 0.15},${1 * d * 0.35}
+      a${i},${i} 1 0,1 ${-1 * A * 0.15},${1 * d * 0.65}
+
+      a${t},${r} 1 0,1 ${-1 * A * 0.25},${A * 0.15}
+      a${e},${e} 1 0,1 ${-1 * A * 0.5},0
+      a${r},${r} 1 0,1 ${-1 * A * 0.25},${-1 * A * 0.15}
+
+      a${r},${r} 1 0,1 ${-1 * A * 0.1},${-1 * d * 0.35}
+      a${i},${i} 1 0,1 ${A * 0.1},${-1 * d * 0.65}
+
+    H0 V0 Z`
+  );
+}, "cloudBkg"), Vt = /* @__PURE__ */ N(function(O, x, f) {
+  const A = f.width, d = f.height, r = 0.15 * A;
+  x.append("path").attr("id", "node-" + f.id).attr("class", "node-bkg node-" + O.type2Str(f.type)).attr(
+    "d",
+    `M0 0 a${r},${r} 1 0,0 ${A * 0.25},${-1 * d * 0.1}
+      a${r},${r} 1 0,0 ${A * 0.25},0
+      a${r},${r} 1 0,0 ${A * 0.25},0
+      a${r},${r} 1 0,0 ${A * 0.25},${1 * d * 0.1}
+
+      a${r},${r} 1 0,0 ${A * 0.15},${1 * d * 0.33}
+      a${r * 0.8},${r * 0.8} 1 0,0 0,${1 * d * 0.34}
+      a${r},${r} 1 0,0 ${-1 * A * 0.15},${1 * d * 0.33}
+
+      a${r},${r} 1 0,0 ${-1 * A * 0.25},${d * 0.15}
+      a${r},${r} 1 0,0 ${-1 * A * 0.25},0
+      a${r},${r} 1 0,0 ${-1 * A * 0.25},0
+      a${r},${r} 1 0,0 ${-1 * A * 0.25},${-1 * d * 0.15}
+
+      a${r},${r} 1 0,0 ${-1 * A * 0.1},${-1 * d * 0.33}
+      a${r * 0.8},${r * 0.8} 1 0,0 0,${-1 * d * 0.34}
+      a${r},${r} 1 0,0 ${A * 0.1},${-1 * d * 0.33}
+
+    H0 V0 Z`
+  );
+}, "bangBkg"), Zt = /* @__PURE__ */ N(function(O, x, f) {
+  x.append("circle").attr("id", "node-" + f.id).attr("class", "node-bkg node-" + O.type2Str(f.type)).attr("r", f.width / 2);
+}, "circleBkg");
+function pt(O, x, f, A, d) {
+  return O.insert("polygon", ":first-child").attr(
+    "points",
+    A.map(function(r) {
+      return r.x + "," + r.y;
+    }).join(" ")
+  ).attr("transform", "translate(" + (d.width - x) / 2 + ", " + f + ")");
+}
+N(pt, "insertPolygonShape");
+var jt = /* @__PURE__ */ N(function(O, x, f) {
+  const A = f.height, r = A / 4, t = f.width - f.padding + 2 * r, e = [
+    { x: r, y: 0 },
+    { x: t - r, y: 0 },
+    { x: t, y: -A / 2 },
+    { x: t - r, y: -A },
+    { x: r, y: -A },
+    { x: 0, y: -A / 2 }
+  ];
+  pt(x, t, A, e, f);
+}, "hexagonBkg"), Qt = /* @__PURE__ */ N(function(O, x, f) {
+  x.append("rect").attr("id", "node-" + f.id).attr("class", "node-bkg node-" + O.type2Str(f.type)).attr("height", f.height).attr("rx", f.padding).attr("ry", f.padding).attr("width", f.width);
+}, "roundedRectBkg"), zt = /* @__PURE__ */ N(async function(O, x, f, A, d) {
+  const r = d.htmlLabels, t = A % (Ht - 1), e = x.append("g");
+  f.section = t;
+  let i = "section-" + t;
+  t < 0 && (i += " section-root"), e.attr("class", (f.class ? f.class + " " : "") + "mindmap-node " + i);
+  const o = e.append("g"), g = e.append("g"), a = f.descr.replace(/(<br\/*>)/g, `
+`);
+  await At(
+    g,
+    a,
+    {
+      useHtmlLabels: r,
+      width: f.width,
+      classes: "mindmap-node-label"
+    },
+    d
+  ), r || g.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "middle").attr("text-anchor", "middle");
+  const y = g.node().getBBox(), [n] = Ot(d.fontSize);
+  if (f.height = y.height + n * 1.1 * 0.5 + f.padding, f.width = y.width + 2 * f.padding, f.icon)
+    if (f.type === O.nodeType.CIRCLE)
+      f.height += 50, f.width += 50, e.append("foreignObject").attr("height", "50px").attr("width", f.width).attr("style", "text-align: center;").append("div").attr("class", "icon-container").append("i").attr("class", "node-icon-" + t + " " + f.icon), g.attr(
+        "transform",
+        "translate(" + f.width / 2 + ", " + (f.height / 2 - 1.5 * f.padding) + ")"
+      );
+    else {
+      f.width += 50;
+      const h = f.height;
+      f.height = Math.max(h, 60);
+      const l = Math.abs(f.height - h);
+      e.append("foreignObject").attr("width", "60px").attr("height", f.height).attr("style", "text-align: center;margin-top:" + l / 2 + "px;").append("div").attr("class", "icon-container").append("i").attr("class", "node-icon-" + t + " " + f.icon), g.attr(
+        "transform",
+        "translate(" + (25 + f.width / 2) + ", " + (l / 2 + f.padding / 2) + ")"
+      );
+    }
+  else if (r) {
+    const h = (f.width - y.width) / 2, l = (f.height - y.height) / 2;
+    g.attr("transform", "translate(" + h + ", " + l + ")");
+  } else {
+    const h = f.width / 2, l = f.padding / 2;
+    g.attr("transform", "translate(" + h + ", " + l + ")");
+  }
+  switch (f.type) {
+    case O.nodeType.DEFAULT:
+      $t(O, o, f, t);
+      break;
+    case O.nodeType.ROUNDED_RECT:
+      Qt(O, o, f, t);
+      break;
+    case O.nodeType.RECT:
+      Wt(O, o, f, t);
+      break;
+    case O.nodeType.CIRCLE:
+      o.attr("transform", "translate(" + f.width / 2 + ", " + +f.height / 2 + ")"), Zt(O, o, f, t);
+      break;
+    case O.nodeType.CLOUD:
+      Bt(O, o, f, t);
+      break;
+    case O.nodeType.BANG:
+      Vt(O, o, f, t);
+      break;
+    case O.nodeType.HEXAGON:
+      jt(O, o, f, t);
+      break;
+  }
+  return O.setElementForId(f.id, e), f.height;
+}, "drawNode"), Kt = /* @__PURE__ */ N(function(O, x) {
+  const f = O.getElementById(x.id), A = x.x || 0, d = x.y || 0;
+  f.attr("transform", "translate(" + A + "," + d + ")");
+}, "positionNode");
+ut.use(kt.default);
+async function ot(O, x, f, A, d) {
+  await zt(O, x, f, A, d), f.children && await Promise.all(
+    f.children.map(
+      (r, t) => ot(O, x, r, A < 0 ? t : A, d)
+    )
+  );
+}
+N(ot, "drawNodes");
+function dt(O, x) {
+  x.edges().map((f, A) => {
+    const d = f.data();
+    if (f[0]._private.bodyBounds) {
+      const r = f[0]._private.rscratch;
+      z.trace("Edge: ", A, d), O.insert("path").attr(
+        "d",
+        `M ${r.startX},${r.startY} L ${r.midX},${r.midY} L${r.endX},${r.endY} `
+      ).attr("class", "edge section-edge-" + d.section + " edge-depth-" + d.depth);
+    }
+  });
+}
+N(dt, "drawEdges");
+function ht(O, x, f, A) {
+  x.add({
+    group: "nodes",
+    data: {
+      id: O.id.toString(),
+      labelText: O.descr,
+      height: O.height,
+      width: O.width,
+      level: A,
+      nodeId: O.id,
+      padding: O.padding,
+      type: O.type
+    },
+    position: {
+      x: O.x,
+      y: O.y
+    }
+  }), O.children && O.children.forEach((d) => {
+    ht(d, x, f, A + 1), x.add({
+      group: "edges",
+      data: {
+        id: `${O.id}_${d.id}`,
+        source: O.id,
+        target: d.id,
+        depth: A,
+        section: d.section
+      }
+    });
+  });
+}
+N(ht, "addNodes");
+function vt(O, x) {
+  return new Promise((f) => {
+    const A = Dt("body").append("div").attr("id", "cy").attr("style", "display:none"), d = ut({
+      container: document.getElementById("cy"),
+      // container to render in
+      style: [
+        {
+          selector: "edge",
+          style: {
+            "curve-style": "bezier"
+          }
+        }
+      ]
+    });
+    A.remove(), ht(O, d, x, 0), d.nodes().forEach(function(r) {
+      r.layoutDimensions = () => {
+        const t = r.data();
+        return { w: t.width, h: t.height };
+      };
+    }), d.layout({
+      name: "cose-bilkent",
+      // @ts-ignore Types for cose-bilkent are not correct?
+      quality: "proof",
+      styleEnabled: !1,
+      animate: !1
+    }).run(), d.ready((r) => {
+      z.info("Ready", r), f(d);
+    });
+  });
+}
+N(vt, "layoutMindmap");
+function yt(O, x) {
+  x.nodes().map((f, A) => {
+    const d = f.data();
+    d.x = f.position().x, d.y = f.position().y, Kt(O, d);
+    const r = O.getElementById(d.nodeId);
+    z.info("Id:", A, "Position: (", f.position().x, ", ", f.position().y, ")", d), r.attr(
+      "transform",
+      `translate(${f.position().x - d.width / 2}, ${f.position().y - d.height / 2})`
+    ), r.attr("attr", `apa-${A})`);
+  });
+}
+N(yt, "positionNodes");
+var qt = /* @__PURE__ */ N(async (O, x, f, A) => {
+  z.debug(`Rendering mindmap diagram
+` + O);
+  const d = A.db, r = d.getMindmap();
+  if (!r)
+    return;
+  const t = nt();
+  t.htmlLabels = !1;
+  const e = Et(x), i = e.append("g");
+  i.attr("class", "mindmap-edges");
+  const o = e.append("g");
+  o.attr("class", "mindmap-nodes"), await ot(d, o, r, -1, t);
+  const g = await vt(r, t);
+  dt(i, g), yt(d, g), Lt(
+    void 0,
+    e,
+    t.mindmap?.padding ?? tt.mindmap.padding,
+    t.mindmap?.useMaxWidth ?? tt.mindmap.useMaxWidth
+  );
+}, "draw"), Jt = {
+  draw: qt
+}, te = /* @__PURE__ */ N((O) => {
+  let x = "";
+  for (let f = 0; f < O.THEME_COLOR_LIMIT; f++)
+    O["lineColor" + f] = O["lineColor" + f] || O["cScaleInv" + f], Tt(O["lineColor" + f]) ? O["lineColor" + f] = mt(O["lineColor" + f], 20) : O["lineColor" + f] = Nt(O["lineColor" + f], 20);
+  for (let f = 0; f < O.THEME_COLOR_LIMIT; f++) {
+    const A = "" + (17 - 3 * f);
+    x += `
+    .section-${f - 1} rect, .section-${f - 1} path, .section-${f - 1} circle, .section-${f - 1} polygon, .section-${f - 1} path  {
+      fill: ${O["cScale" + f]};
+    }
+    .section-${f - 1} text {
+     fill: ${O["cScaleLabel" + f]};
+    }
+    .node-icon-${f - 1} {
+      font-size: 40px;
+      color: ${O["cScaleLabel" + f]};
+    }
+    .section-edge-${f - 1}{
+      stroke: ${O["cScale" + f]};
+    }
+    .edge-depth-${f - 1}{
+      stroke-width: ${A};
+    }
+    .section-${f - 1} line {
+      stroke: ${O["cScaleInv" + f]} ;
+      stroke-width: 3;
+    }
+
+    .disabled, .disabled circle, .disabled text {
+      fill: lightgray;
+    }
+    .disabled text {
+      fill: #efefef;
+    }
+    `;
+  }
+  return x;
+}, "genSections"), ee = /* @__PURE__ */ N((O) => `
+  .edge {
+    stroke-width: 3;
+  }
+  ${te(O)}
+  .section-root rect, .section-root path, .section-root circle, .section-root polygon  {
+    fill: ${O.git0};
+  }
+  .section-root text {
+    fill: ${O.gitBranchLabel0};
+  }
+  .icon-container {
+    height:100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+  .edge {
+    fill: none;
+  }
+  .mindmap-node-label {
+    dy: 1em;
+    alignment-baseline: middle;
+    text-anchor: middle;
+    dominant-baseline: middle;
+    text-align: center;
+  }
+`, "getStyles"), re = ee, se = {
+  db: Xt,
+  renderer: Jt,
+  parser: Rt,
+  styles: re
+};
+export {
+  se as diagram
+};