@hybridcore/ui 1.5.89 → 1.6.0

package/dist/components/charts/drill-down-voronoi-treemap/logic.js

@@ -0,0 +1,1527 @@
+import { G as Zt, k as ve, l as de, R as xe, a as we, A as me } from "../../../AnimatedTheme-jnasw6rT.js";
+import { useThemeProps as ye, useTheme as be } from "@mui/material";
+import Ce from "dayjs";
+import Ae from "lodash";
+import { useId as Pe, useRef as ze, useEffect as _e } from "react";
+import { colorSetFromPalette as De } from "../_common/utils.js";
+import { e as Kt, z as ht, m as Ee, a as lt, c as Ht, b as Vt } from "../../../ColorSet-C7vpNXhM.js";
+import { Z as Te } from "../../../ZoomableContainer-DYyqwaMb.js";
+import { H as Jt } from "../../../Hierarchy-Bihj0S61.js";
+import { c as K, g as ke, a as Ne } from "../../../_commonjsHelpers-BVfed4GL.js";
+class pt extends Zt {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "morphAnimation", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _beforeChanged() {
+    if (super._beforeChanged(), this.isDirty("coordinates")) {
+      const e = [], n = this.get("coordinates");
+      n && Kt(n, (r) => {
+        e.push({ x: r[0], y: r[1] });
+      }), this.set("points", e);
+    }
+    if (this.isPrivateDirty("points") && (this._clear = !0), this.isDirty("points")) {
+      this._clear = !0;
+      const e = this.get("points"), n = this._prevSettings.points;
+      if (n) {
+        if (e) {
+          let h = ht(e), i = ht(n), s = h.length, c = i.length;
+          if (s > c) {
+            let a = ht(h);
+            for (let l = 0; l < s; l++) {
+              let g = Math.floor(l / s * c);
+              a[l] = { x: i[g].x, y: i[g].y };
+            }
+            i = a;
+          } else if (c > s) {
+            let a = ht(i);
+            for (let l = 0; l < c; l++) {
+              let g = Math.floor(l / c * s);
+              a[l] = { x: h[g].x, y: h[g].y };
+            }
+            h = a;
+          }
+          this.setPrivateRaw("previousPoints", i), this.setPrivateRaw("points", h), this.morphAnimation = this.animatePrivate({ key: "morphProgress", from: 0, to: 1, duration: this.get("animationDuration", 0), easing: this.get("animationEasing") }), this._root.events.once("frameended", () => {
+            this._markDirtyPrivateKey("morphProgress");
+          });
+        }
+      } else
+        this.setPrivateRaw("previousPoints", e), this.setPrivateRaw("points", e);
+      let r = 1 / 0, o = -1 / 0, u = 1 / 0, f = -1 / 0;
+      if (e)
+        for (let h = 1, i = e.length; h < i; h++) {
+          const s = e[h];
+          r = Math.min(r, s.x), o = Math.max(o, s.x), u = Math.min(u, s.y), f = Math.max(f, s.y);
+        }
+      this.setPrivate("minX", r), this.setPrivate("maxX", o), this.setPrivate("minY", u), this.setPrivate("maxY", u);
+    }
+    this.isPrivateDirty("morphProgress") && (this._clear = !0);
+  }
+  _changed() {
+    super._changed(), this._clear && this._draw();
+  }
+  _draw() {
+    const e = this.getPrivate("previousPoints"), n = this.getPrivate("points"), r = this.getPrivate("morphProgress", 1);
+    if (n && e) {
+      const o = n[0], u = e[0];
+      o && this._display.moveTo(u.x + (o.x - u.x) * r, u.y + (o.y - u.y) * r);
+      for (let f = 1, h = n.length; f < h; f++) {
+        const i = n[f], s = e[f];
+        this._display.lineTo(s.x + (i.x - s.x) * r, s.y + (i.y - s.y) * r);
+      }
+      this._display.closePath();
+    }
+  }
+  _updateSize() {
+    this.markDirty(), this._clear = !0;
+  }
+}
+Object.defineProperty(pt, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Polygon"
+});
+Object.defineProperty(pt, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: Zt.classNames.concat([pt.className])
+});
+function ft(t) {
+  for (var e = -1, n = t.length, r, o = t[n - 1], u = 0; ++e < n; )
+    r = o, o = t[e], u += r[1] * o[0] - r[0] * o[1];
+  return u / 2;
+}
+function Ie(t) {
+  for (var e = -1, n = t.length, r = 0, o = 0, u, f = t[n - 1], h, i = 0; ++e < n; )
+    u = f, f = t[e], i += h = u[0] * f[1] - f[0] * u[1], r += (u[0] + f[0]) * h, o += (u[1] + f[1]) * h;
+  return i *= 3, [r / i, o / i];
+}
+function Me(t, e, n) {
+  return (e[0] - t[0]) * (n[1] - t[1]) - (e[1] - t[1]) * (n[0] - t[0]);
+}
+function Oe(t, e) {
+  return t[0] - e[0] || t[1] - e[1];
+}
+function Xt(t) {
+  const e = t.length, n = [0, 1];
+  let r = 2, o;
+  for (o = 2; o < e; ++o) {
+    for (; r > 1 && Me(t[n[r - 2]], t[n[r - 1]], t[o]) <= 0; ) --r;
+    n[r++] = o;
+  }
+  return n.slice(0, r);
+}
+function Fe(t) {
+  if ((n = t.length) < 3) return null;
+  var e, n, r = new Array(n), o = new Array(n);
+  for (e = 0; e < n; ++e) r[e] = [+t[e][0], +t[e][1], e];
+  for (r.sort(Oe), e = 0; e < n; ++e) o[e] = [r[e][0], -r[e][1]];
+  var u = Xt(r), f = Xt(o), h = f[0] === u[0], i = f[f.length - 1] === u[u.length - 1], s = [];
+  for (e = u.length - 1; e >= 0; --e) s.push(t[r[u[e]][2]]);
+  for (e = +h; e < f.length - i; ++e) s.push(t[r[f[e]][2]]);
+  return s;
+}
+function Qt(t, e) {
+  for (var n = t.length, r = t[n - 1], o = e[0], u = e[1], f = r[0], h = r[1], i, s, c = !1, a = 0; a < n; ++a)
+    r = t[a], i = r[0], s = r[1], s > u != h > u && o < (f - i) * (u - s) / (h - s) + i && (c = !c), f = i, h = s;
+  return c;
+}
+function We(t) {
+  for (var e = -1, n = t.length, r = t[n - 1], o, u, f = r[0], h = r[1], i = 0; ++e < n; )
+    o = f, u = h, r = t[e], f = r[0], h = r[1], o -= f, u -= h, i += Math.hypot(o, u);
+  return i;
+}
+var nt = 0, ot = 0, rt = 0, te = 1e3, vt, st, dt = 0, Z = 0, wt = 0, at = typeof performance == "object" && performance.now ? performance : Date, ee = typeof window == "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(t) {
+  setTimeout(t, 17);
+};
+function ne() {
+  return Z || (ee(Re), Z = at.now() + wt);
+}
+function Re() {
+  Z = 0;
+}
+function Ct() {
+  this._call = this._time = this._next = null;
+}
+Ct.prototype = ie.prototype = {
+  constructor: Ct,
+  restart: function(t, e, n) {
+    if (typeof t != "function") throw new TypeError("callback is not a function");
+    n = (n == null ? ne() : +n) + (e == null ? 0 : +e), !this._next && st !== this && (st ? st._next = this : vt = this, st = this), this._call = t, this._time = n, At();
+  },
+  stop: function() {
+    this._call && (this._call = null, this._time = 1 / 0, At());
+  }
+};
+function ie(t, e, n) {
+  var r = new Ct();
+  return r.restart(t, e, n), r;
+}
+function Le() {
+  ne(), ++nt;
+  for (var t = vt, e; t; )
+    (e = Z - t._time) >= 0 && t._call.call(null, e), t = t._next;
+  --nt;
+}
+function jt() {
+  Z = (dt = at.now()) + wt, nt = ot = 0;
+  try {
+    Le();
+  } finally {
+    nt = 0, Ve(), Z = 0;
+  }
+}
+function He() {
+  var t = at.now(), e = t - dt;
+  e > te && (wt -= e, dt = t);
+}
+function Ve() {
+  for (var t, e = vt, n, r = 1 / 0; e; )
+    e._call ? (r > e._time && (r = e._time), t = e, e = e._next) : (n = e._next, e._next = null, e = t ? t._next = n : vt = n);
+  st = t, At(r);
+}
+function At(t) {
+  if (!nt) {
+    ot && (ot = clearTimeout(ot));
+    var e = t - Z;
+    e > 24 ? (t < 1 / 0 && (ot = setTimeout(jt, t - at.now() - wt)), rt && (rt = clearInterval(rt))) : (rt || (dt = at.now(), rt = setInterval(He, te)), nt = 1, ee(jt));
+  }
+}
+var Xe = { value: () => {
+} };
+function re() {
+  for (var t = 0, e = arguments.length, n = {}, r; t < e; ++t) {
+    if (!(r = arguments[t] + "") || r in n || /[\s.]/.test(r)) throw new Error("illegal type: " + r);
+    n[r] = [];
+  }
+  return new ct(n);
+}
+function ct(t) {
+  this._ = t;
+}
+function je(t, e) {
+  return t.trim().split(/^|\s+/).map(function(n) {
+    var r = "", o = n.indexOf(".");
+    if (o >= 0 && (r = n.slice(o + 1), n = n.slice(0, o)), n && !e.hasOwnProperty(n)) throw new Error("unknown type: " + n);
+    return { type: n, name: r };
+  });
+}
+ct.prototype = re.prototype = {
+  constructor: ct,
+  on: function(t, e) {
+    var n = this._, r = je(t + "", n), o, u = -1, f = r.length;
+    if (arguments.length < 2) {
+      for (; ++u < f; ) if ((o = (t = r[u]).type) && (o = Se(n[o], t.name))) return o;
+      return;
+    }
+    if (e != null && typeof e != "function") throw new Error("invalid callback: " + e);
+    for (; ++u < f; )
+      if (o = (t = r[u]).type) n[o] = St(n[o], t.name, e);
+      else if (e == null) for (o in n) n[o] = St(n[o], t.name, null);
+    return this;
+  },
+  copy: function() {
+    var t = {}, e = this._;
+    for (var n in e) t[n] = e[n].slice();
+    return new ct(t);
+  },
+  call: function(t, e) {
+    if ((o = arguments.length - 2) > 0) for (var n = new Array(o), r = 0, o, u; r < o; ++r) n[r] = arguments[r + 2];
+    if (!this._.hasOwnProperty(t)) throw new Error("unknown type: " + t);
+    for (u = this._[t], r = 0, o = u.length; r < o; ++r) u[r].value.apply(e, n);
+  },
+  apply: function(t, e, n) {
+    if (!this._.hasOwnProperty(t)) throw new Error("unknown type: " + t);
+    for (var r = this._[t], o = 0, u = r.length; o < u; ++o) r[o].value.apply(e, n);
+  }
+};
+function Se(t, e) {
+  for (var n = 0, r = t.length, o; n < r; ++n)
+    if ((o = t[n]).name === e)
+      return o.value;
+}
+function St(t, e, n) {
+  for (var r = 0, o = t.length; r < o; ++r)
+    if (t[r].name === e) {
+      t[r] = Xe, t = t.slice(0, r).concat(t.slice(r + 1));
+      break;
+    }
+  return n != null && t.push({ name: e, value: n }), t;
+}
+function Gt(t, e) {
+  let n, r;
+  for (const o of t)
+    o != null && (n === void 0 ? o >= o && (n = r = o) : (n > o && (n = o), r < o && (r = o)));
+  return [n, r];
+}
+var U = 1e-10;
+function gt(t) {
+  return t <= U && t >= -U;
+}
+function it(t, e) {
+  return t.x * e.x + t.y * e.y + t.z * e.z;
+}
+function qt(t, e) {
+  return gt(t.x * e.y - t.y * e.x) && gt(t.y * e.z - t.z * e.y) && gt(t.z * e.x - t.x * e.z);
+}
+function Ge(t) {
+  var e, n, r, o, u, f, h, i;
+  if (r = t[t.length - 2], o = t[t.length - 1], u = t[0], f = ut(r, o), h = ut(o, u), n = yt(f, h), e = Math.sign(n), r = o, o = u, u = t[1], f = h, h = ut(o, u), n = yt(f, h), Math.sign(n) === e) {
+    for (i = 2; i < t.length - 1; i++)
+      if (r = o, o = u, u = t[i], f = h, h = ut(o, u), n = yt(f, h), Math.sign(n) !== e)
+        return;
+    return e;
+  }
+}
+function ut(t, e) {
+  return [e[0] - t[0], e[1] - t[1]];
+}
+function yt(t, e) {
+  return t[0] * e[1] - t[1] * e[0];
+}
+function qe(t, e) {
+  this.face = t, this.vert = e, this.nextf = null, this.prevf = null, this.nextv = null, this.prevv = null;
+}
+function $(t) {
+  this.forFace = t, this.head = null;
+}
+$.prototype.add = function(t) {
+  this.head === null ? this.head = t : this.forFace ? (this.head.prevv = t, t.nextv = this.head, this.head = t) : (this.head.prevf = t, t.nextf = this.head, this.head = t);
+};
+$.prototype.isEmpty = function() {
+  return this.head === null;
+};
+$.prototype.fill = function(t) {
+  if (!this.forFace) {
+    var e = this.head;
+    do
+      t.push(e.face), e.face.marked = !0, e = e.nextf;
+    while (e !== null);
+  }
+};
+$.prototype.removeAll = function() {
+  if (this.forFace) {
+    var t = this.head;
+    do
+      t.prevf === null ? t.nextf === null ? t.vert.conflicts.head = null : (t.nextf.prevf = null, t.vert.conflicts.head = t.nextf) : (t.nextf != null && (t.nextf.prevf = t.prevf), t.prevf.nextf = t.nextf), t = t.nextv, t != null && (t.prevv = null);
+    while (t != null);
+  } else {
+    var t = this.head;
+    do
+      t.prevv == null ? t.nextv == null ? t.face.conflicts.head = null : (t.nextv.prevv = null, t.face.conflicts.head = t.nextv) : (t.nextv != null && (t.nextv.prevv = t.prevv), t.prevv.nextv = t.nextv), t = t.nextf, t != null && (t.prevf = null);
+    while (t != null);
+  }
+};
+$.prototype.getVertices = function() {
+  for (var t = [], e = this.head; e !== null; )
+    t.push(e.vert), e = e.nextv;
+  return t;
+};
+function G(t, e, n, r, o, u) {
+  this.x = t, this.y = e, this.weight = U, this.index = 0, this.conflicts = new $(!1), this.neighbours = null, this.nonClippedPolygon = null, this.polygon = null, this.originalObject = null, this.isDummy = !1, o !== void 0 && (this.originalObject = o), u != null && (this.isDummy = u), r != null && (this.weight = r), n != null ? this.z = n : this.z = this.projectZ(this.x, this.y, this.weight);
+}
+G.prototype.projectZ = function(t, e, n) {
+  return t * t + e * e - n;
+};
+G.prototype.setWeight = function(t) {
+  this.weight = t, this.z = this.projectZ(this.x, this.y, this.weight);
+};
+G.prototype.subtract = function(t) {
+  return new G(t.x - this.x, t.y - this.y, t.z - this.z);
+};
+G.prototype.crossproduct = function(t) {
+  return new G(this.y * t.z - this.z * t.y, this.z * t.x - this.x * t.z, this.x * t.y - this.y * t.x);
+};
+G.prototype.equals = function(t) {
+  return this.x === t.x && this.y === t.y && this.z === t.z;
+};
+function Pt(t) {
+  var e = t.verts[0], n = t.verts[1], r = t.verts[2];
+  this.a = e.y * (n.z - r.z) + n.y * (r.z - e.z) + r.y * (e.z - n.z), this.b = e.z * (n.x - r.x) + n.z * (r.x - e.x) + r.z * (e.x - n.x), this.c = e.x * (n.y - r.y) + n.x * (r.y - e.y) + r.x * (e.y - n.y), this.d = -1 * (e.x * (n.y * r.z - r.y * n.z) + n.x * (r.y * e.z - e.y * r.z) + r.x * (e.y * n.z - n.y * e.z));
+}
+Pt.prototype.getNormZPlane = function() {
+  return [
+    -1 * (this.a / this.c),
+    -1 * (this.b / this.c),
+    -1 * (this.d / this.c)
+  ];
+};
+Pt.prototype.getDualPointMappedToPlane = function() {
+  var t = this.getNormZPlane(), e = new Ye(t[0] / 2, t[1] / 2);
+  return e;
+};
+function Ye(t, e) {
+  this.x = t, this.y = e;
+}
+function zt(t, e, n) {
+  this.x = t, this.y = e, this.z = n;
+}
+zt.prototype.negate = function() {
+  this.x *= -1, this.y *= -1, this.z *= -1;
+};
+zt.prototype.normalize = function() {
+  var t = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  t > 0 && (this.x /= t, this.y /= t, this.z /= t);
+};
+function et(t, e, n) {
+  this.next = null, this.prev = null, this.twin = null, this.orig = t, this.dest = e, this.iFace = n;
+}
+et.prototype.isHorizon = function() {
+  return this.twin !== null && !this.iFace.marked && this.twin.iFace.marked;
+};
+et.prototype.findHorizon = function(t) {
+  if (this.isHorizon()) {
+    if (t.length > 0 && this === t[0])
+      return;
+    t.push(this), this.next.findHorizon(t);
+  } else
+    this.twin !== null && this.twin.next.findHorizon(t);
+};
+et.prototype.isEqual = function(t, e) {
+  return this.orig.equals(t) && this.dest.equals(e) || this.orig.equals(e) && this.dest.equals(t);
+};
+function B(t) {
+  this.message = t, this.stack = new Error().stack;
+}
+B.prototype.name = "d3WeightedVoronoiError";
+B.prototype = new Error();
+function H(t, e, n, r) {
+  this.conflicts = new $(!0), this.verts = [t, e, n], this.marked = !1;
+  var o = t.subtract(e).crossproduct(e.subtract(n));
+  this.normal = new zt(-o.x, -o.y, -o.z), this.normal.normalize(), this.createEdges(), this.dualPoint = null, r != null && this.orient(r);
+}
+H.prototype.getDualPoint = function() {
+  if (this.dualPoint == null) {
+    var t = new Pt(this);
+    this.dualPoint = t.getDualPointMappedToPlane();
+  }
+  return this.dualPoint;
+};
+H.prototype.isVisibleFromBelow = function() {
+  return this.normal.z < -14259414393190911e-25;
+};
+H.prototype.createEdges = function() {
+  this.edges = [], this.edges[0] = new et(this.verts[0], this.verts[1], this), this.edges[1] = new et(this.verts[1], this.verts[2], this), this.edges[2] = new et(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];
+};
+H.prototype.orient = function(t) {
+  if (!(it(this.normal, t) < it(this.normal, this.verts[0]))) {
+    var e = this.verts[1];
+    this.verts[1] = this.verts[2], this.verts[2] = e, this.normal.negate(), this.createEdges();
+  }
+};
+H.prototype.getEdge = function(t, e) {
+  for (var n = 0; n < 3; n++)
+    if (this.edges[n].isEqual(t, e))
+      return this.edges[n];
+  return null;
+};
+H.prototype.link = function(t, e, n) {
+  if (t instanceof H) {
+    var r = t.getEdge(e, n);
+    if (r === null)
+      throw new B("when linking, twin is null");
+    var o = this.getEdge(e, n);
+    if (o === null)
+      throw new B("when linking, twin is null");
+    r.twin = o, o.twin = r;
+  } else {
+    var r = t, o = this.getEdge(r.orig, r.dest);
+    r.twin = o, o.twin = r;
+  }
+};
+H.prototype.conflict = function(t) {
+  return it(this.normal, t) > it(this.normal, this.verts[0]) + U;
+};
+H.prototype.getHorizon = function() {
+  for (var t = 0; t < 3; t++)
+    if (this.edges[t].twin !== null && this.edges[t].twin.isHorizon())
+      return this.edges[t];
+  return null;
+};
+H.prototype.removeConflict = function() {
+  this.conflicts.removeAll();
+};
+function q() {
+  this.points = [], this.facets = [], this.created = [], this.horizon = [], this.visible = [], this.current = 0;
+}
+q.prototype.init = function(t, e) {
+  this.points = [];
+  for (var n = 0; n < e.length; n++)
+    this.points[n] = new G(e[n].x, e[n].y, e[n].z, null, e[n], !1);
+  this.points = this.points.concat(t);
+};
+q.prototype.permutate = function() {
+  for (var t = this.points.length, e = t - 1; e > 0; e--) {
+    var n = Math.floor(Math.random() * e), r = this.points[n];
+    r.index = e;
+    var o = this.points[e];
+    o.index = n, this.points.splice(n, 1, o), this.points.splice(e, 1, r);
+  }
+};
+q.prototype.prep = function() {
+  if (this.points.length <= 3)
+    throw new B("Less than 4 points");
+  for (var t = 0; t < this.points.length; t++)
+    this.points[t].index = t;
+  var e, n, r, o, u, f, h, i;
+  e = this.points[0], n = this.points[1], r = o = null;
+  for (var t = 2; t < this.points.length; t++)
+    if (!(qt(e, this.points[t]) && qt(n, this.points[t]))) {
+      r = this.points[t], r.index = 2, this.points[2].index = t, this.points.splice(t, 1, this.points[2]), this.points.splice(2, 1, r);
+      break;
+    }
+  if (r === null)
+    throw new B("Not enough non-planar Points (v2 is null)");
+  i = new H(e, n, r);
+  for (var t = 3; t < this.points.length; t++)
+    if (!gt(it(i.normal, i.verts[0]) - it(i.normal, this.points[t]))) {
+      o = this.points[t], o.index = 3, this.points[3].index = t, this.points.splice(t, 1, this.points[3]), this.points.splice(3, 1, o);
+      break;
+    }
+  if (o === null)
+    throw new B("Not enough non-planar Points (v3 is null)");
+  i.orient(o), u = new H(e, r, o, n), f = new H(e, n, o, r), h = new H(n, r, o, e), this.addFacet(i), this.addFacet(u), this.addFacet(f), this.addFacet(h), i.link(u, e, r), i.link(f, e, n), i.link(h, n, r), u.link(f, e, o), u.link(h, r, o), f.link(h, o, n), this.current = 4;
+  for (var s, t = this.current; t < this.points.length; t++)
+    s = this.points[t], i.conflict(s) && this.addConflict(i, s), u.conflict(s) && this.addConflict(u, s), f.conflict(s) && this.addConflict(f, s), h.conflict(s) && this.addConflict(h, s);
+}, // IN: Faces old1 old2 and fn
+q.prototype.addConflicts = function(t, e, n) {
+  var r = t.conflicts.getVertices(), o = e.conflicts.getVertices(), u = [], f, h, i, s;
+  for (i = s = 0; i < r.length || s < o.length; )
+    i < r.length && s < o.length ? (f = r[i], h = o[s], f.index === h.index ? (u.push(f), i++, s++) : f.index > h.index ? (u.push(f), i++) : (u.push(h), s++)) : i < r.length ? u.push(r[i++]) : u.push(o[s++]);
+  for (var i = u.length - 1; i >= 0; i--)
+    f = u[i], n.conflict(f) && this.addConflict(n, f);
+};
+q.prototype.addConflict = function(t, e) {
+  var n = new qe(t, e);
+  t.conflicts.add(n), e.conflicts.add(n);
+};
+q.prototype.removeConflict = function(t) {
+  t.removeConflict();
+  var e = t.index;
+  if (t.index = -1, e === this.facets.length - 1) {
+    this.facets.splice(this.facets.length - 1, 1);
+    return;
+  }
+  if (!(e >= this.facets.length || e < 0)) {
+    var n = this.facets.splice(this.facets.length - 1, 1);
+    n[0].index = e, this.facets.splice(e, 1, n[0]);
+  }
+};
+q.prototype.addFacet = function(t) {
+  t.index = this.facets.length, this.facets.push(t);
+};
+q.prototype.compute = function() {
+  for (this.prep(); this.current < this.points.length; ) {
+    var t = this.points[this.current];
+    if (t.conflicts.isEmpty()) {
+      this.current++;
+      continue;
+    }
+    this.created = [], this.horizon = [], this.visible = [], t.conflicts.fill(this.visible);
+    for (var e, n = 0; n < this.visible.length; n++)
+      if (e = this.visible[n].getHorizon(), e !== null) {
+        e.findHorizon(this.horizon);
+        break;
+      }
+    for (var r = null, o = null, u = 0; u < this.horizon.length; u++) {
+      var f = this.horizon[u], h = new H(t, f.orig, f.dest, f.twin.next.dest);
+      h.conflicts = new $(!0), this.addFacet(h), this.created.push(h), this.addConflicts(f.iFace, f.twin.iFace, h), h.link(f), r !== null && h.link(r, t, f.orig), r = h, o === null && (o = h);
+    }
+    if (o !== null && r !== null && r.link(o, t, this.horizon[0].orig), this.created.length != 0) {
+      for (var i = 0; i < this.visible.length; i++)
+        this.removeConflict(this.visible[i]);
+      this.current++, this.created = [];
+    }
+  }
+  return this.facets;
+};
+q.prototype.clear = function() {
+  this.points = [], this.facets = [], this.created = [], this.horizon = [], this.visible = [], this.current = 0;
+};
+function Ue(t, e) {
+  for (var n, r = Ut(e), o = -1, u = t.length - Ut(t), f, h, i = t[u - 1], s, c, a, l; ++o < u; ) {
+    for (n = e.slice(), e.length = 0, s = t[o], c = n[(h = n.length - r) - 1], f = -1; ++f < h; )
+      a = n[f], bt(a, i, s) ? (bt(c, i, s) || (l = Yt(c, a, i, s), isFinite(l[0]) && e.push(l)), e.push(a)) : bt(c, i, s) && (l = Yt(c, a, i, s), isFinite(l[0]) && e.push(l)), c = a;
+    r && e.push(e[0]), i = s;
+  }
+  return e;
+}
+function bt(t, e, n) {
+  return (n[0] - e[0]) * (t[1] - e[1]) < (n[1] - e[1]) * (t[0] - e[0]);
+}
+function Yt(t, e, n, r) {
+  var o = t[0], u = n[0], f = e[0] - o, h = r[0] - u, i = t[1], s = n[1], c = e[1] - i, a = r[1] - s, l = (h * (i - s) - a * (o - u)) / (a * f - h * c);
+  return [o + l * f, i + l * c];
+}
+function Ut(t) {
+  var e = t[0], n = t[t.length - 1];
+  return !(e[0] - n[0] || e[1] - n[1]);
+}
+function $e(t) {
+  var e = [], n = t, r = t.dest, o = r.originalObject, u = [];
+  do {
+    n = n.twin.prev;
+    var f = n.orig.originalObject;
+    f.isDummy || u.push(f);
+    var h = n.iFace;
+    h.isVisibleFromBelow() && e.push(h);
+  } while (n !== t);
+  return o.neighbours = u, e;
+}
+function Be(t, e, n) {
+  var r = new q();
+  r.clear(), r.init(e, t);
+  for (var o = r.compute(t), u = [], f = [], h = o.length, i = 0; i < h; i++) {
+    var s = o[i];
+    if (s.isVisibleFromBelow())
+      for (var c = 0; c < 3; c++) {
+        var a = s.edges[c], l = a.dest, g = l.originalObject;
+        if (!f[l.index]) {
+          if (f[l.index] = !0, g.isDummy)
+            continue;
+          for (var v = $e(a), p = [], y = null, C = null, m = 1, k = 1, x = 0; x < v.length; x++) {
+            var w = v[x].getDualPoint(), A = w.x, b = w.y;
+            y !== null && (m = y - A, k = C - b, m < 0 && (m = -m), k < 0 && (k = -k)), (m > U || k > U) && (p.push([A, b]), y = A, C = b);
+          }
+          if (g.nonClippedPolygon = p.reverse(), !g.isDummy && We(g.nonClippedPolygon) > 0) {
+            var D = Ue(n, g.nonClippedPolygon);
+            g.polygon = D, D.site = g, D.length > 0 && u.push(D);
+          }
+        }
+      }
+  }
+  return u;
+}
+function Ze() {
+  var t = function(i) {
+    return i.x;
+  }, e = function(i) {
+    return i.y;
+  }, n = function(i) {
+    return i.weight;
+  }, r = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0]
+  ], o = [
+    [0, 0],
+    [1, 1]
+  ], u = [1, 1];
+  function f(i) {
+    var s;
+    return s = i.map(function(c) {
+      return new G(t(c), e(c), null, n(c), c, !1);
+    }), Be(s, h(), r);
+  }
+  f.x = function(i) {
+    return arguments.length ? (t = i, f) : t;
+  }, f.y = function(i) {
+    return arguments.length ? (e = i, f) : e;
+  }, f.weight = function(i) {
+    return arguments.length ? (n = i, f) : n;
+  }, f.clip = function(i) {
+    var s, c, a;
+    return arguments.length ? (c = Gt(
+      i.map(function(l) {
+        return l[0];
+      })
+    ), a = Gt(
+      i.map(function(l) {
+        return l[1];
+      })
+    ), s = Ge(i), s === void 0 ? r = Fe(i) : s === 1 ? r = i.reverse() : r = i, o = [
+      [c[0], a[0]],
+      [c[1], a[1]]
+    ], u = [c[1] - c[0], a[1] - a[0]], f) : r;
+  }, f.extent = function(i) {
+    return arguments.length ? (r = [i[0], [i[0][0], i[1][1]], i[1], [i[1][0], i[0][1]]], o = i, u = [i[1][0] - i[0][0], i[1][1] - i[0][1]], f) : o;
+  }, f.size = function(i) {
+    return arguments.length ? (r = [
+      [0, 0],
+      [0, i[1]],
+      [i[0], i[1]],
+      [i[0], 0]
+    ], o = [[0, 0], i], u = i, f) : u;
+  };
+  function h() {
+    var i, s, c, a, l, g, v, p, y, C, m = [], k = [];
+    i = o[0][0], s = o[1][0], c = o[0][1], a = o[1][1], l = s - i, g = a - c, v = i - l, p = s + l, y = c - g, C = a + g, m[0] = [v, y], m[1] = [v, C], m[2] = [p, C], m[3] = [p, y];
+    for (var x = 0; x < 4; x++)
+      k.push(
+        new G(
+          m[x][0],
+          m[x][1],
+          null,
+          U,
+          new G(m[x][0], m[x][1], null, U, null, !0),
+          !0
+        )
+      );
+    return k;
+  }
+  return f;
+}
+function J() {
+  this.growthChangesLength = oe, this.totalAvailableArea = NaN, this.lastAreaError = NaN, this.lastGrowth = NaN, this.growthChanges = [], this.growthChangeWeights = _t(this.growthChangesLength), this.growthChangeWeightsSum = Dt(this.growthChangeWeights);
+}
+var oe = 10;
+function Ke(t, e) {
+  return t >= e ? 1 : -1;
+}
+function _t(t) {
+  for (var e = 3, n = 1, r = 1, o = e, u = [], f = 0; f < t; f++)
+    u.push(o), o -= n, o < r && (o = r);
+  return u;
+}
+function Dt(t) {
+  for (var e = 0, n = 0; n < t.length; n++)
+    e += t[n];
+  return e;
+}
+J.prototype.reset = function() {
+  return this.lastAreaError = NaN, this.lastGrowth = NaN, this.growthChanges = [], this.growthChangesLength = oe, this.growthChangeWeights = _t(this.growthChangesLength), this.growthChangeWeightsSum = Dt(this.growthChangeWeights), this.totalAvailableArea = NaN, this;
+};
+J.prototype.clear = function() {
+  return this.lastAreaError = NaN, this.lastGrowth = NaN, this.growthChanges = [], this;
+};
+J.prototype.length = function(t) {
+  return arguments.length ? (parseInt(t) > 0 ? (this.growthChangesLength = Math.floor(parseInt(t)), this.growthChangeWeights = _t(this.growthChangesLength), this.growthChangeWeightsSum = Dt(this.growthChangeWeights)) : console.warn("FlickeringMitigation.length() accepts only positive integers; unable to handle " + t), this) : this.growthChangesLength;
+};
+J.prototype.totalArea = function(t) {
+  return arguments.length ? (parseFloat(t) > 0 ? this.totalAvailableArea = parseFloat(t) : console.warn("FlickeringMitigation.totalArea() accepts only positive numbers; unable to handle " + t), this) : this.totalAvailableArea;
+};
+J.prototype.add = function(t) {
+  var e, n;
+  return e = this.lastAreaError, this.lastAreaError = t, isNaN(e) || (n = this.lastGrowth, this.lastGrowth = Ke(this.lastAreaError, e)), isNaN(n) || this.growthChanges.unshift(this.lastGrowth != n), this.growthChanges.length > this.growthChangesLength && this.growthChanges.pop(), this;
+};
+J.prototype.ratio = function() {
+  var t = 0, e;
+  if (this.growthChanges.length < this.growthChangesLength || this.lastAreaError > this.totalAvailableArea / 10)
+    return 0;
+  for (var n = 0; n < this.growthChangesLength; n++)
+    this.growthChanges[n] && (t += this.growthChangeWeights[n]);
+  return e = t / this.growthChangeWeightsSum, e;
+};
+function Je() {
+  var t, e, n, r, o, u, f, h;
+  function i(c, a, l, g) {
+    var v = !1, p, y;
+    for (t !== g.clip() && (t = g.clip(), e = g.extent(), v = !0), v && s(), p = n + f * g.prng()(), y = o + h * g.prng()(); !Qt(t, [p, y]); )
+      p = n + f * g.prng()(), y = o + h * g.prng()();
+    return [p, y];
+  }
+  function s() {
+    n = e[0][0], r = e[1][0], o = e[0][1], u = e[1][1], f = r - n, h = u - o;
+  }
+  return i;
+}
+function Qe() {
+  var t, e, n, r, o;
+  function u(h, i, s, c) {
+    var a = !1;
+    return t !== c.clip() && (t = c.clip(), a |= !0), e !== s && (e = s, a |= !0), a && f(), o;
+  }
+  function f() {
+    n = e.length, r = ft(t), o = r / n / 2;
+  }
+  return u;
+}
+function tt(t) {
+  this.message = t, this.stack = new Error().stack;
+}
+tt.prototype.name = "d3VoronoiMapError";
+tt.prototype = new Error();
+function $t(t) {
+  var e = 0.01, n = 50, r = 0.01, o = Math.random, u = Je(), f = Qe(), h = 1e-10, i = function(d) {
+    return d.weight;
+  }, s = e, c = n, a = r, l = o, g = u, v = f, p = Ze(), y = new J(), C = !0, m, k, x, w, A, b, D, F, P, R = ie(Ft), V = re("tick", "end");
+  const X = 1, j = 1e3;
+  var S;
+  function Y(d) {
+    return Math.pow(d, 2);
+  }
+  function Ot(d, I) {
+    return Y(I.x - d.x) + Y(I.y - d.y);
+  }
+  P = {
+    tick: Wt,
+    restart: function() {
+      return R.restart(Ft), P;
+    },
+    stop: function() {
+      return R.stop(), P;
+    },
+    weight: function(d) {
+      return arguments.length ? (i = d, C = !0, P) : i;
+    },
+    convergenceRatio: function(d) {
+      return arguments.length ? (s = d, C = !0, P) : s;
+    },
+    maxIterationCount: function(d) {
+      return arguments.length ? (c = d, P) : c;
+    },
+    minWeightRatio: function(d) {
+      return arguments.length ? (a = d, C = !0, P) : a;
+    },
+    clip: function(d) {
+      return arguments.length ? (p.clip(d), C = !0, P) : p.clip();
+    },
+    extent: function(d) {
+      return arguments.length ? (p.extent(d), C = !0, P) : p.extent();
+    },
+    size: function(d) {
+      return arguments.length ? (p.size(d), C = !0, P) : p.size();
+    },
+    prng: function(d) {
+      return arguments.length ? (l = d, C = !0, P) : l;
+    },
+    initialPosition: function(d) {
+      return arguments.length ? (g = d, C = !0, P) : g;
+    },
+    initialWeight: function(d) {
+      return arguments.length ? (v = d, C = !0, P) : v;
+    },
+    state: function() {
+      return C && Rt(), {
+        ended: F,
+        iterationCount: w,
+        convergenceRatio: b / k,
+        polygons: A
+      };
+    },
+    on: function(d, I) {
+      return arguments.length === 1 ? V.on(d) : (V.on(d, I), P);
+    }
+  };
+  function Ft() {
+    Wt(), V.call("tick", P), F && (R.stop(), V.call("end", P));
+  }
+  function Wt() {
+    F || (C && Rt(), A = le(A, y.ratio()), w++, b = ge(A), y.add(b), D = b < x, F = D || w >= c);
+  }
+  function Rt() {
+    pe(), m = t.length, k = Math.abs(ft(p.clip())), x = s * k, y.clear().totalArea(k), w = 0, D = !1, A = ae(t, P), F = !1, C = !1;
+  }
+  function ae(d, I) {
+    var N = d.reduce(function(T, M) {
+      return Math.max(T, i(M));
+    }, -1 / 0), _ = N * a, z, E;
+    return z = d.map(function(T, M, O) {
+      return {
+        index: M,
+        weight: Math.max(i(T), _),
+        initialPosition: g(T, M, O, I),
+        initialWeight: v(T, M, O, I),
+        originalData: T
+      };
+    }), E = he(z, I), S(E), p(E);
+  }
+  function he(d, I) {
+    var N = d.reduce(function(z, E) {
+      return z += E.weight;
+    }, 0), _;
+    return d.map(function(z, E, T) {
+      return _ = z.initialPosition, Qt(p.clip(), _) || (_ = u(z, E, T, I)), {
+        index: z.index,
+        targetedArea: k * z.weight / N,
+        data: z,
+        x: _[0],
+        y: _[1],
+        weight: z.initialWeight
+        // ArlindNocaj/Voronoi-Treemap-Library uses an epsilonesque initial weight; using heavier initial weights allows faster weight adjustements, hence faster stabilization
+      };
+    });
+  }
+  function le(d, I) {
+    var N;
+    if (ue(d, I), N = d.map(function(_) {
+      return _.site.originalObject;
+    }), d = p(N), d.length < m)
+      throw new tt("at least 1 site has no area, which is not supposed to arise");
+    if (fe(d, I), N = d.map(function(_) {
+      return _.site.originalObject;
+    }), d = p(N), d.length < m)
+      throw new tt("at least 1 site has no area, which is not supposed to arise");
+    return d;
+  }
+  function ue(d, I) {
+    var N = [], _ = 0.5, z, E, T, M, O, W, L;
+    z = _ * I, E = 1 - z;
+    for (var mt = 0; mt < m; mt++)
+      T = d[mt], M = T.site.originalObject, O = Ie(T), W = O[0] - M.x, L = O[1] - M.y, W *= E, L *= E, M.x += W, M.y += L, N.push(M);
+    S(N);
+  }
+  function fe(d, I) {
+    var N = [], _ = 0.1, z, E, T, M, O, W;
+    z = _ * I;
+    for (var L = 0; L < m; L++)
+      E = d[L], T = E.site.originalObject, M = ft(E), O = T.targetedArea / M, O = Math.max(O, 1 - _ + z), O = Math.min(O, 1 + _ - z), W = T.weight * O, W = Math.max(W, h), T.weight = W, N.push(T);
+    S(N);
+  }
+  function Lt(d) {
+    var I = 0, N, _, z, E, T, M, O;
+    do {
+      if (I > j)
+        throw new tt("handleOverweighted0 is looping too much");
+      N = !1;
+      for (var W = 0; W < m; W++) {
+        _ = d[W];
+        for (var L = W + 1; L < m; L++)
+          if (z = d[L], _.weight > z.weight ? (E = _, T = z) : (E = z, T = _), M = Ot(_, z), M < E.weight - T.weight) {
+            O = M + T.weight / 2, O = Math.max(O, h), E.weight = O, N = !0, I++;
+            break;
+          }
+        if (N)
+          break;
+      }
+    } while (N);
+  }
+  function ce(d) {
+    var I = 0, N, _, z, E, T, M, O;
+    do {
+      if (I > j)
+        throw new tt("handleOverweighted1 is looping too much");
+      N = !1;
+      for (var W = 0; W < m; W++) {
+        _ = d[W];
+        for (var L = W + 1; L < m; L++)
+          if (z = d[L], _.weight > z.weight ? (E = _, T = z) : (E = z, T = _), M = Ot(_, z), M < E.weight - T.weight) {
+            O = E.weight - T.weight - M, T.weight += O + h, N = !0, I++;
+            break;
+          }
+        if (N)
+          break;
+      }
+    } while (N);
+  }
+  function ge(d) {
+    for (var I = 0, N, _, z, E = 0; E < m; E++)
+      N = d[E], _ = N.site.originalObject, z = ft(N), I += Math.abs(_.targetedArea - z);
+    return I;
+  }
+  function pe() {
+    switch (X) {
+      case 0:
+        S = Lt;
+        break;
+      case 1:
+        S = ce;
+        break;
+      default:
+        console.error("unknown 'handleOverweighted' variant; using variant #1"), S = Lt;
+    }
+  }
+  return P;
+}
+function tn() {
+  var t = 0.01, e = 50, n = 0.01, r = Math.random, o = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0]
+  ], u = [
+    [0, 0],
+    [1, 1]
+  ], f = [1, 1], h = t, i = e, s = n, c = r, a = [
+    {
+      weight: 1
+    },
+    {
+      weight: 1
+    }
+  ], l = $t(a).stop();
+  function g(p) {
+    v(o, p);
+  }
+  g.convergenceRatio = function(p) {
+    return arguments.length ? (h = p, g) : h;
+  }, g.maxIterationCount = function(p) {
+    return arguments.length ? (i = p, g) : i;
+  }, g.minWeightRatio = function(p) {
+    return arguments.length ? (s = p, g) : s;
+  }, g.clip = function(p) {
+    return arguments.length ? (l.clip(p), o = l.clip(), u = l.extent(), f = l.size(), g) : o;
+  }, g.extent = function(p) {
+    return arguments.length ? (l.extent(p), o = l.clip(), u = l.extent(), f = l.size(), g) : u;
+  }, g.size = function(p) {
+    return arguments.length ? (l.size(p), o = l.clip(), u = l.extent(), f = l.size(), g) : f;
+  }, g.prng = function(p) {
+    return arguments.length ? (c = p, g) : c;
+  };
+  function v(p, y) {
+    var C;
+    if (y.polygon = p, y.height != 0) {
+      C = $t(y.children).clip(p).weight(function(k) {
+        return k.value;
+      }).convergenceRatio(h).maxIterationCount(i).minWeightRatio(s).prng(c).stop();
+      for (var m = C.state(); !m.ended; )
+        C.tick(), m = C.state();
+      m.polygons.forEach(function(k) {
+        v(k, k.site.originalObject.data.originalData);
+      });
+    }
+  }
+  return g;
+}
+var Et = { exports: {} };
+Et.exports;
+(function(t) {
+  (function(e, n, r) {
+    function o(i) {
+      var s = this, c = h();
+      s.next = function() {
+        var a = 2091639 * s.s0 + s.c * 23283064365386963e-26;
+        return s.s0 = s.s1, s.s1 = s.s2, s.s2 = a - (s.c = a | 0);
+      }, s.c = 1, s.s0 = c(" "), s.s1 = c(" "), s.s2 = c(" "), s.s0 -= c(i), s.s0 < 0 && (s.s0 += 1), s.s1 -= c(i), s.s1 < 0 && (s.s1 += 1), s.s2 -= c(i), s.s2 < 0 && (s.s2 += 1), c = null;
+    }
+    function u(i, s) {
+      return s.c = i.c, s.s0 = i.s0, s.s1 = i.s1, s.s2 = i.s2, s;
+    }
+    function f(i, s) {
+      var c = new o(i), a = s && s.state, l = c.next;
+      return l.int32 = function() {
+        return c.next() * 4294967296 | 0;
+      }, l.double = function() {
+        return l() + (l() * 2097152 | 0) * 11102230246251565e-32;
+      }, l.quick = l, a && (typeof a == "object" && u(a, c), l.state = function() {
+        return u(c, {});
+      }), l;
+    }
+    function h() {
+      var i = 4022871197, s = function(c) {
+        c = String(c);
+        for (var a = 0; a < c.length; a++) {
+          i += c.charCodeAt(a);
+          var l = 0.02519603282416938 * i;
+          i = l >>> 0, l -= i, l *= i, i = l >>> 0, l -= i, i += l * 4294967296;
+        }
+        return (i >>> 0) * 23283064365386963e-26;
+      };
+      return s;
+    }
+    n && n.exports ? n.exports = f : this.alea = f;
+  })(
+    K,
+    t
+  );
+})(Et);
+var en = Et.exports, Tt = { exports: {} };
+Tt.exports;
+(function(t) {
+  (function(e, n, r) {
+    function o(h) {
+      var i = this, s = "";
+      i.x = 0, i.y = 0, i.z = 0, i.w = 0, i.next = function() {
+        var a = i.x ^ i.x << 11;
+        return i.x = i.y, i.y = i.z, i.z = i.w, i.w ^= i.w >>> 19 ^ a ^ a >>> 8;
+      }, h === (h | 0) ? i.x = h : s += h;
+      for (var c = 0; c < s.length + 64; c++)
+        i.x ^= s.charCodeAt(c) | 0, i.next();
+    }
+    function u(h, i) {
+      return i.x = h.x, i.y = h.y, i.z = h.z, i.w = h.w, i;
+    }
+    function f(h, i) {
+      var s = new o(h), c = i && i.state, a = function() {
+        return (s.next() >>> 0) / 4294967296;
+      };
+      return a.double = function() {
+        do
+          var l = s.next() >>> 11, g = (s.next() >>> 0) / 4294967296, v = (l + g) / (1 << 21);
+        while (v === 0);
+        return v;
+      }, a.int32 = s.next, a.quick = a, c && (typeof c == "object" && u(c, s), a.state = function() {
+        return u(s, {});
+      }), a;
+    }
+    n && n.exports ? n.exports = f : this.xor128 = f;
+  })(
+    K,
+    t
+  );
+})(Tt);
+var nn = Tt.exports, kt = { exports: {} };
+kt.exports;
+(function(t) {
+  (function(e, n, r) {
+    function o(h) {
+      var i = this, s = "";
+      i.next = function() {
+        var a = i.x ^ i.x >>> 2;
+        return i.x = i.y, i.y = i.z, i.z = i.w, i.w = i.v, (i.d = i.d + 362437 | 0) + (i.v = i.v ^ i.v << 4 ^ (a ^ a << 1)) | 0;
+      }, i.x = 0, i.y = 0, i.z = 0, i.w = 0, i.v = 0, h === (h | 0) ? i.x = h : s += h;
+      for (var c = 0; c < s.length + 64; c++)
+        i.x ^= s.charCodeAt(c) | 0, c == s.length && (i.d = i.x << 10 ^ i.x >>> 4), i.next();
+    }
+    function u(h, i) {
+      return i.x = h.x, i.y = h.y, i.z = h.z, i.w = h.w, i.v = h.v, i.d = h.d, i;
+    }
+    function f(h, i) {
+      var s = new o(h), c = i && i.state, a = function() {
+        return (s.next() >>> 0) / 4294967296;
+      };
+      return a.double = function() {
+        do
+          var l = s.next() >>> 11, g = (s.next() >>> 0) / 4294967296, v = (l + g) / (1 << 21);
+        while (v === 0);
+        return v;
+      }, a.int32 = s.next, a.quick = a, c && (typeof c == "object" && u(c, s), a.state = function() {
+        return u(s, {});
+      }), a;
+    }
+    n && n.exports ? n.exports = f : this.xorwow = f;
+  })(
+    K,
+    t
+  );
+})(kt);
+var rn = kt.exports, Nt = { exports: {} };
+Nt.exports;
+(function(t) {
+  (function(e, n, r) {
+    function o(h) {
+      var i = this;
+      i.next = function() {
+        var c = i.x, a = i.i, l, g;
+        return l = c[a], l ^= l >>> 7, g = l ^ l << 24, l = c[a + 1 & 7], g ^= l ^ l >>> 10, l = c[a + 3 & 7], g ^= l ^ l >>> 3, l = c[a + 4 & 7], g ^= l ^ l << 7, l = c[a + 7 & 7], l = l ^ l << 13, g ^= l ^ l << 9, c[a] = g, i.i = a + 1 & 7, g;
+      };
+      function s(c, a) {
+        var l, g = [];
+        if (a === (a | 0))
+          g[0] = a;
+        else
+          for (a = "" + a, l = 0; l < a.length; ++l)
+            g[l & 7] = g[l & 7] << 15 ^ a.charCodeAt(l) + g[l + 1 & 7] << 13;
+        for (; g.length < 8; ) g.push(0);
+        for (l = 0; l < 8 && g[l] === 0; ++l) ;
+        for (l == 8 ? g[7] = -1 : g[l], c.x = g, c.i = 0, l = 256; l > 0; --l)
+          c.next();
+      }
+      s(i, h);
+    }
+    function u(h, i) {
+      return i.x = h.x.slice(), i.i = h.i, i;
+    }
+    function f(h, i) {
+      h == null && (h = +/* @__PURE__ */ new Date());
+      var s = new o(h), c = i && i.state, a = function() {
+        return (s.next() >>> 0) / 4294967296;
+      };
+      return a.double = function() {
+        do
+          var l = s.next() >>> 11, g = (s.next() >>> 0) / 4294967296, v = (l + g) / (1 << 21);
+        while (v === 0);
+        return v;
+      }, a.int32 = s.next, a.quick = a, c && (c.x && u(c, s), a.state = function() {
+        return u(s, {});
+      }), a;
+    }
+    n && n.exports ? n.exports = f : this.xorshift7 = f;
+  })(
+    K,
+    t
+  );
+})(Nt);
+var on = Nt.exports, It = { exports: {} };
+It.exports;
+(function(t) {
+  (function(e, n, r) {
+    function o(h) {
+      var i = this;
+      i.next = function() {
+        var c = i.w, a = i.X, l = i.i, g, v;
+        return i.w = c = c + 1640531527 | 0, v = a[l + 34 & 127], g = a[l = l + 1 & 127], v ^= v << 13, g ^= g << 17, v ^= v >>> 15, g ^= g >>> 12, v = a[l] = v ^ g, i.i = l, v + (c ^ c >>> 16) | 0;
+      };
+      function s(c, a) {
+        var l, g, v, p, y, C = [], m = 128;
+        for (a === (a | 0) ? (g = a, a = null) : (a = a + "\0", g = 0, m = Math.max(m, a.length)), v = 0, p = -32; p < m; ++p)
+          a && (g ^= a.charCodeAt((p + 32) % a.length)), p === 0 && (y = g), g ^= g << 10, g ^= g >>> 15, g ^= g << 4, g ^= g >>> 13, p >= 0 && (y = y + 1640531527 | 0, l = C[p & 127] ^= g + y, v = l == 0 ? v + 1 : 0);
+        for (v >= 128 && (C[(a && a.length || 0) & 127] = -1), v = 127, p = 4 * 128; p > 0; --p)
+          g = C[v + 34 & 127], l = C[v = v + 1 & 127], g ^= g << 13, l ^= l << 17, g ^= g >>> 15, l ^= l >>> 12, C[v] = g ^ l;
+        c.w = y, c.X = C, c.i = v;
+      }
+      s(i, h);
+    }
+    function u(h, i) {
+      return i.i = h.i, i.w = h.w, i.X = h.X.slice(), i;
+    }
+    function f(h, i) {
+      h == null && (h = +/* @__PURE__ */ new Date());
+      var s = new o(h), c = i && i.state, a = function() {
+        return (s.next() >>> 0) / 4294967296;
+      };
+      return a.double = function() {
+        do
+          var l = s.next() >>> 11, g = (s.next() >>> 0) / 4294967296, v = (l + g) / (1 << 21);
+        while (v === 0);
+        return v;
+      }, a.int32 = s.next, a.quick = a, c && (c.X && u(c, s), a.state = function() {
+        return u(s, {});
+      }), a;
+    }
+    n && n.exports ? n.exports = f : this.xor4096 = f;
+  })(
+    K,
+    // window object or global
+    t
+  );
+})(It);
+var sn = It.exports, Mt = { exports: {} };
+Mt.exports;
+(function(t) {
+  (function(e, n, r) {
+    function o(h) {
+      var i = this, s = "";
+      i.next = function() {
+        var a = i.b, l = i.c, g = i.d, v = i.a;
+        return a = a << 25 ^ a >>> 7 ^ l, l = l - g | 0, g = g << 24 ^ g >>> 8 ^ v, v = v - a | 0, i.b = a = a << 20 ^ a >>> 12 ^ l, i.c = l = l - g | 0, i.d = g << 16 ^ l >>> 16 ^ v, i.a = v - a | 0;
+      }, i.a = 0, i.b = 0, i.c = -1640531527, i.d = 1367130551, h === Math.floor(h) ? (i.a = h / 4294967296 | 0, i.b = h | 0) : s += h;
+      for (var c = 0; c < s.length + 20; c++)
+        i.b ^= s.charCodeAt(c) | 0, i.next();
+    }
+    function u(h, i) {
+      return i.a = h.a, i.b = h.b, i.c = h.c, i.d = h.d, i;
+    }
+    function f(h, i) {
+      var s = new o(h), c = i && i.state, a = function() {
+        return (s.next() >>> 0) / 4294967296;
+      };
+      return a.double = function() {
+        do
+          var l = s.next() >>> 11, g = (s.next() >>> 0) / 4294967296, v = (l + g) / (1 << 21);
+        while (v === 0);
+        return v;
+      }, a.int32 = s.next, a.quick = a, c && (typeof c == "object" && u(c, s), a.state = function() {
+        return u(s, {});
+      }), a;
+    }
+    n && n.exports ? n.exports = f : this.tychei = f;
+  })(
+    K,
+    t
+  );
+})(Mt);
+var an = Mt.exports, se = { exports: {} };
+const hn = {}, ln = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: hn
+}, Symbol.toStringTag, { value: "Module" })), un = /* @__PURE__ */ ke(ln);
+(function(t) {
+  (function(e, n, r) {
+    var o = 256, u = 6, f = 52, h = "random", i = r.pow(o, u), s = r.pow(2, f), c = s * 2, a = o - 1, l;
+    function g(x, w, A) {
+      var b = [];
+      w = w == !0 ? { entropy: !0 } : w || {};
+      var D = C(y(
+        w.entropy ? [x, k(n)] : x ?? m(),
+        3
+      ), b), F = new v(b), P = function() {
+        for (var R = F.g(u), V = i, X = 0; R < s; )
+          R = (R + X) * o, V *= o, X = F.g(1);
+        for (; R >= c; )
+          R /= 2, V /= 2, X >>>= 1;
+        return (R + X) / V;
+      };
+      return P.int32 = function() {
+        return F.g(4) | 0;
+      }, P.quick = function() {
+        return F.g(4) / 4294967296;
+      }, P.double = P, C(k(F.S), n), (w.pass || A || function(R, V, X, j) {
+        return j && (j.S && p(j, F), R.state = function() {
+          return p(F, {});
+        }), X ? (r[h] = R, V) : R;
+      })(
+        P,
+        D,
+        "global" in w ? w.global : this == r,
+        w.state
+      );
+    }
+    function v(x) {
+      var w, A = x.length, b = this, D = 0, F = b.i = b.j = 0, P = b.S = [];
+      for (A || (x = [A++]); D < o; )
+        P[D] = D++;
+      for (D = 0; D < o; D++)
+        P[D] = P[F = a & F + x[D % A] + (w = P[D])], P[F] = w;
+      (b.g = function(R) {
+        for (var V, X = 0, j = b.i, S = b.j, Y = b.S; R--; )
+          V = Y[j = a & j + 1], X = X * o + Y[a & (Y[j] = Y[S = a & S + V]) + (Y[S] = V)];
+        return b.i = j, b.j = S, X;
+      })(o);
+    }
+    function p(x, w) {
+      return w.i = x.i, w.j = x.j, w.S = x.S.slice(), w;
+    }
+    function y(x, w) {
+      var A = [], b = typeof x, D;
+      if (w && b == "object")
+        for (D in x)
+          try {
+            A.push(y(x[D], w - 1));
+          } catch {
+          }
+      return A.length ? A : b == "string" ? x : x + "\0";
+    }
+    function C(x, w) {
+      for (var A = x + "", b, D = 0; D < A.length; )
+        w[a & D] = a & (b ^= w[a & D] * 19) + A.charCodeAt(D++);
+      return k(w);
+    }
+    function m() {
+      try {
+        var x;
+        return l && (x = l.randomBytes) ? x = x(o) : (x = new Uint8Array(o), (e.crypto || e.msCrypto).getRandomValues(x)), k(x);
+      } catch {
+        var w = e.navigator, A = w && w.plugins;
+        return [+/* @__PURE__ */ new Date(), e, A, e.screen, k(n)];
+      }
+    }
+    function k(x) {
+      return String.fromCharCode.apply(0, x);
+    }
+    if (C(r.random(), n), t.exports) {
+      t.exports = g;
+      try {
+        l = un;
+      } catch {
+      }
+    } else
+      r["seed" + h] = g;
+  })(
+    // global: `self` in browsers (including strict mode and web workers),
+    // otherwise `this` in Node and other environments
+    typeof self < "u" ? self : K,
+    [],
+    // pool: entropy pool starts empty
+    Math
+    // math: package containing random, pow, and seedrandom
+  );
+})(se);
+var fn = se.exports, cn = en, gn = nn, pn = rn, vn = on, dn = sn, xn = an, Q = fn;
+Q.alea = cn;
+Q.xor128 = gn;
+Q.xorwow = pn;
+Q.xorshift7 = vn;
+Q.xor4096 = dn;
+Q.tychei = xn;
+var wn = Q;
+const Bt = /* @__PURE__ */ Ne(wn);
+class xt extends Jt {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_tag", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "voronoitreemap"
+    }), Object.defineProperty(this, "polygons", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new ve(de.new({}), () => pt._new(this._root, {
+        themeTags: Ee(this.polygons.template.get("themeTags", []), [this._tag, "shape"])
+      }, [this.polygons.template])))
+    }), Object.defineProperty(this, "voronoi", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: tn()
+    });
+  }
+  _afterNew() {
+    this.nodesContainer.setAll({
+      x: lt,
+      y: lt,
+      centerX: lt,
+      centerY: lt
+    }), this.nodes.template.setPrivate("trustBounds", !0), super._afterNew();
+  }
+  _prepareChildren() {
+    super._prepareChildren();
+    const e = this.innerWidth() / 2, n = this.innerHeight() / 2;
+    let r = this._rootNode;
+    const o = this.get("selectedDataItem");
+    o && (r = o.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(Bt("X")), this.voronoi.clip([[-e, -n], [-e, n], [e, n], [e, -n]])(r), this._updateVisuals()), (this._valuesDirty || this.isDirty("selectedDataItem")) && r && (this.voronoi.prng(Bt("X")), this.voronoi(r), this._updateVisuals());
+  }
+  _updateNode(e) {
+    const n = e.get("d3HierarchyNode").polygon, r = e.get("polygon");
+    if (n && r) {
+      let o = [], u = 1;
+      this.get("type") == "polygon" && (u = Math.min(this.innerWidth(), this.innerHeight()) / 2);
+      let f = 1 / 0, h = -1 / 0;
+      for (let a = 0, l = n.length; a < l; a++) {
+        const g = n[a];
+        let v = g[0] * u, p = g[1] * u;
+        o.push([v, p]), f = Math.min(f, v), h = Math.max(h, v);
+      }
+      r.set("coordinates", o);
+      const i = e.get("fill"), s = e.get("fillPattern");
+      r._setDefault("fill", i), r._setDefault("fillPattern", s);
+      const c = e.get("label");
+      if (c) {
+        const a = n.site;
+        a && c.setAll({
+          x: a.x * u,
+          y: a.y * u,
+          maxWidth: Math.abs(h - f)
+        });
+      }
+    }
+  }
+  _handleSingle(e) {
+    const n = e.get("parent");
+    if (n) {
+      const r = n.get("children");
+      r && Kt(r, (o) => {
+        o != e && (this.disableDataItem(o), o.get("node").hide());
+      }), this._handleSingle(n);
+    }
+  }
+  /**
+   * @ignore
+   */
+  makeNode(e) {
+    const n = super.makeNode(e);
+    return this._makeNode(e, n), n;
+  }
+  _makeNode(e, n) {
+    const r = n.children.moveValue(this.polygons.make(), 0);
+    n.setPrivate("tooltipTarget", r), e.setRaw("polygon", r), r._setDataItem(e);
+  }
+  getCirclePolygon(e) {
+    const n = this.get("cornerCount", 120), r = Math.PI * 2 / n, o = [];
+    for (let u = 0; u < n; u++) {
+      let f = u * r;
+      o.push([e * Math.cos(f), e * Math.sin(f)]);
+    }
+    return o;
+  }
+}
+Object.defineProperty(xt, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "VoronoiTreemap"
+});
+Object.defineProperty(xt, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: Jt.classNames.concat([xt.className])
+});
+const Tn = (t) => {
+  const e = ye({
+    props: t,
+    name: "HCDrillDownVoronoiTreemap"
+  }), {
+    dimensions: n,
+    values: r,
+    data: o,
+    initDelay: u = 0,
+    colors: f,
+    sx: h,
+    ...i
+  } = e, s = be(), a = `hc-drill-down-voronoi-treemap-${Pe().replace(/:/g, "")}`, l = ze(null);
+  _e(() => {
+    let v;
+    return v = setTimeout(() => {
+      if (n.length < 2) {
+        console.error("DrillDownVoronoiTreemap requires at least 2 dimensions");
+        return;
+      }
+      if (r.length < 1) {
+        console.error("DrillDownVoronoiTreemap requires at least 1 value");
+        return;
+      }
+      const p = xe.new(a);
+      l.current = p;
+      const y = we.new(p);
+      y.rule("Polygon", ["hierarchy", "node", "shape", "depth0"]).setAll({ strokeOpacity: 0, fillOpacity: 0 }), y.rule("Polygon", ["hierarchy", "node", "shape", "depth1"]).setAll({
+        strokeWidth: 5,
+        fillOpacity: 1,
+        stroke: Ht(0)
+      }), y.rule("Polygon", ["hierarchy", "node", "shape", "depth2"]).setAll({
+        fillOpacity: 0,
+        strokeWidth: 1,
+        stroke: Ht(0)
+      }), y.rule("HierarchyNode", ["last"]).setAll({ cursorOverStyle: "pointer" }), y.rule("Label", ["node"]).setAll({ fontSize: 11, minScale: 0.7 }), y.rule("Label", ["node", "depth0"]).setAll({ forceHidden: !0 }), y.rule("Label", ["node", "depth1"]).setAll({ forceHidden: !0 }), p.setThemes([me.new(p), y]);
+      const m = p.container.children.push(
+        Te.new(p, {
+          width: Vt,
+          height: Vt,
+          wheelable: !0,
+          pinchZoom: !0
+        })
+      ).contents.children.push(
+        xt.new(p, {
+          paddingLeft: 5,
+          paddingRight: 5,
+          paddingTop: 5,
+          paddingBottom: 5,
+          singleBranchOnly: !0,
+          downDepth: 2,
+          upDepth: 0,
+          initialDepth: 2,
+          valueField: r[0].dataFieldName,
+          categoryField: "name",
+          childDataField: "children",
+          idField: "name",
+          type: "polygon",
+          cornerCount: 120
+        })
+      );
+      m.set("colors", De(p, f)), m.labels.template.adapters.add("x", function(x, w) {
+        const A = w.dataItem;
+        if (A) {
+          const b = A.get("polygon");
+          if (b) {
+            const D = b.getPrivate("minX", 0), F = b.getPrivate("maxX", 0), P = A.dataContext;
+            P && (F - D < 50 ? w.set("text", P.id) : w.set("text", P.name));
+          }
+        }
+        return x;
+      }), m.nodes.template.events.on("click", function(x) {
+        const w = x.target.dataItem;
+        w && (w.get("children") || m.selectDataItem(w.get("parent")));
+      });
+      const k = (x, w, A) => {
+        if (x === "date") {
+          let b = "YYYY";
+          return w.includes("month") ? b = "MMM YYYY" : w.includes("day") && (b = "DD MMM YYYY"), Ce(A).format(b);
+        }
+        return A;
+      };
+      if (n.length > 1) {
+        const x = Ae.groupBy(o, n[0].value), w = [];
+        Object.keys(x).forEach((A) => {
+          w.push({
+            name: k(n[0].type, n[0].value, A),
+            children: x[A].map((b) => ({
+              name: k(
+                n[1].type,
+                n[1].value,
+                b[n[1].value]
+              ),
+              [r[0].dataFieldName]: b[r[0].dataFieldName]
+            }))
+          });
+        }), m.data.setAll([{ children: w }]);
+      }
+      m.set("selectedDataItem", m.dataItems[0]), m.appear(1e3, 100);
+    }, u), () => {
+      var p;
+      v && clearTimeout(v), (p = l.current) == null || p.dispose(), l.current = null;
+    };
+  }, [o, n, r, s.palette.mode, f]);
+  const g = { ...e };
+  return { chartId: a, ownerState: g, sx: h, other: i };
+};
+export {
+  Tn as useDrillDownVoronoiTreemapLogic
+};