@linkurious/ogma-linkurious-parser 4.1.6 → 4.1.8

package/dist/index.mjs

@@ -0,0 +1,4082 @@
+import { CurrencyFormat as B, PropertyTypeName as pr, AutoRangeScale as Ut, OgmaEdgeShape as br, SelectorType as S, ForceLayoutMode as yr, EntityType as P } from "@linkurious/rest-client";
+import vr from "@linkurious/ogma";
+import { BehaviorSubject as mr } from "rxjs";
+var X = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Oe(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+function _r() {
+  this.__data__ = [], this.size = 0;
+}
+var Cr = _r;
+function Sr(r, e) {
+  return r === e || r !== r && e !== e;
+}
+var Le = Sr, Ar = Le;
+function xr(r, e) {
+  for (var t = r.length; t--; )
+    if (Ar(r[t][0], e))
+      return t;
+  return -1;
+}
+var se = xr, $r = se, Er = Array.prototype, Fr = Er.splice;
+function Tr(r) {
+  var e = this.__data__, t = $r(e, r);
+  if (t < 0)
+    return !1;
+  var i = e.length - 1;
+  return t == i ? e.pop() : Fr.call(e, t, 1), --this.size, !0;
+}
+var wr = Tr, Nr = se;
+function Dr(r) {
+  var e = this.__data__, t = Nr(e, r);
+  return t < 0 ? void 0 : e[t][1];
+}
+var Or = Dr, Lr = se;
+function Pr(r) {
+  return Lr(this.__data__, r) > -1;
+}
+var Ir = Pr, Mr = se;
+function Rr(r, e) {
+  var t = this.__data__, i = Mr(t, r);
+  return i < 0 ? (++this.size, t.push([r, e])) : t[i][1] = e, this;
+}
+var Br = Rr, zr = Cr, Gr = wr, Ur = Or, jr = Ir, kr = Br;
+function j(r) {
+  var e = -1, t = r == null ? 0 : r.length;
+  for (this.clear(); ++e < t; ) {
+    var i = r[e];
+    this.set(i[0], i[1]);
+  }
+}
+j.prototype.clear = zr;
+j.prototype.delete = Gr;
+j.prototype.get = Ur;
+j.prototype.has = jr;
+j.prototype.set = kr;
+var ae = j, Hr = ae;
+function Vr() {
+  this.__data__ = new Hr(), this.size = 0;
+}
+var Kr = Vr;
+function qr(r) {
+  var e = this.__data__, t = e.delete(r);
+  return this.size = e.size, t;
+}
+var Wr = qr;
+function Yr(r) {
+  return this.__data__.get(r);
+}
+var Jr = Yr;
+function Zr(r) {
+  return this.__data__.has(r);
+}
+var Xr = Zr, Qr = typeof X == "object" && X && X.Object === Object && X, jt = Qr, ei = jt, ti = typeof self == "object" && self && self.Object === Object && self, ri = ei || ti || Function("return this")(), N = ri, ii = N, ni = ii.Symbol, Y = ni, We = Y, kt = Object.prototype, si = kt.hasOwnProperty, ai = kt.toString, q = We ? We.toStringTag : void 0;
+function oi(r) {
+  var e = si.call(r, q), t = r[q];
+  try {
+    r[q] = void 0;
+    var i = !0;
+  } catch {
+  }
+  var n = ai.call(r);
+  return i && (e ? r[q] = t : delete r[q]), n;
+}
+var ui = oi, li = Object.prototype, ci = li.toString;
+function di(r) {
+  return ci.call(r);
+}
+var gi = di, Ye = Y, hi = ui, fi = gi, pi = "[object Null]", bi = "[object Undefined]", Je = Ye ? Ye.toStringTag : void 0;
+function yi(r) {
+  return r == null ? r === void 0 ? bi : pi : Je && Je in Object(r) ? hi(r) : fi(r);
+}
+var J = yi;
+function vi(r) {
+  var e = typeof r;
+  return r != null && (e == "object" || e == "function");
+}
+var oe = vi, mi = J, _i = oe, Ci = "[object AsyncFunction]", Si = "[object Function]", Ai = "[object GeneratorFunction]", xi = "[object Proxy]";
+function $i(r) {
+  if (!_i(r))
+    return !1;
+  var e = mi(r);
+  return e == Si || e == Ai || e == Ci || e == xi;
+}
+var Ht = $i, Ei = N, Fi = Ei["__core-js_shared__"], Ti = Fi, fe = Ti, Ze = function() {
+  var r = /[^.]+$/.exec(fe && fe.keys && fe.keys.IE_PROTO || "");
+  return r ? "Symbol(src)_1." + r : "";
+}();
+function wi(r) {
+  return !!Ze && Ze in r;
+}
+var Ni = wi, Di = Function.prototype, Oi = Di.toString;
+function Li(r) {
+  if (r != null) {
+    try {
+      return Oi.call(r);
+    } catch {
+    }
+    try {
+      return r + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var Vt = Li, Pi = Ht, Ii = Ni, Mi = oe, Ri = Vt, Bi = /[\\^$.*+?()[\]{}|]/g, zi = /^\[object .+?Constructor\]$/, Gi = Function.prototype, Ui = Object.prototype, ji = Gi.toString, ki = Ui.hasOwnProperty, Hi = RegExp(
+  "^" + ji.call(ki).replace(Bi, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function Vi(r) {
+  if (!Mi(r) || Ii(r))
+    return !1;
+  var e = Pi(r) ? Hi : zi;
+  return e.test(Ri(r));
+}
+var Ki = Vi;
+function qi(r, e) {
+  return r == null ? void 0 : r[e];
+}
+var Wi = qi, Yi = Ki, Ji = Wi;
+function Zi(r, e) {
+  var t = Ji(r, e);
+  return Yi(t) ? t : void 0;
+}
+var M = Zi, Xi = M, Qi = N, en = Xi(Qi, "Map"), Pe = en, tn = M, rn = tn(Object, "create"), ue = rn, Xe = ue;
+function nn() {
+  this.__data__ = Xe ? Xe(null) : {}, this.size = 0;
+}
+var sn = nn;
+function an(r) {
+  var e = this.has(r) && delete this.__data__[r];
+  return this.size -= e ? 1 : 0, e;
+}
+var on = an, un = ue, ln = "__lodash_hash_undefined__", cn = Object.prototype, dn = cn.hasOwnProperty;
+function gn(r) {
+  var e = this.__data__;
+  if (un) {
+    var t = e[r];
+    return t === ln ? void 0 : t;
+  }
+  return dn.call(e, r) ? e[r] : void 0;
+}
+var hn = gn, fn = ue, pn = Object.prototype, bn = pn.hasOwnProperty;
+function yn(r) {
+  var e = this.__data__;
+  return fn ? e[r] !== void 0 : bn.call(e, r);
+}
+var vn = yn, mn = ue, _n = "__lodash_hash_undefined__";
+function Cn(r, e) {
+  var t = this.__data__;
+  return this.size += this.has(r) ? 0 : 1, t[r] = mn && e === void 0 ? _n : e, this;
+}
+var Sn = Cn, An = sn, xn = on, $n = hn, En = vn, Fn = Sn;
+function k(r) {
+  var e = -1, t = r == null ? 0 : r.length;
+  for (this.clear(); ++e < t; ) {
+    var i = r[e];
+    this.set(i[0], i[1]);
+  }
+}
+k.prototype.clear = An;
+k.prototype.delete = xn;
+k.prototype.get = $n;
+k.prototype.has = En;
+k.prototype.set = Fn;
+var Tn = k, Qe = Tn, wn = ae, Nn = Pe;
+function Dn() {
+  this.size = 0, this.__data__ = {
+    hash: new Qe(),
+    map: new (Nn || wn)(),
+    string: new Qe()
+  };
+}
+var On = Dn;
+function Ln(r) {
+  var e = typeof r;
+  return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? r !== "__proto__" : r === null;
+}
+var Pn = Ln, In = Pn;
+function Mn(r, e) {
+  var t = r.__data__;
+  return In(e) ? t[typeof e == "string" ? "string" : "hash"] : t.map;
+}
+var le = Mn, Rn = le;
+function Bn(r) {
+  var e = Rn(this, r).delete(r);
+  return this.size -= e ? 1 : 0, e;
+}
+var zn = Bn, Gn = le;
+function Un(r) {
+  return Gn(this, r).get(r);
+}
+var jn = Un, kn = le;
+function Hn(r) {
+  return kn(this, r).has(r);
+}
+var Vn = Hn, Kn = le;
+function qn(r, e) {
+  var t = Kn(this, r), i = t.size;
+  return t.set(r, e), this.size += t.size == i ? 0 : 1, this;
+}
+var Wn = qn, Yn = On, Jn = zn, Zn = jn, Xn = Vn, Qn = Wn;
+function H(r) {
+  var e = -1, t = r == null ? 0 : r.length;
+  for (this.clear(); ++e < t; ) {
+    var i = r[e];
+    this.set(i[0], i[1]);
+  }
+}
+H.prototype.clear = Yn;
+H.prototype.delete = Jn;
+H.prototype.get = Zn;
+H.prototype.has = Xn;
+H.prototype.set = Qn;
+var Ie = H, es = ae, ts = Pe, rs = Ie, is = 200;
+function ns(r, e) {
+  var t = this.__data__;
+  if (t instanceof es) {
+    var i = t.__data__;
+    if (!ts || i.length < is - 1)
+      return i.push([r, e]), this.size = ++t.size, this;
+    t = this.__data__ = new rs(i);
+  }
+  return t.set(r, e), this.size = t.size, this;
+}
+var ss = ns, as = ae, os = Kr, us = Wr, ls = Jr, cs = Xr, ds = ss;
+function V(r) {
+  var e = this.__data__ = new as(r);
+  this.size = e.size;
+}
+V.prototype.clear = os;
+V.prototype.delete = us;
+V.prototype.get = ls;
+V.prototype.has = cs;
+V.prototype.set = ds;
+var Kt = V, gs = "__lodash_hash_undefined__";
+function hs(r) {
+  return this.__data__.set(r, gs), this;
+}
+var fs = hs;
+function ps(r) {
+  return this.__data__.has(r);
+}
+var bs = ps, ys = Ie, vs = fs, ms = bs;
+function te(r) {
+  var e = -1, t = r == null ? 0 : r.length;
+  for (this.__data__ = new ys(); ++e < t; )
+    this.add(r[e]);
+}
+te.prototype.add = te.prototype.push = vs;
+te.prototype.has = ms;
+var _s = te;
+function Cs(r, e) {
+  for (var t = -1, i = r == null ? 0 : r.length; ++t < i; )
+    if (e(r[t], t, r))
+      return !0;
+  return !1;
+}
+var Ss = Cs;
+function As(r, e) {
+  return r.has(e);
+}
+var xs = As, $s = _s, Es = Ss, Fs = xs, Ts = 1, ws = 2;
+function Ns(r, e, t, i, n, s) {
+  var a = t & Ts, o = r.length, l = e.length;
+  if (o != l && !(a && l > o))
+    return !1;
+  var c = s.get(r), d = s.get(e);
+  if (c && d)
+    return c == e && d == r;
+  var g = -1, h = !0, y = t & ws ? new $s() : void 0;
+  for (s.set(r, e), s.set(e, r); ++g < o; ) {
+    var _ = r[g], f = e[g];
+    if (i)
+      var A = a ? i(f, _, g, e, r, s) : i(_, f, g, r, e, s);
+    if (A !== void 0) {
+      if (A)
+        continue;
+      h = !1;
+      break;
+    }
+    if (y) {
+      if (!Es(e, function(x, $) {
+        if (!Fs(y, $) && (_ === x || n(_, x, t, i, s)))
+          return y.push($);
+      })) {
+        h = !1;
+        break;
+      }
+    } else if (!(_ === f || n(_, f, t, i, s))) {
+      h = !1;
+      break;
+    }
+  }
+  return s.delete(r), s.delete(e), h;
+}
+var qt = Ns, Ds = N, Os = Ds.Uint8Array, Ls = Os;
+function Ps(r) {
+  var e = -1, t = Array(r.size);
+  return r.forEach(function(i, n) {
+    t[++e] = [n, i];
+  }), t;
+}
+var Is = Ps;
+function Ms(r) {
+  var e = -1, t = Array(r.size);
+  return r.forEach(function(i) {
+    t[++e] = i;
+  }), t;
+}
+var Rs = Ms, et = Y, tt = Ls, Bs = Le, zs = qt, Gs = Is, Us = Rs, js = 1, ks = 2, Hs = "[object Boolean]", Vs = "[object Date]", Ks = "[object Error]", qs = "[object Map]", Ws = "[object Number]", Ys = "[object RegExp]", Js = "[object Set]", Zs = "[object String]", Xs = "[object Symbol]", Qs = "[object ArrayBuffer]", ea = "[object DataView]", rt = et ? et.prototype : void 0, pe = rt ? rt.valueOf : void 0;
+function ta(r, e, t, i, n, s, a) {
+  switch (t) {
+    case ea:
+      if (r.byteLength != e.byteLength || r.byteOffset != e.byteOffset)
+        return !1;
+      r = r.buffer, e = e.buffer;
+    case Qs:
+      return !(r.byteLength != e.byteLength || !s(new tt(r), new tt(e)));
+    case Hs:
+    case Vs:
+    case Ws:
+      return Bs(+r, +e);
+    case Ks:
+      return r.name == e.name && r.message == e.message;
+    case Ys:
+    case Zs:
+      return r == e + "";
+    case qs:
+      var o = Gs;
+    case Js:
+      var l = i & js;
+      if (o || (o = Us), r.size != e.size && !l)
+        return !1;
+      var c = a.get(r);
+      if (c)
+        return c == e;
+      i |= ks, a.set(r, e);
+      var d = zs(o(r), o(e), i, n, s, a);
+      return a.delete(r), d;
+    case Xs:
+      if (pe)
+        return pe.call(r) == pe.call(e);
+  }
+  return !1;
+}
+var ra = ta;
+function ia(r, e) {
+  for (var t = -1, i = e.length, n = r.length; ++t < i; )
+    r[n + t] = e[t];
+  return r;
+}
+var Wt = ia, na = Array.isArray, T = na, sa = Wt, aa = T;
+function oa(r, e, t) {
+  var i = e(r);
+  return aa(r) ? i : sa(i, t(r));
+}
+var ua = oa;
+function la(r, e) {
+  for (var t = -1, i = r == null ? 0 : r.length, n = 0, s = []; ++t < i; ) {
+    var a = r[t];
+    e(a, t, r) && (s[n++] = a);
+  }
+  return s;
+}
+var ca = la;
+function da() {
+  return [];
+}
+var ga = da, ha = ca, fa = ga, pa = Object.prototype, ba = pa.propertyIsEnumerable, it = Object.getOwnPropertySymbols, ya = it ? function(r) {
+  return r == null ? [] : (r = Object(r), ha(it(r), function(e) {
+    return ba.call(r, e);
+  }));
+} : fa, va = ya;
+function ma(r, e) {
+  for (var t = -1, i = Array(r); ++t < r; )
+    i[t] = e(t);
+  return i;
+}
+var _a = ma;
+function Ca(r) {
+  return r != null && typeof r == "object";
+}
+var Z = Ca, Sa = J, Aa = Z, xa = "[object Arguments]";
+function $a(r) {
+  return Aa(r) && Sa(r) == xa;
+}
+var Ea = $a, nt = Ea, Fa = Z, Yt = Object.prototype, Ta = Yt.hasOwnProperty, wa = Yt.propertyIsEnumerable, Na = nt(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? nt : function(r) {
+  return Fa(r) && Ta.call(r, "callee") && !wa.call(r, "callee");
+}, Me = Na, re = { exports: {} };
+function Da() {
+  return !1;
+}
+var Oa = Da;
+re.exports;
+(function(r, e) {
+  var t = N, i = Oa, n = e && !e.nodeType && e, s = n && !0 && r && !r.nodeType && r, a = s && s.exports === n, o = a ? t.Buffer : void 0, l = o ? o.isBuffer : void 0, c = l || i;
+  r.exports = c;
+})(re, re.exports);
+var Jt = re.exports, La = 9007199254740991, Pa = /^(?:0|[1-9]\d*)$/;
+function Ia(r, e) {
+  var t = typeof r;
+  return e = e ?? La, !!e && (t == "number" || t != "symbol" && Pa.test(r)) && r > -1 && r % 1 == 0 && r < e;
+}
+var Re = Ia, Ma = 9007199254740991;
+function Ra(r) {
+  return typeof r == "number" && r > -1 && r % 1 == 0 && r <= Ma;
+}
+var Be = Ra, Ba = J, za = Be, Ga = Z, Ua = "[object Arguments]", ja = "[object Array]", ka = "[object Boolean]", Ha = "[object Date]", Va = "[object Error]", Ka = "[object Function]", qa = "[object Map]", Wa = "[object Number]", Ya = "[object Object]", Ja = "[object RegExp]", Za = "[object Set]", Xa = "[object String]", Qa = "[object WeakMap]", eo = "[object ArrayBuffer]", to = "[object DataView]", ro = "[object Float32Array]", io = "[object Float64Array]", no = "[object Int8Array]", so = "[object Int16Array]", ao = "[object Int32Array]", oo = "[object Uint8Array]", uo = "[object Uint8ClampedArray]", lo = "[object Uint16Array]", co = "[object Uint32Array]", b = {};
+b[ro] = b[io] = b[no] = b[so] = b[ao] = b[oo] = b[uo] = b[lo] = b[co] = !0;
+b[Ua] = b[ja] = b[eo] = b[ka] = b[to] = b[Ha] = b[Va] = b[Ka] = b[qa] = b[Wa] = b[Ya] = b[Ja] = b[Za] = b[Xa] = b[Qa] = !1;
+function go(r) {
+  return Ga(r) && za(r.length) && !!b[Ba(r)];
+}
+var ho = go;
+function fo(r) {
+  return function(e) {
+    return r(e);
+  };
+}
+var Zt = fo, ie = { exports: {} };
+ie.exports;
+(function(r, e) {
+  var t = jt, i = e && !e.nodeType && e, n = i && !0 && r && !r.nodeType && r, s = n && n.exports === i, a = s && t.process, o = function() {
+    try {
+      var l = n && n.require && n.require("util").types;
+      return l || a && a.binding && a.binding("util");
+    } catch {
+    }
+  }();
+  r.exports = o;
+})(ie, ie.exports);
+var po = ie.exports, bo = ho, yo = Zt, st = po, at = st && st.isTypedArray, vo = at ? yo(at) : bo, Xt = vo, mo = _a, _o = Me, Co = T, So = Jt, Ao = Re, xo = Xt, $o = Object.prototype, Eo = $o.hasOwnProperty;
+function Fo(r, e) {
+  var t = Co(r), i = !t && _o(r), n = !t && !i && So(r), s = !t && !i && !n && xo(r), a = t || i || n || s, o = a ? mo(r.length, String) : [], l = o.length;
+  for (var c in r)
+    (e || Eo.call(r, c)) && !(a && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (c == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    n && (c == "offset" || c == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    s && (c == "buffer" || c == "byteLength" || c == "byteOffset") || // Skip index properties.
+    Ao(c, l))) && o.push(c);
+  return o;
+}
+var To = Fo, wo = Object.prototype;
+function No(r) {
+  var e = r && r.constructor, t = typeof e == "function" && e.prototype || wo;
+  return r === t;
+}
+var Do = No;
+function Oo(r, e) {
+  return function(t) {
+    return r(e(t));
+  };
+}
+var Lo = Oo, Po = Lo, Io = Po(Object.keys, Object), Mo = Io, Ro = Do, Bo = Mo, zo = Object.prototype, Go = zo.hasOwnProperty;
+function Uo(r) {
+  if (!Ro(r))
+    return Bo(r);
+  var e = [];
+  for (var t in Object(r))
+    Go.call(r, t) && t != "constructor" && e.push(t);
+  return e;
+}
+var jo = Uo, ko = Ht, Ho = Be;
+function Vo(r) {
+  return r != null && Ho(r.length) && !ko(r);
+}
+var ce = Vo, Ko = To, qo = jo, Wo = ce;
+function Yo(r) {
+  return Wo(r) ? Ko(r) : qo(r);
+}
+var ze = Yo, Jo = ua, Zo = va, Xo = ze;
+function Qo(r) {
+  return Jo(r, Xo, Zo);
+}
+var eu = Qo, ot = eu, tu = 1, ru = Object.prototype, iu = ru.hasOwnProperty;
+function nu(r, e, t, i, n, s) {
+  var a = t & tu, o = ot(r), l = o.length, c = ot(e), d = c.length;
+  if (l != d && !a)
+    return !1;
+  for (var g = l; g--; ) {
+    var h = o[g];
+    if (!(a ? h in e : iu.call(e, h)))
+      return !1;
+  }
+  var y = s.get(r), _ = s.get(e);
+  if (y && _)
+    return y == e && _ == r;
+  var f = !0;
+  s.set(r, e), s.set(e, r);
+  for (var A = a; ++g < l; ) {
+    h = o[g];
+    var x = r[h], $ = e[h];
+    if (i)
+      var R = a ? i($, x, h, e, r, s) : i(x, $, h, r, e, s);
+    if (!(R === void 0 ? x === $ || n(x, $, t, i, s) : R)) {
+      f = !1;
+      break;
+    }
+    A || (A = h == "constructor");
+  }
+  if (f && !A) {
+    var v = r.constructor, O = e.constructor;
+    v != O && "constructor" in r && "constructor" in e && !(typeof v == "function" && v instanceof v && typeof O == "function" && O instanceof O) && (f = !1);
+  }
+  return s.delete(r), s.delete(e), f;
+}
+var su = nu, au = M, ou = N, uu = au(ou, "DataView"), lu = uu, cu = M, du = N, gu = cu(du, "Promise"), hu = gu, fu = M, pu = N, bu = fu(pu, "Set"), yu = bu, vu = M, mu = N, _u = vu(mu, "WeakMap"), Cu = _u, Se = lu, Ae = Pe, xe = hu, $e = yu, Ee = Cu, Qt = J, K = Vt, ut = "[object Map]", Su = "[object Object]", lt = "[object Promise]", ct = "[object Set]", dt = "[object WeakMap]", gt = "[object DataView]", Au = K(Se), xu = K(Ae), $u = K(xe), Eu = K($e), Fu = K(Ee), L = Qt;
+(Se && L(new Se(new ArrayBuffer(1))) != gt || Ae && L(new Ae()) != ut || xe && L(xe.resolve()) != lt || $e && L(new $e()) != ct || Ee && L(new Ee()) != dt) && (L = function(r) {
+  var e = Qt(r), t = e == Su ? r.constructor : void 0, i = t ? K(t) : "";
+  if (i)
+    switch (i) {
+      case Au:
+        return gt;
+      case xu:
+        return ut;
+      case $u:
+        return lt;
+      case Eu:
+        return ct;
+      case Fu:
+        return dt;
+    }
+  return e;
+});
+var Tu = L, be = Kt, wu = qt, Nu = ra, Du = su, ht = Tu, ft = T, pt = Jt, Ou = Xt, Lu = 1, bt = "[object Arguments]", yt = "[object Array]", Q = "[object Object]", Pu = Object.prototype, vt = Pu.hasOwnProperty;
+function Iu(r, e, t, i, n, s) {
+  var a = ft(r), o = ft(e), l = a ? yt : ht(r), c = o ? yt : ht(e);
+  l = l == bt ? Q : l, c = c == bt ? Q : c;
+  var d = l == Q, g = c == Q, h = l == c;
+  if (h && pt(r)) {
+    if (!pt(e))
+      return !1;
+    a = !0, d = !1;
+  }
+  if (h && !d)
+    return s || (s = new be()), a || Ou(r) ? wu(r, e, t, i, n, s) : Nu(r, e, l, t, i, n, s);
+  if (!(t & Lu)) {
+    var y = d && vt.call(r, "__wrapped__"), _ = g && vt.call(e, "__wrapped__");
+    if (y || _) {
+      var f = y ? r.value() : r, A = _ ? e.value() : e;
+      return s || (s = new be()), n(f, A, t, i, s);
+    }
+  }
+  return h ? (s || (s = new be()), Du(r, e, t, i, n, s)) : !1;
+}
+var Mu = Iu, Ru = Mu, mt = Z;
+function er(r, e, t, i, n) {
+  return r === e ? !0 : r == null || e == null || !mt(r) && !mt(e) ? r !== r && e !== e : Ru(r, e, t, i, er, n);
+}
+var Ge = er, Bu = Ge;
+function zu(r, e) {
+  return Bu(r, e);
+}
+var Gu = zu;
+const Uu = /* @__PURE__ */ Oe(Gu);
+var _t = Y, ju = Me, ku = T, Ct = _t ? _t.isConcatSpreadable : void 0;
+function Hu(r) {
+  return ku(r) || ju(r) || !!(Ct && r && r[Ct]);
+}
+var Vu = Hu, Ku = Wt, qu = Vu;
+function tr(r, e, t, i, n) {
+  var s = -1, a = r.length;
+  for (t || (t = qu), n || (n = []); ++s < a; ) {
+    var o = r[s];
+    e > 0 && t(o) ? e > 1 ? tr(o, e - 1, t, i, n) : Ku(n, o) : i || (n[n.length] = o);
+  }
+  return n;
+}
+var Wu = tr;
+function Yu(r, e) {
+  for (var t = -1, i = r == null ? 0 : r.length, n = Array(i); ++t < i; )
+    n[t] = e(r[t], t, r);
+  return n;
+}
+var rr = Yu, Ju = J, Zu = Z, Xu = "[object Symbol]";
+function Qu(r) {
+  return typeof r == "symbol" || Zu(r) && Ju(r) == Xu;
+}
+var de = Qu, el = T, tl = de, rl = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, il = /^\w*$/;
+function nl(r, e) {
+  if (el(r))
+    return !1;
+  var t = typeof r;
+  return t == "number" || t == "symbol" || t == "boolean" || r == null || tl(r) ? !0 : il.test(r) || !rl.test(r) || e != null && r in Object(e);
+}
+var Ue = nl, ir = Ie, sl = "Expected a function";
+function je(r, e) {
+  if (typeof r != "function" || e != null && typeof e != "function")
+    throw new TypeError(sl);
+  var t = function() {
+    var i = arguments, n = e ? e.apply(this, i) : i[0], s = t.cache;
+    if (s.has(n))
+      return s.get(n);
+    var a = r.apply(this, i);
+    return t.cache = s.set(n, a) || s, a;
+  };
+  return t.cache = new (je.Cache || ir)(), t;
+}
+je.Cache = ir;
+var al = je, ol = al, ul = 500;
+function ll(r) {
+  var e = ol(r, function(i) {
+    return t.size === ul && t.clear(), i;
+  }), t = e.cache;
+  return e;
+}
+var cl = ll, dl = cl, gl = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, hl = /\\(\\)?/g, fl = dl(function(r) {
+  var e = [];
+  return r.charCodeAt(0) === 46 && e.push(""), r.replace(gl, function(t, i, n, s) {
+    e.push(n ? s.replace(hl, "$1") : i || t);
+  }), e;
+}), pl = fl, St = Y, bl = rr, yl = T, vl = de, ml = 1 / 0, At = St ? St.prototype : void 0, xt = At ? At.toString : void 0;
+function nr(r) {
+  if (typeof r == "string")
+    return r;
+  if (yl(r))
+    return bl(r, nr) + "";
+  if (vl(r))
+    return xt ? xt.call(r) : "";
+  var e = r + "";
+  return e == "0" && 1 / r == -ml ? "-0" : e;
+}
+var _l = nr, Cl = _l;
+function Sl(r) {
+  return r == null ? "" : Cl(r);
+}
+var Al = Sl, xl = T, $l = Ue, El = pl, Fl = Al;
+function Tl(r, e) {
+  return xl(r) ? r : $l(r, e) ? [r] : El(Fl(r));
+}
+var sr = Tl, wl = de, Nl = 1 / 0;
+function Dl(r) {
+  if (typeof r == "string" || wl(r))
+    return r;
+  var e = r + "";
+  return e == "0" && 1 / r == -Nl ? "-0" : e;
+}
+var ge = Dl, Ol = sr, Ll = ge;
+function Pl(r, e) {
+  e = Ol(e, r);
+  for (var t = 0, i = e.length; r != null && t < i; )
+    r = r[Ll(e[t++])];
+  return t && t == i ? r : void 0;
+}
+var ke = Pl, Il = Kt, Ml = Ge, Rl = 1, Bl = 2;
+function zl(r, e, t, i) {
+  var n = t.length, s = n, a = !i;
+  if (r == null)
+    return !s;
+  for (r = Object(r); n--; ) {
+    var o = t[n];
+    if (a && o[2] ? o[1] !== r[o[0]] : !(o[0] in r))
+      return !1;
+  }
+  for (; ++n < s; ) {
+    o = t[n];
+    var l = o[0], c = r[l], d = o[1];
+    if (a && o[2]) {
+      if (c === void 0 && !(l in r))
+        return !1;
+    } else {
+      var g = new Il();
+      if (i)
+        var h = i(c, d, l, r, e, g);
+      if (!(h === void 0 ? Ml(d, c, Rl | Bl, i, g) : h))
+        return !1;
+    }
+  }
+  return !0;
+}
+var Gl = zl, Ul = oe;
+function jl(r) {
+  return r === r && !Ul(r);
+}
+var ar = jl, kl = ar, Hl = ze;
+function Vl(r) {
+  for (var e = Hl(r), t = e.length; t--; ) {
+    var i = e[t], n = r[i];
+    e[t] = [i, n, kl(n)];
+  }
+  return e;
+}
+var Kl = Vl;
+function ql(r, e) {
+  return function(t) {
+    return t == null ? !1 : t[r] === e && (e !== void 0 || r in Object(t));
+  };
+}
+var or = ql, Wl = Gl, Yl = Kl, Jl = or;
+function Zl(r) {
+  var e = Yl(r);
+  return e.length == 1 && e[0][2] ? Jl(e[0][0], e[0][1]) : function(t) {
+    return t === r || Wl(t, r, e);
+  };
+}
+var Xl = Zl, Ql = ke;
+function ec(r, e, t) {
+  var i = r == null ? void 0 : Ql(r, e);
+  return i === void 0 ? t : i;
+}
+var tc = ec;
+function rc(r, e) {
+  return r != null && e in Object(r);
+}
+var ic = rc, nc = sr, sc = Me, ac = T, oc = Re, uc = Be, lc = ge;
+function cc(r, e, t) {
+  e = nc(e, r);
+  for (var i = -1, n = e.length, s = !1; ++i < n; ) {
+    var a = lc(e[i]);
+    if (!(s = r != null && t(r, a)))
+      break;
+    r = r[a];
+  }
+  return s || ++i != n ? s : (n = r == null ? 0 : r.length, !!n && uc(n) && oc(a, n) && (ac(r) || sc(r)));
+}
+var dc = cc, gc = ic, hc = dc;
+function fc(r, e) {
+  return r != null && hc(r, e, gc);
+}
+var pc = fc, bc = Ge, yc = tc, vc = pc, mc = Ue, _c = ar, Cc = or, Sc = ge, Ac = 1, xc = 2;
+function $c(r, e) {
+  return mc(r) && _c(e) ? Cc(Sc(r), e) : function(t) {
+    var i = yc(t, r);
+    return i === void 0 && i === e ? vc(t, r) : bc(e, i, Ac | xc);
+  };
+}
+var Ec = $c;
+function Fc(r) {
+  return r;
+}
+var he = Fc;
+function Tc(r) {
+  return function(e) {
+    return e == null ? void 0 : e[r];
+  };
+}
+var wc = Tc, Nc = ke;
+function Dc(r) {
+  return function(e) {
+    return Nc(e, r);
+  };
+}
+var Oc = Dc, Lc = wc, Pc = Oc, Ic = Ue, Mc = ge;
+function Rc(r) {
+  return Ic(r) ? Lc(Mc(r)) : Pc(r);
+}
+var Bc = Rc, zc = Xl, Gc = Ec, Uc = he, jc = T, kc = Bc;
+function Hc(r) {
+  return typeof r == "function" ? r : r == null ? Uc : typeof r == "object" ? jc(r) ? Gc(r[0], r[1]) : zc(r) : kc(r);
+}
+var Vc = Hc;
+function Kc(r) {
+  return function(e, t, i) {
+    for (var n = -1, s = Object(e), a = i(e), o = a.length; o--; ) {
+      var l = a[r ? o : ++n];
+      if (t(s[l], l, s) === !1)
+        break;
+    }
+    return e;
+  };
+}
+var qc = Kc, Wc = qc, Yc = Wc(), Jc = Yc, Zc = Jc, Xc = ze;
+function Qc(r, e) {
+  return r && Zc(r, e, Xc);
+}
+var ed = Qc, td = ce;
+function rd(r, e) {
+  return function(t, i) {
+    if (t == null)
+      return t;
+    if (!td(t))
+      return r(t, i);
+    for (var n = t.length, s = e ? n : -1, a = Object(t); (e ? s-- : ++s < n) && i(a[s], s, a) !== !1; )
+      ;
+    return t;
+  };
+}
+var id = rd, nd = ed, sd = id, ad = sd(nd), od = ad, ud = od, ld = ce;
+function cd(r, e) {
+  var t = -1, i = ld(r) ? Array(r.length) : [];
+  return ud(r, function(n, s, a) {
+    i[++t] = e(n, s, a);
+  }), i;
+}
+var dd = cd;
+function gd(r, e) {
+  var t = r.length;
+  for (r.sort(e); t--; )
+    r[t] = r[t].value;
+  return r;
+}
+var hd = gd, $t = de;
+function fd(r, e) {
+  if (r !== e) {
+    var t = r !== void 0, i = r === null, n = r === r, s = $t(r), a = e !== void 0, o = e === null, l = e === e, c = $t(e);
+    if (!o && !c && !s && r > e || s && a && l && !o && !c || i && a && l || !t && l || !n)
+      return 1;
+    if (!i && !s && !c && r < e || c && t && n && !i && !s || o && t && n || !a && n || !l)
+      return -1;
+  }
+  return 0;
+}
+var pd = fd, bd = pd;
+function yd(r, e, t) {
+  for (var i = -1, n = r.criteria, s = e.criteria, a = n.length, o = t.length; ++i < a; ) {
+    var l = bd(n[i], s[i]);
+    if (l) {
+      if (i >= o)
+        return l;
+      var c = t[i];
+      return l * (c == "desc" ? -1 : 1);
+    }
+  }
+  return r.index - e.index;
+}
+var vd = yd, ye = rr, md = ke, _d = Vc, Cd = dd, Sd = hd, Ad = Zt, xd = vd, $d = he, Ed = T;
+function Fd(r, e, t) {
+  e.length ? e = ye(e, function(s) {
+    return Ed(s) ? function(a) {
+      return md(a, s.length === 1 ? s[0] : s);
+    } : s;
+  }) : e = [$d];
+  var i = -1;
+  e = ye(e, Ad(_d));
+  var n = Cd(r, function(s, a, o) {
+    var l = ye(e, function(c) {
+      return c(s);
+    });
+    return { criteria: l, index: ++i, value: s };
+  });
+  return Sd(n, function(s, a) {
+    return xd(s, a, t);
+  });
+}
+var Td = Fd;
+function wd(r, e, t) {
+  switch (t.length) {
+    case 0:
+      return r.call(e);
+    case 1:
+      return r.call(e, t[0]);
+    case 2:
+      return r.call(e, t[0], t[1]);
+    case 3:
+      return r.call(e, t[0], t[1], t[2]);
+  }
+  return r.apply(e, t);
+}
+var Nd = wd, Dd = Nd, Et = Math.max;
+function Od(r, e, t) {
+  return e = Et(e === void 0 ? r.length - 1 : e, 0), function() {
+    for (var i = arguments, n = -1, s = Et(i.length - e, 0), a = Array(s); ++n < s; )
+      a[n] = i[e + n];
+    n = -1;
+    for (var o = Array(e + 1); ++n < e; )
+      o[n] = i[n];
+    return o[e] = t(a), Dd(r, this, o);
+  };
+}
+var Ld = Od;
+function Pd(r) {
+  return function() {
+    return r;
+  };
+}
+var Id = Pd, Md = M, Rd = function() {
+  try {
+    var r = Md(Object, "defineProperty");
+    return r({}, "", {}), r;
+  } catch {
+  }
+}(), Bd = Rd, zd = Id, Ft = Bd, Gd = he, Ud = Ft ? function(r, e) {
+  return Ft(r, "toString", {
+    configurable: !0,
+    enumerable: !1,
+    value: zd(e),
+    writable: !0
+  });
+} : Gd, jd = Ud, kd = 800, Hd = 16, Vd = Date.now;
+function Kd(r) {
+  var e = 0, t = 0;
+  return function() {
+    var i = Vd(), n = Hd - (i - t);
+    if (t = i, n > 0) {
+      if (++e >= kd)
+        return arguments[0];
+    } else
+      e = 0;
+    return r.apply(void 0, arguments);
+  };
+}
+var qd = Kd, Wd = jd, Yd = qd, Jd = Yd(Wd), Zd = Jd, Xd = he, Qd = Ld, eg = Zd;
+function tg(r, e) {
+  return eg(Qd(r, e, Xd), r + "");
+}
+var rg = tg, ig = Le, ng = ce, sg = Re, ag = oe;
+function og(r, e, t) {
+  if (!ag(t))
+    return !1;
+  var i = typeof e;
+  return (i == "number" ? ng(t) && sg(e, t.length) : i == "string" && e in t) ? ig(t[e], r) : !1;
+}
+var ug = og, lg = Wu, cg = Td, dg = rg, Tt = ug, gg = dg(function(r, e) {
+  if (r == null)
+    return [];
+  var t = e.length;
+  return t > 1 && Tt(r, e[0], e[1]) ? e = [] : t > 2 && Tt(e[0], e[1], e[2]) && (e = [e[0]]), cg(r, lg(e, 1), []);
+}), hg = gg;
+const z = /* @__PURE__ */ Oe(hg), fg = /\S+\.(gif|jpe?g|tiff|png|bmp|svg)$/i, pg = [
+  "label",
+  "Label",
+  "name",
+  "Name",
+  "title",
+  "Title",
+  "rdfs:label"
+];
+class u {
+  static isEqual(e, t) {
+    return Uu(e, t);
+  }
+  /**
+   * Check that a value is defined : not null and not undefined
+   *
+   * @param {any} value
+   * @return {boolean}
+   */
+  static isDefined(e) {
+    return e != null;
+  }
+  /**
+   * Truncate a text
+   */
+  static truncate(e, t, i = 0) {
+    const n = "…";
+    if (!u.isDefined(e))
+      return "";
+    const s = `${e}`;
+    if (s.length <= i + 1)
+      return s;
+    const a = i - 1;
+    switch (t) {
+      case "middle":
+        return s.substring(0, Math.ceil(a / 2)) + n + s.substring(s.length - Math.floor(a / 2));
+      case "end":
+        return s.substring(0, a) + n;
+    }
+  }
+  /**
+   * Return a value from a nested object depending on a keyPath
+   */
+  static getIn(e, t) {
+    return t.reduce((i, n) => i && i[n] !== void 0 ? i[n] : void 0, e);
+  }
+  /**
+   * Return a clone of an object
+   */
+  static clone(e) {
+    return typeof e == "object" ? JSON.parse(
+      JSON.stringify(e, (t, i) => i instanceof Set ? {} : i)
+    ) : e;
+  }
+  /**
+   * Get the amount of hidden neighbors from a list of nodes
+   *
+   * @param nodes
+   */
+  static getHiddenNeighbors(e) {
+    return e.reduce((t, i) => {
+      const n = i.getData("statistics");
+      if (n !== void 0) {
+        const s = n.degree !== void 0 && !n.supernode ? n.degree - u.getDegreeWithoutSelfConnection(i) : n.supernodeDegree;
+        if (s !== void 0 && s > 0)
+          return t += s;
+      }
+      return t;
+    }, 0);
+  }
+  /**
+   * Return the visible degree of a node without self connection (self edge)
+   *
+   * @param {Node} node
+   * @return {number}
+   */
+  static getDegreeWithoutSelfConnection(e) {
+    return e.getAdjacentNodes({ policy: "exclude-sources", filter: "raw" }).size;
+  }
+  /**
+   * Return a formatted version of a number
+   */
+  static formatNumber(e) {
+    let t = 1, i = "";
+    const n = e < 0 ? "-" : "";
+    e = Math.abs(e), e >= 1e6 ? (t = 1e6, i = "M") : e >= 1e3 && (t = 1e3, i = "k");
+    const s = e / t;
+    return s < 10 && s % 1 !== 0 ? n + s.toFixed(1) + i : n + Math.floor(s) + i;
+  }
+  /**
+   * Return true if a string is not composed only by invisible char
+   *
+   * @param {string} value
+   * @return {boolean}
+   */
+  static isStringFilled(e) {
+    return e.trim() !== "";
+  }
+  static getValueFromLkProperty(e) {
+    if (typeof e == "object" && "type" in e) {
+      if (!("original" in e) && !("value" in e))
+        return null;
+      if ("original" in e)
+        return `${e.original}`;
+      if ("value" in e)
+        return u.formatDate(
+          new Date(
+            new Date(e.value).getTime() + u.timezoneToMilliseconds(e.timezone)
+          ).toISOString()
+        );
+    }
+    return e;
+  }
+  /**
+   * Return a formatted date as a string
+   */
+  static formatDate(e, t, i) {
+    let n = e;
+    i !== void 0 && (n = new Date(e).getTime() + i * 1e3);
+    const s = new Date(n);
+    if (isNaN(s.getUTCFullYear()))
+      return null;
+    let a = s.getFullYear() + "-" + ((s.getUTCMonth() + 1).toString().length === 1 ? "0" + (s.getUTCMonth() + 1) : s.getUTCMonth() + 1) + "-" + (s.getUTCDate().toString().length === 1 ? "0" + s.getUTCDate() : s.getUTCDate());
+    return t && (a += " " + (s.getUTCHours().toString().length === 1 ? "0" + s.getUTCHours() : s.getUTCHours()) + ":" + (s.getUTCMinutes().toString().length === 1 ? "0" + s.getUTCMinutes() : s.getUTCMinutes()) + ":" + (s.getUTCSeconds().toString().length === 1 ? "0" + s.getUTCSeconds() : s.getUTCSeconds())), a;
+  }
+  /**
+   * From "+03:00" return the offset in milliseconds
+   * @param timezone
+   */
+  static timezoneToMilliseconds(e) {
+    if (e === void 0 || e === "Z")
+      return 0;
+    const t = e[0], [i, n] = e.slice(1).split(":");
+    return t === "+" ? this.sanitizeFormattedNumber(i) * 36e5 + this.sanitizeFormattedNumber(n) * 6e4 : (this.sanitizeFormattedNumber(i) * 36e5 + this.sanitizeFormattedNumber(n) * 6e4) * -1;
+  }
+  static sanitizeFormattedNumber(e) {
+    return e.length === 2 && e.startsWith("0") ? u.parseNumber(e[1]) : u.parseNumber(e);
+  }
+  /**
+   * Return true if `n` is (or can be parsed as) a float, but is NOT an integer
+   *
+   * @param {any} n
+   * @return {number} a number (NaN is `n` cannot be parsed as a number)
+   */
+  static parseNumber(e) {
+    if (typeof e == "string") {
+      if (e.trim() === "")
+        return Number.NaN;
+      e = +e.replace(",", ".").replace(" ", "");
+    }
+    return typeof e != "number" || !isFinite(e) ? Number.NaN : e;
+  }
+  /**
+   * Return an Array without duplicated keys
+   *
+   * @param {Array<any>} arr
+   * @param {string} key
+   * @return {Array<any>}
+   */
+  static uniqBy(e, t) {
+    const i = /* @__PURE__ */ new Set();
+    if (t) {
+      const n = [];
+      for (let s = 0; s < e.length; ++s)
+        e[s] && e[s][t] && !i.has(e[s][t]) ? (i.add(e[s][t]), n.push(e[s])) : e[s][t] || n.push(e[s]);
+      return n;
+    }
+    return typeof e[0] == "object" ? Array.from(new Set(e.map((n) => JSON.stringify(n)))).map((n) => JSON.parse(n)) : Array.from(new Set(e));
+  }
+  /**
+   * Return 'image' or 'url' depending on the given string
+   *
+   * @param {string} value
+   * @return {"image" | "url"}
+   */
+  static getType(e) {
+    if (u.isURLImage(e))
+      return "imageUrl";
+    if (u.isImage(e))
+      return "image";
+    if (u.isUrl(e))
+      return "url";
+  }
+  /**
+   * Return true if the given string is an url that match the schema handled by LKE
+   *
+   * @param {string}  value
+   * @return {boolean}
+   */
+  static isUrl(e) {
+    try {
+      return new URL(e), !0;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Return true if the given string is an image extension
+   *
+   * @param {string}  value
+   * @return {boolean}
+   */
+  static isImage(e) {
+    return fg.test(e);
+  }
+  /**
+   * Return true if the given string is an url with an image extension
+   *
+   * @param {string}  value
+   * @return {boolean}
+   */
+  static isURLImage(e) {
+    if (u.isUrl(e)) {
+      const t = new URL(e);
+      return u.isImage(t.pathname);
+    }
+    return !1;
+  }
+  /**
+   * Return true if a value is not undefined, not null and not an empty string
+   */
+  static valueExists(e) {
+    return u.isDefined(e) && (typeof e != "string" || u.isStringFilled(e));
+  }
+  /**
+   * Return true if `n` is (or can be parsed as) a number
+   */
+  static isNumber(e) {
+    return e = u.parseNumber(e), u.isDefined(e) && e === e;
+  }
+  /**
+   * return the correct property value
+   */
+  static getPropertyValue(e, t, i) {
+    if (typeof e == "object" && !Array.isArray(e)) {
+      if ("status" in e)
+        return t && "original" in e ? e.original : void 0;
+      if ((e.type === "date" || e.type === "datetime") && i)
+        return u.formatDate(e.value, e.type === "datetime");
+      if (e.type === "date" || e.type === "datetime")
+        return new Date(e.value).getTime();
+    }
+    return e;
+  }
+  /**
+   * Parse the given value and return a float number or NaN
+   *
+   * @param {any} n
+   * @return {number}
+   */
+  static parseFloat(e) {
+    return u.parseNumber(e);
+  }
+  /**
+   * Format a currency value to string.
+   *
+   * eg: 4123 -> 4.123,00 $
+   */
+  static formatCurrencyValue(e, t) {
+    const i = e < 0 ? "- " : "";
+    switch (t.format) {
+      case B.SYMBOL_COMMAS_DOT:
+        return `${i}${t.symbol !== void 0 ? t.symbol + " " : ""}${u.formatNumberToCurrency(e, ",", ".")}`;
+      case B.SYMBOL_COMMAS:
+        return `${i}${t.symbol !== void 0 ? t.symbol + " " : ""}${u.formatNumberToCurrency(e, ",")}`;
+      case B.DOTS_COMMA_SYMBOL:
+        return `${i}${u.formatNumberToCurrency(e, ".", ",")}${t.symbol !== void 0 ? " " + t.symbol : ""}`;
+      case B.DOTS_SYMBOL:
+        return `${i}${u.formatNumberToCurrency(e, ".")}${t.symbol !== void 0 ? " " + t.symbol : ""}`;
+      case B.SPACES_COMMA_SYMBOL:
+        return `${i}${u.formatNumberToCurrency(e, " ", ",")}${t.symbol !== void 0 ? " " + t.symbol : ""}`;
+      case B.SPACES_SYMBOL:
+        return `${i}${u.formatNumberToCurrency(e, " ")}${t.symbol !== void 0 ? " " + t.symbol : ""}`;
+      default:
+        throw Error(`Cannot format property value ${e}, unknown format ${t.format}.`);
+    }
+  }
+  static formatNumberToCurrency(e, t, i) {
+    if (!Number.isFinite(e))
+      return e.toString();
+    const [n, s] = i ? Math.abs(e).toFixed(2).split(".") : [Math.abs(e).toFixed(0), void 0];
+    let a = -1;
+    const o = n.split("").reverse().map((l) => (a++, a > 0 && a % 3 === 0 ? l + t : l)).reverse().join("");
+    return i ? o + i + s : o;
+  }
+}
+class w {
+  /**
+   * Return label for each node
+   */
+  static getText(e, t, i) {
+    const n = "categories" in e ? e.categories : [e.type];
+    if (w.captionExist(n, t))
+      return "categories" in e ? w.generateNodeCaption(e, t, i) || null : w.generateEdgeCaption(e, t, i) || null;
+    if (e.properties !== void 0) {
+      const s = pg.find((a) => e.properties[a] !== void 0);
+      if (s !== void 0 && u.isDefined(e.properties[s]))
+        return `${u.getValueFromLkProperty(
+          e.properties[s]
+        )}`.trim();
+    }
+    return null;
+  }
+  /**
+   * Return a readable string from an LkProperty
+   */
+  static getLabel(e, t) {
+    if (typeof e == "object" && "type" in e) {
+      if (!("original" in e) && !("value" in e))
+        return null;
+      if ("original" in e)
+        return `${e.original}`;
+      if ("value" in e)
+        return u.formatDate(
+          new Date(
+            new Date(e.value).getTime() + u.timezoneToMilliseconds(e.timezone)
+          ).toISOString()
+        );
+    } else if ((t == null ? void 0 : t.name) === pr.NUMBER && t.options !== void 0)
+      return u.formatCurrencyValue(e, t.options);
+    return `${e}`.trim();
+  }
+  /**
+   * Return true if caption configuration exists in schema
+   */
+  static captionExist(e, t) {
+    return e.some((i) => u.isDefined(t[i]));
+  }
+  /**
+   * Generate text from node data and captions schema
+   */
+  static generateNodeCaption(e, t, i) {
+    const n = e.categories, s = [];
+    let a = [];
+    return n.forEach((o) => {
+      t[o] && t[o].active && (t[o].displayName && s.push(o), a = [...a, ...t[o].properties]);
+    }), u.uniqBy(a).forEach((o) => {
+      if (e.properties[o] !== void 0) {
+        const l = i ? w.getPropertyType(i, o, n[0]) : void 0;
+        s.push(this.getLabel(e.properties[o], l));
+      }
+    }), s.filter((o) => o !== null).join(" - ").trim();
+  }
+  static getPropertyType(e, t, i) {
+    const n = e.find((a) => a.itemType === i), s = n == null ? void 0 : n.properties.find(
+      (a) => a.propertyKey === t
+    );
+    return s == null ? void 0 : s.propertyType;
+  }
+  /**
+   * Generate text from edge data and captions schema
+   */
+  static generateEdgeCaption(e, t, i) {
+    const n = e.type, s = [];
+    let a = [];
+    return t[n] && t[n].active ? (t[n].displayName && s.push(n), a = [...a, ...t[n].properties], u.uniqBy(a).forEach((o) => {
+      if (u.isDefined(e.properties[o])) {
+        const l = i ? w.getPropertyType(i, o, n) : void 0;
+        s.push(w.getLabel(e.properties[o], l));
+      }
+    }), s.join(" - ").trim()) : "";
+  }
+}
+var ur = { exports: {} }, lr = { exports: {} };
+(function() {
+  var r = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", e = {
+    // Bit-wise rotation left
+    rotl: function(t, i) {
+      return t << i | t >>> 32 - i;
+    },
+    // Bit-wise rotation right
+    rotr: function(t, i) {
+      return t << 32 - i | t >>> i;
+    },
+    // Swap big-endian to little-endian and vice versa
+    endian: function(t) {
+      if (t.constructor == Number)
+        return e.rotl(t, 8) & 16711935 | e.rotl(t, 24) & 4278255360;
+      for (var i = 0; i < t.length; i++)
+        t[i] = e.endian(t[i]);
+      return t;
+    },
+    // Generate an array of any length of random bytes
+    randomBytes: function(t) {
+      for (var i = []; t > 0; t--)
+        i.push(Math.floor(Math.random() * 256));
+      return i;
+    },
+    // Convert a byte array to big-endian 32-bit words
+    bytesToWords: function(t) {
+      for (var i = [], n = 0, s = 0; n < t.length; n++, s += 8)
+        i[s >>> 5] |= t[n] << 24 - s % 32;
+      return i;
+    },
+    // Convert big-endian 32-bit words to a byte array
+    wordsToBytes: function(t) {
+      for (var i = [], n = 0; n < t.length * 32; n += 8)
+        i.push(t[n >>> 5] >>> 24 - n % 32 & 255);
+      return i;
+    },
+    // Convert a byte array to a hex string
+    bytesToHex: function(t) {
+      for (var i = [], n = 0; n < t.length; n++)
+        i.push((t[n] >>> 4).toString(16)), i.push((t[n] & 15).toString(16));
+      return i.join("");
+    },
+    // Convert a hex string to a byte array
+    hexToBytes: function(t) {
+      for (var i = [], n = 0; n < t.length; n += 2)
+        i.push(parseInt(t.substr(n, 2), 16));
+      return i;
+    },
+    // Convert a byte array to a base-64 string
+    bytesToBase64: function(t) {
+      for (var i = [], n = 0; n < t.length; n += 3)
+        for (var s = t[n] << 16 | t[n + 1] << 8 | t[n + 2], a = 0; a < 4; a++)
+          n * 8 + a * 6 <= t.length * 8 ? i.push(r.charAt(s >>> 6 * (3 - a) & 63)) : i.push("=");
+      return i.join("");
+    },
+    // Convert a base-64 string to a byte array
+    base64ToBytes: function(t) {
+      t = t.replace(/[^A-Z0-9+\/]/ig, "");
+      for (var i = [], n = 0, s = 0; n < t.length; s = ++n % 4)
+        s != 0 && i.push((r.indexOf(t.charAt(n - 1)) & Math.pow(2, -2 * s + 8) - 1) << s * 2 | r.indexOf(t.charAt(n)) >>> 6 - s * 2);
+      return i;
+    }
+  };
+  lr.exports = e;
+})();
+var bg = lr.exports, Fe = {
+  // UTF-8 encoding
+  utf8: {
+    // Convert a string to a byte array
+    stringToBytes: function(r) {
+      return Fe.bin.stringToBytes(unescape(encodeURIComponent(r)));
+    },
+    // Convert a byte array to a string
+    bytesToString: function(r) {
+      return decodeURIComponent(escape(Fe.bin.bytesToString(r)));
+    }
+  },
+  // Binary encoding
+  bin: {
+    // Convert a string to a byte array
+    stringToBytes: function(r) {
+      for (var e = [], t = 0; t < r.length; t++)
+        e.push(r.charCodeAt(t) & 255);
+      return e;
+    },
+    // Convert a byte array to a string
+    bytesToString: function(r) {
+      for (var e = [], t = 0; t < r.length; t++)
+        e.push(String.fromCharCode(r[t]));
+      return e.join("");
+    }
+  }
+}, wt = Fe;
+(function() {
+  var r = bg, e = wt.utf8, t = wt.bin, i = function(s) {
+    s.constructor == String ? s = e.stringToBytes(s) : typeof Buffer < "u" && typeof Buffer.isBuffer == "function" && Buffer.isBuffer(s) ? s = Array.prototype.slice.call(s, 0) : Array.isArray(s) || (s = s.toString());
+    var a = r.bytesToWords(s), o = s.length * 8, l = [], c = 1732584193, d = -271733879, g = -1732584194, h = 271733878, y = -1009589776;
+    a[o >> 5] |= 128 << 24 - o % 32, a[(o + 64 >>> 9 << 4) + 15] = o;
+    for (var _ = 0; _ < a.length; _ += 16) {
+      for (var f = c, A = d, x = g, $ = h, R = y, v = 0; v < 80; v++) {
+        if (v < 16)
+          l[v] = a[_ + v];
+        else {
+          var O = l[v - 3] ^ l[v - 8] ^ l[v - 14] ^ l[v - 16];
+          l[v] = O << 1 | O >>> 31;
+        }
+        var fr = (c << 5 | c >>> 27) + y + (l[v] >>> 0) + (v < 20 ? (d & g | ~d & h) + 1518500249 : v < 40 ? (d ^ g ^ h) + 1859775393 : v < 60 ? (d & g | d & h | g & h) - 1894007588 : (d ^ g ^ h) - 899497514);
+        y = h, h = g, g = d << 30 | d >>> 2, d = c, c = fr;
+      }
+      c += f, d += A, g += x, h += $, y += R;
+    }
+    return [c, d, g, h, y];
+  }, n = function(s, a) {
+    var o = r.wordsToBytes(i(s));
+    return a && a.asBytes ? o : a && a.asString ? t.bytesToString(o) : r.bytesToHex(o);
+  };
+  n._blocksize = 16, n._digestsize = 20, ur.exports = n;
+})();
+var yg = ur.exports;
+const He = /* @__PURE__ */ Oe(yg), F = "#7f7f7f", Nt = [
+  "#9467bd",
+  "#e377c2",
+  "#1f77b4",
+  "#17becf",
+  "#2ca02c",
+  "#bcbd22",
+  "#d62728",
+  "#ff7f0e",
+  "#8c564b",
+  "#c5b0d5",
+  "#f7b6d2",
+  "#aec7e8",
+  "#9edae5",
+  "#98df8a",
+  "#dbdb8d",
+  "#ff9896",
+  "#ffbb78",
+  "#c49c94"
+];
+class E {
+  constructor(e) {
+    this.colorsCache = /* @__PURE__ */ new Map(), this._rulesMap = {}, this.refresh(e);
+  }
+  /**
+   * Refresh the rules
+   */
+  refresh(e) {
+    e.color !== void 0 && (this.colorsCache = /* @__PURE__ */ new Map()), this._rulesMap = {
+      color: e.color ? [...e.color].reverse() : this._rulesMap.color,
+      icon: e.icon ? [...e.icon].reverse() : this._rulesMap.icon,
+      image: e.image ? [...e.image].reverse() : this._rulesMap.image,
+      shape: e.shape ? [...e.shape].reverse() : this._rulesMap.shape,
+      size: e.size ? [...e.size].reverse() : this._rulesMap.size,
+      width: e.width ? [...e.width].reverse() : this._rulesMap.width
+    };
+  }
+  /**
+   * Return the color for a node when style color is auto
+   */
+  static autoColor(e, t) {
+    return u.isDefined(e) ? Nt[E.getRandomUniqueColorPaletteIndex(e, Nt.length, t)] : F;
+  }
+  /**
+   * Return a number from 0 to number of occurrence in a palette based on a property
+   */
+  static getRandomUniqueColorPaletteIndex(e, t, i) {
+    return i && (e = e.toLowerCase()), +("0x" + He(e).substr(-4)) % t;
+  }
+  /**
+   * Get color of a type
+   */
+  static getTypeColor(e, t) {
+    return typeof e.style.color == "object" && e.style.color.input[0] !== "properties" ? E.autoColor(t, e.style.color.ignoreCase) : !u.isDefined(e.input) && typeof e.style.color != "object" ? e.style.color : null;
+  }
+  /**
+   * return the corresponding size to the value with a linear function
+   * @param value
+   * @param lower
+   * @param higher
+   * @param extrema
+   */
+  static getAutomaticRangeStyleLinear(e, { max: t, min: i }, n, s) {
+    if (t !== void 0 && i !== void 0) {
+      if (t === i || isNaN(e))
+        return "100%";
+      const a = (s - n) / (t - i), o = (n * t - s * i) / (t - i);
+      return `${Math.floor(e * a + o)}%`;
+    }
+  }
+  /**
+   * return the corresponding size to the value with a logarithmic function
+   * @param value
+   * @param lower
+   * @param higher
+   * @param extrema
+   */
+  static getAutomaticRangeStyleLog(e, { max: t, min: i }, n, s) {
+    if (i !== void 0 && t !== void 0) {
+      if (t === i || isNaN(e))
+        return "100%";
+      i < 1 && (e += Math.abs(i) + 1, t += Math.abs(i) + 1, i += Math.abs(i) + 1);
+      const a = (s - n) / (Math.log(t) - Math.log(i)), o = (n * Math.log(t) - s * Math.log(i)) / (Math.log(t) - Math.log(i));
+      return `${Math.floor(a * Math.log(e) + o)}%`;
+    }
+  }
+  isAutoRange(e) {
+    return typeof e == "object" && (e == null ? void 0 : e.type) === "autoRange";
+  }
+}
+class W extends E {
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * Return rule that can be applied to the data
+   */
+  static matchStyle(e, t) {
+    if (t !== void 0) {
+      for (let i = 0; i < e.length; ++i)
+        if (e[i].canApplyTo(t))
+          return e[i];
+    }
+  }
+  /**
+   * Generate color for a given edge (call only if _rulesMap.color exists)
+   */
+  color(e) {
+    if (!u.isDefined(e))
+      return F;
+    let t;
+    for (let i = 0; i < this._rulesMap.color.length; ++i) {
+      const n = this._rulesMap.color[i];
+      if (n.canApplyTo(e)) {
+        if (typeof n.style.color == "string")
+          t = n.style.color;
+        else if (typeof n.style.color == "object") {
+          const s = u.getIn(e, n.style.color.input);
+          t = E.autoColor(`${s}`, n.style.color.ignoreCase);
+        }
+        break;
+      }
+    }
+    return u.isDefined(t) ? t : F;
+  }
+  /**
+   * Generate shape for a given node
+   */
+  shape(e) {
+    var t;
+    if (this._rulesMap.shape !== void 0)
+      return (t = W.matchStyle(this._rulesMap.shape, e)) == null ? void 0 : t.style.shape;
+  }
+  /**
+   * Generate size for a given node
+   */
+  width(e) {
+    if (this._rulesMap.width !== void 0) {
+      const t = W.matchStyle(this._rulesMap.width, e);
+      if (t !== void 0) {
+        const i = t == null ? void 0 : t.style.width;
+        if (i !== void 0 && this.isAutoRange(i)) {
+          if (i.input !== void 0 && i.max !== void 0 && i.min !== void 0) {
+            const n = i.input[1], s = u.parseNumber(e.properties[n]), a = i.scale && i.scale === Ut.LOGARITHMIC;
+            return W.getAutomaticRangeWidth(s, t, a);
+          }
+        } else
+          return i;
+      }
+    }
+  }
+  /**
+   * return the corresponding width to the value
+   * @param value
+   * @param rule
+   * @param isLog
+   */
+  static getAutomaticRangeWidth(e, t, i = !1) {
+    return i ? this.getAutomaticRangeStyleLog(
+      e,
+      t.style.width,
+      50,
+      200
+      /* MAX */
+    ) : this.getAutomaticRangeStyleLinear(
+      e,
+      t.style.width,
+      50,
+      200
+      /* MAX */
+    );
+  }
+  /**
+   * Return an object containing all node attributes needed by Ogma to style a node
+   */
+  all(e) {
+    return u.isDefined(e) ? {
+      color: this.color(e),
+      shape: this.shape(e),
+      width: this.width(e)
+    } : {
+      color: F,
+      shape: br.ARROW,
+      width: "100%"
+    };
+  }
+}
+class U extends E {
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * Run the callback if an item match with a style in the array of rules
+   */
+  static matchStyle(e, t, i) {
+    if (u.isDefined(t) && u.isDefined(e)) {
+      for (let n = 0; n < e.length; ++n)
+        if (e[n].canApplyTo(t)) {
+          i(e[n]);
+          break;
+        }
+    }
+  }
+  /**
+   * Generate color for a given node (call only if _rulesMap.color is defined
+   */
+  color(e) {
+    if (!u.isDefined(e))
+      return [F];
+    const t = He(JSON.stringify(e)), i = this.colorsCache.get(t);
+    if (i !== void 0)
+      return i;
+    let n = [];
+    for (let a = 0; a < e.categories.length; ++a) {
+      let o = null;
+      for (let l = 0; l < this._rulesMap.color.length; ++l) {
+        const c = this._rulesMap.color[l];
+        if (!(c.itemType !== void 0 && c.itemType !== null && c.itemType !== e.categories[a]) && c.canApplyTo(e)) {
+          if (typeof c.style.color == "object") {
+            const d = u.getIn(e, c.style.color.input);
+            Array.isArray(d) ? o = E.autoColor(e.categories[a], c.style.color.ignoreCase) : o = E.autoColor(`${d}`, c.style.color.ignoreCase);
+          } else
+            o = c.style.color;
+          break;
+        }
+      }
+      n.push(o);
+    }
+    n = n.filter((a) => u.isDefined(a)), n.length === 0 && (n = [F]);
+    const s = n.length === 1 ? n[0] : n;
+    return this.colorsCache.set(t, s), s;
+  }
+  /**
+   * Generate icon for a given node
+   */
+  icon(e) {
+    var a, o;
+    const t = this.color(e), i = Array.isArray(t) ? t[0] : t;
+    let n = {};
+    const s = [...this._rulesMap.image || [], ...this._rulesMap.icon || []];
+    if (!u.isDefined(e))
+      return {
+        icon: {},
+        image: {}
+      };
+    for (let l = 0; l < s.length; ++l)
+      if (s[l].canApplyTo(e)) {
+        const c = s[l].style;
+        if ("icon" in c && typeof c.icon == "object")
+          n = {
+            icon: {
+              content: (a = c.icon) == null ? void 0 : a.content,
+              font: (o = c.icon) == null ? void 0 : o.font,
+              scale: 0.5,
+              color: ne.isBright(i) ? "#000000" : "#FFFFFF"
+            }
+          };
+        else if ("image" in c && typeof c.image == "object") {
+          const d = U.getImageUrlFromStyleRule(
+            c.image.url,
+            e,
+            this._baseUrl
+          );
+          d !== void 0 && (n = {
+            image: {
+              url: d,
+              scale: c.image.scale,
+              fit: c.image.fit,
+              tile: c.image.tile,
+              minVisibleSize: 0
+            }
+          });
+        }
+        break;
+      }
+    return n;
+  }
+  /**
+   * Generate shape for a given node
+   */
+  shape(e) {
+    let t;
+    return this._rulesMap.shape !== void 0 && U.matchStyle(this._rulesMap.shape, e, (i) => {
+      t = i.style.shape;
+    }), t;
+  }
+  /**
+   * Generate size for a given node
+   */
+  size(e) {
+    let t;
+    return this._rulesMap.size !== void 0 && U.matchStyle(
+      this._rulesMap.size,
+      e,
+      (i) => {
+        const n = i.style.size;
+        if (this.isAutoRange(n)) {
+          if (n.input !== void 0 && n.max !== void 0 && n.min !== void 0) {
+            const s = n.input[1], a = u.parseNumber(e.properties[s]), o = n.scale && n.scale === Ut.LOGARITHMIC;
+            t = U.getAutomaticRangeSize(a, i, o);
+          }
+        } else
+          t = n;
+      }
+    ), t;
+  }
+  /**
+   * return the corresponding size to the value
+   * @param value
+   * @param rule
+   * @param isLog
+   */
+  static getAutomaticRangeSize(e, t, i = !1) {
+    return i ? this.getAutomaticRangeStyleLog(
+      e,
+      t.style.size,
+      50,
+      500
+      /* MAX */
+    ) : this.getAutomaticRangeStyleLinear(
+      e,
+      t.style.size,
+      50,
+      500
+      /* MAX */
+    );
+  }
+  /**
+   * Return an object containing all node attributes needed by Ogma to style a node
+   */
+  all(e) {
+    if (!u.isDefined(e))
+      return {
+        color: F
+      };
+    const t = this.icon(e);
+    return {
+      radius: this.size(e),
+      color: this.color(e),
+      shape: this.shape(e),
+      icon: t.icon,
+      image: t.image
+    };
+  }
+  /**
+   * Return the value of the image url from a style rule or undefined
+   * @param value
+   * @param itemData
+   * @param baseUrl
+   */
+  static getImageUrlFromStyleRule(e, t, i) {
+    let n;
+    return typeof e == "string" && ["imageUrl", "image"].includes(u.getType(e)) ? n = e : typeof e == "object" && (n = u.getIn(t, e.path)), n !== void 0 && i !== void 0 ? new URL(n, i).href : n;
+  }
+  /**
+   * Set the base url (it will be used for image url while styling nodes)
+   * @param baseUrl bse url
+   */
+  setBaseUrl(e) {
+    this._baseUrl = e;
+  }
+}
+var vg = /* @__PURE__ */ ((r) => (r.AUTO_RANGE = "autoRange", r))(vg || {});
+class C {
+  constructor(e) {
+    this.type = e.type, this.input = e.input, this.index = e.index, this.itemType = e.itemType, this.style = e.style, this.value = e.value;
+  }
+  static isAutomaticRange(e) {
+    return e.style !== void 0 && (e.style.width !== void 0 && e.style.width.type === "autoRange" || e.style.size !== void 0 && e.style.size.type === "autoRange");
+  }
+  /**
+   * Return an int describing specificity of the style. 4 = very specific / 1 = not specific
+   *
+   * @return {number}
+   */
+  get specificity() {
+    return this.itemType !== void 0 && this.input !== void 0 ? 4 : this.itemType === void 0 && this.input !== void 0 ? 3 : this.itemType !== void 0 && this.input === void 0 ? 2 : 1;
+  }
+  /**
+   * Return true if this style match values
+   */
+  matchValues(e, t, i) {
+    return u.isDefined(t) ? (e === this.itemType || !u.isDefined(this.itemType)) && u.isEqual(["properties", ...t], this.input) && u.isEqual(i, this.value) || this.type === "any" && !u.isDefined(this.input) && typeof this.style.color == "object" && this.style.color.input[1] === t[0] : u.isDefined(this.itemType) ? e === this.itemType && !u.isDefined(this.input) : !u.isDefined(this.input);
+  }
+  static inputExists(e, t) {
+    return e !== S.ANY;
+  }
+  /**
+   * Return true if a style can apply to a node
+   */
+  canApplyTo(e) {
+    const t = "categories" in e ? e.categories : [e.type];
+    let i = !1;
+    switch (this.type) {
+      case S.ANY:
+        i = C.checkAny(e, this.style);
+        break;
+      case S.NO_VALUE:
+        C.inputExists(this.type, this.input) && (i = C.checkNoValue(e, this.input));
+        break;
+      case S.NAN:
+        C.inputExists(this.type, this.input) && (i = C.checkNan(e, this.input));
+        break;
+      case S.RANGE:
+        C.inputExists(this.type, this.input) && (i = C.checkRange(
+          u.getIn(e, this.input),
+          this.value
+        ));
+        break;
+      case S.IS:
+        C.inputExists(this.type, this.input) && (i = C.checkIs(e, this.input, this.value));
+        break;
+    }
+    return i && C.checkItemType(t, this.itemType);
+  }
+  /**
+   * Return true or false on rule type 'any' if the current node match the rule
+   */
+  static checkAny(e, t) {
+    return typeof t.color == "object" ? u.isDefined(u.getIn(e, t.color.input)) : !0;
+  }
+  /**
+   * Return true or false on rule type 'noValue' if the current node match the rule
+   */
+  static checkNoValue(e, t) {
+    return !u.valueExists(u.getIn(e, t));
+  }
+  /**
+   * Return true or false on rule type 'NaN' if the current node match the rule
+   */
+  static checkNan(e, t) {
+    return !u.isNumber(u.getIn(e, t));
+  }
+  /**
+   * Return true if predicate is true for the node value
+   *
+   * @param value
+   * @param comparator
+   * @return {boolean}
+   */
+  static checkRange(e, t) {
+    return (t["<="] === void 0 || e <= t["<="]) && (t["<"] === void 0 || e < t["<"]) && (t[">"] === void 0 || e > t[">"]) && (t[">="] === void 0 || e >= t[">="]);
+  }
+  /**
+   * Return true or false on rule type 'is' if the current node match the rule
+   */
+  static checkIs(e, t, i) {
+    if (!u.isDefined(t))
+      return !1;
+    const n = u.getIn(e, t);
+    let s = n;
+    if (u.isDefined(n) && typeof n == "object" && (n.type === "date" || n.type === "datetime")) {
+      let a = n.timezone;
+      n.timezone === "Z" && (a = "+00:00"), s = u.formatDate(
+        n.value,
+        n.type === "datetime",
+        u.timezoneToMilliseconds(a) / 1e3
+      );
+    }
+    return u.isEqual(s, i);
+  }
+  /**
+   * Check that value of itemType match for the node
+   */
+  static checkItemType(e, t) {
+    return C.matchCategory(e, t) || C.matchAny(t);
+  }
+  /**
+   * Return true if itemType is defined and category exists in an array of categories
+   *
+   * @param {Array<string> | string} types
+   * @param {string} itemType
+   * @return {boolean}
+   */
+  static matchCategory(e, t) {
+    return u.isDefined(t) && (Array.isArray(e) ? e.includes(t) : u.isEqual(e, t));
+  }
+  /**
+   * Return true if itemType is undefined
+   *
+   * @param {string} itemType
+   * @return {boolean}
+   */
+  static matchAny(e) {
+    return e === void 0;
+  }
+  /**
+   * Return the color for a type
+   */
+  getTypeColor(e) {
+    let t;
+    return C.checkItemType([e], this.itemType) && this.type === S.ANY && !u.isDefined(this.input) && (t = E.getTypeColor(this, e)), t;
+  }
+}
+var D = /* @__PURE__ */ ((r) => (r.COLOR = "color", r.ICON = "icon", r.SIZE = "size", r.IMAGE = "image", r.SHAPE = "shape", r.WIDTH = "width", r))(D || {});
+const G = ["specificity", "itemType", "index"];
+class p {
+  constructor(e) {
+    this._rules = e;
+  }
+  /**
+   * Return an array of StyleRule with only 'color' rules and sorted by specificity, itemType and index
+   *
+   * @return {Array<StyleRule>}
+   */
+  get color() {
+    return z(p.getBy("color", this._rules), G);
+  }
+  /**
+   * Return an array of StyleRule with only 'icon' rules and sorted by specificity, itemType and index
+   *
+   * @return {Array<StyleRule>}
+   */
+  get icon() {
+    return z(
+      [
+        ...p.getBy("icon", this._rules) || [],
+        ...p.getBy("image", this._rules) || []
+      ],
+      G
+    );
+  }
+  /**
+   * Return an array of StyleRule with only 'image' rules and sorted by specificity, itemType and index
+   *
+   * @return {Array<StyleRule>}
+   */
+  get image() {
+    return z(p.getBy("image", this._rules), G);
+  }
+  /**
+   * Return an array of StyleRule with only 'shape' rules and sorted by specificity, itemType and index
+   *
+   * @return {Array<StyleRule>}
+   */
+  get shape() {
+    return z(p.getBy("shape", this._rules), G);
+  }
+  /**
+   * Return an array of StyleRule with only 'size' rules and sorted by specificity, itemType and index
+   *
+   * @return {Array<StyleRule>}
+   */
+  get size() {
+    return z(p.getBy("size", this._rules), G);
+  }
+  /**
+   * Return an array of StyleRule with only 'width' rules and sorted by specificity, itemType and index
+   *
+   * @return {Array<StyleRule>}
+   */
+  get width() {
+    return z(p.getBy("width", this._rules), G);
+  }
+  /**
+   * Return an object containing for each node style a sorted array of StyleRule
+   *
+   * @return {{[key: string]: Array<StyleRule>} }
+   */
+  get nodeRules() {
+    return {
+      color: this.color,
+      icon: this.icon,
+      image: this.image,
+      shape: this.shape,
+      size: this.size
+    };
+  }
+  /**
+   * Return an object containing for each edge style a sorted array of StyleRule
+   *
+   * @return { {[key: string]: Array<StyleRule>}}
+   */
+  get edgeRules() {
+    return {
+      color: this.color,
+      shape: this.shape,
+      width: this.width
+    };
+  }
+  /**
+   * Generate a legend with an array of style rules and existing items in visualization
+   */
+  generateLegend(e) {
+    const t = {};
+    return e.length === 0 || ("categories" in e[0] ? Object.keys(this.nodeRules).forEach((i) => {
+      t[i] = p.getLegendForStyle(
+        i,
+        this.nodeRules[i],
+        e
+      );
+    }) : Object.keys(this.edgeRules).forEach((i) => {
+      t[i] = p.getLegendForStyle(
+        i,
+        this.edgeRules[i],
+        e
+      );
+    })), t;
+  }
+  /**
+   * Return the legend for a specific style type (color, icon, image...)
+   */
+  static getLegendForStyle(e, t, i) {
+    const n = [], s = i.filter((a) => a);
+    for (let a = 0; a < t.length; a++) {
+      const o = new C(t[a]);
+      if (s.some((c) => o.canApplyTo(c)))
+        if (e === "color" && typeof o.style.color == "object")
+          p.addLegendAutoColors(s, o, n);
+        else if (e === "icon" && "image" in o.style) {
+          const c = u.isDefined(o.input) ? `${p.getTypeLabel(o.itemType)}.${o.input[1]} ${p.sanitizeValue(o.type, o.value)}` : `${p.getTypeLabel(o.itemType)}`, d = o.style.image;
+          if (!(d.url && typeof d.url == "object" && d.url.type === "data")) {
+            const g = o.style.image;
+            p.updateLegend(n, { label: c, value: g });
+          }
+        } else {
+          const c = u.isDefined(o.input) ? `${p.getTypeLabel(o.itemType)}.${o.input[1]} ${p.sanitizeValue(o.type, o.value)}` : `${p.getTypeLabel(o.itemType)}`, d = o.style[e];
+          p.updateLegend(n, { label: c, value: d });
+        }
+    }
+    return n;
+  }
+  /**
+   * Sanitize value for legend
+   */
+  static sanitizeValue(e, t) {
+    let i = "";
+    switch (e) {
+      case S.NO_VALUE:
+        return "is undefined";
+      case S.NAN:
+        return "is not an number";
+      case S.RANGE:
+        return Object.keys(t).forEach((n, s) => {
+          s > 0 && (i += " and "), i += `${n} ${t[n]}`;
+        }), i;
+    }
+    return typeof t == "object" ? `= ${JSON.stringify(t)}` : `= ${t}`;
+  }
+  /**
+   * Add items in legend for automatic coloring
+   */
+  static addLegendAutoColors(e, t, i) {
+    const n = t.style.color, s = n.input[1];
+    e.forEach((a) => {
+      const o = u.getIn(a, n.input);
+      if (Array.isArray(o))
+        o.forEach((l) => {
+          const c = n.input.includes("properties") ? `${p.getTypeLabel(t.itemType)}.${s} = ${l}` : `${p.getTypeLabel(l)}`, d = E.autoColor(l, n.ignoreCase);
+          p.updateLegend(i, { label: c, value: d });
+        });
+      else {
+        const l = n.input.includes("properties") ? `${p.getTypeLabel(t.itemType)}.${s} = ${o}` : `${p.getTypeLabel(o)}`, c = E.autoColor(o, n.ignoreCase);
+        p.updateLegend(i, { label: l, value: c });
+      }
+    });
+  }
+  /**
+   * Return the label of item type for a legend item
+   */
+  static getTypeLabel(e) {
+    return e === void 0 ? "All" : e === null ? "Others" : e;
+  }
+  /**
+   * Check if a legend item already exists and overwrite it / push it
+   */
+  static updateLegend(e, { label: t, value: i }) {
+    const n = e.map((s) => s.label).indexOf(t);
+    n < 0 ? e.push({ label: t, value: i }) : e[n] = { label: t, value: i };
+  }
+  /**
+   * return an array of StyleRule, containing only the desired style
+   */
+  static getBy(e, t) {
+    return t.filter((i) => {
+      switch (e) {
+        case "color":
+          return i.style.color !== void 0;
+        case "icon":
+          return "icon" in i.style && i.style.icon !== void 0;
+        case "image":
+          return "image" in i.style && i.style.image !== void 0;
+        case "shape":
+          return i.style.shape !== void 0;
+        case "size":
+          return "size" in i.style && i.style.size !== void 0;
+        case "width":
+          return "width" in i.style && i.style.width !== void 0;
+      }
+    }).map((i) => p.getRule(i, e));
+  }
+  /**
+   * From a RawStyle, generate a StyleRule of a specific style
+   */
+  static getRule(e, t) {
+    const i = u.clone(e);
+    return i.style = { [t]: i.style[t] }, new C(i);
+  }
+  /**
+   * Check for non unique index in styles rules and update them if exists
+   */
+  static sanitizeStylesIndex(e) {
+    const t = [], i = u.clone(e);
+    let n = Math.max(...e.node.map((s) => s.index), ...e.edge.map((s) => s.index)) + 1;
+    return i.node = i.node.map((s) => (t.includes(s.index) ? (s.index = n, n++) : t.push(s.index), s)), i.edge = i.edge.map((s) => (t.includes(s.index) ? (s.index = n, n++) : t.push(s.index), s)), i;
+  }
+}
+const Dt = {
+  text: {
+    style: "bold",
+    backgroundColor: "#fff",
+    minVisibleSize: 0
+  },
+  outerStroke: { width: 2 },
+  outline: !1
+}, Ot = {
+  text: {
+    style: "bold",
+    backgroundColor: "#fff",
+    minVisibleSize: 0
+  },
+  outline: !1
+}, mg = {
+  color: "#FFF",
+  width: 7,
+  scalingMethod: "scaled",
+  strokeWidth: 0,
+  hideNonAdjacentEdges: !1
+}, _g = {
+  color: "#FFF",
+  scalingMethod: "scaled",
+  width: 4
+}, Cg = "'roboto', sans-serif", Lt = "#000", ve = "#FFF", Pt = "#7f7f7f", It = 0.2;
+class Sg {
+  constructor(e, t) {
+    this._nodeAttributes = new U({}), this._edgeAttributes = new W({}), this._ogma = e, this._defaultConfiguration = t, this._nodeAttributes.setBaseUrl(t.baseUrl);
+  }
+  /**
+   * Set nodes default styles based on the configuration
+   */
+  setNodesDefaultStyles() {
+    this._ogma.styles.setHoveredNodeAttributes(Dt), this._ogma.styles.setSelectedNodeAttributes(Dt), this._nodeDefaultStylesRules = this._ogma.styles.addRule({
+      nodeAttributes: {
+        text: {
+          padding: 5,
+          minVisibleSize: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.minVisibleSize ? this._defaultConfiguration.node.text.minVisibleSize : 12,
+          maxLineLength: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.maxLineLength !== void 0 ? this._defaultConfiguration.node.text.maxLineLength : 30,
+          position: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.nodePosition !== void 0 ? this._defaultConfiguration.node.text.nodePosition : "bottom",
+          backgroundColor: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.backgroundColor !== void 0 ? this._defaultConfiguration.node.text.backgroundColor : void 0,
+          font: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.font !== void 0 ? this._defaultConfiguration.node.text.font : "'roboto', sans-serif",
+          color: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.color !== void 0 ? this._defaultConfiguration.node.text.color : "black",
+          size: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.size !== void 0 ? this._defaultConfiguration.node.text.size : 14,
+          margin: 5
+        },
+        radius: this.defaultNodeRadius(this._defaultConfiguration.node),
+        icon: {
+          minVisibleSize: 15
+        },
+        color: Pt,
+        shape: this._defaultConfiguration.node.shape !== void 0 ? this._defaultConfiguration.node.shape : "circle",
+        innerStroke: {
+          width: 3
+        },
+        outline: !1
+      }
+    });
+  }
+  /**
+   * Set edges default styles based on the configuration
+   */
+  setEdgesDefaultStyles() {
+    var e;
+    this._ogma.styles.setHoveredEdgeAttributes(Ot), this._ogma.styles.setSelectedEdgeAttributes(Ot), this._edgeDefaultStylesRules = this._ogma.styles.addRule({
+      edgeAttributes: {
+        text: {
+          minVisibleSize: this._defaultConfiguration.edge.text !== void 0 && this._defaultConfiguration.edge.text.minVisibleSize ? this._defaultConfiguration.edge.text.minVisibleSize : 3,
+          maxLineLength: this._defaultConfiguration.edge.text !== void 0 && this._defaultConfiguration.edge.text.maxLineLength !== void 0 ? this._defaultConfiguration.edge.text.maxLineLength : 30,
+          backgroundColor: this._defaultConfiguration.edge.text !== void 0 && this._defaultConfiguration.edge.text.backgroundColor !== void 0 ? this._defaultConfiguration.edge.text.backgroundColor : void 0,
+          font: this._defaultConfiguration.edge.text !== void 0 && this._defaultConfiguration.edge.text.font !== void 0 ? this._defaultConfiguration.edge.text.font : "'roboto', sans-serif",
+          color: ((e = this._defaultConfiguration.edge) == null ? void 0 : e.text) !== void 0 && this._defaultConfiguration.edge.text.color !== void 0 ? this._defaultConfiguration.edge.text.color : "black",
+          size: this._defaultConfiguration.edge.text !== void 0 && this._defaultConfiguration.edge.text.size !== void 0 ? this._defaultConfiguration.edge.text.size : 14
+        },
+        width: this.defaultEdgeWidth(this._defaultConfiguration.edge),
+        shape: this._defaultConfiguration.edge.shape !== void 0 ? this._defaultConfiguration.edge.shape : "arrow",
+        color: Pt
+      }
+    });
+  }
+  /**
+   * Set nodes default styles based on the configuration
+   */
+  setNodesDefaultHalo() {
+    this._nodeDefaultHaloRules = this._ogma.styles.addRule({
+      nodeSelector: (e) => e && !e.hasClass("filtered"),
+      nodeAttributes: {
+        halo: (e) => e !== void 0 && !e.hasClass("filtered") && (e.isSelected() || e.getAdjacentNodes({}).isSelected().includes(!0) || e.getAdjacentEdges().isSelected().includes(!0)) ? {
+          ...mg,
+          scalingMethod: this._ogma.geo.enabled() ? "fixed" : "scaled"
+        } : null
+      },
+      // recalculate the rule *only* when itself or adjacent
+      // elements change their selection status
+      nodeDependencies: {
+        self: {
+          selection: !0
+        },
+        adjacentNodes: {
+          selection: !0
+        },
+        adjacentEdges: {
+          selection: !0
+        }
+      }
+    });
+  }
+  /**
+   * Set edges default styles based on the configuration
+   */
+  setEdgesDefaultHalo() {
+    this._edgeDefaultHaloRules = this._ogma.styles.addRule({
+      edgeSelector: (e) => e && e.getSource() && e.getTarget() && !e.hasClass("filtered"),
+      edgeAttributes: {
+        halo: (e) => e && !e.hasClass("filtered") && (e.isSelected() || e.getSource().isSelected() || e.getTarget().isSelected()) ? {
+          ..._g,
+          scalingMethod: this._ogma.geo.enabled() ? "fixed" : "scaled"
+        } : null
+      },
+      // this rule will only be invoked when the selection status
+      // of the edge or it's extremities is changed
+      edgeDependencies: {
+        self: {
+          selection: !0
+        },
+        extremities: {
+          selection: !0
+        }
+      }
+    });
+  }
+  /**
+   * Return the default node radius set in configuration or 5
+   *
+   * @returns {number}
+   */
+  defaultNodeRadius(e) {
+    return this.defaultStylesHas(e, ["nodeRadius"]) ? e.nodeRadius : 5;
+  }
+  /**
+   * Return the default edge width set in configuration or 1
+   *
+   * @returns {number}
+   */
+  defaultEdgeWidth(e) {
+    return this.defaultStylesHas(e, ["edgeWidth"]) ? e.edgeWidth : 1;
+  }
+  /**
+   * Check if a style property exists in the default styles object
+   */
+  defaultStylesHas(e, t) {
+    return u.isDefined(e) ? u.getIn(e, t) !== void 0 : !1;
+  }
+  /**
+   * Set styles for the class "filtered"
+   */
+  setFilterClass() {
+    this._ogma.styles.createClass({
+      name: "filtered",
+      nodeAttributes: {
+        opacity: It,
+        layer: (e) => e.getMetaNode() !== null ? 1 : -1,
+        detectable: !1,
+        badges: {
+          topRight: {
+            text: null
+          },
+          bottomRight: {
+            text: null
+          }
+        },
+        text: null,
+        color: "rgb(240, 240, 240)",
+        innerStroke: {
+          width: 1,
+          color: F,
+          minVisibleSize: 1
+        },
+        shape: "circle",
+        image: null,
+        icon: null,
+        radius: "50%"
+      },
+      edgeAttributes: {
+        opacity: It,
+        layer: (e) => {
+          const t = e.getExtremities().getMetaNode().some((i) => i !== null);
+          return !e.isVirtual() && t ? 1 : -1;
+        },
+        detectable: !1,
+        text: null,
+        color: F,
+        shape: "line",
+        width: 0.2
+      }
+    });
+  }
+  /**
+   * Set the class for exported nodes and edges
+   */
+  setExportClass(e) {
+    this._exportClass ? this._exportClass.update({
+      nodeAttributes: {
+        text: {
+          maxLineLength: e ? 30 : 0
+        },
+        halo: null
+      }
+    }) : this._exportClass = this._ogma.styles.createClass({
+      name: "exported",
+      nodeAttributes: {
+        text: {
+          minVisibleSize: 0,
+          size: 12,
+          maxLineLength: e ? 30 : 0
+        },
+        halo: null
+      },
+      edgeAttributes: {
+        text: {
+          minVisibleSize: 0,
+          size: 12
+        },
+        halo: null
+      }
+    });
+  }
+  /**
+   * Set the rule to display badges
+   */
+  setBadgeRule() {
+    this._ogma.styles.createClass({
+      name: "degreeIndicator",
+      nodeAttributes: {
+        badges: {
+          topRight: (e) => {
+            if (e !== void 0) {
+              const t = u.getHiddenNeighbors(e.toList()), i = u.formatNumber(t);
+              if (t > 0) {
+                const n = Array.isArray(e.getAttribute("color")) ? e.getAttribute("color")[0] : e.getAttribute("color"), s = ne.isBright(n) ? Lt : ve, a = e.getData(["statistics", "supernode"]);
+                let o = null;
+                return +i != 0 && (o = a ? i + "+" : i), {
+                  color: "inherit",
+                  minVisibleSize: 20,
+                  stroke: {
+                    width: 0,
+                    color: null
+                  },
+                  text: {
+                    font: this._defaultConfiguration.node.text !== void 0 && this._defaultConfiguration.node.text.font !== void 0 ? this._defaultConfiguration.node.text.font : Cg,
+                    scale: 0.4,
+                    color: s,
+                    content: o
+                  }
+                };
+              }
+            }
+          }
+        }
+      }
+    }), this._ogma.styles.createClass({
+      name: "pinnedIndicator",
+      nodeAttributes: {
+        badges: {
+          bottomRight: (e) => {
+            if (e !== void 0 && !e.getAttribute("layoutable"))
+              return {
+                color: this._findPinBadgeBackgroundColor(e),
+                minVisibleSize: 20,
+                scale: this._findPinBadgeScale(e),
+                stroke: {
+                  width: 0,
+                  color: null
+                },
+                text: {
+                  font: "FontAwesome",
+                  scale: 0.4,
+                  color: this._findPinBadgeTextColor(e),
+                  content: e.getAttribute("layoutable") ? null : ""
+                }
+              };
+          }
+        }
+      },
+      nodeDependencies: {
+        self: { attributes: ["layoutable"] }
+      }
+    }), this._ogma.events.on("addNodes", (e) => e.nodes.addClass("degreeIndicator")), this._ogma.events.on("addNodes", (e) => e.nodes.addClass("pinnedIndicator"));
+  }
+  /**
+   * Delete the rule to display badges
+   */
+  deleteBadgeRule() {
+    this._ogma.getNodes().removeClasses(["degreeIndicator", "pinnedIndicator"], 0);
+  }
+  /**
+   * set text overlap to true or false
+   *
+   * @param {boolean} overlap
+   */
+  toggleTextOverlap(e) {
+    this._ogma.setOptions({ texts: { preventOverlap: e } });
+  }
+  /**
+   * refresh nodes and edge rules
+   *
+   */
+  refreshRules() {
+    this._nodeDefaultStylesRules.refresh(), this._edgeDefaultStylesRules.refresh();
+  }
+  /**
+   * Create / refresh an ogma rule for node colors
+   */
+  refreshNodeColors(e) {
+    u.isDefined(this._ogmaNodeColor) ? (this._nodeAttributes.refresh({ color: e }), this._ogmaNodeColor.refresh()) : (this._nodeAttributes.refresh({ color: e }), this._ogmaNodeColor = this._ogma.styles.addRule({
+      nodeAttributes: {
+        color: (t) => {
+          if (t !== void 0)
+            return this._nodeAttributes.color(t.getData());
+        }
+      },
+      nodeDependencies: { self: { data: !0 } }
+    }));
+  }
+  /**
+   * Return an array of StyleRules with only the style that need to be applied
+   */
+  getStyleRule(e, t) {
+    return new p(e)[t];
+  }
+  initNodeColors(e) {
+    const t = this.getStyleRule(
+      e,
+      D.COLOR
+    );
+    this.refreshNodeColors(t);
+  }
+  initNodesIcons(e) {
+    const t = this.getStyleRule(
+      e,
+      D.ICON
+    );
+    this.refreshNodeIcons(t);
+  }
+  initNodesSizes(e) {
+    const t = this.getStyleRule(e, D.SIZE);
+    this.refreshNodeSize(t);
+  }
+  initNodesShapes(e) {
+    const t = this.getStyleRule(
+      e,
+      D.SHAPE
+    );
+    this.refreshNodeShape(t);
+  }
+  initEdgesWidth(e) {
+    const t = this.getStyleRule(
+      e,
+      D.WIDTH
+    );
+    this.refreshEdgeWidth(t);
+  }
+  initEdgesShape(e) {
+    const t = this.getStyleRule(
+      e,
+      D.SHAPE
+    );
+    this.refreshEdgeShape(t);
+  }
+  initEdgesColor(e) {
+    const t = this.getStyleRule(
+      e,
+      D.COLOR
+    );
+    this.refreshEdgeColors(t);
+  }
+  /**
+   * Create / refresh an ogma rule for node icons
+   *
+   * @param {Array<any>} iconStyleRules
+   */
+  refreshNodeIcons(e) {
+    u.isDefined(this._ogmaNodeIcon) ? (this._nodeAttributes.refresh({ icon: e }), this._ogmaNodeIcon.refresh()) : (this._nodeAttributes.refresh({ icon: e }), this._ogmaNodeIcon = this._ogma.styles.addRule({
+      nodeAttributes: {
+        icon: (t) => {
+          if (t !== void 0)
+            return this._nodeAttributes.icon(t.getData()).icon;
+        },
+        image: (t) => {
+          if (t !== void 0 && !t.isVirtual())
+            return this._nodeAttributes.icon(t.getData()).image;
+        }
+      },
+      nodeDependencies: { self: { data: !0 } }
+    }));
+  }
+  /**
+   * Create / refresh an ogma rule for node sizes
+   *
+   * @param {Array<any>} sizeStyleRules
+   */
+  refreshNodeSize(e) {
+    u.isDefined(this._ogmaNodeSize) ? (this._nodeAttributes.refresh({ size: e }), this._ogmaNodeSize.refresh()) : (this._nodeAttributes.refresh({ size: e }), this._ogmaNodeSize = this._ogma.styles.addRule({
+      nodeAttributes: {
+        radius: (t) => {
+          if (t !== void 0)
+            return this._nodeAttributes.size(t.getData());
+        }
+      },
+      nodeDependencies: { self: { data: !0 } }
+    }));
+  }
+  /**
+   * Create / refresh an ogma rule for node images
+   *
+   * @param {Array<any>} shapeStyleRules
+   */
+  refreshNodeShape(e) {
+    u.isDefined(this._ogmaNodeShape) ? (this._nodeAttributes.refresh({ shape: e }), this._ogmaNodeShape.refresh()) : (this._nodeAttributes.refresh({ shape: e }), this._ogmaNodeShape = this._ogma.styles.addRule({
+      nodeAttributes: {
+        shape: (t) => {
+          if (t !== void 0)
+            return this._nodeAttributes.shape(t.getData());
+        }
+      },
+      nodeSelector: (t) => t !== void 0 && !t.isVirtual(),
+      nodeDependencies: { self: { data: !0 } }
+    }));
+  }
+  /**
+   * Create / refresh an ogma rule for edge colors
+   */
+  refreshEdgeColors(e) {
+    u.isDefined(this._ogmaEdgeColor) ? (this._edgeAttributes.refresh({ color: e }), this._ogmaEdgeColor.refresh()) : (this._edgeAttributes.refresh({ color: e }), this._ogmaEdgeColor = this._ogma.styles.addRule({
+      edgeAttributes: {
+        color: (t) => {
+          if (t !== void 0)
+            return this._edgeAttributes.color(t.getData());
+        }
+      },
+      edgeDependencies: { self: { data: !0 } }
+    }));
+  }
+  /**
+   * Create / refresh an ogma rule for edge width
+   *
+   * @param {Array<LKStyleRule>} widthStyleRules
+   */
+  refreshEdgeWidth(e) {
+    u.isDefined(this._ogmaEdgeWidth) ? (this._edgeAttributes.refresh({ width: e }), this._ogmaEdgeWidth.refresh()) : (this._edgeAttributes.refresh({ width: e }), this._ogmaEdgeWidth = this._ogma.styles.addRule({
+      edgeAttributes: {
+        width: (t) => {
+          if (t !== void 0)
+            return this._edgeAttributes.width(t.getData());
+        }
+      },
+      edgeDependencies: {
+        self: { data: !0 }
+      }
+    }));
+  }
+  /**
+   * Create / refresh an ogma rule for edge width
+   *
+   * @param {Array<LKStyleRule>} shapeStyleRules
+   */
+  refreshEdgeShape(e) {
+    u.isDefined(this._ogmaEdgeShape) ? (this._edgeAttributes.refresh({ shape: e }), this._ogmaEdgeShape.refresh()) : (this._edgeAttributes.refresh({ shape: e }), this._ogmaEdgeShape = this._ogma.styles.addRule({
+      edgeAttributes: {
+        shape: (t) => {
+          if (t !== void 0)
+            return this._edgeAttributes.shape(t.getData());
+        }
+      },
+      edgeDependencies: { self: { data: !0 } }
+    }));
+  }
+  /**
+   * Get node radius
+   * This is a workaround for an ogma issue where the radius of virtual nodes is always set to 5
+   * TODO: check if this is still needed after ogma release the new improvement for transformation v5.X
+   */
+  _getNodeRadius(e) {
+    var t;
+    if (e.isVirtual()) {
+      const { width: i, height: n } = (t = e.getSubNodes()) == null ? void 0 : t.getBoundingBox();
+      return Math.max(i, n);
+    } else
+      return e.getAttribute("radius");
+  }
+  /**
+   * Calculate the scale of the pin badge related to the node radius
+   * This is useful when dealing wih huge nodes, and we don't want the badge to be big
+   * If the node is small enough, the badge will be 0.46 of the node radius
+   * Else it will be 5 / radius
+   */
+  _findPinBadgeScale(e) {
+    return this._getNodeRadius(e) * 0.46 > 5 ? 0.17 : 0.46;
+  }
+  /**
+   * Find the color of the pin badge text
+   */
+  _findPinBadgeTextColor(e) {
+    if (e.isVirtual())
+      return ve;
+    const t = Array.isArray(e.getAttribute("color")) ? e.getAttribute("color")[0] : e.getAttribute("color");
+    return ne.isBright(t) ? Lt : ve;
+  }
+  /**
+   * Find the color of the pin badge background
+   */
+  _findPinBadgeBackgroundColor(e) {
+    return e.isVirtual() ? F : "inherit";
+  }
+}
+class Ag {
+  constructor(e, t, i) {
+    this._nodeMaxTextLength = t, this._edgeMaxTextLength = i, this._captionSchema = { node: {}, edge: {} }, this._graphSchema = { node: [], edge: [] }, this._ogma = e;
+  }
+  set graphSchema(e) {
+    this._graphSchema = e;
+  }
+  /**
+   * Refresh the schema
+   */
+  refreshSchema(e) {
+    this._captionSchema = e;
+  }
+  /**
+   * Refresh visualization captions rules
+   */
+  async initVizCaptions(e) {
+    this._ogma.LKCaptions.nodesCaptionsRule ? (this._ogma.LKCaptions.refreshSchema(e), await this._ogma.LKCaptions.updateNodeCaptions()) : this._ogma.LKCaptions.updateNodeCaptions(e.node), this._ogma.LKCaptions.edgesCaptionsRule ? (this._ogma.LKCaptions.refreshSchema(e), await this._ogma.LKCaptions.updateEdgeCaptions()) : this._ogma.LKCaptions.updateEdgeCaptions(e.edge);
+  }
+  /**
+   * Create or update nodeCaptionRule
+   */
+  updateNodeCaptions(e) {
+    if (e && (this._captionSchema.node = e), !u.isDefined(this.nodesCaptionsRule))
+      this.nodesCaptionsRule = this._ogma.styles.addRule({
+        nodeAttributes: {
+          text: {
+            content: (t) => {
+              if (t === void 0)
+                return "";
+              const i = w.getText(
+                t.getData(),
+                this._captionSchema.node,
+                this._graphSchema.node
+              );
+              return u.isDefined(this._nodeMaxTextLength) ? u.truncate(i, "middle", this._nodeMaxTextLength) : i;
+            }
+          }
+        },
+        // We ignore virtual nodes as they have their proper caption
+        nodeSelector: (t) => !t.isVirtual(),
+        nodeDependencies: { self: { data: !0 } }
+      });
+    else
+      return this.nodesCaptionsRule.refresh();
+  }
+  /**
+   * Create or update edgeCaptionRule
+   */
+  updateEdgeCaptions(e) {
+    if (e && (this._captionSchema.edge = e), !u.isDefined(this.edgesCaptionsRule))
+      this.edgesCaptionsRule = this._ogma.styles.addRule({
+        edgeAttributes: {
+          text: {
+            content: (t) => {
+              if (t === void 0 || t.getData() === void 0)
+                return "";
+              const i = w.getText(
+                t.getData(),
+                this._captionSchema.edge,
+                this._graphSchema.edge
+              );
+              return u.isDefined(this._edgeMaxTextLength) ? u.truncate(i, "middle", this._edgeMaxTextLength) : i;
+            }
+          }
+        },
+        edgeSelector: (t) => !t.isVirtual(),
+        // ogma will trigger the rendering if data change or the shape change (to trigger the rendering when edges are grouped)
+        edgeDependencies: { self: { data: !0, attributes: ["shape.style"] } }
+      });
+    else
+      return this.edgesCaptionsRule.refresh();
+  }
+}
+function I(r) {
+  return typeof r == "function";
+}
+function xg(r) {
+  return I(r == null ? void 0 : r.lift);
+}
+function cr(r) {
+  return function(e) {
+    if (xg(e))
+      return e.lift(function(t) {
+        try {
+          return r(t, this);
+        } catch (i) {
+          this.error(i);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+var Te = function(r, e) {
+  return Te = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, i) {
+    t.__proto__ = i;
+  } || function(t, i) {
+    for (var n in i) Object.prototype.hasOwnProperty.call(i, n) && (t[n] = i[n]);
+  }, Te(r, e);
+};
+function Ve(r, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Class extends value " + String(e) + " is not a constructor or null");
+  Te(r, e);
+  function t() {
+    this.constructor = r;
+  }
+  r.prototype = e === null ? Object.create(e) : (t.prototype = e.prototype, new t());
+}
+function Mt(r) {
+  var e = typeof Symbol == "function" && Symbol.iterator, t = e && r[e], i = 0;
+  if (t) return t.call(r);
+  if (r && typeof r.length == "number") return {
+    next: function() {
+      return r && i >= r.length && (r = void 0), { value: r && r[i++], done: !r };
+    }
+  };
+  throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function we(r, e) {
+  var t = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!t) return r;
+  var i = t.call(r), n, s = [], a;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(n = i.next()).done; ) s.push(n.value);
+  } catch (o) {
+    a = { error: o };
+  } finally {
+    try {
+      n && !n.done && (t = i.return) && t.call(i);
+    } finally {
+      if (a) throw a.error;
+    }
+  }
+  return s;
+}
+function Ne(r, e, t) {
+  if (t || arguments.length === 2) for (var i = 0, n = e.length, s; i < n; i++)
+    (s || !(i in e)) && (s || (s = Array.prototype.slice.call(e, 0, i)), s[i] = e[i]);
+  return r.concat(s || Array.prototype.slice.call(e));
+}
+function $g(r) {
+  var e = function(i) {
+    Error.call(i), i.stack = new Error().stack;
+  }, t = r(e);
+  return t.prototype = Object.create(Error.prototype), t.prototype.constructor = t, t;
+}
+var me = $g(function(r) {
+  return function(t) {
+    r(this), this.message = t ? t.length + ` errors occurred during unsubscription:
+` + t.map(function(i, n) {
+      return n + 1 + ") " + i.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = t;
+  };
+});
+function Rt(r, e) {
+  if (r) {
+    var t = r.indexOf(e);
+    0 <= t && r.splice(t, 1);
+  }
+}
+var Ke = function() {
+  function r(e) {
+    this.initialTeardown = e, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return r.prototype.unsubscribe = function() {
+    var e, t, i, n, s;
+    if (!this.closed) {
+      this.closed = !0;
+      var a = this._parentage;
+      if (a)
+        if (this._parentage = null, Array.isArray(a))
+          try {
+            for (var o = Mt(a), l = o.next(); !l.done; l = o.next()) {
+              var c = l.value;
+              c.remove(this);
+            }
+          } catch (f) {
+            e = { error: f };
+          } finally {
+            try {
+              l && !l.done && (t = o.return) && t.call(o);
+            } finally {
+              if (e) throw e.error;
+            }
+          }
+        else
+          a.remove(this);
+      var d = this.initialTeardown;
+      if (I(d))
+        try {
+          d();
+        } catch (f) {
+          s = f instanceof me ? f.errors : [f];
+        }
+      var g = this._finalizers;
+      if (g) {
+        this._finalizers = null;
+        try {
+          for (var h = Mt(g), y = h.next(); !y.done; y = h.next()) {
+            var _ = y.value;
+            try {
+              Bt(_);
+            } catch (f) {
+              s = s ?? [], f instanceof me ? s = Ne(Ne([], we(s)), we(f.errors)) : s.push(f);
+            }
+          }
+        } catch (f) {
+          i = { error: f };
+        } finally {
+          try {
+            y && !y.done && (n = h.return) && n.call(h);
+          } finally {
+            if (i) throw i.error;
+          }
+        }
+      }
+      if (s)
+        throw new me(s);
+    }
+  }, r.prototype.add = function(e) {
+    var t;
+    if (e && e !== this)
+      if (this.closed)
+        Bt(e);
+      else {
+        if (e instanceof r) {
+          if (e.closed || e._hasParent(this))
+            return;
+          e._addParent(this);
+        }
+        (this._finalizers = (t = this._finalizers) !== null && t !== void 0 ? t : []).push(e);
+      }
+  }, r.prototype._hasParent = function(e) {
+    var t = this._parentage;
+    return t === e || Array.isArray(t) && t.includes(e);
+  }, r.prototype._addParent = function(e) {
+    var t = this._parentage;
+    this._parentage = Array.isArray(t) ? (t.push(e), t) : t ? [t, e] : e;
+  }, r.prototype._removeParent = function(e) {
+    var t = this._parentage;
+    t === e ? this._parentage = null : Array.isArray(t) && Rt(t, e);
+  }, r.prototype.remove = function(e) {
+    var t = this._finalizers;
+    t && Rt(t, e), e instanceof r && e._removeParent(this);
+  }, r.EMPTY = function() {
+    var e = new r();
+    return e.closed = !0, e;
+  }(), r;
+}();
+Ke.EMPTY;
+function Eg(r) {
+  return r instanceof Ke || r && "closed" in r && I(r.remove) && I(r.add) && I(r.unsubscribe);
+}
+function Bt(r) {
+  I(r) ? r() : r.unsubscribe();
+}
+var Fg = {
+  useDeprecatedNextContext: !1
+}, Tg = {
+  setTimeout: function(r, e) {
+    for (var t = [], i = 2; i < arguments.length; i++)
+      t[i - 2] = arguments[i];
+    return setTimeout.apply(void 0, Ne([r, e], we(t)));
+  },
+  clearTimeout: function(r) {
+    return clearTimeout(r);
+  },
+  delegate: void 0
+};
+function wg(r) {
+  Tg.setTimeout(function() {
+    throw r;
+  });
+}
+function zt() {
+}
+var dr = function(r) {
+  Ve(e, r);
+  function e(t) {
+    var i = r.call(this) || this;
+    return i.isStopped = !1, t ? (i.destination = t, Eg(t) && t.add(i)) : i.destination = Pg, i;
+  }
+  return e.create = function(t, i, n) {
+    return new Og(t, i, n);
+  }, e.prototype.next = function(t) {
+    this.isStopped || this._next(t);
+  }, e.prototype.error = function(t) {
+    this.isStopped || (this.isStopped = !0, this._error(t));
+  }, e.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, e.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, r.prototype.unsubscribe.call(this), this.destination = null);
+  }, e.prototype._next = function(t) {
+    this.destination.next(t);
+  }, e.prototype._error = function(t) {
+    try {
+      this.destination.error(t);
+    } finally {
+      this.unsubscribe();
+    }
+  }, e.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, e;
+}(Ke), Ng = Function.prototype.bind;
+function _e(r, e) {
+  return Ng.call(r, e);
+}
+var Dg = function() {
+  function r(e) {
+    this.partialObserver = e;
+  }
+  return r.prototype.next = function(e) {
+    var t = this.partialObserver;
+    if (t.next)
+      try {
+        t.next(e);
+      } catch (i) {
+        ee(i);
+      }
+  }, r.prototype.error = function(e) {
+    var t = this.partialObserver;
+    if (t.error)
+      try {
+        t.error(e);
+      } catch (i) {
+        ee(i);
+      }
+    else
+      ee(e);
+  }, r.prototype.complete = function() {
+    var e = this.partialObserver;
+    if (e.complete)
+      try {
+        e.complete();
+      } catch (t) {
+        ee(t);
+      }
+  }, r;
+}(), Og = function(r) {
+  Ve(e, r);
+  function e(t, i, n) {
+    var s = r.call(this) || this, a;
+    if (I(t) || !t)
+      a = {
+        next: t ?? void 0,
+        error: i ?? void 0,
+        complete: n ?? void 0
+      };
+    else {
+      var o;
+      s && Fg.useDeprecatedNextContext ? (o = Object.create(t), o.unsubscribe = function() {
+        return s.unsubscribe();
+      }, a = {
+        next: t.next && _e(t.next, o),
+        error: t.error && _e(t.error, o),
+        complete: t.complete && _e(t.complete, o)
+      }) : a = t;
+    }
+    return s.destination = new Dg(a), s;
+  }
+  return e;
+}(dr);
+function ee(r) {
+  wg(r);
+}
+function Lg(r) {
+  throw r;
+}
+var Pg = {
+  closed: !0,
+  next: zt,
+  error: Lg,
+  complete: zt
+};
+function Ig(r) {
+  return r;
+}
+function gr(r, e, t, i, n) {
+  return new Mg(r, e, t, i, n);
+}
+var Mg = function(r) {
+  Ve(e, r);
+  function e(t, i, n, s, a, o) {
+    var l = r.call(this, t) || this;
+    return l.onFinalize = a, l.shouldUnsubscribe = o, l._next = i ? function(c) {
+      try {
+        i(c);
+      } catch (d) {
+        t.error(d);
+      }
+    } : r.prototype._next, l._error = s ? function(c) {
+      try {
+        s(c);
+      } catch (d) {
+        t.error(d);
+      } finally {
+        this.unsubscribe();
+      }
+    } : r.prototype._error, l._complete = n ? function() {
+      try {
+        n();
+      } catch (c) {
+        t.error(c);
+      } finally {
+        this.unsubscribe();
+      }
+    } : r.prototype._complete, l;
+  }
+  return e.prototype.unsubscribe = function() {
+    var t;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var i = this.closed;
+      r.prototype.unsubscribe.call(this), !i && ((t = this.onFinalize) === null || t === void 0 || t.call(this));
+    }
+  }, e;
+}(dr);
+function Rg(r, e) {
+  return cr(function(t, i) {
+    var n = 0;
+    t.subscribe(gr(i, function(s) {
+      i.next(r.call(e, s, n++));
+    }));
+  });
+}
+function Bg(r, e) {
+  return e === void 0 && (e = Ig), r = r ?? zg, cr(function(t, i) {
+    var n, s = !0;
+    t.subscribe(gr(i, function(a) {
+      var o = e(a);
+      (s || !r(n, o)) && (s = !1, n = o, i.next(a));
+    }));
+  });
+}
+function zg(r, e) {
+  return r === e;
+}
+class Gg extends mr {
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * Modify Ogma state based on a method
+   */
+  dispatch(e) {
+    this.next(e(this.value));
+  }
+  /**
+   * Return a piece of state
+   */
+  selectStore(e) {
+    return this.pipe(
+      Rg(e),
+      Bg((t, i) => u.isEqual(t, i))
+    );
+  }
+  /**
+   * Clear the state of Ogma
+   */
+  clear() {
+    this.next({
+      selection: new hr(),
+      items: { node: [], edge: [] },
+      changes: void 0,
+      animation: !1
+    });
+  }
+}
+class Ug {
+  constructor(e) {
+    this._store = new Gg({
+      selection: new hr(),
+      items: { node: [], edge: [] },
+      changes: void 0,
+      animation: !1
+    }), this._ogma = e, this.listenToSelectionEvents();
+  }
+  get store() {
+    return this._store;
+  }
+  /**
+   * Listen to ogma events and update the state
+   */
+  listenToSelectionEvents() {
+    let e = Date.now(), t = !1;
+    this._ogma.events.on("animate", (i) => {
+      if (i.updatesPositions === !1)
+        return;
+      t || (t = !0, this._store.dispatch((a) => ({ ...a, animation: !0 })));
+      const n = Math.max(e, Date.now() + i.duration);
+      if (n === e)
+        return;
+      e = n;
+      const s = e - Date.now() + 16;
+      clearTimeout(this._animationThrottle), this._animationThrottle = setTimeout(() => {
+        t = !1, this._store.dispatch((a) => ({ ...a, animation: !1 }));
+      }, s);
+    }), this._ogma.events.on("dragStart", () => {
+      this._store.dispatch((i) => ({ ...i, animation: !0 }));
+    }), this._ogma.events.on("dragEnd", () => {
+      this._store.dispatch((i) => ({ ...i, animation: !1 }));
+    }), this._ogma.events.on("addNodes", () => {
+      this._store.dispatch(this.storeItems.bind(this));
+    }), this._ogma.events.on("removeNodes", () => {
+      this._store.dispatch(this.storeItems.bind(this));
+    }), this._ogma.events.on("addEdges", () => {
+      this._store.dispatch(this.storeItems.bind(this));
+    }), this._ogma.events.on("removeEdges", () => {
+      this._store.dispatch(this.storeItems.bind(this));
+    }), this._ogma.events.on("nodesSelected", () => {
+      this._store.dispatch(this.storeNodeSelection.bind(this));
+    }), this._ogma.events.on("edgesSelected", () => {
+      this._store.dispatch(this.storeEdgeSelection.bind(this));
+    }), this._ogma.events.on("nodesUnselected", () => {
+      this._store.dispatch(this.storeNodeSelection.bind(this));
+    }), this._ogma.events.on("edgesUnselected", () => {
+      this._store.dispatch(this.storeEdgeSelection.bind(this));
+    }), this._ogma.events.on("updateNodeData", (i) => {
+      i !== void 0 && i.changes.forEach((n) => {
+        this._store.dispatch((s) => ({
+          ...s,
+          changes: {
+            entityType: "node",
+            input: n.property,
+            value: n.newValues[0]
+          }
+        }));
+      });
+    }), this._ogma.events.on("updateEdgeData", (i) => {
+      i !== void 0 && i.changes.forEach((n) => {
+        this._store.dispatch((s) => ({
+          ...s,
+          changes: {
+            entityType: "edge",
+            input: n.property,
+            value: n.newValues[0]
+          }
+        }));
+      });
+    });
+  }
+  /**
+   * Store new items in state
+   */
+  storeItems(e) {
+    return {
+      ...e,
+      items: {
+        node: this._ogma.getNodes().getId(),
+        edge: this._ogma.getEdges().getId()
+      }
+    };
+  }
+  /**
+   * Store new node selection in state
+   */
+  storeNodeSelection(e) {
+    return {
+      ...e,
+      selection: this._ogma.getSelectedNodes()
+    };
+  }
+  /**
+   * store new edge selection in state
+   */
+  storeEdgeSelection(e) {
+    return {
+      ...e,
+      selection: this._ogma.getSelectedEdges()
+    };
+  }
+}
+class hr {
+  constructor() {
+    this.size = 0, this.isNode = !0;
+  }
+}
+const jg = 750, kg = {
+  steps: 40,
+  alignSiblings: !0,
+  charge: 5,
+  theta: 0.34,
+  duration: jg
+};
+class Xg extends vr {
+  constructor(e, t) {
+    super(e), this._configuration = e, Object.setPrototypeOf(this, new.target.prototype), this.initOgmaLinkuriousParser(!0, t);
+  }
+  /**
+   * Initialize the Ogma instance with the configuration and the base url
+   * @param init used to know if the instance is initialized for the first time (used in setConfigOgma)
+   * @param baseUrl base url used for relative image urls
+   * @private
+   */
+  initOgmaLinkuriousParser(e, t) {
+    this.nodeCategoriesWatcher = this.schema.watchNodeNonObjectProperty({
+      path: "categories",
+      unwindArrays: !0,
+      filter: "all"
+    }), this.edgeTypeWatcher = this.schema.watchEdgeNonObjectProperty({
+      path: "type",
+      filter: "all"
+    }), this.setOptions({
+      interactions: {
+        zoom: {
+          maxValue: (i) => 128 / i.smallestNodeSize
+        },
+        selection: {
+          enabled: !1
+        }
+      }
+    }), this._reactive === void 0 ? (this._reactive = new Ug(this), this.store = this._reactive.store) : this._reactive.listenToSelectionEvents(), this.initSelection(), this.setConfigOgma(this._configuration, e, t), this.LKTransformation = new qg(this), this.LkNodeGroupingTransformation = new Vg(this), this.LKStyles.setNodesDefaultHalo(), this.LKStyles.setEdgesDefaultHalo(), this.LKStyles.setBadgeRule(), this.LKStyles.setFilterClass();
+  }
+  /**
+   * Initialize selection behavior
+   */
+  initSelection() {
+    this.events.onClick((e) => {
+      if (e !== void 0 && e.button === "left")
+        if (e.target !== null) {
+          const t = navigator.platform === "MacIntel" ? "cmd" : "ctrl";
+          this.keyboard.isKeyPressed(t) ? (e.target.isNode && this.getSelectedEdges().size > 0 && this.getSelectedEdges().setSelected(!1), !e.target.isNode && this.getSelectedNodes().size > 0 && this.getSelectedNodes().setSelected(!1), e.target.isSelected() ? e.target.setSelected(!1) : e.target.setSelected(!0)) : (this.getSelectedNodes().setSelected(!1), this.getSelectedEdges().setSelected(!1), e.target.setSelected(!0));
+        } else
+          this.getSelectedNodes().setSelected(!1), this.getSelectedEdges().setSelected(!1);
+    });
+  }
+  setStyles(e, t) {
+    var i, n, s, a;
+    this.LKStyles = new Sg(this, {
+      node: ((n = (i = e == null ? void 0 : e.options) == null ? void 0 : i.styles) == null ? void 0 : n.node) || {},
+      edge: ((a = (s = e == null ? void 0 : e.options) == null ? void 0 : s.styles) == null ? void 0 : a.edge) || {},
+      baseUrl: t
+    }), this.LKStyles.setNodesDefaultStyles(), this.LKStyles.setEdgesDefaultStyles();
+  }
+  setCaptions(e) {
+    var n, s, a, o, l, c, d, g;
+    const t = (o = (a = (s = (n = e == null ? void 0 : e.options) == null ? void 0 : n.styles) == null ? void 0 : s.node) == null ? void 0 : a.text) == null ? void 0 : o.maxTextLength, i = (g = (d = (c = (l = e == null ? void 0 : e.options) == null ? void 0 : l.styles) == null ? void 0 : c.edge) == null ? void 0 : d.text) == null ? void 0 : g.maxTextLength;
+    this.LKCaptions = new Ag(this, t, i);
+  }
+  /**
+   * Returns Ogma Layout parameters according to visualization layout settings
+   * */
+  getForceLayoutParams(e, t = 0) {
+    let i = 300 - 0.052 * this.getNodes().size;
+    return i < 40 && (i = 40), {
+      steps: e === yr.FAST ? i : 300,
+      alignSiblings: this.getNodes().size > 3,
+      duration: t,
+      charge: 20,
+      gravity: 0.08,
+      theta: this.getNodes().size > 100 ? 0.8 : 0.34
+    };
+  }
+  getRadialLayoutParams(e, t = 0) {
+    return {
+      centralNode: e,
+      radiusDelta: 1,
+      nodeGap: 10,
+      repulsion: this.getNodes().size > 80 ? 1 : 6,
+      duration: t
+    };
+  }
+  getHierarchicalLayoutParams(e, t, i = 0) {
+    return {
+      direction: e,
+      roots: [t],
+      duration: i
+    };
+  }
+  /**
+   * Initialize graph.
+   * add nodes and edges to the viz and init the selection.
+   */
+  async init(e) {
+    this.clearGraph();
+    let t, i = [];
+    const n = e.nodes.map((a) => (a.attributes.selected && (t = P.NODE, i.push(a.id)), delete a.attributes.selected, a)), s = e.edges.map((a) => (a.attributes !== void 0 && (a.attributes.selected && ((t === void 0 || t === P.NODE) && (t = P.EDGE, i = []), i.push(a.id)), delete a.attributes.selected), a));
+    await this.addGraphAfterValidation({
+      nodes: n,
+      edges: s
+    }), t === P.NODE ? this.getNodes(i).setSelected(!0) : t === P.EDGE && this.getEdges(i).setSelected(!0);
+  }
+  async initVisualization(e) {
+    await this.init(e);
+    const t = p.sanitizeStylesIndex(e.design.styles);
+    this.LKStyles.initNodeColors(t.node), this.LKStyles.initNodesIcons(t.node), this.LKStyles.initNodesSizes(t.node), this.LKStyles.initNodesShapes(t.node), this.LKStyles.initEdgesWidth(t.edge), this.LKStyles.initEdgesShape(t.edge), this.LKStyles.initEdgesColor(t.edge), await this.LKCaptions.initVizCaptions({
+      node: e.nodeFields.captions || {},
+      edge: e.edgeFields.captions || {}
+    }), this.LKTransformation.groupedEdges = e.edgeGrouping, await this.LKTransformation.initTransformation(), this.LKTransformation.initEdgeGroupingStyle();
+  }
+  /**
+   * Adding nodes then adding edges to the graph
+   */
+  async addGraphAfterValidation(e) {
+    const t = await this.addNodes(e.nodes), i = await this.addEdges(e.edges);
+    return {
+      nodes: t,
+      edges: i
+    };
+  }
+  /**
+   * Adding edges to the graph after filtering disconnected ones
+   */
+  addEdges(e, t) {
+    return super.addEdges(e, { ...t, ignoreInvalid: !0 });
+  }
+  /**
+   * Return the list of non filtered nodes
+   */
+  getNonFilteredNodes(e) {
+    return u.isDefined(e) ? this.getNodes(e).filter((t) => !t.hasClass("filtered")) : (
+      // take only none virtual nodes
+      this.getNodes("raw").filter((t) => !t.hasClass("filtered"))
+    );
+  }
+  /**
+   * Return the list of filtered nodes
+   * @param items items to check if they are filtered
+   * @param filter type of nodes to check if they are filtered ( nodes that are visible, raw nodes (none virtual) or all nodes)
+   */
+  getFilteredNodes(e, t = "raw") {
+    return u.isDefined(e) ? this.getNodes(e).filter((i) => i.hasClass("filtered")) : this.getNodes(t).filter((i) => i.hasClass("filtered"));
+  }
+  /**
+   * Return the list of non filtered edges
+   */
+  getNonFilteredEdges(e) {
+    return u.isDefined(e) ? this.getEdges(e).filter((t) => !t.hasClass("filtered")) : this.getEdges("raw").filter((t) => !t.hasClass("filtered"));
+  }
+  /**
+   * Return the list of filtered edges
+   */
+  getFilteredEdges(e, t = "raw") {
+    return u.isDefined(e) ? this.getEdges(e).filter((i) => i.hasClass("filtered")) : this.getEdges(t).filter((i) => i.hasClass("filtered"));
+  }
+  /**
+   * Do a full reset on ogma and streams of ogma
+   */
+  shutDown() {
+    this.destroy(), this.store && this.store.clear();
+  }
+  /**
+   * Reset the Ogma instance so that it can be used fresh in the next visulization
+   */
+  clearOgmaState() {
+    this.reset(), this.store && this.store.clear(), this.initOgmaLinkuriousParser();
+  }
+  /**
+   * Updates the Ogma config when config changes in LKE. If init, options were already set by the Ogma.reset()
+   */
+  setConfigOgma(e, t, i) {
+    e && (this._configuration = e), t || this.setOptions({
+      ...this._configuration.options,
+      renderer: this._configuration.renderer
+    }), this.setStyles(this._configuration, i), this.setCaptions(this._configuration);
+  }
+}
+const Ce = {
+  lightsalmon: { hex: "#FFA07A", rgb: "rbg(255,160,122)" },
+  salmon: { hex: "#FA8072", rgb: "rgb(250,128,114)" },
+  darksalmon: { hex: "#E9967A", rgb: "rgb(233,150,122)" },
+  lightcoral: { hex: "#F08080", rgb: "rgb(240,128,128)" },
+  indianred: { hex: "#CD5C5C", rgb: "rgb(205,92,92)" },
+  crimson: { hex: "#DC143C", rgb: "rgb(220,20,60)" },
+  firebrick: { hex: "#B22222", rgb: "rgb(178,34,34)" },
+  red: { hex: "#FF0000", rgb: "rgb(255,0,0)" },
+  darkred: { hex: "#8B0000", rgb: "rgb(139,0,0)" },
+  coral: { hex: "#FF7F50", rgb: "rgb(255,127,80)" },
+  tomato: { hex: "#FF6347", rgb: "rgb(255,99,71)" },
+  orangered: { hex: "#FF4500", rgb: "rgb(255,69,0)" },
+  gold: { hex: "#FFD700", rgb: "rgb(255,215,0)" },
+  orange: { hex: "#FFA500", rgb: "rgb(255,165,0)" },
+  darkorange: { hex: "#FF8C00", rgb: "rgb(255,140,0)" },
+  lightyellow: { hex: "#FFFFE0", rgb: "rgb(255,255,224)" },
+  lemonchiffon: { hex: "#FFFACD", rgb: "rgb(255,250,205)" },
+  lightgoldenrodyellow: { hex: "#FAFAD2", rgb: "rgb(250,250,210)" },
+  papayawhip: { hex: "#FFEFD5", rgb: "rgb(255,239,213)" },
+  moccasin: { hex: "#FFE4B5", rgb: "rgb(255,228,181)" },
+  peachpuff: { hex: "#FFDAB9", rgb: "rgb(255,218,185)" },
+  palegoldenrod: { hex: "#EEE8AA", rgb: "rgb(238,232,170)" },
+  khaki: { hex: "#F0E68C", rgb: "rgb(240,230,140)" },
+  darkkhaki: { hex: "#BDB76B", rgb: "rgb(189,183,107)" },
+  yellow: { hex: "#FFFF00", rgb: "rgb(255,255,0)" },
+  lawngreen: { hex: "#7CFC00", rgb: "rgb(124,252,0)" },
+  chartreuse: { hex: "#7FFF00", rgb: "rgb(127,255,0)" },
+  limegreen: { hex: "#32CD32", rgb: "rgb(50,205,50)" },
+  lime: { hex: "#00FF00", rgb: "rgb(0.255.0)" },
+  forestgreen: { hex: "#228B22", rgb: "rgb(34,139,34)" },
+  green: { hex: "#008000", rgb: "rgb(0,128,0)" },
+  darkgreen: { hex: "#006400", rgb: "rgb(0,100,0)" },
+  greenyellow: { hex: "#ADFF2F", rgb: "rgb(173,255,47)" },
+  yellowgreen: { hex: "#9ACD32", rgb: "rgb(154,205,50)" },
+  springgreen: { hex: "#00FF7F", rgb: "rgb(0,255,127)" },
+  mediumspringgreen: { hex: "#00FA9A", rgb: "rgb(0,250,154)" },
+  lightgreen: { hex: "#90EE90", rgb: "rgb(144,238,144)" },
+  palegreen: { hex: "#98FB98", rgb: "rgb(152,251,152)" },
+  darkseagreen: { hex: "#8FBC8F", rgb: "rgb(143,188,143)" },
+  mediumseagreen: { hex: "#3CB371", rgb: "rgb(60,179,113)" },
+  seagreen: { hex: "#2E8B57", rgb: "rgb(46,139,87)" },
+  olive: { hex: "#808000", rgb: "rgb(128,128,0)" },
+  darkolivegreen: { hex: "#556B2F", rgb: "rgb(85,107,47)" },
+  olivedrab: { hex: "#6B8E23", rgb: "rgb(107,142,35)" },
+  lightcyan: { hex: "#E0FFFF", rgb: "rgb(224,255,255)" },
+  cyan: { hex: "#00FFFF", rgb: "rgb(0,255,255)" },
+  aqua: { hex: "#00FFFF", rgb: "rgb(0,255,255)" },
+  aquamarine: { hex: "#7FFFD4", rgb: "rgb(127,255,212)" },
+  mediumaquamarine: { hex: "#66CDAA", rgb: "rgb(102,205,170)" },
+  paleturquoise: { hex: "#AFEEEE", rgb: "rgb(175,238,238)" },
+  turquoise: { hex: "#40E0D0", rgb: "rgb(64,224,208)" },
+  mediumturquoise: { hex: "#48D1CC", rgb: "rgb(72,209,204)" },
+  darkturquoise: { hex: "#00CED1", rgb: "rgb(0,206,209)" },
+  lightseagreen: { hex: "#20B2AA", rgb: "rgb(32,178,170)" },
+  cadetblue: { hex: "#5F9EA0", rgb: "rgb(95,158,160)" },
+  darkcyan: { hex: "#008B8B", rgb: "rgb(0,139,139)" },
+  teal: { hex: "#008080", rgb: "rgb(0,128,128)" },
+  powderblue: { hex: "#B0E0E6", rgb: "rgb(176,224,230)" },
+  lightblue: { hex: "#ADD8E6", rgb: "rgb(173,216,230)" },
+  lightskyblue: { hex: "#87CEFA", rgb: "rgb(135,206,250)" },
+  skyblue: { hex: "#87CEEB", rgb: "rgb(135,206,235)" },
+  deepskyblue: { hex: "#00BFFF", rgb: "rgb(0,191,255)" },
+  lightsteelblue: { hex: "#B0C4DE", rgb: "rgb(176,196,222)" },
+  dodgerblue: { hex: "#1E90FF", rgb: "rgb(30,144,255)" },
+  cornflowerblue: { hex: "#6495ED", rgb: "rgb(100,149,237)" },
+  steelblue: { hex: "#4682B4", rgb: "rgb(70,130,180)" },
+  royalblue: { hex: "#4169E1", rgb: "rgb(65,105,225)" },
+  blue: { hex: "#0000FF", rgb: "rgb(0,0,255)" },
+  mediumblue: { hex: "#0000CD", rgb: "rgb(0,0,205)" },
+  darkblue: { hex: "#00008B", rgb: "rgb(0,0,139)" },
+  navy: { hex: "#000080", rgb: "rgb(0,0,128)" },
+  midnightblue: { hex: "#191970", rgb: "rgb(25,25,112)" },
+  mediumslateblue: { hex: "#7B68EE", rgb: "rgb(123,104,238)" },
+  slateblue: { hex: "#6A5ACD", rgb: "rgb(106,90,205)" },
+  darkslateblue: { hex: "#483D8B", rgb: "rgb(72,61,139)" },
+  lavender: { hex: "#E6E6FA", rgb: "rgb(230,230,250)" },
+  thistle: { hex: "#D8BFD8", rgb: "rgb(216,191,216)" },
+  plum: { hex: "#DDA0DD", rgb: "rgb(221,160,221)" },
+  violet: { hex: "#EE82EE", rgb: "rgb(238,130,238)" },
+  orchid: { hex: "#DA70D6", rgb: "rgb(218,112,214)" },
+  fuchsia: { hex: "#FF00FF", rgb: "rgb(255,0,255)" },
+  magenta: { hex: "#FF00FF", rgb: "rgb(255,0,255)" },
+  mediumorchid: { hex: "#BA55D3", rgb: "rgb(186,85,211)" },
+  mediumpurple: { hex: "#9370DB", rgb: "rgb(147,112,219)" },
+  blueviolet: { hex: "#8A2BE2", rgb: "rgb(138,43,226)" },
+  darkviolet: { hex: "#9400D3", rgb: "rgb(148,0,211)" },
+  darkorchid: { hex: "#9932CC", rgb: "rgb(153,50,204)" },
+  darkmagenta: { hex: "#8B008B", rgb: "rgb(139,0,139)" },
+  purple: { hex: "#800080", rgb: "rgb(128,0,128)" },
+  indigo: { hex: "#4B0082", rgb: "rgb(75,0,130)" },
+  pink: { hex: "#FFC0CB", rgb: "rgb(255,192,203)" },
+  lightpink: { hex: "#FFB6C1", rgb: "rgb(255,182,193)" },
+  hotpink: { hex: "#FF69B4", rgb: "rgb(255,105,180)" },
+  deeppink: { hex: "#FF1493", rgb: "rgb(255,20,147)" },
+  palevioletred: { hex: "#DB7093", rgb: "rgb(219,112,147)" },
+  mediumvioletred: { hex: "#C71585", rgb: "rgb(199,21,133)" },
+  white: { hex: "#FFFFFF", rgb: "rgb(255,255,255)" },
+  snow: { hex: "#FFFAFA", rgb: "rgb(255,250,250)" },
+  honeydew: { hex: "#F0FFF0", rgb: "rgb(240,255,240)" },
+  mintcream: { hex: "#F5FFFA", rgb: "rgb(245,255,250)" },
+  azure: { hex: "#F0FFFF", rgb: "rgb(240,255,255)" },
+  aliceblue: { hex: "#F0F8FF", rgb: "rgb(240,248,255)" },
+  ghostwhite: { hex: "#F8F8FF", rgb: "rgb(248,248,255)" },
+  whitesmoke: { hex: "#F5F5F5", rgb: "rgb(245,245,245)" },
+  seashell: { hex: "#FFF5EE", rgb: "rgb(255,245,238)" },
+  beige: { hex: "#F5F5DC", rgb: "rgb(245,245,220)" },
+  oldlace: { hex: "#FDF5E6", rgb: "rgb(253,245,230)" },
+  floralwhite: { hex: "#FFFAF0", rgb: "rgb(255,250,240)" },
+  ivory: { hex: "#FFFFF0", rgb: "rgb(255,255,240)" },
+  antiquewhite: { hex: "#FAEBD7", rgb: "rgb(250,235,215)" },
+  linen: { hex: "#FAF0E6", rgb: "rgb(250,240,230)" },
+  lavenderblush: { hex: "#FFF0F5", rgb: "rgb(255,240,245)" },
+  mistyrose: { hex: "#FFE4E1", rgb: "rgb(255,228,225)" },
+  gainsboro: { hex: "#DCDCDC", rgb: "rgb(220,220,220)" },
+  lightgray: { hex: "#D3D3D3", rgb: "rgb(211,211,211)" },
+  silver: { hex: "#C0C0C0", rgb: "rgb(192,192,192)" },
+  darkgray: { hex: "#A9A9A9", rgb: "rgb(169,169,169)" },
+  gray: { hex: "#808080", rgb: "rgb(128,128,128)" },
+  dimgray: { hex: "#696969", rgb: "rgb(105,105,105)" },
+  lightslategray: { hex: "#778899", rgb: "rgb(119,136,153)" },
+  slategray: { hex: "#708090", rgb: "rgb(112,128,144)" },
+  darkslategray: { hex: "#2F4F4F", rgb: "rgb(47,79,79)" },
+  black: { hex: "#000000", rgb: "rgb(0,0,0)" },
+  cornsilk: { hex: "#FFF8DC", rgb: "rgb(255,248,220)" },
+  blanchedalmond: { hex: "#FFEBCD", rgb: "rgb(255,235,205)" },
+  bisque: { hex: "#FFE4C4", rgb: "rgb(255,228,196)" },
+  navajowhite: { hex: "#FFDEAD", rgb: "rgb(255,222,173)" },
+  wheat: { hex: "#F5DEB3", rgb: "rgb(245,222,179)" },
+  burlywood: { hex: "#DEB887", rgb: "rgb(222,184,135)" },
+  tan: { hex: "#D2B48C", rgb: "rgb(210,180,140)" },
+  rosybrown: { hex: "#BC8F8F", rgb: "rgb(188,143,143)" },
+  sandybrown: { hex: "#F4A460", rgb: "rgb(244,164,96)" },
+  goldenrod: { hex: "#DAA520", rgb: "rgb(218,165,32)" },
+  peru: { hex: "#CD853F", rgb: "rgb(205,133,63)" },
+  chocolate: { hex: "#D2691E", rgb: "rgb(210,105,30)" },
+  saddlebrown: { hex: "#8B4513", rgb: "rgb(139,69,19)" },
+  sienna: { hex: "#A0522D", rgb: "rgb(160,82,45)" },
+  brown: { hex: "#A52A2A", rgb: "rgb(165,42,42)" },
+  maroon: { hex: "#800000", rgb: "rgb(128,0,0)" }
+};
+class ne {
+  /**
+   * Get the amount of hidden neighbors from a list of nodes
+   *
+   * @param nodes
+   */
+  static getHiddenNeighbors(e) {
+    return e.reduce((t, i) => {
+      const n = i.getData("statistics");
+      if (n !== void 0) {
+        const s = n.degree !== void 0 && !n.supernode ? n.degree - u.getDegreeWithoutSelfConnection(i) : n.supernodeDegree;
+        if (s !== void 0 && s > 0)
+          return t += s;
+      }
+      return t;
+    }, 0);
+  }
+  /**
+   * Return the visible degree of a node without self connection (self edge)
+   *
+   * @param {Node} node
+   * @return {number}
+   */
+  static getDegreeWithoutSelfConnection(e) {
+    return e.getAdjacentNodes({ policy: "exclude-sources", filter: "all" }).size;
+  }
+  /**
+   * Return true if the color tone is "bright"
+   *
+   * @param {string} color
+   * @returns {boolean}
+   */
+  static isBright(e) {
+    if (e === null || !u.isStringFilled(e))
+      return !0;
+    const t = /#[A-Fa-f0-9]{3,6}/, i = /^rgb\(\s*([01]?\d\d?|2[0-4]\d|25[0-5])\s*,\s*([01]?\d\d?|2[0-4]\d|25[0-5])\s*,\s*([01]?\d\d?|2[0-4]\d|25[0-5])\s*\)$/i, n = /^rgba\(\s*([01]?\d\d?|2[0-4]\d|25[0-5])\s*,\s*([01]?\d\d?|2[0-4]\d|25[0-5])\s*,\s*([01]?\d\d?|2[0-4]\d|25[0-5])\s*,\s*(?:0|1|0?\.\d+)\s*\)$/i;
+    let s;
+    if (t.test(e)) {
+      e.length < 5 && (e += e.slice(1)), e = e.replace("#", "");
+      const c = parseInt(e[0].toString() + e[1].toString(), 16), d = parseInt(e[2].toString() + e[3].toString(), 16), g = parseInt(e[4].toString() + e[5].toString(), 16);
+      s = `rgb(${c}, ${d}, ${g})`;
+    } else if (i.test(e) || n.test(e) || Ce[e.toLowerCase()] !== void 0)
+      s = u.isDefined(Ce[e.toLowerCase()]) ? Ce[e.toLowerCase()].rgb : e;
+    else
+      return !0;
+    const [a, o, l] = /rgba?\((\d{1,3}),(\d{1,3}),(\d{1,3})(,\d{1,3})?\)/.exec(s.replace(/\s/g, "")).slice(1, 4);
+    return !u.isDefined(a) || !u.isDefined(o) || !u.isDefined(l) ? (console.warn("The given color is not a valid rgb formatted color"), !0) : (+a * 299 + +o * 587 + +l * 114) / 1e3 > 255 * 0.7;
+  }
+  static isNode(e) {
+    return e.isNode;
+  }
+  static isNodeList(e) {
+    return e.isNode;
+  }
+  static topologicalSort(e) {
+    let i = e.toArray().find((a) => a.getDegree() === 1);
+    const n = /* @__PURE__ */ new Set(), s = [];
+    for (; i; ) {
+      s.push(i), n.add(i);
+      const a = i.getAdjacentNodes().filter((o) => !n.has(o)).get(0);
+      i = a === void 0 ? null : a;
+    }
+    return s.map((a) => a.getId());
+  }
+  static isStar(e) {
+    for (const t of e.toArray()) {
+      const i = t.getAdjacentNodes();
+      if (t.getDegree() > 2 && i.getDegree().every((s) => s === 1) && i.size + 1 === e.size) return t;
+    }
+    return !1;
+  }
+}
+const De = "LKE_NODE_GROUPING_EDGE", Hg = "LKE_NODE_GROUPING_NODE";
+class Vg {
+  constructor(e) {
+    this._ogma = e;
+  }
+  /**
+   * Set the grouping rule
+   * @param rule of grouping
+   */
+  setGroupingRule(e) {
+    this.groupRule = e;
+  }
+  /**
+   * create a node grouping transformation
+   * It uses groupRule to define the rule
+   * Group the nodes based on a category type and a property value
+   */
+  async initTransformation() {
+    this.transformation === void 0 ? this.transformation = this._ogma.transformations.addNodeGrouping({
+      groupIdFunction: (e) => {
+        var t;
+        if (!this._isRuleNotApplicableToNode(e)) {
+          const i = this._findGroupingPropertyValue(e);
+          return `${(t = this.groupRule) == null ? void 0 : t.groupingOptions.itemTypes.join("-")}-${i}`.toLowerCase().trim();
+        }
+      },
+      nodeGenerator: (e) => ({
+        data: {
+          categories: [Hg],
+          properties: {},
+          nodeGroupId: this._findNodeGroupId(e)
+        }
+      }),
+      edgeGenerator: () => ({
+        data: {
+          type: De
+        }
+      }),
+      showContents: !0,
+      padding: 10
+    }) : await this.refreshTransformation();
+  }
+  /**
+   * refresh the transformation
+   * Called when there is a change in the rule
+   */
+  async refreshTransformation() {
+    this.transformation !== void 0 ? (await this.transformation.refresh(), await this._unpinNodes(this._getAllTransformationRawNodes())) : await this.initTransformation();
+  }
+  /**
+   * init node grouping style
+   */
+  initNodeGroupingStyle() {
+    this.nodeGroupingStyleRule = this._ogma.styles.addRule({
+      nodeAttributes: {
+        // Any default style will go here
+        text: {
+          content: (e) => this._getNodeGroupingCaption(e),
+          style: "bold"
+        },
+        layer: -1,
+        color: "rgba(240, 240, 240)",
+        innerStroke: {
+          color: "#7f7f7f",
+          width: 2
+        }
+      },
+      nodeSelector: (e) => e.isVirtual() && u.isDefined(e.getSubNodes()),
+      // the style will be updated when data object is updated
+      nodeDependencies: { self: { data: !0 } }
+    });
+  }
+  async refreshNodeGroupingStyle() {
+    var e;
+    await ((e = this.nodeGroupingStyleRule) == null ? void 0 : e.refresh());
+  }
+  /**
+   * run layout on all subnodes of virtual nodes
+   */
+  async runLayoutOnAllSubNodes() {
+    await this._ogma.transformations.afterNextUpdate();
+    const e = this._getAllTransformationRawNodes(), t = [];
+    for (let i = 0; i < e.length; i++) {
+      const n = e[i];
+      t.push(this.runSubNodesLayout(n));
+    }
+    await Promise.all(t);
+  }
+  /**
+   * Run the layout on the subnodes of the virtual node
+   * @param subNodes nodes part of a virtual node
+   */
+  async runSubNodesLayout(e) {
+    if (e.size === 0 || e.size === 1)
+      return;
+    if (e.size === 2) {
+      await this._runTwoNodesLayout(e);
+      return;
+    }
+    if (e.getAdjacentEdges({ bothExtremities: !0 }).size === 0) return this._runCirclePack(e);
+    const i = this.isStar(e);
+    if (i) {
+      const s = e.filter((l) => l !== i), a = this._runCircularLayout({
+        radii: s.getAttribute("radius"),
+        cx: i.getAttribute("x"),
+        cy: i.getAttribute("y"),
+        clockwise: !1,
+        distanceRatio: 5
+      });
+      await i.toList().concat(s).setAttributes([i.getPosition(), ...a]);
+      return;
+    }
+    if (e.getDegree().every((s) => s > 0 && s <= 2)) {
+      await this._runChainLayout(e);
+      return;
+    }
+    return await this._runForceLayout(e);
+  }
+  /**
+   * Get the virtual nodes of the transformation
+   * @private
+   */
+  getVirtualNodesOfTransformation() {
+    return this.transformation.getContext().metaNodes;
+  }
+  /**
+   * Set the node group pin
+   * @param nodeGroups object containing the node group id and the layoutable attribute
+   */
+  async setNodeGroupPin(e) {
+    this._ogma.getNodes().filter((t) => t.isVirtual()).forEach((t) => {
+      const i = e.find(
+        (n) => n.id === t.getData("nodeGroupId")
+      );
+      i !== void 0 && t.setAttribute("layoutable", i.attributes.layoutable ?? !1);
+    });
+  }
+  /**
+   * Return the caption of a virtual node
+   * @param node reference to the virtual node
+   */
+  _getNodeGroupingCaption(e) {
+    var t;
+    if (e !== void 0 && e.isVirtual() && ((t = e.getSubNodes()) == null ? void 0 : t.get(0)) !== void 0) {
+      const i = e.getSubNodes().get(0).getData(["properties", this.groupRule.groupingOptions.propertyKey]), n = u.getValueFromLkProperty(i), s = e.getSubNodes().filter((a) => !a.hasClass("filtered")).size;
+      return `${n} (${s})`;
+    }
+  }
+  /**
+   * Run the circle pack layout on the subnodes
+   * @param subNodes
+   */
+  async _runCirclePack(e) {
+    await this._ogma.algorithms.circlePack({
+      nodes: e,
+      margin: 10,
+      sort: "asc"
+    });
+  }
+  async _runChainLayout(e) {
+    const t = this._ogma.getNodes(ne.topologicalSort(e));
+    await this._ogma.layouts.grid({
+      nodes: t,
+      // TODO: test that visually
+      colDistance: Math.max(...e.getAttribute("radius").map(Number)) * 4,
+      rows: 1
+    });
+  }
+  async _runForceLayout(e) {
+    await this._ogma.layouts.force({
+      nodes: e,
+      ...kg
+    });
+  }
+  _isRuleNotApplicableToNode(e) {
+    var i;
+    const t = e.getData([
+      "properties",
+      ((i = this.groupRule) == null ? void 0 : i.groupingOptions.propertyKey) ?? ""
+    ]);
+    return (
+      // if the group rule is not defined
+      this.groupRule === void 0 || // if rule is applied to a different category
+      this.groupRule.groupingOptions.itemTypes.every(
+        (n) => !e.getData("categories").includes(n)
+      ) || // if the property value is not defined
+      !u.isDefined(t) || // if the property value is missing
+      typeof t == "object" && t.status === "missing"
+    );
+  }
+  /**
+   * Unpin list of nodes
+   * @param nodes
+   * @private
+   */
+  async _unpinNodes(e) {
+    await Promise.all(
+      e.map((t) => {
+        if (t !== null)
+          return t.setAttribute("layoutable", !0);
+      })
+    );
+  }
+  /**
+   * Get all the raw nodes part of the transformation
+   * @private
+   */
+  _getAllTransformationRawNodes() {
+    return this.getVirtualNodesOfTransformation().getSubNodes();
+  }
+  _findGroupingPropertyValue(e) {
+    var i;
+    const t = e.getData([
+      "properties",
+      ((i = this.groupRule) == null ? void 0 : i.groupingOptions.propertyKey) ?? ""
+    ]);
+    return `${u.getValueFromLkProperty(t)}`;
+  }
+  /**
+   * Return a hashed string that represents the group id
+   */
+  _findNodeGroupId(e) {
+    var i, n;
+    const t = this._findGroupingPropertyValue(e.get(0));
+    return He(
+      `${(i = this.groupRule) == null ? void 0 : i.name}-${(n = this.groupRule) == null ? void 0 : n.groupingOptions.itemTypes.join(
+        "-"
+      )}-${t}`
+    );
+  }
+  _runCircularLayout({
+    radii: e,
+    clockwise: t = !0,
+    cx: i = 0,
+    cy: n = 0,
+    startAngle: s = 3 / 2 * Math.PI,
+    getRadius: a = (l) => Number(l),
+    distanceRatio: o = 0
+  }) {
+    const l = e.length;
+    if (l === 0) return [];
+    if (l === 1) return [{ x: i, y: n }];
+    const c = e.map(a).reduce((A, x) => Math.max(A, x), 0) * (2 + o), g = (2 * Math.PI - 2 * Math.PI / l) / Math.max(1, l - 1), h = Math.cos(g) - Math.cos(0), y = Math.sin(g) - Math.sin(0), _ = Math.sqrt(c * c / (h * h + y * y)), f = Math.max(_, 0);
+    return e.map((A, x) => {
+      const $ = s + x * g * (t ? 1 : -1), R = f * Math.cos($), v = f * Math.sin($);
+      return {
+        x: i + R,
+        y: n + v
+      };
+    });
+  }
+  async _runTwoNodesLayout(e) {
+    const t = e.getAttribute("radius").map(Number), i = e.getPosition(), n = Math.min(...t);
+    await e.setAttributes([
+      i[0],
+      { x: i[0].x + n + t[0] + t[1], y: i[0].y }
+    ]);
+  }
+  isStar(e) {
+    for (const t of e.getId()) {
+      const i = this._ogma.getNode(t), n = i.getAdjacentNodes();
+      if (i.getDegree() > 2 && n.getDegree().every((a) => a === 1) && n.size + 1 === e.size) return i;
+    }
+    return !1;
+  }
+}
+const Kg = {
+  color: "#000000",
+  shape: {
+    style: "dashed",
+    head: "arrow"
+  },
+  width: 1.5
+};
+class qg {
+  constructor(e) {
+    this._ogma = e, this.groupedEdges = {};
+  }
+  /**
+   * create an edge grouping transformation by edge type
+   */
+  async initTransformation() {
+    this.transformation === void 0 ? this.transformation = this._ogma.transformations.addEdgeGrouping({
+      separateEdgesByDirection: !0,
+      selector: (e) => this.groupedEdges[e.getData("type")],
+      groupIdFunction: (e) => e.getData("type"),
+      generator: (e) => ({
+        data: {
+          properties: {
+            originalType: e.getData("type")[0]
+          }
+        }
+      })
+    }) : await this.transformation.refresh();
+  }
+  /**
+   * init edge grouping style
+   */
+  initEdgeGroupingStyle() {
+    this.edgeGroupingStyleRule = this._ogma.styles.addRule({
+      edgeAttributes: {
+        ...Kg,
+        ...this.edgeGroupStyle,
+        text: {
+          content: (e) => {
+            if (e !== void 0 && e.getSubEdges() !== null && e.getData("type") !== De) {
+              const t = e.getSubEdges().filter((i) => !i.hasClass("filtered")).size;
+              return `${e.getData(["properties", "originalType"])} (${t})`;
+            }
+          },
+          style: "bold"
+        }
+      },
+      edgeSelector: (e) => e.isVirtual() && e.getSubEdges() && e.getSubEdges().filter((t) => !t.hasClass("filtered")).size > 0 && e.getData("type") !== De,
+      edgeDependencies: { self: { data: !0 } }
+    });
+  }
+  refreshEdgeGroupingStyle() {
+    this.edgeGroupingStyleRule !== void 0 && this.edgeGroupingStyleRule.refresh();
+  }
+}
+const m = class m {
+  /**
+   * Returns whether the node/edge should be *filtered* (a.k.a. *hidden*).
+   *
+   * Notes:
+   * 1. `filterRules` are rules that match what should be filtered/hidden.
+   * 2. `filterRules` are combined inclusively: as soon as one rule returns `true` for
+   *    an item, the item can be hidden/filtered.
+   *
+   * @param filterRules
+   * @param itemData
+   */
+  static isFiltered(e, t) {
+    return u.isDefined(t) ? "categories" in t ? m.getFilterFunction(e, !0)(t) : m.getFilterFunction(e, !1)(t) : !1;
+  }
+  static getFilterFunction(e, t) {
+    const i = JSON.stringify(e, null, ""), n = t ? m.nodeCache : m.edgeCache;
+    let s = n.get(i);
+    return s || (s = m.createFilterFunction(e, t), n.size > m.FILTER_CACHE_SIZE && n.clear(), n.set(i, s)), s;
+  }
+  static createFilterFunction(e, t) {
+    const i = e.map(
+      (n) => m.filterToFilterFunction(n, t)
+    );
+    return (n) => {
+      for (const s of i)
+        if (s(n))
+          return !0;
+      return !1;
+    };
+  }
+  static filterToFilterFunction(e, t) {
+    switch (e.type) {
+      case S.ANY:
+        return m.createAnyFilterFunction(e, t);
+      case S.IS:
+        return m.createIsFilterFunction(e, t);
+      case S.NO_VALUE:
+        return m.createNoValueFilterFunction(e, t);
+      case S.RANGE:
+        return m.createRangeFilterFunction(e, t);
+      case S.NAN:
+        return m.createNaNFilterFunction(e, t);
+    }
+  }
+  static createAnyFilterFunction(e, t) {
+    return t ? (i) => e.itemType === void 0 ? !0 : i.categories.includes(e.itemType) : (i) => i.type === e.itemType;
+  }
+  static createIsFilterFunction(e, t) {
+    return t ? (i) => i.categories.includes(e.itemType) && u.getPropertyValue(u.getIn(i, e.input), !0) === e.value : (i) => i.type === e.itemType && u.getPropertyValue(u.getIn(i, e.input), !0) === e.value;
+  }
+  static createNoValueFilterFunction(e, t) {
+    return t ? (i) => i.categories.includes(e.itemType) && !u.isDefined(u.getPropertyValue(u.getIn(i, e.input), !0)) : (i) => i.type === e.itemType && !u.isDefined(u.getPropertyValue(u.getIn(i, e.input), !0));
+  }
+  static createNaNFilterFunction(e, t) {
+    return t ? (i) => i.categories.includes(e.itemType) && m.isNotANumber(u.getPropertyValue(u.getIn(i, e.input), !0)) : (i) => i.type === e.itemType && m.isNotANumber(u.getPropertyValue(u.getIn(i, e.input), !0));
+  }
+  static isNotANumber(e) {
+    return u.isDefined(e) && !u.isNumber(e);
+  }
+  static createRangeFilterFunction(e, t) {
+    return t ? (i) => i.categories.includes(e.itemType) && m.valueShouldBeHidden(
+      u.getPropertyValue(u.getIn(i, e.input), !1),
+      e.value
+    ) : (i) => i.type === e.itemType && m.valueShouldBeHidden(
+      u.getPropertyValue(u.getIn(i, e.input), !1),
+      e.value
+    );
+  }
+  /**
+   * Returns true if `value` should be filtered/hidden.
+   *
+   * `range` describes what should be filtered/hidden:
+   * - e.g. {"<":10, ">=":20} => hide any value in ]-inf, 10[ *OR* in [20, +inf[
+   * - e.g. {"<=":10}         => hide any value in ]-inf, 10]
+   * - e.g. {">=":20}         => hide any value in [20, +inf[
+   *
+   * Returns false (i.e. will not filter/hide) if `value` is not a number.
+   */
+  static valueShouldBeHidden(e, t) {
+    const i = u.parseFloat(e);
+    return Number.isNaN(i) ? !1 : t["<"] !== void 0 && i < t["<"] || t["<="] !== void 0 && i <= t["<="] || t[">"] !== void 0 && i > t[">"] || t[">="] !== void 0 && i >= t[">="];
+  }
+};
+m.nodeCache = /* @__PURE__ */ new Map(), m.edgeCache = /* @__PURE__ */ new Map(), m.FILTER_CACHE_SIZE = 5;
+let Gt = m;
+const Qg = (r) => r.selection.size, eh = (r) => {
+  switch (r.selection.size) {
+    case 1:
+      return "selection";
+    case 0:
+      return "noSelection";
+    default:
+      return "multiSelection";
+  }
+}, th = (r) => {
+  if (r.selection.size !== 0)
+    return r.selection.isNode ? P.NODE : P.EDGE;
+}, qe = (r) => r.selection.size === 1 ? r.selection.get(0) : void 0, rh = (r) => {
+  const e = qe(r);
+  if (e !== void 0)
+    return e.isNode ? e.getData("categories") : [e.getData("type")];
+}, ih = (r) => {
+  const e = qe(r);
+  if (e !== void 0)
+    return e.isNode ? "node" : "edge";
+}, Wg = (r) => {
+  const e = qe(r);
+  if (e !== void 0) {
+    const t = e.getData().properties;
+    return Object.keys(t).map((i) => ({
+      key: i,
+      value: t[i]
+    }));
+  }
+  return [];
+}, nh = (r) => Wg(r).length > 0;
+export {
+  jg as ANIMATION_DURATION,
+  F as BASE_GREY,
+  w as Captions,
+  Ag as CaptionsViz,
+  W as EdgeAttributes,
+  It as FILTER_OPACITY,
+  Gt as Filters,
+  Ce as HTML_COLORS,
+  E as ItemAttributes,
+  De as LKE_NODE_GROUPING_EDGE,
+  Xg as LKOgma,
+  U as NodeAttributes,
+  Gg as OgmaStore,
+  ne as OgmaTools,
+  Nt as PALETTE,
+  C as StyleRule,
+  vg as StyleRuleType,
+  p as StyleRules,
+  D as StyleType,
+  Sg as StylesViz,
+  u as Tools,
+  qg as TransformationsViz,
+  th as getSelectionEntity,
+  Wg as getSelectionProperties,
+  Qg as getSelectionSize,
+  eh as getSelectionState,
+  qe as getUniqSelection,
+  ih as getUniqSelectionEntity,
+  rh as getUniqSelectionTypes,
+  nh as hasSelectionProperties
+};
+//# sourceMappingURL=index.mjs.map