@orangelogic/design-system 2.69.0 → 2.70.0

package/library/chunks/hierarchy.5kfBCoGt.js

@@ -0,0 +1,3561 @@
+import { D as yi, F as mi, al as xi, x as Zt, I as _i, q as O, am as V, H as qt, C as yt, L as Z, T as K, b as Ue, R as ce, m as G, J as Ke, e as P, a2 as ke, aq as wi, a as X, _ as Ne, G as Ze, bi as Di, a4 as be, ap as Qt, r as ut, b1 as ki, o as Ae, h as Ni, j as bi, aZ as Pe } from "./am-chart.oZVBmpnn.js";
+import { N as Ai, h as Pi } from "./index.CZJTjkLp.js";
+import { C as Jt } from "./Circle.tOnnO-F-.js";
+import { t as Ci, d as Ri } from "./timer.B39XOBYL.js";
+import { c as mt, a as xt, i as Ti } from "./index.DU0XUO4k.js";
+import { S as zi } from "./Slice.Dm56LTKj.js";
+import { R as Li } from "./RadialLabel.HfsGiN4x.js";
+import { r as Si } from "./accessors.BHk36ecy.js";
+import { P as Mi } from "./Polygon.Dr-GV2hn.js";
+import { a as Hi } from "./_commonjsHelpers.DQNKXVTB.js";
+import { r as Wi } from "./___vite-browser-external_commonjs-proxy.C2tf3HsQ.js";
+function Qe(s) {
+  s.x0 = Math.round(s.x0), s.y0 = Math.round(s.y0), s.x1 = Math.round(s.x1), s.y1 = Math.round(s.y1);
+}
+function Ft(s, t, e, i, n) {
+  for (var a = s.children, o, h = -1, r = a.length, l = s.value && (i - t) / s.value; ++h < r; )
+    o = a[h], o.y0 = e, o.y1 = n, o.x0 = t, o.x1 = t += o.value * l;
+}
+function Je() {
+  var s = 1, t = 1, e = 0, i = !1;
+  function n(o) {
+    var h = o.height + 1;
+    return o.x0 = o.y0 = e, o.x1 = s, o.y1 = t / h, o.eachBefore(a(t, h)), i && o.eachBefore(Qe), o;
+  }
+  function a(o, h) {
+    return function(r) {
+      r.children && Ft(r, r.x0, o * (r.depth + 1) / h, r.x1, o * (r.depth + 2) / h);
+      var l = r.x0, u = r.y0, f = r.x1 - e, c = r.y1 - e;
+      f < l && (l = f = (l + f) / 2), c < u && (u = c = (u + c) / 2), r.x0 = l, r.y0 = u, r.x1 = f, r.y1 = c;
+    };
+  }
+  return n.round = function(o) {
+    return arguments.length ? (i = !!o, n) : i;
+  }, n.size = function(o) {
+    return arguments.length ? (s = +o[0], t = +o[1], n) : [s, t];
+  }, n.padding = function(o) {
+    return arguments.length ? (e = +o, n) : e;
+  }, n;
+}
+function Ii(s, t) {
+  return s.parent === t.parent ? 1 : 2;
+}
+function Yt(s) {
+  var t = s.children;
+  return t ? t[0] : s.t;
+}
+function Gt(s) {
+  var t = s.children;
+  return t ? t[t.length - 1] : s.t;
+}
+function Bi(s, t, e) {
+  var i = e / (t.i - s.i);
+  t.c -= i, t.s += e, s.c += i, t.z += e, t.m += e;
+}
+function Oi(s) {
+  for (var t = 0, e = 0, i = s.children, n = i.length, a; --n >= 0; )
+    a = i[n], a.z += t, a.m += t, t += a.s + (e += a.c);
+}
+function Ei(s, t, e) {
+  return s.a.parent === t.parent ? s.a : e;
+}
+function At(s, t) {
+  this._ = s, this.parent = null, this.children = null, this.A = null, this.a = this, this.z = 0, this.m = 0, this.c = 0, this.s = 0, this.t = null, this.i = t;
+}
+At.prototype = Object.create(Ai.prototype);
+function Fi(s) {
+  for (var t = new At(s, 0), e, i = [t], n, a, o, h; e = i.pop(); )
+    if (a = e._.children)
+      for (e.children = new Array(h = a.length), o = h - 1; o >= 0; --o)
+        i.push(n = e.children[o] = new At(a[o], o)), n.parent = e;
+  return (t.parent = new At(null, 0)).children = [t], t;
+}
+function Vi() {
+  var s = Ii, t = 1, e = 1, i = null;
+  function n(l) {
+    var u = Fi(l);
+    if (u.eachAfter(a), u.parent.m = -u.z, u.eachBefore(o), i) l.eachBefore(r);
+    else {
+      var f = l, c = l, g = l;
+      l.eachBefore(function(m) {
+        m.x < f.x && (f = m), m.x > c.x && (c = m), m.depth > g.depth && (g = m);
+      });
+      var v = f === c ? 1 : s(f, c) / 2, d = v - f.x, p = t / (c.x + v + d), y = e / (g.depth || 1);
+      l.eachBefore(function(m) {
+        m.x = (m.x + d) * p, m.y = m.depth * y;
+      });
+    }
+    return l;
+  }
+  function a(l) {
+    var u = l.children, f = l.parent.children, c = l.i ? f[l.i - 1] : null;
+    if (u) {
+      Oi(l);
+      var g = (u[0].z + u[u.length - 1].z) / 2;
+      c ? (l.z = c.z + s(l._, c._), l.m = l.z - g) : l.z = g;
+    } else c && (l.z = c.z + s(l._, c._));
+    l.parent.A = h(l, c, l.parent.A || f[0]);
+  }
+  function o(l) {
+    l._.x = l.z + l.parent.m, l.m += l.parent.m;
+  }
+  function h(l, u, f) {
+    if (u) {
+      for (var c = l, g = l, v = u, d = c.parent.children[0], p = c.m, y = g.m, m = v.m, _ = d.m, x; v = Gt(v), c = Yt(c), v && c; )
+        d = Yt(d), g = Gt(g), g.a = l, x = v.z + m - c.z - p + s(v._, c._), x > 0 && (Bi(Ei(v, l, f), l, x), p += x, y += x), m += v.m, p += c.m, _ += d.m, y += g.m;
+      v && !Gt(g) && (g.t = v, g.m += m - y), c && !Yt(d) && (d.t = c, d.m += p - _, f = l);
+    }
+    return f;
+  }
+  function r(l) {
+    l.x *= t, l.y = l.depth * e;
+  }
+  return n.separation = function(l) {
+    return arguments.length ? (s = l, n) : s;
+  }, n.size = function(l) {
+    return arguments.length ? (i = !1, t = +l[0], e = +l[1], n) : i ? null : [t, e];
+  }, n.nodeSize = function(l) {
+    return arguments.length ? (i = !0, t = +l[0], e = +l[1], n) : i ? [t, e] : null;
+  }, n;
+}
+function ue(s, t, e, i, n) {
+  for (var a = s.children, o, h = -1, r = a.length, l = s.value && (n - e) / s.value; ++h < r; )
+    o = a[h], o.x0 = t, o.x1 = i, o.y0 = e, o.y1 = e += o.value * l;
+}
+var Xi = (1 + Math.sqrt(5)) / 2;
+function qi(s, t, e, i, n, a) {
+  for (var o = [], h = t.children, r, l, u = 0, f = 0, c = h.length, g, v, d = t.value, p, y, m, _, x, w, k; u < c; ) {
+    g = n - e, v = a - i;
+    do
+      p = h[f++].value;
+    while (!p && f < c);
+    for (y = m = p, w = Math.max(v / g, g / v) / (d * s), k = p * p * w, x = Math.max(m / k, k / y); f < c; ++f) {
+      if (p += l = h[f].value, l < y && (y = l), l > m && (m = l), k = p * p * w, _ = Math.max(m / k, k / y), _ > x) {
+        p -= l;
+        break;
+      }
+      x = _;
+    }
+    o.push(r = { value: p, dice: g < v, children: h.slice(u, f) }), r.dice ? Ft(r, e, i, n, d ? i += v * p / d : a) : ue(r, e, i, d ? e += g * p / d : n, a), d -= p, u = f;
+  }
+  return o;
+}
+const te = function s(t) {
+  function e(i, n, a, o, h) {
+    qi(t, i, n, a, o, h);
+  }
+  return e.ratio = function(i) {
+    return s((i = +i) > 1 ? i : 1);
+  }, e;
+}(Xi);
+function Ce() {
+  var s = te, t = !1, e = 1, i = 1, n = [0], a = mt, o = mt, h = mt, r = mt, l = mt;
+  function u(c) {
+    return c.x0 = c.y0 = 0, c.x1 = e, c.y1 = i, c.eachBefore(f), n = [0], t && c.eachBefore(Qe), c;
+  }
+  function f(c) {
+    var g = n[c.depth], v = c.x0 + g, d = c.y0 + g, p = c.x1 - g, y = c.y1 - g;
+    p < v && (v = p = (v + p) / 2), y < d && (d = y = (d + y) / 2), c.x0 = v, c.y0 = d, c.x1 = p, c.y1 = y, c.children && (g = n[c.depth + 1] = a(c) / 2, v += l(c) - g, d += o(c) - g, p -= h(c) - g, y -= r(c) - g, p < v && (v = p = (v + p) / 2), y < d && (d = y = (d + y) / 2), s(c, v, d, p, y));
+  }
+  return u.round = function(c) {
+    return arguments.length ? (t = !!c, u) : t;
+  }, u.size = function(c) {
+    return arguments.length ? (e = +c[0], i = +c[1], u) : [e, i];
+  }, u.tile = function(c) {
+    return arguments.length ? (s = Si(c), u) : s;
+  }, u.padding = function(c) {
+    return arguments.length ? u.paddingInner(c).paddingOuter(c) : u.paddingInner();
+  }, u.paddingInner = function(c) {
+    return arguments.length ? (a = typeof c == "function" ? c : xt(+c), u) : a;
+  }, u.paddingOuter = function(c) {
+    return arguments.length ? u.paddingTop(c).paddingRight(c).paddingBottom(c).paddingLeft(c) : u.paddingTop();
+  }, u.paddingTop = function(c) {
+    return arguments.length ? (o = typeof c == "function" ? c : xt(+c), u) : o;
+  }, u.paddingRight = function(c) {
+    return arguments.length ? (h = typeof c == "function" ? c : xt(+c), u) : h;
+  }, u.paddingBottom = function(c) {
+    return arguments.length ? (r = typeof c == "function" ? c : xt(+c), u) : r;
+  }, u.paddingLeft = function(c) {
+    return arguments.length ? (l = typeof c == "function" ? c : xt(+c), u) : l;
+  }, u;
+}
+function Yi(s, t, e, i, n) {
+  var a = s.children, o, h = a.length, r, l = new Array(h + 1);
+  for (l[0] = r = o = 0; o < h; ++o)
+    l[o + 1] = r += a[o].value;
+  u(0, h, s.value, t, e, i, n);
+  function u(f, c, g, v, d, p, y) {
+    if (f >= c - 1) {
+      var m = a[f];
+      m.x0 = v, m.y0 = d, m.x1 = p, m.y1 = y;
+      return;
+    }
+    for (var _ = l[f], x = g / 2 + _, w = f + 1, k = c - 1; w < k; ) {
+      var A = w + k >>> 1;
+      l[A] < x ? w = A + 1 : k = A;
+    }
+    x - l[w - 1] < l[w] - x && f + 1 < w && --w;
+    var N = l[w] - _, C = g - N;
+    if (p - v > y - d) {
+      var b = g ? (v * C + p * N) / g : p;
+      u(f, w, N, v, d, b, y), u(w, c, C, b, d, p, y);
+    } else {
+      var S = g ? (d * C + y * N) / g : y;
+      u(f, w, N, v, d, p, S), u(w, c, C, v, S, p, y);
+    }
+  }
+}
+function Gi(s, t, e, i, n) {
+  (s.depth & 1 ? ue : Ft)(s, t, e, i, n);
+}
+function ji(s) {
+  const t = +this._x.call(null, s), e = +this._y.call(null, s);
+  return ti(this.cover(t, e), t, e, s);
+}
+function ti(s, t, e, i) {
+  if (isNaN(t) || isNaN(e)) return s;
+  var n, a = s._root, o = { data: i }, h = s._x0, r = s._y0, l = s._x1, u = s._y1, f, c, g, v, d, p, y, m;
+  if (!a) return s._root = o, s;
+  for (; a.length; )
+    if ((d = t >= (f = (h + l) / 2)) ? h = f : l = f, (p = e >= (c = (r + u) / 2)) ? r = c : u = c, n = a, !(a = a[y = p << 1 | d])) return n[y] = o, s;
+  if (g = +s._x.call(null, a.data), v = +s._y.call(null, a.data), t === g && e === v) return o.next = a, n ? n[y] = o : s._root = o, s;
+  do
+    n = n ? n[y] = new Array(4) : s._root = new Array(4), (d = t >= (f = (h + l) / 2)) ? h = f : l = f, (p = e >= (c = (r + u) / 2)) ? r = c : u = c;
+  while ((y = p << 1 | d) === (m = (v >= c) << 1 | g >= f));
+  return n[m] = a, n[y] = o, s;
+}
+function $i(s) {
+  var t, e, i = s.length, n, a, o = new Array(i), h = new Array(i), r = 1 / 0, l = 1 / 0, u = -1 / 0, f = -1 / 0;
+  for (e = 0; e < i; ++e)
+    isNaN(n = +this._x.call(null, t = s[e])) || isNaN(a = +this._y.call(null, t)) || (o[e] = n, h[e] = a, n < r && (r = n), n > u && (u = n), a < l && (l = a), a > f && (f = a));
+  if (r > u || l > f) return this;
+  for (this.cover(r, l).cover(u, f), e = 0; e < i; ++e)
+    ti(this, o[e], h[e], s[e]);
+  return this;
+}
+function Ui(s, t) {
+  if (isNaN(s = +s) || isNaN(t = +t)) return this;
+  var e = this._x0, i = this._y0, n = this._x1, a = this._y1;
+  if (isNaN(e))
+    n = (e = Math.floor(s)) + 1, a = (i = Math.floor(t)) + 1;
+  else {
+    for (var o = n - e || 1, h = this._root, r, l; e > s || s >= n || i > t || t >= a; )
+      switch (l = (t < i) << 1 | s < e, r = new Array(4), r[l] = h, h = r, o *= 2, l) {
+        case 0:
+          n = e + o, a = i + o;
+          break;
+        case 1:
+          e = n - o, a = i + o;
+          break;
+        case 2:
+          n = e + o, i = a - o;
+          break;
+        case 3:
+          e = n - o, i = a - o;
+          break;
+      }
+    this._root && this._root.length && (this._root = h);
+  }
+  return this._x0 = e, this._y0 = i, this._x1 = n, this._y1 = a, this;
+}
+function Ki() {
+  var s = [];
+  return this.visit(function(t) {
+    if (!t.length) do
+      s.push(t.data);
+    while (t = t.next);
+  }), s;
+}
+function Zi(s) {
+  return arguments.length ? this.cover(+s[0][0], +s[0][1]).cover(+s[1][0], +s[1][1]) : isNaN(this._x0) ? void 0 : [[this._x0, this._y0], [this._x1, this._y1]];
+}
+function Y(s, t, e, i, n) {
+  this.node = s, this.x0 = t, this.y0 = e, this.x1 = i, this.y1 = n;
+}
+function Qi(s, t, e) {
+  var i, n = this._x0, a = this._y0, o, h, r, l, u = this._x1, f = this._y1, c = [], g = this._root, v, d;
+  for (g && c.push(new Y(g, n, a, u, f)), e == null ? e = 1 / 0 : (n = s - e, a = t - e, u = s + e, f = t + e, e *= e); v = c.pop(); )
+    if (!(!(g = v.node) || (o = v.x0) > u || (h = v.y0) > f || (r = v.x1) < n || (l = v.y1) < a))
+      if (g.length) {
+        var p = (o + r) / 2, y = (h + l) / 2;
+        c.push(
+          new Y(g[3], p, y, r, l),
+          new Y(g[2], o, y, p, l),
+          new Y(g[1], p, h, r, y),
+          new Y(g[0], o, h, p, y)
+        ), (d = (t >= y) << 1 | s >= p) && (v = c[c.length - 1], c[c.length - 1] = c[c.length - 1 - d], c[c.length - 1 - d] = v);
+      } else {
+        var m = s - +this._x.call(null, g.data), _ = t - +this._y.call(null, g.data), x = m * m + _ * _;
+        if (x < e) {
+          var w = Math.sqrt(e = x);
+          n = s - w, a = t - w, u = s + w, f = t + w, i = g.data;
+        }
+      }
+  return i;
+}
+function Ji(s) {
+  if (isNaN(u = +this._x.call(null, s)) || isNaN(f = +this._y.call(null, s))) return this;
+  var t, e = this._root, i, n, a, o = this._x0, h = this._y0, r = this._x1, l = this._y1, u, f, c, g, v, d, p, y;
+  if (!e) return this;
+  if (e.length) for (; ; ) {
+    if ((v = u >= (c = (o + r) / 2)) ? o = c : r = c, (d = f >= (g = (h + l) / 2)) ? h = g : l = g, t = e, !(e = e[p = d << 1 | v])) return this;
+    if (!e.length) break;
+    (t[p + 1 & 3] || t[p + 2 & 3] || t[p + 3 & 3]) && (i = t, y = p);
+  }
+  for (; e.data !== s; ) if (n = e, !(e = e.next)) return this;
+  return (a = e.next) && delete e.next, n ? (a ? n.next = a : delete n.next, this) : t ? (a ? t[p] = a : delete t[p], (e = t[0] || t[1] || t[2] || t[3]) && e === (t[3] || t[2] || t[1] || t[0]) && !e.length && (i ? i[y] = e : this._root = e), this) : (this._root = a, this);
+}
+function tn(s) {
+  for (var t = 0, e = s.length; t < e; ++t) this.remove(s[t]);
+  return this;
+}
+function en() {
+  return this._root;
+}
+function nn() {
+  var s = 0;
+  return this.visit(function(t) {
+    if (!t.length) do
+      ++s;
+    while (t = t.next);
+  }), s;
+}
+function sn(s) {
+  var t = [], e, i = this._root, n, a, o, h, r;
+  for (i && t.push(new Y(i, this._x0, this._y0, this._x1, this._y1)); e = t.pop(); )
+    if (!s(i = e.node, a = e.x0, o = e.y0, h = e.x1, r = e.y1) && i.length) {
+      var l = (a + h) / 2, u = (o + r) / 2;
+      (n = i[3]) && t.push(new Y(n, l, u, h, r)), (n = i[2]) && t.push(new Y(n, a, u, l, r)), (n = i[1]) && t.push(new Y(n, l, o, h, u)), (n = i[0]) && t.push(new Y(n, a, o, l, u));
+    }
+  return this;
+}
+function rn(s) {
+  var t = [], e = [], i;
+  for (this._root && t.push(new Y(this._root, this._x0, this._y0, this._x1, this._y1)); i = t.pop(); ) {
+    var n = i.node;
+    if (n.length) {
+      var a, o = i.x0, h = i.y0, r = i.x1, l = i.y1, u = (o + r) / 2, f = (h + l) / 2;
+      (a = n[0]) && t.push(new Y(a, o, h, u, f)), (a = n[1]) && t.push(new Y(a, u, h, r, f)), (a = n[2]) && t.push(new Y(a, o, f, u, l)), (a = n[3]) && t.push(new Y(a, u, f, r, l));
+    }
+    e.push(i);
+  }
+  for (; i = e.pop(); )
+    s(i.node, i.x0, i.y0, i.x1, i.y1);
+  return this;
+}
+function an(s) {
+  return s[0];
+}
+function on(s) {
+  return arguments.length ? (this._x = s, this) : this._x;
+}
+function ln(s) {
+  return s[1];
+}
+function hn(s) {
+  return arguments.length ? (this._y = s, this) : this._y;
+}
+function fe(s, t, e) {
+  var i = new ge(t ?? an, e ?? ln, NaN, NaN, NaN, NaN);
+  return s == null ? i : i.addAll(s);
+}
+function ge(s, t, e, i, n, a) {
+  this._x = s, this._y = t, this._x0 = e, this._y0 = i, this._x1 = n, this._y1 = a, this._root = void 0;
+}
+function Re(s) {
+  for (var t = { data: s.data }, e = t; s = s.next; ) e = e.next = { data: s.data };
+  return t;
+}
+var U = fe.prototype = ge.prototype;
+U.copy = function() {
+  var s = new ge(this._x, this._y, this._x0, this._y0, this._x1, this._y1), t = this._root, e, i;
+  if (!t) return s;
+  if (!t.length) return s._root = Re(t), s;
+  for (e = [{ source: t, target: s._root = new Array(4) }]; t = e.pop(); )
+    for (var n = 0; n < 4; ++n)
+      (i = t.source[n]) && (i.length ? e.push({ source: i, target: t.target[n] = new Array(4) }) : t.target[n] = Re(i));
+  return s;
+};
+U.add = ji;
+U.addAll = $i;
+U.cover = Ui;
+U.data = Ki;
+U.extent = Zi;
+U.find = Qi;
+U.remove = Ji;
+U.removeAll = tn;
+U.root = en;
+U.size = nn;
+U.visit = sn;
+U.visitAfter = rn;
+U.x = on;
+U.y = hn;
+function j(s) {
+  return function() {
+    return s;
+  };
+}
+function st(s) {
+  return (s() - 0.5) * 1e-6;
+}
+function cn(s) {
+  return s.x + s.vx;
+}
+function un(s) {
+  return s.y + s.vy;
+}
+function fn(s) {
+  var t, e, i, n = 1, a = 1;
+  typeof s != "function" && (s = j(s == null ? 1 : +s));
+  function o() {
+    for (var l, u = t.length, f, c, g, v, d, p, y = 0; y < a; ++y)
+      for (f = fe(t, cn, un).visitAfter(h), l = 0; l < u; ++l)
+        c = t[l], d = e[c.index], p = d * d, g = c.x + c.vx, v = c.y + c.vy, f.visit(m);
+    function m(_, x, w, k, A) {
+      var N = _.data, C = _.r, b = d + C;
+      if (N) {
+        if (N.index > c.index) {
+          var S = g - N.x - N.vx, W = v - N.y - N.vy, B = S * S + W * W;
+          B < b * b && (S === 0 && (S = st(i), B += S * S), W === 0 && (W = st(i), B += W * W), B = (b - (B = Math.sqrt(B))) / B * n, c.vx += (S *= B) * (b = (C *= C) / (p + C)), c.vy += (W *= B) * b, N.vx -= S * (b = 1 - b), N.vy -= W * b);
+        }
+        return;
+      }
+      return x > g + b || k < g - b || w > v + b || A < v - b;
+    }
+  }
+  function h(l) {
+    if (l.data) return l.r = e[l.data.index];
+    for (var u = l.r = 0; u < 4; ++u)
+      l[u] && l[u].r > l.r && (l.r = l[u].r);
+  }
+  function r() {
+    if (t) {
+      var l, u = t.length, f;
+      for (e = new Array(u), l = 0; l < u; ++l) f = t[l], e[f.index] = +s(f, l, t);
+    }
+  }
+  return o.initialize = function(l, u) {
+    t = l, i = u, r();
+  }, o.iterations = function(l) {
+    return arguments.length ? (a = +l, o) : a;
+  }, o.strength = function(l) {
+    return arguments.length ? (n = +l, o) : n;
+  }, o.radius = function(l) {
+    return arguments.length ? (s = typeof l == "function" ? l : j(+l), r(), o) : s;
+  }, o;
+}
+function gn(s) {
+  return s.index;
+}
+function Te(s, t) {
+  var e = s.get(t);
+  if (!e) throw new Error("node not found: " + t);
+  return e;
+}
+function jt(s) {
+  var t = gn, e = f, i, n = j(30), a, o, h, r, l, u = 1;
+  s == null && (s = []);
+  function f(p) {
+    return 1 / Math.min(h[p.source.index], h[p.target.index]);
+  }
+  function c(p) {
+    for (var y = 0, m = s.length; y < u; ++y)
+      for (var _ = 0, x, w, k, A, N, C, b; _ < m; ++_)
+        x = s[_], w = x.source, k = x.target, A = k.x + k.vx - w.x - w.vx || st(l), N = k.y + k.vy - w.y - w.vy || st(l), C = Math.sqrt(A * A + N * N), C = (C - a[_]) / C * p * i[_], A *= C, N *= C, k.vx -= A * (b = r[_]), k.vy -= N * b, w.vx += A * (b = 1 - b), w.vy += N * b;
+  }
+  function g() {
+    if (o) {
+      var p, y = o.length, m = s.length, _ = new Map(o.map((w, k) => [t(w, k, o), w])), x;
+      for (p = 0, h = new Array(y); p < m; ++p)
+        x = s[p], x.index = p, typeof x.source != "object" && (x.source = Te(_, x.source)), typeof x.target != "object" && (x.target = Te(_, x.target)), h[x.source.index] = (h[x.source.index] || 0) + 1, h[x.target.index] = (h[x.target.index] || 0) + 1;
+      for (p = 0, r = new Array(m); p < m; ++p)
+        x = s[p], r[p] = h[x.source.index] / (h[x.source.index] + h[x.target.index]);
+      i = new Array(m), v(), a = new Array(m), d();
+    }
+  }
+  function v() {
+    if (o)
+      for (var p = 0, y = s.length; p < y; ++p)
+        i[p] = +e(s[p], p, s);
+  }
+  function d() {
+    if (o)
+      for (var p = 0, y = s.length; p < y; ++p)
+        a[p] = +n(s[p], p, s);
+  }
+  return c.initialize = function(p, y) {
+    o = p, l = y, g();
+  }, c.links = function(p) {
+    return arguments.length ? (s = p, g(), c) : s;
+  }, c.id = function(p) {
+    return arguments.length ? (t = p, c) : t;
+  }, c.iterations = function(p) {
+    return arguments.length ? (u = +p, c) : u;
+  }, c.strength = function(p) {
+    return arguments.length ? (e = typeof p == "function" ? p : j(+p), v(), c) : e;
+  }, c.distance = function(p) {
+    return arguments.length ? (n = typeof p == "function" ? p : j(+p), d(), c) : n;
+  }, c;
+}
+const dn = 1664525, pn = 1013904223, ze = 4294967296;
+function vn() {
+  let s = 1;
+  return () => (s = (dn * s + pn) % ze) / ze;
+}
+function yn(s) {
+  return s.x;
+}
+function mn(s) {
+  return s.y;
+}
+var xn = 10, _n = Math.PI * (3 - Math.sqrt(5));
+function wn(s) {
+  var t, e = 1, i = 1e-3, n = 1 - Math.pow(i, 1 / 300), a = 0, o = 0.6, h = /* @__PURE__ */ new Map(), r = Ci(f), l = Ri("tick", "end"), u = vn();
+  s == null && (s = []);
+  function f() {
+    c(), l.call("tick", t), e < i && (r.stop(), l.call("end", t));
+  }
+  function c(d) {
+    var p, y = s.length, m;
+    d === void 0 && (d = 1);
+    for (var _ = 0; _ < d; ++_)
+      for (e += (a - e) * n, h.forEach(function(x) {
+        x(e);
+      }), p = 0; p < y; ++p)
+        m = s[p], m.fx == null ? m.x += m.vx *= o : (m.x = m.fx, m.vx = 0), m.fy == null ? m.y += m.vy *= o : (m.y = m.fy, m.vy = 0);
+    return t;
+  }
+  function g() {
+    for (var d = 0, p = s.length, y; d < p; ++d) {
+      if (y = s[d], y.index = d, y.fx != null && (y.x = y.fx), y.fy != null && (y.y = y.fy), isNaN(y.x) || isNaN(y.y)) {
+        var m = xn * Math.sqrt(0.5 + d), _ = d * _n;
+        y.x = m * Math.cos(_), y.y = m * Math.sin(_);
+      }
+      (isNaN(y.vx) || isNaN(y.vy)) && (y.vx = y.vy = 0);
+    }
+  }
+  function v(d) {
+    return d.initialize && d.initialize(s, u), d;
+  }
+  return g(), t = {
+    tick: c,
+    restart: function() {
+      return r.restart(f), t;
+    },
+    stop: function() {
+      return r.stop(), t;
+    },
+    nodes: function(d) {
+      return arguments.length ? (s = d, g(), h.forEach(v), t) : s;
+    },
+    alpha: function(d) {
+      return arguments.length ? (e = +d, t) : e;
+    },
+    alphaMin: function(d) {
+      return arguments.length ? (i = +d, t) : i;
+    },
+    alphaDecay: function(d) {
+      return arguments.length ? (n = +d, t) : +n;
+    },
+    alphaTarget: function(d) {
+      return arguments.length ? (a = +d, t) : a;
+    },
+    velocityDecay: function(d) {
+      return arguments.length ? (o = 1 - d, t) : 1 - o;
+    },
+    randomSource: function(d) {
+      return arguments.length ? (u = d, h.forEach(v), t) : u;
+    },
+    force: function(d, p) {
+      return arguments.length > 1 ? (p == null ? h.delete(d) : h.set(d, v(p)), t) : h.get(d);
+    },
+    find: function(d, p, y) {
+      var m = 0, _ = s.length, x, w, k, A, N;
+      for (y == null ? y = 1 / 0 : y *= y, m = 0; m < _; ++m)
+        A = s[m], x = d - A.x, w = p - A.y, k = x * x + w * w, k < y && (N = A, y = k);
+      return N;
+    },
+    on: function(d, p) {
+      return arguments.length > 1 ? (l.on(d, p), t) : l.on(d);
+    }
+  };
+}
+function Dn() {
+  var s, t, e, i, n = j(-30), a, o = 1, h = 1 / 0, r = 0.81;
+  function l(g) {
+    var v, d = s.length, p = fe(s, yn, mn).visitAfter(f);
+    for (i = g, v = 0; v < d; ++v) t = s[v], p.visit(c);
+  }
+  function u() {
+    if (s) {
+      var g, v = s.length, d;
+      for (a = new Array(v), g = 0; g < v; ++g) d = s[g], a[d.index] = +n(d, g, s);
+    }
+  }
+  function f(g) {
+    var v = 0, d, p, y = 0, m, _, x;
+    if (g.length) {
+      for (m = _ = x = 0; x < 4; ++x)
+        (d = g[x]) && (p = Math.abs(d.value)) && (v += d.value, y += p, m += p * d.x, _ += p * d.y);
+      g.x = m / y, g.y = _ / y;
+    } else {
+      d = g, d.x = d.data.x, d.y = d.data.y;
+      do
+        v += a[d.data.index];
+      while (d = d.next);
+    }
+    g.value = v;
+  }
+  function c(g, v, d, p) {
+    if (!g.value) return !0;
+    var y = g.x - t.x, m = g.y - t.y, _ = p - v, x = y * y + m * m;
+    if (_ * _ / r < x)
+      return x < h && (y === 0 && (y = st(e), x += y * y), m === 0 && (m = st(e), x += m * m), x < o && (x = Math.sqrt(o * x)), t.vx += y * g.value * i / x, t.vy += m * g.value * i / x), !0;
+    if (g.length || x >= h) return;
+    (g.data !== t || g.next) && (y === 0 && (y = st(e), x += y * y), m === 0 && (m = st(e), x += m * m), x < o && (x = Math.sqrt(o * x)));
+    do
+      g.data !== t && (_ = a[g.data.index] * i / x, t.vx += y * _, t.vy += m * _);
+    while (g = g.next);
+  }
+  return l.initialize = function(g, v) {
+    s = g, e = v, u();
+  }, l.strength = function(g) {
+    return arguments.length ? (n = typeof g == "function" ? g : j(+g), u(), l) : n;
+  }, l.distanceMin = function(g) {
+    return arguments.length ? (o = g * g, l) : Math.sqrt(o);
+  }, l.distanceMax = function(g) {
+    return arguments.length ? (h = g * g, l) : Math.sqrt(h);
+  }, l.theta = function(g) {
+    return arguments.length ? (r = g * g, l) : Math.sqrt(r);
+  }, l;
+}
+function kn(s) {
+  var t = j(0.1), e, i, n;
+  typeof s != "function" && (s = j(s == null ? 0 : +s));
+  function a(h) {
+    for (var r = 0, l = e.length, u; r < l; ++r)
+      u = e[r], u.vx += (n[r] - u.x) * i[r] * h;
+  }
+  function o() {
+    if (e) {
+      var h, r = e.length;
+      for (i = new Array(r), n = new Array(r), h = 0; h < r; ++h)
+        i[h] = isNaN(n[h] = +s(e[h], h, e)) ? 0 : +t(e[h], h, e);
+    }
+  }
+  return a.initialize = function(h) {
+    e = h, o();
+  }, a.strength = function(h) {
+    return arguments.length ? (t = typeof h == "function" ? h : j(+h), o(), a) : t;
+  }, a.x = function(h) {
+    return arguments.length ? (s = typeof h == "function" ? h : j(+h), o(), a) : s;
+  }, a;
+}
+function Nn(s) {
+  var t = j(0.1), e, i, n;
+  typeof s != "function" && (s = j(s == null ? 0 : +s));
+  function a(h) {
+    for (var r = 0, l = e.length, u; r < l; ++r)
+      u = e[r], u.vy += (n[r] - u.y) * i[r] * h;
+  }
+  function o() {
+    if (e) {
+      var h, r = e.length;
+      for (i = new Array(r), n = new Array(r), h = 0; h < r; ++h)
+        i[h] = isNaN(n[h] = +s(e[h], h, e)) ? 0 : +t(e[h], h, e);
+    }
+  }
+  return a.initialize = function(h) {
+    e = h, o();
+  }, a.strength = function(h) {
+    return arguments.length ? (t = typeof h == "function" ? h : j(+h), o(), a) : t;
+  }, a.y = function(h) {
+    return arguments.length ? (s = typeof h == "function" ? h : j(+h), o(), a) : s;
+  }, a;
+}
+class ei extends yi {
+  setupDefaultRules() {
+    super.setupDefaultRules();
+    const t = this._root.interfaceColors, e = this._root.gridLayout, i = this.rule.bind(this);
+    i("Hierarchy").setAll({
+      legendLabelText: "{category}",
+      legendValueText: "{sum.formatNumber('#.#')}",
+      width: Zt,
+      height: Zt,
+      colors: xi.new(this._root, { step: 2 }),
+      downDepth: 1,
+      initialDepth: 5,
+      singleBranchOnly: !0,
+      maskContent: !0,
+      animationEasing: mi(_i)
+    }), i("HierarchyNode").setAll({
+      toggleKey: "disabled",
+      setStateOnChildren: !0,
+      position: "absolute",
+      isMeasured: !1,
+      cursorOverStyle: "pointer",
+      tooltipText: "{category}: {sum}"
+    }), i("HierarchyNode", ["last"]).setAll({
+      cursorOverStyle: "default"
+    });
+    {
+      const n = i("Label", ["hierarchy", "node"]);
+      n.setAll({
+        centerX: O,
+        centerY: O,
+        position: "absolute",
+        paddingBottom: 1,
+        paddingTop: 1,
+        paddingRight: 4,
+        paddingLeft: 4,
+        text: "{category}",
+        populateText: !0,
+        oversizedBehavior: "fit",
+        minScale: 0.3
+      }), V(n, "fill", t, "alternativeText");
+    }
+    {
+      const n = i("HierarchyLink");
+      n.setAll({
+        isMeasured: !1,
+        position: "absolute",
+        strokeWidth: 1,
+        strokeOpacity: 1,
+        strength: 0.9,
+        distance: 1.1
+      }), V(n, "stroke", t, "grid");
+    }
+    i("Circle", ["linkedhierarchy", "shape"]).setAll({
+      position: "absolute",
+      fillOpacity: 1,
+      strokeOpacity: 0,
+      radius: 15,
+      tooltipY: 0
+    }), i("Circle", ["linkedhierarchy", "shape", "outer"]).setAll({
+      position: "absolute",
+      opacity: 1,
+      fillOpacity: 0,
+      strokeDasharray: 0,
+      strokeOpacity: 1,
+      radius: 15,
+      scale: 1.1,
+      interactive: !1
+    }), i("Circle", ["linkedhierarchy", "shape", "outer"]).states.create("disabled", { opacity: 1, scale: 1.1, strokeDasharray: 2 }), i("Circle", ["linkedhierarchy", "shape", "outer"]).states.create("hoverDisabled", { scale: 1.2, opacity: 1, strokeDasharray: 2 }), i("Circle", ["linkedhierarchy", "shape", "outer"]).states.create("hover", { scale: 1.05, strokeDasharray: 0 }), i("Circle", ["linkedhierarchy", "shape", "outer"]).states.create("hidden", { opacity: 0, strokeDasharray: 0 }), i("BreadcrumbBar").setAll({
+      paddingLeft: 8,
+      layout: e
+    });
+    {
+      const n = i("Label", ["breadcrumb"]);
+      n.setAll({
+        paddingRight: 4,
+        paddingLeft: 4,
+        cursorOverStyle: "pointer",
+        populateText: !0,
+        text: "{category}:"
+      }), V(n, "fill", t, "primaryButton");
+    }
+    {
+      const n = i("Label", ["breadcrumb"]).states.create("hover", {});
+      V(n, "fill", t, "primaryButtonHover");
+    }
+    {
+      const n = i("Label", ["breadcrumb"]).states.create("down", { stateAnimationDuration: 0 });
+      V(n, "fill", t, "primaryButtonDown");
+    }
+    {
+      const n = i("Label", ["breadcrumb", "last"]);
+      n.setAll({
+        populateText: !0,
+        text: "{category}",
+        fontWeight: "bold",
+        cursorOverStyle: "default"
+      }), V(n, "fill", t, "primaryButton");
+    }
+    {
+      const n = i("RoundedRectangle", ["breadcrumb", "label", "background"]);
+      n.setAll({
+        fillOpacity: 0
+      }), V(n, "fill", t, "background");
+    }
+    i("Partition").setAll({
+      downDepth: 1,
+      upDepth: 0,
+      initialDepth: 5
+    }), i("HierarchyNode", ["partition"]).setAll({
+      setStateOnChildren: !1
+    }), i("HierarchyNode", ["partition"]).states.create("hidden", {
+      opacity: 1,
+      visible: !0
+    });
+    {
+      const n = i("Label", ["partition", "node"]);
+      n.setAll({
+        x: O,
+        y: O,
+        centerY: O,
+        centerX: O,
+        paddingBottom: 1,
+        paddingTop: 1,
+        paddingLeft: 1,
+        paddingRight: 1,
+        rotation: 90,
+        populateText: !0,
+        text: "{category}",
+        oversizedBehavior: "fit",
+        minScale: 0.4
+      }), V(n, "fill", t, "alternativeText");
+    }
+    i("Label", ["horizontal", "partition", "node"]).setAll({
+      rotation: 0
+    });
+    {
+      const n = i("RoundedRectangle", ["partition", "node", "shape"]);
+      n.setAll({
+        strokeOpacity: 1,
+        strokeWidth: 1,
+        cornerRadiusBR: 0,
+        cornerRadiusTR: 0,
+        cornerRadiusBL: 0,
+        cornerRadiusTL: 0
+      }), V(n, "stroke", t, "background");
+    }
+    i("RoundedRectangle", ["partition", "node", "shape", "last"]).setAll({
+      fillOpacity: 0.75
+    }), i("Sunburst").setAll({
+      singleBranchOnly: !0
+    }), i("HierarchyNode", ["sunburst"]).setAll({
+      setStateOnChildren: !1
+    }), i("HierarchyNode", ["sunburst"]).states.create("hidden", {
+      opacity: 0,
+      visible: !1
+    });
+    {
+      const n = i("Slice", ["sunburst", "node", "shape"]);
+      n.setAll({
+        strokeOpacity: 1,
+        strokeWidth: 1,
+        cornerRadius: 0
+      }), V(n, "stroke", t, "background");
+    }
+    i("Slice", ["sunburst", "node", "shape", "last"]).setAll({
+      fillOpacity: 0.75
+    });
+    {
+      const n = i("RadialLabel", ["sunburst", "node"]);
+      n.setAll({
+        x: 0,
+        y: 0,
+        textType: "radial",
+        paddingBottom: 1,
+        paddingTop: 1,
+        paddingLeft: 1,
+        paddingRight: 1,
+        centerX: O,
+        populateText: !0,
+        text: "{category}",
+        oversizedBehavior: "fit",
+        minScale: 0.4,
+        baseRadius: O,
+        rotation: 0
+      }), V(n, "fill", t, "alternativeText");
+    }
+    i("ForceDirected").setAll({
+      minRadius: qt(1),
+      maxRadius: qt(8),
+      initialFrames: 500,
+      centerStrength: 0.8,
+      manyBodyStrength: -14,
+      velocityDecay: 0.5,
+      linkWithStrength: 0.5,
+      showOnFrame: 10,
+      singleBranchOnly: !1,
+      upDepth: 1 / 0,
+      downDepth: 1,
+      initialDepth: 5,
+      topDepth: 0
+    }), i("Tree").setAll({
+      orientation: "vertical",
+      paddingLeft: 20,
+      paddingRight: 20,
+      paddingTop: 20,
+      paddingBottom: 20,
+      singleBranchOnly: !1,
+      upDepth: 1 / 0,
+      downDepth: 1,
+      initialDepth: 5,
+      topDepth: 0
+    }), i("Pack").setAll({
+      paddingLeft: 20,
+      paddingTop: 20,
+      paddingBottom: 20,
+      paddingRight: 20,
+      nodePadding: 0
+    });
+    {
+      const n = i("Label", ["pack", "node"]);
+      n.setAll({
+        centerY: O,
+        centerX: O,
+        paddingBottom: 1,
+        paddingTop: 1,
+        paddingLeft: 1,
+        paddingRight: 1,
+        populateText: !0,
+        text: "{category}",
+        oversizedBehavior: "fit",
+        minScale: 0.4
+      }), V(n, "fill", t, "alternativeText");
+    }
+    {
+      const n = i("Circle", ["pack", "node", "shape"]);
+      n.setAll({
+        strokeOpacity: 0.5,
+        fillOpacity: 0.8,
+        strokeWidth: 1
+      }), V(n, "stroke", t, "background");
+    }
+    i("LinkedHierarchyNode").setAll({
+      draggable: !0
+    }), i("LinkedHierarchyNode").states.create("hidden", { scale: 0, opacity: 0, visible: !1 }), i("Treemap").setAll({
+      upDepth: 0,
+      layoutAlgorithm: "squarify"
+    });
+    {
+      const n = i("Label", ["treemap", "node"]);
+      n.setAll({
+        x: O,
+        y: O,
+        centerY: O,
+        centerX: O,
+        paddingBottom: 1,
+        paddingTop: 1,
+        paddingLeft: 1,
+        paddingRight: 1,
+        populateText: !0,
+        text: "{category}",
+        oversizedBehavior: "fit",
+        minScale: 0.4
+      }), V(n, "fill", t, "alternativeText");
+    }
+    i("HierarchyNode", ["treemap", "node"]).setAll({
+      tooltipY: qt(40),
+      isMeasured: !1,
+      position: "absolute",
+      cursorOverStyle: "pointer"
+    }), i("HierarchyNode", ["treemap", "node", "last"]).setAll({
+      cursorOverStyle: "default"
+    });
+    {
+      const n = i("RoundedRectangle", ["treemap", "node", "shape"]);
+      n.setAll({
+        strokeOpacity: 1,
+        strokeWidth: 1,
+        cornerRadiusBR: 0,
+        cornerRadiusTR: 0,
+        cornerRadiusBL: 0,
+        cornerRadiusTL: 0,
+        fillOpacity: 1
+      }), V(n, "stroke", t, "background");
+    }
+    i("VoronoiTreemap").setAll({
+      type: "polygon",
+      minWeightRatio: 5e-3,
+      convergenceRatio: 5e-3,
+      maxIterationCount: 100,
+      singleBranchOnly: !0
+    });
+    {
+      const n = i("Graphics", ["voronoitreemap", "node", "shape"]);
+      n.setAll({
+        strokeOpacity: 1,
+        strokeWidth: 1,
+        fillOpacity: 1
+      }), V(n, "stroke", t, "background");
+    }
+    i("Polygon", ["hierarchy", "node", "shape", "depth1"]).setAll({
+      strokeWidth: 3
+    });
+    {
+      const n = i("Label", ["voronoitreemap"]);
+      n.setAll({
+        centerY: O,
+        centerX: O,
+        paddingBottom: 1,
+        paddingTop: 1,
+        paddingLeft: 1,
+        paddingRight: 1,
+        populateText: !0,
+        text: "{category}",
+        oversizedBehavior: "fit",
+        minScale: 0.4,
+        layer: 30
+      }), V(n, "fill", t, "alternativeText");
+    }
+  }
+}
+class ee extends yt {
+  constructor() {
+    super(...arguments), this.labels = this.addDisposer(new Z(K.new({}), () => Ue._new(this._root, {
+      themeTags: G(this.labels.template.get("themeTags", []), ["label"]),
+      background: ce.new(this._root, {
+        themeTags: ["background"]
+      })
+    }, [this.labels.template])));
+  }
+  /**
+   * @ignore
+   */
+  makeLabel(t) {
+    const e = this.labels.make();
+    return e._setDataItem(t), e.states.create("hover", {}), e.states.create("down", {}), e.events.on("click", () => {
+      const i = this.get("series");
+      i && i.selectDataItem(t);
+    }), this.labels.push(e), e;
+  }
+  _afterNew() {
+    this._defaultThemes.push(ei.new(this._root)), this._settings.themeTags = G(this._settings.themeTags, ["breadcrumb"]), super._afterNew();
+  }
+  _changed() {
+    if (super._changed(), this.isDirty("series")) {
+      const t = this.get("series"), e = this._prevSettings.series;
+      t != e ? this._disposer = t.events.on("dataitemselected", (i) => {
+        this._handleDataItem(i.dataItem);
+      }) : e && this._disposer && this._disposer.dispose(), this._handleDataItem(t.get("selectedDataItem"));
+    }
+  }
+  _handleDataItem(t) {
+    if (this.set("minHeight", this.height()), this.children.clear(), this.labels.clear(), t) {
+      let e = t;
+      for (; e; ) {
+        let i = this.makeLabel(e);
+        e == t && i.addTag("last"), this.children.moveValue(i, 0), e = e.get("parent");
+      }
+    }
+  }
+}
+ee.className = "BreadcrumbBar";
+ee.classNames = yt.classNames.concat([ee.className]);
+class dt extends yt {
+  _afterNew() {
+    super._afterNew(), this.states.create("disabled", {}), this.states.create("hover", {}), this.states.create("hoverDisabled", {}), this.on("disabled", () => {
+      const t = this.dataItem;
+      if (!t.get("children")) {
+        this.set("disabled", !0);
+        return;
+      }
+      const e = this.get("disabled"), i = this.series;
+      t && i && t.get("disabled") != e && (e ? i.disableDataItem(t) : i.enableDataItem(t, i.get("downDepth", 1), 0));
+    });
+  }
+  _changed() {
+    super._changed(), this.isDirty("toggleKey") && (this.get("toggleKey") == "disabled" ? this._clickDisposer = this.events.on("click", () => {
+      if (!this._isDragging) {
+        let e = this.series;
+        e && e.selectDataItem(this.dataItem);
+      }
+    }) : this._clickDisposer && this._clickDisposer.dispose());
+  }
+}
+dt.className = "HierarchyNode";
+dt.classNames = yt.classNames.concat([dt.className]);
+class Q extends Ke {
+  constructor() {
+    super(...arguments), this.nodesContainer = this.children.push(yt.new(this._root, { isMeasured: !1 })), this._index = 0, this._tag = "hierarchy", this.nodes = this.addDisposer(new Z(K.new({}), () => dt.new(this._root, {
+      themeTags: G(this.nodes.template.get("themeTags", []), [this._tag, "hierarchy", "node"])
+    }, this.nodes.template))), this.labels = this.addDisposer(new Z(K.new({}), () => Ue.new(this._root, {
+      themeTags: G(this.labels.template.get("themeTags", []), [this._tag])
+    }, this.labels.template)));
+  }
+  _applyThemes(t = !1) {
+    const e = this.get("colors");
+    return e && e.reset(), super._applyThemes(t);
+  }
+  /**
+   * @ignore
+   */
+  makeNode(t) {
+    const e = t.get("childData"), i = this.nodes.make();
+    i.series = this, i._setDataItem(t), this.nodes.push(i), t.setRaw("node", i);
+    const n = this.labels.make();
+    n._setDataItem(t), t.setRaw("label", n), this.labels.push(n), (!e || e.length == 0) && i.addTag("last");
+    const a = t.get("depth");
+    return i.addTag("depth" + a), this.nodesContainer.children.push(i), i.children.push(n), i;
+  }
+  _afterNew() {
+    this._defaultThemes.push(ei.new(this._root)), this.fields.push("category", "childData", "disabled", "fill"), this.children.push(this.bulletsContainer), super._afterNew();
+  }
+  _prepareChildren() {
+    if (super._prepareChildren(), this._valuesDirty) {
+      this._treeData = {};
+      const t = this.dataItems[0];
+      if (t && (this._makeHierarchyData(this._treeData, t), this._index = 0, this._rootNode = Pi(this._treeData), this._rootNode)) {
+        this._rootNode.sum((i) => i.value);
+        const e = this.get("sort");
+        e == "descending" ? this._rootNode.sort((i, n) => n.value - i.value) : e == "ascending" && this._rootNode.sort((i, n) => i.value - n.value), this.setPrivateRaw("valueLow", 1 / 0), this.setPrivateRaw("valueHigh", -1 / 0), this.setPrivateRaw("maxDepth", 0), this._updateValues(this._rootNode);
+      }
+    }
+    if ((this._valuesDirty || this._sizeDirty) && this._updateVisuals(), this._sizeDirty) {
+      const t = this.get("selectedDataItem");
+      t && this._zoom(t);
+    }
+  }
+  _changed() {
+    super._changed(), this.isDirty("selectedDataItem") && this._selectDataItem(this.get("selectedDataItem"));
+  }
+  _updateVisuals() {
+    this._rootNode && this._updateNodes(this._rootNode);
+  }
+  _updateNodes(t) {
+    const e = t.data.dataItem;
+    if (e) {
+      this._updateNode(e), this.bullets.length > 0 && !e.bullets && this._makeBullets(e);
+      const i = t.children;
+      i && P(i, (n) => {
+        this._updateNodes(n);
+      });
+    }
+  }
+  _updateNode(t) {
+  }
+  /**
+   * Looks up and returns a data item by its ID.
+   *
+   * @param   id  ID
+   * @return      Data item
+   */
+  getDataItemById(t) {
+    return this._getDataItemById(this.dataItems, t);
+  }
+  _getDataItemById(t, e) {
+    let i;
+    return P(t, (n) => {
+      n.get("id") == e && (i = n);
+      const a = n.get("children");
+      if (a) {
+        let o = this._getDataItemById(a, e);
+        o && (i = o);
+      }
+    }), i;
+  }
+  _handleBullets(t) {
+    P(t, (e) => {
+      const i = e.bullets;
+      i && (P(i, (a) => {
+        a.dispose();
+      }), e.bullets = void 0);
+      const n = e.get("children");
+      n && this._handleBullets(n);
+    }), this._updateVisuals();
+  }
+  _onDataClear() {
+    super._onDataClear();
+    const t = this.get("colors");
+    t && t.reset();
+    const e = this.get("patterns");
+    e && e.reset();
+  }
+  processDataItem(t) {
+    super.processDataItem(t);
+    const e = t.get("childData"), i = this.get("colors"), n = this.get("patterns"), a = this.get("topDepth", 0);
+    t.get("parent") || (t.setRaw("depth", 0), i && a == 0 && t.get("fill") == null && (t.setRaw("fill", i.next()), n && t.setRaw("fillPattern", n.next())));
+    let o = t.get("depth");
+    const h = this.get("initialDepth", 1);
+    if (this.makeNode(t), this._processDataItem(t), e) {
+      const l = [];
+      t.setRaw("children", l), P(e, (u) => {
+        const f = new ke(this, u, this._makeDataItem(u));
+        l.push(f), f.setRaw("parent", t), f.setRaw("depth", o + 1), this.dataItems.length == 1 && o == 0 ? (i && f.get("fill") == null && f.setRaw("fill", i.next()), n && f.get("fillPattern") == null && f.setRaw("fillPattern", n.next())) : (f.get("fill") == null && f.setRaw("fill", t.get("fill")), f.get("fillPattern") == null && f.setRaw("fillPattern", t.get("fillPattern"))), this.processDataItem(f);
+      });
+    }
+    const r = t.get("children");
+    (!r || r.length == 0) && t.get("node").setAll({ toggleKey: void 0 }), t.get("disabled") == null && o >= a + h && this.disableDataItem(t, 0);
+  }
+  /**
+   * Adds children data to the target data item.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/charts/hierarchy/hierarchy-api/#Dynamically_adding_child_nodes} for more info
+   * @since 5.4.5
+   */
+  addChildData(t, e) {
+    const i = t.dataContext, n = this.get("childDataField");
+    let a = i[n];
+    a ? a.push(...e) : (a = e, i[n] = a);
+    let o = t.get("children");
+    o || (o = [], t.set("children", o));
+    const h = t.get("node");
+    h && h.set("toggleKey", this.nodes.template.get("toggleKey", "disabled"));
+    let r = t.get("depth");
+    P(a, (l) => {
+      let u = !1;
+      if (wi(o, (f) => f.dataContext == l ? (u = !0, !1) : !0), !u) {
+        const f = new ke(this, l, this._makeDataItem(l));
+        if (o.push(f), f.setRaw("parent", t), f.setRaw("depth", r + 1), f.get("fill") == null) {
+          let c = t.get("fill");
+          if (c == null) {
+            const g = this.get("colors");
+            g && (c = g.next());
+          }
+          f.setRaw("fill", c);
+        }
+        this.processDataItem(f);
+      }
+    });
+  }
+  _processDataItem(t) {
+  }
+  _updateValues(t) {
+    const e = t.data.dataItem;
+    if (t.depth > this.getPrivate("maxDepth") && this.setPrivateRaw("maxDepth", t.depth), e) {
+      e.setRaw("d3HierarchyNode", t), t.index = this._index, this._index++, this.root.events.once("frameended", () => {
+        e.get("node").set("disabled", e.get("disabled"));
+      });
+      let n = t.data.value, a = t.value;
+      if (n != null && (a = n, t.value = a), X(a)) {
+        e.setRaw("sum", a), e.setRaw("valuePercentTotal", a / this.dataItems[0].get("sum") * 100);
+        let o = 100;
+        const h = e.get("parent");
+        h && (o = a / h.get("sum") * 100), e.get("label").text.markDirtyText(), e.setRaw("valuePercent", o);
+        const r = this.getPrivate("valueLow");
+        r != null && r > a && this.setPrivateRaw("valueLow", a);
+        const l = this.getPrivate("valueHigh");
+        l != null && l < a && this.setPrivateRaw("valueHigh", a);
+      }
+      this.updateLegendValue(e);
+    }
+    const i = t.children;
+    i && P(i, (n) => {
+      this._updateValues(n);
+    });
+  }
+  _makeHierarchyData(t, e) {
+    t.dataItem = e;
+    const i = e.get("children");
+    if (i) {
+      const n = [];
+      t.children = n, P(i, (o) => {
+        const h = {};
+        n.push(h), this._makeHierarchyData(h, o);
+      });
+      const a = e.get("valueWorking");
+      X(a) && (t.value = a);
+    } else {
+      const n = e.get("valueWorking");
+      X(n) && (t.value = n);
+    }
+  }
+  /**
+   * @ignore
+   */
+  disposeDataItem(t) {
+    super.disposeDataItem(t);
+    const e = t.get("node");
+    e && (this.nodes.removeValue(e), e.dispose());
+    const i = t.get("label");
+    i && (this.labels.removeValue(i), i.dispose());
+    const n = t.get("children");
+    n && P(n, (a) => {
+      this.disposeDataItem(a);
+    });
+  }
+  /**
+   * Hides hierarchy's data item.
+   *
+   * @param   dataItem  Data item
+   * @param   duration  Animation duration in milliseconds
+   * @return            Promise
+   */
+  hideDataItem(t, e) {
+    const i = Object.create(null, {
+      hideDataItem: { get: () => super.hideDataItem }
+    });
+    return Ne(this, void 0, void 0, function* () {
+      const n = [i.hideDataItem.call(this, t, e)], a = this.states.create("hidden", {});
+      if (!X(e)) {
+        const u = "stateAnimationDuration";
+        e = a.get(u, this.get(u, 0));
+      }
+      const o = "stateAnimationEasing", h = a.get(o, this.get(o)), r = t.get("children");
+      (!r || r.length == 0) && X(t.get("value")) && n.push(t.animate({ key: "valueWorking", to: 0, duration: e, easing: h }).waitForStop());
+      const l = t.get("node");
+      l.hide(), l.hideTooltip(), r && P(r, (u) => {
+        n.push(this.hideDataItem(u));
+      }), yield Promise.all(n);
+    });
+  }
+  /**
+   * Shows hierarchy's data item.
+   *
+   * @param   dataItem  Data item
+   * @param   duration  Animation duration in milliseconds
+   * @return            Promise
+   */
+  showDataItem(t, e) {
+    const i = Object.create(null, {
+      showDataItem: { get: () => super.showDataItem }
+    });
+    return Ne(this, void 0, void 0, function* () {
+      const n = [i.showDataItem.call(this, t, e)];
+      X(e) || (e = this.get("stateAnimationDuration", 0));
+      const a = this.get("stateAnimationEasing"), o = t.get("children");
+      (!o || o.length == 0) && X(t.get("value")) && n.push(t.animate({ key: "valueWorking", to: t.get("value"), duration: e, easing: a }).waitForStop()), t.get("node").show(), o && P(o, (r) => {
+        n.push(this.showDataItem(r));
+      }), yield Promise.all(n);
+    });
+  }
+  /**
+   * Enables a disabled data item.
+   *
+   * @param  dataItem  Target data item
+   * @param  duration  Animation duration in milliseconds
+   */
+  enableDataItem(t, e, i, n) {
+    i == null && (i = 0), e == null && (e = 1), t.set("disabled", !1), t.get("node").set("disabled", !1), t.isHidden() || t.get("node").show(n);
+    const a = this.get("topDepth", 0);
+    if (t.get("depth") < a && t.get("node").hide(0), i == 0) {
+      const h = this.get("upDepth", 1 / 0);
+      let r = t, l = 0;
+      for (; r !== void 0; )
+        l > h && r.get("node").hide(), r = r.get("parent"), l++;
+    }
+    let o = t.get("children");
+    o && (i < e - 1 ? P(o, (h) => {
+      const r = this.get("disabledField");
+      r ? h.dataContext[r] != !0 ? this.enableDataItem(h, e, i + 1, n) : this.disableDataItem(h) : this.enableDataItem(h, e, i + 1, n);
+    }) : P(o, (h) => {
+      h.isHidden() || (h.get("node").show(n), h.get("node").states.applyAnimate("disabled"), h.set("disabled", !0), this.disableDataItem(h));
+    }));
+  }
+  /**
+   * Disables a data item.
+   *
+   * @param  dataItem  Target data item
+   * @param  duration  Animation duration in milliseconds
+   */
+  disableDataItem(t, e) {
+    t.set("disabled", !0);
+    let i = t.get("children");
+    i && P(i, (n) => {
+      this.disableDataItem(n, e), n.get("node").hide(e);
+    });
+  }
+  _selectDataItem(t, e, i) {
+    if (t) {
+      if (!i) {
+        const l = "dataitemselected";
+        this.events.dispatch(l, { type: l, target: this, dataItem: t });
+      }
+      let n = this.getPrivate("maxDepth", 1);
+      const a = this.get("topDepth", 0);
+      e == null && (e = Math.min(this.get("downDepth", 1), n - t.get("depth")));
+      const o = t.get("d3HierarchyNode");
+      let h = o.depth;
+      this.inited || (e = Math.min(this.get("initialDepth", 1), n - a), e = Math.max(0, e)), this._currentDownDepth = e, h + e > n && (e = n - h), h < a && (e += a - h, h = a);
+      const r = t.get("children");
+      r && r.length > 0 ? (e > 0 ? this.enableDataItem(t, e) : (t.get("node").show(), P(r, (l) => {
+        l.get("node").hide();
+      })), o.depth < a && t.get("node").hide(0), this.get("singleBranchOnly") && this._handleSingle(t)) : this.enableDataItem(t, e), this._root.events.once("frameended", () => {
+        this._zoom(t);
+      });
+    }
+  }
+  _zoom(t) {
+  }
+  _handleSingle(t) {
+    const e = t.get("parent");
+    if (e) {
+      const i = e.get("children");
+      i && P(i, (n) => {
+        n != t && this.disableDataItem(n);
+      });
+    }
+  }
+  /**
+   * Selects specific data item.
+   *
+   * @param  dataItem  Target data item
+   */
+  selectDataItem(t) {
+    const e = t.get("parent"), i = this.getPrivate("maxDepth", 1);
+    if (this.get("selectedDataItem") == t)
+      if (e)
+        this.set("selectedDataItem", e);
+      else {
+        let n = Math.min(this.get("downDepth", 1), i - t.get("depth"));
+        this._currentDownDepth == n && (n = Math.min(this.get("initialDepth", 1), i - this.get("topDepth", 0))), this._selectDataItem(t, n);
+      }
+    else
+      this.set("selectedDataItem", t);
+  }
+  _makeBullet(t, e, i) {
+    const n = super._makeBullet(t, e, i);
+    if (n) {
+      const a = n.get("sprite"), o = t.get("node");
+      a && (o.children.push(a), o.on("width", () => {
+        this._positionBullet(n);
+      }), o.on("height", () => {
+        this._positionBullet(n);
+      }));
+    }
+    return n;
+  }
+  _positionBullet(t) {
+    const e = t.get("sprite");
+    if (e) {
+      const i = e.dataItem, n = t.get("locationX", 0.5), a = t.get("locationY", 0.5), o = i.get("node");
+      e.set("x", o.width() * n), e.set("y", o.height() * a);
+    }
+  }
+  /**
+   * Triggers hover on a series data item.
+   *
+   * @since 5.0.7
+   * @param  dataItem  Target data item
+   */
+  hoverDataItem(t) {
+    const e = t.get("node");
+    e && !e.isHidden() && e.hover();
+  }
+  /**
+   * Triggers un-hover on a series data item.
+   *
+   * @since 5.0.7
+   * @param  dataItem  Target data item
+   */
+  unhoverDataItem(t) {
+    const e = t.get("node");
+    e && e.unhover();
+  }
+}
+Q.className = "Hierarchy";
+Q.classNames = Ke.classNames.concat([Q.className]);
+class It extends dt {
+  _afterNew() {
+    super._afterNew(), this.states.create("disabled", {}), this.states.create("hover", {}), this.states.create("hoverDisabled", {});
+  }
+  _updateLinks(t) {
+    const e = this.dataItem;
+    if (e) {
+      let i = e.get("links");
+      P(i, (n) => {
+        let a = n.get("source"), o = n.get("target");
+        a && o && (a.get("node").isHidden() || o.get("node").isHidden() ? n.hide(t) : n.show(t));
+      });
+    }
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this.isDirty("disabled") && this._updateLinks();
+  }
+  _onHide(t) {
+    super._onHide(t), this._updateLinks(t);
+  }
+  _onShow(t) {
+    super._onShow(t), this._updateLinks(t);
+  }
+}
+It.className = "LinkedHierarchyNode";
+It.classNames = dt.classNames.concat([It.className]);
+class Bt extends Ze {
+  constructor() {
+    super(...arguments), this.bullets = [];
+  }
+  _handleBullets(t) {
+    P(this.bullets, (e) => {
+      e.dispose();
+    }), t.each((e) => {
+      const i = e(this._root, this.get("source"), this.get("target"));
+      if (i) {
+        this.bullets.push(i);
+        const n = i.get("sprite");
+        if (this.addDisposer(i.on("locationX", () => {
+          this._clear = !0, this.markDirty();
+        })), n) {
+          const a = this.series;
+          a && a.linksContainer.children.push(n);
+        }
+      }
+    });
+  }
+  _changed() {
+    var t, e;
+    if (super._changed(), this._clear) {
+      let i = this.get("source"), n = this.get("target");
+      if (i && n) {
+        const a = i.get("node"), o = n.get("node"), h = a.x(), r = a.y(), l = o.x(), u = o.y();
+        this._display.moveTo(h, r), this._display.lineTo(l, u);
+        const f = (t = a.dataItem) === null || t === void 0 ? void 0 : t.get("outerCircle").get("radius", 0), c = (e = o.dataItem) === null || e === void 0 ? void 0 : e.get("outerCircle").get("radius", 0), g = Math.hypot(l - h, u - r), v = g - f - c;
+        P(this.bullets, (d) => {
+          const p = d.get("sprite");
+          if (p) {
+            const y = d.get("locationX", 0.5);
+            p.set("x", h + f / g * (l - h) + v / g * (l - h) * y), p.set("y", r + f / g * (u - r) + v / g * (u - r) * y), d.get("autoRotate") && p.set("rotation", Math.atan2(u - r, l - h) * 180 / Math.PI + d.get("autoRotateAngle", 0));
+          }
+        });
+      }
+    }
+  }
+  hide(t) {
+    return P(this.bullets, (e) => {
+      if (e) {
+        const i = e.get("sprite");
+        i && i.hide(t);
+      }
+    }), super.hide();
+  }
+  show(t) {
+    return P(this.bullets, (e) => {
+      if (e) {
+        const i = e.get("sprite");
+        i && i.show(t);
+      }
+    }), super.show();
+  }
+  _beforeChanged() {
+    if (super._beforeChanged(), this.isDirty("source")) {
+      const t = this.get("source");
+      t && t.get("node").events.on("positionchanged", () => {
+        this._markDirtyKey("stroke");
+      });
+    }
+    if (this.isDirty("target")) {
+      const t = this.get("target");
+      t && t.get("node").events.on("positionchanged", () => {
+        this._markDirtyKey("stroke");
+      });
+    }
+  }
+  _dispose() {
+    super._dispose(), P(this.bullets, (t) => {
+      t.dispose();
+    }), this.bullets = [];
+  }
+}
+Bt.className = "HierarchyLink";
+Bt.classNames = Ze.classNames.concat([Bt.className]);
+class lt extends Q {
+  constructor() {
+    super(...arguments), this.linkBullets = new Di(), this.nodes = this.addDisposer(new Z(K.new({}), () => It._new(this._root, {
+      themeTags: G(this.nodes.template.get("themeTags", []), [this._tag, "linkedhierarchy", "hierarchy", "node"]),
+      x: this.width() / 2,
+      y: this.height() / 2
+    }, [this.nodes.template]))), this.circles = this.addDisposer(new Z(K.new({}), () => Jt._new(this._root, {
+      themeTags: G(this.circles.template.get("themeTags", []), [this._tag, "shape"])
+    }, [this.circles.template]))), this.outerCircles = this.addDisposer(new Z(K.new({}), () => Jt._new(this._root, {
+      themeTags: G(this.outerCircles.template.get("themeTags", []), [this._tag, "outer", "shape"])
+    }, [this.outerCircles.template]))), this.links = this.addDisposer(new Z(K.new({}), () => Bt._new(this._root, {
+      themeTags: G(this.links.template.get("themeTags", []), [this._tag, "linkedhierarchy", "hierarchy", "link"])
+    }, [this.links.template]))), this.linksContainer = this.children.moveValue(yt.new(this._root, {}), 0);
+  }
+  _afterNew() {
+    this.fields.push("linkWith", "x", "y"), this._disposers.push(this.linkBullets.events.onAll(() => {
+      this.links.each((t) => {
+        t._handleBullets(this.linkBullets);
+      });
+    })), super._afterNew();
+  }
+  /**
+   * @ignore
+   */
+  makeNode(t) {
+    const e = super.makeNode(t), i = e.children.moveValue(this.circles.make(), 0);
+    this.circles.push(i), e.setPrivate("tooltipTarget", i), t.setRaw("circle", i);
+    const n = e.children.moveValue(this.outerCircles.make(), 0);
+    this.outerCircles.push(n), t.setRaw("outerCircle", n);
+    const a = t.get("label");
+    i.on("radius", () => {
+      const h = i.get("radius", this.width()) * 2;
+      a.setAll({ maxWidth: h, maxHeight: h }), n.set("radius", h / 2), this._handleRadiusChange();
+    });
+    const o = i.get("radius", this.width()) * 2;
+    return a.setAll({ maxWidth: o, maxHeight: o }), i._setDataItem(t), n._setDataItem(t), e;
+  }
+  _handleRadiusChange() {
+  }
+  processDataItem(t) {
+    t.setRaw("childLinks", []), t.setRaw("links", []), super.processDataItem(t);
+  }
+  _processDataItem(t) {
+    super._processDataItem(t);
+    const e = t.get("parent");
+    if (e && e.get("depth") >= this.get("topDepth")) {
+      const n = this.linkDataItems(e, t);
+      t.setRaw("parentLink", n);
+    }
+    const i = t.get("node");
+    this.updateLinkWith(this.dataItems), i._updateLinks(0);
+  }
+  /**
+   * @ignore
+   */
+  updateLinkWith(t) {
+    P(t, (e) => {
+      const i = e.get("linkWith");
+      i && P(i, (a) => {
+        const o = this._getDataItemById(this.dataItems, a);
+        o && this.linkDataItems(e, o);
+      });
+      const n = e.get("children");
+      n && this.updateLinkWith(n);
+    });
+  }
+  _getPoint(t) {
+    return { x: t.x, y: t.y };
+  }
+  _animatePositions(t) {
+    const e = t.get("node"), i = t.get("d3HierarchyNode"), n = this._getPoint(i), a = this.get("animationDuration", 0), o = this.get("animationEasing");
+    e.animate({ key: "x", to: n.x, duration: a, easing: o }), e.animate({ key: "y", to: n.y, duration: a, easing: o });
+  }
+  _updateNode(t) {
+    super._updateNode(t), this._animatePositions(t);
+    const i = t.get("d3HierarchyNode").children;
+    i && P(i, (l) => {
+      this._updateNodes(l);
+    });
+    const n = t.get("fill"), a = t.get("fillPattern"), o = t.get("circle"), h = t.get("children");
+    o && (o._setDefault("fill", n), o._setDefault("fillPattern", a), o._setDefault("stroke", n));
+    const r = t.get("outerCircle");
+    r && (r._setDefault("fill", n), r._setDefault("stroke", n), !h || h.length == 0 ? r.setPrivate("visible", !1) : r.setPrivate("visible", !0));
+  }
+  /**
+   * Link two data items with a link element.
+   *
+   * @param   source    Source node data item
+   * @param   target    Target node data item
+   * @param   strength  Link strength
+   * @return            Link element
+   */
+  linkDataItems(t, e, i) {
+    let n;
+    const a = t.get("links");
+    a && P(a, (h) => {
+      h.get("target") == e && (n = h);
+    });
+    const o = e.get("links");
+    return o && P(o, (h) => {
+      h.get("target") == t && (n = h);
+    }), n || (n = this.links.make(), n.series = this, this.links.push(n), this.linksContainer.children.push(n), n.set("source", t), n.set("target", e), n._setDataItem(t), n._handleBullets(this.linkBullets), n.set("stroke", t.get("fill")), i != null && n.set("strength", i), t.get("childLinks").push(n), be(t.get("links"), n), be(e.get("links"), n), this._processLink(n, t, e)), n;
+  }
+  /**
+   * Unlink two linked data items.
+   *
+   * @param   source  Source node data item
+   * @param   target  Target node data item
+   */
+  unlinkDataItems(t, e) {
+    let i;
+    const n = t.get("links");
+    n && P(n, (o) => {
+      o && o.get("target") == e && (i = o, Qt(n, i));
+    });
+    const a = e.get("links");
+    a && P(a, (o) => {
+      o && o.get("target") == t && (i = o, Qt(a, i));
+    }), i && this._disposeLink(i), this._handleUnlink();
+  }
+  _handleUnlink() {
+  }
+  _disposeLink(t) {
+    this.links.removeValue(t), t.dispose();
+  }
+  /**
+   * Returns `true` if two nodes are linked with each other.
+   */
+  areLinked(t, e) {
+    const i = t.get("links");
+    let n = !1;
+    i && P(i, (o) => {
+      o.get("target") == e && (n = !0);
+    });
+    const a = e.get("links");
+    return a && P(a, (o) => {
+      o.get("target") == t && (n = !0);
+    }), n;
+  }
+  _processLink(t, e, i) {
+  }
+  /**
+   * @ignore
+   */
+  disposeDataItem(t) {
+    super.disposeDataItem(t);
+    const e = t.get("links");
+    e && P(e, (i) => {
+      this._disposeLink(i);
+    });
+  }
+  /**
+   * Select a data item.
+   * @param  dataItem  Data item
+   */
+  selectDataItem(t) {
+    const e = t.get("parent");
+    if (!t.get("disabled"))
+      this.set("selectedDataItem", t);
+    else if (e) {
+      this.setRaw("selectedDataItem", e);
+      const i = "dataitemselected";
+      this.events.dispatch(i, { type: i, target: this, dataItem: e }), this.disableDataItem(t);
+    }
+  }
+}
+lt.className = "LinkedHierarchy";
+lt.classNames = Q.classNames.concat([lt.className]);
+class ie extends lt {
+  constructor() {
+    super(...arguments), this._tag = "forcedirected", this.d3forceSimulation = wn(), this.collisionForce = fn(20), this.linkForce = jt(), this._nodes = [], this._links = [], this._tick = 0, this._nodesDirty = !1;
+  }
+  _afterNew() {
+    super._afterNew(), this.d3forceSimulation.on("tick", () => {
+      this._tick++, this.updateNodePositions();
+    });
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this.isDirty("showOnFrame") && this.get("showOnFrame") > this._tick && (this.nodesContainer.setPrivate("visible", !1), this.linksContainer.setPrivate("visible", !1));
+    const t = this.d3forceSimulation;
+    this.isDirty("velocityDecay") && t.velocityDecay(this.get("velocityDecay", 0)), this.isDirty("initialFrames") && t.alphaDecay(1 - Math.pow(1e-3, 1 / this.get("initialFrames", 500)));
+  }
+  /**
+   * @ignore
+   */
+  restartSimulation(t) {
+    const e = this.d3forceSimulation;
+    e.alpha() < 0.25 && (e.alpha(t), e.restart());
+  }
+  _handleRadiusChange() {
+    this._updateForces();
+  }
+  processDataItem(t) {
+    const e = { index: this._index, x: this.innerWidth() / 2, y: this.innerHeight() / 2, dataItem: t }, i = this._nodes.push(e) - 1;
+    e.index = i, this.d3forceSimulation.nodes(this._nodes), t.set("d3ForceNode", e), super.processDataItem(t);
+    const n = t.get("node");
+    n.set("x", -1e4), n.on("scale", () => {
+      this._updateForces();
+    }), n.events.on("dragged", () => {
+      e.fx = n.x(), e.fy = n.y(), this._updateForces();
+    }), n.events.on("dragstop", () => {
+      t.get("x") == null && (e.fx = void 0), t.get("y") == null && (e.fy = void 0);
+    });
+  }
+  _updateValues(t) {
+    super._updateValues(t), this._nodesDirty = !0;
+    const e = this.d3forceSimulation;
+    e.force("collision", this.collisionForce), e.nodes(this._nodes), this.linkForce = jt(this._links), e.force("link", this.linkForce);
+  }
+  _updateVisuals() {
+    super._updateVisuals(), this.restartSimulation(0.3);
+  }
+  _updateChildren() {
+    super._updateChildren();
+    const t = this.d3forceSimulation;
+    if (this._sizeDirty) {
+      let e = Math.max(50, this.innerWidth()), i = Math.max(50, this.innerHeight()), n = this.get("paddingTop", 0), a = this.get("paddingLeft", 0), o = this.get("centerStrength", 1);
+      t.force("x", kn().x(e / 2 + a).strength(o * 100 / e)), t.force("y", Nn().y(i / 2 + n).strength(o * 100 / i));
+    }
+    this._nodesDirty && this._updateForces();
+  }
+  _updateForces() {
+    this.d3forceSimulation.force("manybody", Dn().strength((e) => {
+      let i = e.dataItem, n = i.get("node"), a = i.get("circle"), o = this.get("manyBodyStrength", -15);
+      return a ? a.get("radius", 1) * n.get("scale", 1) * o : 0;
+    })), this.collisionForce.radius((e) => {
+      let i = e.dataItem, n = i.get("node"), a = i.get("circle"), o = i.get("outerCircle");
+      if (a && o) {
+        let h = a.get("radius", 1);
+        return o.isHidden() || (h = h * o.get("scale", 1.1)), h *= n.get("scale", 1), h + this.get("nodePadding", 0);
+      }
+    }), this.restartSimulation(0.3);
+  }
+  _animatePositions(t) {
+  }
+  _clearDirty() {
+    super._clearDirty(), this._nodesDirty = !1;
+  }
+  /**
+   * @ignore
+   */
+  updateNodePositions() {
+    const t = this.linkForce;
+    t && (t.distance((i) => this.getDistance(i)), t.strength((i) => this.getStrength(i))), this._tick == this.get("showOnFrame") && (this.nodesContainer.setPrivate("visible", !0), this.linksContainer.setPrivate("visible", !0));
+    let e = this.d3forceSimulation.nodes();
+    P(e, (i) => {
+      const a = i.dataItem.get("node");
+      a.set("x", i.x), a.set("y", i.y);
+    });
+  }
+  /**
+   * @ignore
+   */
+  updateLinkWith(t) {
+    P(t, (e) => {
+      const i = e.get("linkWith");
+      i && P(i, (a) => {
+        const o = this._getDataItemById(this.dataItems, a);
+        o && this.linkDataItems(e, o, this.get("linkWithStrength"));
+      });
+      const n = e.get("children");
+      n && this.updateLinkWith(n);
+    });
+  }
+  /**
+   * @ignore
+   */
+  getDistance(t) {
+    let e = t.sourceDataItem, i = t.targetDataItem, n = 0;
+    if (e && i) {
+      const a = i.get("node");
+      if (a.isHidden())
+        return 0;
+      let o = t.link;
+      o && (n = o.get("distance", 1));
+      const h = e.get("node");
+      return a.isHidden() && (n = 1), n * (e.get("circle").get("radius", 1) * h.get("scale", 1) + i.get("circle").get("radius", 1) * a.get("scale", 1));
+    }
+    return n;
+  }
+  /**
+   * @ignore
+   */
+  getStrength(t) {
+    let e = 0, i = t.link;
+    i && (e = i.get("strength", 1));
+    const n = t.targetDataItem;
+    return e *= n.get("node").get("scale"), e;
+  }
+  _updateNode(t) {
+    super._updateNode(t), this._updateRadius(t);
+    const e = t.get("x"), i = t.get("y"), n = t.get("d3ForceNode");
+    e != null ? n.fx = ut(e, this.innerWidth()) : n.fx = void 0, i != null ? n.fy = ut(i, this.innerHeight()) : n.fx = void 0;
+  }
+  _updateRadius(t) {
+    let e = (this.innerWidth() + this.innerHeight()) / 2, i = ut(this.get("minRadius", 1), e), n = ut(this.get("maxRadius", 5), e), a = t.get("sum"), o = n;
+    const h = this.getPrivate("valueLow", 0), r = this.getPrivate("valueHigh", 0);
+    r > 0 && (o = i + (a - h) / (r - h) * (n - i)), X(o) || (o = i);
+    const l = this.get("animationDuration", 0), u = this.get("animationEasing");
+    t.get("circle").animate({ key: "radius", to: o, duration: l, easing: u });
+  }
+  _processLink(t, e, i) {
+    const n = { link: t, source: e.get("d3ForceNode").index, target: i.get("d3ForceNode").index, sourceDataItem: e, targetDataItem: i };
+    this._links.push(n), t.setPrivate("d3Link", n), this.linkForce = jt(this._links), this.d3forceSimulation.force("link", this.linkForce), this.restartSimulation(0.5);
+  }
+  _disposeLink(t) {
+    super._disposeLink(t), Qt(this._links, t.getPrivate("d3Link"));
+  }
+  _handleUnlink() {
+    this.restartSimulation(0.5);
+  }
+  _onDataClear() {
+    super._onDataClear(), this._nodes = [], this._links = [];
+  }
+}
+ie.className = "ForceDirected";
+ie.classNames = lt.classNames.concat([ie.className]);
+class ne extends Q {
+  constructor() {
+    super(...arguments), this._tag = "pack", this._packLayout = Ti(), this.circles = this.addDisposer(new Z(K.new({}), () => Jt._new(this._root, {
+      themeTags: G(this.circles.template.get("themeTags", []), [this._tag, "shape"])
+    }, [this.circles.template])));
+  }
+  _afterNew() {
+    super._afterNew(), this.setPrivate("scaleR", 1);
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this.isPrivateDirty("scaleR") && this._rootNode && this._updateNodesScale(this._rootNode);
+  }
+  _updateVisuals() {
+    if (this._rootNode) {
+      const t = this._packLayout;
+      t.size([this.innerWidth(), this.innerHeight()]), t(this._rootNode), t.padding(this.get("nodePadding", 0)), this._updateNodes(this._rootNode);
+    }
+  }
+  _updateNode(t) {
+    super._updateNode(t);
+    const e = t.get("node"), i = t.get("circle"), n = t.get("d3HierarchyNode"), a = this.getPrivate("scaleR", 1), o = n.x * a, h = n.y * a, r = n.r * a, l = this.get("animationDuration", 0), u = this.get("animationEasing");
+    if (e.animate({ key: "x", to: o, duration: l, easing: u }), e.animate({ key: "y", to: h, duration: l, easing: u }), i) {
+      const f = t.get("fill"), c = t.get("fillPattern");
+      i.animate({ key: "radius", to: r, duration: l, easing: u }), i._setDefault("fill", f), i._setDefault("fillPattern", c), i._setDefault("stroke", f);
+    }
+  }
+  _updateNodesScale(t) {
+    const e = t.data.dataItem;
+    if (e) {
+      const i = e.get("node"), n = e.get("circle"), a = this.getPrivate("scaleR", 1), o = t.x * a, h = t.y * a, r = t.r * a;
+      i.setAll({ x: o, y: h }), n.set("radius", r);
+      const l = t.children;
+      l && P(l, (u) => {
+        this._updateNodesScale(u);
+      });
+    }
+  }
+  /**
+   * @ignore
+   */
+  makeNode(t) {
+    const e = super.makeNode(t), i = e.children.moveValue(this.circles.make(), 0);
+    e.setPrivate("tooltipTarget", i), this.circles.push(i), t.setRaw("circle", i);
+    const n = t.get("label");
+    return i.on("radius", () => {
+      const a = i.get("radius", this.width()) * 2;
+      n.setAll({ maxWidth: a, maxHeight: a });
+    }), e;
+  }
+  _zoom(t) {
+    const e = t.get("d3HierarchyNode");
+    let i = e.x, n = e.y, a = e.r, o = Math.min(this.innerWidth(), this.innerHeight()) / (a * 2);
+    const h = this.get("animationEasing");
+    let r = this.get("animationDuration", 0);
+    this.inited || (r = 0), this.animatePrivate({ key: "scaleR", to: o, duration: r, easing: h });
+    const l = this.nodesContainer;
+    l.animate({ key: "x", from: l.x(), to: this.width() / 2 - i * o, duration: r, easing: h }), l.animate({ key: "y", from: l.y(), to: this.height() / 2 - n * o, duration: r, easing: h });
+  }
+}
+ne.className = "Pack";
+ne.classNames = Q.classNames.concat([ne.className]);
+class kt extends Q {
+  constructor() {
+    super(...arguments), this._tag = "partition", this.rectangles = this.addDisposer(new Z(K.new({}), () => ce._new(this._root, {
+      themeTags: G(this.rectangles.template.get("themeTags", []), [this._tag, "shape"])
+    }, [this.rectangles.template]))), this._partitionLayout = Je();
+  }
+  _afterNew() {
+    this._settings.themeTags = G(this._settings.themeTags, ["partition", this._settings.orientation || "vertical"]), super._afterNew(), this.setPrivate("scaleX", 1), this.setPrivate("scaleY", 1);
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this.isDirty("nodePadding") && this._rootNode && this._updateNodes(this._rootNode), (this.isPrivateDirty("scaleX") || this.isPrivateDirty("scaleY")) && this._rootNode && this._updateNodesScale(this._rootNode), this.isDirty("orientation") && this._updateVisuals();
+  }
+  _updateVisuals() {
+    if (this._rootNode) {
+      const t = this._partitionLayout;
+      let e = this.innerWidth(), i = this.innerHeight();
+      this.get("orientation") == "horizontal" && ([e, i] = [i, e]), t.size([e, i]);
+      const n = this.get("nodePadding");
+      X(n) && t.padding(n), t(this._rootNode), this._updateNodes(this._rootNode);
+    }
+  }
+  _updateNode(t) {
+    super._updateNode(t);
+    const e = t.get("node"), i = t.get("rectangle"), n = t.get("d3HierarchyNode"), a = this.getPrivate("scaleX", 1), o = this.getPrivate("scaleY", 1);
+    let h, r, l, u;
+    this.get("orientation") == "horizontal" ? (h = n.y0 * a, r = n.y1 * a, l = n.x0 * o, u = n.x1 * o) : (h = n.x0 * a, r = n.x1 * a, l = n.y0 * o, u = n.y1 * o);
+    let f = r - h, c = u - l;
+    const g = this.get("animationDuration", 0), v = this.get("animationEasing");
+    if (e.animate({ key: "x", to: h, duration: g, easing: v }), e.animate({ key: "y", to: l, duration: g, easing: v }), e.animate({ key: "width", to: f, duration: g, easing: v }), e.animate({ key: "height", to: c, duration: g, easing: v }), i) {
+      const d = t.get("fill"), p = t.get("fillPattern");
+      i.animate({ key: "width", to: f, duration: g, easing: v }), i.animate({ key: "height", to: c, duration: g, easing: v }), i._setDefault("fill", d), i._setDefault("fillPattern", p), i._setDefault("stroke", d);
+    }
+  }
+  _updateNodesScale(t) {
+    const e = t.data.dataItem;
+    if (e) {
+      const i = e.get("node"), n = e.get("rectangle"), a = this.getPrivate("scaleX", 1), o = this.getPrivate("scaleY", 1);
+      let h, r, l, u;
+      this.get("orientation") == "horizontal" ? (h = t.y0 * a, r = t.y1 * a, l = t.x0 * o, u = t.x1 * o) : (h = t.x0 * a, r = t.x1 * a, l = t.y0 * o, u = t.y1 * o);
+      const f = r - h, c = u - l;
+      i.setAll({ x: h, y: l, width: f, height: c }), n.setAll({ width: f, height: c });
+      const g = t.children;
+      g && P(g, (v) => {
+        this._updateNodesScale(v);
+      });
+    }
+  }
+  /**
+   * @ignore
+   */
+  makeNode(t) {
+    const e = super.makeNode(t);
+    return this._makeNode(t, e), e;
+  }
+  _makeNode(t, e) {
+    const i = e.children.moveValue(this.rectangles.make(), 0);
+    e.setPrivate("tooltipTarget", i), t.setRaw("rectangle", i), i._setDataItem(t);
+    const n = t.get("label");
+    i.on("width", () => {
+      n.set("maxWidth", i.width());
+    }), i.on("height", () => {
+      n.set("maxHeight", i.height());
+    });
+  }
+  _zoom(t) {
+    let e = 0, i = 0, n = 0, a = 0;
+    const o = this.get("upDepth", 0) + 1, h = this.get("topDepth", 0), r = this.innerWidth(), l = this.innerHeight(), u = this.getPrivate("maxDepth", 1), f = l / (u + 1), c = r / (u + 1), g = Math.min(this.get("initialDepth", 1), u);
+    let v = this._currentDownDepth;
+    if (v == null && (v = this.get("downDepth", 1)), t) {
+      const _ = t.get("d3HierarchyNode");
+      let x = _.depth;
+      this.get("orientation") == "horizontal" ? (e = _.y0, i = _.y1, n = _.x0, a = _.x1, e = i - c * o, i = e + c * (v + 1), x < h && (n = 0, a = l, e = c * h, i = e + c * g)) : (e = _.x0, i = _.x1, n = _.y0, a = _.y1, n = a - f * o, a = n + f * (v + 1), x < h && (e = 0, i = r, n = f * h, a = n + f * g));
+    }
+    let d = r / (i - e), p = l / (a - n);
+    const y = this.get("animationEasing");
+    let m = this.get("animationDuration", 0);
+    this.inited || (m = 0), this.animatePrivate({ key: "scaleX", to: d, duration: m, easing: y }), this.animatePrivate({ key: "scaleY", to: p, duration: m, easing: y }), this.animate({ key: "_d", from: 0, to: 1, duration: m, easing: y }), this.nodesContainer.animate({ key: "x", to: -e * d, duration: m, easing: y }), this.nodesContainer.animate({ key: "y", to: -n * p, duration: m, easing: y });
+  }
+}
+kt.className = "Partition";
+kt.classNames = Q.classNames.concat([kt.className]);
+class se extends kt {
+  constructor() {
+    super(...arguments), this._tag = "sunburst", this._partitionLayout = Je(), this.slices = this.addDisposer(new Z(K.new({}), () => zi._new(this._root, {
+      themeTags: G(this.slices.template.get("themeTags", []), [this._tag, "hierarchy", "node", "shape"])
+    }, [this.slices.template]))), this.labels = this.addDisposer(new Z(K.new({}), () => Li._new(this._root, {
+      themeTags: G(this.labels.template.get("themeTags", []), [this._tag])
+    }, [this.labels.template])));
+  }
+  _afterNew() {
+    super._afterNew(), this.nodesContainer.setAll({ x: O, y: O }), this.setPrivateRaw("dx", 0), this.setPrivateRaw("dr", 0);
+  }
+  _prepareChildren() {
+    super._prepareChildren(), (this.isPrivateDirty("dr") || this.isPrivateDirty("dx")) && this._rootNode && this._updateNodesScale(this._rootNode);
+  }
+  _updateVisuals() {
+    if (this._rootNode) {
+      const t = this._partitionLayout;
+      let e = ki(0, 0, this.get("startAngle", 0), this.get("endAngle", 360), 1), i = this.innerWidth(), n = this.innerHeight();
+      const a = i / (e.right - e.left), o = n / (e.bottom - e.top);
+      let h = Math.min(a, o), r = ut(this.get("radius", Zt), h), l = ut(this.get("innerRadius", 0), r);
+      l < 0 && (l = r + l), h = r - l, this.setPrivateRaw("innerRadius", l), this.setPrivateRaw("hierarchySize", h), t.size([h, h]), this.nodesContainer.setAll({
+        dy: -r * (e.bottom + e.top) / 2,
+        dx: -r * (e.right + e.left) / 2
+      });
+      const u = this.get("nodePadding");
+      X(u) && t.padding(u), t(this._rootNode), this._updateNodes(this._rootNode);
+    }
+  }
+  _updateNode(t) {
+    super._updateNode(t);
+    const e = t.get("d3HierarchyNode");
+    t.get("node").setAll({ x: 0, y: 0 });
+    const n = this.get("animationDuration", 0), a = this.get("animationEasing"), o = this.getPrivate("scaleX", 1), h = this.getPrivate("scaleY", 1), r = this.getPrivate("dr", 0), l = this.getPrivate("dx", 0), u = e.x0 * o + l, f = e.x1 * o + l, c = e.y0 * h, g = e.y1 * h, v = this.getPrivate("innerRadius"), d = this.getPrivate("hierarchySize", 0), p = t.get("slice");
+    if (p) {
+      const y = this.get("startAngle", -90), m = this.get("endAngle", 270), _ = y + u / d * (m - y), x = y + f / d * (m - y) - _;
+      let w = v + c, k = v + g;
+      w -= r, k -= r, k = Math.max(0, k), w = Math.max(0, w), p.animate({ key: "radius", to: k, duration: n, easing: a }), p.animate({ key: "innerRadius", to: w, duration: n, easing: a }), p.animate({ key: "startAngle", to: _, duration: n, easing: a }), p.animate({ key: "arc", to: x, duration: n, easing: a });
+      const A = t.get("fill"), N = t.get("fillPattern");
+      p._setDefault("fill", A), p._setDefault("fillPattern", N), p._setDefault("stroke", A);
+    }
+  }
+  _updateNodesScale(t) {
+    const e = t.data.dataItem;
+    if (e) {
+      const i = this.getPrivate("scaleX", 1), n = this.getPrivate("scaleY", 1), a = this.getPrivate("dr", 0), o = this.getPrivate("dx", 0), h = t.x0 * i + o, r = t.x1 * i + o, l = t.y0 * n, u = t.y1 * n, f = this.getPrivate("innerRadius"), c = this.getPrivate("hierarchySize", 0), g = e.get("slice");
+      if (g) {
+        const d = this.get("startAngle", -90), p = this.get("endAngle", 270), y = d + h / c * (p - d), m = d + r / c * (p - d) - y;
+        let _ = f + l, x = f + u;
+        _ -= a, x -= a, x = Math.max(0, x), _ = Math.max(0, _), g.setAll({ radius: x, innerRadius: _, startAngle: y, arc: m });
+      }
+      const v = t.children;
+      v && P(v, (d) => {
+        this._updateNodesScale(d);
+      });
+    }
+  }
+  _makeNode(t, e) {
+    const i = e.children.moveValue(this.slices.make(), 0);
+    e.setPrivate("tooltipTarget", i), t.setRaw("slice", i), i._setDataItem(t), i.on("arc", () => {
+      this._updateLabel(t);
+    }), i.on("innerRadius", () => {
+      this._updateLabel(t);
+    }), i.on("radius", () => {
+      this._updateLabel(t);
+    });
+  }
+  _updateLabel(t) {
+    const e = t.get("slice"), i = t.get("label");
+    if (e && i) {
+      let n = e.get("innerRadius", 0), a = e.get("radius", 0), o = e.get("startAngle", 0), h = Math.abs(e.get("arc", 0)), r = o + h / 2, l = i.get("textType"), u = a - n, f = a * h * Ae;
+      n == 0 && h >= 360 && l == "radial" && (a = 1, r = 0, u *= 2, f = u), Math.round(h) >= 360 && l == "radial" && (r = 0), l == "circular" && (u = h * Ae * (n + (a - n) / 2) - 10), i.setAll({ labelAngle: r }), i.setPrivate("radius", a), i.setPrivate("innerRadius", n), i.setAll({
+        maxHeight: f,
+        maxWidth: u
+      });
+    }
+  }
+  _zoom(t) {
+    let e = 0, i = 0, n = this.getPrivate("hierarchySize", 0);
+    const a = t.get("d3HierarchyNode");
+    let o = this.get("upDepth", 0), h = this.get("topDepth", 0), r = a.depth, l = this.getPrivate("maxDepth", 1), u = this._currentDownDepth;
+    u == null && (u = this.get("downDepth", 1));
+    const f = n / (l + 1);
+    r < h && (r = h), r - o < 0 && (o = r), e = a.x0, i = a.x1;
+    let c = u + o + 1;
+    c > l - h + 1 && (c = l - h + 1);
+    let g = n / (i - e), v = n / (f * c), d = Math.max(r - o, h) * f * v;
+    const p = this.get("animationEasing");
+    let y = this.get("animationDuration", 0);
+    this.inited || (y = 0);
+    let m = -e * g;
+    this.animatePrivate({ key: "scaleX", to: g, duration: y, easing: p }), this.animatePrivate({ key: "scaleY", to: v, duration: y, easing: p }), this.animatePrivate({ key: "dr", to: d, duration: y, easing: p }), this.animatePrivate({ key: "dx", to: m, duration: y, easing: p });
+  }
+  _handleSingle(t) {
+    const e = t.get("parent");
+    if (e) {
+      const i = e.get("children");
+      i && P(i, (n) => {
+        n != t && (this.disableDataItem(n), n.get("node").hide());
+      }), this._handleSingle(e);
+    }
+  }
+  _positionBullet(t) {
+    const e = t.get("sprite");
+    if (e) {
+      const i = e.dataItem, n = t.get("locationX", 0.5), a = t.get("locationY", 0.5), o = i.get("slice"), h = o.get("arc", 0), r = o.get("startAngle", 0) + o.get("arc", 0) * n, l = o.get("innerRadius", 0), u = l + (o.get("radius", 0) - l) * a;
+      let f = Ni(r) * u, c = bi(r) * u;
+      Pe(h, 5) === 360 && Pe(l, 2) === 0 && (f = 0, c = 0), e.set("x", f), e.set("y", c);
+    }
+  }
+  _makeBullet(t, e, i) {
+    const n = super._makeBullet(t, e, i);
+    if (n) {
+      const a = n.get("sprite"), o = t.get("slice");
+      return a && o && (o.on("arc", () => {
+        this._positionBullet(n);
+      }), o.on("radius", () => {
+        this._positionBullet(n);
+      })), n;
+    }
+  }
+}
+se.className = "Sunburst";
+se.classNames = kt.classNames.concat([se.className]);
+class re extends lt {
+  constructor() {
+    super(...arguments), this._tag = "tree", this._hierarchyLayout = Vi();
+  }
+  _prepareChildren() {
+    super._prepareChildren(), (this.isDirty("orientation") || this.isDirty("inversed")) && this._updateVisuals();
+  }
+  _updateVisuals() {
+    if (this._rootNode) {
+      const t = this._hierarchyLayout;
+      this.get("orientation") == "vertical" ? t.size([this.innerWidth(), this.innerHeight()]) : t.size([this.innerHeight(), this.innerWidth()]), t(this._rootNode);
+    }
+    super._updateVisuals();
+  }
+  _getPoint(t) {
+    const e = this.get("inversed");
+    return this.get("orientation") == "vertical" ? e ? { x: t.x, y: this.innerHeight() - t.y } : { x: t.x, y: t.y } : e ? { x: this.innerWidth() - t.y, y: t.x } : { x: t.y, y: t.x };
+  }
+}
+re.className = "Tree";
+re.classNames = lt.classNames.concat([re.className]);
+class ae extends Q {
+  constructor() {
+    super(...arguments), this._tag = "treemap", this.rectangleTemplate = K.new({}), this._treemapLayout = Ce().tile(te), this.rectangles = this.addDisposer(new Z(K.new({}), () => ce._new(this._root, {
+      themeTags: G(this.rectangles.template.get("themeTags", []), [this._tag, "shape"])
+    }, [this.rectangles.template])));
+  }
+  _afterNew() {
+    super._afterNew(), this.setPrivate("scaleX", 1), this.setPrivate("scaleY", 1), this.nodes.template.setPrivate("trustBounds", !0);
+  }
+  _prepareChildren() {
+    if (super._prepareChildren(), this.isDirty("layoutAlgorithm")) {
+      let t;
+      switch (this.get("layoutAlgorithm")) {
+        case "squarify":
+          t = te;
+          break;
+        case "binary":
+          t = Yi;
+          break;
+        case "slice":
+          t = ue;
+          break;
+        case "dice":
+          t = Ft;
+          break;
+        case "sliceDice":
+          t = Gi;
+          break;
+      }
+      if (t) {
+        this._treemapLayout = Ce().tile(t), this._updateVisuals();
+        const e = this.get("selectedDataItem");
+        e && this._zoom(e);
+      }
+    }
+    (this.isDirty("nodePaddingRight") || this.isDirty("nodePaddingLeft") || this.isDirty("nodePaddingTop") || this.isDirty("nodePaddingBottom") || this.isDirty("nodePaddingOuter") || this.isDirty("nodePaddingInner")) && this._rootNode && this._updateNodes(this._rootNode), (this.isPrivateDirty("scaleX") || this.isPrivateDirty("scaleY")) && this._rootNode && this._updateNodesScale(this._rootNode);
+  }
+  _updateVisuals() {
+    if (this._rootNode) {
+      const t = this._treemapLayout;
+      t.size([this.innerWidth(), this.innerHeight()]);
+      const e = this.get("nodePaddingLeft"), i = this.get("nodePaddingRight"), n = this.get("nodePaddingTop"), a = this.get("nodePaddingBottom"), o = this.get("nodePaddingInner"), h = this.get("nodePaddingOuter");
+      X(e) && t.paddingLeft(e), X(i) && t.paddingRight(i), X(n) && t.paddingTop(n), X(a) && t.paddingBottom(a), X(o) && t.paddingInner(o), X(h) && t.paddingOuter(h), t(this._rootNode), this._updateNodes(this._rootNode);
+    }
+  }
+  _updateNode(t) {
+    super._updateNode(t);
+    const e = t.get("node"), i = t.get("rectangle"), n = t.get("d3HierarchyNode"), a = this.getPrivate("scaleX", 1), o = this.getPrivate("scaleY", 1), h = n.x0 * a, r = n.x1 * a, l = n.y0 * o, u = n.y1 * o, f = r - h, c = u - l, g = this.get("animationDuration", 0), v = this.get("animationEasing");
+    if (e.animate({ key: "x", to: h, duration: g, easing: v }), e.animate({ key: "y", to: l, duration: g, easing: v }), e.animate({ key: "width", to: f, duration: g, easing: v }), e.animate({ key: "height", to: c, duration: g, easing: v }), i) {
+      const d = t.get("fill"), p = t.get("fillPattern");
+      i.animate({ key: "width", to: f, duration: g, easing: v }), i.animate({ key: "height", to: c, duration: g, easing: v }), i._setDefault("fill", d), i._setDefault("fillPattern", p), i._setDefault("stroke", d);
+    }
+  }
+  _updateNodesScale(t) {
+    const e = t.data.dataItem;
+    if (e) {
+      const i = e.get("node"), n = e.get("rectangle"), a = this.getPrivate("scaleX", 1), o = this.getPrivate("scaleY", 1), h = t.x0 * a, r = t.x1 * a, l = t.y0 * o, u = t.y1 * o, f = r - h, c = u - l;
+      i.setAll({ x: h, y: l, width: f, height: c }), n.setAll({ width: f, height: c });
+      const g = t.children;
+      g && P(g, (v) => {
+        this._updateNodesScale(v);
+      });
+    }
+  }
+  /**
+   * @ignore
+   */
+  makeNode(t) {
+    const e = super.makeNode(t), i = e.children.moveValue(this.rectangles.make(), 0);
+    e.setPrivate("tooltipTarget", i), t.setRaw("rectangle", i);
+    const n = t.get("label");
+    return i.on("width", () => {
+      n.setPrivate("maxWidth", i.width());
+    }), i.on("height", () => {
+      n.setPrivate("maxHeight", i.height());
+    }), e;
+  }
+  _zoom(t) {
+    if (this.width() > 0 && this.height() > 0) {
+      const e = t.get("d3HierarchyNode"), i = this.get("nodePaddingOuter", 0);
+      let n = e.x0 + i, a = e.x1 - i, o = e.y0 + i, h = e.y1 - i, r = (this.innerWidth() - i * 2) / (a - n), l = (this.innerHeight() - i * 2) / (h - o);
+      const u = this.get("animationEasing");
+      let f = this.get("animationDuration", 0);
+      this.inited || (f = 0), this.animatePrivate({ key: "scaleX", to: r, duration: f, easing: u }), this.animatePrivate({ key: "scaleY", to: l, duration: f, easing: u }), this.nodesContainer.animate({ key: "x", to: i - n * r, duration: f, easing: u }), this.nodesContainer.animate({ key: "y", to: i - o * l, duration: f, easing: u });
+    }
+  }
+  _selectDataItem(t, e, i) {
+    if (super._selectDataItem(t, e, i), t) {
+      let n = this.get("downDepth", 1) + t.get("depth");
+      this.inited || (n = this.get("initialDepth", 1));
+      const a = this._getVisibleNodes(t, n);
+      this.nodes.each((o) => {
+        a.indexOf(o.dataItem) == -1 ? o.setPrivate("focusable", !1) : o.removePrivate("focusable");
+      });
+    }
+    this._root._invalidateTabindexes();
+  }
+  _getVisibleNodes(t, e) {
+    const i = t.get("children");
+    let n = [];
+    return i && P(i, (a) => {
+      a.get("depth") == e || !a.get("children") ? n.push(a) : n = n.concat(this._getVisibleNodes(a, e));
+    }), n;
+  }
+}
+ae.className = "Treemap";
+ae.classNames = Q.classNames.concat([ae.className]);
+function Pt(s) {
+  for (var t = -1, e = s.length, i, n = s[e - 1], a = 0; ++t < e; )
+    i = n, n = s[t], a += i[1] * n[0] - i[0] * n[1];
+  return a / 2;
+}
+function bn(s) {
+  for (var t = -1, e = s.length, i = 0, n = 0, a, o = s[e - 1], h, r = 0; ++t < e; )
+    a = o, o = s[t], r += h = a[0] * o[1] - o[0] * a[1], i += (a[0] + o[0]) * h, n += (a[1] + o[1]) * h;
+  return r *= 3, [i / r, n / r];
+}
+function ii(s, t) {
+  for (var e = s.length, i = s[e - 1], n = t[0], a = t[1], o = i[0], h = i[1], r, l, u = !1, f = 0; f < e; ++f)
+    i = s[f], r = i[0], l = i[1], l > a != h > a && n < (o - r) * (a - l) / (h - l) + r && (u = !u), o = r, h = l;
+  return u;
+}
+var pt = 0, wt = 0, _t = 0, ni = 1e3, Ot, Dt, Et = 0, ht = 0, Vt = 0, Nt = typeof performance == "object" && performance.now ? performance : Date, si = typeof window == "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(s) {
+  setTimeout(s, 17);
+};
+function ri() {
+  return ht || (si(An), ht = Nt.now() + Vt);
+}
+function An() {
+  ht = 0;
+}
+function oe() {
+  this._call = this._time = this._next = null;
+}
+oe.prototype = ai.prototype = {
+  constructor: oe,
+  restart: function(s, t, e) {
+    if (typeof s != "function") throw new TypeError("callback is not a function");
+    e = (e == null ? ri() : +e) + (t == null ? 0 : +t), !this._next && Dt !== this && (Dt ? Dt._next = this : Ot = this, Dt = this), this._call = s, this._time = e, le();
+  },
+  stop: function() {
+    this._call && (this._call = null, this._time = 1 / 0, le());
+  }
+};
+function ai(s, t, e) {
+  var i = new oe();
+  return i.restart(s, t, e), i;
+}
+function Pn() {
+  ri(), ++pt;
+  for (var s = Ot, t; s; )
+    (t = ht - s._time) >= 0 && s._call.call(null, t), s = s._next;
+  --pt;
+}
+function Le() {
+  ht = (Et = Nt.now()) + Vt, pt = wt = 0;
+  try {
+    Pn();
+  } finally {
+    pt = 0, Rn(), ht = 0;
+  }
+}
+function Cn() {
+  var s = Nt.now(), t = s - Et;
+  t > ni && (Vt -= t, Et = s);
+}
+function Rn() {
+  for (var s, t = Ot, e, i = 1 / 0; t; )
+    t._call ? (i > t._time && (i = t._time), s = t, t = t._next) : (e = t._next, t._next = null, t = s ? s._next = e : Ot = e);
+  Dt = s, le(i);
+}
+function le(s) {
+  if (!pt) {
+    wt && (wt = clearTimeout(wt));
+    var t = s - ht;
+    t > 24 ? (s < 1 / 0 && (wt = setTimeout(Le, s - Nt.now() - Vt)), _t && (_t = clearInterval(_t))) : (_t || (Et = Nt.now(), _t = setInterval(Cn, ni)), pt = 1, si(Le));
+  }
+}
+var Tn = { value: () => {
+} };
+function oi() {
+  for (var s = 0, t = arguments.length, e = {}, i; s < t; ++s) {
+    if (!(i = arguments[s] + "") || i in e || /[\s.]/.test(i)) throw new Error("illegal type: " + i);
+    e[i] = [];
+  }
+  return new Ct(e);
+}
+function Ct(s) {
+  this._ = s;
+}
+function zn(s, t) {
+  return s.trim().split(/^|\s+/).map(function(e) {
+    var i = "", n = e.indexOf(".");
+    if (n >= 0 && (i = e.slice(n + 1), e = e.slice(0, n)), e && !t.hasOwnProperty(e)) throw new Error("unknown type: " + e);
+    return { type: e, name: i };
+  });
+}
+Ct.prototype = oi.prototype = {
+  constructor: Ct,
+  on: function(s, t) {
+    var e = this._, i = zn(s + "", e), n, a = -1, o = i.length;
+    if (arguments.length < 2) {
+      for (; ++a < o; ) if ((n = (s = i[a]).type) && (n = Ln(e[n], s.name))) return n;
+      return;
+    }
+    if (t != null && typeof t != "function") throw new Error("invalid callback: " + t);
+    for (; ++a < o; )
+      if (n = (s = i[a]).type) e[n] = Se(e[n], s.name, t);
+      else if (t == null) for (n in e) e[n] = Se(e[n], s.name, null);
+    return this;
+  },
+  copy: function() {
+    var s = {}, t = this._;
+    for (var e in t) s[e] = t[e].slice();
+    return new Ct(s);
+  },
+  call: function(s, t) {
+    if ((n = arguments.length - 2) > 0) for (var e = new Array(n), i = 0, n, a; i < n; ++i) e[i] = arguments[i + 2];
+    if (!this._.hasOwnProperty(s)) throw new Error("unknown type: " + s);
+    for (a = this._[s], i = 0, n = a.length; i < n; ++i) a[i].value.apply(t, e);
+  },
+  apply: function(s, t, e) {
+    if (!this._.hasOwnProperty(s)) throw new Error("unknown type: " + s);
+    for (var i = this._[s], n = 0, a = i.length; n < a; ++n) i[n].value.apply(t, e);
+  }
+};
+function Ln(s, t) {
+  for (var e = 0, i = s.length, n; e < i; ++e)
+    if ((n = s[e]).name === t)
+      return n.value;
+}
+function Se(s, t, e) {
+  for (var i = 0, n = s.length; i < n; ++i)
+    if (s[i].name === t) {
+      s[i] = Tn, s = s.slice(0, i).concat(s.slice(i + 1));
+      break;
+    }
+  return e != null && s.push({ name: t, value: e }), s;
+}
+function Me(s, t) {
+  let e, i;
+  for (const n of s)
+    n != null && (e === void 0 ? n >= n && (e = i = n) : (e > n && (e = n), i < n && (i = n)));
+  return [e, i];
+}
+function Sn(s, t, e) {
+  return (t[0] - s[0]) * (e[1] - s[1]) - (t[1] - s[1]) * (e[0] - s[0]);
+}
+function Mn(s, t) {
+  return s[0] - t[0] || s[1] - t[1];
+}
+function He(s) {
+  const t = s.length, e = [0, 1];
+  let i = 2, n;
+  for (n = 2; n < t; ++n) {
+    for (; i > 1 && Sn(s[e[i - 2]], s[e[i - 1]], s[n]) <= 0; ) --i;
+    e[i++] = n;
+  }
+  return e.slice(0, i);
+}
+function Hn(s) {
+  if ((e = s.length) < 3) return null;
+  var t, e, i = new Array(e), n = new Array(e);
+  for (t = 0; t < e; ++t) i[t] = [+s[t][0], +s[t][1], t];
+  for (i.sort(Mn), t = 0; t < e; ++t) n[t] = [i[t][0], -i[t][1]];
+  var a = He(i), o = He(n), h = o[0] === a[0], r = o[o.length - 1] === a[a.length - 1], l = [];
+  for (t = a.length - 1; t >= 0; --t) l.push(s[i[a[t]][2]]);
+  for (t = +h; t < o.length - r; ++t) l.push(s[i[o[t]][2]]);
+  return l;
+}
+function Wn(s) {
+  for (var t = -1, e = s.length, i = s[e - 1], n, a, o = i[0], h = i[1], r = 0; ++t < e; )
+    n = o, a = h, i = s[t], o = i[0], h = i[1], n -= o, a -= h, r += Math.hypot(n, a);
+  return r;
+}
+var rt = 1e-10;
+function Rt(s) {
+  return s <= rt && s >= -rt;
+}
+function vt(s, t) {
+  return s.x * t.x + s.y * t.y + s.z * t.z;
+}
+function We(s, t) {
+  return Rt(s.x * t.y - s.y * t.x) && Rt(s.y * t.z - s.z * t.y) && Rt(s.z * t.x - s.x * t.z);
+}
+function In(s) {
+  var t, e, i, n, a, o, h, r;
+  if (i = s[s.length - 2], n = s[s.length - 1], a = s[0], o = bt(i, n), h = bt(n, a), e = $t(o, h), t = Math.sign(e), i = n, n = a, a = s[1], o = h, h = bt(n, a), e = $t(o, h), Math.sign(e) === t) {
+    for (r = 2; r < s.length - 1; r++)
+      if (i = n, n = a, a = s[r], o = h, h = bt(n, a), e = $t(o, h), Math.sign(e) !== t)
+        return;
+    return t;
+  }
+}
+function bt(s, t) {
+  return [t[0] - s[0], t[1] - s[1]];
+}
+function $t(s, t) {
+  return s[0] * t[1] - s[1] * t[0];
+}
+function Bn(s, t) {
+  this.face = s, this.vert = t, this.nextf = null, this.prevf = null, this.nextv = null, this.prevv = null;
+}
+function at(s) {
+  this.forFace = s, this.head = null;
+}
+at.prototype.add = function(s) {
+  this.head === null ? this.head = s : this.forFace ? (this.head.prevv = s, s.nextv = this.head, this.head = s) : (this.head.prevf = s, s.nextf = this.head, this.head = s);
+};
+at.prototype.isEmpty = function() {
+  return this.head === null;
+};
+at.prototype.fill = function(s) {
+  if (!this.forFace) {
+    var t = this.head;
+    do
+      s.push(t.face), t.face.marked = !0, t = t.nextf;
+    while (t !== null);
+  }
+};
+at.prototype.removeAll = function() {
+  if (this.forFace) {
+    var s = this.head;
+    do
+      s.prevf === null ? s.nextf === null ? s.vert.conflicts.head = null : (s.nextf.prevf = null, s.vert.conflicts.head = s.nextf) : (s.nextf != null && (s.nextf.prevf = s.prevf), s.prevf.nextf = s.nextf), s = s.nextv, s != null && (s.prevv = null);
+    while (s != null);
+  } else {
+    var s = this.head;
+    do
+      s.prevv == null ? s.nextv == null ? s.face.conflicts.head = null : (s.nextv.prevv = null, s.face.conflicts.head = s.nextv) : (s.nextv != null && (s.nextv.prevv = s.prevv), s.prevv.nextv = s.nextv), s = s.nextf, s != null && (s.prevf = null);
+    while (s != null);
+  }
+};
+at.prototype.getVertices = function() {
+  for (var s = [], t = this.head; t !== null; )
+    s.push(t.vert), t = t.nextv;
+  return s;
+};
+function et(s, t, e, i, n, a) {
+  this.x = s, this.y = t, this.weight = rt, this.index = 0, this.conflicts = new at(!1), this.neighbours = null, this.nonClippedPolygon = null, this.polygon = null, this.originalObject = null, this.isDummy = !1, n !== void 0 && (this.originalObject = n), a != null && (this.isDummy = a), i != null && (this.weight = i), e != null ? this.z = e : this.z = this.projectZ(this.x, this.y, this.weight);
+}
+et.prototype.projectZ = function(s, t, e) {
+  return s * s + t * t - e;
+};
+et.prototype.setWeight = function(s) {
+  this.weight = s, this.z = this.projectZ(this.x, this.y, this.weight);
+};
+et.prototype.subtract = function(s) {
+  return new et(s.x - this.x, s.y - this.y, s.z - this.z);
+};
+et.prototype.crossproduct = function(s) {
+  return new et(this.y * s.z - this.z * s.y, this.z * s.x - this.x * s.z, this.x * s.y - this.y * s.x);
+};
+et.prototype.equals = function(s) {
+  return this.x === s.x && this.y === s.y && this.z === s.z;
+};
+function de(s) {
+  var t = s.verts[0], e = s.verts[1], i = s.verts[2];
+  this.a = t.y * (e.z - i.z) + e.y * (i.z - t.z) + i.y * (t.z - e.z), this.b = t.z * (e.x - i.x) + e.z * (i.x - t.x) + i.z * (t.x - e.x), this.c = t.x * (e.y - i.y) + e.x * (i.y - t.y) + i.x * (t.y - e.y), this.d = -1 * (t.x * (e.y * i.z - i.y * e.z) + e.x * (i.y * t.z - t.y * i.z) + i.x * (t.y * e.z - e.y * t.z));
+}
+de.prototype.getNormZPlane = function() {
+  return [
+    -1 * (this.a / this.c),
+    -1 * (this.b / this.c),
+    -1 * (this.d / this.c)
+  ];
+};
+de.prototype.getDualPointMappedToPlane = function() {
+  var s = this.getNormZPlane(), t = new On(s[0] / 2, s[1] / 2);
+  return t;
+};
+function On(s, t) {
+  this.x = s, this.y = t;
+}
+function pe(s, t, e) {
+  this.x = s, this.y = t, this.z = e;
+}
+pe.prototype.negate = function() {
+  this.x *= -1, this.y *= -1, this.z *= -1;
+};
+pe.prototype.normalize = function() {
+  var s = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  s > 0 && (this.x /= s, this.y /= s, this.z /= s);
+};
+function gt(s, t, e) {
+  this.next = null, this.prev = null, this.twin = null, this.orig = s, this.dest = t, this.iFace = e;
+}
+gt.prototype.isHorizon = function() {
+  return this.twin !== null && !this.iFace.marked && this.twin.iFace.marked;
+};
+gt.prototype.findHorizon = function(s) {
+  if (this.isHorizon()) {
+    if (s.length > 0 && this === s[0])
+      return;
+    s.push(this), this.next.findHorizon(s);
+  } else
+    this.twin !== null && this.twin.next.findHorizon(s);
+};
+gt.prototype.isEqual = function(s, t) {
+  return this.orig.equals(s) && this.dest.equals(t) || this.orig.equals(t) && this.dest.equals(s);
+};
+function ot(s) {
+  this.message = s, this.stack = new Error().stack;
+}
+ot.prototype.name = "d3WeightedVoronoiError";
+ot.prototype = new Error();
+function $(s, t, e, i) {
+  this.conflicts = new at(!0), this.verts = [s, t, e], this.marked = !1;
+  var n = s.subtract(t).crossproduct(t.subtract(e));
+  this.normal = new pe(-n.x, -n.y, -n.z), this.normal.normalize(), this.createEdges(), this.dualPoint = null, i != null && this.orient(i);
+}
+$.prototype.getDualPoint = function() {
+  if (this.dualPoint == null) {
+    var s = new de(this);
+    this.dualPoint = s.getDualPointMappedToPlane();
+  }
+  return this.dualPoint;
+};
+$.prototype.isVisibleFromBelow = function() {
+  return this.normal.z < -14259414393190911e-25;
+};
+$.prototype.createEdges = function() {
+  this.edges = [], this.edges[0] = new gt(this.verts[0], this.verts[1], this), this.edges[1] = new gt(this.verts[1], this.verts[2], this), this.edges[2] = new gt(this.verts[2], this.verts[0], this), this.edges[0].next = this.edges[1], this.edges[0].prev = this.edges[2], this.edges[1].next = this.edges[2], this.edges[1].prev = this.edges[0], this.edges[2].next = this.edges[0], this.edges[2].prev = this.edges[1];
+};
+$.prototype.orient = function(s) {
+  if (!(vt(this.normal, s) < vt(this.normal, this.verts[0]))) {
+    var t = this.verts[1];
+    this.verts[1] = this.verts[2], this.verts[2] = t, this.normal.negate(), this.createEdges();
+  }
+};
+$.prototype.getEdge = function(s, t) {
+  for (var e = 0; e < 3; e++)
+    if (this.edges[e].isEqual(s, t))
+      return this.edges[e];
+  return null;
+};
+$.prototype.link = function(s, t, e) {
+  if (s instanceof $) {
+    var i = s.getEdge(t, e);
+    if (i === null)
+      throw new ot("when linking, twin is null");
+    var n = this.getEdge(t, e);
+    if (n === null)
+      throw new ot("when linking, twin is null");
+    i.twin = n, n.twin = i;
+  } else {
+    var i = s, n = this.getEdge(i.orig, i.dest);
+    i.twin = n, n.twin = i;
+  }
+};
+$.prototype.conflict = function(s) {
+  return vt(this.normal, s) > vt(this.normal, this.verts[0]) + rt;
+};
+$.prototype.getHorizon = function() {
+  for (var s = 0; s < 3; s++)
+    if (this.edges[s].twin !== null && this.edges[s].twin.isHorizon())
+      return this.edges[s];
+  return null;
+};
+$.prototype.removeConflict = function() {
+  this.conflicts.removeAll();
+};
+function it() {
+  this.points = [], this.facets = [], this.created = [], this.horizon = [], this.visible = [], this.current = 0;
+}
+it.prototype.init = function(s, t) {
+  this.points = [];
+  for (var e = 0; e < t.length; e++)
+    this.points[e] = new et(t[e].x, t[e].y, t[e].z, null, t[e], !1);
+  this.points = this.points.concat(s);
+};
+it.prototype.permutate = function() {
+  for (var s = this.points.length, t = s - 1; t > 0; t--) {
+    var e = Math.floor(Math.random() * t), i = this.points[e];
+    i.index = t;
+    var n = this.points[t];
+    n.index = e, this.points.splice(e, 1, n), this.points.splice(t, 1, i);
+  }
+};
+it.prototype.prep = function() {
+  if (this.points.length <= 3)
+    throw new ot("Less than 4 points");
+  for (var s = 0; s < this.points.length; s++)
+    this.points[s].index = s;
+  var t, e, i, n, a, o, h, r;
+  t = this.points[0], e = this.points[1], i = n = null;
+  for (var s = 2; s < this.points.length; s++)
+    if (!(We(t, this.points[s]) && We(e, this.points[s]))) {
+      i = this.points[s], i.index = 2, this.points[2].index = s, this.points.splice(s, 1, this.points[2]), this.points.splice(2, 1, i);
+      break;
+    }
+  if (i === null)
+    throw new ot("Not enough non-planar Points (v2 is null)");
+  r = new $(t, e, i);
+  for (var s = 3; s < this.points.length; s++)
+    if (!Rt(vt(r.normal, r.verts[0]) - vt(r.normal, this.points[s]))) {
+      n = this.points[s], n.index = 3, this.points[3].index = s, this.points.splice(s, 1, this.points[3]), this.points.splice(3, 1, n);
+      break;
+    }
+  if (n === null)
+    throw new ot("Not enough non-planar Points (v3 is null)");
+  r.orient(n), a = new $(t, i, n, e), o = new $(t, e, n, i), h = new $(e, i, n, t), this.addFacet(r), this.addFacet(a), this.addFacet(o), this.addFacet(h), r.link(a, t, i), r.link(o, t, e), r.link(h, e, i), a.link(o, t, n), a.link(h, i, n), o.link(h, n, e), this.current = 4;
+  for (var l, s = this.current; s < this.points.length; s++)
+    l = this.points[s], r.conflict(l) && this.addConflict(r, l), a.conflict(l) && this.addConflict(a, l), o.conflict(l) && this.addConflict(o, l), h.conflict(l) && this.addConflict(h, l);
+}, // IN: Faces old1 old2 and fn
+it.prototype.addConflicts = function(s, t, e) {
+  var i = s.conflicts.getVertices(), n = t.conflicts.getVertices(), a = [], o, h, r, l;
+  for (r = l = 0; r < i.length || l < n.length; )
+    r < i.length && l < n.length ? (o = i[r], h = n[l], o.index === h.index ? (a.push(o), r++, l++) : o.index > h.index ? (a.push(o), r++) : (a.push(h), l++)) : r < i.length ? a.push(i[r++]) : a.push(n[l++]);
+  for (var r = a.length - 1; r >= 0; r--)
+    o = a[r], e.conflict(o) && this.addConflict(e, o);
+};
+it.prototype.addConflict = function(s, t) {
+  var e = new Bn(s, t);
+  s.conflicts.add(e), t.conflicts.add(e);
+};
+it.prototype.removeConflict = function(s) {
+  s.removeConflict();
+  var t = s.index;
+  if (s.index = -1, t === this.facets.length - 1) {
+    this.facets.splice(this.facets.length - 1, 1);
+    return;
+  }
+  if (!(t >= this.facets.length || t < 0)) {
+    var e = this.facets.splice(this.facets.length - 1, 1);
+    e[0].index = t, this.facets.splice(t, 1, e[0]);
+  }
+};
+it.prototype.addFacet = function(s) {
+  s.index = this.facets.length, this.facets.push(s);
+};
+it.prototype.compute = function() {
+  for (this.prep(); this.current < this.points.length; ) {
+    var s = this.points[this.current];
+    if (s.conflicts.isEmpty()) {
+      this.current++;
+      continue;
+    }
+    this.created = [], this.horizon = [], this.visible = [], s.conflicts.fill(this.visible);
+    for (var t, e = 0; e < this.visible.length; e++)
+      if (t = this.visible[e].getHorizon(), t !== null) {
+        t.findHorizon(this.horizon);
+        break;
+      }
+    for (var i = null, n = null, a = 0; a < this.horizon.length; a++) {
+      var o = this.horizon[a], h = new $(s, o.orig, o.dest, o.twin.next.dest);
+      h.conflicts = new at(!0), this.addFacet(h), this.created.push(h), this.addConflicts(o.iFace, o.twin.iFace, h), h.link(o), i !== null && h.link(i, s, o.orig), i = h, n === null && (n = h);
+    }
+    if (n !== null && i !== null && i.link(n, s, this.horizon[0].orig), this.created.length != 0) {
+      for (var r = 0; r < this.visible.length; r++)
+        this.removeConflict(this.visible[r]);
+      this.current++, this.created = [];
+    }
+  }
+  return this.facets;
+};
+it.prototype.clear = function() {
+  this.points = [], this.facets = [], this.created = [], this.horizon = [], this.visible = [], this.current = 0;
+};
+function En(s, t) {
+  for (var e, i = Be(t), n = -1, a = s.length - Be(s), o, h, r = s[a - 1], l, u, f, c; ++n < a; ) {
+    for (e = t.slice(), t.length = 0, l = s[n], u = e[(h = e.length - i) - 1], o = -1; ++o < h; )
+      f = e[o], Ut(f, r, l) ? (Ut(u, r, l) || (c = Ie(u, f, r, l), isFinite(c[0]) && t.push(c)), t.push(f)) : Ut(u, r, l) && (c = Ie(u, f, r, l), isFinite(c[0]) && t.push(c)), u = f;
+    i && t.push(t[0]), r = l;
+  }
+  return t;
+}
+function Ut(s, t, e) {
+  return (e[0] - t[0]) * (s[1] - t[1]) < (e[1] - t[1]) * (s[0] - t[0]);
+}
+function Ie(s, t, e, i) {
+  var n = s[0], a = e[0], o = t[0] - n, h = i[0] - a, r = s[1], l = e[1], u = t[1] - r, f = i[1] - l, c = (h * (r - l) - f * (n - a)) / (f * o - h * u);
+  return [n + c * o, r + c * u];
+}
+function Be(s) {
+  var t = s[0], e = s[s.length - 1];
+  return !(t[0] - e[0] || t[1] - e[1]);
+}
+function Fn(s) {
+  var t = [], e = s, i = s.dest, n = i.originalObject, a = [];
+  do {
+    e = e.twin.prev;
+    var o = e.orig.originalObject;
+    o.isDummy || a.push(o);
+    var h = e.iFace;
+    h.isVisibleFromBelow() && t.push(h);
+  } while (e !== s);
+  return n.neighbours = a, t;
+}
+function Vn(s, t, e) {
+  var i = new it();
+  i.clear(), i.init(t, s);
+  for (var n = i.compute(s), a = [], o = [], h = n.length, r = 0; r < h; r++) {
+    var l = n[r];
+    if (l.isVisibleFromBelow())
+      for (var u = 0; u < 3; u++) {
+        var f = l.edges[u], c = f.dest, g = c.originalObject;
+        if (!o[c.index]) {
+          if (o[c.index] = !0, g.isDummy)
+            continue;
+          for (var v = Fn(f), d = [], p = null, y = null, m = 1, _ = 1, x = 0; x < v.length; x++) {
+            var w = v[x].getDualPoint(), k = w.x, A = w.y;
+            p !== null && (m = p - k, _ = y - A, m < 0 && (m = -m), _ < 0 && (_ = -_)), (m > rt || _ > rt) && (d.push([k, A]), p = k, y = A);
+          }
+          if (g.nonClippedPolygon = d.reverse(), !g.isDummy && Wn(g.nonClippedPolygon) > 0) {
+            var N = En(e, g.nonClippedPolygon);
+            g.polygon = N, N.site = g, N.length > 0 && a.push(N);
+          }
+        }
+      }
+  }
+  return a;
+}
+function Xn() {
+  var s = function(r) {
+    return r.x;
+  }, t = function(r) {
+    return r.y;
+  }, e = function(r) {
+    return r.weight;
+  }, i = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0]
+  ], n = [
+    [0, 0],
+    [1, 1]
+  ], a = [1, 1];
+  function o(r) {
+    var l;
+    return l = r.map(function(u) {
+      return new et(s(u), t(u), null, e(u), u, !1);
+    }), Vn(l, h(), i);
+  }
+  o.x = function(r) {
+    return arguments.length ? (s = r, o) : s;
+  }, o.y = function(r) {
+    return arguments.length ? (t = r, o) : t;
+  }, o.weight = function(r) {
+    return arguments.length ? (e = r, o) : e;
+  }, o.clip = function(r) {
+    var l, u, f;
+    return arguments.length ? (u = Me(
+      r.map(function(c) {
+        return c[0];
+      })
+    ), f = Me(
+      r.map(function(c) {
+        return c[1];
+      })
+    ), l = In(r), l === void 0 ? i = Hn(r) : l === 1 ? i = r.reverse() : i = r, n = [
+      [u[0], f[0]],
+      [u[1], f[1]]
+    ], a = [u[1] - u[0], f[1] - f[0]], o) : i;
+  }, o.extent = function(r) {
+    return arguments.length ? (i = [r[0], [r[0][0], r[1][1]], r[1], [r[1][0], r[0][1]]], n = r, a = [r[1][0] - r[0][0], r[1][1] - r[0][1]], o) : n;
+  }, o.size = function(r) {
+    return arguments.length ? (i = [
+      [0, 0],
+      [0, r[1]],
+      [r[0], r[1]],
+      [r[0], 0]
+    ], n = [[0, 0], r], a = r, o) : a;
+  };
+  function h() {
+    var r, l, u, f, c, g, v, d, p, y, m = [], _ = [];
+    r = n[0][0], l = n[1][0], u = n[0][1], f = n[1][1], c = l - r, g = f - u, v = r - c, d = l + c, p = u - g, y = f + g, m[0] = [v, p], m[1] = [v, y], m[2] = [d, y], m[3] = [d, p];
+    for (var x = 0; x < 4; x++)
+      _.push(
+        new et(
+          m[x][0],
+          m[x][1],
+          null,
+          rt,
+          new et(m[x][0], m[x][1], null, rt, null, !0),
+          !0
+        )
+      );
+    return _;
+  }
+  return o;
+}
+function ct() {
+  this.growthChangesLength = li, this.totalAvailableArea = NaN, this.lastAreaError = NaN, this.lastGrowth = NaN, this.growthChanges = [], this.growthChangeWeights = ve(this.growthChangesLength), this.growthChangeWeightsSum = ye(this.growthChangeWeights);
+}
+var li = 10;
+function qn(s, t) {
+  return s >= t ? 1 : -1;
+}
+function ve(s) {
+  for (var t = 3, e = 1, i = 1, n = t, a = [], o = 0; o < s; o++)
+    a.push(n), n -= e, n < i && (n = i);
+  return a;
+}
+function ye(s) {
+  for (var t = 0, e = 0; e < s.length; e++)
+    t += s[e];
+  return t;
+}
+ct.prototype.reset = function() {
+  return this.lastAreaError = NaN, this.lastGrowth = NaN, this.growthChanges = [], this.growthChangesLength = li, this.growthChangeWeights = ve(this.growthChangesLength), this.growthChangeWeightsSum = ye(this.growthChangeWeights), this.totalAvailableArea = NaN, this;
+};
+ct.prototype.clear = function() {
+  return this.lastAreaError = NaN, this.lastGrowth = NaN, this.growthChanges = [], this;
+};
+ct.prototype.length = function(s) {
+  return arguments.length ? (parseInt(s) > 0 ? (this.growthChangesLength = Math.floor(parseInt(s)), this.growthChangeWeights = ve(this.growthChangesLength), this.growthChangeWeightsSum = ye(this.growthChangeWeights)) : console.warn("FlickeringMitigation.length() accepts only positive integers; unable to handle " + s), this) : this.growthChangesLength;
+};
+ct.prototype.totalArea = function(s) {
+  return arguments.length ? (parseFloat(s) > 0 ? this.totalAvailableArea = parseFloat(s) : console.warn("FlickeringMitigation.totalArea() accepts only positive numbers; unable to handle " + s), this) : this.totalAvailableArea;
+};
+ct.prototype.add = function(s) {
+  var t, e;
+  return t = this.lastAreaError, this.lastAreaError = s, isNaN(t) || (e = this.lastGrowth, this.lastGrowth = qn(this.lastAreaError, t)), isNaN(e) || this.growthChanges.unshift(this.lastGrowth != e), this.growthChanges.length > this.growthChangesLength && this.growthChanges.pop(), this;
+};
+ct.prototype.ratio = function() {
+  var s = 0, t;
+  if (this.growthChanges.length < this.growthChangesLength || this.lastAreaError > this.totalAvailableArea / 10)
+    return 0;
+  for (var e = 0; e < this.growthChangesLength; e++)
+    this.growthChanges[e] && (s += this.growthChangeWeights[e]);
+  return t = s / this.growthChangeWeightsSum, t;
+};
+function Yn() {
+  var s, t, e, i, n, a, o, h;
+  function r(u, f, c, g) {
+    var v = !1, d, p;
+    for (s !== g.clip() && (s = g.clip(), t = g.extent(), v = !0), v && l(), d = e + o * g.prng()(), p = n + h * g.prng()(); !ii(s, [d, p]); )
+      d = e + o * g.prng()(), p = n + h * g.prng()();
+    return [d, p];
+  }
+  function l() {
+    e = t[0][0], i = t[1][0], n = t[0][1], a = t[1][1], o = i - e, h = a - n;
+  }
+  return r;
+}
+function Gn() {
+  var s, t, e, i, n;
+  function a(h, r, l, u) {
+    var f = !1;
+    return s !== u.clip() && (s = u.clip(), f |= !0), t !== l && (t = l, f |= !0), f && o(), n;
+  }
+  function o() {
+    e = t.length, i = Pt(s), n = i / e / 2;
+  }
+  return a;
+}
+function ft(s) {
+  this.message = s, this.stack = new Error().stack;
+}
+ft.prototype.name = "d3VoronoiMapError";
+ft.prototype = new Error();
+function Oe(s) {
+  var t = 0.01, e = 50, i = 0.01, n = Math.random, a = Yn(), o = Gn(), h = 1e-10, r = function(D) {
+    return D.weight;
+  }, l = t, u = e, f = i, c = n, g = a, v = o, d = Xn(), p = new ct(), y = !0, m, _, x, w, k, A, N, C, b, S = ai(xe), W = oi("tick", "end");
+  const B = 1, J = 1e3;
+  var tt;
+  function nt(D) {
+    return Math.pow(D, 2);
+  }
+  function me(D, H) {
+    return nt(H.x - D.x) + nt(H.y - D.y);
+  }
+  b = {
+    tick: _e,
+    restart: function() {
+      return S.restart(xe), b;
+    },
+    stop: function() {
+      return S.stop(), b;
+    },
+    weight: function(D) {
+      return arguments.length ? (r = D, y = !0, b) : r;
+    },
+    convergenceRatio: function(D) {
+      return arguments.length ? (l = D, y = !0, b) : l;
+    },
+    maxIterationCount: function(D) {
+      return arguments.length ? (u = D, b) : u;
+    },
+    minWeightRatio: function(D) {
+      return arguments.length ? (f = D, y = !0, b) : f;
+    },
+    clip: function(D) {
+      return arguments.length ? (d.clip(D), y = !0, b) : d.clip();
+    },
+    extent: function(D) {
+      return arguments.length ? (d.extent(D), y = !0, b) : d.extent();
+    },
+    size: function(D) {
+      return arguments.length ? (d.size(D), y = !0, b) : d.size();
+    },
+    prng: function(D) {
+      return arguments.length ? (c = D, y = !0, b) : c;
+    },
+    initialPosition: function(D) {
+      return arguments.length ? (g = D, y = !0, b) : g;
+    },
+    initialWeight: function(D) {
+      return arguments.length ? (v = D, y = !0, b) : v;
+    },
+    state: function() {
+      return y && we(), {
+        ended: C,
+        iterationCount: w,
+        convergenceRatio: A / _,
+        polygons: k
+      };
+    },
+    on: function(D, H) {
+      return arguments.length === 1 ? W.on(D) : (W.on(D, H), b);
+    }
+  };
+  function xe() {
+    _e(), W.call("tick", b), C && (S.stop(), W.call("end", b));
+  }
+  function _e() {
+    C || (y && we(), k = ui(k, p.ratio()), w++, A = pi(k), p.add(A), N = A < x, C = N || w >= u);
+  }
+  function we() {
+    vi(), m = s.length, _ = Math.abs(Pt(d.clip())), x = l * _, p.clear().totalArea(_), w = 0, N = !1, k = hi(s, b), C = !1, y = !1;
+  }
+  function hi(D, H) {
+    var M = D.reduce(function(L, I) {
+      return Math.max(L, r(I));
+    }, -1 / 0), T = M * f, R, z;
+    return R = D.map(function(L, I, E) {
+      return {
+        index: I,
+        weight: Math.max(r(L), T),
+        initialPosition: g(L, I, E, H),
+        initialWeight: v(L, I, E, H),
+        originalData: L
+      };
+    }), z = ci(R, H), tt(z), d(z);
+  }
+  function ci(D, H) {
+    var M = D.reduce(function(R, z) {
+      return R += z.weight;
+    }, 0), T;
+    return D.map(function(R, z, L) {
+      return T = R.initialPosition, ii(d.clip(), T) || (T = a(R, z, L, H)), {
+        index: R.index,
+        targetedArea: _ * R.weight / M,
+        data: R,
+        x: T[0],
+        y: T[1],
+        weight: R.initialWeight
+        // ArlindNocaj/Voronoi-Treemap-Library uses an epsilonesque initial weight; using heavier initial weights allows faster weight adjustements, hence faster stabilization
+      };
+    });
+  }
+  function ui(D, H) {
+    var M;
+    if (fi(D, H), M = D.map(function(T) {
+      return T.site.originalObject;
+    }), D = d(M), D.length < m)
+      throw new ft("at least 1 site has no area, which is not supposed to arise");
+    if (gi(D, H), M = D.map(function(T) {
+      return T.site.originalObject;
+    }), D = d(M), D.length < m)
+      throw new ft("at least 1 site has no area, which is not supposed to arise");
+    return D;
+  }
+  function fi(D, H) {
+    var M = [], T = 0.5, R, z, L, I, E, F, q;
+    R = T * H, z = 1 - R;
+    for (var Xt = 0; Xt < m; Xt++)
+      L = D[Xt], I = L.site.originalObject, E = bn(L), F = E[0] - I.x, q = E[1] - I.y, F *= z, q *= z, I.x += F, I.y += q, M.push(I);
+    tt(M);
+  }
+  function gi(D, H) {
+    var M = [], T = 0.1, R, z, L, I, E, F;
+    R = T * H;
+    for (var q = 0; q < m; q++)
+      z = D[q], L = z.site.originalObject, I = Pt(z), E = L.targetedArea / I, E = Math.max(E, 1 - T + R), E = Math.min(E, 1 + T - R), F = L.weight * E, F = Math.max(F, h), L.weight = F, M.push(L);
+    tt(M);
+  }
+  function De(D) {
+    var H = 0, M, T, R, z, L, I, E;
+    do {
+      if (H > J)
+        throw new ft("handleOverweighted0 is looping too much");
+      M = !1;
+      for (var F = 0; F < m; F++) {
+        T = D[F];
+        for (var q = F + 1; q < m; q++)
+          if (R = D[q], T.weight > R.weight ? (z = T, L = R) : (z = R, L = T), I = me(T, R), I < z.weight - L.weight) {
+            E = I + L.weight / 2, E = Math.max(E, h), z.weight = E, M = !0, H++;
+            break;
+          }
+        if (M)
+          break;
+      }
+    } while (M);
+  }
+  function di(D) {
+    var H = 0, M, T, R, z, L, I, E;
+    do {
+      if (H > J)
+        throw new ft("handleOverweighted1 is looping too much");
+      M = !1;
+      for (var F = 0; F < m; F++) {
+        T = D[F];
+        for (var q = F + 1; q < m; q++)
+          if (R = D[q], T.weight > R.weight ? (z = T, L = R) : (z = R, L = T), I = me(T, R), I < z.weight - L.weight) {
+            E = z.weight - L.weight - I, L.weight += E + h, M = !0, H++;
+            break;
+          }
+        if (M)
+          break;
+      }
+    } while (M);
+  }
+  function pi(D) {
+    for (var H = 0, M, T, R, z = 0; z < m; z++)
+      M = D[z], T = M.site.originalObject, R = Pt(M), H += Math.abs(T.targetedArea - R);
+    return H;
+  }
+  function vi() {
+    switch (B) {
+      case 0:
+        tt = De;
+        break;
+      case 1:
+        tt = di;
+        break;
+      default:
+        console.error("unknown 'handleOverweighted' variant; using variant #1"), tt = De;
+    }
+  }
+  return b;
+}
+function jn() {
+  var s = 0.01, t = 50, e = 0.01, i = Math.random, n = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0]
+  ], a = [
+    [0, 0],
+    [1, 1]
+  ], o = [1, 1], h = s, r = t, l = e, u = i, f = [
+    {
+      weight: 1
+    },
+    {
+      weight: 1
+    }
+  ], c = Oe(f).stop();
+  function g(d) {
+    v(n, d);
+  }
+  g.convergenceRatio = function(d) {
+    return arguments.length ? (h = d, g) : h;
+  }, g.maxIterationCount = function(d) {
+    return arguments.length ? (r = d, g) : r;
+  }, g.minWeightRatio = function(d) {
+    return arguments.length ? (l = d, g) : l;
+  }, g.clip = function(d) {
+    return arguments.length ? (c.clip(d), n = c.clip(), a = c.extent(), o = c.size(), g) : n;
+  }, g.extent = function(d) {
+    return arguments.length ? (c.extent(d), n = c.clip(), a = c.extent(), o = c.size(), g) : a;
+  }, g.size = function(d) {
+    return arguments.length ? (c.size(d), n = c.clip(), a = c.extent(), o = c.size(), g) : o;
+  }, g.prng = function(d) {
+    return arguments.length ? (u = d, g) : u;
+  };
+  function v(d, p) {
+    var y;
+    if (p.polygon = d, p.height != 0) {
+      y = Oe(p.children).clip(d).weight(function(_) {
+        return _.value;
+      }).convergenceRatio(h).maxIterationCount(r).minWeightRatio(l).prng(u).stop();
+      for (var m = y.state(); !m.ended; )
+        y.tick(), m = y.state();
+      m.polygons.forEach(function(_) {
+        v(_, _.site.originalObject.data.originalData);
+      });
+    }
+  }
+  return g;
+}
+var Tt = { exports: {} }, $n = Tt.exports, Ee;
+function Un() {
+  return Ee || (Ee = 1, function(s) {
+    (function(t, e, i) {
+      function n(r) {
+        var l = this, u = h();
+        l.next = function() {
+          var f = 2091639 * l.s0 + l.c * 23283064365386963e-26;
+          return l.s0 = l.s1, l.s1 = l.s2, l.s2 = f - (l.c = f | 0);
+        }, l.c = 1, l.s0 = u(" "), l.s1 = u(" "), l.s2 = u(" "), l.s0 -= u(r), l.s0 < 0 && (l.s0 += 1), l.s1 -= u(r), l.s1 < 0 && (l.s1 += 1), l.s2 -= u(r), l.s2 < 0 && (l.s2 += 1), u = null;
+      }
+      function a(r, l) {
+        return l.c = r.c, l.s0 = r.s0, l.s1 = r.s1, l.s2 = r.s2, l;
+      }
+      function o(r, l) {
+        var u = new n(r), f = l && l.state, c = u.next;
+        return c.int32 = function() {
+          return u.next() * 4294967296 | 0;
+        }, c.double = function() {
+          return c() + (c() * 2097152 | 0) * 11102230246251565e-32;
+        }, c.quick = c, f && (typeof f == "object" && a(f, u), c.state = function() {
+          return a(u, {});
+        }), c;
+      }
+      function h() {
+        var r = 4022871197, l = function(u) {
+          u = String(u);
+          for (var f = 0; f < u.length; f++) {
+            r += u.charCodeAt(f);
+            var c = 0.02519603282416938 * r;
+            r = c >>> 0, c -= r, c *= r, r = c >>> 0, c -= r, r += c * 4294967296;
+          }
+          return (r >>> 0) * 23283064365386963e-26;
+        };
+        return l;
+      }
+      e && e.exports ? e.exports = o : this.alea = o;
+    })(
+      $n,
+      s
+    );
+  }(Tt)), Tt.exports;
+}
+var zt = { exports: {} }, Kn = zt.exports, Fe;
+function Zn() {
+  return Fe || (Fe = 1, function(s) {
+    (function(t, e, i) {
+      function n(h) {
+        var r = this, l = "";
+        r.x = 0, r.y = 0, r.z = 0, r.w = 0, r.next = function() {
+          var f = r.x ^ r.x << 11;
+          return r.x = r.y, r.y = r.z, r.z = r.w, r.w ^= r.w >>> 19 ^ f ^ f >>> 8;
+        }, h === (h | 0) ? r.x = h : l += h;
+        for (var u = 0; u < l.length + 64; u++)
+          r.x ^= l.charCodeAt(u) | 0, r.next();
+      }
+      function a(h, r) {
+        return r.x = h.x, r.y = h.y, r.z = h.z, r.w = h.w, r;
+      }
+      function o(h, r) {
+        var l = new n(h), u = r && r.state, f = function() {
+          return (l.next() >>> 0) / 4294967296;
+        };
+        return f.double = function() {
+          do
+            var c = l.next() >>> 11, g = (l.next() >>> 0) / 4294967296, v = (c + g) / (1 << 21);
+          while (v === 0);
+          return v;
+        }, f.int32 = l.next, f.quick = f, u && (typeof u == "object" && a(u, l), f.state = function() {
+          return a(l, {});
+        }), f;
+      }
+      e && e.exports ? e.exports = o : this.xor128 = o;
+    })(
+      Kn,
+      s
+    );
+  }(zt)), zt.exports;
+}
+var Lt = { exports: {} }, Qn = Lt.exports, Ve;
+function Jn() {
+  return Ve || (Ve = 1, function(s) {
+    (function(t, e, i) {
+      function n(h) {
+        var r = this, l = "";
+        r.next = function() {
+          var f = r.x ^ r.x >>> 2;
+          return r.x = r.y, r.y = r.z, r.z = r.w, r.w = r.v, (r.d = r.d + 362437 | 0) + (r.v = r.v ^ r.v << 4 ^ (f ^ f << 1)) | 0;
+        }, r.x = 0, r.y = 0, r.z = 0, r.w = 0, r.v = 0, h === (h | 0) ? r.x = h : l += h;
+        for (var u = 0; u < l.length + 64; u++)
+          r.x ^= l.charCodeAt(u) | 0, u == l.length && (r.d = r.x << 10 ^ r.x >>> 4), r.next();
+      }
+      function a(h, r) {
+        return r.x = h.x, r.y = h.y, r.z = h.z, r.w = h.w, r.v = h.v, r.d = h.d, r;
+      }
+      function o(h, r) {
+        var l = new n(h), u = r && r.state, f = function() {
+          return (l.next() >>> 0) / 4294967296;
+        };
+        return f.double = function() {
+          do
+            var c = l.next() >>> 11, g = (l.next() >>> 0) / 4294967296, v = (c + g) / (1 << 21);
+          while (v === 0);
+          return v;
+        }, f.int32 = l.next, f.quick = f, u && (typeof u == "object" && a(u, l), f.state = function() {
+          return a(l, {});
+        }), f;
+      }
+      e && e.exports ? e.exports = o : this.xorwow = o;
+    })(
+      Qn,
+      s
+    );
+  }(Lt)), Lt.exports;
+}
+var St = { exports: {} }, ts = St.exports, Xe;
+function es() {
+  return Xe || (Xe = 1, function(s) {
+    (function(t, e, i) {
+      function n(h) {
+        var r = this;
+        r.next = function() {
+          var u = r.x, f = r.i, c, g;
+          return c = u[f], c ^= c >>> 7, g = c ^ c << 24, c = u[f + 1 & 7], g ^= c ^ c >>> 10, c = u[f + 3 & 7], g ^= c ^ c >>> 3, c = u[f + 4 & 7], g ^= c ^ c << 7, c = u[f + 7 & 7], c = c ^ c << 13, g ^= c ^ c << 9, u[f] = g, r.i = f + 1 & 7, g;
+        };
+        function l(u, f) {
+          var c, g = [];
+          if (f === (f | 0))
+            g[0] = f;
+          else
+            for (f = "" + f, c = 0; c < f.length; ++c)
+              g[c & 7] = g[c & 7] << 15 ^ f.charCodeAt(c) + g[c + 1 & 7] << 13;
+          for (; g.length < 8; ) g.push(0);
+          for (c = 0; c < 8 && g[c] === 0; ++c) ;
+          for (c == 8 ? g[7] = -1 : g[c], u.x = g, u.i = 0, c = 256; c > 0; --c)
+            u.next();
+        }
+        l(r, h);
+      }
+      function a(h, r) {
+        return r.x = h.x.slice(), r.i = h.i, r;
+      }
+      function o(h, r) {
+        h == null && (h = +/* @__PURE__ */ new Date());
+        var l = new n(h), u = r && r.state, f = function() {
+          return (l.next() >>> 0) / 4294967296;
+        };
+        return f.double = function() {
+          do
+            var c = l.next() >>> 11, g = (l.next() >>> 0) / 4294967296, v = (c + g) / (1 << 21);
+          while (v === 0);
+          return v;
+        }, f.int32 = l.next, f.quick = f, u && (u.x && a(u, l), f.state = function() {
+          return a(l, {});
+        }), f;
+      }
+      e && e.exports ? e.exports = o : this.xorshift7 = o;
+    })(
+      ts,
+      s
+    );
+  }(St)), St.exports;
+}
+var Mt = { exports: {} }, is = Mt.exports, qe;
+function ns() {
+  return qe || (qe = 1, function(s) {
+    (function(t, e, i) {
+      function n(h) {
+        var r = this;
+        r.next = function() {
+          var u = r.w, f = r.X, c = r.i, g, v;
+          return r.w = u = u + 1640531527 | 0, v = f[c + 34 & 127], g = f[c = c + 1 & 127], v ^= v << 13, g ^= g << 17, v ^= v >>> 15, g ^= g >>> 12, v = f[c] = v ^ g, r.i = c, v + (u ^ u >>> 16) | 0;
+        };
+        function l(u, f) {
+          var c, g, v, d, p, y = [], m = 128;
+          for (f === (f | 0) ? (g = f, f = null) : (f = f + "\0", g = 0, m = Math.max(m, f.length)), v = 0, d = -32; d < m; ++d)
+            f && (g ^= f.charCodeAt((d + 32) % f.length)), d === 0 && (p = g), g ^= g << 10, g ^= g >>> 15, g ^= g << 4, g ^= g >>> 13, d >= 0 && (p = p + 1640531527 | 0, c = y[d & 127] ^= g + p, v = c == 0 ? v + 1 : 0);
+          for (v >= 128 && (y[(f && f.length || 0) & 127] = -1), v = 127, d = 512; d > 0; --d)
+            g = y[v + 34 & 127], c = y[v = v + 1 & 127], g ^= g << 13, c ^= c << 17, g ^= g >>> 15, c ^= c >>> 12, y[v] = g ^ c;
+          u.w = p, u.X = y, u.i = v;
+        }
+        l(r, h);
+      }
+      function a(h, r) {
+        return r.i = h.i, r.w = h.w, r.X = h.X.slice(), r;
+      }
+      function o(h, r) {
+        h == null && (h = +/* @__PURE__ */ new Date());
+        var l = new n(h), u = r && r.state, f = function() {
+          return (l.next() >>> 0) / 4294967296;
+        };
+        return f.double = function() {
+          do
+            var c = l.next() >>> 11, g = (l.next() >>> 0) / 4294967296, v = (c + g) / (1 << 21);
+          while (v === 0);
+          return v;
+        }, f.int32 = l.next, f.quick = f, u && (u.X && a(u, l), f.state = function() {
+          return a(l, {});
+        }), f;
+      }
+      e && e.exports ? e.exports = o : this.xor4096 = o;
+    })(
+      is,
+      // window object or global
+      s
+    );
+  }(Mt)), Mt.exports;
+}
+var Ht = { exports: {} }, ss = Ht.exports, Ye;
+function rs() {
+  return Ye || (Ye = 1, function(s) {
+    (function(t, e, i) {
+      function n(h) {
+        var r = this, l = "";
+        r.next = function() {
+          var f = r.b, c = r.c, g = r.d, v = r.a;
+          return f = f << 25 ^ f >>> 7 ^ c, c = c - g | 0, g = g << 24 ^ g >>> 8 ^ v, v = v - f | 0, r.b = f = f << 20 ^ f >>> 12 ^ c, r.c = c = c - g | 0, r.d = g << 16 ^ c >>> 16 ^ v, r.a = v - f | 0;
+        }, r.a = 0, r.b = 0, r.c = -1640531527, r.d = 1367130551, h === Math.floor(h) ? (r.a = h / 4294967296 | 0, r.b = h | 0) : l += h;
+        for (var u = 0; u < l.length + 20; u++)
+          r.b ^= l.charCodeAt(u) | 0, r.next();
+      }
+      function a(h, r) {
+        return r.a = h.a, r.b = h.b, r.c = h.c, r.d = h.d, r;
+      }
+      function o(h, r) {
+        var l = new n(h), u = r && r.state, f = function() {
+          return (l.next() >>> 0) / 4294967296;
+        };
+        return f.double = function() {
+          do
+            var c = l.next() >>> 11, g = (l.next() >>> 0) / 4294967296, v = (c + g) / (1 << 21);
+          while (v === 0);
+          return v;
+        }, f.int32 = l.next, f.quick = f, u && (typeof u == "object" && a(u, l), f.state = function() {
+          return a(l, {});
+        }), f;
+      }
+      e && e.exports ? e.exports = o : this.tychei = o;
+    })(
+      ss,
+      s
+    );
+  }(Ht)), Ht.exports;
+}
+var Wt = { exports: {} }, as = Wt.exports, Ge;
+function os() {
+  return Ge || (Ge = 1, function(s) {
+    (function(t, e, i) {
+      var n = 256, a = 6, o = 52, h = "random", r = i.pow(n, a), l = i.pow(2, o), u = l * 2, f = n - 1, c;
+      function g(x, w, k) {
+        var A = [];
+        w = w == !0 ? { entropy: !0 } : w || {};
+        var N = y(p(
+          w.entropy ? [x, _(e)] : x ?? m(),
+          3
+        ), A), C = new v(A), b = function() {
+          for (var S = C.g(a), W = r, B = 0; S < l; )
+            S = (S + B) * n, W *= n, B = C.g(1);
+          for (; S >= u; )
+            S /= 2, W /= 2, B >>>= 1;
+          return (S + B) / W;
+        };
+        return b.int32 = function() {
+          return C.g(4) | 0;
+        }, b.quick = function() {
+          return C.g(4) / 4294967296;
+        }, b.double = b, y(_(C.S), e), (w.pass || k || function(S, W, B, J) {
+          return J && (J.S && d(J, C), S.state = function() {
+            return d(C, {});
+          }), B ? (i[h] = S, W) : S;
+        })(
+          b,
+          N,
+          "global" in w ? w.global : this == i,
+          w.state
+        );
+      }
+      function v(x) {
+        var w, k = x.length, A = this, N = 0, C = A.i = A.j = 0, b = A.S = [];
+        for (k || (x = [k++]); N < n; )
+          b[N] = N++;
+        for (N = 0; N < n; N++)
+          b[N] = b[C = f & C + x[N % k] + (w = b[N])], b[C] = w;
+        (A.g = function(S) {
+          for (var W, B = 0, J = A.i, tt = A.j, nt = A.S; S--; )
+            W = nt[J = f & J + 1], B = B * n + nt[f & (nt[J] = nt[tt = f & tt + W]) + (nt[tt] = W)];
+          return A.i = J, A.j = tt, B;
+        })(n);
+      }
+      function d(x, w) {
+        return w.i = x.i, w.j = x.j, w.S = x.S.slice(), w;
+      }
+      function p(x, w) {
+        var k = [], A = typeof x, N;
+        if (w && A == "object")
+          for (N in x)
+            try {
+              k.push(p(x[N], w - 1));
+            } catch {
+            }
+        return k.length ? k : A == "string" ? x : x + "\0";
+      }
+      function y(x, w) {
+        for (var k = x + "", A, N = 0; N < k.length; )
+          w[f & N] = f & (A ^= w[f & N] * 19) + k.charCodeAt(N++);
+        return _(w);
+      }
+      function m() {
+        try {
+          var x;
+          return c && (x = c.randomBytes) ? x = x(n) : (x = new Uint8Array(n), (t.crypto || t.msCrypto).getRandomValues(x)), _(x);
+        } catch {
+          var w = t.navigator, k = w && w.plugins;
+          return [+/* @__PURE__ */ new Date(), t, k, t.screen, _(e)];
+        }
+      }
+      function _(x) {
+        return String.fromCharCode.apply(0, x);
+      }
+      if (y(i.random(), e), s.exports) {
+        s.exports = g;
+        try {
+          c = Wi;
+        } catch {
+        }
+      } else
+        i["seed" + h] = g;
+    })(
+      // global: `self` in browsers (including strict mode and web workers),
+      // otherwise `this` in Node and other environments
+      typeof self < "u" ? self : as,
+      [],
+      // pool: entropy pool starts empty
+      Math
+      // math: package containing random, pow, and seedrandom
+    );
+  }(Wt)), Wt.exports;
+}
+var Kt, je;
+function ls() {
+  if (je) return Kt;
+  je = 1;
+  var s = Un(), t = Zn(), e = Jn(), i = es(), n = ns(), a = rs(), o = os();
+  return o.alea = s, o.xor128 = t, o.xorwow = e, o.xorshift7 = i, o.xor4096 = n, o.tychei = a, Kt = o, Kt;
+}
+var hs = ls();
+const $e = /* @__PURE__ */ Hi(hs);
+class he extends Q {
+  constructor() {
+    super(...arguments), this._tag = "voronoitreemap", this.polygons = this.addDisposer(new Z(K.new({}), () => Mi._new(this._root, {
+      themeTags: G(this.polygons.template.get("themeTags", []), [this._tag, "shape"])
+    }, [this.polygons.template]))), this.voronoi = jn();
+  }
+  _afterNew() {
+    this.nodesContainer.setAll({
+      x: O,
+      y: O,
+      centerX: O,
+      centerY: O
+    }), this.nodes.template.setPrivate("trustBounds", !0), super._afterNew();
+  }
+  _prepareChildren() {
+    super._prepareChildren();
+    const t = this.innerWidth() / 2, e = this.innerHeight() / 2;
+    let i = this._rootNode;
+    const n = this.get("selectedDataItem");
+    n && (i = n.get("d3HierarchyNode")), this.voronoi.convergenceRatio(this.get("convergenceRatio", 5e-3)), this.voronoi.maxIterationCount(this.get("maxIterationCount", 100)), this.voronoi.minWeightRatio(this.get("minWeightRatio", 5e-3)), this.isDirty("type") && this.get("type") == "polygon" && (this.voronoi.clip(this.getCirclePolygon(1)), this._updateVisuals()), this._sizeDirty && this.get("type") == "rectangle" && (this.voronoi.prng($e("X")), this.voronoi.clip([[-t, -e], [-t, e], [t, e], [t, -e]])(i), this._updateVisuals()), (this._valuesDirty || this.isDirty("selectedDataItem")) && i && (this.voronoi.prng($e("X")), this.voronoi(i), this._updateVisuals());
+  }
+  _updateNode(t) {
+    const e = t.get("d3HierarchyNode").polygon, i = t.get("polygon");
+    if (e && i) {
+      let n = [], a = 1;
+      this.get("type") == "polygon" && (a = Math.min(this.innerWidth(), this.innerHeight()) / 2);
+      let o = 1 / 0, h = -1 / 0;
+      for (let f = 0, c = e.length; f < c; f++) {
+        const g = e[f];
+        let v = g[0] * a, d = g[1] * a;
+        n.push([v, d]), o = Math.min(o, v), h = Math.max(h, v);
+      }
+      i.set("coordinates", n);
+      const r = t.get("fill"), l = t.get("fillPattern");
+      i._setDefault("fill", r), i._setDefault("fillPattern", l);
+      const u = t.get("label");
+      if (u) {
+        const f = e.site;
+        f && u.setAll({
+          x: f.x * a,
+          y: f.y * a,
+          maxWidth: Math.abs(h - o)
+        });
+      }
+    }
+  }
+  _handleSingle(t) {
+    const e = t.get("parent");
+    if (e) {
+      const i = e.get("children");
+      i && P(i, (n) => {
+        n != t && (this.disableDataItem(n), n.get("node").hide());
+      }), this._handleSingle(e);
+    }
+  }
+  /**
+   * @ignore
+   */
+  makeNode(t) {
+    const e = super.makeNode(t);
+    return this._makeNode(t, e), e;
+  }
+  _makeNode(t, e) {
+    const i = e.children.moveValue(this.polygons.make(), 0);
+    e.setPrivate("tooltipTarget", i), t.setRaw("polygon", i), i._setDataItem(t);
+  }
+  getCirclePolygon(t) {
+    const e = this.get("cornerCount", 120), i = Math.PI * 2 / e, n = [];
+    for (let a = 0; a < e; a++) {
+      let o = a * i;
+      n.push([t * Math.cos(o), t * Math.sin(o)]);
+    }
+    return n;
+  }
+}
+he.className = "VoronoiTreemap";
+he.classNames = Q.classNames.concat([he.className]);
+export {
+  ee as BreadcrumbBar,
+  ei as DefaultTheme,
+  ie as ForceDirected,
+  Q as Hierarchy,
+  Bt as HierarchyLink,
+  dt as HierarchyNode,
+  lt as LinkedHierarchy,
+  It as LinkedHierarchyNode,
+  ne as Pack,
+  kt as Partition,
+  se as Sunburst,
+  re as Tree,
+  ae as Treemap,
+  he as VoronoiTreemap
+};