@hybridcore/ui 1.6.8 → 1.6.9

package/dist/Tooltip-A_HlttXp.js

@@ -0,0 +1,3606 @@
+import { e as w, ai as mt, a7 as St, au as rt, av as yt, aw as Ot, f as m, r as H, a6 as Q, D as B, M as C, z as Ct, u as bt, k as lt, E as F, P as D, ac as vt, w as L, d as q, i as Dt, ax as at, _ as nt, ay as Lt, a9 as It, az as wt, Q as xt, C as ht, ad as Mt, t as Pt, aA as Bt, aB as kt, h as Wt, v as Nt, aC as Rt, b as Ft, a as At, m as Gt } from "./Entity-CCUIdRAr.js";
+function z(n, t) {
+  if (!(n >= 0 && n < t))
+    throw new Error("Index out of bounds: " + n);
+}
+class Ht {
+  /**
+   * Constructor
+   *
+   * @param initial  Inital list of values to add to list
+   */
+  constructor(t = []) {
+    Object.defineProperty(this, "_values", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "events", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new mt()
+    }), this._values = t;
+  }
+  /**
+   * An array of values in the list.
+   *
+   * Do not use this property to add values. Rather use dedicated methods, like
+   * `push()`, `removeIndex()`, etc.
+   *
+   * @readonly
+   * @return List values
+   */
+  get values() {
+    return this._values;
+  }
+  /**
+   * Checks if list contains specific item reference.
+   *
+   * @param item  Item to search for
+   * @return `true` if found, `false` if not found
+   */
+  contains(t) {
+    return this._values.indexOf(t) !== -1;
+  }
+  /**
+   * Removes specific item from the list.
+   *
+   * @param item An item to remove
+   */
+  removeValue(t) {
+    let e = 0, i = this._values.length;
+    for (; e < i; )
+      this._values[e] === t ? (this.removeIndex(e), --i) : ++e;
+  }
+  /**
+   * Searches the list for specific item and returns its index.
+   *
+   * @param item  An item to search for
+   * @return Index or -1 if not found
+   */
+  indexOf(t) {
+    return St(this._values, t);
+  }
+  /**
+   * Number of items in list.
+   *
+   * @readonly
+   * @return Number of items
+   */
+  get length() {
+    return this._values.length;
+  }
+  /**
+   * Checks if there's a value at specific index.
+   *
+   * @param index  Index
+   * @return Value exists?
+   */
+  hasIndex(t) {
+    return t >= 0 && t < this._values.length;
+  }
+  /**
+   * Returns an item at specified index.
+   *
+   * @param index  Index
+   * @return List item
+   */
+  getIndex(t) {
+    return this._values[t];
+  }
+  _onPush(t) {
+    this.events.isEnabled("push") && this.events.dispatch("push", {
+      type: "push",
+      target: this,
+      newValue: t
+    });
+  }
+  _onInsertIndex(t, e) {
+    this.events.isEnabled("insertIndex") && this.events.dispatch("insertIndex", {
+      type: "insertIndex",
+      target: this,
+      index: t,
+      newValue: e
+    });
+  }
+  _onSetIndex(t, e, i) {
+    this.events.isEnabled("setIndex") && this.events.dispatch("setIndex", {
+      type: "setIndex",
+      target: this,
+      index: t,
+      oldValue: e,
+      newValue: i
+    });
+  }
+  _onSwap(t, e) {
+    this.events.isEnabled("swap") && this.events.dispatch("swap", {
+      type: "swap",
+      target: this,
+      a: t,
+      b: e
+    });
+  }
+  _onRemoveIndex(t, e) {
+    this.events.isEnabled("removeIndex") && this.events.dispatch("removeIndex", {
+      type: "removeIndex",
+      target: this,
+      index: t,
+      oldValue: e
+    });
+  }
+  _onMoveIndex(t, e, i) {
+    this.events.isEnabled("moveIndex") && this.events.dispatch("moveIndex", {
+      type: "moveIndex",
+      target: this,
+      oldIndex: t,
+      newIndex: e,
+      value: i
+    });
+  }
+  _onClear(t) {
+    this.events.isEnabled("clear") && this.events.dispatch("clear", {
+      type: "clear",
+      target: this,
+      oldValues: t
+    });
+  }
+  /**
+   * Sets value at specific index.
+   *
+   * If there's already a value at the index, it is overwritten.
+   *
+   * @param index  Index
+   * @param value  New value
+   * @return New value
+   */
+  setIndex(t, e) {
+    z(t, this._values.length);
+    const i = this._values[t];
+    return i !== e && (this._values[t] = e, this._onSetIndex(t, i, e)), i;
+  }
+  /**
+   * Adds an item to the list at a specific index, which pushes all the other
+   * items further down the list.
+   *
+   * @param index Index
+   * @param item  An item to add
+   */
+  insertIndex(t, e) {
+    return z(t, this._values.length + 1), rt(this._values, t, e), this._onInsertIndex(t, e), e;
+  }
+  /**
+   * Swaps indexes of two items in the list.
+   *
+   * @param a  Item 1
+   * @param b  Item 2
+   */
+  swap(t, e) {
+    const i = this._values.length;
+    if (z(t, i), z(e, i), t !== e) {
+      const s = this._values[t], r = this._values[e];
+      this._values[t] = r, this._values[e] = s, this._onSwap(s, r);
+    }
+  }
+  /**
+   * Removes a value at specific index.
+   *
+   * @param index  Index of value to remove
+   * @return Removed value
+   */
+  removeIndex(t) {
+    z(t, this._values.length);
+    const e = this._values[t];
+    return yt(this._values, t), this._onRemoveIndex(t, e), e;
+  }
+  /**
+   * Moves an item to a specific index within the list.
+   *
+   * If the index is not specified it will move the item to the end of the
+   * list.
+   *
+   * @param value  Item to move
+   * @param index  Index to place item at
+   */
+  moveValue(t, e) {
+    let i = this.indexOf(t);
+    if (i !== -1)
+      if (yt(this._values, i), e == null) {
+        const s = this._values.length;
+        this._values.push(t), this._onMoveIndex(i, s, t);
+      } else
+        rt(this._values, e, t), this._onMoveIndex(i, e, t);
+    else e == null ? (this._values.push(t), this._onPush(t)) : (rt(this._values, e, t), this._onInsertIndex(e, t));
+    return t;
+  }
+  /**
+   * Adds an item to the end of the list.
+   *
+   * @param item  An item to add
+   */
+  push(t) {
+    return this._values.push(t), this._onPush(t), t;
+  }
+  /**
+   * Adds an item as a first item in the list.
+   *
+   * @param item  An item to add
+   */
+  unshift(t) {
+    return this.insertIndex(0, t), t;
+  }
+  /**
+   * Adds multiple items to the list.
+   *
+   * @param items  An Array of items to add
+   */
+  pushAll(t) {
+    w(t, (e) => {
+      this.push(e);
+    });
+  }
+  /**
+   * Copies and adds items from abother list.
+   *
+   * @param source  A list top copy items from
+   */
+  copyFrom(t) {
+    this.pushAll(t._values);
+  }
+  /**
+   * Returns the last item from the list, and removes it.
+   *
+   * @return Item
+   */
+  pop() {
+    return this._values.length - 1 < 0 ? void 0 : this.removeIndex(this._values.length - 1);
+  }
+  /**
+   * Returns the first item from the list, and removes it.
+   *
+   * @return Item
+   */
+  shift() {
+    return this._values.length ? this.removeIndex(0) : void 0;
+  }
+  /**
+   * Sets multiple items to the list.
+   *
+   * All current items are removed.
+   *
+   * @param newArray  New items
+   */
+  setAll(t) {
+    const e = this._values;
+    this._values = [], this._onClear(e), w(t, (i) => {
+      this._values.push(i), this._onPush(i);
+    });
+  }
+  /**
+   * Removes all items from the list.
+   */
+  clear() {
+    this.setAll([]);
+  }
+  /**
+   * Returns an ES6 iterator for the list.
+   */
+  *[Symbol.iterator]() {
+    const t = this._values.length;
+    for (let e = 0; e < t; ++e)
+      yield this._values[e];
+  }
+  /**
+   * Calls `f` for each element in the list.
+   *
+   * `f` should have at least one parameter defined which will get a current
+   * item, with optional second argument - index.
+   */
+  each(t) {
+    w(this._values, t);
+  }
+  /**
+   * Calls `f` for each element in the list, from right to left.
+   *
+   * `f` should have at least one parameter defined which will get a current
+   * item, with optional second argument - index.
+   */
+  eachReverse(t) {
+    Ot(this._values, t);
+  }
+}
+class Vt extends Ht {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "autoDispose", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), Object.defineProperty(this, "_disposed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    });
+  }
+  /**
+   * Swaps indexes of two items in the list.
+   *
+   * @param a  Item 1
+   * @param b  Item 2
+   */
+  swap(t, e) {
+    const i = this.autoDispose;
+    this.autoDispose = !1, super.swap(t, e), this.autoDispose = i;
+  }
+  _onSetIndex(t, e, i) {
+    this.autoDispose && e.dispose(), super._onSetIndex(t, e, i);
+  }
+  _onRemoveIndex(t, e) {
+    this.autoDispose && e.dispose(), super._onRemoveIndex(t, e);
+  }
+  _onClear(t) {
+    this.autoDispose && w(t, (e) => {
+      e.dispose();
+    }), super._onClear(t);
+  }
+  _dispose() {
+    this.autoDispose && w(this._values, (t) => {
+      t.dispose();
+    });
+  }
+  isDisposed() {
+    return this._disposed;
+  }
+  dispose() {
+    this._disposed || (this._disposed = !0, this._dispose());
+  }
+}
+class qt extends Vt {
+  constructor(t, e) {
+    super(), Object.defineProperty(this, "template", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "make", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.template = t, this.make = e;
+  }
+  _dispose() {
+    super._dispose(), this.autoDispose && this.template.dispose();
+  }
+}
+class zt extends Ht {
+  constructor(t) {
+    super(), Object.defineProperty(this, "_disposed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_container", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_events", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._container = t, this._events = this.events.onAll((e) => {
+      if (e.type === "clear")
+        w(e.oldValues, (i) => {
+          this._onRemoved(i);
+        });
+      else if (e.type === "push")
+        this._onInserted(e.newValue);
+      else if (e.type === "setIndex")
+        this._onRemoved(e.oldValue), this._onInserted(e.newValue, e.index);
+      else if (e.type === "insertIndex")
+        this._onInserted(e.newValue, e.index);
+      else if (e.type === "removeIndex")
+        this._onRemoved(e.oldValue);
+      else if (e.type === "moveIndex")
+        this._onRemoved(e.value), this._onInserted(e.value, e.newIndex);
+      else
+        throw new Error("Unknown IListEvent type");
+    });
+  }
+  _onInserted(t, e) {
+    t._setParent(this._container, !0);
+    const i = this._container._childrenDisplay;
+    e === void 0 ? i.addChild(t._display) : i.addChildAt(t._display, e);
+  }
+  _onRemoved(t) {
+    this._container._childrenDisplay.removeChild(t._display), this._container.markDirtyBounds(), this._container.markDirty();
+  }
+  /**
+   * Returns `true` if obejct is disposed.
+   */
+  isDisposed() {
+    return this._disposed;
+  }
+  /**
+   * Permanently dispose this object.
+   */
+  dispose() {
+    this._disposed || (this._disposed = !0, this._events.dispose(), w(this.values, (t) => {
+      t.dispose();
+    }));
+  }
+}
+const jt = Math.PI, Et = jt / 180, Qt = 180 / jt;
+function Zt(n, t, e) {
+  if (!m(t) || t <= 0)
+    return Math.round(n);
+  {
+    let i = Math.pow(10, t);
+    return Math.round(n * i) / i;
+  }
+}
+function te(n, t) {
+  if (!m(t) || t <= 0)
+    return Math.ceil(n);
+  {
+    let e = Math.pow(10, t);
+    return Math.ceil(n * e) / e;
+  }
+}
+function T(n, t, e) {
+  return Math.min(Math.max(n, t), e);
+}
+function ut(n) {
+  return Math.sin(Et * n);
+}
+function dt(n) {
+  return Math.cos(Et * n);
+}
+function Tt(n) {
+  return n = n % 360, n < 0 && (n += 360), n;
+}
+function ee(n, t, e, i, s) {
+  let r = Number.MAX_VALUE, a = Number.MAX_VALUE, o = -Number.MAX_VALUE, l = -Number.MAX_VALUE, h = [];
+  h.push(ot(s, e)), h.push(ot(s, i));
+  let u = Math.min(Math.floor(e / 90) * 90, Math.floor(i / 90) * 90), f = Math.max(Math.ceil(e / 90) * 90, Math.ceil(i / 90) * 90);
+  for (let d = u; d <= f; d += 90)
+    d >= e && d <= i && h.push(ot(s, d));
+  for (let d = 0; d < h.length; d++) {
+    let p = h[d];
+    p.x < r && (r = p.x), p.y < a && (a = p.y), p.x > o && (o = p.x), p.y > l && (l = p.y);
+  }
+  return { left: n + r, top: t + a, right: n + o, bottom: t + l };
+}
+function ot(n, t) {
+  return { x: n * dt(t), y: n * ut(t) };
+}
+function ie(n) {
+  const t = n.length;
+  if (t > 0) {
+    let e = n[0], i = e.left, s = e.top, r = e.right, a = e.bottom;
+    if (t > 1)
+      for (let o = 1; o < t; o++)
+        e = n[o], i = Math.min(e.left, i), r = Math.max(e.right, r), s = Math.min(e.top, s), a = Math.max(e.bottom, a);
+    return { left: i, right: r, top: s, bottom: a };
+  }
+  return { left: 0, right: 0, top: 0, bottom: 0 };
+}
+function se(n, t, e) {
+  if (t > e) {
+    let a = t;
+    t = e, e = a;
+  }
+  n = Tt(n);
+  let i = (t - Tt(t)) / 360;
+  n < t && (n += 360 * (i + 1));
+  let s = t + (e - t) / 2 + 180, r = t + (e - t) / 2 - 180;
+  return n > e && (n - 360 > t ? n -= 360 : n < s ? n = e : n = t), n < t && (n > r ? n = t : n = e), n;
+}
+function Xt(n, t) {
+  return n.x >= t.left && n.y >= t.top && n.x <= t.right && n.y <= t.bottom;
+}
+function pt(n) {
+  H(n, (t, e) => {
+    bt(e) && typeof e.dispose == "function" && (e.enableDispose = !0, e.dispose());
+  });
+}
+class Yt {
+  constructor(t, e, i) {
+    Object.defineProperty(this, "_settings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_template", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this._name = t, this._template = e, this._settings = i;
+  }
+  _dispose() {
+    pt(this._settings);
+  }
+  get(t, e) {
+    const i = this._settings[t];
+    return i !== void 0 ? i : e;
+  }
+  set(t, e) {
+    this._settings[t] = e, this._template._stateChanged(this._name);
+  }
+  remove(t) {
+    delete this._settings[t], this._template._stateChanged(this._name);
+  }
+  setAll(t) {
+    lt(t).forEach((e) => {
+      this._settings[e] = t[e];
+    }), this._template._stateChanged(this._name);
+  }
+  _apply(t, e) {
+    H(this._settings, (i, s) => {
+      !e[i] && !t._userSettings[i] && (e[i] = !0, t.setRaw(i, s));
+    });
+  }
+}
+class Ut {
+  constructor(t) {
+    Object.defineProperty(this, "_template", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_states", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), this._template = t;
+  }
+  _dispose() {
+    H(this._states, (t, e) => {
+      e._dispose();
+    });
+  }
+  lookup(t) {
+    return this._states[t];
+  }
+  create(t, e) {
+    const i = this._states[t];
+    if (i)
+      return i.setAll(e), i;
+    {
+      const s = new Yt(t, this._template, e);
+      return this._states[t] = s, this._template._stateChanged(t), s;
+    }
+  }
+  remove(t) {
+    delete this._states[t], this._template._stateChanged(t);
+  }
+  _apply(t, e) {
+    H(this._states, (i, s) => {
+      let r = e.states[i];
+      r == null && (r = e.states[i] = {});
+      const a = t.states.create(i, {});
+      s._apply(a, r);
+    });
+  }
+}
+class Kt {
+  constructor() {
+    Object.defineProperty(this, "_callbacks", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    });
+  }
+  add(t, e) {
+    let i = this._callbacks[t];
+    return i === void 0 && (i = this._callbacks[t] = []), i.push(e), new Q(() => {
+      B(i, e), i.length === 0 && delete this._callbacks[t];
+    });
+  }
+  remove(t) {
+    this._callbacks[t] !== void 0 && delete this._callbacks[t];
+  }
+  _apply(t) {
+    const e = [];
+    return H(this._callbacks, (i, s) => {
+      w(s, (r) => {
+        e.push(t.adapters.add(i, r));
+      });
+    }), new C(e);
+  }
+}
+class Z {
+  constructor(t, e) {
+    if (Object.defineProperty(this, "_disposed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), 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, "_entities", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "states", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new Ut(this)
+    }), Object.defineProperty(this, "adapters", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new Kt()
+    }), Object.defineProperty(this, "events", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new mt()
+    }), Object.defineProperty(this, "setup", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), !e)
+      throw new Error("You cannot use `new Class()`, instead use `Class.new()`");
+    this._settings = t;
+  }
+  /**
+   * 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(t) {
+    return new Z(t, !0);
+  }
+  _dispose() {
+    pt(this._settings), pt(this._privateSettings);
+  }
+  /**
+   * Returns `true` if this element is disposed.
+   *
+   * @return Disposed
+   */
+  isDisposed() {
+    return this._disposed;
+  }
+  /**
+   * Disposes this object.
+   */
+  dispose() {
+    this._disposed || (this._disposed = !0, this._dispose());
+  }
+  _checkDisposed() {
+    if (this._disposed)
+      throw new Error("Template is disposed");
+  }
+  /**
+   * Array of all entities using this template.
+   */
+  get entities() {
+    return this._entities;
+  }
+  get(t, e) {
+    this._checkDisposed();
+    const i = this._settings[t];
+    return i !== void 0 ? i : e;
+  }
+  setRaw(t, e) {
+    this._checkDisposed(), this._settings[t] = e;
+  }
+  set(t, e) {
+    this._checkDisposed(), this._settings[t] !== e && (this.setRaw(t, e), this._entities.forEach((i) => {
+      i._setTemplateProperty(this, t, e);
+    }));
+  }
+  remove(t) {
+    this._checkDisposed(), t in this._settings && (delete this._settings[t], this._entities.forEach((e) => {
+      e._removeTemplateProperty(t);
+    }));
+  }
+  removeAll() {
+    this._checkDisposed(), H(this._settings, (t, e) => {
+      this.remove(t);
+    });
+  }
+  getPrivate(t, e) {
+    this._checkDisposed();
+    const i = this._privateSettings[t];
+    return i !== void 0 ? i : e;
+  }
+  setPrivateRaw(t, e) {
+    return this._checkDisposed(), this._privateSettings[t] = e, e;
+  }
+  setPrivate(t, e) {
+    return this._checkDisposed(), this._privateSettings[t] !== e && (this.setPrivateRaw(t, e), this._entities.forEach((i) => {
+      i._setTemplatePrivateProperty(this, t, e);
+    })), e;
+  }
+  removePrivate(t) {
+    this._checkDisposed(), t in this._privateSettings && (delete this._privateSettings[t], this._entities.forEach((e) => {
+      e._removeTemplatePrivateProperty(t);
+    }));
+  }
+  setAll(t) {
+    this._checkDisposed(), H(t, (e, i) => {
+      this.set(e, i);
+    });
+  }
+  // TODO code duplication with Properties
+  on(t, e) {
+    this._checkDisposed();
+    let i = this._settingEvents[t];
+    return i === void 0 && (i = this._settingEvents[t] = []), i.push(e), new Q(() => {
+      B(i, e), i.length === 0 && delete this._settingEvents[t];
+    });
+  }
+  // TODO code duplication with Properties
+  onPrivate(t, e) {
+    this._checkDisposed();
+    let i = this._privateSettingEvents[t];
+    return i === void 0 && (i = this._privateSettingEvents[t] = []), i.push(e), new Q(() => {
+      B(i, e), i.length === 0 && delete this._privateSettingEvents[t];
+    });
+  }
+  _apply(t, e) {
+    this._checkDisposed();
+    const i = [];
+    return H(this._settingEvents, (s, r) => {
+      w(r, (a) => {
+        i.push(t.on(s, a));
+      });
+    }), H(this._privateSettingEvents, (s, r) => {
+      w(r, (a) => {
+        i.push(t.onPrivate(s, a));
+      });
+    }), this.states._apply(t, e), i.push(this.adapters._apply(t)), i.push(t.events.copyFrom(this.events)), new C(i);
+  }
+  _setObjectTemplate(t) {
+    this._checkDisposed(), this._entities.push(t);
+  }
+  _removeObjectTemplate(t) {
+    Ct(this._entities, t);
+  }
+  _stateChanged(t) {
+    this._checkDisposed(), this._entities.forEach((e) => {
+      e._applyStateByKey(t);
+    });
+  }
+}
+class st extends mt {
+  constructor(t) {
+    super(), Object.defineProperty(this, "_sprite", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_rendererDisposers", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_dispatchParents", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), this._sprite = t;
+  }
+  _makePointerEvent(t, e) {
+    return {
+      type: t,
+      originalEvent: e.event,
+      point: e.point,
+      simulated: e.simulated,
+      native: e.native,
+      target: this._sprite
+    };
+  }
+  _onRenderer(t, e) {
+    this._sprite.set("interactive", !0), this._sprite._display.interactive = !0;
+    let i = this._rendererDisposers[t];
+    if (i === void 0) {
+      const s = this._sprite._display.on(t, (r) => {
+        e.call(this, r);
+      });
+      i = this._rendererDisposers[t] = new It(() => {
+        delete this._rendererDisposers[t], s.dispose();
+      });
+    }
+    return i.increment();
+  }
+  _on(t, e, i, s, r, a, o) {
+    const l = super._on(t, e, i, s, r, a, o), h = st.RENDERER_EVENTS[e];
+    return h !== void 0 && (l.disposer = new C([
+      l.disposer,
+      this._onRenderer(e, h)
+    ])), l;
+  }
+  /**
+   * Will stop any bubbling up of the event to element's parents.
+   *
+   * Should be called in an event handler, e.g.:
+   *
+   * ```TypeScript
+   * element.events.on("pointerdown", function(ev) {
+   *   // Do something here and prevent from "pointerdown" bubbling up
+   *   // ...
+   *   ev.target.events.stopParentDispatch();
+   * });
+   * ```
+   * ```JavaScript
+   * element.events.on("pointerdown", function(ev) {
+   *   // Do something here and prevent from "pointerdown" bubbling up
+   *   // ...
+   *   ev.target.events.stopParentDispatch();
+   * });
+   * ```
+   */
+  stopParentDispatch() {
+    this._dispatchParents = !1;
+  }
+  /**
+   * @ignore
+   */
+  dispatchParents(t, e) {
+    const i = this._dispatchParents;
+    this._dispatchParents = !0;
+    try {
+      this.dispatch(t, e), this._dispatchParents && this._sprite.parent && this._sprite.parent.events.dispatchParents(t, e);
+    } finally {
+      this._dispatchParents = i;
+    }
+  }
+}
+Object.defineProperty(st, "RENDERER_EVENTS", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: {
+    click: function(n) {
+      this.isEnabled("click") && !this._sprite.isDragging() && this._sprite._hasDown() && !this._sprite._hasMoved(this._makePointerEvent("click", n)) && this.dispatch("click", this._makePointerEvent("click", n));
+    },
+    rightclick: function(n) {
+      this.isEnabled("rightclick") && this.dispatch("rightclick", this._makePointerEvent("rightclick", n));
+    },
+    middleclick: function(n) {
+      this.isEnabled("middleclick") && this.dispatch("middleclick", this._makePointerEvent("middleclick", n));
+    },
+    dblclick: function(n) {
+      this.dispatchParents("dblclick", this._makePointerEvent("dblclick", n));
+    },
+    pointerover: function(n) {
+      const t = this._sprite;
+      let e = !0;
+      if (t.getPrivate("trustBounds")) {
+        t._getBounds();
+        const i = t.globalBounds();
+        if (t.isType("Graphics")) {
+          const s = t.get("strokeWidth", 1) / 2;
+          s >= 1 && (i.left -= s, i.right += s, i.top -= s, i.bottom += s);
+        }
+        Xt(n.point, i) || (e = !1, t._root._renderer.removeHovering(t._display));
+      }
+      e && this.isEnabled("pointerover") && this.dispatch("pointerover", this._makePointerEvent("pointerover", n));
+    },
+    pointerout: function(n) {
+      this.isEnabled("pointerout") && this.dispatch("pointerout", this._makePointerEvent("pointerout", n));
+    },
+    pointerdown: function(n) {
+      this.dispatchParents("pointerdown", this._makePointerEvent("pointerdown", n));
+    },
+    pointerup: function(n) {
+      this.isEnabled("pointerup") && this.dispatch("pointerup", this._makePointerEvent("pointerup", n));
+    },
+    globalpointerup: function(n) {
+      this.isEnabled("globalpointerup") && this.dispatch("globalpointerup", this._makePointerEvent("globalpointerup", n));
+    },
+    globalpointermove: function(n) {
+      this.isEnabled("globalpointermove") && this.dispatch("globalpointermove", this._makePointerEvent("globalpointermove", n));
+    },
+    wheel: function(n) {
+      this.dispatchParents("wheel", {
+        type: "wheel",
+        target: this._sprite,
+        originalEvent: n.event,
+        point: n.point
+      });
+    }
+  }
+});
+class O extends F {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_adjustedLocalBounds", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: { left: 0, right: 0, top: 0, bottom: 0 }
+    }), Object.defineProperty(this, "_localBounds", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: { left: 0, right: 0, top: 0, bottom: 0 }
+    }), Object.defineProperty(this, "_parent", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_dataItem", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_templateField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_sizeDirty", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_isDragging", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_dragEvent", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_dragPoint", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_isHidden", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_isShowing", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_isHiding", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_isDown", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_downPoint", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_downPoints", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_toggleDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_dragDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_tooltipDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_hoverDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_focusDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_tooltipMoveDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_tooltipPointerDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_virtualParent", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _afterNew() {
+    this.setPrivateRaw("visible", !0), super._afterNew();
+  }
+  /**
+   * Marks some setting as dirty. Could be used to trigger adapter.
+   * @param key
+   */
+  markDirtyKey(t) {
+    this._markDirtyKey(t);
+  }
+  _markDirtyKey(t) {
+    super._markDirtyKey(t), (t == "x" || t == "y" || t == "dx" || t == "dy") && (this.markDirtyBounds(), this._addPercentagePositionChildren(), this.markDirtyPosition());
+  }
+  _markDirtyPrivateKey(t) {
+    super._markDirtyPrivateKey(t), (t == "x" || t == "y") && this.markDirtyPosition();
+  }
+  _removeTemplateField() {
+    this._templateField && this._templateField._removeObjectTemplate(this);
+  }
+  _createEvents() {
+    return new st(this);
+  }
+  _processTemplateField() {
+    let t;
+    const e = this.get("templateField");
+    if (e) {
+      const i = this.dataItem;
+      if (i) {
+        const s = i.dataContext;
+        s && (t = s[e], !(t instanceof Z) && t && (t = Z.new(t)));
+      }
+    }
+    this._templateField !== t && (this._removeTemplateField(), this._templateField = t, t && t._setObjectTemplate(this), this._applyTemplates());
+  }
+  // TODO change this to run before the element is added to the parent, so that way
+  //      it doesn't need to apply the themes twice
+  _setDataItem(t) {
+    const e = this._dataItem;
+    this._dataItem = t, this._processTemplateField();
+    const i = "dataitemchanged";
+    t != e && this.events.isEnabled(i) && this.events.dispatch(i, {
+      type: i,
+      target: this,
+      oldDataItem: e,
+      newDataItem: t
+    });
+  }
+  /**
+   * A [[DataItem]] used for this element.
+   *
+   * NOTE: data item is being assigned automatically in most cases where it
+   * matters. Use this accessor to set data item only if you know what you're
+   * doing.
+   *
+   * @param  value  Data item
+   */
+  set dataItem(t) {
+    this._setDataItem(t);
+  }
+  /**
+   * @return DataItem
+   */
+  get dataItem() {
+    if (this._dataItem)
+      return this._dataItem;
+    {
+      let t = this._parent;
+      for (; t; ) {
+        if (t._dataItem)
+          return t._dataItem;
+        t = t._parent;
+      }
+    }
+  }
+  _addPercentageSizeChildren() {
+    let t = this.parent;
+    t && (this.get("width") instanceof D || this.get("height") instanceof D ? vt(t._percentageSizeChildren, this) : B(t._percentageSizeChildren, this));
+  }
+  _addPercentagePositionChildren() {
+    let t = this.parent;
+    t && (this.get("x") instanceof D || this.get("y") instanceof D ? vt(t._percentagePositionChildren, this) : B(t._percentagePositionChildren, this));
+  }
+  /**
+   * @ignore
+   */
+  markDirtyPosition() {
+    this._root._addDirtyPosition(this);
+  }
+  updatePivotPoint() {
+    const t = this._localBounds;
+    if (t) {
+      const e = this.get("centerX");
+      e != null && (this._display.pivot.x = t.left + L(e, t.right - t.left));
+      const i = this.get("centerY");
+      i != null && (this._display.pivot.y = t.top + L(i, t.bottom - t.top));
+    }
+  }
+  _beforeChanged() {
+    if (super._beforeChanged(), this._handleStates(), this.isDirty("tooltip")) {
+      const t = this._prevSettings.tooltip;
+      t && t.dispose();
+    }
+    if ((this.isDirty("layer") || this.isDirty("layerMargin")) && (this._display.setLayer(this.get("layer"), this.get("layerMargin")), this.markDirtyLayer()), this.isDirty("tooltipPosition")) {
+      const t = this._tooltipMoveDp;
+      t && (t.dispose(), this._tooltipMoveDp = void 0);
+      const e = this._tooltipPointerDp;
+      e && (e.dispose(), this._tooltipPointerDp = void 0), this.get("tooltipPosition") == "pointer" && (this.isHover() && (this._tooltipMoveDp = this.events.on("globalpointermove", (i) => {
+        this.showTooltip(i.point);
+      })), this._tooltipPointerDp = new C([
+        this.events.on("pointerover", () => {
+          this._tooltipMoveDp = this.events.on("globalpointermove", (i) => {
+            this.showTooltip(i.point);
+          });
+        }),
+        this.events.on("pointerout", () => {
+          const i = this._tooltipMoveDp;
+          i && (i.dispose(), this._tooltipMoveDp = void 0);
+        })
+      ]));
+    }
+  }
+  _handleStates() {
+    this.isDirty("active") && (this.get("active") ? (this.states.applyAnimate("active"), this.set("ariaChecked", !0)) : (this.isHidden() || this.states.applyAnimate("default"), this.set("ariaChecked", !1)), this.markDirtyAccessibility()), this.isDirty("disabled") && (this.get("disabled") ? (this.states.applyAnimate("disabled"), this.set("ariaChecked", !1)) : (this.isHidden() || this.states.applyAnimate("default"), this.set("ariaChecked", !0)), this.markDirtyAccessibility());
+  }
+  _changed() {
+    super._changed();
+    const t = this._display, e = this.events;
+    if (this.isDirty("draggable")) {
+      const s = this.get("draggable");
+      s ? (this.set("interactive", !0), this._dragDp = new C([
+        e.on("pointerdown", (r) => {
+          this.dragStart(r);
+        }),
+        e.on("globalpointermove", (r) => {
+          this.dragMove(r);
+        }),
+        e.on("globalpointerup", (r) => {
+          this.dragStop(r);
+        })
+      ])) : this._dragDp && (this._dragDp.dispose(), this._dragDp = void 0), t.cancelTouch = !!s;
+    }
+    if (this.isDirty("tooltipText") || this.isDirty("tooltipHTML") || this.isDirty("showTooltipOn")) {
+      const s = this.get("tooltipText"), r = this.get("tooltipHTML"), a = this.get("showTooltipOn", "hover");
+      this._tooltipDp && (this._tooltipDp.dispose(), this._tooltipDp = void 0), (s || r) && (a == "click" ? (this._tooltipDp = new C([
+        e.on("click", () => {
+          this.setTimeout(() => {
+            const o = this.getTooltip();
+            o && !o.isHidden() && o.get("tooltipTarget") === this ? this.hideTooltip() : this.showTooltip();
+          }, 10);
+        }),
+        q(document, "click", (o) => {
+          this.hideTooltip();
+        })
+      ]), this._disposers.push(this._tooltipDp)) : a == "always" || (this._tooltipDp = new C([
+        e.on("pointerover", () => {
+          this.showTooltip();
+        }),
+        e.on("pointerout", () => {
+          this.hideTooltip();
+        })
+      ]), this._disposers.push(this._tooltipDp)));
+    }
+    if (this.isDirty("toggleKey")) {
+      let s = this.get("toggleKey");
+      s && s != "none" ? this._toggleDp = e.on("click", () => {
+        this._isDragging || this.set(s, !this.get(s));
+      }) : this._toggleDp && (this._toggleDp.dispose(), this._toggleDp = void 0);
+    }
+    if (this.isDirty("opacity") && (t.alpha = Math.max(0, this.get("opacity", 1)), this.get("focusable") && this.markDirtyAccessibility()), this.isDirty("rotation") && (this.markDirtyBounds(), t.angle = this.get("rotation", 0)), this.isDirty("scale") && (this.markDirtyBounds(), t.scale = this.get("scale", 0)), (this.isDirty("centerX") || this.isDirty("centerY")) && (this.markDirtyBounds(), this.updatePivotPoint()), (this.isDirty("visible") || this.isPrivateDirty("visible") || this.isDirty("forceHidden")) && (!this.get("visible") || !this.getPrivate("visible") || this.get("forceHidden") ? (t.visible = !1, this.hideTooltip()) : t.visible = !0, this.markDirtyBounds(), this.get("focusable") && this.markDirtyAccessibility()), this.isDirty("width") || this.isDirty("height")) {
+      this.markDirtyBounds(), this._addPercentageSizeChildren();
+      const s = this.parent;
+      s && (this.isDirty("width") && this.get("width") instanceof D || this.isDirty("height") && this.get("height") instanceof D) && (s.markDirty(), s._prevWidth = 0), this._sizeDirty = !0;
+    }
+    if ((this.isDirty("maxWidth") || this.isDirty("maxHeight") || this.isPrivateDirty("width") || this.isPrivateDirty("height") || this.isDirty("minWidth") || this.isDirty("minHeight") || this.isPrivateDirty("maxWidth") || this.isPrivateDirty("maxHeight") || this.isPrivateDirty("minWidth") || this.isPrivateDirty("minHeight") || this.isDirty("marginLeft") || this.isDirty("marginTop") || this.isDirty("marginRight") || this.isDirty("marginBottom")) && (this.markDirtyBounds(), this._sizeDirty = !0), this._sizeDirty && this._updateSize(), this.isDirty("wheelable")) {
+      const s = this.get("wheelable");
+      s && this.set("interactive", !0), t.wheelable = !!s;
+    }
+    (this.isDirty("tabindexOrder") || this.isDirty("focusableGroup")) && (this.get("focusable") ? this._root._registerTabindexOrder(this) : this._root._unregisterTabindexOrder(this)), this.isDirty("filter") && (t.filter = this.get("filter"));
+    let i = this.get("filter", "");
+    if (this.isDirty("blur")) {
+      const s = this.get("blur", 0);
+      s != 0 && (i += " blur(" + s + "px)");
+    }
+    if (this.isDirty("saturate")) {
+      const s = this.get("saturate", 1);
+      s != 1 && (i += " saturate(" + s + ")");
+    }
+    if (this.isDirty("brightness")) {
+      const s = this.get("brightness", 1);
+      s != 1 && (i += " brightness(" + s + ")");
+    }
+    if (this.isDirty("contrast")) {
+      const s = this.get("contrast", 1);
+      s != 1 && (i += " contrast(" + s + ")");
+    }
+    if (this.isDirty("sepia")) {
+      const s = this.get("sepia", 0);
+      s != 0 && (i += " sepia(" + s + ")");
+    }
+    if (this.isDirty("hue")) {
+      const s = this.get("hue", 0);
+      s != 0 && (i += " hue-rotate(" + s + "deg)");
+    }
+    if (this.isDirty("invert")) {
+      const s = this.get("invert", 0);
+      s != 0 && (i += " invert(" + s + ")");
+    }
+    if (i && (t.filter = i), this.isDirty("cursorOverStyle") && (t.cursorOverStyle = this.get("cursorOverStyle")), this.isDirty("hoverOnFocus") && (this.get("hoverOnFocus") ? this._focusDp = new C([
+      e.on("focus", () => {
+        this.showTooltip();
+      }),
+      e.on("blur", () => {
+        this.hideTooltip();
+      })
+    ]) : this._focusDp && (this._focusDp.dispose(), this._focusDp = void 0)), this.isDirty("focusable") && (this.get("focusable") ? this._root._registerTabindexOrder(this) : this._root._unregisterTabindexOrder(this), this.markDirtyAccessibility(), this._disposers.push(e.on("blur", () => {
+      this.setPrivateRaw("touchHovering", !1);
+    })), this._disposers.push(e.once("boundschanged", () => {
+      this.markDirtyAccessibility();
+    }))), this.isPrivateDirty("focusable") && this.markDirtyAccessibility(), (this.isDirty("role") || this.isDirty("ariaLive") || this.isDirty("ariaChecked") || this.isDirty("ariaHidden") || this.isDirty("ariaOrientation") || this.isDirty("ariaValueNow") || this.isDirty("ariaValueMin") || this.isDirty("ariaValueMax") || this.isDirty("ariaValueText") || this.isDirty("ariaLabel") || this.isDirty("ariaControls")) && this.markDirtyAccessibility(), this.isDirty("exportable") && (t.exportable = this.get("exportable")), this.isDirty("interactive")) {
+      const s = this.events;
+      this.get("interactive") && !s.isDisposed() ? this._hoverDp = new C([
+        s.on("click", (r) => {
+          Dt(r.originalEvent) && (this.getPrivate("touchHovering") || this.setTimeout(() => {
+            this._handleOver(), (this.get("tooltipText") || this.get("tooltipHTML")) && this.showTooltip(), this.setPrivateRaw("touchHovering", !0), this.events.dispatch("pointerover", {
+              type: "pointerover",
+              target: r.target,
+              originalEvent: r.originalEvent,
+              point: r.point,
+              simulated: r.simulated
+            });
+          }, 10));
+        }),
+        s.on("globalpointerup", (r) => {
+          Dt(r.originalEvent) && this.getPrivate("touchHovering") && (this._handleOut(), (this.get("tooltipText") || this.get("tooltipHTML")) && this.hideTooltip(), this.setPrivateRaw("touchHovering", !1), this.events.dispatch("pointerout", {
+            type: "pointerout",
+            target: r.target,
+            originalEvent: r.originalEvent,
+            point: r.point,
+            simulated: r.simulated
+          })), this._isDown && this._handleUp(r);
+        }),
+        s.on("pointerover", () => {
+          this._handleOver();
+        }),
+        s.on("pointerout", () => {
+          this._handleOut();
+        }),
+        s.on("pointerdown", (r) => {
+          this._handleDown(r);
+        })
+      ]) : (this._display.interactive = !1, this._hoverDp && (this._hoverDp.dispose(), this._hoverDp = void 0));
+    }
+    this.isDirty("forceInactive") && (this._display.inactive = this.get("forceInactive", null)), this.get("showTooltipOn") == "always" && this._display.visible && this.showTooltip();
+  }
+  /**
+   * @ignore
+   * @todo should this be user-accessible?
+   */
+  dragStart(t) {
+    this._dragEvent = t, this.events.stopParentDispatch();
+  }
+  /**
+   * @ignore
+   * @todo should this be user-accessible?
+   */
+  dragStop(t) {
+    if (this._dragEvent = void 0, this._dragPoint = void 0, this.events.stopParentDispatch(), this._isDragging) {
+      this._isDragging = !1;
+      const e = "dragstop";
+      this.events.isEnabled(e) && this.events.dispatch(e, {
+        type: e,
+        target: this,
+        originalEvent: t.originalEvent,
+        point: t.point,
+        simulated: t.simulated
+      });
+    }
+  }
+  _handleOver() {
+    this.isHidden() || (this.get("active") && this.states.lookup("hoverActive") ? this.states.applyAnimate("hoverActive") : this.get("disabled") && this.states.lookup("hoverDisabled") ? this.states.applyAnimate("hoverDisabled") : this.states.applyAnimate("hover"), this.get("draggable") && this._isDown && this.states.lookup("down") && this.states.applyAnimate("down"));
+  }
+  _handleOut() {
+    this.isHidden() || (this.get("active") && this.states.lookup("active") ? this.states.applyAnimate("active") : this.get("disabled") && this.states.lookup("disabled") ? this.states.applyAnimate("disabled") : (this.states.lookup("hover") || this.states.lookup("hoverActive")) && this.states.applyAnimate("default"), this.get("draggable") && this._isDown && this.states.lookup("down") && this.states.applyAnimate("down"));
+  }
+  _handleUp(t) {
+    if (!this.isHidden()) {
+      this.get("active") && this.states.lookup("active") ? this.states.applyAnimate("active") : this.get("disabled") && this.states.lookup("disabled") ? this.states.applyAnimate("disabled") : this.states.lookup("down") && (this.isHover() ? this.states.applyAnimate("hover") : this.states.applyAnimate("default")), this._downPoint = void 0;
+      const e = at(t.originalEvent);
+      delete this._downPoints[e], lt(this._downPoints).length == 0 && (this._isDown = !1);
+    }
+  }
+  _hasMoved(t) {
+    const e = at(t.originalEvent), i = this._downPoints[e];
+    if (i) {
+      const s = Math.abs(i.x - t.point.x), r = Math.abs(i.y - t.point.y);
+      return s > 5 || r > 5;
+    }
+    return !1;
+  }
+  _hasDown() {
+    return lt(this._downPoints).length > 0;
+  }
+  _handleDown(t) {
+    const e = this.parent;
+    if (e && !this.get("draggable") && e._handleDown(t), this.get("interactive") && !this.isHidden()) {
+      this.states.lookup("down") && this.states.applyAnimate("down"), this._downPoint = {
+        x: t.point.x,
+        y: t.point.y
+      }, this._isDown = !0;
+      const i = at(t.originalEvent);
+      this._downPoints[i] = {
+        x: t.point.x,
+        y: t.point.y
+      };
+    }
+  }
+  /**
+   * @ignore
+   * @todo should this be user-accessible?
+   */
+  dragMove(t) {
+    let e = this._dragEvent;
+    if (e) {
+      if (e.simulated && !t.simulated)
+        return !0;
+      let i = 0, s = this.parent, r = 1;
+      for (; s != null; )
+        i += s.get("rotation", 0), s = s.parent, s && (r *= s.get("scale", 1));
+      let a = (t.point.x - e.point.x) / r, o = (t.point.y - e.point.y) / r;
+      const l = this.events;
+      if (e.simulated && !this._isDragging) {
+        this._isDragging = !0, this._dragEvent = t, this._dragPoint = {
+          x: this.x(),
+          y: this.y()
+        };
+        const h = "dragstart";
+        l.isEnabled(h) && l.dispatch(h, {
+          type: h,
+          target: this,
+          originalEvent: t.originalEvent,
+          point: t.point,
+          simulated: t.simulated
+        });
+      }
+      if (this._isDragging) {
+        let h = this._dragPoint;
+        this.set("x", h.x + a * dt(i) + o * ut(i)), this.set("y", h.y + o * dt(i) - a * ut(i));
+        const u = "dragged";
+        l.isEnabled(u) && l.dispatch(u, {
+          type: u,
+          target: this,
+          originalEvent: t.originalEvent,
+          point: t.point,
+          simulated: t.simulated
+        });
+      } else if (Math.hypot(a, o) > 5) {
+        this._isDragging = !0, this._dragEvent = t, this._dragPoint = {
+          x: this.x(),
+          y: this.y()
+        };
+        const h = "dragstart";
+        l.isEnabled(h) && l.dispatch(h, {
+          type: h,
+          target: this,
+          originalEvent: t.originalEvent,
+          point: t.point,
+          simulated: t.simulated
+        });
+      }
+    }
+  }
+  _updateSize() {
+  }
+  _getBounds() {
+    this._localBounds = this._display.getLocalBounds();
+  }
+  /**
+   * Returns depth (how deep in the hierachy of the content tree) of this
+   * element.
+   *
+   * @return Depth
+   */
+  depth() {
+    let t = this.parent, e = 0;
+    for (; ; )
+      if (t)
+        ++e, t = t.parent;
+      else
+        return e;
+  }
+  /**
+   * @ignore
+   */
+  markDirtySize() {
+    this._sizeDirty = !0, this.markDirty();
+  }
+  /**
+   * @ignore
+   */
+  markDirtyBounds() {
+    const t = this._display;
+    if (this.get("isMeasured")) {
+      this._root._addDirtyBounds(this), t.isMeasured = !0, t.invalidateBounds();
+      const e = this.parent;
+      e && this.get("position") != "absolute" && (e.get("width") == null || e.get("height") == null || e.get("layout")) && e.markDirtyBounds(), this.get("focusable") && this.markDirtyAccessibility();
+    }
+  }
+  /**
+   * @ignore
+   */
+  markDirtyAccessibility() {
+    this._root._invalidateAccessibility(this);
+  }
+  /**
+   * @ignore
+   */
+  markDirtyLayer() {
+    this._display.markDirtyLayer(!0);
+  }
+  /**
+   * @ignore
+   */
+  markDirty() {
+    super.markDirty(), this.markDirtyLayer();
+  }
+  _updateBounds() {
+    const t = this._adjustedLocalBounds;
+    let e;
+    if (!this.get("visible") || !this.getPrivate("visible") || this.get("forceHidden") ? (e = {
+      left: 0,
+      right: 0,
+      top: 0,
+      bottom: 0
+    }, this._localBounds = e, this._adjustedLocalBounds = e) : (this._getBounds(), this._fixMinBounds(this._localBounds), this.updatePivotPoint(), this._adjustedLocalBounds = this._display.getAdjustedBounds(this._localBounds), e = this._adjustedLocalBounds), !t || t.left !== e.left || t.top !== e.top || t.right !== e.right || t.bottom !== e.bottom) {
+      const i = "boundschanged";
+      this.events.isEnabled(i) && this.events.dispatch(i, { type: i, target: this }), this.parent && (this.parent.markDirty(), this.parent.markDirtyBounds()), this.getPrivate("showingTooltip") && this.showTooltip();
+    }
+  }
+  _fixMinBounds(t) {
+    let e = this.get("minWidth", this.getPrivate("minWidth")), i = this.get("minHeight", this.getPrivate("minHeight"));
+    m(e) && t.right - t.left < e && (t.right = t.left + e), m(i) && t.bottom - t.top < i && (t.bottom = t.top + i);
+    let s = this.getPrivate("width"), r = this.getPrivate("height");
+    m(s) && (s > 0 ? t.right = t.left + s : t.left = t.right + s), m(r) && (r > 0 ? t.bottom = t.top + r : t.top = t.bottom + r);
+  }
+  _removeParent(t) {
+    t && (t.children.removeValue(this), B(t._percentageSizeChildren, this), B(t._percentagePositionChildren, this));
+  }
+  _clearDirty() {
+    super._clearDirty(), this._sizeDirty = !1;
+  }
+  /**
+   * Simulate hover over element.
+   */
+  hover() {
+    this.isDisposed() || (this.showTooltip(), this._handleOver());
+  }
+  /**
+   * Simulate unhover over element.
+   */
+  unhover() {
+    this.isDisposed() || (this.hideTooltip(), this._handleOut());
+  }
+  /**
+   * Shows element's [[Tooltip]].
+   */
+  showTooltip(t) {
+    if (!this.isDisposed()) {
+      const e = this.getTooltip(), i = this.get("tooltipText"), s = this.get("tooltipHTML");
+      if ((i || s) && e) {
+        const r = this.get("tooltipPosition"), a = this.getPrivate("tooltipTarget", this);
+        if ((r == "fixed" || !t) && (this._display._setMatrix(), t = this.toGlobal(a._getTooltipPoint())), r == "pointer") {
+          const h = this.getPrivate("lastTooltipCoords");
+          if (h && h.x == t.x && h.y == t.y)
+            return;
+          this.setPrivate("lastTooltipCoords", t);
+        }
+        e.set("pointTo", t), e.set("tooltipTarget", a), e.get("x") || e.set("x", t.x), e.get("y") || e.set("y", t.y), i && e.label.set("text", i), s && e.label.set("html", s);
+        const o = this.dataItem;
+        if (o && e.label._setDataItem(o), this.get("showTooltipOn") == "always" && (t.x < 0 || t.x > this._root.width() || t.y < 0 || t.y > this._root.height())) {
+          this.hideTooltip();
+          return;
+        }
+        e.label.text.markDirtyText();
+        const l = e.show();
+        return this.setPrivateRaw("showingTooltip", !0), l;
+      }
+    }
+  }
+  /**
+   * Hides element's [[Tooltip]].
+   */
+  hideTooltip() {
+    const t = this.getTooltip();
+    if (t && (this.removePrivate("lastTooltipCoords"), t.get("tooltipTarget") == this.getPrivate("tooltipTarget", this) || this.get("tooltip") == t)) {
+      let e = t.get("keepTargetHover") && t.get("stateAnimationDuration", 0) == 0 ? 400 : void 0;
+      const i = t.hide(e);
+      return this.setPrivateRaw("showingTooltip", !1), i;
+    }
+  }
+  _getTooltipPoint() {
+    const t = this._localBounds;
+    if (t) {
+      let e = 0, i = 0;
+      return this.get("isMeasured") ? (e = t.left + L(this.get("tooltipX", 0), t.right - t.left), i = t.top + L(this.get("tooltipY", 0), t.bottom - t.top)) : (e = L(this.get("tooltipX", 0), this.width()), i = L(this.get("tooltipY", 0), this.height())), { x: e, y: i };
+    }
+    return { x: 0, y: 0 };
+  }
+  /**
+   * Returns [[Tooltip]] used for this element.
+   *
+   * @return Tooltip
+   */
+  getTooltip() {
+    let t = this.get("tooltip");
+    if (t)
+      return t;
+    {
+      let e = this.parent;
+      if (e)
+        return e.getTooltip();
+    }
+  }
+  _updatePosition() {
+    const t = this.parent;
+    let e = this.get("dx", 0), i = this.get("dy", 0), s = this.get("x"), r = this.getPrivate("x"), a = 0, o = 0;
+    const l = this.get("position");
+    s instanceof D && (t ? s = t.innerWidth() * s.value + t.get("paddingLeft", 0) : s = 0), m(s) ? a = s + e : r != null ? a = r : t && l == "relative" && (a = t.get("paddingLeft", 0) + e);
+    let h = this.get("y"), u = this.getPrivate("y");
+    h instanceof D && (t ? h = t.innerHeight() * h.value + t.get("paddingTop", 0) : h = 0), m(h) ? o = h + i : u != null ? o = u : t && l == "relative" && (o = t.get("paddingTop", 0) + i);
+    const f = this._display;
+    if (f.x != a || f.y != o) {
+      f.invalidateBounds(), f.x = a, f.y = o;
+      const d = "positionchanged";
+      this.events.isEnabled(d) && this.events.dispatch(d, { type: d, target: this });
+    }
+    this.getPrivate("showingTooltip") && this.showTooltip();
+  }
+  /**
+   * Returns element's actual X position in pixels.
+   *
+   * @return X (px)
+   */
+  x() {
+    let t = this.get("x"), e = this.getPrivate("x");
+    const i = this.parent;
+    return i ? t instanceof D ? L(t, i.innerWidth()) + i.get("paddingLeft", 0) : m(t) ? t : e ?? i.get("paddingLeft", this._display.x) : this._display.x;
+  }
+  /**
+   * Returns element's actual Y position in pixels.
+   *
+   * @return Y (px)
+   */
+  y() {
+    let t = this.getPrivate("y");
+    if (t != null)
+      return t;
+    let e = this.get("y");
+    const i = this.parent;
+    return i ? e instanceof D ? L(e, i.innerHeight()) + i.get("paddingTop", 0) : m(e) ? e : t ?? i.get("paddingTop", this._display.y) : this._display.y;
+  }
+  _dispose() {
+    super._dispose(), this._display.dispose(), this._removeTemplateField(), this._removeParent(this.parent), this._root._removeFocusElement(this);
+    const t = this.get("tooltip");
+    t && t.dispose(), this.markDirty();
+  }
+  /**
+   * @ignore
+   */
+  adjustedLocalBounds() {
+    return this._fixMinBounds(this._adjustedLocalBounds), this._adjustedLocalBounds;
+  }
+  /**
+   * Returns local coordinates of the element's bounds.
+   *
+   * @ignore
+   * @return Global bounds
+   */
+  localBounds() {
+    return this._localBounds;
+  }
+  /**
+   * Returns adjusted local coordinates of the element's bounds.
+   *
+   * @ignore
+   * @return Global bounds
+   */
+  bounds() {
+    const t = this._adjustedLocalBounds, e = this.x(), i = this.y();
+    return { left: t.left + e, right: t.right + e, top: t.top + i, bottom: t.bottom + i };
+  }
+  /**
+   * Returns global coordinates of the element's bounds.
+   *
+   * @ignore
+   * @return Global bounds
+   */
+  globalBounds() {
+    const t = this.localBounds(), e = this.toGlobal({ x: t.left, y: t.top }), i = this.toGlobal({ x: t.right, y: t.top }), s = this.toGlobal({ x: t.right, y: t.bottom }), r = this.toGlobal({ x: t.left, y: t.bottom });
+    return {
+      left: Math.min(e.x, i.x, s.x, r.x),
+      top: Math.min(e.y, i.y, s.y, r.y),
+      right: Math.max(e.x, i.x, s.x, r.x),
+      bottom: Math.max(e.y, i.y, s.y, r.y)
+    };
+  }
+  _onShow(t) {
+  }
+  _onHide(t) {
+  }
+  /**
+   * Plays initial reveal animation regardless if element is currently hidden
+   * or visible.
+   *
+   * @param   duration  Duration of the animation in milliseconds
+   * @param   delay     Delay showing of the element by X milliseconds
+   * @return            Promise
+   */
+  appear(t, e) {
+    return nt(this, void 0, void 0, function* () {
+      return yield this.hide(0), e ? new Promise((i, s) => {
+        this.setTimeout(() => {
+          i(this.show(t));
+        }, e);
+      }) : this.show(t);
+    });
+  }
+  /**
+   * Shows currently hidden element and returns a `Promise` which completes
+   * when all showing animations are finished.
+   *
+   * ```TypeScript
+   * series.show().then(function(ev) {
+   *   console.log("Series is now fully visible");
+   * })
+   * ```
+   * ```JavaScript
+   * series.show().then(function(ev) {
+   *   console.log("Series is now fully visible");
+   * })
+   * ```
+   *
+   * @return Promise
+   */
+  show(t) {
+    return nt(this, void 0, void 0, function* () {
+      if (!this._isShowing) {
+        this._isHidden = !1, this._isShowing = !0, this._isHiding = !1, this.states.lookup("default").get("visible") && this.set("visible", !0), this._onShow(t);
+        const e = this.states.applyAnimate("default", t);
+        yield wt(e), this._isShowing = !1;
+      }
+    });
+  }
+  /**
+   * Hides the element and returns a `Promise` which completes when all hiding
+   * animations are finished.
+   *
+   * ```TypeScript
+   * series.hide().then(function(ev) {
+   *   console.log("Series finished hiding");
+   * })
+   * ```
+   * ```JavaScript
+   * series.hide().then(function(ev) {
+   *   console.log("Series finished hiding");
+   * })
+   * ```
+   *
+   * @return Promise
+   */
+  hide(t) {
+    return nt(this, void 0, void 0, function* () {
+      if (!this._isHiding && !this._isHidden) {
+        this._isHiding = !0, this._isShowing = !1;
+        let e = this.states.lookup("hidden");
+        e || (e = this.states.create("hidden", {
+          opacity: 0,
+          visible: !1
+        })), this._isHidden = !0, this._onHide(t);
+        const i = this.states.applyAnimate("hidden", t);
+        yield wt(i), this._isHiding = !1;
+      }
+    });
+  }
+  /**
+   * Returns `true` if this element is currently hidden.
+   *
+   * @return Is hidden?
+   */
+  isHidden() {
+    return this._isHidden;
+  }
+  /**
+   * Returns `true` if this element is currently animating to a default state.
+   *
+   * @return Is showing?
+   */
+  isShowing() {
+    return this._isShowing;
+  }
+  /**
+   * Returns `true` if this element is currently animating to a hidden state.
+   *
+   * @return Is hiding?
+   */
+  isHiding() {
+    return this._isHiding;
+  }
+  /**
+   * Returns `true` if this element is currently hovered by a pointer.
+   *
+   * @return Is hovered?
+   */
+  isHover() {
+    return this._display.hovering();
+  }
+  /**
+   * Returns `true` if this element does currently have focus.
+   *
+   * @return Is focused?
+   */
+  isFocus() {
+    return this._root.focused(this);
+  }
+  /**
+   * Returns `true` if this element is currently being dragged.
+   *
+   * @return Is dragged?
+   */
+  isDragging() {
+    return this._isDragging;
+  }
+  /**
+   * Returns `false` if if either public or private setting `visible` is set
+   * to `false`, or `forceHidden` is set to `true`.
+   *
+   * @return Visible?
+   */
+  isVisible() {
+    return !!(this.get("visible") && this.getPrivate("visible") && !this.get("forceHidden"));
+  }
+  /**
+   * Same as `isVisible()`, except it checks all ascendants, too.
+   *
+   * @since 5.2.7
+   * @return Visible?
+   */
+  isVisibleDeep() {
+    return this._parent ? this._parent.isVisibleDeep() && this.isVisible() : this.isVisible();
+  }
+  /**
+   * Returns an actual opacity of the element, taking into account all parents.
+   *
+   * @return Opacity
+   * @since 5.2.11
+   */
+  compositeOpacity() {
+    const t = this.get("opacity", 1);
+    return this._parent ? this._parent.compositeOpacity() * t : t;
+  }
+  /**
+   * Returns an actual scale of the element, taking into account all parents.
+   *
+   * @return Opacity
+   * @since 5.9.2
+   */
+  compositeScale() {
+    const t = this.get("scale", 1);
+    return this._parent ? this._parent.compositeScale() * t : t;
+  }
+  /**
+   * Returns an actual roation of the element, taking into account all parents.
+   *
+   * @return Opacity
+   * @since 5.9.2
+   */
+  compositeRotation() {
+    const t = this.get("rotation", 0);
+    return this._parent ? this._parent.compositeRotation() + t : t;
+  }
+  /**
+   * Returns width of this element in pixels.
+   *
+   * @return Width (px)
+   */
+  width() {
+    let t = this.get("width"), e = this.get("maxWidth", this.getPrivate("maxWidth")), i = this.get("minWidth", this.getPrivate("minWidth")), s = this.getPrivate("width"), r = 0;
+    if (m(s))
+      r = s;
+    else if (t == null)
+      this._adjustedLocalBounds && (r = this._adjustedLocalBounds.right - this._adjustedLocalBounds.left);
+    else if (t instanceof D) {
+      const a = this.parent;
+      a ? r = a.innerWidth() * t.value : r = this._root.width() * t.value;
+    } else m(t) && (r = t);
+    return m(i) && (r = Math.max(i, r)), m(e) && (r = Math.min(e, r)), r;
+  }
+  /**
+   * Returns maximum allowed width of this element in pixels.
+   *
+   * @return Maximum width (px)
+   */
+  maxWidth() {
+    let t = this.get("maxWidth", this.getPrivate("maxWidth"));
+    if (m(t))
+      return t;
+    {
+      let i = this.get("width");
+      if (m(i))
+        return i;
+    }
+    const e = this.parent;
+    return e ? e.innerWidth() : this._root.width();
+  }
+  /**
+   * Returns maximum allowed height of this element in pixels.
+   *
+   * @return Maximum height (px)
+   */
+  maxHeight() {
+    let t = this.get("maxHeight", this.getPrivate("maxHeight"));
+    if (m(t))
+      return t;
+    {
+      let i = this.get("height");
+      if (m(i))
+        return i;
+    }
+    const e = this.parent;
+    return e ? e.innerHeight() : this._root.height();
+  }
+  /**
+   * Returns height of this element in pixels.
+   *
+   * @return Height (px)
+   */
+  height() {
+    let t = this.get("height"), e = this.get("maxHeight", this.getPrivate("maxHeight")), i = this.get("minHeight", this.getPrivate("minHeight")), s = this.getPrivate("height"), r = 0;
+    if (m(s))
+      r = s;
+    else if (t == null)
+      this._adjustedLocalBounds && (r = this._adjustedLocalBounds.bottom - this._adjustedLocalBounds.top);
+    else if (t instanceof D) {
+      const a = this.parent;
+      a ? r = a.innerHeight() * t.value : r = this._root.height() * t.value;
+    } else m(t) && (r = t);
+    return m(i) && (r = Math.max(i, r)), m(e) && (r = Math.min(e, r)), r;
+  }
+  _findStaticTemplate(t) {
+    return this._templateField && t(this._templateField) ? this._templateField : super._findStaticTemplate(t);
+  }
+  _walkParents(t) {
+    (this._parent || this._virtualParent) && this._walkParent(t);
+  }
+  _walkParent(t) {
+    this._parent ? this._parent._walkParent(t) : this._virtualParent && this._virtualParent._walkParent(t), t(this);
+  }
+  set virtualParent(t) {
+    this._virtualParent = t, this._applyThemes();
+  }
+  /**
+   * Parent [[Container]] of this element.
+   *
+   * @return Parent container
+   */
+  get parent() {
+    return this._parent;
+  }
+  _setParent(t, e = !1) {
+    const i = this._parent;
+    t !== i && (this.markDirtyBounds(), t.markDirty(), this._parent = t, e && (this._removeParent(i), t && (this._addPercentageSizeChildren(), this._addPercentagePositionChildren())), this.markDirtyPosition(), this._applyThemes());
+  }
+  /**
+   * Returns an instance of [[NumberFormatter]] used in this element.
+   *
+   * If this element does not have it set, global one form [[Root]] is used.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/using-formatters/} for more info
+   * @return NumberFormatter instace
+   */
+  getNumberFormatter() {
+    return this.get("numberFormatter", this._root.numberFormatter);
+  }
+  /**
+   * Returns an instance of [[DateFormatter]] used in this element.
+   *
+   * If this element does not have it set, global one form [[Root]] is used.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/using-formatters/} for more info
+   * @return DateFormatter instace
+   */
+  getDateFormatter() {
+    return this.get("dateFormatter", this._root.dateFormatter);
+  }
+  /**
+   * Returns an instance of [[DurationFormatter]] used in this element.
+   *
+   * If this element does not have it set, global one form [[Root]] is used.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/concepts/using-formatters/} for more info
+   * @return DurationFormatter instace
+   */
+  getDurationFormatter() {
+    return this.get("durationFormatter", this._root.durationFormatter);
+  }
+  /**
+   * Converts X/Y coordinate within this element to a global coordinate.
+   *
+   * @param  point  Local coordinate
+   * @return        Global coordinate
+   */
+  toGlobal(t) {
+    return this._display.toGlobal(t);
+  }
+  /**
+   * Converts global X/Y coordinate to a coordinate within this element.
+   *
+   * @param  point  Global coordinate
+   * @return        Local coordinate
+   */
+  toLocal(t) {
+    return this._display.toLocal(t);
+  }
+  _getDownPoint() {
+    const t = this._getDownPointId();
+    if (t)
+      return this._downPoints[t];
+  }
+  _getDownPointId() {
+    if (this._downPoints)
+      return Lt(this._downPoints, (t, e) => t > e ? 1 : t < e ? -1 : 0)[0];
+  }
+  /**
+   * Moves sprite to the end of the parent's children array.
+   *
+   * Depending on `layout` setting of the parten container, it may effect the
+   * positioning or overlapping order of the elements.
+   */
+  toFront() {
+    const t = this.parent;
+    t && t.children.moveValue(this, t.children.length - 1);
+  }
+  /**
+   * Moves sprite to the beginning of the parent's children array.
+   *
+   * Depending on `layout` setting of the parten container, it may effect the
+   * positioning or overlapping order of the elements.
+   */
+  toBack() {
+    const t = this.parent;
+    t && t.children.moveValue(this, 0);
+  }
+}
+Object.defineProperty(O, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Sprite"
+});
+Object.defineProperty(O, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: F.classNames.concat([O.className])
+});
+class X extends F {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_display", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._root._renderer.makeGraphics()
+    }), Object.defineProperty(this, "_backgroundDisplay", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._root._renderer.makeGraphics()
+    }), Object.defineProperty(this, "_clear", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_pattern", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _afterNew() {
+    super._afterNewApplyThemes();
+  }
+  get pattern() {
+    return this._pattern;
+  }
+  _draw() {
+  }
+  _beforeChanged() {
+    super._beforeChanged(), (this.isDirty("repetition") || this.isDirty("width") || this.isDirty("height") || this.isDirty("rotation") || this.isDirty("strokeWidth") || this.isDirty("strokeDasharray") || this.isDirty("strokeDashoffset") || this.isDirty("colorOpacity") || this.isDirty("fillOpacity")) && (this._clear = !0), this._checkDirtyFill();
+  }
+  _checkDirtyFill() {
+    (this.isDirty("color") || this.isDirty("fill")) && (this._clear = !0);
+  }
+  _changed() {
+    if (super._changed(), this._clear) {
+      const t = this.get("repetition", ""), e = this.get("width", 100), i = this.get("height", 100), s = this.get("fill"), r = this.get("fillOpacity", 1), a = this._backgroundDisplay, o = this._display;
+      o.clear(), a.clear(), s && r > 0 && (a.beginFill(s, r), a.drawRect(0, 0, e, i), a.endFill()), o.angle = this.get("rotation", 0), this._draw(), this._pattern = this._root._renderer.createPattern(o, a, t, e, i);
+    }
+    this._clear = !1;
+  }
+}
+Object.defineProperty(X, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Pattern"
+});
+Object.defineProperty(X, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: F.classNames.concat([X.className])
+});
+class Y extends X {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_image", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _beforeChanged() {
+    super._beforeChanged(), this._clear = !0, this.isDirty("src") && this._load();
+    const t = this.get("canvas");
+    t && (this.set("width", t.width), this.set("height", t.height));
+  }
+  _draw() {
+    super._draw();
+    const t = this.get("colorOpacity");
+    t !== void 0 && (this._display.alpha = Math.max(0, t));
+    const e = this._image;
+    if (e) {
+      const s = this.get("width", 100), r = this.get("height", 100), a = this.get("fit", "image");
+      let o = 0, l = 0;
+      a == "pattern" ? (o = s, l = r, this.markDirty()) : (o = e.width, l = e.height, a == "image" && (this.set("width", o), this.set("height", l)));
+      const h = this.get("centered", !0);
+      let u = 0, f = 0;
+      h && (u = s / 2 - o / 2, f = r / 2 - l / 2), this._display.image(e, o, l, u, f);
+    }
+    const i = this.get("canvas");
+    i && this._display.image(i, i.width, i.height, 0, 0);
+  }
+  _load() {
+    const t = this.get("src");
+    if (t) {
+      const e = new Image();
+      e.src = t, e.decode().then(() => {
+        this._image = e, this._draw(), this.events.isEnabled("loaded") && this.events.dispatch("loaded", { type: "loaded", target: this });
+      }).catch((i) => {
+      });
+    }
+  }
+}
+Object.defineProperty(Y, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "PicturePattern"
+});
+Object.defineProperty(Y, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: X.classNames.concat([Y.className])
+});
+var ft;
+(function(n) {
+  n.ADD = "lighter", n.COLOR = "color", n.COLOR_BURN = "color-burn", n.COLOR_DODGE = "color-dodge", n.DARKEN = "darken", n.DIFFERENCE = "difference", n.DST_OVER = "destination-over", n.EXCLUSION = "exclusion", n.HARD_LIGHT = "hard-light", n.HUE = "hue", n.LIGHTEN = "lighten", n.LUMINOSITY = "luminosity", n.MULTIPLY = "multiply", n.NORMAL = "source-over", n.OVERLAY = "overlay", n.SATURATION = "saturation", n.SCREEN = "screen", n.SOFT_LIGHT = "soft-light", n.SRC_ATOP = "source-atop", n.XOR = "xor";
+})(ft || (ft = {}));
+const re = ["fill", "fillOpacity", "stroke", "strokeWidth", "strokeOpacity", "fillPattern", "strokePattern", "fillGradient", "strokeGradient", "strokeDasharray", "strokeDashoffset", "shadowBlur", "shadowColor", "shadowOpacity", "shadowOffsetX", "shadowOffsetY", "blur", "sepia", "invert", "brightness", "hue", "contrast", "saturate"];
+class W extends O {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_display", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._root._renderer.makeGraphics()
+    }), Object.defineProperty(this, "_clear", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    });
+  }
+  _beforeChanged() {
+    if (super._beforeChanged(), (this.isDirty("draw") || this.isDirty("svgPath")) && this.markDirtyBounds(), (this.isDirty("fill") || this.isDirty("stroke") || this.isDirty("visible") || this.isDirty("forceHidden") || this.isDirty("scale") || this.isDirty("fillGradient") || this.isDirty("strokeGradient") || this.isDirty("fillPattern") || this.isDirty("strokePattern") || this.isDirty("fillOpacity") || this.isDirty("strokeOpacity") || this.isDirty("strokeWidth") || this.isDirty("draw") || this.isDirty("blendMode") || this.isDirty("strokeDasharray") || this.isDirty("strokeDashoffset") || this.isDirty("svgPath") || this.isDirty("lineJoin") || this.isDirty("lineCap") || this.isDirty("shadowColor") || this.isDirty("shadowBlur") || this.isDirty("shadowOffsetX") || this.isDirty("shadowOffsetY")) && (this._clear = !0), this._display.crisp = this.get("crisp", !1), this.isDirty("fillGradient")) {
+      const t = this.get("fillGradient");
+      if (t) {
+        this._display.isMeasured = !0;
+        const e = t.get("target");
+        e && (this._disposers.push(e.events.on("boundschanged", () => {
+          this._markDirtyKey("fill");
+        })), this._disposers.push(e.events.on("positionchanged", () => {
+          this._markDirtyKey("fill");
+        })));
+      }
+    }
+    if (this.isDirty("strokeGradient")) {
+      const t = this.get("strokeGradient");
+      if (t) {
+        this._display.isMeasured = !0;
+        const e = t.get("target");
+        e && (this._disposers.push(e.events.on("boundschanged", () => {
+          this._markDirtyKey("stroke");
+        })), this._disposers.push(e.events.on("positionchanged", () => {
+          this._markDirtyKey("stroke");
+        })));
+      }
+    }
+  }
+  _changed() {
+    if (super._changed(), this._clear) {
+      this.markDirtyBounds(), this.markDirtyLayer(), this._display.clear();
+      let t = this.get("strokeDasharray");
+      m(t) && (t < 0.5 ? t = [0] : t = [t]), this._display.setLineDash(t);
+      const e = this.get("strokeDashoffset");
+      e && this._display.setLineDashOffset(e);
+      const i = this.get("blendMode", ft.NORMAL);
+      this._display.blendMode = i;
+      const s = this.get("draw");
+      s && typeof s == "function" && s(this._display, this);
+      const r = this.get("svgPath");
+      r != null && this._display.svgPath(r);
+    }
+  }
+  _afterChanged() {
+    if (super._afterChanged(), this._clear) {
+      const t = this.get("fill"), e = this.get("fillGradient"), i = this.get("fillPattern"), s = this.get("fillOpacity"), r = this.get("stroke"), a = this.get("strokeGradient"), o = this.get("strokePattern"), l = this.get("shadowColor"), h = this.get("shadowBlur"), u = this.get("shadowOffsetX"), f = this.get("shadowOffsetY"), d = this.get("shadowOpacity");
+      if (l && (h || u || f) && this._display.shadow(l, h, u, f, d), t && !e && (this._display.beginFill(t, s), this._display.endFill()), e) {
+        if (t) {
+          const g = e.get("stops", []);
+          g.length && w(g, (_) => {
+            (!_.color || _.colorInherited) && t && (_.color = t, _.colorInherited = !0), (_.opacity == null || _.opacityInherited) && (_.opacity = s, _.opacityInherited = !0);
+          });
+        }
+        const p = e.getFill(this);
+        p && (this._display.beginFill(p, s), this._display.endFill());
+      }
+      if (i) {
+        const p = i.pattern;
+        p && (this._display.beginFill(p, s), this._display.endFill(), i instanceof Y && i.events.once("loaded", () => {
+          this._clear = !0, this.markDirty();
+        }));
+      }
+      if (r || a || o) {
+        const p = this.get("strokeOpacity");
+        let g = this.get("strokeWidth", 1);
+        this.get("nonScalingStroke") && (g = g / this.get("scale", 1)), this.get("crisp") && (g /= this._root._renderer.resolution);
+        const _ = this.get("lineJoin"), v = this.get("lineCap");
+        if (r && !a && (this._display.lineStyle(g, r, p, _, v), this._display.endStroke()), a) {
+          const c = a.get("stops", []);
+          c.length && w(c, (y) => {
+            (!y.color || y.colorInherited) && r && (y.color = r, y.colorInherited = !0), (y.opacity == null || y.opacityInherited) && (y.opacity = p, y.opacityInherited = !0);
+          });
+          const b = a.getFill(this);
+          b && (this._display.lineStyle(g, b, p, _, v), this._display.endStroke());
+        }
+        if (o) {
+          let c = o.pattern;
+          c && (this._display.lineStyle(g, c, p, _, v), this._display.endStroke(), o instanceof Y && o.events.once("loaded", () => {
+            this._clear = !0, this.markDirty();
+          }));
+        }
+      }
+      this.getPrivate("showingTooltip") && this.showTooltip();
+    }
+    this._clear = !1;
+  }
+}
+Object.defineProperty(W, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Graphics"
+});
+Object.defineProperty(W, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: O.classNames.concat([W.className])
+});
+class U extends W {
+  _afterNew() {
+    super._afterNew(), this._display.isMeasured = !0, this.setPrivateRaw("trustBounds", !0);
+  }
+  _beforeChanged() {
+    super._beforeChanged(), (this.isDirty("width") || this.isDirty("height") || this.isPrivateDirty("width") || this.isPrivateDirty("height")) && (this._clear = !0);
+  }
+  _changed() {
+    super._changed(), this._clear && !this.get("draw") && this._draw();
+  }
+  _draw() {
+    let t = this.width(), e = this.height(), i = 0, s = 0, r = t / Math.abs(t), a = e / Math.abs(e);
+    if (this.get("containStroke", !1)) {
+      const o = this.get("strokeWidth", 0);
+      t -= o * r, e -= o * a, i += o / 2 * r, s += o / 2 * a;
+    }
+    this._display.drawRect(i, s, t, e);
+  }
+  _updateSize() {
+    this.markDirty(), this._clear = !0;
+  }
+}
+Object.defineProperty(U, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Rectangle"
+});
+Object.defineProperty(U, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: W.classNames.concat([U.className])
+});
+function j(n, t) {
+  n.get("reverseChildren", !1) ? n.children.eachReverse(t) : n.children.each(t);
+}
+class E extends F {
+}
+Object.defineProperty(E, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Layout"
+});
+Object.defineProperty(E, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: F.classNames.concat([E.className])
+});
+class K extends E {
+  /**
+   * @ignore
+   */
+  updateContainer(t) {
+    let e = t.get("paddingLeft", 0), i = t.innerWidth(), s = 0;
+    j(t, (a) => {
+      if (a.isVisible() && a.get("position") == "relative") {
+        let o = a.get("width");
+        if (o instanceof D) {
+          s += o.value;
+          let l = i * o.value, h = a.get("minWidth", a.getPrivate("minWidth", -1 / 0));
+          h > l && (i -= h, s -= o.value);
+          let u = a.get("maxWidth", a.getPrivate("maxWidth", 1 / 0));
+          l > u && (i -= u, s -= o.value);
+        } else
+          m(o) || (o = a.width()), i -= o + a.get("marginLeft", 0) + a.get("marginRight", 0);
+      }
+    }), (i <= 0 || i == 1 / 0) && (i = 0.1), j(t, (a) => {
+      if (a.isVisible() && a.get("position") == "relative") {
+        let o = a.get("width");
+        if (o instanceof D) {
+          let l = i * o.value / s - a.get("marginLeft", 0) - a.get("marginRight", 0), h = a.get("minWidth", a.getPrivate("minWidth", -1 / 0)), u = a.get("maxWidth", a.getPrivate("maxWidth", 1 / 0));
+          l = Math.min(Math.max(h, l), u), a.setPrivate("width", l);
+        } else
+          a._prevSettings.width instanceof D && a.setPrivate("width", void 0);
+      }
+    });
+    let r = e;
+    j(t, (a) => {
+      if (a.get("position") == "relative")
+        if (a.isVisible()) {
+          let o = a.adjustedLocalBounds(), l = a.get("marginLeft", 0), h = a.get("marginRight", 0), u = a.get("maxWidth"), f = o.left, d = o.right;
+          u && d - f > u && (d = f + u);
+          let p = r + l - f;
+          a.setPrivate("x", p), r = p + d + h;
+        } else
+          a.setPrivate("x", void 0);
+    });
+  }
+}
+Object.defineProperty(K, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "HorizontalLayout"
+});
+Object.defineProperty(K, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: E.classNames.concat([K.className])
+});
+class $ extends E {
+  /**
+   * @ignore
+   */
+  updateContainer(t) {
+    let e = t.get("paddingTop", 0), i = t.innerHeight(), s = 0;
+    j(t, (a) => {
+      if (a.isVisible() && a.get("position") == "relative") {
+        let o = a.get("height");
+        if (o instanceof D) {
+          s += o.value;
+          let l = i * o.value, h = a.get("minHeight", a.getPrivate("minHeight", -1 / 0));
+          h > l && (i -= h, s -= o.value);
+          let u = a.get("maxHeight", a.getPrivate("maxHeight", 1 / 0));
+          l > u && (i -= u, s -= o.value);
+        } else
+          m(o) || (o = a.height()), i -= o + a.get("marginTop", 0) + a.get("marginBottom", 0);
+      }
+    }), (i <= 0 || i == 1 / 0) && (i = 0.1), j(t, (a) => {
+      if (a.isVisible() && a.get("position") == "relative") {
+        let o = a.get("height");
+        if (o instanceof D) {
+          let l = i * o.value / s - a.get("marginTop", 0) - a.get("marginBottom", 0), h = a.get("minHeight", a.getPrivate("minHeight", -1 / 0)), u = a.get("maxHeight", a.getPrivate("maxHeight", 1 / 0));
+          l = Math.min(Math.max(h, l), u), a.setPrivate("height", l);
+        } else
+          a._prevSettings.height instanceof D && a.setPrivate("height", void 0);
+      }
+    });
+    let r = e;
+    j(t, (a) => {
+      if (a.get("position") == "relative")
+        if (a.isVisible()) {
+          let o = a.adjustedLocalBounds(), l = a.get("marginTop", 0), h = o.top, u = o.bottom, f = a.get("maxHeight");
+          f && u - h > f && (u = h + f);
+          let d = a.get("marginBottom", 0), p = r + l - h;
+          a.setPrivate("y", p), r = p + u + d;
+        } else
+          a.setPrivate("y", void 0);
+    });
+  }
+}
+Object.defineProperty($, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "VerticalLayout"
+});
+Object.defineProperty($, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: E.classNames.concat([$.className])
+});
+class J extends E {
+  _afterNew() {
+    this._setRawDefault("maxColumns", Number.MAX_VALUE), super._afterNew();
+  }
+  /**
+   * @ignore
+   */
+  updateContainer(t) {
+    let e = t.get("paddingLeft", 0), i = t.get("paddingRight", 0), s = t.get("paddingTop", 0), r = t.maxWidth() - e - i, a = r, o = 1;
+    j(t, (g) => {
+      if (g.get("visible") && g.getPrivate("visible") && !g.get("forceHidden") && g.get("position") != "absolute") {
+        let _ = g.width();
+        _ < a && (a = _), _ > o && (o = _);
+      }
+    }), a = T(a, 1, r), o = T(o, 1, r);
+    let l = 1;
+    this.get("fixedWidthGrid") ? l = r / o : l = r / a, l = Math.max(1, Math.floor(l)), l = Math.min(this.get("maxColumns", Number.MAX_VALUE), l);
+    let h = this.getColumnWidths(t, l, o, r), u = s, f = 0, d = 0;
+    l = h.length;
+    let p = e;
+    j(t, (g) => {
+      if (g.get("position") == "relative" && g.isVisible()) {
+        const _ = g.get("marginTop", 0), v = g.get("marginBottom", 0);
+        let c = g.adjustedLocalBounds(), b = g.get("marginLeft", 0), y = g.get("marginRight", 0), x = p + b - c.left, k = u + _ - c.top;
+        g.setPrivate("x", x), g.setPrivate("y", k), p += h[f] + y, d = Math.max(d, g.height() + _ + v), f++, f >= l && (f = 0, p = e, u += d, d = 0);
+      }
+    });
+  }
+  /**
+   * @ignore
+   */
+  getColumnWidths(t, e, i, s) {
+    let r = 0, a = [], o = 0;
+    return j(t, (l) => {
+      let h = l.adjustedLocalBounds();
+      l.get("position") != "absolute" && l.isVisible() && (this.get("fixedWidthGrid") ? a[o] = i : a[o] = Math.max(a[o] | 0, h.right - h.left + l.get("marginLeft", 0) + l.get("marginRight", 0)), o < t.children.length - 1 && (o++, o == e && (o = 0)));
+    }), w(a, (l) => {
+      r += l;
+    }), r > s ? e > 2 ? (e -= 1, this.getColumnWidths(t, e, i, s)) : [s] : a;
+  }
+}
+Object.defineProperty(J, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "GridLayout"
+});
+Object.defineProperty(J, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: E.classNames.concat([J.className])
+});
+class ct {
+  /**
+   * Replaces brackets with temporary placeholders.
+   *
+   * @ignore Exclude from docs
+   * @param text  Input text
+   * @return Escaped text
+   */
+  static escape(t) {
+    return t.replace(/\[\[/g, this.prefix + "1").replace(/([^\/\]]{1})\]\]/g, "$1" + this.prefix + "2").replace(/\]\]/g, this.prefix + "2").replace(/\{\{/g, this.prefix + "3").replace(/\}\}/g, this.prefix + "4").replace(/\'\'/g, this.prefix + "5");
+  }
+  /**
+   * Replaces placeholders back to brackets.
+   *
+   * @ignore Exclude from docs
+   * @param text  Escaped text
+   * @return Unescaped text
+   */
+  static unescape(t) {
+    return t.replace(new RegExp(this.prefix + "1", "g"), "[[").replace(new RegExp(this.prefix + "2", "g"), "]]").replace(new RegExp(this.prefix + "3", "g"), "{{").replace(new RegExp(this.prefix + "4", "g"), "}}").replace(new RegExp(this.prefix + "5", "g"), "''");
+  }
+  /**
+   * Cleans up the text text for leftover double square brackets.
+   *
+   * @ignore Exclude from docs
+   * @param text  Input text
+   * @return Cleaned up text
+   */
+  static cleanUp(t) {
+    return t.replace(/\[\[/g, "[").replace(/\]\]/g, "]").replace(/\{\{/g, "{").replace(/\}\}/g, "}").replace(/\'\'/g, "'");
+  }
+  /**
+   * Splits string into chunks. (style blocks, quoted blocks, regular blocks)
+   *
+   * If the second parameter `quotedBlocks` is set to `true` this method will
+   * also single out text blocks enclosed within single quotes that no
+   * formatting should be applied to, and they should be displayed as is.
+   *
+   * Default for the above is `false`, so that you can use single quote in text
+   * without escaping it.
+   *
+   * If enabled, single quotes can be escaped by doubling it - adding two
+   * single quotes, which will be replaced by a one single quote in the final
+   * output.
+   *
+   * @ignore Exclude from docs
+   * @param text          Text to chunk
+   * @param quotedBlocks  Use quoted blocks
+   * @param noFormatting  Formatting blocks will be treated as regular text
+   * @return Array of string chunks
+   */
+  static chunk(t, e = !1, i = !1) {
+    let s = [];
+    t = this.escape(t);
+    let r = e ? t.split("'") : [t];
+    for (let a = 0; a < r.length; a++) {
+      let o = r[a];
+      if (o !== "")
+        if (a % 2 === 0) {
+          o = o.replace(/\]\[/g, "]" + xt + "["), o = o.replace(/\[\]/g, "[ ]");
+          let l = o.split(/[\[\]]+/);
+          for (let h = 0; h < l.length; h++) {
+            let u = this.cleanUp(this.unescape(l[h]));
+            u !== xt && u !== "" && (h % 2 === 0 ? s.push({
+              type: "value",
+              text: u
+            }) : s.push({
+              type: i ? "value" : "format",
+              text: "[" + u + "]"
+            }));
+          }
+        } else {
+          let l = o.split(/[\[\]]+/);
+          for (let h = 0; h < l.length; h++) {
+            let u = this.cleanUp(this.unescape(l[h]));
+            u !== "" && (h % 2 === 0 ? s.push({
+              type: "text",
+              text: u
+            }) : this.isImage(u) ? s.push({
+              type: "image",
+              text: "[" + u + "]"
+            }) : s.push({
+              type: "format",
+              text: "[" + u + "]"
+            }));
+          }
+        }
+    }
+    return s;
+  }
+  /**
+   * Checks if supplied format contains image information and should be
+   * formatted as such.
+   * I.e.: `[img: myImage.png]`
+   *
+   * @ignore
+   * @param  text  Format
+   * @return true if it is an image
+   */
+  static isImage(t) {
+    return !!t.match(/img[ ]?:/);
+  }
+  static getTextStyle(t) {
+    let e = {};
+    if (t == "" || t == "[ ]")
+      return {};
+    const i = t.match(/('[^']*')|("[^"]*")/gi);
+    if (i)
+      for (let r = 0; r < i.length; r++)
+        t = t.replace(i[r], i[r].replace(/['"]*/g, "").replace(/[ ]+/g, "+"));
+    let s = t.match(/([\w\-]*:[\s]?[^;\s\]]*)|(\#[\w]{1,6})|([\w\-]+)|(\/)/gi);
+    if (!s)
+      return {};
+    for (let r = 0; r < s.length; r++)
+      if (s[r].match(/^(normal|bold|bolder|lighter|100|200|300|400|500|600|700|800|900)$/i))
+        e.fontWeight = s[r];
+      else if (s[r].match(/^(underline|line-through)$/i))
+        e.textDecoration = s[r];
+      else if (s[r] != "/") if (!s[r].match(/:/))
+        e.fill = ht.fromString(s[r]);
+      else {
+        const a = s[r].replace("+", " ").split(/:[ ]*/);
+        e[a[0]] = a[1];
+      }
+    return e;
+  }
+}
+Object.defineProperty(ct, "prefix", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "__amcharts__"
+});
+function tt(n, t) {
+  if (t != null) {
+    t = "" + t, t = ct.escape(t);
+    let e = t.match(/\{([^}]+)\}/g), i;
+    if (e)
+      for (i = 0; i < e.length; i++) {
+        let s = e[i].replace(/\{([^}]+)\}/, "$1"), r = gt(n, s);
+        r == null && (r = ""), t = t.split(e[i]).join(r);
+      }
+    t = ct.unescape(t);
+  } else
+    t = "";
+  return t;
+}
+function gt(n, t, e) {
+  let i;
+  const s = n.dataItem;
+  let r = [], a = /(format[a-zA-Z]*)\((.*)\)|([^.]+)/g, o;
+  for (; o = a.exec(t), o !== null; )
+    if (o[3]) {
+      r.push({
+        prop: o[3]
+      });
+      const l = n.getDateFormatter().get("dateFields", []), h = n.getNumberFormatter().get("numericFields", []), u = n.getDurationFormatter().get("durationFields", []);
+      l.indexOf(o[3]) !== -1 ? r.push({
+        method: "formatDate",
+        params: []
+      }) : h.indexOf(o[3]) !== -1 ? r.push({
+        method: "formatNumber",
+        params: []
+      }) : u.indexOf(o[3]) !== -1 && r.push({
+        method: "formatDuration",
+        params: []
+      });
+    } else {
+      let l = [];
+      if (Mt(o[2]) != "") {
+        let h = /'([^']*)'|"([^"]*)"|([0-9\-]+)/g, u;
+        for (; u = h.exec(o[2]), u !== null; )
+          l.push(u[1] || u[2] || u[3]);
+      }
+      r.push({
+        method: o[1],
+        params: l
+      });
+    }
+  if (s) {
+    i = M(n, r, s._settings), (i == null || bt(i)) && (i = M(n, r, s));
+    let l = s.dataContext;
+    i == null && l && (i = M(n, r, l), i == null && (i = M(n, [{
+      prop: t
+    }], l)), i == null && l.dataContext && (i = M(n, r, l.dataContext))), i == null && s.component && s.component.dataItem !== s && (i = gt(s.component, t));
+  }
+  return i == null && (i = M(n, r, n)), i == null && n.parent && (i = gt(n.parent, t)), i;
+}
+function $t(n, t) {
+  const e = n.getPrivate("customData");
+  if (bt(e))
+    return e[t];
+}
+function M(n, t, e, i) {
+  let s = e, r = !1;
+  for (let a = 0, o = t.length; a < o; a++) {
+    let l = t[a];
+    if (l.prop) {
+      if (s instanceof O) {
+        let h = s.get(l.prop);
+        h == null && (h = s.getPrivate(l.prop)), h == null && (h = $t(s, l.prop)), h == null && (h = s[l.prop]), s = h;
+      } else if (s.get) {
+        let h = s.get(l.prop);
+        h == null && (h = s[l.prop]), s = h;
+      } else
+        s = s[l.prop];
+      if (s == null)
+        return;
+    } else
+      switch (l.method) {
+        case "formatNumber":
+          let h = Pt(s);
+          h != null && (s = n.getNumberFormatter().format(h, l.params[0] || void 0), r = !0);
+          break;
+        case "formatDate":
+          let u = Bt(s);
+          if (!kt(u) || Wt(u.getTime()))
+            return;
+          u != null && (s = n.getDateFormatter().format(u, l.params[0] || void 0), r = !0);
+          break;
+        case "formatDuration":
+          let f = Pt(s);
+          f != null && (s = n.getDurationFormatter().format(f, l.params[0] || void 0, l.params[1] || void 0), r = !0);
+          break;
+        case "urlEncode":
+        case "encodeURIComponent":
+          s = encodeURIComponent(s);
+          break;
+        default:
+          s[l.method] && s[l.method].apply(e, l.params);
+          break;
+      }
+  }
+  if (!r) {
+    let a = [{
+      method: "",
+      params: i
+    }];
+    m(s) ? (a[0].method = "formatNumber", a[0].params = "") : kt(s) && (a[0].method = "formatDate", a[0].params = ""), a[0].method && (s = M(n, a, s));
+  }
+  return s;
+}
+class S extends O {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_display", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._root._renderer.makeContainer()
+    }), Object.defineProperty(this, "_childrenDisplay", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._root._renderer.makeContainer()
+    }), Object.defineProperty(this, "children", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new zt(this)
+    }), Object.defineProperty(this, "_percentageSizeChildren", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_percentagePositionChildren", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_prevWidth", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_prevHeight", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_contentWidth", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_contentHeight", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_contentMask", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_vsbd0", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_vsbd1", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_hsbd0", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_hsbd1", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_childrenPrep", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_childrenUpdt", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    });
+  }
+  _afterNew() {
+    super._afterNew(), this._display.addChild(this._childrenDisplay);
+  }
+  _afterChanged() {
+    super._afterChanged(), this._childrenPrep = !1, this._childrenUpdt = !1;
+  }
+  _dispose() {
+    Ot(this.allChildren(), (t) => {
+      t.dispose();
+    }), this.getPrivate("htmlElement") && this._root._removeHTMLContent(this), super._dispose();
+  }
+  _beforeChanged() {
+    this._childrenPrep || this._prepareChildren(), this._childrenUpdt || this._updateChildren(), super._beforeChanged();
+  }
+  _changed() {
+    if (super._changed(), this.isDirty("interactiveChildren") && (this._display.interactiveChildren = this.get("interactiveChildren", !1)), this.isDirty("layout") && (this._prevWidth = 0, this._prevHeight = 0, this.markDirtyBounds(), this._prevSettings.layout && this.children.each((t) => {
+      t.removePrivate("x"), t.removePrivate("y");
+    })), (this.isDirty("paddingTop") || this.isDirty("paddingBottom") || this.isDirty("paddingLeft") || this.isDirty("paddingRight")) && this.children.each((t) => {
+      t.markDirtyPosition();
+    }), this.isDirty("maskContent")) {
+      const t = this._childrenDisplay;
+      let e = this._contentMask;
+      this.get("maskContent") ? e || (e = U.new(this._root, {
+        x: -0.5,
+        y: -0.5,
+        width: this.width() + 1,
+        height: this.height() + 1
+      }), this._contentMask = e, t.addChildAt(e._display, 0), t.mask = e._display) : e && (t.removeChild(e._display), t.mask = null, e.dispose(), this._contentMask = void 0);
+    }
+  }
+  _updateSize() {
+    super._updateSize(), w(this._percentageSizeChildren, (t) => {
+      t._updateSize();
+    }), w(this._percentagePositionChildren, (t) => {
+      t.markDirtyPosition(), t._updateSize();
+    }), this.updateBackground();
+  }
+  updateBackground() {
+    const t = this.get("background");
+    let e = this._localBounds;
+    if (e && !this.isHidden()) {
+      let i = e.left, s = e.top, r = e.right - i, a = e.bottom - s, o = this.get("maxWidth"), l = this.get("maxHeight");
+      l && a > l && (a = l), o && r > o && (r = o);
+      let h = this.width(), u = this.height();
+      t && (t.setAll({ width: r, height: a, x: i, y: s }), this._display.interactive && (t._display.interactive = !0));
+      const f = this._contentMask;
+      f && f.setAll({ width: h + 1, height: u + 1 });
+      const d = this.get("verticalScrollbar");
+      if (d) {
+        d.set("height", u), d.set("x", h - d.width() - d.get("marginRight", 0)), d.set("end", d.get("start", 0) + u / this._contentHeight);
+        const p = d.get("background");
+        p && p.setAll({ width: d.width(), height: u });
+        let g = !0;
+        this._contentHeight <= u && (g = !1), d.setPrivate("visible", g);
+      }
+    }
+  }
+  _applyThemes(t = !1) {
+    return super._applyThemes(t) ? (this.eachChildren((e) => {
+      e._applyThemes(t);
+    }), !0) : !1;
+  }
+  _applyState(t) {
+    super._applyState(t), this.get("setStateOnChildren") && this.eachChildren((e) => {
+      e.states.apply(t);
+    });
+  }
+  _applyStateAnimated(t, e) {
+    super._applyStateAnimated(t, e), this.get("setStateOnChildren") && this.eachChildren((i) => {
+      i.states.applyAnimate(t, e);
+    });
+  }
+  /**
+   * Returns container's inner width (width without padding) in pixels.
+   *
+   * @return Inner width (px)
+   */
+  innerWidth() {
+    return this.width() - this.get("paddingRight", 0) - this.get("paddingLeft", 0);
+  }
+  /**
+   * Returns container's inner height (height without padding) in pixels.
+   *
+   * @return Inner height (px)
+   */
+  innerHeight() {
+    return this.height() - this.get("paddingTop", 0) - this.get("paddingBottom", 0);
+  }
+  _getBounds() {
+    if (this.get("html")) {
+      let t = this._localBounds;
+      t && (this._contentWidth = t.right - t.left, this._contentHeight = t.bottom - t.top);
+    } else {
+      let t = this.get("width"), e = this.get("height"), i = this.getPrivate("width"), s = this.getPrivate("height"), r = {
+        left: 0,
+        top: 0,
+        right: this.width(),
+        bottom: this.height()
+      }, a = this.get("layout"), o = !1, l = !1;
+      if ((a instanceof K || a instanceof J) && (o = !0), a instanceof $ && (l = !0), !((t != null || i != null) && (e != null || s != null) && !this.get("verticalScrollbar"))) {
+        let h = Number.MAX_VALUE, u = h, f = -h, d = h, p = -h;
+        const g = this.get("paddingLeft", 0), _ = this.get("paddingTop", 0), v = this.get("paddingRight", 0), c = this.get("paddingBottom", 0);
+        this.children.each((x) => {
+          if (x.get("position") != "absolute" && x.get("isMeasured")) {
+            let k = x.adjustedLocalBounds(), A = x.x(), G = x.y(), N = A + k.left, V = A + k.right, I = G + k.top, P = G + k.bottom;
+            o && (N -= x.get("marginLeft", 0), V += x.get("marginRight", 0)), l && (I -= x.get("marginTop", 0), P += x.get("marginBottom", 0)), N < u && (u = N), V > f && (f = V), I < d && (d = I), P > p && (p = P);
+          }
+        }), u == h && (u = 0), f == -h && (f = 0), d == h && (d = 0), p == -h && (p = 0), r.left = u - g, r.top = d - _, r.right = f + v, r.bottom = p + c;
+        const b = this.get("minWidth");
+        m(b) && b > 0 && r.right - r.left < b && (r.right >= b ? r.left = r.right - b : r.right = r.left + b);
+        const y = this.get("minHeight");
+        m(y) && y > 0 && r.bottom - r.top < y && (r.bottom >= y ? r.top = r.bottom - y : r.bottom = r.top + y);
+      }
+      this._contentWidth = r.right - r.left, this._contentHeight = r.bottom - r.top, m(t) && (r.left = 0, r.right = t), m(i) && (r.left = 0, r.right = i), m(e) && (r.top = 0, r.bottom = e), m(s) && (r.top = 0, r.bottom = s), this._localBounds = r;
+    }
+  }
+  _updateBounds() {
+    const t = this.get("layout");
+    t && t.updateContainer(this), super._updateBounds(), this.updateBackground();
+  }
+  /**
+   * @ignore
+   */
+  markDirty() {
+    super.markDirty(), this._root._addDirtyParent(this);
+  }
+  _prepareChildren() {
+    this._childrenPrep = !0;
+    const t = this.innerWidth(), e = this.innerHeight();
+    if (t != this._prevWidth || e != this._prevHeight) {
+      let i = this.get("layout"), s = !1, r = !1;
+      i && ((i instanceof K || i instanceof J) && (s = !0), i instanceof $ && (r = !0)), w(this._percentageSizeChildren, (a) => {
+        if (!s) {
+          let o = a.get("width");
+          o instanceof D && a.setPrivate("width", o.value * t);
+        }
+        if (!r) {
+          let o = a.get("height");
+          o instanceof D && a.setPrivate("height", o.value * e);
+        }
+      }), w(this._percentagePositionChildren, (a) => {
+        a.markDirtyPosition(), a.markDirtyBounds();
+      }), this._prevWidth = t, this._prevHeight = e, this._sizeDirty = !0, this.updateBackground();
+    }
+  }
+  _updateHTMLContent() {
+    const t = this.get("html", "");
+    t && t !== "" ? this._root._setHTMLContent(this, tt(this, t)) : this._root._removeHTMLContent(this), this._root._positionHTMLElement(this);
+  }
+  /**
+   * If scrolling is enabled on the Container (by adding `verticalScrollbar`)
+   * the Container will scroll in such way so that target element becomes
+   * visible if its currently outside of view.
+   *
+   * @param  child  Target child
+   * @since 5.10.5
+   */
+  scrollToChild(t) {
+    const e = this.get("verticalScrollbar");
+    if (e) {
+      let i = t.y(), s = this.innerHeight(), r = t.height(), a = this._contentHeight, o = 1 - (s - r / 2) / a;
+      if (i + r * 0.7 + this._childrenDisplay.y > s || i - r * 0.3 + this._childrenDisplay.y < 0) {
+        let l = Math.max(0, Math.min(o, (i - r / 2) / a));
+        e.animate({ key: "start", to: l, duration: e.get("animationDuration", 0), easing: e.get("animationEasing") });
+      }
+    }
+  }
+  _updateChildren() {
+    if (this._childrenUpdt = !0, this.isDirty("html") && this._updateHTMLContent(), this.isDirty("verticalScrollbar")) {
+      const t = this.get("verticalScrollbar");
+      if (t) {
+        t._setParent(this), t.startGrip.setPrivate("visible", !1), t.endGrip.setPrivate("visible", !1), this.set("maskContent", !0), this.set("paddingRight", t.width() + t.get("marginRight", 0) + t.get("marginLeft", 0));
+        let e = this.get("background");
+        e || (e = this.set("background", U.new(this._root, {
+          themeTags: ["background"],
+          fillOpacity: 0,
+          fill: this._root.interfaceColors.get("alternativeBackground")
+        }))), this._vsbd0 = this.events.on("wheel", (i) => {
+          const s = i.originalEvent;
+          if (Nt(s, this))
+            s.preventDefault();
+          else
+            return;
+          let r = s.deltaY / 5e3;
+          const a = t.get("start", 0), o = t.get("end", 1);
+          a + r <= 0 && (r = -a), o + r >= 1 && (r = 1 - o), a + r >= 0 && o + r <= 1 && (t.set("start", a + r), t.set("end", o + r));
+        }), this._disposers.push(this._vsbd0), this._vsbd1 = t.events.on("rangechanged", () => {
+          let i = this._contentHeight;
+          const s = this._childrenDisplay, r = this._contentMask;
+          s.y = -t.get("start", 0) * i, s.markDirtyLayer(), r && (r._display.y = -s.y, s.mask = r._display);
+        }), this._disposers.push(this._vsbd1), this._display.addChild(t._display);
+      } else {
+        const e = this._prevSettings.verticalScrollbar;
+        if (e) {
+          this._display.removeChild(e._display), this._vsbd0 && this._vsbd0.dispose(), this._vsbd1 && this._vsbd1.dispose();
+          const i = this._childrenDisplay;
+          i.y = 0, this.setPrivate("height", void 0), this.set("maskContent", !1), this.set("paddingRight", void 0);
+        }
+      }
+    }
+    if (this.isDirty("background")) {
+      const t = this._prevSettings.background;
+      t && this._display.removeChild(t._display);
+      const e = this.get("background");
+      e instanceof O && (e.set("isMeasured", !1), e._setParent(this), this._display.addChildAt(e._display, 0));
+    }
+    if (this.isDirty("mask")) {
+      const t = this.get("mask"), e = this._prevSettings.mask;
+      if (e && (this._display.removeChild(e._display), e != t && e.dispose()), t) {
+        const i = t.parent;
+        i && i.children.removeValue(t), t._setParent(this), this._display.addChildAt(t._display, 0), this._childrenDisplay.mask = t._display;
+      }
+    }
+  }
+  _processTemplateField() {
+    super._processTemplateField(), this.children.each((t) => {
+      t._processTemplateField();
+    });
+  }
+  /**
+   * @ignore
+   */
+  walkChildren(t) {
+    this.children.each((e) => {
+      e instanceof S && e.walkChildren(t), t(e);
+    });
+  }
+  eachChildren(t) {
+    const e = this.get("background");
+    e && t(e);
+    const i = this.get("verticalScrollbar");
+    i && t(i);
+    const s = this.get("mask");
+    s && t(s), this.children.values.forEach((r) => {
+      t(r);
+    });
+  }
+  allChildren() {
+    const t = [];
+    return this.eachChildren((e) => {
+      t.push(e);
+    }), t;
+  }
+  _setDataItem(t) {
+    const e = t !== this._dataItem;
+    super._setDataItem(t);
+    const i = this.get("html", "");
+    i && i !== "" && e && this._root._setHTMLContent(this, tt(this, i));
+  }
+  contentWidth() {
+    return this._contentWidth;
+  }
+  contentHeight() {
+    return this._contentHeight;
+  }
+}
+Object.defineProperty(S, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Container"
+});
+Object.defineProperty(S, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: O.classNames.concat([S.className])
+});
+class et extends O {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "textStyle", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._root._renderer.makeTextStyle()
+    }), Object.defineProperty(this, "_display", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this._root._renderer.makeText("", this.textStyle)
+    }), Object.defineProperty(this, "_textStyles", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: [
+        "textAlign",
+        "fontFamily",
+        "fontSize",
+        "fontStyle",
+        "fontWeight",
+        "fontStyle",
+        "fontVariant",
+        "textDecoration",
+        "shadowColor",
+        "shadowBlur",
+        "shadowOffsetX",
+        "shadowOffsetY",
+        "shadowOpacity",
+        // "leading",
+        // "letterSpacing",
+        "lineHeight",
+        "baselineRatio",
+        //"padding",
+        // "stroke",
+        // "strokeThickness",
+        // "trim",
+        // "wordWrap",
+        "direction",
+        "textBaseline",
+        "oversizedBehavior",
+        "breakWords",
+        "ellipsis",
+        "minScale",
+        "maxChars"
+      ]
+    }), Object.defineProperty(this, "_originalScale", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _updateBounds() {
+    if (this.get("text")) {
+      super._updateBounds();
+      let t = this.get("fillGradient");
+      t && (this._display.style.fill = t.getFill(this));
+    } else {
+      let t = {
+        left: 0,
+        right: 0,
+        top: 0,
+        bottom: 0
+      };
+      this._adjustedLocalBounds = t;
+    }
+  }
+  _changed() {
+    super._changed(), this._display.clear();
+    let t = this.textStyle;
+    if (this.isDirty("opacity")) {
+      let e = this.get("opacity", 1);
+      this._display.alpha = e;
+    }
+    if ((this.isDirty("text") || this.isDirty("populateText")) && (this._display.text = this._getText(), this.markDirtyBounds(), this.get("role") == "tooltip" && this._root.updateTooltip(this)), this.isPrivateDirty("tooltipElement") && this.getPrivate("tooltipElement") && this._disposers.push(new Q(() => {
+      this._root._removeTooltipElement(this);
+    })), this.isDirty("width") && (t.wordWrapWidth = this.width(), this.markDirtyBounds()), this.isDirty("oversizedBehavior") && (t.oversizedBehavior = this.get("oversizedBehavior", "none"), this._display.invalidateVisibility(), this.markDirtyBounds()), this.isDirty("breakWords") && (t.breakWords = this.get("breakWords", !1), this.markDirtyBounds()), this.isDirty("ellipsis") && (t.ellipsis = this.get("ellipsis"), this.markDirtyBounds()), this.isDirty("ignoreFormatting") && (t.ignoreFormatting = this.get("ignoreFormatting", !1), this.markDirtyBounds()), this.isDirty("minScale") && (t.minScale = this.get("minScale", 0), this.markDirtyBounds()), this.isDirty("fill") || this.isDirty("fillGradient")) {
+      const e = this.get("fill"), i = this.get("fillGradient"), s = this.get("fillOpacity");
+      if (i) {
+        if (e) {
+          const r = i.get("stops", []);
+          r.length && w(r, (a) => {
+            (!a.color || a.colorInherited) && e && (a.color = e, a.colorInherited = !0), (a.opacity == null || a.opacityInherited) && (a.opacity = s, a.opacityInherited = !0);
+          });
+        }
+        t.fill = i.getFill(this);
+      } else e && (t.fill = e);
+    }
+    if (this.isDirty("fillOpacity")) {
+      let e = this.get("fillOpacity", 1);
+      e && (t.fillOpacity = e);
+    }
+    (this.isDirty("maxWidth") || this.isPrivateDirty("maxWidth")) && (t.maxWidth = this.get("maxWidth", this.getPrivate("maxWidth")), this.markDirtyBounds()), (this.isDirty("maxHeight") || this.isPrivateDirty("maxHeight")) && (t.maxHeight = this.get("maxHeight", this.getPrivate("maxHeight")), this.markDirtyBounds()), w(this._textStyles, (e) => {
+      this._dirty[e] && (t[e] = this.get(e), this.markDirtyBounds());
+    }), t.fontSize = this.get("fontSize"), t.fontFamily = this.get("fontFamily"), this._display.style = t, this.isDirty("role") && this.get("role") == "tooltip" && this._root.updateTooltip(this);
+  }
+  _getText() {
+    let t = this.get("text", "");
+    return this.get("maxChars") && (t = Rt(t, this.get("maxChars", 1e8), this.get("breakWords"), this.get("ellipsis"))), this.get("populateText") ? tt(this, t) : t;
+  }
+  _getAccessibleText() {
+    const t = this.get("ariaLabel");
+    return t !== void 0 ? this.get("populateText") ? tt(this, t) : t : this._getText();
+  }
+  /**
+   * Forces the text to be re-evaluated and re-populated.
+   */
+  markDirtyText() {
+    this._display.text = this._getText(), this.get("role") == "tooltip" && this._root.updateTooltip(this), this.markDirtyBounds(), this.markDirty();
+  }
+  _setDataItem(t) {
+    super._setDataItem(t), this.get("populateText") && this.markDirtyText();
+  }
+  getNumberFormatter() {
+    return this.parent ? this.parent.getNumberFormatter() : super.getNumberFormatter();
+  }
+  getDateFormatter() {
+    return this.parent ? this.parent.getDateFormatter() : super.getDateFormatter();
+  }
+  getDurationFormatter() {
+    return this.parent ? this.parent.getDurationFormatter() : super.getDurationFormatter();
+  }
+}
+Object.defineProperty(et, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Text"
+});
+Object.defineProperty(et, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: O.classNames.concat([et.className])
+});
+class it extends S {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_text", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_textKeys", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: [
+        "text",
+        "fill",
+        "fillGradient",
+        "fillOpacity",
+        "textAlign",
+        "fontFamily",
+        "fontSize",
+        "fontStyle",
+        "fontWeight",
+        "fontStyle",
+        "fontVariant",
+        "textDecoration",
+        "shadowColor",
+        "shadowBlur",
+        "shadowOffsetX",
+        "shadowOffsetY",
+        "shadowOpacity",
+        // "leading",
+        // "letterSpacing",
+        "lineHeight",
+        "baselineRatio",
+        //"padding",
+        // "stroke",
+        // "strokeThickness",
+        // "trim",
+        // "wordWrap",
+        "direction",
+        "textBaseline",
+        "oversizedBehavior",
+        "breakWords",
+        "ellipsis",
+        "minScale",
+        "populateText",
+        "role",
+        "ignoreFormatting",
+        "maxChars",
+        "ariaLabel"
+      ]
+    });
+  }
+  /**
+   * @ignore Text is not to be used directly
+   */
+  get text() {
+    return this._text;
+  }
+  _afterNew() {
+    super._afterNew(), this._makeText(), w(this._textKeys, (t) => {
+      const e = this.get(t);
+      e != null && this._text.set(t, e);
+    }), this.get("html", "") !== "" && this._text.set("text", ""), this.onPrivate("maxWidth", () => {
+      this._setMaxDimentions();
+    }), this.onPrivate("maxHeight", () => {
+      this._setMaxDimentions();
+    });
+  }
+  _makeText() {
+    this._text = this.children.push(et.new(this._root, {}));
+  }
+  _updateChildren() {
+    super._updateChildren();
+    const t = this._text;
+    if (w(this._textKeys, (i) => {
+      this._text.set(i, this.get(i));
+    }), (this.isDirty("maxWidth") || this.isDirty("maxHeight") || this.isDirty("rotation")) && this._setMaxDimentions(), this.get("html", "") !== "" ? t.set("text", "") : (t.set("text", this.get("text")), this._maybeUpdateHTMLColor()), (this.isDirty("fill") || this.isDirty("fillGradient")) && this._maybeUpdateHTMLColor(), this.isDirty("textAlign") || this.isDirty("width")) {
+      const i = this.get("textAlign");
+      let s;
+      this.get("width") != null ? i == "right" ? s = Ft : i == "center" ? s = At : s = 0 : i == "left" || i == "start" ? s = this.get("paddingLeft", 0) : (i == "right" || i == "end") && (s = -this.get("paddingRight", 0)), t.set("x", s);
+    }
+    const e = this.get("background");
+    e && e.setPrivate("visible", t._display.textVisible);
+  }
+  _maybeUpdateHTMLColor() {
+    const t = this.getPrivate("htmlElement");
+    t && this.get("fill") && (t.style.color = this.get("fill").toCSSHex());
+  }
+  _setMaxDimentions() {
+    const t = this.get("rotation"), e = t == 90 || t == 270 || t == -90, i = this._text, s = this.get("maxWidth", this.getPrivate("maxWidth", 1 / 0));
+    m(s) ? i.set(e ? "maxHeight" : "maxWidth", s - this.get("paddingTop", 0) - this.get("paddingBottom", 0)) : i.set(e ? "maxHeight" : "maxWidth", void 0);
+    const r = this.get("maxHeight", this.getPrivate("maxHeight", 1 / 0));
+    m(r) ? i.set(e ? "maxWidth" : "maxHeight", r - this.get("paddingLeft", 0) - this.get("paddingRight", 0)) : i.set(e ? "maxWidth" : "maxHeight", void 0), this.root.events.once("frameended", () => {
+      i.markDirtyBounds();
+    });
+  }
+  _setDataItem(t) {
+    super._setDataItem(t), this._markDirtyKey("text"), this._markDirtyKey("html");
+    const e = this._text;
+    e.get("populateText") && e.markDirtyText();
+    const i = this.get("html");
+    i && i !== "" && this._updateHTMLContent();
+  }
+  /**
+   * Returns text with populated placeholders and formatting if `populateText` is
+   * set to `true`.
+   *
+   * @return Populated text
+   */
+  getText() {
+    return this._text._getText();
+  }
+  /**
+   * Returns "aria-label" text with populated placeholders and formatting
+   * if `populateText` is set to `true`.
+   *
+   * @return Populated text
+   */
+  getAccessibleText() {
+    return this._text._getAccessibleText();
+  }
+}
+Object.defineProperty(it, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Label"
+});
+Object.defineProperty(it, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: S.classNames.concat([it.className])
+});
+class R extends W {
+  _beforeChanged() {
+    super._beforeChanged(), (this.isDirty("pointerBaseWidth") || this.isDirty("cornerRadius") || this.isDirty("pointerLength") || this.isDirty("pointerX") || this.isDirty("pointerY") || this.isDirty("width") || this.isDirty("height")) && (this._clear = !0);
+  }
+  _changed() {
+    if (super._changed(), this._clear) {
+      this.markDirtyBounds();
+      let t = this.width(), e = this.height();
+      if (t > 0 && e > 0) {
+        let i = this.get("cornerRadius", 8);
+        i = T(i, 0, Math.min(t / 2, e / 2));
+        let s = this.get("pointerX", 0), r = this.get("pointerY", 0), a = this.get("pointerBaseWidth", 15) / 2, o = 0, l = 0, h = t, u = 0, f = t, d = e, p = 0, g = e, _ = (s - o) * (d - l) - (r - l) * (f - o), v = (s - p) * (u - g) - (r - g) * (h - p);
+        const c = this._display;
+        if (c.moveTo(i, 0), _ > 0 && v > 0) {
+          let b = Math.round(T(s, i + a, t - a - i));
+          r = T(r, -1 / 0, 0), c.lineTo(b - a, 0), c.lineTo(s, r), c.lineTo(b + a, 0);
+        }
+        if (c.lineTo(t - i, 0), c.arcTo(t, 0, t, i, i), _ > 0 && v < 0) {
+          let b = Math.round(T(r, i + a, e - a - i));
+          s = T(s, t, 1 / 0), c.lineTo(t, i), c.lineTo(t, Math.max(b - a, i)), c.lineTo(s, r), c.lineTo(t, b + a);
+        }
+        if (c.lineTo(t, e - i), c.arcTo(t, e, t - i, e, i), _ < 0 && v < 0) {
+          let b = Math.round(T(s, i + a, t - a - i));
+          r = T(r, e, 1 / 0), c.lineTo(t - i, e), c.lineTo(b + a, e), c.lineTo(s, r), c.lineTo(b - a, e);
+        }
+        if (c.lineTo(i, e), c.arcTo(0, e, 0, e - i, i), _ < 0 && v > 0) {
+          let b = Math.round(T(r, i + a, e - i - a));
+          s = T(s, -1 / 0, 0), c.lineTo(0, e - i), c.lineTo(0, b + a), c.lineTo(s, r), c.lineTo(0, Math.max(b - a, i));
+        }
+        c.lineTo(0, i), c.arcTo(0, 0, i, 0, i), c.closePath();
+      }
+    }
+  }
+}
+Object.defineProperty(R, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "PointedRectangle"
+});
+Object.defineProperty(R, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: W.classNames.concat([R.className])
+});
+class _t extends S {
+  constructor(t, e, i, s = []) {
+    super(t, e, i, s), Object.defineProperty(this, "_fx", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_fy", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_label", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_fillDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_fillGrDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_strokeDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_labelDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_w", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_h", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_keepHoverDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_htmlContentHovered", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    });
+  }
+  _afterNew() {
+    this._settings.themeTags = Gt(this._settings.themeTags, ["tooltip"]), super._afterNew(), this._setDefaultFn("background", () => R.new(this._root, {})).set("themeTags", ["tooltip", "background"]), this._label = this.children.push(it.new(this._root, {})), this._disposers.push(this._label.events.on("boundschanged", () => {
+      this._updateBackground();
+    })), this._disposers.push(this.on("bounds", () => {
+      this._updateBackground();
+    })), this._updateTextColor(), this._root.tooltipContainer.children.push(this), this.hide(0), this._disposers.push(this.label.onPrivate("htmlElement", (e) => {
+      e && (this._disposers.push(q(e, "pointerover", (i) => {
+        this._htmlContentHovered = !0;
+      })), this._disposers.push(q(e, "pointerout", (i) => {
+        this._htmlContentHovered = !1;
+      })));
+    })), this.on("visible", (e) => {
+      this._handleReaderAnnouncement();
+    }), this.label.events.on("dataitemchanged", (e) => {
+      this._handleReaderAnnouncement();
+    }), this._root._tooltips.push(this);
+  }
+  _handleReaderAnnouncement() {
+    this.get("readerAnnounce") && this.isVisibleDeep() && this._root.readerAlert(this.label.getAccessibleText());
+  }
+  /**
+   * A [[Label]] element for the tooltip.
+   *
+   * @readonly
+   * @return Label
+   */
+  get label() {
+    return this._label;
+  }
+  /**
+   * Permanently disposes the tooltip.
+   */
+  _dispose() {
+    super._dispose(), Ct(this._root._tooltips, this);
+  }
+  _updateChildren() {
+    super._updateChildren(), (this.isDirty("pointerOrientation") || this.isPrivateDirty("minWidth") || this.isPrivateDirty("minHeight")) && this.get("background")._markDirtyKey("width"), this.get("labelText") != null && this.label.set("text", this.get("labelText")), this.get("labelHTML") != null && this.label.set("html", this.get("labelHTML")), this.get("labelAriaLabel") != null && this.label.set("ariaLabel", this.get("labelAriaLabel"));
+  }
+  _changed() {
+    if (super._changed(), (this.isDirty("pointTo") || this.isDirty("pointerOrientation")) && this._updateBackground(), this.isDirty("tooltipTarget") && this.updateBackgroundColor(), this.isDirty("keepTargetHover"))
+      if (this.get("keepTargetHover")) {
+        const e = this.get("background");
+        this._keepHoverDp = new C([
+          e.events.on("pointerover", (i) => {
+            let s = this.get("tooltipTarget");
+            s && (s.parent && s.parent.getPrivate("tooltipTarget") == s && (s = s.parent), s.hover());
+          }),
+          e.events.on("pointerout", (i) => {
+            let s = this.get("tooltipTarget");
+            s && (s.parent && s.parent.getPrivate("tooltipTarget") == s && (s = s.parent), this._htmlContentHovered || s.unhover());
+          })
+        ]), this.label.onPrivate("htmlElement", (i) => {
+          this._keepHoverDp && i && this._keepHoverDp.disposers.push(q(i, "pointerleave", (s) => {
+            const r = this.root._renderer.getEvent(s);
+            e.events.dispatch("pointerout", {
+              type: "pointerout",
+              originalEvent: r.event,
+              point: r.point,
+              simulated: !1,
+              target: e
+            });
+          }));
+        });
+      } else
+        this._keepHoverDp && (this._keepHoverDp.dispose(), this._keepHoverDp = void 0);
+  }
+  _onShow() {
+    super._onShow(), this.updateBackgroundColor();
+  }
+  updateBackgroundColor() {
+    let t = this.get("tooltipTarget");
+    const e = this.get("background");
+    let i, s;
+    if (t && e) {
+      if (i = t.get("fill"), s = t.get("stroke"), i == null && (i = s), this.get("getFillFromSprite") && (this._fillDp && this._fillDp.dispose(), i != null && e.set("fill", i), this._fillDp = t.on("fill", (r) => {
+        r != null && (e.set("fill", r), this._updateTextColor(r));
+      }), this._disposers.push(this._fillDp)), this.get("getFillGradientFromSprite")) {
+        this._fillGrDp && this._fillGrDp.dispose();
+        let r = t.get("fillGradient");
+        r != null && e.set("fillGradient", r), this._fillGrDp = t.on("fillGradient", (a) => {
+          a != null && e.set("fillGradient", a);
+        }), this._disposers.push(this._fillGrDp);
+      }
+      this.get("getStrokeFromSprite") && (this._strokeDp && this._strokeDp.dispose(), i != null && e.set("stroke", i), this._strokeDp = t.on("fill", (r) => {
+        r != null && e.set("stroke", r);
+      }), this._disposers.push(this._strokeDp)), this.get("getLabelFillFromSprite") && (this._labelDp && this._labelDp.dispose(), i != null && this.label.set("fill", i), this._labelDp = t.on("fill", (r) => {
+        r != null && this.label.set("fill", r);
+      }), this._disposers.push(this._labelDp));
+    }
+    this._updateTextColor(i);
+  }
+  _updateTextColor(t) {
+    this.get("autoTextColor") && (t == null && (t = this.get("background").get("fill")), t == null && (t = this._root.interfaceColors.get("background")), t instanceof ht && this.label.set("fill", ht.alternative(t, this._root.interfaceColors.get("alternativeText"), this._root.interfaceColors.get("text"))));
+  }
+  _setDataItem(t) {
+    super._setDataItem(t), this.label._setDataItem(t);
+  }
+  _updateBackground() {
+    super.updateBackground();
+    const t = this._root.container;
+    if (t) {
+      let e = 0.5, i = 0.5, s = this.get("centerX");
+      s instanceof D && (e = s.value);
+      let r = this.get("centerY");
+      r instanceof D && (i = r.value);
+      let a = t.width(), o = t.height(), l = this.parent, h = 0, u = 0;
+      if (l) {
+        h = l.x(), u = l.y();
+        const P = l.get("layerMargin");
+        P && (h += P.left || 0, u += P.top || 0, a += (P.left || 0) + (P.right || 0), o += (P.top || 0) + (P.bottom || 0));
+      }
+      const f = this.get("bounds", { left: -h, top: -u, right: a - h, bottom: o - u });
+      this._updateBounds();
+      let d = this.width(), p = this.height();
+      d === 0 && (d = this._w), p === 0 && (p = this._h);
+      let g = this.get("pointTo", { x: a / 2, y: o / 2 }), _ = g.x, v = g.y, c = this.get("pointerOrientation"), b = this.get("background"), y = 0, x = 0, k = 0;
+      b instanceof R && (y = b.get("pointerLength", 0), x = b.get("strokeWidth", 0) / 2, k = x, b.set("width", d), b.set("height", p));
+      let A = 0, G = 0, N = f.right - f.left, V = f.bottom - f.top;
+      c == "horizontal" || c == "left" || c == "right" ? (x = 0, c == "horizontal" ? _ > f.left + N / 2 ? (_ -= d * (1 - e) + y, k *= -1) : _ += d * e + y : c == "left" ? _ += d * (1 - e) + y : (_ -= d * e + y, k *= -1)) : (k = 0, c == "vertical" ? v > f.top + p / 2 + y ? v -= p * (1 - i) + y : (v += p * i + y, x *= -1) : c == "down" ? v -= p * (1 - i) + y : (v += p * i + y, x *= -1)), _ = T(_, f.left + d * e, f.left + N - d * (1 - e)) + k, v = T(v, f.top + p * i, f.top + V - p * (1 - i)) - x, A = g.x - _ + d * e + k, G = g.y - v + p * i - x, this._fx = _, this._fy = v;
+      const I = this.get("animationDuration", 0);
+      if (I > 0 && this.get("visible") && this.get("opacity") > 0.1) {
+        const P = this.get("animationEasing");
+        this.animate({ key: "x", to: _, duration: I, easing: P }), this.animate({ key: "y", to: v, duration: I, easing: P });
+      } else
+        this.set("x", _), this.set("y", v);
+      b instanceof R && (b.set("pointerX", A), b.set("pointerY", G)), d > 0 && (this._w = d), p > 0 && (this._h = p);
+    }
+  }
+}
+Object.defineProperty(_t, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Tooltip"
+});
+Object.defineProperty(_t, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: S.classNames.concat([_t.className])
+});
+export {
+  ft as B,
+  S as C,
+  Qt as D,
+  W as G,
+  K as H,
+  it as L,
+  U as R,
+  _t as T,
+  $ as V,
+  qt as a,
+  Z as b,
+  dt as c,
+  Vt as d,
+  et as e,
+  T as f,
+  ee as g,
+  Et as h,
+  se as i,
+  Ht as j,
+  te as k,
+  ct as l,
+  ie as m,
+  Tt as n,
+  J as o,
+  tt as p,
+  Zt as r,
+  ut as s,
+  re as v
+};