@orangelogic/design-system 2.0.0-29DUO2-beta-1

package/library/atoms.d.ts

@@ -0,0 +1 @@
+export * from './packages/atoms/src/index'

package/library/chunks/AxisLabelRadial.CgPb7ghO.js

@@ -0,0 +1,11 @@
+import { R as s } from "./RadialLabel.TyXECvYG.js";
+class a extends s {
+  constructor() {
+    super(...arguments), this._tickPoints = [];
+  }
+}
+a.className = "AxisLabelRadial";
+a.classNames = s.classNames.concat([a.className]);
+export {
+  a as A
+};

package/library/chunks/BaseColumnSeries.B6rG-Ylz.js

@@ -0,0 +1,304 @@
+import { X as B, e as L, v as j, P as R, i as E, a as Y, _ as U } from "./am-chart.B_OdX4Q-.js";
+class M extends B {
+  constructor() {
+    super(...arguments), this._ph = 0, this._pw = 0, this._columnsUpdated = !1;
+  }
+  _makeGraphics(t, s) {
+    return this.makeColumn(s, t);
+  }
+  _makeFieldNames() {
+    super._makeFieldNames();
+    const t = this.get("xAxis"), s = this.get("yAxis"), n = "CategoryAxis", i = "ValueAxis";
+    t.isType(n) && (this.get("openCategoryXField") || (this._xOpenField = this._xField)), t.isType(i) && (this.get("openValueXField") || (this._xOpenField = this._xField)), s.isType(n) && (this.get("openCategoryYField") || (this._yOpenField = this._yField)), s.isType(i) && (this.get("openValueYField") || (this._yOpenField = this._yField));
+  }
+  _prepareChildren() {
+    super._prepareChildren();
+    const t = this.get("xAxis"), s = this.get("yAxis"), n = this.dataItems.length, i = Math.max(0, this.startIndex() - 2), e = Math.min(this.endIndex() + 2, n - 1);
+    if (t.inited && s.inited)
+      for (let o = i; o <= e; o++) {
+        let a = this.dataItems[o];
+        this._createGraphics(a);
+      }
+  }
+  _updateChildren() {
+    const t = this.chart;
+    t && (this._ph = t.plotContainer.height(), this._pw = t.plotContainer.width());
+    const s = this.get("xAxis"), n = this.get("yAxis"), i = this.get("baseAxis"), e = this.columns.template;
+    this.isDirty("fill") && e.get("fill") == null && e.set("fill", this.get("fill")), this.isDirty("fillPattern") && e.get("fillPattern") == null && e.set("fillPattern", this.get("fillPattern")), this.isDirty("stroke") && e.get("stroke") == null && e.set("stroke", this.get("stroke"));
+    let o = 0, a = 0, v = 0;
+    i && L(i.series, (r) => {
+      if (r instanceof M) {
+        const h = r.get("stacked");
+        h && v == 0 && a++, !h && r.get("clustered") && a++;
+      }
+      r === this && (o = a - 1), v++;
+    }), this.get("clustered") || (o = 0, a = 1), a === 0 && (a = 1, o = 0);
+    const m = "cellStartLocation", D = "cellEndLocation", g = this._xRenderer.get(m, 0), p = this._xRenderer.get(D, 1), f = this._yRenderer.get(m, 0), k = this._yRenderer.get(D, 1);
+    if (this._aLocationX0 = g + o / a * (p - g), this._aLocationX1 = g + (o + 1) / a * (p - g), this._aLocationY0 = f + o / a * (k - f), this._aLocationY1 = f + (o + 1) / a * (k - f), s.inited && n.inited) {
+      if (this._axesDirty || this._valuesDirty || this._stackDirty || this.isDirty("vcx") || this.isDirty("vcy") || this._sizeDirty) {
+        const r = this.dataItems.length;
+        let h = Math.max(0, this.startIndex() - 2), X = Math.min(this.endIndex() + 2, r - 1);
+        for (let l = 0; l < h; l++)
+          this._toggleColumn(this.dataItems[l], !1);
+        let C = this.dataItems[h];
+        for (let l = h; l <= X; l++) {
+          let P = this.dataItems[l];
+          if (P.get("valueX") != null && P.get("valueY") != null) {
+            if (C = P, l > 0 && h > 0)
+              for (let w = l - 1; w >= 0; w--) {
+                let G = this.dataItems[w];
+                if (G.get("valueX") != null && G.get("valueY") != null) {
+                  C = G;
+                  break;
+                }
+              }
+            break;
+          } else
+            this._toggleColumn(P, !1);
+        }
+        this._beforeColumnsDraw();
+        let d = 0;
+        n.isType("CategoryAxis") && s.isType("CategoryAxis") ? d = 2 : s === i ? d = 0 : n === i && (d = 1);
+        for (let l = h; l <= X; l++) {
+          let P = this.dataItems[l];
+          this._updateGraphics(P, C, d), P.get("valueX") != null && P.get("valueY") != null && (C = P);
+        }
+        this._afterColumnsDraw();
+        for (let l = X + 1; l < r; l++)
+          this._toggleColumn(this.dataItems[l], !1);
+        this._columnsUpdated = !0;
+      }
+    } else
+      this._skipped = !0;
+    this.getPrivate("doNotUpdateLegend") || this.updateLegendMarker(this.get("tooltipDataItem")), super._updateChildren();
+  }
+  _afterChanged() {
+    super._afterChanged(), this._columnsUpdated = !1;
+  }
+  _beforeColumnsDraw() {
+  }
+  _afterColumnsDraw() {
+  }
+  _createGraphics(t) {
+    let s = t.get("graphics");
+    if (!s) {
+      s = this._makeGraphics(this.columns, t), t.set("graphics", s), s._setDataItem(t);
+      const n = t.get("legendDataItem");
+      if (n) {
+        const e = n.get("markerRectangle");
+        if (e) {
+          const o = e.states.lookup("default");
+          L(j, (a) => {
+            const v = s.get(a, this.get(a));
+            e.set(a, v), o.set(a, v);
+          });
+        }
+      }
+      let i = t.get("rangeGraphics");
+      i && L(i, (e) => {
+        e.dispose();
+      }), i = [], t.setRaw("rangeGraphics", i), this.axisRanges.each((e) => {
+        const o = e.container, a = this._makeGraphics(e.columns, t);
+        i && i.push(a), a.setPrivate("list", e.columns), o.children.push(a);
+      });
+    }
+  }
+  createAxisRange(t) {
+    return L(this.dataItems, (s) => {
+      const n = s.get("graphics");
+      n && (n.dispose(), s.set("graphics", void 0));
+    }), super.createAxisRange(t);
+  }
+  _updateGraphics(t, s, n) {
+    let i = t.get("graphics");
+    const e = this._xField, o = this._yField, a = t.get(e), v = t.get(o), m = this.get("exactLocationX", !1);
+    if (a != null && v != null) {
+      const D = this._xOpenField, g = this._yOpenField, p = this.get("locationX", t.get("locationX", 0.5)), f = this.get("locationY", t.get("locationY", 0.5)), k = this.get("openLocationX", t.get("openLocationX", p)), r = this.get("openLocationY", t.get("openLocationY", f)), h = i.get("width"), X = i.get("height"), C = this.get("stacked"), d = this.get("xAxis"), l = this.get("yAxis"), P = d.get("start"), w = d.get("end"), G = l.get("start"), N = l.get("end");
+      let x, A, y, F, T = this.get("vcy", 1), O = this.get("vcx", 1), S = !1, b = !1;
+      if (n == 0) {
+        let u = this._aLocationX0 + k - 0.5, _ = this._aLocationX1 + p - 0.5;
+        if (h instanceof R) {
+          let c = (_ - u) * (1 - h.value) / 2;
+          u += c, _ -= c;
+        }
+        if (x = d.getDataItemPositionX(t, D, u, O, m), A = d.getDataItemPositionX(t, e, _, O, m), y = l.getDataItemPositionY(t, o, f, T), this._yOpenField !== this._yField)
+          F = l.getDataItemPositionY(t, g, r, T);
+        else if (C) {
+          let c = t.get("stackToItemY");
+          c ? F = l.getDataItemPositionY(c, o, r, c.component.get("vcy")) : F = l.basePosition();
+        } else
+          F = l.basePosition();
+        t.setRaw("point", { x: x + (A - x) / 2, y }), b = !0;
+      } else if (n == 1) {
+        let u = this._aLocationY0 + r - 0.5, _ = this._aLocationY1 + f - 0.5;
+        if (X instanceof R) {
+          let c = (_ - u) * (1 - X.value) / 2;
+          u += c, _ -= c;
+        }
+        if (y = l.getDataItemPositionY(t, g, u, T), F = l.getDataItemPositionY(t, o, _, T), A = d.getDataItemPositionX(t, e, p, O, m), this._xOpenField !== this._xField)
+          x = d.getDataItemPositionX(t, D, k, O, m);
+        else if (C) {
+          let c = t.get("stackToItemX");
+          c ? x = d.getDataItemPositionX(c, e, k, c.component.get("vcx"), m) : x = d.basePosition();
+        } else
+          x = d.basePosition();
+        S = !0, t.setRaw("point", { x: A, y: y + (F - y) / 2 });
+      } else if (n == 2) {
+        let u = this._aLocationX0 + k - 0.5, _ = this._aLocationX1 + p - 0.5;
+        if (h instanceof R) {
+          let c = (_ - u) * (1 - h.value) / 2;
+          u += c, _ -= c;
+        }
+        if (x = d.getDataItemPositionX(t, D, u, O), A = d.getDataItemPositionX(t, e, _, O), u = this._aLocationY0 + r - 0.5, _ = this._aLocationY1 + f - 0.5, X instanceof R) {
+          let c = (_ - u) * (1 - X.value) / 2;
+          u += c, _ -= c;
+        }
+        y = l.getDataItemPositionY(t, g, u, T), F = l.getDataItemPositionY(t, o, _, T), t.setRaw("point", { x: x + (A - x) / 2, y: y + (F - y) / 2 });
+      }
+      this._applyGraphicsStates(t, s), this._updateSeriesGraphics(t, i, x, A, y, F, S, b), x < P && A < P || x > w && A > w || y < G && F <= G || y >= N && F > N || E(x) || E(y) ? this._toggleColumn(t, !1) : this._toggleColumn(t, !0);
+      let V = t.get("rangeGraphics");
+      V && L(V, (u) => {
+        this._updateSeriesGraphics(t, u, x, A, y, F, S, b);
+      });
+    } else
+      this._toggleColumn(t, !1);
+  }
+  _updateSeriesGraphics(t, s, n, i, e, o, a, v) {
+    const m = s.get("width"), D = s.get("height"), g = s.get("maxWidth"), p = s.get("maxHeight"), f = this.getPoint(n, e), k = this.getPoint(i, o), r = t.get("point");
+    if (r) {
+      const h = this.getPoint(r.x, r.y);
+      r.x = h.x + this._x, r.y = h.y + this._y;
+    }
+    if (n = f.x, i = k.x, e = f.y, o = k.y, Y(m)) {
+      const h = (i - n - m) / 2;
+      n += h, i -= h;
+    }
+    if (Y(g) && g < Math.abs(i - n)) {
+      const h = (i - n - g) / 2;
+      n += h, i -= h;
+    }
+    if (Y(D)) {
+      const h = (o - e - D) / 2;
+      e += h, o -= h;
+    }
+    if (Y(p) && p < Math.abs(o - e)) {
+      const h = (o - e - p) / 2;
+      e += h, o -= h;
+    }
+    this.get("adjustBulletPosition") && (a && (i = Math.min(Math.max(0, i), this._pw), n = Math.min(Math.max(0, n), this._pw)), v && (e = Math.min(Math.max(0, e), this._ph), o = Math.min(Math.max(0, o), this._ph))), t.setRaw("left", n), t.setRaw("right", i), t.setRaw("top", e), t.setRaw("bottom", o), s.setPrivate("width", i - n), s.setPrivate("height", o - e), s.set("x", n), s.set("y", o - (o - e));
+  }
+  _handleDataSetChange() {
+    super._handleDataSetChange(), L(this._dataItems, (t) => {
+      this._toggleColumn(t, !1);
+    });
+  }
+  _applyGraphicsStates(t, s) {
+    const n = t.get("graphics"), i = n.states.lookup("dropFromOpen"), e = n.states.lookup("riseFromOpen"), o = n.states.lookup("dropFromPrevious"), a = n.states.lookup("riseFromPrevious");
+    if (i || o || e || a) {
+      const v = this.get("xAxis"), m = this.get("yAxis"), D = this.get("baseAxis");
+      let g, p, f;
+      D === v && m.isType("ValueAxis") ? (g = t.get(this._yOpenField), p = t.get(this._yField), f = s.get(this._yField)) : D === m && v.isType("ValueAxis") && (g = t.get(this._xOpenField), p = t.get(this._xField), f = s.get(this._xField)), Y(g) && Y(p) && (p < g ? i && i.apply() : e && e.apply(), Y(f) && (p < f ? o && o.apply() : a && a.apply()));
+    }
+  }
+  /**
+   * @ignore
+   */
+  disposeDataItem(t) {
+    super.disposeDataItem(t);
+    const s = t.get("graphics");
+    s && (this.columns.removeValue(s), s.dispose());
+    const n = t.get("rangeGraphics");
+    n && L(n, (i) => {
+      const e = i.getPrivate("list");
+      e && e.removeValue(i), i.dispose();
+    });
+  }
+  /**
+   * Hides series's data item.
+   *
+   * @param   dataItem  Data item
+   * @param   duration  Animation duration in milliseconds
+   * @return            Promise
+   */
+  hideDataItem(t, s) {
+    const n = Object.create(null, {
+      hideDataItem: { get: () => super.hideDataItem }
+    });
+    return U(this, void 0, void 0, function* () {
+      const i = [n.hideDataItem.call(this, t, s)], e = t.get("graphics");
+      e && i.push(e.hide(s));
+      const o = t.get("rangeGraphics");
+      o && L(o, (a) => {
+        i.push(a.hide(s));
+      }), yield Promise.all(i);
+    });
+  }
+  _toggleColumn(t, s) {
+    const n = t.get("graphics");
+    n && n.setPrivate("visible", s);
+    const i = t.get("rangeGraphics");
+    i && L(i, (o) => {
+      o.setPrivate("visible", s);
+    });
+    const e = t.bullets;
+    e && L(e, (o) => {
+      o.setPrivate("hidden", !s);
+    });
+  }
+  /**
+   * Shows series's data item.
+   *
+   * @param   dataItem  Data item
+   * @param   duration  Animation duration in milliseconds
+   * @return            Promise
+   */
+  showDataItem(t, s) {
+    const n = Object.create(null, {
+      showDataItem: { get: () => super.showDataItem }
+    });
+    return U(this, void 0, void 0, function* () {
+      const i = [n.showDataItem.call(this, t, s)], e = t.get("graphics");
+      e && i.push(e.show(s));
+      const o = t.get("rangeGraphics");
+      o && L(o, (a) => {
+        i.push(a.show(s));
+      }), yield Promise.all(i);
+    });
+  }
+  /**
+   * @ignore
+   */
+  updateLegendMarker(t) {
+    let s = this.get("legendDataItem");
+    if (this.get("useLastColorForLegendMarker") && !t) {
+      const n = this.dataItems[this.endIndex() - 1];
+      n && (t = n);
+    }
+    if (s) {
+      let n = this.columns.template;
+      if (t) {
+        let e = t.get("graphics");
+        e && (n = e);
+      }
+      const i = s.get("markerRectangle");
+      if (i && !s.get("itemContainer").get("disabled")) {
+        const e = i.states.lookup("default");
+        L(j, (o) => {
+          const a = n.get(o, this.get(o));
+          i.set(o, a), e.set(o, a);
+        });
+      }
+    }
+  }
+  _getTooltipTarget(t) {
+    if (this.get("seriesTooltipTarget") == "bullet")
+      return super._getTooltipTarget(t);
+    let s = t.get("graphics");
+    return s || this;
+  }
+}
+M.className = "BaseColumnSeries";
+M.classNames = B.classNames.concat([M.className]);
+export {
+  M as B
+};

