@hybridcore/ui 1.5.89 → 1.6.0

package/dist/ColorSet-C7vpNXhM.js

@@ -0,0 +1,2957 @@
+function Q(s, e, t, i) {
+  function r(n) {
+    return n instanceof t ? n : new t(function(a) {
+      a(n);
+    });
+  }
+  return new (t || (t = Promise))(function(n, a) {
+    function u(f) {
+      try {
+        l(i.next(f));
+      } catch (d) {
+        a(d);
+      }
+    }
+    function o(f) {
+      try {
+        l(i.throw(f));
+      } catch (d) {
+        a(d);
+      }
+    }
+    function l(f) {
+      f.done ? n(f.value) : r(f.value).then(u, o);
+    }
+    l((i = i.apply(s, e || [])).next());
+  });
+}
+class g {
+  /**
+   * Constructor.
+   *
+   * @param percent  Percent value
+   */
+  constructor(e) {
+    Object.defineProperty(this, "_value", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._value = e;
+  }
+  /**
+   * Relative value.
+   *
+   * E.g. 100% is 1, 50% is 0.5, etc.
+   *
+   * This is useful to apply transformations to other values. E.g.:
+   *
+   * ```TypeScript
+   * let value = 256;
+   * let percent = new am5.p50;
+   * console.log(value * percent.value); // outputs 128
+   * ```
+   * ```JavaScript
+   * var value = 256;
+   * var percent = new am5.p50;
+   * console.log(value * percent.value); // outputs 128
+   * ```
+   *
+   * Alternatively, you can use `am5.percent()` helper function:
+   *
+   * ```TypeScript
+   * let value = 256;
+   * let percent = am5.p50;
+   * console.log(value * percent.value); // outputs 128
+   * ```
+   * ```JavaScript
+   * var value = 256;
+   * var percent = am5.p50;
+   * console.log(value * percent.value); // outputs 128
+   * ```
+   *
+   * @readonly
+   * @return Relative value
+   */
+  get value() {
+    return this._value / 100;
+  }
+  /**
+   * Value in percent.
+   *
+   * @readonly
+   * @return Percent
+   */
+  get percent() {
+    return this._value;
+  }
+  toString() {
+    return "" + this._value + "%";
+  }
+  interpolate(e, t) {
+    return e + this.value * (t - e);
+  }
+  static normalize(e, t, i) {
+    return e instanceof g ? e : t === i ? new g(0) : new g(Math.min(Math.max((e - t) * (1 / (i - t)), 0), 1) * 100);
+  }
+}
+function R(s) {
+  return new g(s);
+}
+R(0);
+const Ie = R(100), Le = R(50);
+function Fe(s) {
+  return s instanceof g;
+}
+function Y(s) {
+  return Number(s) !== s;
+}
+function X(s) {
+  return {}.toString.call(s);
+}
+function k(s) {
+  if (s != null && !v(s)) {
+    let e = Number(s);
+    if (Y(e) && $(s) && s != "" && s.match(/[0-9]+/)) {
+      const t = s.replace(/[^0-9.\-]+/g, "");
+      return s === t ? e : k(t);
+    }
+    return e;
+  }
+  return s;
+}
+function Re(s) {
+  if (ee(s))
+    return new Date(s);
+  if (v(s))
+    return new Date(s);
+  {
+    let e = Number(s);
+    return v(e) ? new Date(e) : new Date(s);
+  }
+}
+function Me(s) {
+  if (Y(s))
+    return "NaN";
+  if (s === 1 / 0)
+    return "Infinity";
+  if (s === -1 / 0)
+    return "-Infinity";
+  if (s === 0 && 1 / s === -1 / 0)
+    return "-0";
+  let e = s < 0;
+  s = Math.abs(s);
+  let t = /^([0-9]+)(?:\.([0-9]+))?(?:e[\+\-]([0-9]+))?$/.exec("" + s), i = t[1], r = t[2] || "", n;
+  if (t[3] === void 0)
+    n = r === "" ? i : i + "." + r;
+  else {
+    let a = +t[3];
+    if (s < 1) {
+      let u = a - 1;
+      n = "0." + K("0", u) + i + r;
+    } else {
+      let u = a - r.length;
+      u === 0 ? n = i + r : u < 0 ? n = i + r.slice(0, u) + "." + r.slice(u) : n = i + r + K("0", u);
+    }
+  }
+  return e ? "-" + n : n;
+}
+function K(s, e) {
+  return new Array(e + 1).join(s);
+}
+function ee(s) {
+  return X(s) === "[object Date]";
+}
+function $(s) {
+  return typeof s == "string";
+}
+function v(s) {
+  return typeof s == "number" && Number(s) == s;
+}
+function Ne(s) {
+  return typeof s == "object" && s !== null;
+}
+function Ke(s) {
+  return Array.isArray(s);
+}
+const Be = "__§§§__", Ue = "__§§§§__";
+function I(s, e) {
+  const t = s.length;
+  for (let i = 0; i < t; ++i)
+    if (s[i] === e)
+      return i;
+  return -1;
+}
+function te(s, e) {
+  const t = s.length;
+  for (let i = 0; i < t; ++i)
+    if (e(s[i]))
+      return !0;
+  return !1;
+}
+function He(s, e) {
+  const t = s.length, i = new Array(t);
+  for (let r = 0; r < t; ++r)
+    i[r] = e(s[r], r);
+  return i;
+}
+function c(s, e) {
+  const t = s.length;
+  for (let i = 0; i < t; ++i)
+    e(s[i], i);
+}
+function j(s, e) {
+  let t = s.length;
+  for (; t > 0; )
+    --t, e(s[t], t);
+}
+function ze(s, e) {
+  const t = s.length;
+  for (let i = 0; i < t && e(s[i], i); ++i)
+    ;
+}
+function se(s, e) {
+  let t = !1, i = 0;
+  for (; ; ) {
+    if (i = s.indexOf(e, i), i === -1)
+      return t;
+    t = !0, s.splice(i, 1);
+  }
+}
+function P(s, e) {
+  let t = s.indexOf(e);
+  return t !== -1 ? (s.splice(t, 1), !0) : !1;
+}
+function Ye(s, e, t) {
+  let i = I(s, e);
+  i !== -1 && ie(s, i), s.push(e);
+}
+function $e(s, e) {
+  s.indexOf(e) === -1 && s.push(e);
+}
+function We(s) {
+  const e = s.length, t = new Array(e);
+  for (let i = 0; i < e; ++i)
+    t[i] = s[i];
+  return t;
+}
+function Ze(s, e, t) {
+  s.splice(e, 0, t);
+}
+function ie(s, e) {
+  s.splice(e, 1);
+}
+function W(s, e) {
+  const t = s.length;
+  for (let i = 0; i < t; ++i)
+    if (e(s[i], i))
+      return i;
+  return -1;
+}
+function re(s, e) {
+  let t = s.length;
+  for (; t > 0; )
+    if (--t, e(s[t], t))
+      return t;
+  return -1;
+}
+function ne(s, e) {
+  const t = W(s, e);
+  if (t !== -1)
+    return s[t];
+}
+function ae(s, e) {
+  const t = re(s, e);
+  if (t !== -1)
+    return s[t];
+}
+function Ge(s, e) {
+  let t = 0, i = s.length, r = !1;
+  for (; t < i; ) {
+    const n = t + i >> 1, a = e(s[n]);
+    a < 0 ? t = n + 1 : a === 0 ? (r = !0, t = n + 1) : i = n;
+  }
+  return {
+    found: r,
+    index: r ? t - 1 : t
+  };
+}
+function ue(s, e) {
+  let t = 0, i = s.length, r = !1;
+  for (; t < i; ) {
+    const n = t + i >> 1, a = e(s[n]);
+    a < 0 ? t = n + 1 : (a === 0 && (r = !0), i = n);
+  }
+  return {
+    found: r,
+    index: t
+  };
+}
+function Ve(s, e) {
+  let t = s.length;
+  for (; t > 0; )
+    --t, e(s[t]) || s.splice(t, 1);
+}
+function y(s) {
+  return Object.keys(s);
+}
+function qe(s, e) {
+  return y(s).sort(e);
+}
+function Je(s) {
+  return Object.assign({}, s);
+}
+function p(s, e) {
+  y(s).forEach((t) => {
+    e(t, s[t]);
+  });
+}
+function Qe(s, e) {
+  for (let t in s)
+    if (oe(s, t) && !e(t, s[t]))
+      break;
+}
+function oe(s, e) {
+  return {}.hasOwnProperty.call(s, e);
+}
+class Z {
+  /**
+   * Constructor.
+   */
+  constructor() {
+    Object.defineProperty(this, "_disposed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._disposed = !1;
+  }
+  /**
+   * Checks if object is disposed.
+   *
+   * @return Disposed?
+   */
+  isDisposed() {
+    return this._disposed;
+  }
+  /**
+   * Disposes the object.
+   */
+  dispose() {
+    this._disposed || (this._disposed = !0, this._dispose());
+  }
+}
+class w {
+  /**
+   * Constructor.
+   *
+   * @param dispose  Function that disposes object
+   */
+  constructor(e) {
+    Object.defineProperty(this, "_disposed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_dispose", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._disposed = !1, this._dispose = e;
+  }
+  /**
+   * Checks if object is disposed.
+   *
+   * @return Disposed?
+   */
+  isDisposed() {
+    return this._disposed;
+  }
+  /**
+   * Disposes the object.
+   */
+  dispose() {
+    this._disposed || (this._disposed = !0, this._dispose());
+  }
+}
+class Xe extends Z {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_disposers", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    });
+  }
+  _dispose() {
+    c(this._disposers, (e) => {
+      e.dispose();
+    });
+  }
+}
+class le extends Z {
+  constructor(e) {
+    super(), Object.defineProperty(this, "_disposers", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._disposers = e;
+  }
+  _dispose() {
+    c(this._disposers, (e) => {
+      e.dispose();
+    });
+  }
+  get disposers() {
+    return this._disposers;
+  }
+}
+class ke extends w {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_counter", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    });
+  }
+  /**
+   * [increment description]
+   *
+   * @todo Description
+   */
+  increment() {
+    return ++this._counter, new w(() => {
+      --this._counter, this._counter === 0 && this.dispose();
+    });
+  }
+}
+function et(s) {
+  s.parentNode && s.parentNode.removeChild(s);
+}
+function he(s, e, t, i) {
+  return s.addEventListener(e, t, i || !1), new w(() => {
+    s.removeEventListener(e, t, i || !1);
+  });
+}
+function tt(s) {
+  return he(window, "resize", (e) => {
+    s();
+  });
+}
+function x(s) {
+  switch (s) {
+    case "touchevents":
+      return window.hasOwnProperty("TouchEvent");
+    case "pointerevents":
+      return window.hasOwnProperty("PointerEvent");
+    case "mouseevents":
+      return window.hasOwnProperty("MouseEvent");
+    case "wheelevents":
+      return window.hasOwnProperty("WheelEvent");
+    case "keyboardevents":
+      return window.hasOwnProperty("KeyboardEvent");
+  }
+  return !1;
+}
+function st(s) {
+  return s.pointerId || 0;
+}
+function it() {
+  if (document.activeElement && document.activeElement != document.body)
+    if (document.activeElement.blur)
+      document.activeElement.blur();
+    else {
+      let s = document.createElement("button");
+      s.style.position = "fixed", s.style.top = "0px", s.style.left = "-10000px", document.body.appendChild(s), s.focus(), s.blur(), document.body.removeChild(s);
+    }
+}
+function rt(s) {
+  s && s.focus();
+}
+function nt(s) {
+  if (x("pointerevents"))
+    return s;
+  if (x("touchevents"))
+    switch (s) {
+      case "pointerover":
+        return "touchstart";
+      case "pointerout":
+        return "touchend";
+      case "pointerleave":
+        return "touchend";
+      case "pointerdown":
+        return "touchstart";
+      case "pointermove":
+        return "touchmove";
+      case "pointerup":
+        return "touchend";
+      case "click":
+        return "click";
+      case "dblclick":
+        return "dblclick";
+    }
+  else if (x("mouseevents"))
+    switch (s) {
+      case "pointerover":
+        return "mouseover";
+      case "pointerout":
+        return "mouseout";
+      case "pointerleave":
+        return "mouseleave";
+      case "pointerdown":
+        return "mousedown";
+      case "pointermove":
+        return "mousemove";
+      case "pointerup":
+        return "mouseup";
+      case "click":
+        return "click";
+      case "dblclick":
+        return "dblclick";
+    }
+  return s;
+}
+function at(s) {
+  if (typeof Touch < "u" && s instanceof Touch)
+    return !0;
+  if (typeof PointerEvent < "u" && s instanceof PointerEvent && s.pointerType != null)
+    switch (s.pointerType) {
+      case "touch":
+      case "pen":
+      case 2:
+        return !0;
+      case "mouse":
+      case 4:
+        return !1;
+      default:
+        return !(s instanceof MouseEvent);
+    }
+  else if (s.type != null && s.type.match(/^mouse/))
+    return !1;
+  return !0;
+}
+function ut(s, e, t) {
+  s.style[e] = t;
+}
+function ot(s, e) {
+  return s.style[e];
+}
+function lt(s) {
+  if (s.composedPath) {
+    const e = s.composedPath();
+    return e.length === 0 ? null : e[0];
+  } else
+    return s.target;
+}
+function ce(s, e) {
+  let t = e;
+  for (; ; ) {
+    if (s === t)
+      return !0;
+    if (t.parentNode === null) {
+      if (t.host == null)
+        return !1;
+      t = t.host;
+    } else
+      t = t.parentNode;
+  }
+}
+function ht(s, e) {
+  return s.target && ce(e.root.dom, s.target);
+}
+function ct(s, e) {
+  e ? s.style.pointerEvents = "auto" : s.style.pointerEvents = "none";
+}
+function ft(s) {
+  if (s.key !== void 0)
+    return s.key;
+  switch (s.keyCode) {
+    case 9:
+      return "Tab";
+    case 13:
+      return "Enter";
+    case 16:
+      return "Shift";
+    case 17:
+      return "Control";
+    case 27:
+      return "Escape";
+    case 32:
+      return " ";
+    case 37:
+      return "ArrowLeft";
+    case 38:
+      return "ArrowUp";
+    case 39:
+      return "ArrowRight";
+    case 40:
+      return "ArrowDown";
+    case 46:
+      return "Delete";
+  }
+  return "" + s.keyCode;
+}
+function fe() {
+  return /apple/i.test(navigator.vendor) && "ontouchend" in document;
+}
+function dt() {
+  return fe() ? 1 : void 0;
+}
+function pt(s, e) {
+  return v(s) ? s : s != null && v(s.value) && v(e) ? e * s.value : 0;
+}
+function _t(s) {
+  let e = ("" + s).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+  return e ? Math.max(0, (e[1] ? e[1].length : 0) - (e[2] ? +e[2] : 0)) : 0;
+}
+function A(s, e = 0, t = "0") {
+  return typeof s != "string" && (s = s.toString()), e > s.length ? Array(e - s.length + 1).join(t) + s : s;
+}
+function de(s) {
+  return s.replace(/^[\s]*/, "");
+}
+function pe(s) {
+  return s.replace(/[\s]*$/, "");
+}
+function B(s) {
+  return de(pe(s));
+}
+function gt(s, e, t = !1, i = "...") {
+  if (s.length > e) {
+    let r = e - 1;
+    for (; r >= 0 && s.charAt(r).match(/\w/); )
+      r--;
+    return r >= 0 && t == !1 ? s.substring(0, r + 1) + "..." : s.substring(0, e) + i;
+  } else
+    return s;
+}
+function mt(s) {
+  return s.replace(/\/(date|number|duration)$/i, "");
+}
+function bt(s) {
+  return s && s.replace(/<[^>]*>/g, "");
+}
+function vt(s) {
+  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+function wt(s) {
+  const e = /[\u0590-\u05FF\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/, t = /([^اأدذرزو]*[اأدذرزو])/gi;
+  let i = s.split(/(\s+)/), r = [];
+  return i.forEach((n) => {
+    if (n.match(/^\s+$/))
+      (n = " ") && (n = "  "), r.push(n);
+    else if (e.test(n)) {
+      let a = n.split(t).filter((u) => u !== "");
+      r = r.concat(a);
+    } else
+      r = r.concat([...n]);
+  }), r;
+}
+function yt(s, e = !1) {
+  const t = new Date(s.getFullYear(), 0, 0), i = s.getTime() - t.getTime() + (t.getTimezoneOffset() - s.getTimezoneOffset()) * 60 * 1e3, r = 1e3 * 60 * 60 * 24;
+  return Math.floor(i / r);
+}
+function U(s, e = !1) {
+  const t = new Date(Date.UTC(s.getFullYear(), s.getMonth(), s.getDate())), i = t.getUTCDay() || 7;
+  t.setUTCDate(t.getUTCDate() + 4 - i);
+  const r = new Date(Date.UTC(t.getUTCFullYear(), 0, 1));
+  return Math.ceil(((t.getTime() - r.getTime()) / 864e5 + 1) / 7);
+}
+function Pt(s, e = !1) {
+  const t = new Date(Date.UTC(s.getFullYear(), s.getMonth(), s.getDate())), i = t.getUTCDay() || 7;
+  return t.setUTCDate(t.getUTCDate() + 4 - i), new Date(Date.UTC(t.getUTCFullYear(), 0, 1)).getFullYear();
+}
+function Tt(s, e = !1) {
+  const t = U(new Date(s.getFullYear(), s.getMonth(), 1), e);
+  let i = U(s, e);
+  return i == 1 && (i = 53), i - t + 1;
+}
+function St(s, e, t = 1, i = !1) {
+  let r = new Date(e, 0, 4, 0, 0, 0, 0);
+  return i && r.setUTCFullYear(e), s * 7 + t - ((r.getDay() || 7) + 3);
+}
+function Dt(s, e) {
+  return s > 12 ? s -= 12 : s === 0 && (s = 12), e != null ? s + (e - 1) : s;
+}
+function Ot(s, e = !1, t = !1, i = !1, r) {
+  if (i)
+    return e ? "Coordinated Universal Time" : "UTC";
+  if (r) {
+    const u = s.toLocaleString("en-US", { timeZone: r }), o = s.toLocaleString("en-US", { timeZone: r, timeZoneName: e ? "long" : "short" });
+    return B(o.substr(u.length));
+  }
+  let n = s.toLocaleString("UTC"), a = s.toLocaleString("UTC", { timeZoneName: e ? "long" : "short" }).substr(n.length);
+  return t === !1 && (a = a.replace(/ (standard|daylight|summer|winter) /i, " ")), B(a);
+}
+function Et(s, e) {
+  const t = e || new Date(Date.UTC(2012, 0, 1, 0, 0, 0, 0)), i = new Date(t.toLocaleString("en-US", { timeZone: "UTC" }));
+  return (new Date(t.toLocaleString("en-US", { timeZone: s })).getTime() - i.getTime()) / 6e4 * -1;
+}
+function jt(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function G(s) {
+  let e, t, i, r = s.h, n = s.s, a = s.l;
+  if (n == 0)
+    e = t = i = a;
+  else {
+    let u = function(d, m, _) {
+      return _ < 0 && (_ += 1), _ > 1 && (_ -= 1), _ < 0.16666666666666666 ? d + (m - d) * 6 * _ : _ < 0.5 ? m : _ < 0.6666666666666666 ? d + (m - d) * (0.6666666666666666 - _) * 6 : d;
+    }, o = a < 0.5 ? a * (1 + n) : a + n - a * n, l = 2 * a - o;
+    e = u(l, o, r + 1 / 3), t = u(l, o, r), i = u(l, o, r - 1 / 3);
+  }
+  return {
+    r: Math.round(e * 255),
+    g: Math.round(t * 255),
+    b: Math.round(i * 255)
+  };
+}
+function V(s) {
+  let e = s.r / 255, t = s.g / 255, i = s.b / 255, r = Math.max(e, t, i), n = Math.min(e, t, i), a = 0, u = 0, o = (r + n) / 2;
+  if (r === n)
+    a = u = 0;
+  else {
+    let l = r - n;
+    switch (u = o > 0.5 ? l / (2 - r - n) : l / (r + n), r) {
+      case e:
+        a = (t - i) / l + (t < i ? 6 : 0);
+        break;
+      case t:
+        a = (i - e) / l + 2;
+        break;
+      case i:
+        a = (e - t) / l + 4;
+        break;
+    }
+    a /= 6;
+  }
+  return {
+    h: a,
+    s: u,
+    l: o
+  };
+}
+function _e(s, e) {
+  return s && {
+    r: Math.max(0, Math.min(255, s.r + D(s.r, e))),
+    g: Math.max(0, Math.min(255, s.g + D(s.g, e))),
+    b: Math.max(0, Math.min(255, s.b + D(s.b, e))),
+    a: s.a
+  };
+}
+function D(s, e) {
+  let t = e > 0 ? 255 - s : s;
+  return Math.round(t * e);
+}
+function ge(s, e) {
+  if (s) {
+    let t = Math.min(Math.max(s.r, s.g, s.b), 230), i = D(t, e);
+    return {
+      r: Math.max(0, Math.min(255, Math.round(s.r + i))),
+      g: Math.max(0, Math.min(255, Math.round(s.g + i))),
+      b: Math.max(0, Math.min(255, Math.round(s.b + i))),
+      a: s.a
+    };
+  } else
+    return s;
+}
+function H(s) {
+  return (s.r * 299 + s.g * 587 + s.b * 114) / 1e3 >= 128;
+}
+function me(s, e) {
+  if (s === void 0 || e == 1)
+    return s;
+  let t = V(s);
+  return t.s = e, G(t);
+}
+function be(s, e = { r: 255, g: 255, b: 255 }, t = { r: 255, g: 255, b: 255 }) {
+  let i = e, r = t;
+  return H(t) && (i = t, r = e), H(s) ? r : i;
+}
+function xt(s, e) {
+  return s || (s = []), [...s, ...e].filter((t, i, r) => r.indexOf(t) === i);
+}
+function At(s, e) {
+  return !(!e || s.left != e.left || s.right != e.right || s.top != e.top || s.bottom != e.bottom);
+}
+function q(s) {
+  return s[0] === "#" && (s = s.substr(1)), s.length == 3 && (s = s[0].repeat(2) + s[1].repeat(2) + s[2].repeat(2)), parseInt(s, 16);
+}
+function ve(s) {
+  s = s.replace(/[ ]/g, "");
+  let e = s.match(/^rgb\(([0-9]*),([0-9]*),([0-9]*)\)/i);
+  if (e)
+    e.push("1");
+  else if (e = s.match(/^rgba\(([0-9]*),([0-9]*),([0-9]*),([.0-9]*)\)/i), !e)
+    return 0;
+  let t = "";
+  for (let i = 1; i <= 3; i++) {
+    let r = parseInt(e[i]).toString(16);
+    r.length == 1 && (r = "0" + r), t += r;
+  }
+  return q(t);
+}
+function Ct(s) {
+  return h.fromAny(s);
+}
+class h {
+  constructor(e) {
+    Object.defineProperty(this, "_hex", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._hex = e | 0;
+  }
+  /**
+   * Color numeric value.
+   */
+  get hex() {
+    return this._hex;
+  }
+  /**
+   * Value of color's R channel.
+   * @return R value
+   */
+  get r() {
+    return this._hex >>> 16;
+  }
+  /**
+   * Value of color's G channel.
+   * @return G value
+   */
+  get g() {
+    return this._hex >> 8 & 255;
+  }
+  /**
+   * Value of color's B channel.
+   * @return B value
+   */
+  get b() {
+    return this._hex & 255;
+  }
+  /**
+   * Returns color CSS representation in form of `rgba(r, g, b, a)` string.
+   *
+   * @param   alpha  Opacity
+   * @return         CSS string
+   */
+  toCSS(e = 1) {
+    return "rgba(" + this.r + ", " + this.g + ", " + this.b + ", " + e + ")";
+  }
+  /**
+   * Returns color CSS representation in form of `#rgb` string.
+   *
+   * @return         CSS string
+   */
+  toCSSHex() {
+    return "#" + A(this.r.toString(16), 2) + A(this.g.toString(16), 2) + A(this.b.toString(16), 2);
+  }
+  /**
+   * Returns color's HSL info.
+   * @param   alpha Opacity
+   * @return        HSL info
+   */
+  toHSL(e = 1) {
+    return V({
+      r: this.r,
+      g: this.g,
+      b: this.b,
+      a: e
+    });
+  }
+  /**
+   * Converts HSL values into a new [[Color]] object.
+   *
+   * @param   h H value
+   * @param   s S value
+   * @param   l L value
+   * @return    Color object
+   */
+  static fromHSL(e, t, i) {
+    const r = G({
+      h: e,
+      s: t,
+      l: i
+    });
+    return this.fromRGB(r.r, r.g, r.b);
+  }
+  toString() {
+    return this.toCSSHex();
+  }
+  /**
+   * Converts hex number into a new [[Color]] object.
+   *
+   * ```TypeScript
+   * Color.fromHex(0xff0000) // red
+   * ```
+   * ```JavaScript
+   * Color.fromHex(0xff0000) // red
+   * ```
+   *
+   * @param   hex  Hex color
+   * @return       Color
+   */
+  static fromHex(e) {
+    return new h(e);
+  }
+  /**
+   * Converts RGB values to a new [[Color]] object.
+   *
+   * @param   r  R value
+   * @param   g  G value
+   * @param   b  B value
+   * @return     Color
+   */
+  static fromRGB(e, t, i) {
+    return new h((i | 0) + (t << 8) + (e << 16));
+  }
+  /**
+   * Converts RGB string to a new [[Color]] object.
+   *
+   * ```TypeScript
+   * Color.fromString("#ff0000") // red
+   * ```
+   * ```JavaScript
+   * Color.fromString("#ff0000") // red
+   * ```
+   *
+   * @param   s  RGB string
+   * @return     Color
+   */
+  static fromString(e) {
+    return new h(q(e));
+  }
+  /**
+   * Converts CSS rgba() syntax to a new [[Color]] object.
+   *
+   * ```TypeScript
+   * Color.fromCSS("rgba(255, 0, 0, 1)") // red
+   * ```
+   * ```JavaScript
+   * Color.fromCSS("rgba(255, 0, 0, 1)") // red
+   * ```
+   *
+   * @param  {string} s [description]
+   * @return {Color}    [description]
+   */
+  static fromCSS(e) {
+    return new h(ve(e));
+  }
+  /**
+   * Convert to color from virtually anything.
+   *
+   * Will throw an exception if unable to resolve the color.
+   *
+   * @param   s  Source
+   * @return     Color
+   */
+  static fromAny(e) {
+    if ($(e)) {
+      if (e[0] == "#")
+        return h.fromString(e);
+      if (e.substr(0, 3) == "rgb")
+        return h.fromCSS(e);
+    } else {
+      if (v(e))
+        return h.fromHex(e);
+      if (e instanceof h)
+        return h.fromHex(e.hex);
+    }
+    throw new Error("Unknown color syntax: " + e);
+  }
+  /**
+   * Returns a new [[Color]] object based on either `lightAlternative` or
+   * `darkAlternative` depending on which one is more contrasting with
+   * the `color`.
+   *
+   * @param   color             Reference color
+   * @param   lightAlternative  Light color
+   * @param   darkAlternative   Dark color
+   * @return                    Alternative color
+   */
+  static alternative(e, t, i) {
+    const r = be({ r: e.r, g: e.g, b: e.b }, t ? { r: t.r, g: t.g, b: t.b } : void 0, i ? { r: i.r, g: i.g, b: i.b } : void 0);
+    return this.fromRGB(r.r, r.g, r.b);
+  }
+  /**
+   * Returns an intermediate Color between two reference colors depending on
+   * the progress (`diff`) between the two.
+   *
+   * @param   diff  Progress
+   * @param   from  Source color
+   * @param   to    Target color
+   * @param   mode  Interpolation mode
+   * @return        Color
+   */
+  static interpolate(e, t, i, r = "rgb") {
+    if (r == "hsl") {
+      const n = t.toHSL(), a = i.toHSL();
+      return h.fromHSL(b(e, n.h, a.h), b(e, n.s, a.s), b(e, n.l, a.l));
+    } else
+      return h.fromRGB(b(e, t.r, i.r), b(e, t.g, i.g), b(e, t.b, i.b));
+  }
+  /**
+   * Returns a new [[Color]] lightened by `percent` value.
+   *
+   * Use negative value to darken the color.
+   *
+   * @param   color    Source color
+   * @param   percent  Percent
+   * @return           New color
+   */
+  static lighten(e, t) {
+    const i = _e({ r: e.r, g: e.g, b: e.b }, t);
+    return h.fromRGB(i.r, i.g, i.b);
+  }
+  /**
+   * Returns a new [[Color]] brightened by `percent` value.
+   *
+   * Use negative value to dim the color.
+   *
+   * @param   color    Source color
+   * @param   percent  Percent
+   * @return           New color
+   */
+  static brighten(e, t) {
+    const i = ge({ r: e.r, g: e.g, b: e.b }, t);
+    return h.fromRGB(i.r, i.g, i.b);
+  }
+  /**
+   * Returns a new [[Color]] saturated by `percent` value.
+   *
+   * Value range is between `0` (fully desaturated), to `1` (full color).
+   *
+   * @param   color    Source color
+   * @param   percent  Percent
+   * @return           New color
+   */
+  static saturate(e, t) {
+    const i = me({ r: e.r, g: e.g, b: e.b }, t);
+    return h.fromRGB(i.r, i.g, i.b);
+  }
+}
+class J {
+  /**
+   * Constructor
+   */
+  constructor() {
+    Object.defineProperty(this, "_listeners", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_killed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_disabled", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_iterating", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_enabled", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_disposed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._listeners = [], this._killed = [], this._disabled = {}, this._iterating = 0, this._enabled = !0, this._disposed = !1;
+  }
+  /**
+   * Returns if this object has been already disposed.
+   *
+   * @return Disposed?
+   */
+  isDisposed() {
+    return this._disposed;
+  }
+  /**
+   * Dispose (destroy) this object.
+   */
+  dispose() {
+    if (!this._disposed) {
+      this._disposed = !0;
+      const e = this._listeners;
+      this._iterating = 1, this._listeners = null, this._disabled = null;
+      try {
+        c(e, (t) => {
+          t.disposer.dispose();
+        });
+      } finally {
+        this._killed = null, this._iterating = null;
+      }
+    }
+  }
+  /**
+   * Checks if this particular event dispatcher has any listeners set.
+   *
+   * @return Has listeners?
+   */
+  hasListeners() {
+    return this._listeners.length !== 0;
+  }
+  /**
+   * Checks if this particular event dispatcher has any particular listeners set.
+   *
+   * @return Has particular event listeners?
+   */
+  hasListenersByType(e) {
+    return te(this._listeners, (t) => (t.type === null || t.type === e) && !t.killed);
+  }
+  /**
+   * Enable dispatching of events if they were previously disabled by
+   * `disable()`.
+   */
+  enable() {
+    this._enabled = !0;
+  }
+  /**
+   * Disable dispatching of events until re-enabled by `enable()`.
+   */
+  disable() {
+    this._enabled = !1;
+  }
+  /**
+   * Enable dispatching particular event, if it was disabled before by
+   * `disableType()`.
+   *
+   * @param type Event type
+   */
+  enableType(e) {
+    delete this._disabled[e];
+  }
+  /**
+   * Disable dispatching of events for a certain event type.
+   *
+   * Optionally, can set how many dispatches to skip before automatically
+   * re-enabling the dispatching.
+   *
+   * @param type    Event type
+   * @param amount  Number of event dispatches to skip
+   */
+  disableType(e, t = 1 / 0) {
+    this._disabled[e] = t;
+  }
+  /**
+   * Removes listener from dispatcher.
+   *
+   * Will throw an exception if such listener does not exists.
+   *
+   * @param listener Listener to remove
+   */
+  _removeListener(e) {
+    if (this._iterating === 0) {
+      const t = this._listeners.indexOf(e);
+      if (t === -1)
+        throw new Error("Invalid state: could not remove listener");
+      this._listeners.splice(t, 1);
+    } else
+      this._killed.push(e);
+  }
+  /**
+   * Removes existing listener by certain parameters.
+   *
+   * @param once         Listener's once setting
+   * @param type         Listener's type
+   * @param callback     Callback function
+   * @param context      Callback context
+   */
+  _removeExistingListener(e, t, i, r) {
+    if (this._disposed)
+      throw new Error("EventDispatcher is disposed");
+    this._eachListener((n) => {
+      n.once === e && // TODO is this correct ?
+      n.type === t && (i === void 0 || n.callback === i) && n.context === r && n.disposer.dispose();
+    });
+  }
+  /**
+   * Checks if dispatching for particular event type is enabled.
+   *
+   * @param type  Event type
+   * @return Enabled?
+   */
+  isEnabled(e) {
+    if (this._disposed)
+      throw new Error("EventDispatcher is disposed");
+    return this._enabled && this._listeners.length > 0 && this.hasListenersByType(e) && this._disabled[e] === void 0;
+  }
+  /**
+   * Removes all listeners of a particular event type
+   *
+   * @param type  Listener's type
+   */
+  removeType(e) {
+    if (this._disposed)
+      throw new Error("EventDispatcher is disposed");
+    this._eachListener((t) => {
+      t.type === e && t.disposer.dispose();
+    });
+  }
+  /**
+   * Checks if there's already a listener with specific parameters.
+   *
+   * @param type      Listener's type
+   * @param callback  Callback function
+   * @param context   Callback context
+   * @return Has listener?
+   */
+  has(e, t, i) {
+    return W(this._listeners, (n) => n.once !== !0 && // Ignoring "once" listeners
+    n.type === e && (t === void 0 || n.callback === t) && n.context === i) !== -1;
+  }
+  /**
+   * Checks whether event of the particular type should be dispatched.
+   *
+   * @param type  Event type
+   * @return Dispatch?
+   */
+  _shouldDispatch(e) {
+    if (this._disposed)
+      throw new Error("EventDispatcher is disposed");
+    const t = this._disabled[e];
+    return v(t) ? (t <= 1 ? delete this._disabled[e] : --this._disabled[e], !1) : this._enabled;
+  }
+  /**
+   * [_eachListener description]
+   *
+   * All of this extra code is needed when a listener is removed while iterating
+   *
+   * @todo Description
+   * @param fn [description]
+   */
+  _eachListener(e) {
+    ++this._iterating;
+    try {
+      c(this._listeners, e);
+    } finally {
+      --this._iterating, this._iterating === 0 && this._killed.length !== 0 && (c(this._killed, (t) => {
+        this._removeListener(t);
+      }), this._killed.length = 0);
+    }
+  }
+  /**
+   * Dispatches an event immediately without waiting for next cycle.
+   *
+   * @param type   Event type
+   * @param event  Event object
+   * @todo automatically add in type and target properties if they are missing
+   */
+  dispatch(e, t) {
+    this._shouldDispatch(e) && this._eachListener((i) => {
+      !i.killed && (i.type === null || i.type === e) && (i._debounceDelay ? (i._debounceTimeout && window.clearTimeout(i._debounceTimeout), i._debounceTimeout = window.setTimeout(() => {
+        i._debounceTimeout = void 0, i.killed || i.dispatch(e, t);
+      }, i._debounceDelay)) : i.dispatch(e, t));
+    });
+  }
+  /**
+   * Shelves the event to be dispatched within next update cycle.
+   *
+   * @param type   Event type
+   * @param event  Event object
+   * @todo automatically add in type and target properties if they are missing
+   */
+  /*public dispatchLater<Key extends keyof T>(type: Key, event: T[Key]): void {
+      if (this._shouldDispatch(type)) {
+          this._eachListener((listener) => {
+              // TODO check if it's faster to use an object of listeners rather than a single big array
+              if (!listener.killed && (listener.type === null || listener.type === type)) {
+                  // TODO if the function throws, maybe it should keep going ?
+                  // TODO dispatch during the update cycle, rather than using whenIdle
+                  $async.whenIdle(() => {
+                      if (!listener.killed) {
+                          listener.dispatch(type, event);
+                      }
+                  });
+              }
+          });
+      }
+  }*/
+  /**
+   * Creates, catalogs and returns an [[EventListener]].
+   *
+   * Event listener can be disposed.
+   *
+   * @param once         Listener's once setting
+   * @param type         Listener's type
+   * @param callback     Callback function
+   * @param context      Callback context
+   * @param shouldClone  Whether the listener should be copied when the EventDispatcher is copied
+   * @param dispatch
+   * @returns An event listener
+   */
+  _on(e, t, i, r, n, a, u) {
+    if (this._disposed)
+      throw new Error("EventDispatcher is disposed");
+    this._removeExistingListener(e, t, i, r);
+    const o = {
+      type: t,
+      callback: i,
+      context: r,
+      shouldClone: n,
+      dispatch: a,
+      killed: !1,
+      once: e,
+      disposer: new w(() => {
+        o.killed = !0, o._debounceTimeout && window.clearTimeout(o._debounceTimeout), this._removeListener(o);
+      }),
+      _debounceDelay: u
+    };
+    return this._listeners.push(o), o;
+  }
+  /**
+   * Creates an event listener to be invoked on **any** event.
+   *
+   * @param callback     Callback function
+   * @param context      Callback context
+   * @param shouldClone  Whether the listener should be copied when the EventDispatcher is copied
+   * @returns A disposable event listener
+   */
+  onAll(e, t, i = !0) {
+    return this._on(!1, null, e, t, i, (r, n) => e.call(t, n)).disposer;
+  }
+  /**
+   * Creates an event listener to be invoked on a specific event type.
+   *
+   * ```TypeScript
+   * button.events.once("click", (ev) => {
+   *   console.log("Button clicked");
+   * }, this);
+   * ```
+   * ```JavaScript
+   * button.events.once("click", function(ev) {
+   *   console.log("Button clicked");
+   * }, this);
+   * ```
+   *
+   * The above will invoke our custom event handler whenever series we put
+   * event on is hidden.
+   *
+   * @param type         Listener's type
+   * @param callback     Callback function
+   * @param context      Callback context
+   * @param shouldClone  Whether the listener should be copied when the EventDispatcher is copied
+   * @returns A disposable event listener
+   */
+  on(e, t, i, r = !0) {
+    return this._on(!1, e, t, i, r, (n, a) => t.call(i, a)).disposer;
+  }
+  /**
+   * Creates a debounced event listener to be invoked on a specific event type.
+   *
+   * ```TypeScript
+   * button.events.onDebounced("click", (ev) => {
+   *   console.log("Button clicked");
+   * }, 500, this);
+   * ```
+   * ```JavaScript
+   * button.events.onDebounced("click", function(ev) {
+   *   console.log("Button clicked");
+   * }, 500, this);
+   * ```
+   *
+   * The above will invoke our custom event handler whenever series we put
+   * event on is hidden.
+   *
+   * @param type           Listener's type
+   * @param callback       Callback function
+   * @param debounceDelay  Debounce delay in milliseconds
+   * @param context        Callback context
+   * @param shouldClone    Whether the listener should be copied when the EventDispatcher is copied
+   * @returns A disposable event listener
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/events/#Debounced_events} for more info
+   * @since 5.14.0
+   */
+  onDebounced(e, t, i, r, n = !0) {
+    return this._on(!1, e, t, r, n, (a, u) => t.call(r, u), i).disposer;
+  }
+  /**
+   * Creates an event listener to be invoked on a specific event type once.
+   *
+   * Once the event listener is invoked, it is automatically disposed.
+   *
+   * ```TypeScript
+   * button.events.once("click", (ev) => {
+   *   console.log("Button clicked");
+   * }, this);
+   * ```
+   * ```JavaScript
+   * button.events.once("click", function(ev) {
+   *   console.log("Button clicked");
+   * }, this);
+   * ```
+   *
+   * The above will invoke our custom event handler the first time series we
+   * put event on is hidden.
+   *
+   * @param type         Listener's type
+   * @param callback     Callback function
+   * @param context      Callback context
+   * @param shouldClone  Whether the listener should be copied when the EventDispatcher is copied
+   * @returns A disposable event listener
+   */
+  once(e, t, i, r = !0) {
+    const n = this._on(!0, e, t, i, r, (a, u) => {
+      n.disposer.dispose(), t.call(i, u);
+    });
+    return n.disposer;
+  }
+  /**
+   * Removes the event listener with specific parameters.
+   *
+   * @param type         Listener's type
+   * @param callback     Callback function
+   * @param context      Callback context
+   */
+  off(e, t, i) {
+    this._removeExistingListener(!1, e, t, i);
+  }
+  /**
+   * Copies all dispatcher parameters, including listeners, from another event
+   * dispatcher.
+   *
+   * @param source Source event dispatcher
+   * @ignore
+   */
+  copyFrom(e) {
+    if (this._disposed)
+      throw new Error("EventDispatcher is disposed");
+    if (e === this)
+      throw new Error("Cannot copyFrom the same TargetedEventDispatcher");
+    const t = [];
+    return c(e._listeners, (i) => {
+      !i.killed && i.shouldClone && (i.type === null ? t.push(this.onAll(i.callback, i.context)) : i.once ? t.push(this.once(i.type, i.callback, i.context)) : t.push(this.on(i.type, i.callback, i.context)));
+    }), new le(t);
+  }
+}
+function It(s) {
+  return Q(this, void 0, void 0, function* () {
+    if (s !== void 0) {
+      const e = [];
+      p(s, (t, i) => {
+        e.push(i.waitForStop());
+      }), yield Promise.all(e);
+    }
+  });
+}
+function b(s, e, t) {
+  return e + s * (t - e);
+}
+function we(s, e, t) {
+  return s >= 1 ? t : e;
+}
+function ye(s, e, t) {
+  return new g(b(s, e.percent, t.percent));
+}
+function Pe(s, e, t) {
+  return h.interpolate(s, e, t);
+}
+function Te(s, e) {
+  return typeof s == "number" && typeof e == "number" ? b : s instanceof g && e instanceof g ? ye : s instanceof h && e instanceof h ? Pe : we;
+}
+var T;
+(function(s) {
+  s[s.Stopped = 0] = "Stopped", s[s.Playing = 1] = "Playing", s[s.Paused = 2] = "Paused";
+})(T || (T = {}));
+function z(s) {
+  return s;
+}
+function Se(s) {
+  return s * s * s;
+}
+function Lt(s) {
+  return function(e) {
+    return 1 - s(1 - e);
+  };
+}
+class De {
+  constructor(e, t) {
+    Object.defineProperty(this, "_entity", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_settings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_userSettings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), this._entity = e, this._settings = t, p(t, (i) => {
+      this._userSettings[i] = !0;
+    });
+  }
+  get(e, t) {
+    const i = this._settings[e];
+    return i !== void 0 ? i : t;
+  }
+  /**
+   * @ignore
+   */
+  setRaw(e, t) {
+    this._settings[e] = t;
+  }
+  /**
+   * Sets a setting `value` for the specified `key` to be set when the state
+   * is applied.
+   *
+   * @param   key       Setting key
+   * @param   value     Setting value
+   * @return            Setting value
+   */
+  set(e, t) {
+    this._userSettings[e] = !0, this.setRaw(e, t);
+  }
+  /**
+   * Removes a setting value for the specified `key`.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param   key       Setting key
+   */
+  remove(e) {
+    delete this._userSettings[e], delete this._settings[e];
+  }
+  /**
+   * Sets multiple settings at once.
+   *
+   * `settings` must be an object with key: value pairs.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param settings Settings
+   */
+  setAll(e) {
+    y(e).forEach((t) => {
+      this.set(t, e[t]);
+    });
+  }
+  _eachSetting(e) {
+    p(this._settings, e);
+  }
+  /**
+   * Applies the state to the target element.
+   *
+   * All setting values are set immediately.
+   */
+  apply() {
+    const e = {};
+    e.stateAnimationEasing = !0, e.stateAnimationDuration = !0;
+    const t = this._entity.states.lookup("default");
+    this._eachSetting((i, r) => {
+      e[i] || (e[i] = !0, this !== t && (i in t._settings || (t._settings[i] = this._entity.get(i))), this._entity.set(i, r));
+    });
+  }
+  /**
+   * Applies the state to the target element.
+   *
+   * Returns an object representing all [[Animation]] objects created for
+   * each setting key transition.
+   *
+   * @return           Animations
+   */
+  applyAnimate(e) {
+    e == null && (e = this._settings.stateAnimationDuration), e == null && (e = this.get("stateAnimationDuration", this._entity.get("stateAnimationDuration", 0)));
+    let t = this._settings.stateAnimationEasing;
+    t == null && (t = this.get("stateAnimationEasing", this._entity.get("stateAnimationEasing", Se)));
+    const i = this._entity.states.lookup("default"), r = {};
+    r.stateAnimationEasing = !0, r.stateAnimationDuration = !0;
+    const n = {};
+    return this._eachSetting((a, u) => {
+      if (!r[a]) {
+        r[a] = !0, this != i && (a in i._settings || (i._settings[a] = this._entity.get(a)));
+        const o = this._entity.animate({
+          key: a,
+          to: u,
+          duration: e,
+          easing: t
+        });
+        o && (n[a] = o);
+      }
+    }), n;
+  }
+}
+class Oe {
+  constructor(e) {
+    Object.defineProperty(this, "_states", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_entity", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._entity = e;
+  }
+  /**
+   * Checks if a state by `name` exists. Returns it there is one.
+   *
+   * @param  name  State name
+   * @return       State
+   */
+  lookup(e) {
+    return this._states[e];
+  }
+  /**
+   * Sets supplied `settings` on a state by the `name`.
+   *
+   * If such state does not yet exists, it is created.
+   *
+   * @param   name      State name
+   * @param   settings  Settings
+   * @return            New State
+   */
+  create(e, t) {
+    const i = this._states[e];
+    if (i)
+      return i.setAll(t), i;
+    {
+      const r = new De(this._entity, t);
+      return this._states[e] = r, r;
+    }
+  }
+  /**
+   * Removes the state called `name`.
+   *
+   * @param   name      State name
+   */
+  remove(e) {
+    delete this._states[e];
+  }
+  /**
+   * Applies a named state to the target element.
+   *
+   * @param  newState  State name
+   */
+  apply(e) {
+    const t = this._states[e];
+    t && t.apply(), this._entity._applyState(e);
+  }
+  /**
+   * Applies a named state to the element.
+   *
+   * Returns an object representing all [[Animation]] objects created for
+   * each setting key transition.
+   *
+   * @param   newState  State name
+   * @return            Animations
+   */
+  applyAnimate(e, t) {
+    let i;
+    const r = this._states[e];
+    return r && (i = r.applyAnimate(t)), this._entity._applyStateAnimated(e, t), i;
+  }
+}
+class Ee {
+  constructor() {
+    Object.defineProperty(this, "version", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "5.14.4"
+    }), Object.defineProperty(this, "licenses", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "entitiesById", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "rootElements", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "autoDispose", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    });
+  }
+}
+const C = new Ee();
+function L(s, e) {
+  return s === e ? 0 : s < e ? -1 : 1;
+}
+function je(s, e, t) {
+  const i = s.length, r = e.length, n = Math.min(i, r);
+  for (let a = 0; a < n; ++a) {
+    const u = t(s[a], e[a]);
+    if (u !== 0)
+      return u;
+  }
+  return L(i, r);
+}
+function Ft(s, e) {
+  return s === e ? 0 : s < e ? -1 : 1;
+}
+class xe {
+  constructor(e) {
+    Object.defineProperty(this, "_entity", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_callbacks", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_disabled", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), this._entity = e;
+  }
+  /**
+   * Add a function (`callback`) that will modify value for setting `key`.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/adapters/} for more info
+   */
+  add(e, t) {
+    let i = this._callbacks[e];
+    return i === void 0 && (i = this._callbacks[e] = []), i.push(t), this._entity._markDirtyKey(e), new w(() => {
+      P(i, t) && this._entity._markDirtyKey(e);
+    });
+  }
+  /**
+   * Removes all adapters for the specific key.
+   *
+   * @since 5.1.0
+   */
+  remove(e) {
+    const t = this._callbacks[e];
+    t !== void 0 && (delete this._callbacks[e], t.length !== 0 && this._entity._markDirtyKey(e));
+  }
+  /**
+   * Enables (previously disabled) adapters for specific key.
+   *
+   * @since 5.1.0
+   */
+  enable(e) {
+    this._disabled[e] && (delete this._disabled[e], this._entity._markDirtyKey(e));
+  }
+  /**
+   * Disables all adapters for specific key.
+   *
+   * @since 5.1.0
+   */
+  disable(e) {
+    this._disabled[e] || (this._disabled[e] = !0, this._entity._markDirtyKey(e));
+  }
+  /**
+   * @ignore
+   */
+  fold(e, t) {
+    if (!this._disabled[e]) {
+      const i = this._callbacks[e];
+      if (i !== void 0)
+        for (let r = 0, n = i.length; r < n; ++r)
+          t = i[r](t, this._entity, e);
+    }
+    return t;
+  }
+}
+class S {
+  constructor(e, t, i, r, n, a, u) {
+    Object.defineProperty(this, "_animation", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_from", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_to", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_duration", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_easing", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_loops", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_interpolate", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_oldTime", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_time", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_stopped", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_playing", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), Object.defineProperty(this, "events", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new J()
+    }), this._animation = e, this._from = t, this._to = i, this._duration = r, this._easing = n, this._loops = a, this._interpolate = Te(t, i), this._oldTime = u;
+  }
+  get to() {
+    return this._to;
+  }
+  get from() {
+    return this._from;
+  }
+  get playing() {
+    return this._playing;
+  }
+  get stopped() {
+    return this._stopped;
+  }
+  stop() {
+    this._stopped || (this._stopped = !0, this._playing = !1, this.events.isEnabled("stopped") && this.events.dispatch("stopped", {
+      type: "stopped",
+      target: this
+    }));
+  }
+  pause() {
+    this._playing = !1, this._oldTime = null;
+  }
+  play() {
+    !this._stopped && !this._playing && (this._playing = !0, this._animation._startAnimation());
+  }
+  get percentage() {
+    return this._time / this._duration;
+  }
+  waitForStop() {
+    return new Promise((e, t) => {
+      if (this._stopped)
+        e();
+      else {
+        const i = () => {
+          r.dispose(), e();
+        }, r = this.events.on("stopped", i);
+      }
+    });
+  }
+  _checkEnded() {
+    return this._loops > 1 ? (--this._loops, !1) : !0;
+  }
+  _run(e) {
+    this._oldTime !== null && (this._time += e - this._oldTime, this._time > this._duration && (this._time = this._duration)), this._oldTime = e;
+  }
+  _reset(e) {
+    this._oldTime = e, this._time = 0;
+  }
+  _value(e) {
+    return this._interpolate(this._easing(e), this._from, this._to);
+  }
+}
+let Ae = 0;
+class Ce {
+  constructor(e) {
+    Object.defineProperty(this, "uid", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: ++Ae
+    }), Object.defineProperty(this, "_settings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_privateSettings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_settingEvents", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_privateSettingEvents", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_prevSettings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_prevPrivateSettings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_animatingSettings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_animatingPrivateSettings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_disposed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_userProperties", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "enableDispose", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), this._settings = e;
+  }
+  _checkDirty() {
+    y(this._settings).forEach((e) => {
+      this._userProperties[e] = !0, this._markDirtyKey(e);
+    });
+  }
+  /**
+   * @ignore
+   */
+  resetUserSettings() {
+    this._userProperties = {};
+  }
+  _runAnimation(e) {
+    let t = T.Stopped;
+    if (!this.isDisposed()) {
+      let i = !1, r = !1;
+      p(this._animatingSettings, (n, a) => {
+        if (a.stopped)
+          this._stopAnimation(n);
+        else if (a.playing) {
+          a._run(e);
+          const u = a.percentage;
+          u >= 1 ? a._checkEnded() ? this.set(n, a._value(1)) : (i = !0, a._reset(e), this._set(n, a._value(1))) : (i = !0, this._set(n, a._value(u)));
+        } else
+          r = !0;
+      }), p(this._animatingPrivateSettings, (n, a) => {
+        if (a.stopped)
+          this._stopAnimationPrivate(n);
+        else if (a.playing) {
+          a._run(e);
+          const u = a.percentage;
+          u >= 1 ? a._checkEnded() ? this.setPrivate(n, a._value(1)) : (i = !0, a._reset(e), this._setPrivate(n, a._value(1))) : (i = !0, this._setPrivate(n, a._value(u)));
+        } else
+          r = !0;
+      }), i ? t = T.Playing : r && (t = T.Paused);
+    }
+    return t;
+  }
+  _markDirtyKey(e) {
+    this.markDirty();
+  }
+  _markDirtyPrivateKey(e) {
+    this.markDirty();
+  }
+  /**
+   * Sets a callback function to invoke when specific key of settings changes
+   * or is set.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/events/#Settings_value_change} for more info
+   * @param   key       Settings key
+   * @param   callback  Callback
+   * @return            Disposer for event
+   */
+  on(e, t) {
+    let i = this._settingEvents[e];
+    return i === void 0 && (i = this._settingEvents[e] = []), i.push(t), new w(() => {
+      P(i, t), i.length === 0 && delete this._settingEvents[e];
+    });
+  }
+  /**
+   * Removes a callback for when value of a setting changes.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/events/#Settings_value_change} for more info
+   * @param   key       Private settings key
+   * @param   callback  Callback
+   * @since 5.9.2
+   */
+  off(e, t) {
+    let i = this._settingEvents[e];
+    i !== void 0 && t !== void 0 ? P(i, t) : delete this._settingEvents[e];
+  }
+  /**
+   * Sets a callback function to invoke when specific key of private settings
+   * changes or is set.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/events/#Settings_value_change} for more info
+   * @param   key       Private settings key
+   * @param   callback  Callback
+   * @return            Disposer for event
+   */
+  onPrivate(e, t) {
+    let i = this._privateSettingEvents[e];
+    return i === void 0 && (i = this._privateSettingEvents[e] = []), i.push(t), new w(() => {
+      P(i, t), i.length === 0 && delete this._privateSettingEvents[e];
+    });
+  }
+  /**
+   * Removes a callback for when value of a private setting changes.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/events/#Settings_value_change} for more info
+   * @param   key       Private settings key
+   * @param   callback  Callback
+   * @since 5.9.2
+   */
+  offPrivate(e, t) {
+    let i = this._privateSettingEvents[e];
+    i !== void 0 && t !== void 0 ? P(i, t) : delete this._privateSettingEvents[e];
+  }
+  /**
+   * @ignore
+   */
+  getRaw(e, t) {
+    const i = this._settings[e];
+    return i !== void 0 ? i : t;
+  }
+  /**
+   * Returns `true` if the setting exists.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param   key        Settings key
+   * @return  {boolean}  Key exists
+   */
+  has(e) {
+    return e in this._settings;
+  }
+  get(e, t) {
+    return this.getRaw(e, t);
+  }
+  _sendKeyEvent(e, t) {
+    const i = this._settingEvents[e];
+    i !== void 0 && c(i, (r) => {
+      r(t, this, e);
+    });
+  }
+  _sendPrivateKeyEvent(e, t) {
+    const i = this._privateSettingEvents[e];
+    i !== void 0 && c(i, (r) => {
+      r(t, this, e);
+    });
+  }
+  /**
+   * @ignore
+   */
+  _setRaw(e, t, i) {
+    this._prevSettings[e] = t, this._sendKeyEvent(e, i);
+  }
+  /**
+   * @ignore
+   */
+  setRaw(e, t) {
+    const i = this._settings[e];
+    this._settings[e] = t, i !== t && this._setRaw(e, i, t);
+  }
+  /**
+   * @ignore
+   */
+  _set(e, t) {
+    const i = this._settings[e];
+    this._settings[e] = t, i !== t && (this._setRaw(e, i, t), this._markDirtyKey(e));
+  }
+  _stopAnimation(e) {
+    const t = this._animatingSettings[e];
+    t && (delete this._animatingSettings[e], t.stop());
+  }
+  /**
+   * Sets a setting `value` for the specified `key`, and returns the same `value`.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param   key       Setting key
+   * @param   value     Setting value
+   * @return            Setting value
+   */
+  set(e, t) {
+    return this._set(e, t), this._stopAnimation(e), t;
+  }
+  /**
+   * Removes a setting value for the specified `key`;
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param   key       Setting key
+   */
+  remove(e) {
+    e in this._settings && (this._prevSettings[e] = this._settings[e], delete this._settings[e], this._sendKeyEvent(e, void 0), this._markDirtyKey(e)), this._stopAnimation(e);
+  }
+  /**
+   * Removes all keys;
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   */
+  removeAll() {
+    c(y(this._settings), (e) => {
+      this.remove(e);
+    });
+  }
+  /**
+   * Returns a value of a private setting.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/#Private_settings} for more info
+   */
+  getPrivate(e, t) {
+    const i = this._privateSettings[e];
+    return i !== void 0 ? i : t;
+  }
+  /**
+   * @ignore
+   */
+  _setPrivateRaw(e, t, i) {
+    this._prevPrivateSettings[e] = t, this._sendPrivateKeyEvent(e, i);
+  }
+  /**
+   * @ignore
+   */
+  setPrivateRaw(e, t) {
+    const i = this._privateSettings[e];
+    this._privateSettings[e] = t, i !== t && this._setPrivateRaw(e, i, t);
+  }
+  /**
+   * @ignore
+   */
+  _setPrivate(e, t) {
+    const i = this._privateSettings[e];
+    this._privateSettings[e] = t, i !== t && (this._setPrivateRaw(e, i, t), this._markDirtyPrivateKey(e));
+  }
+  _stopAnimationPrivate(e) {
+    const t = this._animatingPrivateSettings[e];
+    t && (t.stop(), delete this._animatingPrivateSettings[e]);
+  }
+  /**
+   * @ignore
+   */
+  setPrivate(e, t) {
+    return this._setPrivate(e, t), this._stopAnimationPrivate(e), t;
+  }
+  /**
+   * @ignore
+   */
+  removePrivate(e) {
+    e in this._privateSettings && (this._prevPrivateSettings[e] = this._privateSettings[e], delete this._privateSettings[e], this._markDirtyPrivateKey(e)), this._stopAnimationPrivate(e);
+  }
+  /**
+   * Sets multiple settings at once.
+   *
+   * `settings` must be an object with key: value pairs.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param settings Settings
+   */
+  setAll(e) {
+    p(e, (t, i) => {
+      this.set(t, i);
+    });
+  }
+  /**
+   * Animates setting values from current/start values to new ones.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/animations/#Animating_settings} for more info
+   * @param   options  Animation options
+   * @return           Animation object
+   */
+  animate(e) {
+    const t = e.key, i = e.to, r = e.duration || 0, n = e.loops || 1, a = e.from === void 0 ? this.get(t) : e.from, u = e.easing === void 0 ? z : e.easing;
+    if (r === 0)
+      this.set(t, i);
+    else if (a === void 0 || a === i)
+      this.set(t, i);
+    else {
+      this.set(t, a);
+      const l = this._animatingSettings[t] = new S(this, a, i, r, u, n, this._animationTime());
+      return this._startAnimation(), l;
+    }
+    const o = new S(this, a, i, r, u, n, null);
+    return o.stop(), o;
+  }
+  /**
+   * @ignore
+   */
+  animatePrivate(e) {
+    const t = e.key, i = e.to, r = e.duration || 0, n = e.loops || 1, a = e.from === void 0 ? this.getPrivate(t) : e.from, u = e.easing === void 0 ? z : e.easing;
+    if (r === 0)
+      this.setPrivate(t, i);
+    else if (a === void 0 || a === i)
+      this.setPrivate(t, i);
+    else {
+      this.setPrivate(t, a);
+      const l = this._animatingPrivateSettings[t] = new S(this, a, i, r, u, n, this._animationTime());
+      return this._startAnimation(), l;
+    }
+    const o = new S(this, a, i, r, u, n, null);
+    return o.stop(), o;
+  }
+  _dispose() {
+  }
+  /**
+   * Returns `true` if this element is disposed.
+   *
+   * @return Disposed
+   */
+  isDisposed() {
+    return this._disposed;
+  }
+  /**
+   * Disposes this object.
+   */
+  dispose() {
+    this.enableDispose && !this._disposed && (this._disposed = !0, this._dispose());
+  }
+}
+class O extends Ce {
+  /**
+   * IMPORTANT! Do not instantiate this class via `new Class()` syntax.
+   *
+   * Use static method `Class.new()` instead.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/getting-started/#New_element_syntax} for more info
+   * @ignore
+   */
+  constructor(e, t, i, r = []) {
+    if (super(t), Object.defineProperty(this, "_root", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_user_id", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "states", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new Oe(this)
+    }), Object.defineProperty(this, "adapters", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new xe(this)
+    }), Object.defineProperty(this, "events", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._createEvents()
+    }), Object.defineProperty(this, "_userPrivateProperties", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_dirty", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_dirtyPrivate", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_template", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_templates", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_internalTemplates", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_defaultThemes", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_templateDisposers", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_disposers", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_runSetup", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), Object.defineProperty(this, "_disposerProperties", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), !i)
+      throw new Error("You cannot use `new Class()`, instead use `Class.new()`");
+    this._root = e, this._internalTemplates = r, t.id && this._registerId(t.id);
+  }
+  /**
+   * Use this method to create an instance of this class.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/getting-started/#New_element_syntax} for more info
+   * @param   root      Root element
+   * @param   settings  Settings
+   * @param   template  Template
+   * @return            Instantiated object
+   */
+  static new(e, t, i) {
+    const r = new this(e, t, !0);
+    return r._template = i, r._afterNew(), r;
+  }
+  static _new(e, t, i = []) {
+    const r = new this(e, t, !0, i);
+    return r._afterNew(), r;
+  }
+  _afterNew() {
+    this._checkDirty();
+    let e = !1;
+    const t = this._template;
+    t && (e = !0, t._setObjectTemplate(this)), c(this._internalTemplates, (i) => {
+      e = !0, i._setObjectTemplate(this);
+    }), e && this._applyTemplates(!1), this.states.create("default", {}), this._setDefaults();
+  }
+  // This is the same as _afterNew, except it also applies the themes.
+  // This should only be used for classes which don't have a parent (because they extend from Entity and not Sprite).
+  _afterNewApplyThemes() {
+    this._checkDirty();
+    const e = this._template;
+    e && e._setObjectTemplate(this), c(this._internalTemplates, (t) => {
+      t._setObjectTemplate(this);
+    }), this.states.create("default", {}), this._setDefaults(), this._applyThemes();
+  }
+  _createEvents() {
+    return new J();
+  }
+  /**
+   * @ignore
+   */
+  get classNames() {
+    return this.constructor.classNames;
+  }
+  /**
+   * @ignore
+   */
+  get className() {
+    return this.constructor.className;
+  }
+  _setDefaults() {
+  }
+  _setDefaultFn(e, t) {
+    const i = this.get(e);
+    if (i)
+      return i;
+    {
+      const r = t();
+      return this.set(e, r), r;
+    }
+  }
+  _setDefault(e, t) {
+    this.has(e) || super.set(e, t);
+  }
+  _setRawDefault(e, t) {
+    this.has(e) || super.setRaw(e, t);
+  }
+  _clearDirty() {
+    y(this._dirty).forEach((e) => {
+      this._dirty[e] = !1;
+    }), y(this._dirtyPrivate).forEach((e) => {
+      this._dirtyPrivate[e] = !1;
+    });
+  }
+  /**
+   * @ignore
+   */
+  isDirty(e) {
+    return !!this._dirty[e];
+  }
+  /**
+   * @ignore
+   */
+  isPrivateDirty(e) {
+    return !!this._dirtyPrivate[e];
+  }
+  _markDirtyKey(e) {
+    this._dirty[e] = !0, super._markDirtyKey(e);
+  }
+  _markDirtyPrivateKey(e) {
+    this._dirtyPrivate[e] = !0, super._markDirtyKey(e);
+  }
+  /**
+   * Checks if element is of certain class (or inherits one).
+   *
+   * @param   type  Class name to check
+   * @return {boolean} Is of class?
+   */
+  isType(e) {
+    return this.classNames.indexOf(e) !== -1;
+  }
+  _pushPropertyDisposer(e, t) {
+    let i = this._disposerProperties[e];
+    return i === void 0 && (i = this._disposerProperties[e] = []), i.push(t), t;
+  }
+  _disposeProperty(e) {
+    const t = this._disposerProperties[e];
+    t !== void 0 && (c(t, (i) => {
+      i.dispose();
+    }), delete this._disposerProperties[e]);
+  }
+  /**
+   * @todo needs description
+   * @param  value  Template
+   */
+  set template(e) {
+    const t = this._template;
+    t !== e && (this._template = e, t && t._removeObjectTemplate(this), e && e._setObjectTemplate(this), this._applyTemplates());
+  }
+  get template() {
+    return this._template;
+  }
+  /**
+   * @ignore
+   */
+  markDirty() {
+    this._root._addDirtyEntity(this);
+  }
+  _startAnimation() {
+    this._root._addAnimation(this);
+  }
+  _animationTime() {
+    return this._root.animationTime;
+  }
+  _applyState(e) {
+  }
+  _applyStateAnimated(e, t) {
+  }
+  get(e, t) {
+    const i = this.adapters.fold(e, this._settings[e]);
+    return i !== void 0 ? i : t;
+  }
+  /**
+   * @ignore
+   */
+  isUserSetting(e) {
+    return this._userProperties[e] || !1;
+  }
+  /**
+   * Sets a setting `value` for the specified `key`, and returns the same `value`.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param   key       Setting key
+   * @param   value     Setting value
+   * @return            Setting value
+   */
+  set(e, t) {
+    return this._userProperties[e] = !0, super.set(e, t);
+  }
+  /**
+   * @ignore
+   */
+  setRaw(e, t) {
+    this._userProperties[e] = !0, super.setRaw(e, t);
+  }
+  /**
+   * Sets a setting `value` for the specified `key` only if the value for this key was not set previously using set method, and returns the same `value`.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param   key       Setting key
+   * @param   value     Setting value
+   * @return            Setting value
+   */
+  _setSoft(e, t) {
+    return this._userProperties[e] ? t : super.set(e, t);
+  }
+  /**
+   * Removes a setting value for the specified `key`.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/settings/} for more info
+   * @param   key       Setting key
+   */
+  remove(e) {
+    delete this._userProperties[e], this._removeTemplateProperty(e);
+  }
+  /**
+   * @ignore
+   */
+  setPrivate(e, t) {
+    return this._userPrivateProperties[e] = !0, super.setPrivate(e, t);
+  }
+  /**
+   * @ignore
+   */
+  setPrivateRaw(e, t) {
+    this._userPrivateProperties[e] = !0, super.setPrivateRaw(e, t);
+  }
+  /**
+   * @ignore
+   */
+  removePrivate(e) {
+    delete this._userPrivateProperties[e], this._removeTemplatePrivateProperty(e);
+  }
+  _setTemplateProperty(e, t, i) {
+    if (!this._userProperties[t]) {
+      const r = this._findTemplateByKey(t);
+      e === r && super.set(t, i);
+    }
+  }
+  _setTemplatePrivateProperty(e, t, i) {
+    if (!this._userPrivateProperties[t]) {
+      const r = this._findTemplateByPrivateKey(t);
+      e === r && super.setPrivate(t, i);
+    }
+  }
+  _removeTemplateProperty(e) {
+    if (!this._userProperties[e]) {
+      const t = this._findTemplateByKey(e);
+      t ? super.set(e, t._settings[e]) : super.remove(e);
+    }
+  }
+  _removeTemplatePrivateProperty(e) {
+    if (!this._userPrivateProperties[e]) {
+      const t = this._findTemplateByPrivateKey(e);
+      t ? super.setPrivate(e, t._privateSettings[e]) : super.removePrivate(e);
+    }
+  }
+  _walkParents(e) {
+    e(this._root._rootContainer), e(this);
+  }
+  // TODO faster version of this method which is specialized to just 1 key
+  _applyStateByKey(e) {
+    const t = this.states.create(e, {}), i = {};
+    this._eachTemplate((r) => {
+      const n = r.states.lookup(e);
+      n && n._apply(t, i);
+    }), p(t._settings, (r) => {
+      !i[r] && !t._userSettings[r] && t.remove(r);
+    });
+  }
+  _applyTemplate(e, t) {
+    this._templateDisposers.push(e._apply(this, t)), p(e._settings, (i, r) => {
+      !t.settings[i] && !this._userProperties[i] && (t.settings[i] = !0, super.set(i, r));
+    }), p(e._privateSettings, (i, r) => {
+      !t.privateSettings[i] && !this._userPrivateProperties[i] && (t.privateSettings[i] = !0, super.setPrivate(i, r));
+    }), this._runSetup && e.setup && (this._runSetup = !1, e.setup(this));
+  }
+  /**
+   * Calls the closure with each template and returns the first template which is true
+   */
+  _findStaticTemplate(e) {
+    if (this._template && e(this._template))
+      return this._template;
+  }
+  _eachTemplate(e) {
+    this._findStaticTemplate((t) => (e(t), !1)), j(this._internalTemplates, e), c(this._templates, e);
+  }
+  _applyTemplates(e = !0) {
+    e && this._disposeTemplates();
+    const t = {
+      settings: {},
+      privateSettings: {},
+      states: {}
+    };
+    this._eachTemplate((i) => {
+      this._applyTemplate(i, t);
+    }), e && (p(this._settings, (i) => {
+      !this._userProperties[i] && !t.settings[i] && super.remove(i);
+    }), p(this._privateSettings, (i) => {
+      !this._userPrivateProperties[i] && !t.privateSettings[i] && super.removePrivate(i);
+    }));
+  }
+  _findTemplate(e) {
+    const t = this._findStaticTemplate(e);
+    if (t === void 0) {
+      const i = ae(this._internalTemplates, e);
+      return i === void 0 ? ne(this._templates, e) : i;
+    } else
+      return t;
+  }
+  _findTemplateByKey(e) {
+    return this._findTemplate((t) => e in t._settings);
+  }
+  _findTemplateByPrivateKey(e) {
+    return this._findTemplate((t) => e in t._privateSettings);
+  }
+  _disposeTemplates() {
+    c(this._templateDisposers, (e) => {
+      e.dispose();
+    }), this._templateDisposers.length = 0;
+  }
+  _removeTemplates() {
+    c(this._templates, (e) => {
+      e._removeObjectTemplate(this);
+    }), this._templates.length = 0;
+  }
+  _applyThemes(e = !1) {
+    let t = !1;
+    const i = [];
+    let r = [];
+    const n = /* @__PURE__ */ new Set(), a = this.get("themeTagsSelf");
+    return a && c(a, (u) => {
+      n.add(u);
+    }), this._walkParents((u) => {
+      u === this._root._rootContainer && (t = !0), u._defaultThemes.length > 0 && i.push(u._defaultThemes);
+      const o = u.get("themes");
+      o && r.push(o);
+      const l = u.get("themeTags");
+      l && c(l, (f) => {
+        n.add(f);
+      });
+    }), r = i.concat(r), this._removeTemplates(), (t || e) && j(this.classNames, (u) => {
+      const o = [];
+      c(r, (l) => {
+        c(l, (f) => {
+          const d = f._lookupRules(u);
+          d && j(d, (m) => {
+            if (m.tags.every((E) => n.has(E))) {
+              const E = ue(o, (M) => {
+                const N = L(m.tags.length, M.tags.length);
+                return N === 0 ? je(m.tags, M.tags, L) : N;
+              });
+              o.splice(E.index, 0, m);
+            }
+          });
+        });
+      }), c(o, (l) => {
+        this._templates.push(l.template), l.template._setObjectTemplate(this);
+      });
+    }), this._applyTemplates(), (t || e) && (this._runSetup = !1), t || e;
+  }
+  _changed() {
+  }
+  _beforeChanged() {
+    if (this.isDirty("id")) {
+      const e = this.get("id");
+      e && this._registerId(e);
+      const t = this._prevSettings.id;
+      t && (delete this._root.entitiesById[t], delete C.entitiesById[t]);
+    }
+  }
+  _registerId(e) {
+    if (this._root.entitiesById[e] && this._root.entitiesById[e] !== this)
+      throw new Error('An entity with id "' + e + '" already exists.');
+    this._root.entitiesById[e] = this, C.entitiesById[e] = this;
+  }
+  _afterChanged() {
+  }
+  /**
+   * @ignore
+   */
+  addDisposer(e) {
+    return this._disposers.push(e), e;
+  }
+  _dispose() {
+    super._dispose();
+    const e = this._template;
+    e && e._removeObjectTemplate(this), c(this._internalTemplates, (i) => {
+      i._removeObjectTemplate(this);
+    }), this._removeTemplates(), this._disposeTemplates(), this.events.dispose(), this._disposers.forEach((i) => {
+      i.dispose();
+    }), p(this._disposerProperties, (i, r) => {
+      c(r, (n) => {
+        n.dispose();
+      });
+    });
+    const t = this.get("id");
+    t && (delete this._root.entitiesById[t], delete C.entitiesById[t]);
+  }
+  /**
+   * Creates and returns a "disposable" timeout.
+   *
+   * @param   fn     Callback
+   * @param   delay  Delay in milliseconds
+   * @return         Timeout disposer
+   */
+  setTimeout(e, t) {
+    const i = setTimeout(() => {
+      this.removeDispose(r), e();
+    }, t), r = new w(() => {
+      clearTimeout(i);
+    });
+    return this._disposers.push(r), r;
+  }
+  /**
+   * @ignore
+   */
+  removeDispose(e) {
+    if (!this.isDisposed()) {
+      let t = I(this._disposers, e);
+      t > -1 && this._disposers.splice(t, 1);
+    }
+    e.dispose();
+  }
+  /**
+   * @ignore
+   */
+  hasTag(e) {
+    return I(this.get("themeTags", []), e) !== -1;
+  }
+  /**
+   * @ignore
+   */
+  addTag(e) {
+    if (!this.hasTag(e)) {
+      const t = this.get("themeTags", []);
+      t.push(e), this.set("themeTags", t);
+    }
+  }
+  /**
+   * @ignore
+   */
+  removeTag(e) {
+    if (this.hasTag(e)) {
+      const t = this.get("themeTags", []);
+      se(t, e), this.set("themeTags", t);
+    }
+  }
+  _t(e, t, ...i) {
+    return this._root.language.translate(e, t, ...i);
+  }
+  /**
+   * An instance of [[Root]] object.
+   *
+   * @readonly
+   * @since 5.0.6
+   * @return Root object
+   */
+  get root() {
+    return this._root;
+  }
+}
+Object.defineProperty(O, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Entity"
+});
+Object.defineProperty(O, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: ["Entity"]
+});
+class F extends O {
+  //protected _currentPass: number = 0;
+  _afterNew() {
+    super._afterNewApplyThemes(), this._dirty.colors = !1;
+  }
+  _beforeChanged() {
+    this.isDirty("colors") && this.reset();
+  }
+  /**
+   * @ignore
+   */
+  generateColors() {
+    this.setPrivate("currentPass", this.getPrivate("currentPass", 0) + 1);
+    const e = this.getPrivate("currentPass"), t = this.get("colors", [this.get("baseColor", h.fromHex(16711680))]);
+    this.getPrivate("numColors") || this.setPrivate("numColors", t.length);
+    const i = this.getPrivate("numColors"), r = 0, n = this.get("passOptions"), a = this.get("reuse");
+    for (let u = r; u < i; u++)
+      if (a)
+        t.push(t[u]);
+      else {
+        const o = t[u].toHSL();
+        let l = o.h + (n.hue || 0) * e;
+        for (; l > 1; )
+          l -= 1;
+        let f = o.s + (n.saturation || 0) * e;
+        f > 1 && (f = 1), f < 0 && (f = 0);
+        let d = o.l + (n.lightness || 0) * e;
+        for (; d > 1; )
+          d -= 1;
+        t.push(h.fromHSL(l, f, d));
+      }
+  }
+  /**
+   * Returns a [[Color]] at specific index.
+   *
+   * If there's no color at this index, a new color is generated.
+   *
+   * @param   index  Index
+   * @return         Color
+   */
+  getIndex(e) {
+    const t = this.get("colors", []), i = this.get("saturation");
+    return e >= t.length ? (this.generateColors(), this.getIndex(e)) : i != null ? h.saturate(t[e], i) : t[e];
+  }
+  /**
+   * Returns next [[Color]] in the list.
+   *
+   * If the list is out of colors, new ones are generated dynamically.
+   */
+  next() {
+    let e = this.getPrivate("currentStep", this.get("startIndex", 0));
+    return this.setPrivate("currentStep", e + this.get("step", 1)), this.getIndex(e);
+  }
+  /**
+   * Resets counter to the start of the list, so the next call for `next()` will
+   * return the first color.
+   */
+  reset() {
+    this.setPrivate("currentStep", this.get("startIndex", 0)), this.setPrivate("currentPass", 0);
+  }
+}
+Object.defineProperty(F, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "ColorSet"
+});
+Object.defineProperty(F, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: O.classNames.concat([F.className])
+});
+export {
+  Re as $,
+  se as A,
+  Ye as B,
+  F as C,
+  Ft as D,
+  O as E,
+  P as F,
+  jt as G,
+  _t as H,
+  Lt as I,
+  Se as J,
+  ze as K,
+  J as L,
+  le as M,
+  I as N,
+  Ze as O,
+  g as P,
+  ie as Q,
+  j as R,
+  w as S,
+  $e as T,
+  st as U,
+  qe as V,
+  ke as W,
+  It as X,
+  Be as Y,
+  B as Z,
+  Q as _,
+  Le as a,
+  ee as a0,
+  gt as a1,
+  tt as a2,
+  Ve as a3,
+  $ as a4,
+  mt as a5,
+  Ue as a6,
+  Me as a7,
+  Et as a8,
+  A as a9,
+  T as aA,
+  Ce as aB,
+  ne as aC,
+  ye as aD,
+  Ot as aa,
+  Dt as ab,
+  yt as ac,
+  Tt as ad,
+  U as ae,
+  Pt as af,
+  St as ag,
+  vt as ah,
+  Qe as ai,
+  He as aj,
+  je as ak,
+  Xe as al,
+  ut as am,
+  nt as an,
+  lt as ao,
+  wt as ap,
+  ot as aq,
+  Z as ar,
+  ct as as,
+  C as at,
+  et as au,
+  bt as av,
+  Fe as aw,
+  dt as ax,
+  it as ay,
+  rt as az,
+  Ie as b,
+  Ct as c,
+  he as d,
+  c as e,
+  v as f,
+  ft as g,
+  Y as h,
+  at as i,
+  Ge as j,
+  y as k,
+  Je as l,
+  xt as m,
+  ue as n,
+  L as o,
+  R as p,
+  Ke as q,
+  p as r,
+  x as s,
+  k as t,
+  h as u,
+  Ne as v,
+  ht as w,
+  pt as x,
+  At as y,
+  We as z
+};