@kestra-io/ui-libs 0.0.222 → 0.0.224

package/dist/VueFlowUtils-DKrM_RaI.js

@@ -0,0 +1,4513 @@
+import { useVueFlow as he, Position as $, MarkerType as zo } from "@vue-flow/core";
+import { D as le, E as Xs, F as ri, G as jo, H as ye, I as Ko, J as ni, K as ti, L as W, M as Ee, N as qe, O as ve, P as ae, Q as ii, R as Re, S as ai, T as Yo, U as Zs, V as $o, W as ue, X as Qs, Y as Xo, Z as Js, _ as Zo, $ as Qo, a0 as eo, a1 as ui, a2 as Jo, a3 as ef, a4 as rf, a5 as we, a6 as nf, a7 as tf, a8 as af, a9 as uf, aa as sf, ab as of, ac as ro, ad as ff, ae as df, B as cf, f as hf } from "./FlowYamlUtils-BnXiRqSX.js";
+import { getCurrentInstance as Ti } from "vue";
+import lf from "humanize-duration";
+import Ii from "moment";
+import vf from "moment-timezone";
+const zc = {
+  TASKS: "TASKS",
+  TRIGGERS: "TRIGGERS",
+  TASK_RUNNERS: "TASK_RUNNERS"
+}, jc = {
+  EDIT: "edit",
+  DELETE: "delete",
+  SHOW_DESCRIPTION: "showDescription",
+  COLLAPSE: "collapse",
+  EXPAND: "expand",
+  OPEN_LINK: "openLink",
+  ADD_TASK: "addTask",
+  SHOW_LOGS: "showLogs",
+  MOUSE_OVER: "mouseover",
+  MOUSE_LEAVE: "mouseleave",
+  ADD_ERROR: "addError",
+  EXPAND_DEPENDENCIES: "expandDependencies",
+  SHOW_CONDITION: "showCondition",
+  RUN_TASK: "runTask"
+}, ce = "cluster_", Kc = {
+  EXECUTIONS: "executions",
+  TASKRUNS: "taskruns"
+}, Yc = {
+  ALL: "all",
+  ERROR: "error",
+  HIDDEN: "hidden",
+  DEFAULT: "all"
+}, ne = {
+  TASK_WIDTH: 184,
+  TASK_HEIGHT: 44,
+  TRIGGER_WIDTH: 184,
+  TRIGGER_HEIGHT: 44,
+  DOT_WIDTH: 5,
+  DOT_HEIGHT: 5,
+  COLLAPSED_CLUSTER_WIDTH: 150,
+  COLLAPSED_CLUSTER_HEIGHT: 44,
+  TRIGGER_CLUSTER_WIDTH: 350,
+  TRIGGER_CLUSTER_HEIGHT: 180
+}, $c = {
+  STORAGE_KEY: "view-type",
+  SOURCE: "source",
+  SOURCE_TOPOLOGY: "source-topology",
+  SOURCE_DOC: "source-doc",
+  TOPOLOGY: "topology",
+  SOURCE_BLUEPRINTS: "source-blueprints"
+}, Xc = {
+  DISPLAY_EXECUTIONS_COLUMNS: "displayExecutionsColumns",
+  DISPLAY_FLOW_EXECUTIONS_COLUMNS: "displayFlowExecutionsColumns",
+  SELECTED_TENANT: "selectedTenant",
+  EXECUTE_FLOW_BEHAVIOUR: "executeFlowBehaviour",
+  SHOW_CHART: "showChart",
+  SHOW_FLOWS_CHART: "showFlowsChart",
+  SHOW_LOGS_CHART: "showLogsChart",
+  DEFAULT_NAMESPACE: "defaultNamespace",
+  LATEST_NAMESPACE: "latestNamespace",
+  PAGINATION_SIZE: "paginationSize",
+  IMPERSONATE: "impersonate",
+  EDITOR_VIEW_TYPE: "editorViewType"
+}, Zc = {
+  SAME_TAB: "same tab",
+  NEW_TAB: "new tab"
+}, Qc = {
+  INPROGRESS: "IN-PROGRESS"
+};
+var xe, Si;
+function pf() {
+  if (Si) return xe;
+  Si = 1;
+  function e(a) {
+    return function(u, n, r) {
+      for (var t = -1, s = Object(u), i = r(u), f = i.length; f--; ) {
+        var d = i[a ? f : ++t];
+        if (n(s[d], d, s) === !1)
+          break;
+      }
+      return u;
+    };
+  }
+  return xe = e, xe;
+}
+var Le, Ci;
+function si() {
+  if (Ci) return Le;
+  Ci = 1;
+  var e = pf(), a = e();
+  return Le = a, Le;
+}
+var ke, Oi;
+function oi() {
+  if (Oi) return ke;
+  Oi = 1;
+  var e = si(), a = le();
+  function u(n, r) {
+    return n && e(n, r, a);
+  }
+  return ke = u, ke;
+}
+var Pe, Ni;
+function _f() {
+  if (Ni) return Pe;
+  Ni = 1;
+  var e = "__lodash_hash_undefined__";
+  function a(u) {
+    return this.__data__.set(u, e), this;
+  }
+  return Pe = a, Pe;
+}
+var Me, Ai;
+function gf() {
+  if (Ai) return Me;
+  Ai = 1;
+  function e(a) {
+    return this.__data__.has(a);
+  }
+  return Me = e, Me;
+}
+var Fe, xi;
+function no() {
+  if (xi) return Fe;
+  xi = 1;
+  var e = Xs(), a = _f(), u = gf();
+  function n(r) {
+    var t = -1, s = r == null ? 0 : r.length;
+    for (this.__data__ = new e(); ++t < s; )
+      this.add(r[t]);
+  }
+  return n.prototype.add = n.prototype.push = a, n.prototype.has = u, Fe = n, Fe;
+}
+var Ge, Li;
+function mf() {
+  if (Li) return Ge;
+  Li = 1;
+  function e(a, u) {
+    for (var n = -1, r = a == null ? 0 : a.length; ++n < r; )
+      if (u(a[n], n, a))
+        return !0;
+    return !1;
+  }
+  return Ge = e, Ge;
+}
+var De, ki;
+function to() {
+  if (ki) return De;
+  ki = 1;
+  function e(a, u) {
+    return a.has(u);
+  }
+  return De = e, De;
+}
+var Ue, Pi;
+function io() {
+  if (Pi) return Ue;
+  Pi = 1;
+  var e = no(), a = mf(), u = to(), n = 1, r = 2;
+  function t(s, i, f, d, o, c) {
+    var h = f & n, l = s.length, y = i.length;
+    if (l != y && !(h && y > l))
+      return !1;
+    var p = c.get(s), v = c.get(i);
+    if (p && v)
+      return p == i && v == s;
+    var _ = -1, m = !0, g = f & r ? new e() : void 0;
+    for (c.set(s, i), c.set(i, s); ++_ < l; ) {
+      var b = s[_], E = i[_];
+      if (d)
+        var w = h ? d(E, b, _, i, s, c) : d(b, E, _, s, i, c);
+      if (w !== void 0) {
+        if (w)
+          continue;
+        m = !1;
+        break;
+      }
+      if (g) {
+        if (!a(i, function(q, S) {
+          if (!u(g, S) && (b === q || o(b, q, f, d, c)))
+            return g.push(S);
+        })) {
+          m = !1;
+          break;
+        }
+      } else if (!(b === E || o(b, E, f, d, c))) {
+        m = !1;
+        break;
+      }
+    }
+    return c.delete(s), c.delete(i), m;
+  }
+  return Ue = t, Ue;
+}
+var Be, Mi;
+function bf() {
+  if (Mi) return Be;
+  Mi = 1;
+  function e(a) {
+    var u = -1, n = Array(a.size);
+    return a.forEach(function(r, t) {
+      n[++u] = [t, r];
+    }), n;
+  }
+  return Be = e, Be;
+}
+var He, Fi;
+function fi() {
+  if (Fi) return He;
+  Fi = 1;
+  function e(a) {
+    var u = -1, n = Array(a.size);
+    return a.forEach(function(r) {
+      n[++u] = r;
+    }), n;
+  }
+  return He = e, He;
+}
+var We, Gi;
+function yf() {
+  if (Gi) return We;
+  Gi = 1;
+  var e = ri(), a = jo(), u = ye(), n = io(), r = bf(), t = fi(), s = 1, i = 2, f = "[object Boolean]", d = "[object Date]", o = "[object Error]", c = "[object Map]", h = "[object Number]", l = "[object RegExp]", y = "[object Set]", p = "[object String]", v = "[object Symbol]", _ = "[object ArrayBuffer]", m = "[object DataView]", g = e ? e.prototype : void 0, b = g ? g.valueOf : void 0;
+  function E(w, q, S, O, I, x, L) {
+    switch (S) {
+      case m:
+        if (w.byteLength != q.byteLength || w.byteOffset != q.byteOffset)
+          return !1;
+        w = w.buffer, q = q.buffer;
+      case _:
+        return !(w.byteLength != q.byteLength || !x(new a(w), new a(q)));
+      case f:
+      case d:
+      case h:
+        return u(+w, +q);
+      case o:
+        return w.name == q.name && w.message == q.message;
+      case l:
+      case p:
+        return w == q + "";
+      case c:
+        var k = r;
+      case y:
+        var P = O & s;
+        if (k || (k = t), w.size != q.size && !P)
+          return !1;
+        var F = L.get(w);
+        if (F)
+          return F == q;
+        O |= i, L.set(w, q);
+        var U = n(k(w), k(q), O, I, x, L);
+        return L.delete(w), U;
+      case v:
+        if (b)
+          return b.call(w) == b.call(q);
+    }
+    return !1;
+  }
+  return We = E, We;
+}
+var Ve, Di;
+function Ef() {
+  if (Di) return Ve;
+  Di = 1;
+  var e = Ko(), a = 1, u = Object.prototype, n = u.hasOwnProperty;
+  function r(t, s, i, f, d, o) {
+    var c = i & a, h = e(t), l = h.length, y = e(s), p = y.length;
+    if (l != p && !c)
+      return !1;
+    for (var v = l; v--; ) {
+      var _ = h[v];
+      if (!(c ? _ in s : n.call(s, _)))
+        return !1;
+    }
+    var m = o.get(t), g = o.get(s);
+    if (m && g)
+      return m == s && g == t;
+    var b = !0;
+    o.set(t, s), o.set(s, t);
+    for (var E = c; ++v < l; ) {
+      _ = h[v];
+      var w = t[_], q = s[_];
+      if (f)
+        var S = c ? f(q, w, _, s, t, o) : f(w, q, _, t, s, o);
+      if (!(S === void 0 ? w === q || d(w, q, i, f, o) : S)) {
+        b = !1;
+        break;
+      }
+      E || (E = _ == "constructor");
+    }
+    if (b && !E) {
+      var O = t.constructor, I = s.constructor;
+      O != I && "constructor" in t && "constructor" in s && !(typeof O == "function" && O instanceof O && typeof I == "function" && I instanceof I) && (b = !1);
+    }
+    return o.delete(t), o.delete(s), b;
+  }
+  return Ve = r, Ve;
+}
+var ze, Ui;
+function qf() {
+  if (Ui) return ze;
+  Ui = 1;
+  var e = ni(), a = io(), u = yf(), n = Ef(), r = ti(), t = W(), s = Ee(), i = qe(), f = 1, d = "[object Arguments]", o = "[object Array]", c = "[object Object]", h = Object.prototype, l = h.hasOwnProperty;
+  function y(p, v, _, m, g, b) {
+    var E = t(p), w = t(v), q = E ? o : r(p), S = w ? o : r(v);
+    q = q == d ? c : q, S = S == d ? c : S;
+    var O = q == c, I = S == c, x = q == S;
+    if (x && s(p)) {
+      if (!s(v))
+        return !1;
+      E = !0, O = !1;
+    }
+    if (x && !O)
+      return b || (b = new e()), E || i(p) ? a(p, v, _, m, g, b) : u(p, v, q, _, m, g, b);
+    if (!(_ & f)) {
+      var L = O && l.call(p, "__wrapped__"), k = I && l.call(v, "__wrapped__");
+      if (L || k) {
+        var P = L ? p.value() : p, F = k ? v.value() : v;
+        return b || (b = new e()), g(P, F, _, m, b);
+      }
+    }
+    return x ? (b || (b = new e()), n(p, v, _, m, g, b)) : !1;
+  }
+  return ze = y, ze;
+}
+var je, Bi;
+function ao() {
+  if (Bi) return je;
+  Bi = 1;
+  var e = qf(), a = ve();
+  function u(n, r, t, s, i) {
+    return n === r ? !0 : n == null || r == null || !a(n) && !a(r) ? n !== n && r !== r : e(n, r, t, s, u, i);
+  }
+  return je = u, je;
+}
+var Ke, Hi;
+function Rf() {
+  if (Hi) return Ke;
+  Hi = 1;
+  var e = ni(), a = ao(), u = 1, n = 2;
+  function r(t, s, i, f) {
+    var d = i.length, o = d, c = !f;
+    if (t == null)
+      return !o;
+    for (t = Object(t); d--; ) {
+      var h = i[d];
+      if (c && h[2] ? h[1] !== t[h[0]] : !(h[0] in t))
+        return !1;
+    }
+    for (; ++d < o; ) {
+      h = i[d];
+      var l = h[0], y = t[l], p = h[1];
+      if (c && h[2]) {
+        if (y === void 0 && !(l in t))
+          return !1;
+      } else {
+        var v = new e();
+        if (f)
+          var _ = f(y, p, l, t, s, v);
+        if (!(_ === void 0 ? a(p, y, u | n, f, v) : _))
+          return !1;
+      }
+    }
+    return !0;
+  }
+  return Ke = r, Ke;
+}
+var Ye, Wi;
+function uo() {
+  if (Wi) return Ye;
+  Wi = 1;
+  var e = ae();
+  function a(u) {
+    return u === u && !e(u);
+  }
+  return Ye = a, Ye;
+}
+var $e, Vi;
+function wf() {
+  if (Vi) return $e;
+  Vi = 1;
+  var e = uo(), a = le();
+  function u(n) {
+    for (var r = a(n), t = r.length; t--; ) {
+      var s = r[t], i = n[s];
+      r[t] = [s, i, e(i)];
+    }
+    return r;
+  }
+  return $e = u, $e;
+}
+var Xe, zi;
+function so() {
+  if (zi) return Xe;
+  zi = 1;
+  function e(a, u) {
+    return function(n) {
+      return n == null ? !1 : n[a] === u && (u !== void 0 || a in Object(n));
+    };
+  }
+  return Xe = e, Xe;
+}
+var Ze, ji;
+function Tf() {
+  if (ji) return Ze;
+  ji = 1;
+  var e = Rf(), a = wf(), u = so();
+  function n(r) {
+    var t = a(r);
+    return t.length == 1 && t[0][2] ? u(t[0][0], t[0][1]) : function(s) {
+      return s === r || e(s, r, t);
+    };
+  }
+  return Ze = n, Ze;
+}
+var Qe, Ki;
+function oe() {
+  if (Ki) return Qe;
+  Ki = 1;
+  var e = ii(), a = ve(), u = "[object Symbol]";
+  function n(r) {
+    return typeof r == "symbol" || a(r) && e(r) == u;
+  }
+  return Qe = n, Qe;
+}
+var Je, Yi;
+function di() {
+  if (Yi) return Je;
+  Yi = 1;
+  var e = W(), a = oe(), u = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, n = /^\w*$/;
+  function r(t, s) {
+    if (e(t))
+      return !1;
+    var i = typeof t;
+    return i == "number" || i == "symbol" || i == "boolean" || t == null || a(t) ? !0 : n.test(t) || !u.test(t) || s != null && t in Object(s);
+  }
+  return Je = r, Je;
+}
+var er, $i;
+function If() {
+  if ($i) return er;
+  $i = 1;
+  var e = Xs(), a = "Expected a function";
+  function u(n, r) {
+    if (typeof n != "function" || r != null && typeof r != "function")
+      throw new TypeError(a);
+    var t = function() {
+      var s = arguments, i = r ? r.apply(this, s) : s[0], f = t.cache;
+      if (f.has(i))
+        return f.get(i);
+      var d = n.apply(this, s);
+      return t.cache = f.set(i, d) || f, d;
+    };
+    return t.cache = new (u.Cache || e)(), t;
+  }
+  return u.Cache = e, er = u, er;
+}
+var rr, Xi;
+function Sf() {
+  if (Xi) return rr;
+  Xi = 1;
+  var e = If(), a = 500;
+  function u(n) {
+    var r = e(n, function(s) {
+      return t.size === a && t.clear(), s;
+    }), t = r.cache;
+    return r;
+  }
+  return rr = u, rr;
+}
+var nr, Zi;
+function Cf() {
+  if (Zi) return nr;
+  Zi = 1;
+  var e = Sf(), a = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, u = /\\(\\)?/g, n = e(function(r) {
+    var t = [];
+    return r.charCodeAt(0) === 46 && t.push(""), r.replace(a, function(s, i, f, d) {
+      t.push(f ? d.replace(u, "$1") : i || s);
+    }), t;
+  });
+  return nr = n, nr;
+}
+var tr, Qi;
+function Te() {
+  if (Qi) return tr;
+  Qi = 1;
+  function e(a, u) {
+    for (var n = -1, r = a == null ? 0 : a.length, t = Array(r); ++n < r; )
+      t[n] = u(a[n], n, a);
+    return t;
+  }
+  return tr = e, tr;
+}
+var ir, Ji;
+function Of() {
+  if (Ji) return ir;
+  Ji = 1;
+  var e = ri(), a = Te(), u = W(), n = oe(), r = e ? e.prototype : void 0, t = r ? r.toString : void 0;
+  function s(i) {
+    if (typeof i == "string")
+      return i;
+    if (u(i))
+      return a(i, s) + "";
+    if (n(i))
+      return t ? t.call(i) : "";
+    var f = i + "";
+    return f == "0" && 1 / i == -1 / 0 ? "-0" : f;
+  }
+  return ir = s, ir;
+}
+var ar, ea;
+function oo() {
+  if (ea) return ar;
+  ea = 1;
+  var e = Of();
+  function a(u) {
+    return u == null ? "" : e(u);
+  }
+  return ar = a, ar;
+}
+var ur, ra;
+function Ie() {
+  if (ra) return ur;
+  ra = 1;
+  var e = W(), a = di(), u = Cf(), n = oo();
+  function r(t, s) {
+    return e(t) ? t : a(t, s) ? [t] : u(n(t));
+  }
+  return ur = r, ur;
+}
+var sr, na;
+function pe() {
+  if (na) return sr;
+  na = 1;
+  var e = oe();
+  function a(u) {
+    if (typeof u == "string" || e(u))
+      return u;
+    var n = u + "";
+    return n == "0" && 1 / u == -1 / 0 ? "-0" : n;
+  }
+  return sr = a, sr;
+}
+var or, ta;
+function Se() {
+  if (ta) return or;
+  ta = 1;
+  var e = Ie(), a = pe();
+  function u(n, r) {
+    r = e(r, n);
+    for (var t = 0, s = r.length; n != null && t < s; )
+      n = n[a(r[t++])];
+    return t && t == s ? n : void 0;
+  }
+  return or = u, or;
+}
+var fr, ia;
+function Nf() {
+  if (ia) return fr;
+  ia = 1;
+  var e = Se();
+  function a(u, n, r) {
+    var t = u == null ? void 0 : e(u, n);
+    return t === void 0 ? r : t;
+  }
+  return fr = a, fr;
+}
+var dr, aa;
+function Af() {
+  if (aa) return dr;
+  aa = 1;
+  function e(a, u) {
+    return a != null && u in Object(a);
+  }
+  return dr = e, dr;
+}
+var cr, ua;
+function fo() {
+  if (ua) return cr;
+  ua = 1;
+  var e = Ie(), a = Re(), u = W(), n = ai(), r = Yo(), t = pe();
+  function s(i, f, d) {
+    f = e(f, i);
+    for (var o = -1, c = f.length, h = !1; ++o < c; ) {
+      var l = t(f[o]);
+      if (!(h = i != null && d(i, l)))
+        break;
+      i = i[l];
+    }
+    return h || ++o != c ? h : (c = i == null ? 0 : i.length, !!c && r(c) && n(l, c) && (u(i) || a(i)));
+  }
+  return cr = s, cr;
+}
+var hr, sa;
+function co() {
+  if (sa) return hr;
+  sa = 1;
+  var e = Af(), a = fo();
+  function u(n, r) {
+    return n != null && a(n, r, e);
+  }
+  return hr = u, hr;
+}
+var lr, oa;
+function xf() {
+  if (oa) return lr;
+  oa = 1;
+  var e = ao(), a = Nf(), u = co(), n = di(), r = uo(), t = so(), s = pe(), i = 1, f = 2;
+  function d(o, c) {
+    return n(o) && r(c) ? t(s(o), c) : function(h) {
+      var l = a(h, o);
+      return l === void 0 && l === c ? u(h, o) : e(c, l, i | f);
+    };
+  }
+  return lr = d, lr;
+}
+var vr, fa;
+function se() {
+  if (fa) return vr;
+  fa = 1;
+  function e(a) {
+    return a;
+  }
+  return vr = e, vr;
+}
+var pr, da;
+function ho() {
+  if (da) return pr;
+  da = 1;
+  function e(a) {
+    return function(u) {
+      return u == null ? void 0 : u[a];
+    };
+  }
+  return pr = e, pr;
+}
+var _r, ca;
+function Lf() {
+  if (ca) return _r;
+  ca = 1;
+  var e = Se();
+  function a(u) {
+    return function(n) {
+      return e(n, u);
+    };
+  }
+  return _r = a, _r;
+}
+var gr, ha;
+function kf() {
+  if (ha) return gr;
+  ha = 1;
+  var e = ho(), a = Lf(), u = di(), n = pe();
+  function r(t) {
+    return u(t) ? e(n(t)) : a(t);
+  }
+  return gr = r, gr;
+}
+var mr, la;
+function ee() {
+  if (la) return mr;
+  la = 1;
+  var e = Tf(), a = xf(), u = se(), n = W(), r = kf();
+  function t(s) {
+    return typeof s == "function" ? s : s == null ? u : typeof s == "object" ? n(s) ? a(s[0], s[1]) : e(s) : r(s);
+  }
+  return mr = t, mr;
+}
+var br, va;
+function Pf() {
+  if (va) return br;
+  va = 1;
+  var e = Zs(), a = oi(), u = ee();
+  function n(r, t) {
+    var s = {};
+    return t = u(t, 3), a(r, function(i, f, d) {
+      e(s, f, t(i, f, d));
+    }), s;
+  }
+  return br = n, br;
+}
+const Mf = {
+  en: {
+    y: () => "y",
+    mo: () => "mo",
+    w: () => "w",
+    d: () => "d",
+    h: () => "h",
+    m: () => "m",
+    s: () => "s",
+    ms: () => "ms"
+  },
+  fr: {
+    y: () => "a",
+    mo: () => "mo",
+    w: () => "se",
+    d: () => "j",
+    h: () => "h",
+    m: () => "m",
+    s: () => "s",
+    ms: () => "ms"
+  }
+}, Ff = "dateFormat", Gf = "timezone", yr = {
+  capitalize: (e) => e.charAt(0).toUpperCase() + e.slice(1),
+  dateFilter: (e, a) => {
+    var t, s;
+    const u = (t = Ti()) == null ? void 0 : t.appContext.config.globalProperties.$moment().locale(), n = (s = Ti()) == null ? void 0 : s.appContext.config.globalProperties.$moment(e).locale(u);
+    let r;
+    return a === "iso" ? r = "YYYY-MM-DD HH:mm:ss.SSS" : r = a ?? localStorage.getItem(Ff) ?? "llll", n.tz(localStorage.getItem(Gf) ?? vf.tz.guess()).format(r);
+  },
+  splitFirst(e, a) {
+    return e.split(a).slice(1).join(a);
+  },
+  duration(e) {
+    return Ii.duration(e, Ii.ISO_8601).asMilliseconds() / 1e3;
+  },
+  humanDuration(e, a) {
+    return a = a || { maxDecimalPoints: 2 }, a.spacer = "", a.language = localStorage.getItem("lang") || "en", a.languages = Mf, a.largest = 2, typeof e != "number" && (e = this.duration(e)), lf(e * 1e3, a).replace(
+      /\.([0-9])s$/i,
+      ".$10s"
+    );
+  },
+  afterLastDot(e) {
+    return e.split(".").pop();
+  },
+  distinctFilter(e, a, u) {
+    return u.indexOf(e) === a;
+  }
+};
+function ci(e) {
+  throw new Error('Could not dynamically require "' + e + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var Er, pa;
+function Df() {
+  if (pa) return Er;
+  pa = 1;
+  var e = $o(), a = 4;
+  function u(n) {
+    return e(n, a);
+  }
+  return Er = u, Er;
+}
+var qr, _a;
+function hi() {
+  if (_a) return qr;
+  _a = 1;
+  function e(a) {
+    return function() {
+      return a;
+    };
+  }
+  return qr = e, qr;
+}
+var Rr, ga;
+function Uf() {
+  if (ga) return Rr;
+  ga = 1;
+  var e = ue();
+  function a(u, n) {
+    return function(r, t) {
+      if (r == null)
+        return r;
+      if (!e(r))
+        return u(r, t);
+      for (var s = r.length, i = n ? s : -1, f = Object(r); (n ? i-- : ++i < s) && t(f[i], i, f) !== !1; )
+        ;
+      return r;
+    };
+  }
+  return Rr = a, Rr;
+}
+var wr, ma;
+function Ce() {
+  if (ma) return wr;
+  ma = 1;
+  var e = oi(), a = Uf(), u = a(e);
+  return wr = u, wr;
+}
+var Tr, ba;
+function lo() {
+  if (ba) return Tr;
+  ba = 1;
+  var e = se();
+  function a(u) {
+    return typeof u == "function" ? u : e;
+  }
+  return Tr = a, Tr;
+}
+var Ir, ya;
+function vo() {
+  if (ya) return Ir;
+  ya = 1;
+  var e = Qs(), a = Ce(), u = lo(), n = W();
+  function r(t, s) {
+    var i = n(t) ? e : a;
+    return i(t, u(s));
+  }
+  return Ir = r, Ir;
+}
+var Sr, Ea;
+function po() {
+  return Ea || (Ea = 1, Sr = vo()), Sr;
+}
+var Cr, qa;
+function Bf() {
+  if (qa) return Cr;
+  qa = 1;
+  var e = Ce();
+  function a(u, n) {
+    var r = [];
+    return e(u, function(t, s, i) {
+      n(t, s, i) && r.push(t);
+    }), r;
+  }
+  return Cr = a, Cr;
+}
+var Or, Ra;
+function _o() {
+  if (Ra) return Or;
+  Ra = 1;
+  var e = Xo(), a = Bf(), u = ee(), n = W();
+  function r(t, s) {
+    var i = n(t) ? e : a;
+    return i(t, u(s, 3));
+  }
+  return Or = r, Or;
+}
+var Nr, wa;
+function Hf() {
+  if (wa) return Nr;
+  wa = 1;
+  var e = Object.prototype, a = e.hasOwnProperty;
+  function u(n, r) {
+    return n != null && a.call(n, r);
+  }
+  return Nr = u, Nr;
+}
+var Ar, Ta;
+function go() {
+  if (Ta) return Ar;
+  Ta = 1;
+  var e = Hf(), a = fo();
+  function u(n, r) {
+    return n != null && a(n, r, e);
+  }
+  return Ar = u, Ar;
+}
+var xr, Ia;
+function Wf() {
+  if (Ia) return xr;
+  Ia = 1;
+  var e = Js(), a = ti(), u = Re(), n = W(), r = ue(), t = Ee(), s = Zo(), i = qe(), f = "[object Map]", d = "[object Set]", o = Object.prototype, c = o.hasOwnProperty;
+  function h(l) {
+    if (l == null)
+      return !0;
+    if (r(l) && (n(l) || typeof l == "string" || typeof l.splice == "function" || t(l) || i(l) || u(l)))
+      return !l.length;
+    var y = a(l);
+    if (y == f || y == d)
+      return !l.size;
+    if (s(l))
+      return !e(l).length;
+    for (var p in l)
+      if (c.call(l, p))
+        return !1;
+    return !0;
+  }
+  return xr = h, xr;
+}
+var Lr, Sa;
+function mo() {
+  if (Sa) return Lr;
+  Sa = 1;
+  function e(a) {
+    return a === void 0;
+  }
+  return Lr = e, Lr;
+}
+var kr, Ca;
+function bo() {
+  if (Ca) return kr;
+  Ca = 1;
+  var e = Ce(), a = ue();
+  function u(n, r) {
+    var t = -1, s = a(n) ? Array(n.length) : [];
+    return e(n, function(i, f, d) {
+      s[++t] = r(i, f, d);
+    }), s;
+  }
+  return kr = u, kr;
+}
+var Pr, Oa;
+function yo() {
+  if (Oa) return Pr;
+  Oa = 1;
+  var e = Te(), a = ee(), u = bo(), n = W();
+  function r(t, s) {
+    var i = n(t) ? e : u;
+    return i(t, a(s, 3));
+  }
+  return Pr = r, Pr;
+}
+var Mr, Na;
+function Vf() {
+  if (Na) return Mr;
+  Na = 1;
+  function e(a, u, n, r) {
+    var t = -1, s = a == null ? 0 : a.length;
+    for (r && s && (n = a[++t]); ++t < s; )
+      n = u(n, a[t], t, a);
+    return n;
+  }
+  return Mr = e, Mr;
+}
+var Fr, Aa;
+function zf() {
+  if (Aa) return Fr;
+  Aa = 1;
+  function e(a, u, n, r, t) {
+    return t(a, function(s, i, f) {
+      n = r ? (r = !1, s) : u(n, s, i, f);
+    }), n;
+  }
+  return Fr = e, Fr;
+}
+var Gr, xa;
+function Eo() {
+  if (xa) return Gr;
+  xa = 1;
+  var e = Vf(), a = Ce(), u = ee(), n = zf(), r = W();
+  function t(s, i, f) {
+    var d = r(s) ? e : n, o = arguments.length < 3;
+    return d(s, u(i, 4), f, o, a);
+  }
+  return Gr = t, Gr;
+}
+var Dr, La;
+function jf() {
+  if (La) return Dr;
+  La = 1;
+  var e = ii(), a = W(), u = ve(), n = "[object String]";
+  function r(t) {
+    return typeof t == "string" || !a(t) && u(t) && e(t) == n;
+  }
+  return Dr = r, Dr;
+}
+var Ur, ka;
+function Kf() {
+  if (ka) return Ur;
+  ka = 1;
+  var e = ho(), a = e("length");
+  return Ur = a, Ur;
+}
+var Br, Pa;
+function Yf() {
+  if (Pa) return Br;
+  Pa = 1;
+  var e = "\\ud800-\\udfff", a = "\\u0300-\\u036f", u = "\\ufe20-\\ufe2f", n = "\\u20d0-\\u20ff", r = a + u + n, t = "\\ufe0e\\ufe0f", s = "\\u200d", i = RegExp("[" + s + e + r + t + "]");
+  function f(d) {
+    return i.test(d);
+  }
+  return Br = f, Br;
+}
+var Hr, Ma;
+function $f() {
+  if (Ma) return Hr;
+  Ma = 1;
+  var e = "\\ud800-\\udfff", a = "\\u0300-\\u036f", u = "\\ufe20-\\ufe2f", n = "\\u20d0-\\u20ff", r = a + u + n, t = "\\ufe0e\\ufe0f", s = "[" + e + "]", i = "[" + r + "]", f = "\\ud83c[\\udffb-\\udfff]", d = "(?:" + i + "|" + f + ")", o = "[^" + e + "]", c = "(?:\\ud83c[\\udde6-\\uddff]){2}", h = "[\\ud800-\\udbff][\\udc00-\\udfff]", l = "\\u200d", y = d + "?", p = "[" + t + "]?", v = "(?:" + l + "(?:" + [o, c, h].join("|") + ")" + p + y + ")*", _ = p + y + v, m = "(?:" + [o + i + "?", i, c, h, s].join("|") + ")", g = RegExp(f + "(?=" + f + ")|" + m + _, "g");
+  function b(E) {
+    for (var w = g.lastIndex = 0; g.test(E); )
+      ++w;
+    return w;
+  }
+  return Hr = b, Hr;
+}
+var Wr, Fa;
+function Xf() {
+  if (Fa) return Wr;
+  Fa = 1;
+  var e = Kf(), a = Yf(), u = $f();
+  function n(r) {
+    return a(r) ? u(r) : e(r);
+  }
+  return Wr = n, Wr;
+}
+var Vr, Ga;
+function Zf() {
+  if (Ga) return Vr;
+  Ga = 1;
+  var e = Js(), a = ti(), u = ue(), n = jf(), r = Xf(), t = "[object Map]", s = "[object Set]";
+  function i(f) {
+    if (f == null)
+      return 0;
+    if (u(f))
+      return n(f) ? r(f) : f.length;
+    var d = a(f);
+    return d == t || d == s ? f.size : e(f).length;
+  }
+  return Vr = i, Vr;
+}
+var zr, Da;
+function Qf() {
+  if (Da) return zr;
+  Da = 1;
+  var e = Qs(), a = Qo(), u = oi(), n = ee(), r = eo(), t = W(), s = Ee(), i = ui(), f = ae(), d = qe();
+  function o(c, h, l) {
+    var y = t(c), p = y || s(c) || d(c);
+    if (h = n(h, 4), l == null) {
+      var v = c && c.constructor;
+      p ? l = y ? new v() : [] : f(c) ? l = i(v) ? a(r(c)) : {} : l = {};
+    }
+    return (p ? e : u)(c, function(_, m, g) {
+      return h(l, _, m, g);
+    }), l;
+  }
+  return zr = o, zr;
+}
+var jr, Ua;
+function Jf() {
+  if (Ua) return jr;
+  Ua = 1;
+  var e = ri(), a = Re(), u = W(), n = e ? e.isConcatSpreadable : void 0;
+  function r(t) {
+    return u(t) || a(t) || !!(n && t && t[n]);
+  }
+  return jr = r, jr;
+}
+var Kr, Ba;
+function li() {
+  if (Ba) return Kr;
+  Ba = 1;
+  var e = Jo(), a = Jf();
+  function u(n, r, t, s, i) {
+    var f = -1, d = n.length;
+    for (t || (t = a), i || (i = []); ++f < d; ) {
+      var o = n[f];
+      r > 0 && t(o) ? r > 1 ? u(o, r - 1, t, s, i) : e(i, o) : s || (i[i.length] = o);
+    }
+    return i;
+  }
+  return Kr = u, Kr;
+}
+var Yr, Ha;
+function ed() {
+  if (Ha) return Yr;
+  Ha = 1;
+  function e(a, u, n) {
+    switch (n.length) {
+      case 0:
+        return a.call(u);
+      case 1:
+        return a.call(u, n[0]);
+      case 2:
+        return a.call(u, n[0], n[1]);
+      case 3:
+        return a.call(u, n[0], n[1], n[2]);
+    }
+    return a.apply(u, n);
+  }
+  return Yr = e, Yr;
+}
+var $r, Wa;
+function qo() {
+  if (Wa) return $r;
+  Wa = 1;
+  var e = ed(), a = Math.max;
+  function u(n, r, t) {
+    return r = a(r === void 0 ? n.length - 1 : r, 0), function() {
+      for (var s = arguments, i = -1, f = a(s.length - r, 0), d = Array(f); ++i < f; )
+        d[i] = s[r + i];
+      i = -1;
+      for (var o = Array(r + 1); ++i < r; )
+        o[i] = s[i];
+      return o[r] = t(d), e(n, this, o);
+    };
+  }
+  return $r = u, $r;
+}
+var Xr, Va;
+function rd() {
+  if (Va) return Xr;
+  Va = 1;
+  var e = hi(), a = ef(), u = se(), n = a ? function(r, t) {
+    return a(r, "toString", {
+      configurable: !0,
+      enumerable: !1,
+      value: e(t),
+      writable: !0
+    });
+  } : u;
+  return Xr = n, Xr;
+}
+var Zr, za;
+function nd() {
+  if (za) return Zr;
+  za = 1;
+  var e = 800, a = 16, u = Date.now;
+  function n(r) {
+    var t = 0, s = 0;
+    return function() {
+      var i = u(), f = a - (i - s);
+      if (s = i, f > 0) {
+        if (++t >= e)
+          return arguments[0];
+      } else
+        t = 0;
+      return r.apply(void 0, arguments);
+    };
+  }
+  return Zr = n, Zr;
+}
+var Qr, ja;
+function Ro() {
+  if (ja) return Qr;
+  ja = 1;
+  var e = rd(), a = nd(), u = a(e);
+  return Qr = u, Qr;
+}
+var Jr, Ka;
+function Oe() {
+  if (Ka) return Jr;
+  Ka = 1;
+  var e = se(), a = qo(), u = Ro();
+  function n(r, t) {
+    return u(a(r, t, e), r + "");
+  }
+  return Jr = n, Jr;
+}
+var en, Ya;
+function wo() {
+  if (Ya) return en;
+  Ya = 1;
+  function e(a, u, n, r) {
+    for (var t = a.length, s = n + (r ? 1 : -1); r ? s-- : ++s < t; )
+      if (u(a[s], s, a))
+        return s;
+    return -1;
+  }
+  return en = e, en;
+}
+var rn, $a;
+function td() {
+  if ($a) return rn;
+  $a = 1;
+  function e(a) {
+    return a !== a;
+  }
+  return rn = e, rn;
+}
+var nn, Xa;
+function id() {
+  if (Xa) return nn;
+  Xa = 1;
+  function e(a, u, n) {
+    for (var r = n - 1, t = a.length; ++r < t; )
+      if (a[r] === u)
+        return r;
+    return -1;
+  }
+  return nn = e, nn;
+}
+var tn, Za;
+function ad() {
+  if (Za) return tn;
+  Za = 1;
+  var e = wo(), a = td(), u = id();
+  function n(r, t, s) {
+    return t === t ? u(r, t, s) : e(r, a, s);
+  }
+  return tn = n, tn;
+}
+var an, Qa;
+function ud() {
+  if (Qa) return an;
+  Qa = 1;
+  var e = ad();
+  function a(u, n) {
+    var r = u == null ? 0 : u.length;
+    return !!r && e(u, n, 0) > -1;
+  }
+  return an = a, an;
+}
+var un, Ja;
+function sd() {
+  if (Ja) return un;
+  Ja = 1;
+  function e(a, u, n) {
+    for (var r = -1, t = a == null ? 0 : a.length; ++r < t; )
+      if (n(u, a[r]))
+        return !0;
+    return !1;
+  }
+  return un = e, un;
+}
+var sn, eu;
+function od() {
+  if (eu) return sn;
+  eu = 1;
+  function e() {
+  }
+  return sn = e, sn;
+}
+var on, ru;
+function fd() {
+  if (ru) return on;
+  ru = 1;
+  var e = rf(), a = od(), u = fi(), n = 1 / 0, r = e && 1 / u(new e([, -0]))[1] == n ? function(t) {
+    return new e(t);
+  } : a;
+  return on = r, on;
+}
+var fn, nu;
+function dd() {
+  if (nu) return fn;
+  nu = 1;
+  var e = no(), a = ud(), u = sd(), n = to(), r = fd(), t = fi(), s = 200;
+  function i(f, d, o) {
+    var c = -1, h = a, l = f.length, y = !0, p = [], v = p;
+    if (o)
+      y = !1, h = u;
+    else if (l >= s) {
+      var _ = d ? null : r(f);
+      if (_)
+        return t(_);
+      y = !1, h = n, v = new e();
+    } else
+      v = d ? [] : p;
+    e:
+      for (; ++c < l; ) {
+        var m = f[c], g = d ? d(m) : m;
+        if (m = o || m !== 0 ? m : 0, y && g === g) {
+          for (var b = v.length; b--; )
+            if (v[b] === g)
+              continue e;
+          d && v.push(g), p.push(m);
+        } else h(v, g, o) || (v !== p && v.push(g), p.push(m));
+      }
+    return p;
+  }
+  return fn = i, fn;
+}
+var dn, tu;
+function To() {
+  if (tu) return dn;
+  tu = 1;
+  var e = ue(), a = ve();
+  function u(n) {
+    return a(n) && e(n);
+  }
+  return dn = u, dn;
+}
+var cn, iu;
+function cd() {
+  if (iu) return cn;
+  iu = 1;
+  var e = li(), a = Oe(), u = dd(), n = To(), r = a(function(t) {
+    return u(e(t, 1, n, !0));
+  });
+  return cn = r, cn;
+}
+var hn, au;
+function hd() {
+  if (au) return hn;
+  au = 1;
+  var e = Te();
+  function a(u, n) {
+    return e(n, function(r) {
+      return u[r];
+    });
+  }
+  return hn = a, hn;
+}
+var ln, uu;
+function Io() {
+  if (uu) return ln;
+  uu = 1;
+  var e = hd(), a = le();
+  function u(n) {
+    return n == null ? [] : e(n, a(n));
+  }
+  return ln = u, ln;
+}
+var vn, su;
+function X() {
+  if (su) return vn;
+  su = 1;
+  var e;
+  if (typeof ci == "function")
+    try {
+      e = {
+        clone: Df(),
+        constant: hi(),
+        each: po(),
+        filter: _o(),
+        has: go(),
+        isArray: W(),
+        isEmpty: Wf(),
+        isFunction: ui(),
+        isUndefined: mo(),
+        keys: le(),
+        map: yo(),
+        reduce: Eo(),
+        size: Zf(),
+        transform: Qf(),
+        union: cd(),
+        values: Io()
+      };
+    } catch {
+    }
+  return e || (e = window._), vn = e, vn;
+}
+var pn, ou;
+function vi() {
+  if (ou) return pn;
+  ou = 1;
+  var e = X();
+  pn = r;
+  var a = "\0", u = "\0", n = "
";
+  function r(o) {
+    this._isDirected = e.has(o, "directed") ? o.directed : !0, this._isMultigraph = e.has(o, "multigraph") ? o.multigraph : !1, this._isCompound = e.has(o, "compound") ? o.compound : !1, this._label = void 0, this._defaultNodeLabelFn = e.constant(void 0), this._defaultEdgeLabelFn = e.constant(void 0), this._nodes = {}, this._isCompound && (this._parent = {}, this._children = {}, this._children[u] = {}), this._in = {}, this._preds = {}, this._out = {}, this._sucs = {}, this._edgeObjs = {}, this._edgeLabels = {};
+  }
+  r.prototype._nodeCount = 0, r.prototype._edgeCount = 0, r.prototype.isDirected = function() {
+    return this._isDirected;
+  }, r.prototype.isMultigraph = function() {
+    return this._isMultigraph;
+  }, r.prototype.isCompound = function() {
+    return this._isCompound;
+  }, r.prototype.setGraph = function(o) {
+    return this._label = o, this;
+  }, r.prototype.graph = function() {
+    return this._label;
+  }, r.prototype.setDefaultNodeLabel = function(o) {
+    return e.isFunction(o) || (o = e.constant(o)), this._defaultNodeLabelFn = o, this;
+  }, r.prototype.nodeCount = function() {
+    return this._nodeCount;
+  }, r.prototype.nodes = function() {
+    return e.keys(this._nodes);
+  }, r.prototype.sources = function() {
+    var o = this;
+    return e.filter(this.nodes(), function(c) {
+      return e.isEmpty(o._in[c]);
+    });
+  }, r.prototype.sinks = function() {
+    var o = this;
+    return e.filter(this.nodes(), function(c) {
+      return e.isEmpty(o._out[c]);
+    });
+  }, r.prototype.setNodes = function(o, c) {
+    var h = arguments, l = this;
+    return e.each(o, function(y) {
+      h.length > 1 ? l.setNode(y, c) : l.setNode(y);
+    }), this;
+  }, r.prototype.setNode = function(o, c) {
+    return e.has(this._nodes, o) ? (arguments.length > 1 && (this._nodes[o] = c), this) : (this._nodes[o] = arguments.length > 1 ? c : this._defaultNodeLabelFn(o), this._isCompound && (this._parent[o] = u, this._children[o] = {}, this._children[u][o] = !0), this._in[o] = {}, this._preds[o] = {}, this._out[o] = {}, this._sucs[o] = {}, ++this._nodeCount, this);
+  }, r.prototype.node = function(o) {
+    return this._nodes[o];
+  }, r.prototype.hasNode = function(o) {
+    return e.has(this._nodes, o);
+  }, r.prototype.removeNode = function(o) {
+    var c = this;
+    if (e.has(this._nodes, o)) {
+      var h = function(l) {
+        c.removeEdge(c._edgeObjs[l]);
+      };
+      delete this._nodes[o], this._isCompound && (this._removeFromParentsChildList(o), delete this._parent[o], e.each(this.children(o), function(l) {
+        c.setParent(l);
+      }), delete this._children[o]), e.each(e.keys(this._in[o]), h), delete this._in[o], delete this._preds[o], e.each(e.keys(this._out[o]), h), delete this._out[o], delete this._sucs[o], --this._nodeCount;
+    }
+    return this;
+  }, r.prototype.setParent = function(o, c) {
+    if (!this._isCompound)
+      throw new Error("Cannot set parent in a non-compound graph");
+    if (e.isUndefined(c))
+      c = u;
+    else {
+      c += "";
+      for (var h = c; !e.isUndefined(h); h = this.parent(h))
+        if (h === o)
+          throw new Error("Setting " + c + " as parent of " + o + " would create a cycle");
+      this.setNode(c);
+    }
+    return this.setNode(o), this._removeFromParentsChildList(o), this._parent[o] = c, this._children[c][o] = !0, this;
+  }, r.prototype._removeFromParentsChildList = function(o) {
+    delete this._children[this._parent[o]][o];
+  }, r.prototype.parent = function(o) {
+    if (this._isCompound) {
+      var c = this._parent[o];
+      if (c !== u)
+        return c;
+    }
+  }, r.prototype.children = function(o) {
+    if (e.isUndefined(o) && (o = u), this._isCompound) {
+      var c = this._children[o];
+      if (c)
+        return e.keys(c);
+    } else {
+      if (o === u)
+        return this.nodes();
+      if (this.hasNode(o))
+        return [];
+    }
+  }, r.prototype.predecessors = function(o) {
+    var c = this._preds[o];
+    if (c)
+      return e.keys(c);
+  }, r.prototype.successors = function(o) {
+    var c = this._sucs[o];
+    if (c)
+      return e.keys(c);
+  }, r.prototype.neighbors = function(o) {
+    var c = this.predecessors(o);
+    if (c)
+      return e.union(c, this.successors(o));
+  }, r.prototype.isLeaf = function(o) {
+    var c;
+    return this.isDirected() ? c = this.successors(o) : c = this.neighbors(o), c.length === 0;
+  }, r.prototype.filterNodes = function(o) {
+    var c = new this.constructor({
+      directed: this._isDirected,
+      multigraph: this._isMultigraph,
+      compound: this._isCompound
+    });
+    c.setGraph(this.graph());
+    var h = this;
+    e.each(this._nodes, function(p, v) {
+      o(v) && c.setNode(v, p);
+    }), e.each(this._edgeObjs, function(p) {
+      c.hasNode(p.v) && c.hasNode(p.w) && c.setEdge(p, h.edge(p));
+    });
+    var l = {};
+    function y(p) {
+      var v = h.parent(p);
+      return v === void 0 || c.hasNode(v) ? (l[p] = v, v) : v in l ? l[v] : y(v);
+    }
+    return this._isCompound && e.each(c.nodes(), function(p) {
+      c.setParent(p, y(p));
+    }), c;
+  }, r.prototype.setDefaultEdgeLabel = function(o) {
+    return e.isFunction(o) || (o = e.constant(o)), this._defaultEdgeLabelFn = o, this;
+  }, r.prototype.edgeCount = function() {
+    return this._edgeCount;
+  }, r.prototype.edges = function() {
+    return e.values(this._edgeObjs);
+  }, r.prototype.setPath = function(o, c) {
+    var h = this, l = arguments;
+    return e.reduce(o, function(y, p) {
+      return l.length > 1 ? h.setEdge(y, p, c) : h.setEdge(y, p), p;
+    }), this;
+  }, r.prototype.setEdge = function() {
+    var o, c, h, l, y = !1, p = arguments[0];
+    typeof p == "object" && p !== null && "v" in p ? (o = p.v, c = p.w, h = p.name, arguments.length === 2 && (l = arguments[1], y = !0)) : (o = p, c = arguments[1], h = arguments[3], arguments.length > 2 && (l = arguments[2], y = !0)), o = "" + o, c = "" + c, e.isUndefined(h) || (h = "" + h);
+    var v = i(this._isDirected, o, c, h);
+    if (e.has(this._edgeLabels, v))
+      return y && (this._edgeLabels[v] = l), this;
+    if (!e.isUndefined(h) && !this._isMultigraph)
+      throw new Error("Cannot set a named edge when isMultigraph = false");
+    this.setNode(o), this.setNode(c), this._edgeLabels[v] = y ? l : this._defaultEdgeLabelFn(o, c, h);
+    var _ = f(this._isDirected, o, c, h);
+    return o = _.v, c = _.w, Object.freeze(_), this._edgeObjs[v] = _, t(this._preds[c], o), t(this._sucs[o], c), this._in[c][v] = _, this._out[o][v] = _, this._edgeCount++, this;
+  }, r.prototype.edge = function(o, c, h) {
+    var l = arguments.length === 1 ? d(this._isDirected, arguments[0]) : i(this._isDirected, o, c, h);
+    return this._edgeLabels[l];
+  }, r.prototype.hasEdge = function(o, c, h) {
+    var l = arguments.length === 1 ? d(this._isDirected, arguments[0]) : i(this._isDirected, o, c, h);
+    return e.has(this._edgeLabels, l);
+  }, r.prototype.removeEdge = function(o, c, h) {
+    var l = arguments.length === 1 ? d(this._isDirected, arguments[0]) : i(this._isDirected, o, c, h), y = this._edgeObjs[l];
+    return y && (o = y.v, c = y.w, delete this._edgeLabels[l], delete this._edgeObjs[l], s(this._preds[c], o), s(this._sucs[o], c), delete this._in[c][l], delete this._out[o][l], this._edgeCount--), this;
+  }, r.prototype.inEdges = function(o, c) {
+    var h = this._in[o];
+    if (h) {
+      var l = e.values(h);
+      return c ? e.filter(l, function(y) {
+        return y.v === c;
+      }) : l;
+    }
+  }, r.prototype.outEdges = function(o, c) {
+    var h = this._out[o];
+    if (h) {
+      var l = e.values(h);
+      return c ? e.filter(l, function(y) {
+        return y.w === c;
+      }) : l;
+    }
+  }, r.prototype.nodeEdges = function(o, c) {
+    var h = this.inEdges(o, c);
+    if (h)
+      return h.concat(this.outEdges(o, c));
+  };
+  function t(o, c) {
+    o[c] ? o[c]++ : o[c] = 1;
+  }
+  function s(o, c) {
+    --o[c] || delete o[c];
+  }
+  function i(o, c, h, l) {
+    var y = "" + c, p = "" + h;
+    if (!o && y > p) {
+      var v = y;
+      y = p, p = v;
+    }
+    return y + n + p + n + (e.isUndefined(l) ? a : l);
+  }
+  function f(o, c, h, l) {
+    var y = "" + c, p = "" + h;
+    if (!o && y > p) {
+      var v = y;
+      y = p, p = v;
+    }
+    var _ = { v: y, w: p };
+    return l && (_.name = l), _;
+  }
+  function d(o, c) {
+    return i(o, c.v, c.w, c.name);
+  }
+  return pn;
+}
+var _n, fu;
+function ld() {
+  return fu || (fu = 1, _n = "2.1.8"), _n;
+}
+var gn, du;
+function vd() {
+  return du || (du = 1, gn = {
+    Graph: vi(),
+    version: ld()
+  }), gn;
+}
+var mn, cu;
+function pd() {
+  if (cu) return mn;
+  cu = 1;
+  var e = X(), a = vi();
+  mn = {
+    write: u,
+    read: t
+  };
+  function u(s) {
+    var i = {
+      options: {
+        directed: s.isDirected(),
+        multigraph: s.isMultigraph(),
+        compound: s.isCompound()
+      },
+      nodes: n(s),
+      edges: r(s)
+    };
+    return e.isUndefined(s.graph()) || (i.value = e.clone(s.graph())), i;
+  }
+  function n(s) {
+    return e.map(s.nodes(), function(i) {
+      var f = s.node(i), d = s.parent(i), o = { v: i };
+      return e.isUndefined(f) || (o.value = f), e.isUndefined(d) || (o.parent = d), o;
+    });
+  }
+  function r(s) {
+    return e.map(s.edges(), function(i) {
+      var f = s.edge(i), d = { v: i.v, w: i.w };
+      return e.isUndefined(i.name) || (d.name = i.name), e.isUndefined(f) || (d.value = f), d;
+    });
+  }
+  function t(s) {
+    var i = new a(s.options).setGraph(s.value);
+    return e.each(s.nodes, function(f) {
+      i.setNode(f.v, f.value), f.parent && i.setParent(f.v, f.parent);
+    }), e.each(s.edges, function(f) {
+      i.setEdge({ v: f.v, w: f.w, name: f.name }, f.value);
+    }), i;
+  }
+  return mn;
+}
+var bn, hu;
+function _d() {
+  if (hu) return bn;
+  hu = 1;
+  var e = X();
+  bn = a;
+  function a(u) {
+    var n = {}, r = [], t;
+    function s(i) {
+      e.has(n, i) || (n[i] = !0, t.push(i), e.each(u.successors(i), s), e.each(u.predecessors(i), s));
+    }
+    return e.each(u.nodes(), function(i) {
+      t = [], s(i), t.length && r.push(t);
+    }), r;
+  }
+  return bn;
+}
+var yn, lu;
+function So() {
+  if (lu) return yn;
+  lu = 1;
+  var e = X();
+  yn = a;
+  function a() {
+    this._arr = [], this._keyIndices = {};
+  }
+  return a.prototype.size = function() {
+    return this._arr.length;
+  }, a.prototype.keys = function() {
+    return this._arr.map(function(u) {
+      return u.key;
+    });
+  }, a.prototype.has = function(u) {
+    return e.has(this._keyIndices, u);
+  }, a.prototype.priority = function(u) {
+    var n = this._keyIndices[u];
+    if (n !== void 0)
+      return this._arr[n].priority;
+  }, a.prototype.min = function() {
+    if (this.size() === 0)
+      throw new Error("Queue underflow");
+    return this._arr[0].key;
+  }, a.prototype.add = function(u, n) {
+    var r = this._keyIndices;
+    if (u = String(u), !e.has(r, u)) {
+      var t = this._arr, s = t.length;
+      return r[u] = s, t.push({ key: u, priority: n }), this._decrease(s), !0;
+    }
+    return !1;
+  }, a.prototype.removeMin = function() {
+    this._swap(0, this._arr.length - 1);
+    var u = this._arr.pop();
+    return delete this._keyIndices[u.key], this._heapify(0), u.key;
+  }, a.prototype.decrease = function(u, n) {
+    var r = this._keyIndices[u];
+    if (n > this._arr[r].priority)
+      throw new Error("New priority is greater than current priority. Key: " + u + " Old: " + this._arr[r].priority + " New: " + n);
+    this._arr[r].priority = n, this._decrease(r);
+  }, a.prototype._heapify = function(u) {
+    var n = this._arr, r = 2 * u, t = r + 1, s = u;
+    r < n.length && (s = n[r].priority < n[s].priority ? r : s, t < n.length && (s = n[t].priority < n[s].priority ? t : s), s !== u && (this._swap(u, s), this._heapify(s)));
+  }, a.prototype._decrease = function(u) {
+    for (var n = this._arr, r = n[u].priority, t; u !== 0 && (t = u >> 1, !(n[t].priority < r)); )
+      this._swap(u, t), u = t;
+  }, a.prototype._swap = function(u, n) {
+    var r = this._arr, t = this._keyIndices, s = r[u], i = r[n];
+    r[u] = i, r[n] = s, t[i.key] = u, t[s.key] = n;
+  }, yn;
+}
+var En, vu;
+function Co() {
+  if (vu) return En;
+  vu = 1;
+  var e = X(), a = So();
+  En = n;
+  var u = e.constant(1);
+  function n(t, s, i, f) {
+    return r(
+      t,
+      String(s),
+      i || u,
+      f || function(d) {
+        return t.outEdges(d);
+      }
+    );
+  }
+  function r(t, s, i, f) {
+    var d = {}, o = new a(), c, h, l = function(y) {
+      var p = y.v !== c ? y.v : y.w, v = d[p], _ = i(y), m = h.distance + _;
+      if (_ < 0)
+        throw new Error("dijkstra does not allow negative edge weights. Bad edge: " + y + " Weight: " + _);
+      m < v.distance && (v.distance = m, v.predecessor = c, o.decrease(p, m));
+    };
+    for (t.nodes().forEach(function(y) {
+      var p = y === s ? 0 : Number.POSITIVE_INFINITY;
+      d[y] = { distance: p }, o.add(y, p);
+    }); o.size() > 0 && (c = o.removeMin(), h = d[c], h.distance !== Number.POSITIVE_INFINITY); )
+      f(c).forEach(l);
+    return d;
+  }
+  return En;
+}
+var qn, pu;
+function gd() {
+  if (pu) return qn;
+  pu = 1;
+  var e = Co(), a = X();
+  qn = u;
+  function u(n, r, t) {
+    return a.transform(n.nodes(), function(s, i) {
+      s[i] = e(n, i, r, t);
+    }, {});
+  }
+  return qn;
+}
+var Rn, _u;
+function Oo() {
+  if (_u) return Rn;
+  _u = 1;
+  var e = X();
+  Rn = a;
+  function a(u) {
+    var n = 0, r = [], t = {}, s = [];
+    function i(f) {
+      var d = t[f] = {
+        onStack: !0,
+        lowlink: n,
+        index: n++
+      };
+      if (r.push(f), u.successors(f).forEach(function(h) {
+        e.has(t, h) ? t[h].onStack && (d.lowlink = Math.min(d.lowlink, t[h].index)) : (i(h), d.lowlink = Math.min(d.lowlink, t[h].lowlink));
+      }), d.lowlink === d.index) {
+        var o = [], c;
+        do
+          c = r.pop(), t[c].onStack = !1, o.push(c);
+        while (f !== c);
+        s.push(o);
+      }
+    }
+    return u.nodes().forEach(function(f) {
+      e.has(t, f) || i(f);
+    }), s;
+  }
+  return Rn;
+}
+var wn, gu;
+function md() {
+  if (gu) return wn;
+  gu = 1;
+  var e = X(), a = Oo();
+  wn = u;
+  function u(n) {
+    return e.filter(a(n), function(r) {
+      return r.length > 1 || r.length === 1 && n.hasEdge(r[0], r[0]);
+    });
+  }
+  return wn;
+}
+var Tn, mu;
+function bd() {
+  if (mu) return Tn;
+  mu = 1;
+  var e = X();
+  Tn = u;
+  var a = e.constant(1);
+  function u(r, t, s) {
+    return n(
+      r,
+      t || a,
+      s || function(i) {
+        return r.outEdges(i);
+      }
+    );
+  }
+  function n(r, t, s) {
+    var i = {}, f = r.nodes();
+    return f.forEach(function(d) {
+      i[d] = {}, i[d][d] = { distance: 0 }, f.forEach(function(o) {
+        d !== o && (i[d][o] = { distance: Number.POSITIVE_INFINITY });
+      }), s(d).forEach(function(o) {
+        var c = o.v === d ? o.w : o.v, h = t(o);
+        i[d][c] = { distance: h, predecessor: d };
+      });
+    }), f.forEach(function(d) {
+      var o = i[d];
+      f.forEach(function(c) {
+        var h = i[c];
+        f.forEach(function(l) {
+          var y = h[d], p = o[l], v = h[l], _ = y.distance + p.distance;
+          _ < v.distance && (v.distance = _, v.predecessor = p.predecessor);
+        });
+      });
+    }), i;
+  }
+  return Tn;
+}
+var In, bu;
+function No() {
+  if (bu) return In;
+  bu = 1;
+  var e = X();
+  In = a, a.CycleException = u;
+  function a(n) {
+    var r = {}, t = {}, s = [];
+    function i(f) {
+      if (e.has(t, f))
+        throw new u();
+      e.has(r, f) || (t[f] = !0, r[f] = !0, e.each(n.predecessors(f), i), delete t[f], s.push(f));
+    }
+    if (e.each(n.sinks(), i), e.size(r) !== n.nodeCount())
+      throw new u();
+    return s;
+  }
+  function u() {
+  }
+  return u.prototype = new Error(), In;
+}
+var Sn, yu;
+function yd() {
+  if (yu) return Sn;
+  yu = 1;
+  var e = No();
+  Sn = a;
+  function a(u) {
+    try {
+      e(u);
+    } catch (n) {
+      if (n instanceof e.CycleException)
+        return !1;
+      throw n;
+    }
+    return !0;
+  }
+  return Sn;
+}
+var Cn, Eu;
+function Ao() {
+  if (Eu) return Cn;
+  Eu = 1;
+  var e = X();
+  Cn = a;
+  function a(n, r, t) {
+    e.isArray(r) || (r = [r]);
+    var s = (n.isDirected() ? n.successors : n.neighbors).bind(n), i = [], f = {};
+    return e.each(r, function(d) {
+      if (!n.hasNode(d))
+        throw new Error("Graph does not have node: " + d);
+      u(n, d, t === "post", f, s, i);
+    }), i;
+  }
+  function u(n, r, t, s, i, f) {
+    e.has(s, r) || (s[r] = !0, t || f.push(r), e.each(i(r), function(d) {
+      u(n, d, t, s, i, f);
+    }), t && f.push(r));
+  }
+  return Cn;
+}
+var On, qu;
+function Ed() {
+  if (qu) return On;
+  qu = 1;
+  var e = Ao();
+  On = a;
+  function a(u, n) {
+    return e(u, n, "post");
+  }
+  return On;
+}
+var Nn, Ru;
+function qd() {
+  if (Ru) return Nn;
+  Ru = 1;
+  var e = Ao();
+  Nn = a;
+  function a(u, n) {
+    return e(u, n, "pre");
+  }
+  return Nn;
+}
+var An, wu;
+function Rd() {
+  if (wu) return An;
+  wu = 1;
+  var e = X(), a = vi(), u = So();
+  An = n;
+  function n(r, t) {
+    var s = new a(), i = {}, f = new u(), d;
+    function o(h) {
+      var l = h.v === d ? h.w : h.v, y = f.priority(l);
+      if (y !== void 0) {
+        var p = t(h);
+        p < y && (i[l] = d, f.decrease(l, p));
+      }
+    }
+    if (r.nodeCount() === 0)
+      return s;
+    e.each(r.nodes(), function(h) {
+      f.add(h, Number.POSITIVE_INFINITY), s.setNode(h);
+    }), f.decrease(r.nodes()[0], 0);
+    for (var c = !1; f.size() > 0; ) {
+      if (d = f.removeMin(), e.has(i, d))
+        s.setEdge(d, i[d]);
+      else {
+        if (c)
+          throw new Error("Input graph is not connected: " + r);
+        c = !0;
+      }
+      r.nodeEdges(d).forEach(o);
+    }
+    return s;
+  }
+  return An;
+}
+var xn, Tu;
+function wd() {
+  return Tu || (Tu = 1, xn = {
+    components: _d(),
+    dijkstra: Co(),
+    dijkstraAll: gd(),
+    findCycles: md(),
+    floydWarshall: bd(),
+    isAcyclic: yd(),
+    postorder: Ed(),
+    preorder: qd(),
+    prim: Rd(),
+    tarjan: Oo(),
+    topsort: No()
+  }), xn;
+}
+var Ln, Iu;
+function Td() {
+  if (Iu) return Ln;
+  Iu = 1;
+  var e = vd();
+  return Ln = {
+    Graph: e.Graph,
+    json: pd(),
+    alg: wd(),
+    version: e.version
+  }, Ln;
+}
+var kn, Su;
+function Z() {
+  if (Su) return kn;
+  Su = 1;
+  var e;
+  if (typeof ci == "function")
+    try {
+      e = Td();
+    } catch {
+    }
+  return e || (e = window.graphlib), kn = e, kn;
+}
+var Pn, Cu;
+function Ne() {
+  if (Cu) return Pn;
+  Cu = 1;
+  var e = ye(), a = ue(), u = ai(), n = ae();
+  function r(t, s, i) {
+    if (!n(i))
+      return !1;
+    var f = typeof s;
+    return (f == "number" ? a(i) && u(s, i.length) : f == "string" && s in i) ? e(i[s], t) : !1;
+  }
+  return Pn = r, Pn;
+}
+var Mn, Ou;
+function Id() {
+  if (Ou) return Mn;
+  Ou = 1;
+  var e = Oe(), a = ye(), u = Ne(), n = we(), r = Object.prototype, t = r.hasOwnProperty, s = e(function(i, f) {
+    i = Object(i);
+    var d = -1, o = f.length, c = o > 2 ? f[2] : void 0;
+    for (c && u(f[0], f[1], c) && (o = 1); ++d < o; )
+      for (var h = f[d], l = n(h), y = -1, p = l.length; ++y < p; ) {
+        var v = l[y], _ = i[v];
+        (_ === void 0 || a(_, r[v]) && !t.call(i, v)) && (i[v] = h[v]);
+      }
+    return i;
+  });
+  return Mn = s, Mn;
+}
+var Fn, Nu;
+function Sd() {
+  if (Nu) return Fn;
+  Nu = 1;
+  var e = ee(), a = ue(), u = le();
+  function n(r) {
+    return function(t, s, i) {
+      var f = Object(t);
+      if (!a(t)) {
+        var d = e(s, 3);
+        t = u(t), s = function(c) {
+          return d(f[c], c, f);
+        };
+      }
+      var o = r(t, s, i);
+      return o > -1 ? f[d ? t[o] : o] : void 0;
+    };
+  }
+  return Fn = n, Fn;
+}
+var Gn, Au;
+function Cd() {
+  if (Au) return Gn;
+  Au = 1;
+  var e = /\s/;
+  function a(u) {
+    for (var n = u.length; n-- && e.test(u.charAt(n)); )
+      ;
+    return n;
+  }
+  return Gn = a, Gn;
+}
+var Dn, xu;
+function Od() {
+  if (xu) return Dn;
+  xu = 1;
+  var e = Cd(), a = /^\s+/;
+  function u(n) {
+    return n && n.slice(0, e(n) + 1).replace(a, "");
+  }
+  return Dn = u, Dn;
+}
+var Un, Lu;
+function Nd() {
+  if (Lu) return Un;
+  Lu = 1;
+  var e = Od(), a = ae(), u = oe(), n = NaN, r = /^[-+]0x[0-9a-f]+$/i, t = /^0b[01]+$/i, s = /^0o[0-7]+$/i, i = parseInt;
+  function f(d) {
+    if (typeof d == "number")
+      return d;
+    if (u(d))
+      return n;
+    if (a(d)) {
+      var o = typeof d.valueOf == "function" ? d.valueOf() : d;
+      d = a(o) ? o + "" : o;
+    }
+    if (typeof d != "string")
+      return d === 0 ? d : +d;
+    d = e(d);
+    var c = t.test(d);
+    return c || s.test(d) ? i(d.slice(2), c ? 2 : 8) : r.test(d) ? n : +d;
+  }
+  return Un = f, Un;
+}
+var Bn, ku;
+function xo() {
+  if (ku) return Bn;
+  ku = 1;
+  var e = Nd(), a = 1 / 0, u = 17976931348623157e292;
+  function n(r) {
+    if (!r)
+      return r === 0 ? r : 0;
+    if (r = e(r), r === a || r === -1 / 0) {
+      var t = r < 0 ? -1 : 1;
+      return t * u;
+    }
+    return r === r ? r : 0;
+  }
+  return Bn = n, Bn;
+}
+var Hn, Pu;
+function Ad() {
+  if (Pu) return Hn;
+  Pu = 1;
+  var e = xo();
+  function a(u) {
+    var n = e(u), r = n % 1;
+    return n === n ? r ? n - r : n : 0;
+  }
+  return Hn = a, Hn;
+}
+var Wn, Mu;
+function xd() {
+  if (Mu) return Wn;
+  Mu = 1;
+  var e = wo(), a = ee(), u = Ad(), n = Math.max;
+  function r(t, s, i) {
+    var f = t == null ? 0 : t.length;
+    if (!f)
+      return -1;
+    var d = i == null ? 0 : u(i);
+    return d < 0 && (d = n(f + d, 0)), e(t, a(s, 3), d);
+  }
+  return Wn = r, Wn;
+}
+var Vn, Fu;
+function Ld() {
+  if (Fu) return Vn;
+  Fu = 1;
+  var e = Sd(), a = xd(), u = e(a);
+  return Vn = u, Vn;
+}
+var zn, Gu;
+function Lo() {
+  if (Gu) return zn;
+  Gu = 1;
+  var e = li();
+  function a(u) {
+    var n = u == null ? 0 : u.length;
+    return n ? e(u, 1) : [];
+  }
+  return zn = a, zn;
+}
+var jn, Du;
+function kd() {
+  if (Du) return jn;
+  Du = 1;
+  var e = si(), a = lo(), u = we();
+  function n(r, t) {
+    return r == null ? r : e(r, a(t), u);
+  }
+  return jn = n, jn;
+}
+var Kn, Uu;
+function Pd() {
+  if (Uu) return Kn;
+  Uu = 1;
+  function e(a) {
+    var u = a == null ? 0 : a.length;
+    return u ? a[u - 1] : void 0;
+  }
+  return Kn = e, Kn;
+}
+var Yn, Bu;
+function pi() {
+  if (Bu) return Yn;
+  Bu = 1;
+  var e = oe();
+  function a(u, n, r) {
+    for (var t = -1, s = u.length; ++t < s; ) {
+      var i = u[t], f = n(i);
+      if (f != null && (d === void 0 ? f === f && !e(f) : r(f, d)))
+        var d = f, o = i;
+    }
+    return o;
+  }
+  return Yn = a, Yn;
+}
+var $n, Hu;
+function Md() {
+  if (Hu) return $n;
+  Hu = 1;
+  function e(a, u) {
+    return a > u;
+  }
+  return $n = e, $n;
+}
+var Xn, Wu;
+function Fd() {
+  if (Wu) return Xn;
+  Wu = 1;
+  var e = pi(), a = Md(), u = se();
+  function n(r) {
+    return r && r.length ? e(r, u, a) : void 0;
+  }
+  return Xn = n, Xn;
+}
+var Zn, Vu;
+function ko() {
+  if (Vu) return Zn;
+  Vu = 1;
+  var e = Zs(), a = ye();
+  function u(n, r, t) {
+    (t !== void 0 && !a(n[r], t) || t === void 0 && !(r in n)) && e(n, r, t);
+  }
+  return Zn = u, Zn;
+}
+var Qn, zu;
+function Gd() {
+  if (zu) return Qn;
+  zu = 1;
+  var e = ii(), a = eo(), u = ve(), n = "[object Object]", r = Function.prototype, t = Object.prototype, s = r.toString, i = t.hasOwnProperty, f = s.call(Object);
+  function d(o) {
+    if (!u(o) || e(o) != n)
+      return !1;
+    var c = a(o);
+    if (c === null)
+      return !0;
+    var h = i.call(c, "constructor") && c.constructor;
+    return typeof h == "function" && h instanceof h && s.call(h) == f;
+  }
+  return Qn = d, Qn;
+}
+var Jn, ju;
+function Po() {
+  if (ju) return Jn;
+  ju = 1;
+  function e(a, u) {
+    if (!(u === "constructor" && typeof a[u] == "function") && u != "__proto__")
+      return a[u];
+  }
+  return Jn = e, Jn;
+}
+var et, Ku;
+function Dd() {
+  if (Ku) return et;
+  Ku = 1;
+  var e = nf(), a = we();
+  function u(n) {
+    return e(n, a(n));
+  }
+  return et = u, et;
+}
+var rt, Yu;
+function Ud() {
+  if (Yu) return rt;
+  Yu = 1;
+  var e = ko(), a = tf(), u = af(), n = uf(), r = sf(), t = Re(), s = W(), i = To(), f = Ee(), d = ui(), o = ae(), c = Gd(), h = qe(), l = Po(), y = Dd();
+  function p(v, _, m, g, b, E, w) {
+    var q = l(v, m), S = l(_, m), O = w.get(S);
+    if (O) {
+      e(v, m, O);
+      return;
+    }
+    var I = E ? E(q, S, m + "", v, _, w) : void 0, x = I === void 0;
+    if (x) {
+      var L = s(S), k = !L && f(S), P = !L && !k && h(S);
+      I = S, L || k || P ? s(q) ? I = q : i(q) ? I = n(q) : k ? (x = !1, I = a(S, !0)) : P ? (x = !1, I = u(S, !0)) : I = [] : c(S) || t(S) ? (I = q, t(q) ? I = y(q) : (!o(q) || d(q)) && (I = r(S))) : x = !1;
+    }
+    x && (w.set(S, I), b(I, S, g, E, w), w.delete(S)), e(v, m, I);
+  }
+  return rt = p, rt;
+}
+var nt, $u;
+function Bd() {
+  if ($u) return nt;
+  $u = 1;
+  var e = ni(), a = ko(), u = si(), n = Ud(), r = ae(), t = we(), s = Po();
+  function i(f, d, o, c, h) {
+    f !== d && u(d, function(l, y) {
+      if (h || (h = new e()), r(l))
+        n(f, d, y, o, i, c, h);
+      else {
+        var p = c ? c(s(f, y), l, y + "", f, d, h) : void 0;
+        p === void 0 && (p = l), a(f, y, p);
+      }
+    }, t);
+  }
+  return nt = i, nt;
+}
+var tt, Xu;
+function Hd() {
+  if (Xu) return tt;
+  Xu = 1;
+  var e = Oe(), a = Ne();
+  function u(n) {
+    return e(function(r, t) {
+      var s = -1, i = t.length, f = i > 1 ? t[i - 1] : void 0, d = i > 2 ? t[2] : void 0;
+      for (f = n.length > 3 && typeof f == "function" ? (i--, f) : void 0, d && a(t[0], t[1], d) && (f = i < 3 ? void 0 : f, i = 1), r = Object(r); ++s < i; ) {
+        var o = t[s];
+        o && n(r, o, s, f);
+      }
+      return r;
+    });
+  }
+  return tt = u, tt;
+}
+var it, Zu;
+function Wd() {
+  if (Zu) return it;
+  Zu = 1;
+  var e = Bd(), a = Hd(), u = a(function(n, r, t) {
+    e(n, r, t);
+  });
+  return it = u, it;
+}
+var at, Qu;
+function Mo() {
+  if (Qu) return at;
+  Qu = 1;
+  function e(a, u) {
+    return a < u;
+  }
+  return at = e, at;
+}
+var ut, Ju;
+function Vd() {
+  if (Ju) return ut;
+  Ju = 1;
+  var e = pi(), a = Mo(), u = se();
+  function n(r) {
+    return r && r.length ? e(r, u, a) : void 0;
+  }
+  return ut = n, ut;
+}
+var st, es;
+function zd() {
+  if (es) return st;
+  es = 1;
+  var e = pi(), a = ee(), u = Mo();
+  function n(r, t) {
+    return r && r.length ? e(r, a(t, 2), u) : void 0;
+  }
+  return st = n, st;
+}
+var ot, rs;
+function jd() {
+  if (rs) return ot;
+  rs = 1;
+  var e = of(), a = function() {
+    return e.Date.now();
+  };
+  return ot = a, ot;
+}
+var ft, ns;
+function Kd() {
+  if (ns) return ft;
+  ns = 1;
+  var e = ro(), a = Ie(), u = ai(), n = ae(), r = pe();
+  function t(s, i, f, d) {
+    if (!n(s))
+      return s;
+    i = a(i, s);
+    for (var o = -1, c = i.length, h = c - 1, l = s; l != null && ++o < c; ) {
+      var y = r(i[o]), p = f;
+      if (y === "__proto__" || y === "constructor" || y === "prototype")
+        return s;
+      if (o != h) {
+        var v = l[y];
+        p = d ? d(v, y, l) : void 0, p === void 0 && (p = n(v) ? v : u(i[o + 1]) ? [] : {});
+      }
+      e(l, y, p), l = l[y];
+    }
+    return s;
+  }
+  return ft = t, ft;
+}
+var dt, ts;
+function Yd() {
+  if (ts) return dt;
+  ts = 1;
+  var e = Se(), a = Kd(), u = Ie();
+  function n(r, t, s) {
+    for (var i = -1, f = t.length, d = {}; ++i < f; ) {
+      var o = t[i], c = e(r, o);
+      s(c, o) && a(d, u(o, r), c);
+    }
+    return d;
+  }
+  return dt = n, dt;
+}
+var ct, is;
+function $d() {
+  if (is) return ct;
+  is = 1;
+  var e = Yd(), a = co();
+  function u(n, r) {
+    return e(n, r, function(t, s) {
+      return a(n, s);
+    });
+  }
+  return ct = u, ct;
+}
+var ht, as;
+function Xd() {
+  if (as) return ht;
+  as = 1;
+  var e = Lo(), a = qo(), u = Ro();
+  function n(r) {
+    return u(a(r, void 0, e), r + "");
+  }
+  return ht = n, ht;
+}
+var lt, us;
+function Zd() {
+  if (us) return lt;
+  us = 1;
+  var e = $d(), a = Xd(), u = a(function(n, r) {
+    return n == null ? {} : e(n, r);
+  });
+  return lt = u, lt;
+}
+var vt, ss;
+function Qd() {
+  if (ss) return vt;
+  ss = 1;
+  var e = Math.ceil, a = Math.max;
+  function u(n, r, t, s) {
+    for (var i = -1, f = a(e((r - n) / (t || 1)), 0), d = Array(f); f--; )
+      d[s ? f : ++i] = n, n += t;
+    return d;
+  }
+  return vt = u, vt;
+}
+var pt, os;
+function Jd() {
+  if (os) return pt;
+  os = 1;
+  var e = Qd(), a = Ne(), u = xo();
+  function n(r) {
+    return function(t, s, i) {
+      return i && typeof i != "number" && a(t, s, i) && (s = i = void 0), t = u(t), s === void 0 ? (s = t, t = 0) : s = u(s), i = i === void 0 ? t < s ? 1 : -1 : u(i), e(t, s, i, r);
+    };
+  }
+  return pt = n, pt;
+}
+var _t, fs;
+function ec() {
+  if (fs) return _t;
+  fs = 1;
+  var e = Jd(), a = e();
+  return _t = a, _t;
+}
+var gt, ds;
+function rc() {
+  if (ds) return gt;
+  ds = 1;
+  function e(a, u) {
+    var n = a.length;
+    for (a.sort(u); n--; )
+      a[n] = a[n].value;
+    return a;
+  }
+  return gt = e, gt;
+}
+var mt, cs;
+function nc() {
+  if (cs) return mt;
+  cs = 1;
+  var e = oe();
+  function a(u, n) {
+    if (u !== n) {
+      var r = u !== void 0, t = u === null, s = u === u, i = e(u), f = n !== void 0, d = n === null, o = n === n, c = e(n);
+      if (!d && !c && !i && u > n || i && f && o && !d && !c || t && f && o || !r && o || !s)
+        return 1;
+      if (!t && !i && !c && u < n || c && r && s && !t && !i || d && r && s || !f && s || !o)
+        return -1;
+    }
+    return 0;
+  }
+  return mt = a, mt;
+}
+var bt, hs;
+function tc() {
+  if (hs) return bt;
+  hs = 1;
+  var e = nc();
+  function a(u, n, r) {
+    for (var t = -1, s = u.criteria, i = n.criteria, f = s.length, d = r.length; ++t < f; ) {
+      var o = e(s[t], i[t]);
+      if (o) {
+        if (t >= d)
+          return o;
+        var c = r[t];
+        return o * (c == "desc" ? -1 : 1);
+      }
+    }
+    return u.index - n.index;
+  }
+  return bt = a, bt;
+}
+var yt, ls;
+function ic() {
+  if (ls) return yt;
+  ls = 1;
+  var e = Te(), a = Se(), u = ee(), n = bo(), r = rc(), t = ff(), s = tc(), i = se(), f = W();
+  function d(o, c, h) {
+    c.length ? c = e(c, function(p) {
+      return f(p) ? function(v) {
+        return a(v, p.length === 1 ? p[0] : p);
+      } : p;
+    }) : c = [i];
+    var l = -1;
+    c = e(c, t(u));
+    var y = n(o, function(p, v, _) {
+      var m = e(c, function(g) {
+        return g(p);
+      });
+      return { criteria: m, index: ++l, value: p };
+    });
+    return r(y, function(p, v) {
+      return s(p, v, h);
+    });
+  }
+  return yt = d, yt;
+}
+var Et, vs;
+function ac() {
+  if (vs) return Et;
+  vs = 1;
+  var e = li(), a = ic(), u = Oe(), n = Ne(), r = u(function(t, s) {
+    if (t == null)
+      return [];
+    var i = s.length;
+    return i > 1 && n(t, s[0], s[1]) ? s = [] : i > 2 && n(s[0], s[1], s[2]) && (s = [s[0]]), a(t, e(s, 1), []);
+  });
+  return Et = r, Et;
+}
+var qt, ps;
+function uc() {
+  if (ps) return qt;
+  ps = 1;
+  var e = oo(), a = 0;
+  function u(n) {
+    var r = ++a;
+    return e(n) + r;
+  }
+  return qt = u, qt;
+}
+var Rt, _s;
+function sc() {
+  if (_s) return Rt;
+  _s = 1;
+  function e(a, u, n) {
+    for (var r = -1, t = a.length, s = u.length, i = {}; ++r < t; ) {
+      var f = r < s ? u[r] : void 0;
+      n(i, a[r], f);
+    }
+    return i;
+  }
+  return Rt = e, Rt;
+}
+var wt, gs;
+function oc() {
+  if (gs) return wt;
+  gs = 1;
+  var e = ro(), a = sc();
+  function u(n, r) {
+    return a(n || [], r || [], e);
+  }
+  return wt = u, wt;
+}
+var Tt, ms;
+function G() {
+  if (ms) return Tt;
+  ms = 1;
+  var e;
+  if (typeof ci == "function")
+    try {
+      e = {
+        cloneDeep: df(),
+        constant: hi(),
+        defaults: Id(),
+        each: po(),
+        filter: _o(),
+        find: Ld(),
+        flatten: Lo(),
+        forEach: vo(),
+        forIn: kd(),
+        has: go(),
+        isUndefined: mo(),
+        last: Pd(),
+        map: yo(),
+        mapValues: Pf(),
+        max: Fd(),
+        merge: Wd(),
+        min: Vd(),
+        minBy: zd(),
+        now: jd(),
+        pick: Zd(),
+        range: ec(),
+        reduce: Eo(),
+        sortBy: ac(),
+        uniqueId: uc(),
+        values: Io(),
+        zipObject: oc()
+      };
+    } catch {
+    }
+  return e || (e = window._), Tt = e, Tt;
+}
+var It, bs;
+function fc() {
+  if (bs) return It;
+  bs = 1, It = e;
+  function e() {
+    var n = {};
+    n._next = n._prev = n, this._sentinel = n;
+  }
+  e.prototype.dequeue = function() {
+    var n = this._sentinel, r = n._prev;
+    if (r !== n)
+      return a(r), r;
+  }, e.prototype.enqueue = function(n) {
+    var r = this._sentinel;
+    n._prev && n._next && a(n), n._next = r._next, r._next._prev = n, r._next = n, n._prev = r;
+  }, e.prototype.toString = function() {
+    for (var n = [], r = this._sentinel, t = r._prev; t !== r; )
+      n.push(JSON.stringify(t, u)), t = t._prev;
+    return "[" + n.join(", ") + "]";
+  };
+  function a(n) {
+    n._prev._next = n._next, n._next._prev = n._prev, delete n._next, delete n._prev;
+  }
+  function u(n, r) {
+    if (n !== "_next" && n !== "_prev")
+      return r;
+  }
+  return It;
+}
+var St, ys;
+function dc() {
+  if (ys) return St;
+  ys = 1;
+  var e = G(), a = Z().Graph, u = fc();
+  St = r;
+  var n = e.constant(1);
+  function r(d, o) {
+    if (d.nodeCount() <= 1)
+      return [];
+    var c = i(d, o || n), h = t(c.graph, c.buckets, c.zeroIdx);
+    return e.flatten(e.map(h, function(l) {
+      return d.outEdges(l.v, l.w);
+    }), !0);
+  }
+  function t(d, o, c) {
+    for (var h = [], l = o[o.length - 1], y = o[0], p; d.nodeCount(); ) {
+      for (; p = y.dequeue(); )
+        s(d, o, c, p);
+      for (; p = l.dequeue(); )
+        s(d, o, c, p);
+      if (d.nodeCount()) {
+        for (var v = o.length - 2; v > 0; --v)
+          if (p = o[v].dequeue(), p) {
+            h = h.concat(s(d, o, c, p, !0));
+            break;
+          }
+      }
+    }
+    return h;
+  }
+  function s(d, o, c, h, l) {
+    var y = l ? [] : void 0;
+    return e.forEach(d.inEdges(h.v), function(p) {
+      var v = d.edge(p), _ = d.node(p.v);
+      l && y.push({ v: p.v, w: p.w }), _.out -= v, f(o, c, _);
+    }), e.forEach(d.outEdges(h.v), function(p) {
+      var v = d.edge(p), _ = p.w, m = d.node(_);
+      m.in -= v, f(o, c, m);
+    }), d.removeNode(h.v), y;
+  }
+  function i(d, o) {
+    var c = new a(), h = 0, l = 0;
+    e.forEach(d.nodes(), function(v) {
+      c.setNode(v, { v, in: 0, out: 0 });
+    }), e.forEach(d.edges(), function(v) {
+      var _ = c.edge(v.v, v.w) || 0, m = o(v), g = _ + m;
+      c.setEdge(v.v, v.w, g), l = Math.max(l, c.node(v.v).out += m), h = Math.max(h, c.node(v.w).in += m);
+    });
+    var y = e.range(l + h + 3).map(function() {
+      return new u();
+    }), p = h + 1;
+    return e.forEach(c.nodes(), function(v) {
+      f(y, p, c.node(v));
+    }), { graph: c, buckets: y, zeroIdx: p };
+  }
+  function f(d, o, c) {
+    c.out ? c.in ? d[c.out - c.in + o].enqueue(c) : d[d.length - 1].enqueue(c) : d[0].enqueue(c);
+  }
+  return St;
+}
+var Ct, Es;
+function cc() {
+  if (Es) return Ct;
+  Es = 1;
+  var e = G(), a = dc();
+  Ct = {
+    run: u,
+    undo: r
+  };
+  function u(t) {
+    var s = t.graph().acyclicer === "greedy" ? a(t, i(t)) : n(t);
+    e.forEach(s, function(f) {
+      var d = t.edge(f);
+      t.removeEdge(f), d.forwardName = f.name, d.reversed = !0, t.setEdge(f.w, f.v, d, e.uniqueId("rev"));
+    });
+    function i(f) {
+      return function(d) {
+        return f.edge(d).weight;
+      };
+    }
+  }
+  function n(t) {
+    var s = [], i = {}, f = {};
+    function d(o) {
+      e.has(f, o) || (f[o] = !0, i[o] = !0, e.forEach(t.outEdges(o), function(c) {
+        e.has(i, c.w) ? s.push(c) : d(c.w);
+      }), delete i[o]);
+    }
+    return e.forEach(t.nodes(), d), s;
+  }
+  function r(t) {
+    e.forEach(t.edges(), function(s) {
+      var i = t.edge(s);
+      if (i.reversed) {
+        t.removeEdge(s);
+        var f = i.forwardName;
+        delete i.reversed, delete i.forwardName, t.setEdge(s.w, s.v, i, f);
+      }
+    });
+  }
+  return Ct;
+}
+var Ot, qs;
+function j() {
+  if (qs) return Ot;
+  qs = 1;
+  var e = G(), a = Z().Graph;
+  Ot = {
+    addDummyNode: u,
+    simplify: n,
+    asNonCompoundGraph: r,
+    successorWeights: t,
+    predecessorWeights: s,
+    intersectRect: i,
+    buildLayerMatrix: f,
+    normalizeRanks: d,
+    removeEmptyRanks: o,
+    addBorderNode: c,
+    maxRank: h,
+    partition: l,
+    time: y,
+    notime: p
+  };
+  function u(v, _, m, g) {
+    var b;
+    do
+      b = e.uniqueId(g);
+    while (v.hasNode(b));
+    return m.dummy = _, v.setNode(b, m), b;
+  }
+  function n(v) {
+    var _ = new a().setGraph(v.graph());
+    return e.forEach(v.nodes(), function(m) {
+      _.setNode(m, v.node(m));
+    }), e.forEach(v.edges(), function(m) {
+      var g = _.edge(m.v, m.w) || { weight: 0, minlen: 1 }, b = v.edge(m);
+      _.setEdge(m.v, m.w, {
+        weight: g.weight + b.weight,
+        minlen: Math.max(g.minlen, b.minlen)
+      });
+    }), _;
+  }
+  function r(v) {
+    var _ = new a({ multigraph: v.isMultigraph() }).setGraph(v.graph());
+    return e.forEach(v.nodes(), function(m) {
+      v.children(m).length || _.setNode(m, v.node(m));
+    }), e.forEach(v.edges(), function(m) {
+      _.setEdge(m, v.edge(m));
+    }), _;
+  }
+  function t(v) {
+    var _ = e.map(v.nodes(), function(m) {
+      var g = {};
+      return e.forEach(v.outEdges(m), function(b) {
+        g[b.w] = (g[b.w] || 0) + v.edge(b).weight;
+      }), g;
+    });
+    return e.zipObject(v.nodes(), _);
+  }
+  function s(v) {
+    var _ = e.map(v.nodes(), function(m) {
+      var g = {};
+      return e.forEach(v.inEdges(m), function(b) {
+        g[b.v] = (g[b.v] || 0) + v.edge(b).weight;
+      }), g;
+    });
+    return e.zipObject(v.nodes(), _);
+  }
+  function i(v, _) {
+    var m = v.x, g = v.y, b = _.x - m, E = _.y - g, w = v.width / 2, q = v.height / 2;
+    if (!b && !E)
+      throw new Error("Not possible to find intersection inside of the rectangle");
+    var S, O;
+    return Math.abs(E) * w > Math.abs(b) * q ? (E < 0 && (q = -q), S = q * b / E, O = q) : (b < 0 && (w = -w), S = w, O = w * E / b), { x: m + S, y: g + O };
+  }
+  function f(v) {
+    var _ = e.map(e.range(h(v) + 1), function() {
+      return [];
+    });
+    return e.forEach(v.nodes(), function(m) {
+      var g = v.node(m), b = g.rank;
+      e.isUndefined(b) || (_[b][g.order] = m);
+    }), _;
+  }
+  function d(v) {
+    var _ = e.min(e.map(v.nodes(), function(m) {
+      return v.node(m).rank;
+    }));
+    e.forEach(v.nodes(), function(m) {
+      var g = v.node(m);
+      e.has(g, "rank") && (g.rank -= _);
+    });
+  }
+  function o(v) {
+    var _ = e.min(e.map(v.nodes(), function(E) {
+      return v.node(E).rank;
+    })), m = [];
+    e.forEach(v.nodes(), function(E) {
+      var w = v.node(E).rank - _;
+      m[w] || (m[w] = []), m[w].push(E);
+    });
+    var g = 0, b = v.graph().nodeRankFactor;
+    e.forEach(m, function(E, w) {
+      e.isUndefined(E) && w % b !== 0 ? --g : g && e.forEach(E, function(q) {
+        v.node(q).rank += g;
+      });
+    });
+  }
+  function c(v, _, m, g) {
+    var b = {
+      width: 0,
+      height: 0
+    };
+    return arguments.length >= 4 && (b.rank = m, b.order = g), u(v, "border", b, _);
+  }
+  function h(v) {
+    return e.max(e.map(v.nodes(), function(_) {
+      var m = v.node(_).rank;
+      if (!e.isUndefined(m))
+        return m;
+    }));
+  }
+  function l(v, _) {
+    var m = { lhs: [], rhs: [] };
+    return e.forEach(v, function(g) {
+      _(g) ? m.lhs.push(g) : m.rhs.push(g);
+    }), m;
+  }
+  function y(v, _) {
+    var m = e.now();
+    try {
+      return _();
+    } finally {
+      console.log(v + " time: " + (e.now() - m) + "ms");
+    }
+  }
+  function p(v, _) {
+    return _();
+  }
+  return Ot;
+}
+var Nt, Rs;
+function hc() {
+  if (Rs) return Nt;
+  Rs = 1;
+  var e = G(), a = j();
+  Nt = {
+    run: u,
+    undo: r
+  };
+  function u(t) {
+    t.graph().dummyChains = [], e.forEach(t.edges(), function(s) {
+      n(t, s);
+    });
+  }
+  function n(t, s) {
+    var i = s.v, f = t.node(i).rank, d = s.w, o = t.node(d).rank, c = s.name, h = t.edge(s), l = h.labelRank;
+    if (o !== f + 1) {
+      t.removeEdge(s);
+      var y, p, v;
+      for (v = 0, ++f; f < o; ++v, ++f)
+        h.points = [], p = {
+          width: 0,
+          height: 0,
+          edgeLabel: h,
+          edgeObj: s,
+          rank: f
+        }, y = a.addDummyNode(t, "edge", p, "_d"), f === l && (p.width = h.width, p.height = h.height, p.dummy = "edge-label", p.labelpos = h.labelpos), t.setEdge(i, y, { weight: h.weight }, c), v === 0 && t.graph().dummyChains.push(y), i = y;
+      t.setEdge(i, d, { weight: h.weight }, c);
+    }
+  }
+  function r(t) {
+    e.forEach(t.graph().dummyChains, function(s) {
+      var i = t.node(s), f = i.edgeLabel, d;
+      for (t.setEdge(i.edgeObj, f); i.dummy; )
+        d = t.successors(s)[0], t.removeNode(s), f.points.push({ x: i.x, y: i.y }), i.dummy === "edge-label" && (f.x = i.x, f.y = i.y, f.width = i.width, f.height = i.height), s = d, i = t.node(s);
+    });
+  }
+  return Nt;
+}
+var At, ws;
+function _e() {
+  if (ws) return At;
+  ws = 1;
+  var e = G();
+  At = {
+    longestPath: a,
+    slack: u
+  };
+  function a(n) {
+    var r = {};
+    function t(s) {
+      var i = n.node(s);
+      if (e.has(r, s))
+        return i.rank;
+      r[s] = !0;
+      var f = e.min(e.map(n.outEdges(s), function(d) {
+        return t(d.w) - n.edge(d).minlen;
+      }));
+      return (f === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
+      f === void 0 || // return value of _.map([]) for Lodash 4
+      f === null) && (f = 0), i.rank = f;
+    }
+    e.forEach(n.sources(), t);
+  }
+  function u(n, r) {
+    return n.node(r.w).rank - n.node(r.v).rank - n.edge(r).minlen;
+  }
+  return At;
+}
+var xt, Ts;
+function Fo() {
+  if (Ts) return xt;
+  Ts = 1;
+  var e = G(), a = Z().Graph, u = _e().slack;
+  xt = n;
+  function n(i) {
+    var f = new a({ directed: !1 }), d = i.nodes()[0], o = i.nodeCount();
+    f.setNode(d, {});
+    for (var c, h; r(f, i) < o; )
+      c = t(f, i), h = f.hasNode(c.v) ? u(i, c) : -u(i, c), s(f, i, h);
+    return f;
+  }
+  function r(i, f) {
+    function d(o) {
+      e.forEach(f.nodeEdges(o), function(c) {
+        var h = c.v, l = o === h ? c.w : h;
+        !i.hasNode(l) && !u(f, c) && (i.setNode(l, {}), i.setEdge(o, l, {}), d(l));
+      });
+    }
+    return e.forEach(i.nodes(), d), i.nodeCount();
+  }
+  function t(i, f) {
+    return e.minBy(f.edges(), function(d) {
+      if (i.hasNode(d.v) !== i.hasNode(d.w))
+        return u(f, d);
+    });
+  }
+  function s(i, f, d) {
+    e.forEach(i.nodes(), function(o) {
+      f.node(o).rank += d;
+    });
+  }
+  return xt;
+}
+var Lt, Is;
+function lc() {
+  if (Is) return Lt;
+  Is = 1;
+  var e = G(), a = Fo(), u = _e().slack, n = _e().longestPath, r = Z().alg.preorder, t = Z().alg.postorder, s = j().simplify;
+  Lt = i, i.initLowLimValues = c, i.initCutValues = f, i.calcCutValue = o, i.leaveEdge = l, i.enterEdge = y, i.exchangeEdges = p;
+  function i(g) {
+    g = s(g), n(g);
+    var b = a(g);
+    c(b), f(b, g);
+    for (var E, w; E = l(b); )
+      w = y(b, g, E), p(b, g, E, w);
+  }
+  function f(g, b) {
+    var E = t(g, g.nodes());
+    E = E.slice(0, E.length - 1), e.forEach(E, function(w) {
+      d(g, b, w);
+    });
+  }
+  function d(g, b, E) {
+    var w = g.node(E), q = w.parent;
+    g.edge(E, q).cutvalue = o(g, b, E);
+  }
+  function o(g, b, E) {
+    var w = g.node(E), q = w.parent, S = !0, O = b.edge(E, q), I = 0;
+    return O || (S = !1, O = b.edge(q, E)), I = O.weight, e.forEach(b.nodeEdges(E), function(x) {
+      var L = x.v === E, k = L ? x.w : x.v;
+      if (k !== q) {
+        var P = L === S, F = b.edge(x).weight;
+        if (I += P ? F : -F, _(g, E, k)) {
+          var U = g.edge(E, k).cutvalue;
+          I += P ? -U : U;
+        }
+      }
+    }), I;
+  }
+  function c(g, b) {
+    arguments.length < 2 && (b = g.nodes()[0]), h(g, {}, 1, b);
+  }
+  function h(g, b, E, w, q) {
+    var S = E, O = g.node(w);
+    return b[w] = !0, e.forEach(g.neighbors(w), function(I) {
+      e.has(b, I) || (E = h(g, b, E, I, w));
+    }), O.low = S, O.lim = E++, q ? O.parent = q : delete O.parent, E;
+  }
+  function l(g) {
+    return e.find(g.edges(), function(b) {
+      return g.edge(b).cutvalue < 0;
+    });
+  }
+  function y(g, b, E) {
+    var w = E.v, q = E.w;
+    b.hasEdge(w, q) || (w = E.w, q = E.v);
+    var S = g.node(w), O = g.node(q), I = S, x = !1;
+    S.lim > O.lim && (I = O, x = !0);
+    var L = e.filter(b.edges(), function(k) {
+      return x === m(g, g.node(k.v), I) && x !== m(g, g.node(k.w), I);
+    });
+    return e.minBy(L, function(k) {
+      return u(b, k);
+    });
+  }
+  function p(g, b, E, w) {
+    var q = E.v, S = E.w;
+    g.removeEdge(q, S), g.setEdge(w.v, w.w, {}), c(g), f(g, b), v(g, b);
+  }
+  function v(g, b) {
+    var E = e.find(g.nodes(), function(q) {
+      return !b.node(q).parent;
+    }), w = r(g, E);
+    w = w.slice(1), e.forEach(w, function(q) {
+      var S = g.node(q).parent, O = b.edge(q, S), I = !1;
+      O || (O = b.edge(S, q), I = !0), b.node(q).rank = b.node(S).rank + (I ? O.minlen : -O.minlen);
+    });
+  }
+  function _(g, b, E) {
+    return g.hasEdge(b, E);
+  }
+  function m(g, b, E) {
+    return E.low <= b.lim && b.lim <= E.lim;
+  }
+  return Lt;
+}
+var kt, Ss;
+function vc() {
+  if (Ss) return kt;
+  Ss = 1;
+  var e = _e(), a = e.longestPath, u = Fo(), n = lc();
+  kt = r;
+  function r(f) {
+    switch (f.graph().ranker) {
+      case "network-simplex":
+        i(f);
+        break;
+      case "tight-tree":
+        s(f);
+        break;
+      case "longest-path":
+        t(f);
+        break;
+      default:
+        i(f);
+    }
+  }
+  var t = a;
+  function s(f) {
+    a(f), u(f);
+  }
+  function i(f) {
+    n(f);
+  }
+  return kt;
+}
+var Pt, Cs;
+function pc() {
+  if (Cs) return Pt;
+  Cs = 1;
+  var e = G();
+  Pt = a;
+  function a(r) {
+    var t = n(r);
+    e.forEach(r.graph().dummyChains, function(s) {
+      for (var i = r.node(s), f = i.edgeObj, d = u(r, t, f.v, f.w), o = d.path, c = d.lca, h = 0, l = o[h], y = !0; s !== f.w; ) {
+        if (i = r.node(s), y) {
+          for (; (l = o[h]) !== c && r.node(l).maxRank < i.rank; )
+            h++;
+          l === c && (y = !1);
+        }
+        if (!y) {
+          for (; h < o.length - 1 && r.node(l = o[h + 1]).minRank <= i.rank; )
+            h++;
+          l = o[h];
+        }
+        r.setParent(s, l), s = r.successors(s)[0];
+      }
+    });
+  }
+  function u(r, t, s, i) {
+    var f = [], d = [], o = Math.min(t[s].low, t[i].low), c = Math.max(t[s].lim, t[i].lim), h, l;
+    h = s;
+    do
+      h = r.parent(h), f.push(h);
+    while (h && (t[h].low > o || c > t[h].lim));
+    for (l = h, h = i; (h = r.parent(h)) !== l; )
+      d.push(h);
+    return { path: f.concat(d.reverse()), lca: l };
+  }
+  function n(r) {
+    var t = {}, s = 0;
+    function i(f) {
+      var d = s;
+      e.forEach(r.children(f), i), t[f] = { low: d, lim: s++ };
+    }
+    return e.forEach(r.children(), i), t;
+  }
+  return Pt;
+}
+var Mt, Os;
+function _c() {
+  if (Os) return Mt;
+  Os = 1;
+  var e = G(), a = j();
+  Mt = {
+    run: u,
+    cleanup: s
+  };
+  function u(i) {
+    var f = a.addDummyNode(i, "root", {}, "_root"), d = r(i), o = e.max(e.values(d)) - 1, c = 2 * o + 1;
+    i.graph().nestingRoot = f, e.forEach(i.edges(), function(l) {
+      i.edge(l).minlen *= c;
+    });
+    var h = t(i) + 1;
+    e.forEach(i.children(), function(l) {
+      n(i, f, c, h, o, d, l);
+    }), i.graph().nodeRankFactor = c;
+  }
+  function n(i, f, d, o, c, h, l) {
+    var y = i.children(l);
+    if (!y.length) {
+      l !== f && i.setEdge(f, l, { weight: 0, minlen: d });
+      return;
+    }
+    var p = a.addBorderNode(i, "_bt"), v = a.addBorderNode(i, "_bb"), _ = i.node(l);
+    i.setParent(p, l), _.borderTop = p, i.setParent(v, l), _.borderBottom = v, e.forEach(y, function(m) {
+      n(i, f, d, o, c, h, m);
+      var g = i.node(m), b = g.borderTop ? g.borderTop : m, E = g.borderBottom ? g.borderBottom : m, w = g.borderTop ? o : 2 * o, q = b !== E ? 1 : c - h[l] + 1;
+      i.setEdge(p, b, {
+        weight: w,
+        minlen: q,
+        nestingEdge: !0
+      }), i.setEdge(E, v, {
+        weight: w,
+        minlen: q,
+        nestingEdge: !0
+      });
+    }), i.parent(l) || i.setEdge(f, p, { weight: 0, minlen: c + h[l] });
+  }
+  function r(i) {
+    var f = {};
+    function d(o, c) {
+      var h = i.children(o);
+      h && h.length && e.forEach(h, function(l) {
+        d(l, c + 1);
+      }), f[o] = c;
+    }
+    return e.forEach(i.children(), function(o) {
+      d(o, 1);
+    }), f;
+  }
+  function t(i) {
+    return e.reduce(i.edges(), function(f, d) {
+      return f + i.edge(d).weight;
+    }, 0);
+  }
+  function s(i) {
+    var f = i.graph();
+    i.removeNode(f.nestingRoot), delete f.nestingRoot, e.forEach(i.edges(), function(d) {
+      var o = i.edge(d);
+      o.nestingEdge && i.removeEdge(d);
+    });
+  }
+  return Mt;
+}
+var Ft, Ns;
+function gc() {
+  if (Ns) return Ft;
+  Ns = 1;
+  var e = G(), a = j();
+  Ft = u;
+  function u(r) {
+    function t(s) {
+      var i = r.children(s), f = r.node(s);
+      if (i.length && e.forEach(i, t), e.has(f, "minRank")) {
+        f.borderLeft = [], f.borderRight = [];
+        for (var d = f.minRank, o = f.maxRank + 1; d < o; ++d)
+          n(r, "borderLeft", "_bl", s, f, d), n(r, "borderRight", "_br", s, f, d);
+      }
+    }
+    e.forEach(r.children(), t);
+  }
+  function n(r, t, s, i, f, d) {
+    var o = { width: 0, height: 0, rank: d, borderType: t }, c = f[t][d - 1], h = a.addDummyNode(r, "border", o, s);
+    f[t][d] = h, r.setParent(h, i), c && r.setEdge(c, h, { weight: 1 });
+  }
+  return Ft;
+}
+var Gt, As;
+function mc() {
+  if (As) return Gt;
+  As = 1;
+  var e = G();
+  Gt = {
+    adjust: a,
+    undo: u
+  };
+  function a(d) {
+    var o = d.graph().rankdir.toLowerCase();
+    (o === "lr" || o === "rl") && n(d);
+  }
+  function u(d) {
+    var o = d.graph().rankdir.toLowerCase();
+    (o === "bt" || o === "rl") && t(d), (o === "lr" || o === "rl") && (i(d), n(d));
+  }
+  function n(d) {
+    e.forEach(d.nodes(), function(o) {
+      r(d.node(o));
+    }), e.forEach(d.edges(), function(o) {
+      r(d.edge(o));
+    });
+  }
+  function r(d) {
+    var o = d.width;
+    d.width = d.height, d.height = o;
+  }
+  function t(d) {
+    e.forEach(d.nodes(), function(o) {
+      s(d.node(o));
+    }), e.forEach(d.edges(), function(o) {
+      var c = d.edge(o);
+      e.forEach(c.points, s), e.has(c, "y") && s(c);
+    });
+  }
+  function s(d) {
+    d.y = -d.y;
+  }
+  function i(d) {
+    e.forEach(d.nodes(), function(o) {
+      f(d.node(o));
+    }), e.forEach(d.edges(), function(o) {
+      var c = d.edge(o);
+      e.forEach(c.points, f), e.has(c, "x") && f(c);
+    });
+  }
+  function f(d) {
+    var o = d.x;
+    d.x = d.y, d.y = o;
+  }
+  return Gt;
+}
+var Dt, xs;
+function bc() {
+  if (xs) return Dt;
+  xs = 1;
+  var e = G();
+  Dt = a;
+  function a(u) {
+    var n = {}, r = e.filter(u.nodes(), function(d) {
+      return !u.children(d).length;
+    }), t = e.max(e.map(r, function(d) {
+      return u.node(d).rank;
+    })), s = e.map(e.range(t + 1), function() {
+      return [];
+    });
+    function i(d) {
+      if (!e.has(n, d)) {
+        n[d] = !0;
+        var o = u.node(d);
+        s[o.rank].push(d), e.forEach(u.successors(d), i);
+      }
+    }
+    var f = e.sortBy(r, function(d) {
+      return u.node(d).rank;
+    });
+    return e.forEach(f, i), s;
+  }
+  return Dt;
+}
+var Ut, Ls;
+function yc() {
+  if (Ls) return Ut;
+  Ls = 1;
+  var e = G();
+  Ut = a;
+  function a(n, r) {
+    for (var t = 0, s = 1; s < r.length; ++s)
+      t += u(n, r[s - 1], r[s]);
+    return t;
+  }
+  function u(n, r, t) {
+    for (var s = e.zipObject(
+      t,
+      e.map(t, function(h, l) {
+        return l;
+      })
+    ), i = e.flatten(e.map(r, function(h) {
+      return e.sortBy(e.map(n.outEdges(h), function(l) {
+        return { pos: s[l.w], weight: n.edge(l).weight };
+      }), "pos");
+    }), !0), f = 1; f < t.length; ) f <<= 1;
+    var d = 2 * f - 1;
+    f -= 1;
+    var o = e.map(new Array(d), function() {
+      return 0;
+    }), c = 0;
+    return e.forEach(i.forEach(function(h) {
+      var l = h.pos + f;
+      o[l] += h.weight;
+      for (var y = 0; l > 0; )
+        l % 2 && (y += o[l + 1]), l = l - 1 >> 1, o[l] += h.weight;
+      c += h.weight * y;
+    })), c;
+  }
+  return Ut;
+}
+var Bt, ks;
+function Ec() {
+  if (ks) return Bt;
+  ks = 1;
+  var e = G();
+  Bt = a;
+  function a(u, n) {
+    return e.map(n, function(r) {
+      var t = u.inEdges(r);
+      if (t.length) {
+        var s = e.reduce(t, function(i, f) {
+          var d = u.edge(f), o = u.node(f.v);
+          return {
+            sum: i.sum + d.weight * o.order,
+            weight: i.weight + d.weight
+          };
+        }, { sum: 0, weight: 0 });
+        return {
+          v: r,
+          barycenter: s.sum / s.weight,
+          weight: s.weight
+        };
+      } else
+        return { v: r };
+    });
+  }
+  return Bt;
+}
+var Ht, Ps;
+function qc() {
+  if (Ps) return Ht;
+  Ps = 1;
+  var e = G();
+  Ht = a;
+  function a(r, t) {
+    var s = {};
+    e.forEach(r, function(f, d) {
+      var o = s[f.v] = {
+        indegree: 0,
+        in: [],
+        out: [],
+        vs: [f.v],
+        i: d
+      };
+      e.isUndefined(f.barycenter) || (o.barycenter = f.barycenter, o.weight = f.weight);
+    }), e.forEach(t.edges(), function(f) {
+      var d = s[f.v], o = s[f.w];
+      !e.isUndefined(d) && !e.isUndefined(o) && (o.indegree++, d.out.push(s[f.w]));
+    });
+    var i = e.filter(s, function(f) {
+      return !f.indegree;
+    });
+    return u(i);
+  }
+  function u(r) {
+    var t = [];
+    function s(d) {
+      return function(o) {
+        o.merged || (e.isUndefined(o.barycenter) || e.isUndefined(d.barycenter) || o.barycenter >= d.barycenter) && n(d, o);
+      };
+    }
+    function i(d) {
+      return function(o) {
+        o.in.push(d), --o.indegree === 0 && r.push(o);
+      };
+    }
+    for (; r.length; ) {
+      var f = r.pop();
+      t.push(f), e.forEach(f.in.reverse(), s(f)), e.forEach(f.out, i(f));
+    }
+    return e.map(
+      e.filter(t, function(d) {
+        return !d.merged;
+      }),
+      function(d) {
+        return e.pick(d, ["vs", "i", "barycenter", "weight"]);
+      }
+    );
+  }
+  function n(r, t) {
+    var s = 0, i = 0;
+    r.weight && (s += r.barycenter * r.weight, i += r.weight), t.weight && (s += t.barycenter * t.weight, i += t.weight), r.vs = t.vs.concat(r.vs), r.barycenter = s / i, r.weight = i, r.i = Math.min(t.i, r.i), t.merged = !0;
+  }
+  return Ht;
+}
+var Wt, Ms;
+function Rc() {
+  if (Ms) return Wt;
+  Ms = 1;
+  var e = G(), a = j();
+  Wt = u;
+  function u(t, s) {
+    var i = a.partition(t, function(p) {
+      return e.has(p, "barycenter");
+    }), f = i.lhs, d = e.sortBy(i.rhs, function(p) {
+      return -p.i;
+    }), o = [], c = 0, h = 0, l = 0;
+    f.sort(r(!!s)), l = n(o, d, l), e.forEach(f, function(p) {
+      l += p.vs.length, o.push(p.vs), c += p.barycenter * p.weight, h += p.weight, l = n(o, d, l);
+    });
+    var y = { vs: e.flatten(o, !0) };
+    return h && (y.barycenter = c / h, y.weight = h), y;
+  }
+  function n(t, s, i) {
+    for (var f; s.length && (f = e.last(s)).i <= i; )
+      s.pop(), t.push(f.vs), i++;
+    return i;
+  }
+  function r(t) {
+    return function(s, i) {
+      return s.barycenter < i.barycenter ? -1 : s.barycenter > i.barycenter ? 1 : t ? i.i - s.i : s.i - i.i;
+    };
+  }
+  return Wt;
+}
+var Vt, Fs;
+function wc() {
+  if (Fs) return Vt;
+  Fs = 1;
+  var e = G(), a = Ec(), u = qc(), n = Rc();
+  Vt = r;
+  function r(i, f, d, o) {
+    var c = i.children(f), h = i.node(f), l = h ? h.borderLeft : void 0, y = h ? h.borderRight : void 0, p = {};
+    l && (c = e.filter(c, function(E) {
+      return E !== l && E !== y;
+    }));
+    var v = a(i, c);
+    e.forEach(v, function(E) {
+      if (i.children(E.v).length) {
+        var w = r(i, E.v, d, o);
+        p[E.v] = w, e.has(w, "barycenter") && s(E, w);
+      }
+    });
+    var _ = u(v, d);
+    t(_, p);
+    var m = n(_, o);
+    if (l && (m.vs = e.flatten([l, m.vs, y], !0), i.predecessors(l).length)) {
+      var g = i.node(i.predecessors(l)[0]), b = i.node(i.predecessors(y)[0]);
+      e.has(m, "barycenter") || (m.barycenter = 0, m.weight = 0), m.barycenter = (m.barycenter * m.weight + g.order + b.order) / (m.weight + 2), m.weight += 2;
+    }
+    return m;
+  }
+  function t(i, f) {
+    e.forEach(i, function(d) {
+      d.vs = e.flatten(d.vs.map(function(o) {
+        return f[o] ? f[o].vs : o;
+      }), !0);
+    });
+  }
+  function s(i, f) {
+    e.isUndefined(i.barycenter) ? (i.barycenter = f.barycenter, i.weight = f.weight) : (i.barycenter = (i.barycenter * i.weight + f.barycenter * f.weight) / (i.weight + f.weight), i.weight += f.weight);
+  }
+  return Vt;
+}
+var zt, Gs;
+function Tc() {
+  if (Gs) return zt;
+  Gs = 1;
+  var e = G(), a = Z().Graph;
+  zt = u;
+  function u(r, t, s) {
+    var i = n(r), f = new a({ compound: !0 }).setGraph({ root: i }).setDefaultNodeLabel(function(d) {
+      return r.node(d);
+    });
+    return e.forEach(r.nodes(), function(d) {
+      var o = r.node(d), c = r.parent(d);
+      (o.rank === t || o.minRank <= t && t <= o.maxRank) && (f.setNode(d), f.setParent(d, c || i), e.forEach(r[s](d), function(h) {
+        var l = h.v === d ? h.w : h.v, y = f.edge(l, d), p = e.isUndefined(y) ? 0 : y.weight;
+        f.setEdge(l, d, { weight: r.edge(h).weight + p });
+      }), e.has(o, "minRank") && f.setNode(d, {
+        borderLeft: o.borderLeft[t],
+        borderRight: o.borderRight[t]
+      }));
+    }), f;
+  }
+  function n(r) {
+    for (var t; r.hasNode(t = e.uniqueId("_root")); ) ;
+    return t;
+  }
+  return zt;
+}
+var jt, Ds;
+function Ic() {
+  if (Ds) return jt;
+  Ds = 1;
+  var e = G();
+  jt = a;
+  function a(u, n, r) {
+    var t = {}, s;
+    e.forEach(r, function(i) {
+      for (var f = u.parent(i), d, o; f; ) {
+        if (d = u.parent(f), d ? (o = t[d], t[d] = f) : (o = s, s = f), o && o !== f) {
+          n.setEdge(o, f);
+          return;
+        }
+        f = d;
+      }
+    });
+  }
+  return jt;
+}
+var Kt, Us;
+function Sc() {
+  if (Us) return Kt;
+  Us = 1;
+  var e = G(), a = bc(), u = yc(), n = wc(), r = Tc(), t = Ic(), s = Z().Graph, i = j();
+  Kt = f;
+  function f(h) {
+    var l = i.maxRank(h), y = d(h, e.range(1, l + 1), "inEdges"), p = d(h, e.range(l - 1, -1, -1), "outEdges"), v = a(h);
+    c(h, v);
+    for (var _ = Number.POSITIVE_INFINITY, m, g = 0, b = 0; b < 4; ++g, ++b) {
+      o(g % 2 ? y : p, g % 4 >= 2), v = i.buildLayerMatrix(h);
+      var E = u(h, v);
+      E < _ && (b = 0, m = e.cloneDeep(v), _ = E);
+    }
+    c(h, m);
+  }
+  function d(h, l, y) {
+    return e.map(l, function(p) {
+      return r(h, p, y);
+    });
+  }
+  function o(h, l) {
+    var y = new s();
+    e.forEach(h, function(p) {
+      var v = p.graph().root, _ = n(p, v, y, l);
+      e.forEach(_.vs, function(m, g) {
+        p.node(m).order = g;
+      }), t(p, y, _.vs);
+    });
+  }
+  function c(h, l) {
+    e.forEach(l, function(y) {
+      e.forEach(y, function(p, v) {
+        h.node(p).order = v;
+      });
+    });
+  }
+  return Kt;
+}
+var Yt, Bs;
+function Cc() {
+  if (Bs) return Yt;
+  Bs = 1;
+  var e = G(), a = Z().Graph, u = j();
+  Yt = {
+    positionX: y,
+    findType1Conflicts: n,
+    findType2Conflicts: r,
+    addConflict: s,
+    hasConflict: i,
+    verticalAlignment: f,
+    horizontalCompaction: d,
+    alignCoordinates: h,
+    findSmallestWidthAlignment: c,
+    balance: l
+  };
+  function n(_, m) {
+    var g = {};
+    function b(E, w) {
+      var q = 0, S = 0, O = E.length, I = e.last(w);
+      return e.forEach(w, function(x, L) {
+        var k = t(_, x), P = k ? _.node(k).order : O;
+        (k || x === I) && (e.forEach(w.slice(S, L + 1), function(F) {
+          e.forEach(_.predecessors(F), function(U) {
+            var te = _.node(U), ie = te.order;
+            (ie < q || P < ie) && !(te.dummy && _.node(F).dummy) && s(g, U, F);
+          });
+        }), S = L + 1, q = P);
+      }), w;
+    }
+    return e.reduce(m, b), g;
+  }
+  function r(_, m) {
+    var g = {};
+    function b(w, q, S, O, I) {
+      var x;
+      e.forEach(e.range(q, S), function(L) {
+        x = w[L], _.node(x).dummy && e.forEach(_.predecessors(x), function(k) {
+          var P = _.node(k);
+          P.dummy && (P.order < O || P.order > I) && s(g, k, x);
+        });
+      });
+    }
+    function E(w, q) {
+      var S = -1, O, I = 0;
+      return e.forEach(q, function(x, L) {
+        if (_.node(x).dummy === "border") {
+          var k = _.predecessors(x);
+          k.length && (O = _.node(k[0]).order, b(q, I, L, S, O), I = L, S = O);
+        }
+        b(q, I, q.length, O, w.length);
+      }), q;
+    }
+    return e.reduce(m, E), g;
+  }
+  function t(_, m) {
+    if (_.node(m).dummy)
+      return e.find(_.predecessors(m), function(g) {
+        return _.node(g).dummy;
+      });
+  }
+  function s(_, m, g) {
+    if (m > g) {
+      var b = m;
+      m = g, g = b;
+    }
+    var E = _[m];
+    E || (_[m] = E = {}), E[g] = !0;
+  }
+  function i(_, m, g) {
+    if (m > g) {
+      var b = m;
+      m = g, g = b;
+    }
+    return e.has(_[m], g);
+  }
+  function f(_, m, g, b) {
+    var E = {}, w = {}, q = {};
+    return e.forEach(m, function(S) {
+      e.forEach(S, function(O, I) {
+        E[O] = O, w[O] = O, q[O] = I;
+      });
+    }), e.forEach(m, function(S) {
+      var O = -1;
+      e.forEach(S, function(I) {
+        var x = b(I);
+        if (x.length) {
+          x = e.sortBy(x, function(U) {
+            return q[U];
+          });
+          for (var L = (x.length - 1) / 2, k = Math.floor(L), P = Math.ceil(L); k <= P; ++k) {
+            var F = x[k];
+            w[I] === I && O < q[F] && !i(g, I, F) && (w[F] = I, w[I] = E[I] = E[F], O = q[F]);
+          }
+        }
+      });
+    }), { root: E, align: w };
+  }
+  function d(_, m, g, b, E) {
+    var w = {}, q = o(_, m, g, E), S = E ? "borderLeft" : "borderRight";
+    function O(L, k) {
+      for (var P = q.nodes(), F = P.pop(), U = {}; F; )
+        U[F] ? L(F) : (U[F] = !0, P.push(F), P = P.concat(k(F))), F = P.pop();
+    }
+    function I(L) {
+      w[L] = q.inEdges(L).reduce(function(k, P) {
+        return Math.max(k, w[P.v] + q.edge(P));
+      }, 0);
+    }
+    function x(L) {
+      var k = q.outEdges(L).reduce(function(F, U) {
+        return Math.min(F, w[U.w] - q.edge(U));
+      }, Number.POSITIVE_INFINITY), P = _.node(L);
+      k !== Number.POSITIVE_INFINITY && P.borderType !== S && (w[L] = Math.max(w[L], k));
+    }
+    return O(I, q.predecessors.bind(q)), O(x, q.successors.bind(q)), e.forEach(b, function(L) {
+      w[L] = w[g[L]];
+    }), w;
+  }
+  function o(_, m, g, b) {
+    var E = new a(), w = _.graph(), q = p(w.nodesep, w.edgesep, b);
+    return e.forEach(m, function(S) {
+      var O;
+      e.forEach(S, function(I) {
+        var x = g[I];
+        if (E.setNode(x), O) {
+          var L = g[O], k = E.edge(L, x);
+          E.setEdge(L, x, Math.max(q(_, I, O), k || 0));
+        }
+        O = I;
+      });
+    }), E;
+  }
+  function c(_, m) {
+    return e.minBy(e.values(m), function(g) {
+      var b = Number.NEGATIVE_INFINITY, E = Number.POSITIVE_INFINITY;
+      return e.forIn(g, function(w, q) {
+        var S = v(_, q) / 2;
+        b = Math.max(w + S, b), E = Math.min(w - S, E);
+      }), b - E;
+    });
+  }
+  function h(_, m) {
+    var g = e.values(m), b = e.min(g), E = e.max(g);
+    e.forEach(["u", "d"], function(w) {
+      e.forEach(["l", "r"], function(q) {
+        var S = w + q, O = _[S], I;
+        if (O !== m) {
+          var x = e.values(O);
+          I = q === "l" ? b - e.min(x) : E - e.max(x), I && (_[S] = e.mapValues(O, function(L) {
+            return L + I;
+          }));
+        }
+      });
+    });
+  }
+  function l(_, m) {
+    return e.mapValues(_.ul, function(g, b) {
+      if (m)
+        return _[m.toLowerCase()][b];
+      var E = e.sortBy(e.map(_, b));
+      return (E[1] + E[2]) / 2;
+    });
+  }
+  function y(_) {
+    var m = u.buildLayerMatrix(_), g = e.merge(
+      n(_, m),
+      r(_, m)
+    ), b = {}, E;
+    e.forEach(["u", "d"], function(q) {
+      E = q === "u" ? m : e.values(m).reverse(), e.forEach(["l", "r"], function(S) {
+        S === "r" && (E = e.map(E, function(L) {
+          return e.values(L).reverse();
+        }));
+        var O = (q === "u" ? _.predecessors : _.successors).bind(_), I = f(_, E, g, O), x = d(
+          _,
+          E,
+          I.root,
+          I.align,
+          S === "r"
+        );
+        S === "r" && (x = e.mapValues(x, function(L) {
+          return -L;
+        })), b[q + S] = x;
+      });
+    });
+    var w = c(_, b);
+    return h(b, w), l(b, _.graph().align);
+  }
+  function p(_, m, g) {
+    return function(b, E, w) {
+      var q = b.node(E), S = b.node(w), O = 0, I;
+      if (O += q.width / 2, e.has(q, "labelpos"))
+        switch (q.labelpos.toLowerCase()) {
+          case "l":
+            I = -q.width / 2;
+            break;
+          case "r":
+            I = q.width / 2;
+            break;
+        }
+      if (I && (O += g ? I : -I), I = 0, O += (q.dummy ? m : _) / 2, O += (S.dummy ? m : _) / 2, O += S.width / 2, e.has(S, "labelpos"))
+        switch (S.labelpos.toLowerCase()) {
+          case "l":
+            I = S.width / 2;
+            break;
+          case "r":
+            I = -S.width / 2;
+            break;
+        }
+      return I && (O += g ? I : -I), I = 0, O;
+    };
+  }
+  function v(_, m) {
+    return _.node(m).width;
+  }
+  return Yt;
+}
+var $t, Hs;
+function Oc() {
+  if (Hs) return $t;
+  Hs = 1;
+  var e = G(), a = j(), u = Cc().positionX;
+  $t = n;
+  function n(t) {
+    t = a.asNonCompoundGraph(t), r(t), e.forEach(u(t), function(s, i) {
+      t.node(i).x = s;
+    });
+  }
+  function r(t) {
+    var s = a.buildLayerMatrix(t), i = t.graph().ranksep, f = 0;
+    e.forEach(s, function(d) {
+      var o = e.max(e.map(d, function(c) {
+        return t.node(c).height;
+      }));
+      e.forEach(d, function(c) {
+        t.node(c).y = f + o / 2;
+      }), f += o + i;
+    });
+  }
+  return $t;
+}
+var Xt, Ws;
+function Nc() {
+  if (Ws) return Xt;
+  Ws = 1;
+  var e = G(), a = cc(), u = hc(), n = vc(), r = j().normalizeRanks, t = pc(), s = j().removeEmptyRanks, i = _c(), f = gc(), d = mc(), o = Sc(), c = Oc(), h = j(), l = Z().Graph;
+  Xt = y;
+  function y(R, T) {
+    var C = T && T.debugTiming ? h.time : h.notime;
+    C("layout", function() {
+      var A = C("  buildLayoutGraph", function() {
+        return O(R);
+      });
+      C("  runLayout", function() {
+        p(A, C);
+      }), C("  updateInputGraph", function() {
+        v(R, A);
+      });
+    });
+  }
+  function p(R, T) {
+    T("    makeSpaceForEdgeLabels", function() {
+      I(R);
+    }), T("    removeSelfEdges", function() {
+      N(R);
+    }), T("    acyclic", function() {
+      a.run(R);
+    }), T("    nestingGraph.run", function() {
+      i.run(R);
+    }), T("    rank", function() {
+      n(h.asNonCompoundGraph(R));
+    }), T("    injectEdgeLabelProxies", function() {
+      x(R);
+    }), T("    removeEmptyRanks", function() {
+      s(R);
+    }), T("    nestingGraph.cleanup", function() {
+      i.cleanup(R);
+    }), T("    normalizeRanks", function() {
+      r(R);
+    }), T("    assignRankMinMax", function() {
+      L(R);
+    }), T("    removeEdgeLabelProxies", function() {
+      k(R);
+    }), T("    normalize.run", function() {
+      u.run(R);
+    }), T("    parentDummyChains", function() {
+      t(R);
+    }), T("    addBorderSegments", function() {
+      f(R);
+    }), T("    order", function() {
+      o(R);
+    }), T("    insertSelfEdges", function() {
+      H(R);
+    }), T("    adjustCoordinateSystem", function() {
+      d.adjust(R);
+    }), T("    position", function() {
+      c(R);
+    }), T("    positionSelfEdges", function() {
+      V(R);
+    }), T("    removeBorderNodes", function() {
+      ie(R);
+    }), T("    normalize.undo", function() {
+      u.undo(R);
+    }), T("    fixupEdgeLabelCoords", function() {
+      U(R);
+    }), T("    undoCoordinateSystem", function() {
+      d.undo(R);
+    }), T("    translateGraph", function() {
+      P(R);
+    }), T("    assignNodeIntersects", function() {
+      F(R);
+    }), T("    reversePoints", function() {
+      te(R);
+    }), T("    acyclic.undo", function() {
+      a.undo(R);
+    });
+  }
+  function v(R, T) {
+    e.forEach(R.nodes(), function(C) {
+      var A = R.node(C), M = T.node(C);
+      A && (A.x = M.x, A.y = M.y, T.children(C).length && (A.width = M.width, A.height = M.height));
+    }), e.forEach(R.edges(), function(C) {
+      var A = R.edge(C), M = T.edge(C);
+      A.points = M.points, e.has(M, "x") && (A.x = M.x, A.y = M.y);
+    }), R.graph().width = T.graph().width, R.graph().height = T.graph().height;
+  }
+  var _ = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"], m = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" }, g = ["acyclicer", "ranker", "rankdir", "align"], b = ["width", "height"], E = { width: 0, height: 0 }, w = ["minlen", "weight", "width", "height", "labeloffset"], q = {
+    minlen: 1,
+    weight: 1,
+    width: 0,
+    height: 0,
+    labeloffset: 10,
+    labelpos: "r"
+  }, S = ["labelpos"];
+  function O(R) {
+    var T = new l({ multigraph: !0, compound: !0 }), C = J(R.graph());
+    return T.setGraph(e.merge(
+      {},
+      m,
+      Q(C, _),
+      e.pick(C, g)
+    )), e.forEach(R.nodes(), function(A) {
+      var M = J(R.node(A));
+      T.setNode(A, e.defaults(Q(M, b), E)), T.setParent(A, R.parent(A));
+    }), e.forEach(R.edges(), function(A) {
+      var M = J(R.edge(A));
+      T.setEdge(A, e.merge(
+        {},
+        q,
+        Q(M, w),
+        e.pick(M, S)
+      ));
+    }), T;
+  }
+  function I(R) {
+    var T = R.graph();
+    T.ranksep /= 2, e.forEach(R.edges(), function(C) {
+      var A = R.edge(C);
+      A.minlen *= 2, A.labelpos.toLowerCase() !== "c" && (T.rankdir === "TB" || T.rankdir === "BT" ? A.width += A.labeloffset : A.height += A.labeloffset);
+    });
+  }
+  function x(R) {
+    e.forEach(R.edges(), function(T) {
+      var C = R.edge(T);
+      if (C.width && C.height) {
+        var A = R.node(T.v), M = R.node(T.w), D = { rank: (M.rank - A.rank) / 2 + A.rank, e: T };
+        h.addDummyNode(R, "edge-proxy", D, "_ep");
+      }
+    });
+  }
+  function L(R) {
+    var T = 0;
+    e.forEach(R.nodes(), function(C) {
+      var A = R.node(C);
+      A.borderTop && (A.minRank = R.node(A.borderTop).rank, A.maxRank = R.node(A.borderBottom).rank, T = e.max(T, A.maxRank));
+    }), R.graph().maxRank = T;
+  }
+  function k(R) {
+    e.forEach(R.nodes(), function(T) {
+      var C = R.node(T);
+      C.dummy === "edge-proxy" && (R.edge(C.e).labelRank = C.rank, R.removeNode(T));
+    });
+  }
+  function P(R) {
+    var T = Number.POSITIVE_INFINITY, C = 0, A = Number.POSITIVE_INFINITY, M = 0, D = R.graph(), B = D.marginx || 0, K = D.marginy || 0;
+    function qi(Y) {
+      var z = Y.x, de = Y.y, Ri = Y.width, wi = Y.height;
+      T = Math.min(T, z - Ri / 2), C = Math.max(C, z + Ri / 2), A = Math.min(A, de - wi / 2), M = Math.max(M, de + wi / 2);
+    }
+    e.forEach(R.nodes(), function(Y) {
+      qi(R.node(Y));
+    }), e.forEach(R.edges(), function(Y) {
+      var z = R.edge(Y);
+      e.has(z, "x") && qi(z);
+    }), T -= B, A -= K, e.forEach(R.nodes(), function(Y) {
+      var z = R.node(Y);
+      z.x -= T, z.y -= A;
+    }), e.forEach(R.edges(), function(Y) {
+      var z = R.edge(Y);
+      e.forEach(z.points, function(de) {
+        de.x -= T, de.y -= A;
+      }), e.has(z, "x") && (z.x -= T), e.has(z, "y") && (z.y -= A);
+    }), D.width = C - T + B, D.height = M - A + K;
+  }
+  function F(R) {
+    e.forEach(R.edges(), function(T) {
+      var C = R.edge(T), A = R.node(T.v), M = R.node(T.w), D, B;
+      C.points ? (D = C.points[0], B = C.points[C.points.length - 1]) : (C.points = [], D = M, B = A), C.points.unshift(h.intersectRect(A, D)), C.points.push(h.intersectRect(M, B));
+    });
+  }
+  function U(R) {
+    e.forEach(R.edges(), function(T) {
+      var C = R.edge(T);
+      if (e.has(C, "x"))
+        switch ((C.labelpos === "l" || C.labelpos === "r") && (C.width -= C.labeloffset), C.labelpos) {
+          case "l":
+            C.x -= C.width / 2 + C.labeloffset;
+            break;
+          case "r":
+            C.x += C.width / 2 + C.labeloffset;
+            break;
+        }
+    });
+  }
+  function te(R) {
+    e.forEach(R.edges(), function(T) {
+      var C = R.edge(T);
+      C.reversed && C.points.reverse();
+    });
+  }
+  function ie(R) {
+    e.forEach(R.nodes(), function(T) {
+      if (R.children(T).length) {
+        var C = R.node(T), A = R.node(C.borderTop), M = R.node(C.borderBottom), D = R.node(e.last(C.borderLeft)), B = R.node(e.last(C.borderRight));
+        C.width = Math.abs(B.x - D.x), C.height = Math.abs(M.y - A.y), C.x = D.x + C.width / 2, C.y = A.y + C.height / 2;
+      }
+    }), e.forEach(R.nodes(), function(T) {
+      R.node(T).dummy === "border" && R.removeNode(T);
+    });
+  }
+  function N(R) {
+    e.forEach(R.edges(), function(T) {
+      if (T.v === T.w) {
+        var C = R.node(T.v);
+        C.selfEdges || (C.selfEdges = []), C.selfEdges.push({ e: T, label: R.edge(T) }), R.removeEdge(T);
+      }
+    });
+  }
+  function H(R) {
+    var T = h.buildLayerMatrix(R);
+    e.forEach(T, function(C) {
+      var A = 0;
+      e.forEach(C, function(M, D) {
+        var B = R.node(M);
+        B.order = D + A, e.forEach(B.selfEdges, function(K) {
+          h.addDummyNode(R, "selfedge", {
+            width: K.label.width,
+            height: K.label.height,
+            rank: B.rank,
+            order: D + ++A,
+            e: K.e,
+            label: K.label
+          }, "_se");
+        }), delete B.selfEdges;
+      });
+    });
+  }
+  function V(R) {
+    e.forEach(R.nodes(), function(T) {
+      var C = R.node(T);
+      if (C.dummy === "selfedge") {
+        var A = R.node(C.e.v), M = A.x + A.width / 2, D = A.y, B = C.x - M, K = A.height / 2;
+        R.setEdge(C.e, C.label), R.removeNode(T), C.label.points = [
+          { x: M + 2 * B / 3, y: D - K },
+          { x: M + 5 * B / 6, y: D - K },
+          { x: M + B, y: D },
+          { x: M + 5 * B / 6, y: D + K },
+          { x: M + 2 * B / 3, y: D + K }
+        ], C.label.x = C.x, C.label.y = C.y;
+      }
+    });
+  }
+  function Q(R, T) {
+    return e.mapValues(e.pick(R, T), Number);
+  }
+  function J(R) {
+    var T = {};
+    return e.forEach(R, function(C, A) {
+      T[A.toLowerCase()] = C;
+    }), T;
+  }
+  return Xt;
+}
+var Zt, Vs;
+function Ac() {
+  if (Vs) return Zt;
+  Vs = 1;
+  var e = G(), a = j(), u = Z().Graph;
+  Zt = {
+    debugOrdering: n
+  };
+  function n(r) {
+    var t = a.buildLayerMatrix(r), s = new u({ compound: !0, multigraph: !0 }).setGraph({});
+    return e.forEach(r.nodes(), function(i) {
+      s.setNode(i, { label: i }), s.setParent(i, "layer" + r.node(i).rank);
+    }), e.forEach(r.edges(), function(i) {
+      s.setEdge(i.v, i.w, {}, i.name);
+    }), e.forEach(t, function(i, f) {
+      var d = "layer" + f;
+      s.setNode(d, { rank: "same" }), e.reduce(i, function(o, c) {
+        return s.setEdge(o, c, { style: "invis" }), c;
+      });
+    }), s;
+  }
+  return Zt;
+}
+var Qt, zs;
+function xc() {
+  return zs || (zs = 1, Qt = "0.8.5"), Qt;
+}
+var Jt, js;
+function Lc() {
+  return js || (js = 1, Jt = {
+    graphlib: Z(),
+    layout: Nc(),
+    debug: Ac(),
+    util: {
+      time: j().time,
+      notime: j().notime
+    },
+    version: xc()
+  }), Jt;
+}
+var kc = Lc();
+const Ks = /* @__PURE__ */ cf(kc), re = "root.Triggers";
+function _i(e, a) {
+  const { getEdges: u } = he(e), n = [];
+  for (const r of u.value)
+    if (r.target === a) {
+      n.push(r);
+      const t = _i(e, r.source);
+      t.length > 0 && n.push(...t);
+    }
+  return n;
+}
+function gi(e, a) {
+  const { getEdges: u } = he(e), n = [];
+  for (const r of u.value)
+    if (r.source === a) {
+      n.push(r);
+      const t = gi(e, r.target);
+      t.length > 0 && n.push(...t);
+    }
+  return n;
+}
+function mi(e, a) {
+  const { getEdges: u, findNode: n } = he(e), r = n(a), t = r ? [r] : [];
+  for (const s of u.value)
+    if (s.target === a) {
+      t.push(s.sourceNode);
+      const i = mi(e, s.source);
+      i.length > 0 && t.push(...i);
+    }
+  return t;
+}
+function bi(e, a) {
+  const { getEdges: u, findNode: n } = he(e), r = [n(a)];
+  for (const t of u.value)
+    if (t.source === a) {
+      r.push(t.targetNode);
+      const s = bi(e, t.target);
+      s.length > 0 && r.push(...s);
+    }
+  return r;
+}
+function Pc(e, a) {
+  return [
+    ..._i(e, a),
+    ...mi(e, a),
+    ...gi(e, a),
+    ...bi(e, a)
+  ];
+}
+function Go(e, a, u, n, r, t, s) {
+  const i = new Ks.graphlib.Graph({ compound: !0 });
+  i.setDefaultEdgeLabel(() => ({})), i.setGraph({ rankdir: u ? "LR" : "TB" });
+  for (const f of e.nodes)
+    a.includes(f.uid) || i.setNode(f.uid, {
+      width: me(f),
+      height: be(f)
+    });
+  for (const f of e.clusters || []) {
+    const d = f.cluster.uid.replace(ce, "");
+    if (n.includes(f.cluster.uid) && t.has(d)) {
+      const o = { uid: d, type: "collapsedcluster" };
+      i.setNode(d, {
+        width: me(o),
+        height: be(o)
+      }), s.push(o);
+      continue;
+    }
+    if (!r[f.cluster.uid]) {
+      i.setNode(f.cluster.uid, { clusterLabelPos: "top" });
+      for (const o of f.nodes || [])
+        a.includes(o) || i.setParent(o, f.cluster.uid);
+    }
+    if (f.parents) {
+      const o = r[f.cluster.uid] ? r[f.cluster.uid] : f.cluster.uid;
+      a.includes(o) || i.setParent(
+        o,
+        f.parents[f.parents.length - 1]
+      );
+    }
+  }
+  for (const f of e.edges || []) {
+    const d = Ei(
+      f.source,
+      f.target,
+      r,
+      a
+    );
+    d && i.setEdge(d.source, d.target);
+  }
+  return Ks.layout(i), i;
+}
+function ge(e, a) {
+  const u = { x: e.x - e.width / 2, y: e.y - e.height / 2 };
+  if (a) {
+    const n = ge(a);
+    u.x = u.x - n.x, u.y = u.y - n.y;
+  }
+  return u;
+}
+function me(e) {
+  return yi(e) || Ae(e) ? ne.TASK_WIDTH : fe(e) ? ne.COLLAPSED_CLUSTER_WIDTH : ne.DOT_WIDTH;
+}
+function be(e) {
+  return yi(e) || Ae(e) ? ne.TASK_HEIGHT : fe(e) ? ne.COLLAPSED_CLUSTER_HEIGHT : ne.DOT_HEIGHT;
+}
+function yi(e) {
+  return ["GraphTask", "SubflowGraphTask$1"].some((a) => e.type.endsWith(a));
+}
+function Ae(e) {
+  return e.type.endsWith("GraphTrigger");
+}
+function fe(e) {
+  return e.type === "collapsedcluster";
+}
+function Ei(e, a, u, n) {
+  const r = u[e] ? u[e] : e, t = u[a] ? u[a] : a;
+  return r === t || n.includes(r) || n.includes(t) ? null : { target: t, source: r };
+}
+function Mc(e) {
+  const {
+    getEdges: a,
+    getNodes: u,
+    getElements: n,
+    removeEdges: r,
+    removeNodes: t,
+    removeSelectedElements: s
+  } = he(e);
+  r(a.value), t(u.value), s(n.value);
+}
+function Do(e) {
+  return e ? hf(e) : !1;
+}
+function Uo(e, a) {
+  return e.uid === re || Ae(e) || fe(e) ? "success" : e.type.endsWith("SubflowGraphTask") ? "primary" : e.branchType == "ERROR" ? "danger" : e.branchType == "FINALLY" ? "warning" : a.has(e.uid) ? "blue" : "default";
+}
+function Bo(e, a, u, n) {
+  var d, o, c;
+  if (n.some(
+    (h) => e.source.startsWith(h) && e.target.startsWith(h)
+  ) || u.includes(e.target) || e.source.startsWith(re) || e.target.startsWith(re))
+    return;
+  const r = e.target.split(".");
+  r.pop();
+  const t = r.join("."), s = yr.afterLastDot(t), i = a[e.target];
+  if (i.type.endsWith("GraphClusterEnd") && ((c = (o = (d = a[t]) == null ? void 0 : d.task) == null ? void 0 : o.type) != null && c.endsWith("Parallel")))
+    return;
+  if (i.type.endsWith("GraphClusterRoot"))
+    return [s, "before"];
+  const f = a[e.source].type.endsWith("GraphClusterEnd");
+  if (!f && i.type.endsWith("GraphClusterEnd"))
+    return [yr.afterLastDot(e.source), "after"];
+  if (f) {
+    const h = e.source.split(".");
+    return [h[h.length - 2], "after"];
+  }
+  return [yr.afterLastDot(e.target), "before"];
+}
+function Ho(e, a, u) {
+  const n = (s) => {
+    var f, d;
+    const i = s.split(".");
+    for (let o = 1; o <= i.length; o++) {
+      const c = i.slice(0, o).join("."), h = (f = u[c]) == null ? void 0 : f.branchType;
+      if (h) return h;
+    }
+    return ((d = a[s]) == null ? void 0 : d.branchType) ?? null;
+  }, r = n(e.source), t = n(e.target);
+  return [r, t].includes(
+    "ERROR"
+    /* ERROR */
+  ) ? "danger" : [r, t].includes(
+    "FINALLY"
+    /* FINALLY */
+  ) ? "warning" : null;
+}
+function Fc(e, a, u, n, r, t, s, i, f, d, o, c, h) {
+  var q, S, O, I, x, L, k, P, F, U, te, ie;
+  const l = [], y = [ce + re];
+  if (!n || r && !Do(r)) {
+    l.push({
+      id: "start",
+      type: "dot",
+      position: { x: 0, y: 0 },
+      style: {
+        width: "5px",
+        height: "5px"
+      },
+      sourcePosition: s ? $.Right : $.Bottom,
+      targetPosition: s ? $.Left : $.Top,
+      parentNode: void 0,
+      draggable: !1
+    }), l.push({
+      id: "end",
+      type: "dot",
+      position: s ? { x: 50, y: 0 } : { x: 0, y: 50 },
+      style: {
+        width: "5px",
+        height: "5px"
+      },
+      sourcePosition: s ? $.Right : $.Bottom,
+      targetPosition: s ? $.Left : $.Top,
+      parentNode: void 0,
+      draggable: !1
+    }), l.push({
+      id: "start|end",
+      source: "start",
+      target: "end",
+      type: "edge",
+      data: {
+        edge: {
+          relation: {
+            relationType: "SEQUENTIAL"
+          }
+        },
+        isFlowable: !1,
+        initTask: !0,
+        color: "primary"
+      }
+    });
+    return;
+  }
+  const p = Go(
+    n,
+    t,
+    s,
+    y,
+    i,
+    f,
+    d
+  ), v = {}, _ = n.clusters || [], m = _.map((N) => N.cluster), g = m.filter((N) => N.type.endsWith("SubflowGraphCluster")).map((N) => N.taskNode.uid), b = Object.fromEntries(
+    n.nodes.concat(d).map((N) => [N.uid, N])
+  );
+  for (const N of _)
+    if (!i[N.cluster.uid] && !f.has(N.cluster.uid)) {
+      ((S = (q = N.cluster.taskNode) == null ? void 0 : q.task) == null ? void 0 : S.type) === "io.kestra.core.tasks.flows.Dag" && g.push(N.cluster.taskNode.uid);
+      for (const R of N.nodes)
+        v[R] = N.cluster;
+      const H = N.cluster.uid, V = p.node(H), Q = N.parents ? N.parents[N.parents.length - 1] : void 0, J = Wo(N.cluster);
+      l.push({
+        id: H,
+        type: "cluster",
+        parentNode: Q,
+        position: ge(
+          V,
+          Q ? p.node(Q) : void 0
+        ),
+        style: {
+          width: H === re && s ? ne.TRIGGER_CLUSTER_WIDTH + "px" : V.width + "px",
+          height: H === re && !s ? ne.TRIGGER_CLUSTER_HEIGHT + "px" : V.height + "px"
+        },
+        data: {
+          collapsable: !0,
+          color: J,
+          taskNode: N.cluster.taskNode,
+          unused: N.cluster.taskNode ? b[N.cluster.taskNode.uid].unused : !1
+        },
+        class: `ks-topology-${J}-border rounded p-2`
+      });
+    }
+  for (const N of n.nodes.concat(d))
+    if (!t.includes(N.uid)) {
+      const H = p.node(N.uid);
+      let V = "task";
+      ei(N) ? V = "dot" : N.type.includes("GraphTrigger") ? V = "trigger" : N.type === "collapsedcluster" && (V = "collapsedcluster");
+      const Q = Uo(N, f), J = o || ((I = (O = N.task) == null ? void 0 : O.type) == null ? void 0 : I.includes("$")) || g.some(
+        (R) => N.uid.startsWith(R + ".")
+      );
+      l.push({
+        id: N.uid,
+        type: V,
+        position: ge(
+          H,
+          v[N.uid] ? p.node(v[N.uid].uid) : void 0
+        ),
+        style: {
+          width: me(N) + "px",
+          height: be(N) + "px"
+        },
+        sourcePosition: s ? $.Right : $.Bottom,
+        targetPosition: s ? $.Left : $.Top,
+        parentNode: v[N.uid] ? v[N.uid].uid : void 0,
+        draggable: V === "task" ? !J : !1,
+        data: {
+          node: N,
+          parent: v[N.uid] ? v[N.uid] : void 0,
+          namespace: ((k = (L = (x = v[N.uid]) == null ? void 0 : x.taskNode) == null ? void 0 : L.task) == null ? void 0 : k.namespace) ?? u,
+          flowId: ((U = (F = (P = v[N.uid]) == null ? void 0 : P.taskNode) == null ? void 0 : F.task) == null ? void 0 : U.flowId) ?? a,
+          isFlowable: ((te = v[N.uid]) == null ? void 0 : te.uid) === ce + N.uid && !N.type.endsWith("SubflowGraphTask"),
+          color: Q,
+          expandable: Vo(
+            N,
+            v,
+            i,
+            h
+          ),
+          isReadOnly: J,
+          iconComponent: fe(N) ? "lightning-bolt" : null,
+          executionId: N.executionId,
+          unused: N.unused
+        },
+        class: N.type === "collapsedcluster" ? `ks-topology-${Q}-border rounded` : ""
+      });
+    }
+  const E = m.filter((N) => N.taskNode).map((N) => N.taskNode.uid), w = n.edges ?? [];
+  for (const N of w) {
+    const H = Ei(
+      N.source,
+      N.target,
+      i,
+      t
+    );
+    if (H) {
+      const V = Ho(N, b, v);
+      l.push({
+        id: H.source + "|" + H.target,
+        source: H.source,
+        target: H.target,
+        type: "edge",
+        markerEnd: ei(b[H.target]) ? "" : {
+          id: "marker-" + (b[H.target].branchType ? (ie = b[H.target].branchType) == null ? void 0 : ie.toLocaleLowerCase() : "custom"),
+          type: zo.ArrowClosed,
+          color: V ? `var(--ks-border-${V})` : "var(--ks-topology-edge-color)"
+        },
+        data: {
+          haveAdd: !o && c && Bo(
+            N,
+            b,
+            E,
+            g
+          ),
+          haveDashArray: b[N.source].type.endsWith("GraphTrigger") || b[N.target].type.endsWith("GraphTrigger") || N.source.startsWith(re),
+          color: V,
+          unused: N.unused
+        },
+        style: {
+          zIndex: 10
+        }
+      });
+    }
+  }
+  return l;
+}
+function ei(e) {
+  return ["GraphClusterRoot", "GraphClusterFinally", "GraphClusterAfterExecution", "GraphClusterEnd"].some(
+    (a) => e.type.endsWith(a)
+  );
+}
+function Wo(e) {
+  return e.uid === ce + re ? "success" : e.type.endsWith("SubflowGraphCluster") ? "primary" : e.branchType === "ERROR" ? "danger" : "blue";
+}
+function Vo(e, a, u, n) {
+  var r, t;
+  return Object.values(u).includes(e.uid) || fe(e) ? !0 : e.type.endsWith("SubflowGraphTask") && ((t = (r = a[e.uid]) == null ? void 0 : r.uid) == null ? void 0 : t.replace(ce, "")) !== e.uid && n;
+}
+function Ys(e) {
+  const u = e.nodes.map((n) => n.uid).filter((n) => !e.edges.some((r) => r.target === n));
+  return e.nodes.filter((n) => u.includes(n.uid));
+}
+function Gc(e, a) {
+  if (a)
+    return e.edges.filter((u) => u.source === a && u.target);
+}
+function $s(e, a) {
+  let u, n, r = [a.uid];
+  do {
+    if (u = r.flatMap((t) => Gc(e, t)).filter(Boolean), u.length === 0)
+      return [];
+    r = u.map((t) => t.target), n = e.nodes.filter((t) => r.includes(t.uid) && t.task);
+  } while (!n.length);
+  return n;
+}
+function Jc(e, a, u) {
+  if (!u)
+    return !1;
+  let n = Ys(e), r = Ys(a);
+  if (n.length !== r.length)
+    return !1;
+  let t = 120;
+  do {
+    if (r = r.flatMap((s) => $s(a, s)), r.some((s) => s.task.id === u))
+      return !0;
+    if (n = n.flatMap((s) => $s(e, s)), n.length !== r.length)
+      return !1;
+    for (const s of r) {
+      const i = n.find((o) => {
+        var c, h;
+        return ((c = o.task) == null ? void 0 : c.id) === ((h = s.task) == null ? void 0 : h.id);
+      }), f = (i == null ? void 0 : i.task) ?? {}, d = s.task ?? {};
+      if (!i || Object.keys(f).length !== Object.keys(d).length)
+        return !1;
+      for (const o in s.task)
+        if (f[o] !== d[o])
+          return !1;
+    }
+  } while (n.length && r.length && t-- > 0);
+  return t <= 0 ? (console.warn("areTasksIdenticalInGraphUntilTask: Infinite loop detected, stopping comparison."), !1) : !0;
+}
+const eh = {
+  isClusterRootOrEnd: ei,
+  computeClusterColor: Wo,
+  isExpandableTask: Vo,
+  generateGraph: Fc,
+  generateDagreGraph: Go,
+  getNodePosition: ge,
+  getNodeWidth: me,
+  getNodeHeight: be,
+  isTaskNode: yi,
+  isTriggerNode: Ae,
+  isCollapsedCluster: fe,
+  replaceIfCollapsed: Ei,
+  cleanGraph: Mc,
+  flowHaveTasks: Do,
+  nodeColor: Uo,
+  haveAdd: Bo,
+  getEdgeColor: Ho,
+  predecessorsEdge: _i,
+  successorsEdge: gi,
+  predecessorsNode: mi,
+  successorsNode: bi,
+  linkedElements: Pc
+};
+export {
+  ei as A,
+  Wo as B,
+  ce as C,
+  Vo as D,
+  jc as E,
+  Ys as F,
+  Gc as G,
+  $s as H,
+  Jc as I,
+  ne as N,
+  zc as S,
+  yr as U,
+  eh as V,
+  Yc as a,
+  Xc as b,
+  Mc as c,
+  Zc as d,
+  $c as e,
+  Qc as f,
+  Fc as g,
+  gi as h,
+  mi as i,
+  bi as j,
+  Go as k,
+  Pc as l,
+  ge as m,
+  me as n,
+  be as o,
+  _i as p,
+  yi as q,
+  Pf as r,
+  Kc as s,
+  Ae as t,
+  fe as u,
+  Ei as v,
+  Do as w,
+  Uo as x,
+  Bo as y,
+  Ho as z
+};
+//# sourceMappingURL=VueFlowUtils-DKrM_RaI.js.map