package/library/chunks/CandlestickSeries.C-YfO-57.js

@@ -0,0 +1,362 @@
+import { Q as nt, U as C, W as G, Y as dt, e as X, a as F, Z as N, $ as I, a0 as mt, a1 as H, a2 as et, a3 as ut, a4 as st, a5 as ft, t as $, a6 as _t, E as lt, z as xt, R as ht, L as it, T as at, m as ot } from "./am-chart.B_OdX4Q-.js";
+import { C as rt } from "./ColumnSeries.CZi2LBZ2.js";
+class j extends nt {
+  constructor() {
+    super(...arguments), this._frequency = 1, this._m = 0, this._dates = [];
+  }
+  _afterNew() {
+    this.valueFields.push("date"), this.addTag("gapless"), super._afterNew();
+  }
+  _getDates() {
+    return this._customDates ? this._customDates : this._dates;
+  }
+  _updateDates(t, e) {
+    if (!e.get("ignoreMinMax")) {
+      const a = this._getDates(), o = C(a, (n) => G(n, t));
+      o.found || dt(a, o.index, t);
+    }
+  }
+  _updateAllDates() {
+    if (!this._customDates) {
+      const t = this._dates;
+      t.length = 0, X(this.series, (r) => {
+        let l = "valueX";
+        r.get("yAxis") == this && (l = "valueY"), X(r.dataItems, (h) => {
+          let c = h.get(l);
+          F(c) && h.open && this._updateDates(h.open[l], r);
+        });
+      });
+      const e = this.get("extraMax", 0), a = this.get("extraMin", 0);
+      let o = t.length;
+      const n = this.getPrivate("baseInterval"), i = n.count, s = n.timeUnit;
+      if (e > 0) {
+        const r = o * e;
+        let l = t[o - 1];
+        if (F(l))
+          for (let h = o - 1; h < o + r; h++)
+            l += N(s, i * this._getM(s)), l = I(l, s, i, this._root), t.push(l);
+      }
+      if (a > 0) {
+        const r = o * a;
+        let l = t[0];
+        if (F(l))
+          for (let h = 0; h < r; h++)
+            l -= N(s, i), l = I(l, s, i, this._root), t.unshift(l);
+      }
+    }
+  }
+  /**
+   * Convers value to a relative position on axis.
+   *
+   * @param   value  Value
+   * @return         Relative position
+   */
+  valueToPosition(t) {
+    const e = this._getDates(), a = this.get("startLocation", 0), o = this.get("endLocation", 1), n = e.length - a - (1 - o), i = C(e, (r) => G(r, t));
+    let s = i.index;
+    if (i.found)
+      return (s - a) / n;
+    {
+      s > 0 && (s -= 1);
+      let r = e[s];
+      const l = e[s + 1];
+      if (l) {
+        let c = l;
+        Math.abs(c - t) < Math.abs(r - t) && (r = c, s++);
+      }
+      let h = t - r;
+      return (s - a) / n + h / this._baseDuration / n;
+    }
+  }
+  /**
+   * Converts numeric value from axis scale to index.
+   *
+   * @param  value  Value
+   * @return        Index
+   */
+  valueToIndex(t) {
+    const e = this._getDates(), a = C(e, (n) => G(n, t));
+    let o = a.index;
+    return a.found || o > 0 && (o -= 1), o;
+  }
+  /**
+   * Converts a relative position to a corresponding numeric value from axis
+   * scale.
+   *
+   * @param   position  Relative position
+   * @return            Value
+   */
+  positionToValue(t) {
+    const e = this.get("startLocation", 0), a = this.get("endLocation", 1), o = this._getDates();
+    let n = Math.round(o.length - e - (1 - a)), i = t * n, s = Math.floor(i);
+    return s < 0 && (s = 0), s > n - 1 && (s = n - 1), o[s] + (i - s + e) * this._baseDuration;
+  }
+  _fixZoomFactor() {
+    this.setPrivateRaw("maxZoomFactor", this._getDates().length - this.get("startLocation", 0) - (1 - this.get("endLocation", 1)));
+  }
+  /**
+   * Zooms the axis to specific `start` and `end` dates.
+   *
+   * Optional `duration` specifies duration of zoom animation in milliseconds.
+   *
+   * @param  start     Start Date
+   * @param  end       End Date
+   * @param  duration  Duration in milliseconds
+   */
+  zoomToDates(t, e, a) {
+    const o = this._getDates(), n = o.length;
+    let i = C(o, (l) => G(l, t.getTime())), s = o[Math.min(i.index, n - 1)];
+    i = C(o, (l) => G(l, e.getTime()));
+    let r = o[i.index];
+    i.index >= n && (r = o[n - 1] + this._baseDuration), this.zoomToValues(s, r, a);
+  }
+  /**
+   * Zooms the axis to specific `start` and `end` values.
+   *
+   * Optional `duration` specifies duration of zoom animation in milliseconds.
+   *
+   * @param  start     Start value
+   * @param  end       End value
+   * @param  duration  Duration in milliseconds
+   */
+  zoomToValues(t, e, a) {
+    const o = this.getPrivate("min", 0), n = this.getPrivate("max", 0);
+    t = $(t, o, n), e = $(e, o, n), this.zoom(this.valueToPosition(t), this.valueToPosition(e), a);
+  }
+  _prepareAxisItems() {
+    let t = this.getPrivate("selectionMin", 0), e = this.getPrivate("selectionMax", 0);
+    if (F(t) && F(e)) {
+      this._seriesValuesDirty && (this._seriesValuesDirty = !1, this._updateAllDates());
+      const a = this._root, o = a.utc, n = a.timezone, i = this._getDates(), s = this.get("renderer"), r = i.length, l = this._baseDuration;
+      let h = this.valueToIndex(t);
+      h > 0 && h--;
+      let c = this.valueToIndex(e);
+      c < r - 1 && c++;
+      let g = s.axisLength() / Math.max(s.get("minGridDistance"), 1 / Number.MAX_SAFE_INTEGER), u = Math.min(r, Math.ceil((c - h) / g));
+      u = Math.max(1, u), h = Math.floor(h / u) * u, this._frequency = u, X(this.dataItems, (w) => {
+        this._toggleDataItem(w, !1);
+      }), X(this.minorDataItems, (w) => {
+        this._toggleDataItem(w, !1);
+      });
+      let x = e - t - ((e - t) / l - (c - h)) * l, d = mt(0, x, g, this.get("gridIntervals"));
+      const f = this.getPrivate("baseInterval");
+      let m = H(d);
+      m < l && (d = Object.assign({}, f), m = H(d)), this.setPrivateRaw("gridInterval", d), this._intervalDuration = m;
+      const D = d.timeUnit, _ = this.get("dateFormats");
+      let Y = Date.now();
+      i[0] && (Y = i[0]);
+      let b = I(this.getPrivate("selectionMin", 0), D, d.count, a, Y);
+      const L = s.get("minorLabelsEnabled"), T = s.get("minorGridEnabled", L);
+      let v, U = 0, E;
+      T && (v = this._getMinorInterval(d), U = H(v));
+      let A = this._getIndexes(b, this.getPrivate("selectionMax", b) + m, d, this.getPrivate("min", b));
+      if (A.length > 0) {
+        let w = 0;
+        this._m = 0;
+        let q = b - m * 10;
+        const K = _t(D);
+        if (v) {
+          let z = i[A[0]];
+          this._addMinorGrid(z - m, z, U, v);
+        }
+        let ct = s.axisLength() / s.gridCount() * 0.5;
+        X(A, (z) => {
+          var Z;
+          let p;
+          this.dataItems.length < w + 1 ? (p = new et(this, void 0, {}), this._dataItems.push(p), this.processDataItem(p)) : p = this.dataItems[w];
+          let y = i[z], gt = new Date(y), S = y;
+          w < A.length - 1 ? S = i[A[w + 1]] : S += m, p.setRaw("value", y), p.setRaw("endValue", S), p.setRaw("index", w), p.setRaw("labelEndValue", void 0);
+          let tt = _[D];
+          K && this.get("markUnitChange") && F(q) && D != "year" && ut(y, q, K, o, n) && (tt = this.get("periodChangeDateFormats")[D]), this._createAssets(p, []);
+          const k = p.get("label");
+          k && k.set("text", a.dateFormatter.format(gt, tt)), this._toggleDataItem(p, !0);
+          let B = d.count;
+          if (D == "week" && p.setRaw("labelEndValue", y), T) {
+            let M = d.timeUnit;
+            if (M == "week" && (M = "day"), B > 1 || d.timeUnit == "week") {
+              let P = I(y, M, 1, a) + N(M, this._getM(M)), O = this.valueToIndex(P);
+              if (P = i[O], P == y) {
+                let V = i[O + 1];
+                V ? P = V : P += U;
+              }
+              p.setRaw("labelEndValue", P);
+            }
+            B = 1;
+          }
+          if (this._prepareDataItem(p, B), k && E && s.getPrivate("letter") == "X") {
+            let M = E.get("label");
+            if (M) {
+              let P = k.x(), O = M.x();
+              if (P - O < ct) {
+                let V = this._pickWorse(E, p, d);
+                V && ((Z = V.get("label")) === null || Z === void 0 || Z.setPrivate("visible", !1));
+              }
+            }
+          }
+          v && this._addMinorGrid(y, S, U, v), w++, k && k.getPrivate("visible") && (E = p), q = y;
+        });
+      }
+      X(this.series, (w) => {
+        w.inited && w._markDirtyAxes();
+      });
+    }
+    this._updateGhost();
+  }
+  _pickWorse(t, e, a) {
+    const o = a.timeUnit, n = t.get("value", 0), i = e.get("value", 0);
+    return o == "hour" && new Date(n).getDate() != new Date(i).getDate() ? t : e;
+  }
+  _addMinorGrid(t, e, a, o) {
+    const n = this.get("minorDateFormats", this.get("dateFormats")), i = o.timeUnit;
+    let s = t + N(i, this._getM(i));
+    s = I(s, i, 1, this._root);
+    let r = e - a * 0.5, l = this._getIndexes(s, r, o, s);
+    const h = this._getDates();
+    X(l, (c) => {
+      let g;
+      this.minorDataItems.length < this._m + 1 ? (g = new et(this, void 0, {}), this.minorDataItems.push(g), this.processDataItem(g)) : g = this.minorDataItems[this._m], s = h[c], g.setRaw("value", s), g.setRaw("endValue", s + a), g.setRaw("index", c), this._createAssets(g, ["minor"], !0);
+      const u = g.get("label");
+      if (u)
+        if (this.get("renderer").get("minorLabelsEnabled")) {
+          let x = new Date(s), d = n[i];
+          u.set("text", this._root.dateFormatter.format(x, d));
+        } else
+          u.setPrivate("visible", !1);
+      this._toggleDataItem(g, !0), this._prepareDataItem(g, 1), this._m++;
+    });
+  }
+  _getIndexes(t, e, a, o) {
+    const n = [], i = a.timeUnit, s = a.count, r = this._getM(i), l = this.getPrivate("baseInterval"), h = this._root, c = this._getDates();
+    let g = s - 1, u = -1 / 0, x = N(i, r), d = N(i, s * r), f = t;
+    for (i == "day" && (t = o); t <= e; ) {
+      t = I(t, i, s, h);
+      let m = this.valueToIndex(t), D = c[m];
+      if (i == "day" && l.timeUnit == "day")
+        this._hasDate(t) && g++, g == s && (t >= f - d * 2 && st(n, m), g = 0), t += x, t = I(t, i, 1, h);
+      else {
+        if (D < t) {
+          for (let _ = m, Y = c.length; _ < Y; _++)
+            if (D = c[_], D >= t) {
+              m = _;
+              break;
+            }
+        }
+        st(n, m), t += d, t = I(t, i, s, h);
+      }
+      if (t == u && (t += d + x, t = I(t, i, s, h)), t == u)
+        break;
+      u = t;
+    }
+    return n;
+  }
+  _hasDate(t) {
+    return C(this._getDates(), (a) => ft(a, t)).found;
+  }
+  _nextTime(t, e, a) {
+    let o = $(this.valueToIndex(t) + e, 0, this._dates.length - 1);
+    return this._dates[o];
+  }
+}
+j.className = "GaplessDateAxis";
+j.classNames = nt.classNames.concat([j.className]);
+class Q extends lt {
+  _beforeChanged() {
+    super._beforeChanged();
+    const t = this.get("sprite");
+    if (this.isDirty("sprite") && t && (t.setAll({ position: "absolute", role: "figure" }), this._disposers.push(t)), this.isDirty("location")) {
+      const e = t.dataItem;
+      this.axis && t && e && this.axis._prepareDataItem(e);
+    }
+  }
+  _dispose() {
+    const t = this.axis;
+    t && xt(t._bullets, (e, a) => {
+      a.uid == this.uid && delete t._bullets[e];
+    }), super._dispose();
+  }
+}
+Q.className = "AxisBullet";
+Q.classNames = lt.classNames.concat([Q.className]);
+class R extends ht {
+  _beforeChanged() {
+    super._beforeChanged(), (this.isDirty("lowX0") || this.isDirty("lowY0") || this.isDirty("lowX1") || this.isDirty("lowY1") || this.isDirty("highX0") || this.isDirty("highX1") || this.isDirty("highY0") || this.isDirty("highY1")) && (this._clear = !0);
+  }
+  _draw() {
+    super._draw();
+    const t = this._display;
+    t.moveTo(this.get("lowX0", 0), this.get("lowY0", 0)), t.lineTo(this.get("lowX1", 0), this.get("lowY1", 0)), t.moveTo(this.get("highX0", 0), this.get("highY0", 0)), t.lineTo(this.get("highX1", 0), this.get("highY1", 0));
+  }
+}
+R.className = "Candlestick";
+R.classNames = ht.classNames.concat([R.className]);
+class J extends rt {
+  constructor() {
+    super(...arguments), this.columns = this.addDisposer(new it(at.new({
+      themeTags: ["autocolor"]
+    }), () => R._new(this._root, {
+      themeTags: ot(this.columns.template.get("themeTags", []), ["candlestick", "series", "column"])
+    }, [this.columns.template])));
+  }
+  /**
+   * @ignore
+   */
+  makeColumn(t, e) {
+    const a = e.make();
+    return this.get("turboMode") ? a.virtualParent = this.chart : this.mainContainer.children.push(a), a._setDataItem(t), e.push(a), a;
+  }
+  _updateGraphics(t, e, a) {
+    super._updateGraphics(t, e, a);
+    const o = this.getRaw("xAxis"), n = this.getRaw("yAxis");
+    let i = this.get("vcy", 1), s = this.get("vcx", 1), r, l, h, c, g, u, x, d, f = this.get("locationX", t.get("locationX", 0.5)), m = this.get("locationY", t.get("locationY", 0.5)), D = this.get("openLocationX", t.get("openLocationX", f)), _ = this.get("openLocationY", t.get("openLocationY", m)), Y;
+    if (a == 0) {
+      let b = n.getDataItemPositionY(t, this._yOpenField, 1, i), L = n.getDataItemPositionY(t, this._yField, 1, i);
+      c = n.getDataItemPositionY(t, this._yLowField, 1, i), d = n.getDataItemPositionY(t, this._yHighField, 1, i), x = Math.max(b, L), h = Math.min(b, L);
+      let T = this._aLocationX0 + D - 0.5, v = this._aLocationX1 + f - 0.5;
+      r = o.getDataItemPositionX(t, this._xField, T + (v - T) / 2, s), l = r, g = r, u = r, Y = "vertical";
+    } else {
+      let b = o.getDataItemPositionX(t, this._xOpenField, 1, s), L = o.getDataItemPositionX(t, this._xField, 1, s);
+      l = o.getDataItemPositionX(t, this._xLowField, 1, s), u = o.getDataItemPositionX(t, this._xHighField, 1, s), g = Math.max(b, L), r = Math.min(b, L);
+      let T = this._aLocationY0 + _ - 0.5, v = this._aLocationY1 + m - 0.5;
+      h = n.getDataItemPositionY(t, this._yField, T + (v - T) / 2, i), c = h, x = h, d = h, Y = "horizontal";
+    }
+    this._updateCandleGraphics(t, r, l, h, c, g, u, x, d, Y);
+  }
+  _updateCandleGraphics(t, e, a, o, n, i, s, r, l, h) {
+    let c = t.get("graphics");
+    if (c) {
+      let g = this.getPoint(e, o), u = this.getPoint(a, n), x = this.getPoint(i, r), d = this.getPoint(s, l);
+      if (this.get("turboMode")) {
+        const f = this.allColumnsData[this.allColumnsData.length - 1];
+        f.lowX0 = g.x, f.lowY0 = g.y, f.lowX1 = u.x, f.lowY1 = u.y, f.highX0 = x.x, f.highY0 = x.y, f.highX1 = d.x, f.highY1 = d.y;
+      } else {
+        let f = c.x(), m = c.y();
+        c.set("lowX0", g.x - f), c.set("lowY0", g.y - m), c.set("lowX1", u.x - f), c.set("lowY1", u.y - m), c.set("highX0", x.x - f), c.set("highY0", x.y - m), c.set("highX1", d.x - f), c.set("highY1", d.y - m), c.set("orientation", h);
+        let D = t.get("rangeGraphics");
+        D && X(D, (_) => {
+          _.set("lowX0", g.x - f), _.set("lowY0", g.y - m), _.set("lowX1", u.x - f), _.set("lowY1", u.y - m), _.set("highX0", x.x - f), _.set("highY0", x.y - m), _.set("highX1", d.x - f), _.set("highY1", d.y - m), _.set("orientation", h);
+        });
+      }
+    }
+  }
+  _afterColumnsDraw() {
+    this.get("turboMode") && this.allColumns.set("draw", (t) => {
+      t.clear(), X(this.allColumnsData, (e) => {
+        const a = e.width, o = e.height, n = e.x, i = e.y, s = e.stroke, r = e.fill, l = e.strokeWidth, h = e.strokeOpacity, c = e.fillOpacity, g = e.lowX0, u = e.lowY0, x = e.lowX1, d = e.lowY1, f = e.highX0, m = e.highY0, D = e.highX1, _ = e.highY1;
+        t.beginFill(r, c), t.beginPath(), t.lineStyle(l, s, h), t.drawRect(n, i, a, o), t.moveTo(g, u), t.lineTo(x, d), t.moveTo(f, m), t.lineTo(D, _), t.endStroke(), t.endFill();
+      });
+    });
+  }
+  _processAxisRange(t) {
+    super._processAxisRange(t), t.columns = new it(at.new({}), () => R._new(this._root, {
+      themeTags: ot(t.columns.template.get("themeTags", []), ["candlestick", "series", "column"])
+    }, [this.columns.template, t.columns.template]));
+  }
+}
+J.className = "CandlestickSeries";
+J.classNames = rt.classNames.concat([J.className]);
+export {
+  Q as A,
+  R as C,
+  j as G,
+  J as a
+};