@mobileaction/action-kit 1.57.0 → 1.57.1

package/dist/stock-Cv-uIi1p.js

@@ -0,0 +1,2076 @@
+import { g as va } from "./index-bTz35Vhl.js";
+function ya(Ct, ee) {
+  for (var X = 0; X < ee.length; X++) {
+    const tt = ee[X];
+    if (typeof tt != "string" && !Array.isArray(tt)) {
+      for (const dt in tt)
+        if (dt !== "default" && !(dt in Ct)) {
+          const Pt = Object.getOwnPropertyDescriptor(tt, dt);
+          Pt && Object.defineProperty(Ct, dt, Pt.get ? Pt : {
+            enumerable: !0,
+            get: () => tt[dt]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(Ct, Symbol.toStringTag, { value: "Module" }));
+}
+var te = { exports: {} }, Ma = te.exports, is;
+function Aa() {
+  return is || (is = 1, function(Ct, ee) {
+    /**
+    * Highstock JS v12.5.0 (2026-01-12)
+    * @module highcharts/modules/stock
+    * @requires highcharts
+    *
+    * Highcharts Stock as a plugin for Highcharts
+    *
+    * (c) 2010-2026 Highsoft AS
+    * Author: Torstein Honsi
+    *
+    * A commercial license may be required depending on use.
+    * See www.highcharts.com/license
+    */
+    (function(X, tt) {
+      Ct.exports = tt(X._Highcharts, X._Highcharts.Point, X._Highcharts.Series, X._Highcharts.Axis, X._Highcharts.Color, X._Highcharts.SeriesRegistry, X._Highcharts.RendererRegistry, X._Highcharts.SVGRenderer, X._Highcharts.SVGElement, X._Highcharts.Templating, X._Highcharts.Chart, X._Highcharts.Series.types.column, X._Highcharts.StackItem);
+    })("u" < typeof window ? Ma : window, (X, tt, dt, Pt, os, rs, as, ns, ls, hs, ds, ps, us) => (() => {
+      let ie, se, We, oe;
+      var re, ae, ne, le, he, de, pe, ue, ce, cs = { 28: (a) => {
+        a.exports = ls;
+      }, 184: (a) => {
+        a.exports = us;
+      }, 260: (a) => {
+        a.exports = tt;
+      }, 448: (a) => {
+        a.exports = ps;
+      }, 512: (a) => {
+        a.exports = rs;
+      }, 532: (a) => {
+        a.exports = Pt;
+      }, 540: (a) => {
+        a.exports = ns;
+      }, 608: (a) => {
+        a.exports = as;
+      }, 620: (a) => {
+        a.exports = os;
+      }, 820: (a) => {
+        a.exports = dt;
+      }, 944: (a) => {
+        a.exports = X;
+      }, 960: (a) => {
+        a.exports = ds;
+      }, 984: (a) => {
+        a.exports = hs;
+      } }, Xe = {};
+      function I(a) {
+        var t = Xe[a];
+        if (t !== void 0) return t.exports;
+        var e = Xe[a] = { exports: {} };
+        return cs[a](e, e.exports, I), e.exports;
+      }
+      I.n = (a) => {
+        var t = a && a.__esModule ? () => a.default : () => a;
+        return I.d(t, { a: t }), t;
+      }, I.d = (a, t) => {
+        for (var e in t) I.o(t, e) && !I.o(a, e) && Object.defineProperty(a, e, { enumerable: !0, get: t[e] });
+      }, I.o = (a, t) => Object.prototype.hasOwnProperty.call(a, t);
+      var He = {};
+      I.d(He, { default: () => ba });
+      var gs = I(944), C = I.n(gs), fs = I(260), ms = I.n(fs), xs = I(820), Ye = I.n(xs);
+      let { tooltipFormatter: bs } = ms().prototype, { addEvent: ge, arrayMax: vs, arrayMin: ys, correctFloat: Ms, defined: Ne, isArray: As, isNumber: ks, isString: ws, pick: vt } = C();
+      (function(a) {
+        function t(l, r, n) {
+          !this.isXAxis && (this.series.forEach(function(h) {
+            l === "compare" && typeof r != "boolean" ? h.setCompare(r, !1) : l !== "cumulative" || ws(r) || h.setCumulative(r, !1);
+          }), vt(n, !0) && this.chart.redraw());
+        }
+        function e(l) {
+          let r = this, { numberFormatter: n } = r.series.chart, h = function(g) {
+            l = l.replace("{point." + g + "}", (r[g] > 0 && g === "change" ? "+" : "") + n(r[g], vt(r.series.tooltipOptions.changeDecimals, 2)));
+          };
+          return Ne(r.change) && h("change"), Ne(r.cumulativeSum) && h("cumulativeSum"), bs.apply(this, [l]);
+        }
+        function i() {
+          let l, r = this.options.linkedTo, n = this.chart;
+          if (r) {
+            let g = r === ":previous" ? n.series[this.index - 1] : n.get(r);
+            g instanceof Ye() && (this.options.compare = vt(this.userOptions.compare, g.options.compare));
+          }
+          let h = this.options.compare;
+          (h === "percent" || h === "value" || this.options.cumulative) && (l = new f(this), h === "percent" || h === "value" ? l.initCompare(h) : l.initCumulative()), this.dataModify = l;
+        }
+        function s(l) {
+          let r = l.dataExtremes, n = r.activeYData;
+          if (this.dataModify && r) {
+            let h;
+            this.options.compare ? h = [this.dataModify.modifyValue(r.dataMin), this.dataModify.modifyValue(r.dataMax)] : this.options.cumulative && As(n) && n.length >= 2 && (h = f.getCumulativeExtremes(n)), h && (r.dataMin = ys(h), r.dataMax = vs(h));
+          }
+        }
+        function o(l, r) {
+          this.options.compare = this.userOptions.compare = l, this.update({}, vt(r, !0)), this.dataModify && (l === "value" || l === "percent") ? this.dataModify.initCompare(l) : this.points.forEach((n) => {
+            delete n.change;
+          });
+        }
+        function d() {
+          let l = this.getColumn(this.pointArrayMap && (this.options.pointValKey || this.pointValKey) || "y", !0);
+          if (this.xAxis && l.length && this.dataModify) {
+            let r = this.getColumn("x", !0), n = this.dataTable.rowCount, h = +(this.options.compareStart !== !0);
+            for (let g = 0; g < n - h; g++) {
+              let m = l[g];
+              if (ks(m) && m !== 0 && r[g + h] >= (this.xAxis.min || 0)) {
+                this.dataModify.compareValue = m;
+                break;
+              }
+            }
+          }
+        }
+        function p(l, r) {
+          this.setModifier("compare", l, r);
+        }
+        function u(l, r) {
+          l = vt(l, !1), this.options.cumulative = this.userOptions.cumulative = l, this.update({}, vt(r, !0)), this.dataModify ? this.dataModify.initCumulative() : this.points.forEach((n) => {
+            delete n.cumulativeSum;
+          });
+        }
+        function c(l, r) {
+          this.setModifier("cumulative", l, r);
+        }
+        a.compose = function(l, r, n) {
+          let h = r.prototype, g = n.prototype, m = l.prototype;
+          return m.setCompare || (m.setCompare = o, m.setCumulative = u, ge(l, "afterInit", i), ge(l, "afterGetExtremes", s), ge(l, "afterProcessData", d)), h.setCompare || (h.setCompare = p, h.setModifier = t, h.setCumulative = c, g.tooltipFormatter = e), l;
+        };
+        class f {
+          constructor(r) {
+            this.series = r;
+          }
+          modifyValue() {
+            return 0;
+          }
+          static getCumulativeExtremes(r) {
+            let n = 1 / 0, h = -1 / 0;
+            return r.reduce((g, m) => {
+              let x = g + m;
+              return n = Math.min(n, x, g), h = Math.max(h, x, g), x;
+            }), [n, h];
+          }
+          initCompare(r) {
+            this.modifyValue = function(n, h) {
+              n === null && (n = 0);
+              let g = this.compareValue;
+              if (n !== void 0 && g !== void 0) {
+                if (r === "value" ? n -= g : n = n / g * 100 - 100 * (this.series.options.compareBase !== 100), h !== void 0) {
+                  let m = this.series.points[h];
+                  m && (m.change = n);
+                }
+                return n;
+              }
+              return 0;
+            };
+          }
+          initCumulative() {
+            this.modifyValue = function(r, n) {
+              if (r === null && (r = 0), r !== void 0 && n !== void 0) {
+                let h = n > 0 ? this.series.points[n - 1] : null;
+                h && h.cumulativeSum && (r = Ms(h.cumulativeSum + r));
+                let g = this.series.points[n], m = g.series.options.cumulativeStart, x = g.x <= this.series.xAxis.max && g.x >= this.series.xAxis.min;
+                return g && (!m || x ? g.cumulativeSum = r : g.cumulativeSum = void 0), r;
+              }
+              return 0;
+            };
+          }
+        }
+        a.Additions = f;
+      })(ae || (ae = {}));
+      let Ss = ae;
+      var Ts = I(532), fe = I.n(Ts);
+      let { isTouchDevice: Fe } = C(), { addEvent: yt, merge: Ue, pick: me } = C(), Es = [];
+      function Os() {
+        this.navigator && this.navigator.setBaseSeries(null, !1);
+      }
+      function Bs() {
+        let a, t, e, i = this.legend, s = this.navigator;
+        if (s) {
+          a = i && i.options, t = s.xAxis, e = s.yAxis;
+          let { scrollbarHeight: o, scrollButtonSize: d } = s;
+          this.inverted ? (s.left = s.opposite ? this.chartWidth - o - s.height : this.spacing[3] + o, s.top = this.plotTop + d) : (s.left = me(t.left, this.plotLeft + d), s.top = s.navigatorOptions.top || this.chartHeight - s.height - o - (this.scrollbar?.options.margin || 0) - this.spacing[2] - (this.rangeSelector && this.extraBottomMargin ? this.rangeSelector.getHeight() : 0) - (a && a.verticalAlign === "bottom" && a.layout !== "proximate" && a.enabled && !a.floating ? i.legendHeight + me(a.margin, 10) : 0) - (this.titleOffset ? this.titleOffset[2] : 0)), t && e && (this.inverted ? t.options.left = e.options.left = s.left : t.options.top = e.options.top = s.top, t.setAxisSize(), e.setAxisSize());
+        }
+      }
+      function Cs(a) {
+        !this.navigator && !this.scroller && (this.options.navigator.enabled || this.options.scrollbar.enabled) && (this.scroller = this.navigator = new ie(this), me(a.redraw, !0) && this.redraw(a.animation));
+      }
+      function Ps() {
+        let a = this.options;
+        (a.navigator.enabled || a.scrollbar.enabled) && (this.scroller = this.navigator = new ie(this));
+      }
+      function Ds() {
+        let a = this.options, t = a.navigator, e = a.rangeSelector;
+        if ((t && t.enabled || e && e.enabled) && (!Fe && this.zooming.type === "x" || Fe && this.zooming.pinchType === "x")) return !1;
+      }
+      function Rs(a) {
+        let t = a.navigator;
+        if (t && a.xAxis[0]) {
+          let e = a.xAxis[0].getExtremes();
+          t.render(e.min, e.max);
+        }
+      }
+      function Gs(a) {
+        let t = a.options.navigator || {}, e = a.options.scrollbar || {};
+        !this.navigator && !this.scroller && (t.enabled || e.enabled) && (Ue(!0, this.options.navigator, t), Ue(!0, this.options.scrollbar, e), delete a.options.navigator, delete a.options.scrollbar);
+      }
+      let Is = function(a, t) {
+        if (C().pushUnique(Es, a)) {
+          let e = a.prototype;
+          ie = t, e.callbacks.push(Rs), yt(a, "afterAddSeries", Os), yt(a, "afterSetChartSize", Bs), yt(a, "afterUpdate", Cs), yt(a, "beforeRender", Ps), yt(a, "beforeShowResetZoom", Ds), yt(a, "update", Gs);
+        }
+      }, { isTouchDevice: zs } = C(), { addEvent: Ve, correctFloat: _e, defined: xe, isNumber: je, pick: qe } = C();
+      function Ls() {
+        this.navigatorAxis || (this.navigatorAxis = new be(this));
+      }
+      function Ws(a) {
+        let t, e = this.chart, i = e.options, s = i.navigator, o = this.navigatorAxis, d = e.zooming.pinchType, p = i.rangeSelector, u = e.zooming.type;
+        if (this.isXAxis && (s?.enabled || p?.enabled)) {
+          if (u === "y" && a.trigger === "zoom") t = !1;
+          else if ((a.trigger === "zoom" && u === "xy" || zs && d === "xy") && this.options.range) {
+            let c = o.previousZoom;
+            xe(a.min) ? o.previousZoom = [this.min, this.max] : c && (a.min = c[0], a.max = c[1], o.previousZoom = void 0);
+          }
+        }
+        t !== void 0 && a.preventDefault();
+      }
+      class be {
+        static compose(t) {
+          t.keepProps.includes("navigatorAxis") || (t.keepProps.push("navigatorAxis"), Ve(t, "init", Ls), Ve(t, "setExtremes", Ws));
+        }
+        constructor(t) {
+          this.axis = t;
+        }
+        destroy() {
+          this.axis = void 0;
+        }
+        toFixedRange(t, e, i, s) {
+          let o = this.axis, d = (o.pointRange || 0) / 2, p = qe(i, o.translate(t, !0, !o.horiz)), u = qe(s, o.translate(e, !0, !o.horiz));
+          return xe(i) || (p = _e(p + d)), xe(s) || (u = _e(u - d)), je(p) && je(u) || (p = u = void 0), { min: p, max: u };
+        }
+      }
+      var Xs = I(620), Hs = I.n(Xs), Ys = I(512), j = I.n(Ys);
+      let { parse: Ns } = Hs(), { seriesTypes: Fs } = j(), ve = { height: 40, margin: 22, maskInside: !0, handles: { width: 7, borderRadius: 0, height: 15, symbols: ["navigator-handle", "navigator-handle"], enabled: !0, lineWidth: 1, backgroundColor: "#f2f2f2", borderColor: "#999999" }, maskFill: Ns("#667aff").setOpacity(0.3).get(), outlineColor: "#999999", outlineWidth: 1, series: { type: Fs.areaspline === void 0 ? "line" : "areaspline", fillOpacity: 0.05, lineWidth: 1, compare: null, sonification: { enabled: !1 }, dataGrouping: { approximation: "average", enabled: !0, groupPixelWidth: 2, firstAnchor: "firstPoint", anchor: "middle", lastAnchor: "lastPoint", units: [["millisecond", [1, 2, 5, 10, 20, 25, 50, 100, 200, 500]], ["second", [1, 2, 5, 10, 15, 30]], ["minute", [1, 2, 5, 10, 15, 30]], ["hour", [1, 2, 3, 4, 6, 8, 12]], ["day", [1, 2, 3, 4]], ["week", [1, 2, 3]], ["month", [1, 3, 6]], ["year", null]] }, dataLabels: { enabled: !1, zIndex: 2 }, id: "highcharts-navigator-series", className: "highcharts-navigator-series", lineColor: null, marker: { enabled: !1 }, threshold: null }, xAxis: { className: "highcharts-navigator-xaxis", tickLength: 0, lineWidth: 0, gridLineColor: "#e6e6e6", id: "navigator-x-axis", gridLineWidth: 1, tickPixelInterval: 200, labels: { align: "left", style: { color: "#000000", fontSize: "0.7em", opacity: 0.6, textOutline: "2px contrast" }, x: 3, y: -4 }, crosshair: !1 }, yAxis: { className: "highcharts-navigator-yaxis", gridLineWidth: 0, startOnTick: !1, endOnTick: !1, minPadding: 0.1, id: "navigator-y-axis", maxPadding: 0.1, labels: { enabled: !1 }, crosshair: !1, title: { text: void 0 }, tickLength: 0, tickWidth: 0 } }, { defined: wa, isNumber: Sa, pick: Ta } = C(), { relativeLength: Us } = C(), Vs = { "navigator-handle": function(a, t, e, i, s = {}) {
+        var o, d, p, u;
+        let c = s.width ? s.width / 2 : e, f = Us(s.borderRadius || 0, Math.min(2 * c, i));
+        return [["M", -1.5, (i = s.height || i) / 2 - 3.5], ["L", -1.5, i / 2 + 4.5], ["M", 0.5, i / 2 - 3.5], ["L", 0.5, i / 2 + 4.5], ...(o = -c - 1, d = 2 * c + 1, p = i, u = { r: f }, u?.r ? function(l, r, n, h, g) {
+          let m = g?.r || 0;
+          return [["M", l + m, r], ["L", l + n - m, r], ["A", m, m, 0, 0, 1, l + n, r + m], ["L", l + n, r + h - m], ["A", m, m, 0, 0, 1, l + n - m, r + h], ["L", l + m, r + h], ["A", m, m, 0, 0, 1, l, r + h - m], ["L", l, r + m], ["A", m, m, 0, 0, 1, l + m, r], ["Z"]];
+        }(o, 0.5, d, p, u) : [["M", o, 0.5], ["L", o + d, 0.5], ["L", o + d, 0.5 + p], ["L", o, 0.5 + p], ["Z"]])];
+      } };
+      var _s = I(608), Ze = I.n(_s);
+      let { defined: Ke } = C(), $e = { setFixedRange: function(a) {
+        let t = this.xAxis[0];
+        Ke(t.dataMax) && Ke(t.dataMin) && a ? this.fixedRange = Math.min(a, t.dataMax - t.dataMin) : this.fixedRange = a;
+      } }, { defaultOptions: js } = C(), { composed: qs } = C(), { getRendererType: Zs } = Ze(), { setFixedRange: Ks } = $e, { addEvent: $s, extend: Je, pushUnique: Js } = C();
+      function Qs() {
+        this.chart.navigator && !this.options.isInternal && this.chart.navigator.setBaseSeries(null, !1);
+      }
+      let to = function(a, t, e) {
+        be.compose(t), Js(qs, "Navigator") && (a.prototype.setFixedRange = Ks, Je(Zs().prototype.symbols, Vs), Je(js, { navigator: ve }), $s(e, "afterUpdate", Qs));
+      }, { composed: eo } = C(), { addEvent: Yt, correctFloat: Qe, defined: pt, pick: ti, pushUnique: io } = C();
+      (function(a) {
+        let t;
+        function e(d) {
+          let p = ti(d.options?.min, d.min), u = ti(d.options?.max, d.max);
+          return { axisMin: p, axisMax: u, scrollMin: pt(d.dataMin) ? Math.min(p, d.min ?? 1 / 0, d.dataMin, d.threshold ?? 1 / 0) : p, scrollMax: d.treeGrid?.adjustedMax ?? (pt(d.dataMax) ? Math.max(u, d.max ?? -1 / 0, d.dataMax, d.threshold ?? -1 / 0) : u) };
+        }
+        function i() {
+          let d = this.scrollbar, p = d && !d.options.opposite, u = this.horiz ? 2 : p ? 3 : 1;
+          d && (this.chart.scrollbarsOffsets = [0, 0], this.chart.axisOffset[u] += d.size + (d.options.margin || 0));
+        }
+        function s() {
+          let d = this;
+          d.options?.scrollbar?.enabled && (d.options.scrollbar.vertical = !d.horiz, d.options.startOnTick = d.options.endOnTick = !1, d.scrollbar = new t(d.chart.renderer, d.options.scrollbar, d.chart), Yt(d.scrollbar, "changed", function(p) {
+            let u, c, { axisMin: f, axisMax: l, scrollMin: r, scrollMax: n } = e(d), h = d.toPixels(r), g = d.toPixels(n) - h;
+            if (pt(f) && pt(l)) if (d.horiz && !d.reversed || !d.horiz && d.reversed ? (u = Math.min(n, d.toValue(h + g * this.to)), c = Math.max(r, d.toValue(h + g * this.from))) : (u = Math.min(n, d.toValue(h + g * (1 - this.from))), c = Math.max(r, d.toValue(h + g * (1 - this.to)))), this.shouldUpdateExtremes(p.DOMType)) {
+              let m = p.DOMType !== "mousemove" && p.DOMType !== "touchmove" && void 0;
+              d.setExtremes(Qe(c), Qe(u), !0, m, p);
+            } else this.setRange(this.from, this.to);
+          }));
+        }
+        function o() {
+          let d, p, u, { scrollMin: c, scrollMax: f } = e(this), l = this.scrollbar, r = (this.axisTitleMargin || 0) + (this.titleOffset || 0), n = this.chart.scrollbarsOffsets, h = this.options.margin || 0;
+          if (l && n) {
+            if (this.horiz) this.opposite || (n[1] += r), l.position(this.left, this.top + this.height + 2 + n[1] - (this.opposite ? h : 0), this.width, this.height), this.opposite || (n[1] += h), d = 1;
+            else {
+              let g;
+              this.opposite && (n[0] += r), g = l.options.opposite ? this.left + this.width + 2 + n[0] - (this.opposite ? 0 : h) : this.opposite ? 0 : h, l.position(g, this.top, this.width, this.height), this.opposite && (n[0] += h), d = 0;
+            }
+            if (n[d] += l.size + (l.options.margin || 0), isNaN(c) || isNaN(f) || !pt(this.min) || !pt(this.max) || pt(this.dataMin) && this.dataMin === this.dataMax) l.setRange(0, 1);
+            else if (this.min === this.max) {
+              let g = this.pointRange / (this.dataMax + 1);
+              p = g * this.min, u = g * (this.max + 1), l.setRange(p, u);
+            } else p = (this.toPixels(this.min) - this.toPixels(c)) / (this.toPixels(f) - this.toPixels(c)), u = (this.toPixels(this.max) - this.toPixels(c)) / (this.toPixels(f) - this.toPixels(c)), this.horiz && !this.reversed || !this.horiz && this.reversed ? l.setRange(p, u) : l.setRange(1 - u, 1 - p);
+          }
+        }
+        a.compose = function(d, p) {
+          io(eo, "Axis.Scrollbar") && (t = p, Yt(d, "afterGetOffset", i), Yt(d, "afterInit", s), Yt(d, "afterRender", o));
+        };
+      })(ne || (ne = {}));
+      let so = ne, Nt = { height: 10, barBorderRadius: 5, buttonBorderRadius: 0, buttonsEnabled: !1, liveRedraw: void 0, margin: void 0, minWidth: 6, opposite: !0, step: 0.2, zIndex: 3, barBackgroundColor: "#cccccc", barBorderWidth: 0, barBorderColor: "#cccccc", buttonArrowColor: "#333333", buttonBackgroundColor: "#e6e6e6", buttonBorderColor: "#cccccc", buttonBorderWidth: 1, rifleColor: "none", trackBackgroundColor: "rgba(255, 255, 255, 0.001)", trackBorderColor: "#cccccc", trackBorderRadius: 5, trackBorderWidth: 1 }, { defaultOptions: ei } = C(), { composed: oo } = C(), { addEvent: ro, correctFloat: ut, crisp: Ft, defined: ii, destroyObjectProperties: ao, extend: no, fireEvent: Dt, merge: si, pick: Rt, pushUnique: lo, removeEvent: ho } = C();
+      class ct {
+        static compose(t) {
+          so.compose(t, ct), lo(oo, "Scrollbar") && no(ei, { scrollbar: Nt });
+        }
+        static swapXY(t, e) {
+          return e && t.forEach((i) => {
+            let s, o = i.length;
+            for (let d = 0; d < o; d += 2) typeof (s = i[d + 1]) == "number" && (i[d + 1] = i[d + 2], i[d + 2] = s);
+          }), t;
+        }
+        constructor(t, e, i) {
+          this._events = [], this.chartX = 0, this.chartY = 0, this.from = 0, this.scrollbarButtons = [], this.scrollbarLeft = 0, this.scrollbarStrokeWidth = 1, this.scrollbarTop = 0, this.size = 0, this.to = 0, this.trackBorderWidth = 1, this.x = 0, this.y = 0, this.init(t, e, i);
+        }
+        addEvents() {
+          let t = this.options.inverted ? [1, 0] : [0, 1], e = this.scrollbarButtons, i = this.scrollbarGroup.element, s = this.track.element, o = this.mouseDownHandler.bind(this), d = this.mouseMoveHandler.bind(this), p = this.mouseUpHandler.bind(this), u = [[e[t[0]].element, "click", this.buttonToMinClick.bind(this)], [e[t[1]].element, "click", this.buttonToMaxClick.bind(this)], [s, "click", this.trackClick.bind(this)], [i, "mousedown", o], [i.ownerDocument, "mousemove", d], [i.ownerDocument, "mouseup", p], [i, "touchstart", o], [i.ownerDocument, "touchmove", d], [i.ownerDocument, "touchend", p]];
+          u.forEach(function(c) {
+            ro.apply(null, c);
+          }), this._events = u;
+        }
+        buttonToMaxClick(t) {
+          let e = (this.to - this.from) * Rt(this.options.step, 0.2);
+          this.updatePosition(this.from + e, this.to + e), Dt(this, "changed", { from: this.from, to: this.to, trigger: "scrollbar", DOMEvent: t });
+        }
+        buttonToMinClick(t) {
+          let e = ut(this.to - this.from) * Rt(this.options.step, 0.2);
+          this.updatePosition(ut(this.from - e), ut(this.to - e)), Dt(this, "changed", { from: this.from, to: this.to, trigger: "scrollbar", DOMEvent: t });
+        }
+        cursorToScrollbarPosition(t) {
+          let e = this.options, i = e.minWidth > this.calculatedWidth ? e.minWidth : 0;
+          return { chartX: (t.chartX - this.x - this.xOffset) / (this.barWidth - i), chartY: (t.chartY - this.y - this.yOffset) / (this.barWidth - i) };
+        }
+        destroy() {
+          let t = this, e = t.chart.scroller;
+          t.removeEvents(), ["track", "scrollbarRifles", "scrollbar", "scrollbarGroup", "group"].forEach(function(i) {
+            t[i] && t[i].destroy && (t[i] = t[i].destroy());
+          }), e && t === e.scrollbar && (e.scrollbar = null, ao(e.scrollbarButtons));
+        }
+        drawScrollbarButton(t) {
+          let e = this.renderer, i = this.scrollbarButtons, s = this.options, o = this.size, d = e.g().add(this.group);
+          if (i.push(d), s.buttonsEnabled) {
+            let p = e.rect().addClass("highcharts-scrollbar-button").add(d);
+            this.chart.styledMode || p.attr({ stroke: s.buttonBorderColor, "stroke-width": s.buttonBorderWidth, fill: s.buttonBackgroundColor }), p.attr(p.crisp({ x: -0.5, y: -0.5, width: o, height: o, r: s.buttonBorderRadius }, p.strokeWidth()));
+            let u = e.path(ct.swapXY([["M", o / 2 + (t ? -1 : 1), o / 2 - 3], ["L", o / 2 + (t ? -1 : 1), o / 2 + 3], ["L", o / 2 + (t ? 2 : -2), o / 2]], s.vertical)).addClass("highcharts-scrollbar-arrow").add(i[t]);
+            this.chart.styledMode || u.attr({ fill: s.buttonArrowColor });
+          }
+        }
+        init(t, e, i) {
+          this.scrollbarButtons = [], this.renderer = t, this.userOptions = e, this.options = si(Nt, ei.scrollbar, e), this.options.margin = Rt(this.options.margin, 10), this.chart = i, this.size = Rt(this.options.size, this.options.height), e.enabled && (this.render(), this.addEvents());
+        }
+        mouseDownHandler(t) {
+          let e = this.chart.pointer?.normalize(t) || t, i = this.cursorToScrollbarPosition(e);
+          this.chartX = i.chartX, this.chartY = i.chartY, this.initPositions = [this.from, this.to], this.grabbedCenter = !0;
+        }
+        mouseMoveHandler(t) {
+          let e, i = this.chart.pointer?.normalize(t) || t, s = this.options.vertical ? "chartY" : "chartX", o = this.initPositions || [];
+          this.grabbedCenter && (!t.touches || t.touches[0][s] !== 0) && (e = this.cursorToScrollbarPosition(i)[s] - this[s], this.hasDragged = !0, this.updatePosition(o[0] + e, o[1] + e), this.hasDragged && Dt(this, "changed", { from: this.from, to: this.to, trigger: "scrollbar", DOMType: t.type, DOMEvent: t }));
+        }
+        mouseUpHandler(t) {
+          this.hasDragged && Dt(this, "changed", { from: this.from, to: this.to, trigger: "scrollbar", DOMType: t.type, DOMEvent: t }), this.grabbedCenter = this.hasDragged = this.chartX = this.chartY = null;
+        }
+        position(t, e, i, s) {
+          let { buttonsEnabled: o, margin: d = 0, vertical: p } = this.options, u = this.rendered ? "animate" : "attr", c = s, f = 0;
+          this.group.show(), this.x = t, this.y = e + this.trackBorderWidth, this.width = i, this.height = s, this.xOffset = c, this.yOffset = f, p ? (this.width = this.yOffset = i = f = this.size, this.xOffset = c = 0, this.yOffset = f = o ? this.size : 0, this.barWidth = s - (o ? 2 * i : 0), this.x = t += d) : (this.height = s = this.size, this.xOffset = c = o ? this.size : 0, this.barWidth = i - (o ? 2 * s : 0), this.y = this.y + d), this.group[u]({ translateX: t, translateY: this.y }), this.track[u]({ width: i, height: s }), this.scrollbarButtons[1][u]({ translateX: p ? 0 : i - c, translateY: p ? s - f : 0 });
+        }
+        removeEvents() {
+          this._events.forEach(function(t) {
+            ho.apply(null, t);
+          }), this._events.length = 0;
+        }
+        render() {
+          let t = this.renderer, e = this.options, i = this.size, s = this.chart.styledMode, o = t.g("scrollbar").attr({ zIndex: e.zIndex }).hide().add();
+          this.group = o, this.track = t.rect().addClass("highcharts-scrollbar-track").attr({ r: e.trackBorderRadius || 0, height: i, width: i }).add(o), s || this.track.attr({ fill: e.trackBackgroundColor, stroke: e.trackBorderColor, "stroke-width": e.trackBorderWidth });
+          let d = this.trackBorderWidth = this.track.strokeWidth();
+          this.track.attr({ x: -Ft(0, d), y: -Ft(0, d) }), this.scrollbarGroup = t.g().add(o), this.scrollbar = t.rect().addClass("highcharts-scrollbar-thumb").attr({ height: i - d, width: i - d, r: e.barBorderRadius || 0 }).add(this.scrollbarGroup), this.scrollbarRifles = t.path(ct.swapXY([["M", -3, i / 4], ["L", -3, 2 * i / 3], ["M", 0, i / 4], ["L", 0, 2 * i / 3], ["M", 3, i / 4], ["L", 3, 2 * i / 3]], e.vertical)).addClass("highcharts-scrollbar-rifles").add(this.scrollbarGroup), s || (this.scrollbar.attr({ fill: e.barBackgroundColor, stroke: e.barBorderColor, "stroke-width": e.barBorderWidth }), this.scrollbarRifles.attr({ stroke: e.rifleColor, "stroke-width": 1 })), this.scrollbarStrokeWidth = this.scrollbar.strokeWidth(), this.scrollbarGroup.translate(-Ft(0, this.scrollbarStrokeWidth), -Ft(0, this.scrollbarStrokeWidth)), this.drawScrollbarButton(0), this.drawScrollbarButton(1);
+        }
+        setRange(t, e) {
+          let i, s, o = this.options, d = o.vertical, p = o.minWidth, u = this.barWidth, c = !this.rendered || this.hasDragged || this.chart.navigator && this.chart.navigator.hasDragged ? "attr" : "animate";
+          if (!ii(u)) return;
+          let f = u * Math.min(e, 1);
+          i = Math.ceil(u * (t = Math.max(t, 0))), this.calculatedWidth = s = ut(f - i), s < p && (i = (u - p + s) * t, s = p);
+          let l = Math.floor(i + this.xOffset + this.yOffset), r = s / 2 - 0.5;
+          this.from = t, this.to = e, d ? (this.scrollbarGroup[c]({ translateY: l }), this.scrollbar[c]({ height: s }), this.scrollbarRifles[c]({ translateY: r }), this.scrollbarTop = l, this.scrollbarLeft = 0) : (this.scrollbarGroup[c]({ translateX: l }), this.scrollbar[c]({ width: s }), this.scrollbarRifles[c]({ translateX: r }), this.scrollbarLeft = l, this.scrollbarTop = 0), s <= 12 ? this.scrollbarRifles.hide() : this.scrollbarRifles.show(), o.showFull === !1 && (t <= 0 && e >= 1 ? this.group.hide() : this.group.show()), this.rendered = !0;
+        }
+        shouldUpdateExtremes(t) {
+          return Rt(this.options.liveRedraw, C().svg && !C().isTouchDevice && !this.chart.boosted) || t === "mouseup" || t === "touchend" || !ii(t);
+        }
+        trackClick(t) {
+          let e = this.chart.pointer?.normalize(t) || t, i = this.to - this.from, s = this.y + this.scrollbarTop, o = this.x + this.scrollbarLeft;
+          this.options.vertical && e.chartY > s || !this.options.vertical && e.chartX > o ? this.updatePosition(this.from + i, this.to + i) : this.updatePosition(this.from - i, this.to - i), Dt(this, "changed", { from: this.from, to: this.to, trigger: "scrollbar", DOMEvent: t });
+        }
+        update(t) {
+          this.destroy(), this.init(this.chart.renderer, si(!0, this.options, t), this.chart);
+        }
+        updatePosition(t, e) {
+          e > 1 && (t = ut(1 - ut(e - t)), e = 1), t < 0 && (e = ut(e - t), t = 0), this.from = t, this.to = e;
+        }
+      }
+      ct.defaultOptions = Nt;
+      var po = I(540), uo = I.n(po);
+      let { defaultOptions: ye } = C(), { isTouchDevice: co } = C(), { prototype: { symbols: oi } } = uo(), { addEvent: Y, clamp: ri, correctFloat: Ut, defined: Mt, destroyObjectProperties: go, erase: At, extend: fo, find: mo, fireEvent: Me, isArray: ai, isNumber: K, merge: kt, pick: q, removeEvent: Vt, splat: ni } = C();
+      function _t(a, ...t) {
+        let e = [].filter.call(t, K);
+        if (e.length) return Math[a].apply(0, e);
+      }
+      class jt {
+        static compose(t, e, i) {
+          Is(t, jt), to(t, e, i);
+        }
+        constructor(t) {
+          this.isDirty = !1, this.scrollbarHeight = 0, this.init(t);
+        }
+        drawHandle(t, e, i, s) {
+          let o = this.navigatorOptions.handles.height;
+          this.handles[e][s](i ? { translateX: Math.round(this.left + this.height / 2), translateY: Math.round(this.top + parseInt(t, 10) + 0.5 - o) } : { translateX: Math.round(this.left + parseInt(t, 10)), translateY: Math.round(this.top + this.height / 2 - o / 2 - 1) });
+        }
+        drawOutline(t, e, i, s) {
+          let o = this.navigatorOptions.maskInside, d = this.outline.strokeWidth(), p = d / 2, u = d % 2 / 2, c = this.scrollButtonSize, f = this.size, l = this.top, r = this.height, n = l - p, h = l + r, g = this.left, m, x;
+          i ? (m = l + e + u, e = l + t + u, x = [["M", g + r, l - c - u], ["L", g + r, m], ["L", g, m], ["M", g, e], ["L", g + r, e], ["L", g + r, l + f + c]], o && x.push(["M", g + r, m - p], ["L", g + r, e + p])) : (g -= c, t += g + c - u, e += g + c - u, x = [["M", g, n], ["L", t, n], ["L", t, h], ["M", e, h], ["L", e, n], ["L", g + f + 2 * c, n]], o && x.push(["M", t - p, n], ["L", e + p, n])), this.outline[s]({ d: x });
+        }
+        drawMasks(t, e, i, s) {
+          let o, d, p, u, c = this.left, f = this.top, l = this.height;
+          i ? (p = [c, c, c], u = [f, f + t, f + e], d = [l, l, l], o = [t, e - t, this.size - e]) : (p = [c, c + t, c + e], u = [f, f, f], d = [t, e - t, this.size - e], o = [l, l, l]), this.shades.forEach((r, n) => {
+            r[s]({ x: p[n], y: u[n], width: d[n], height: o[n] });
+          });
+        }
+        renderElements() {
+          let t = this, e = t.navigatorOptions, i = e.maskInside, s = t.chart, o = s.inverted, d = s.renderer, p = { cursor: o ? "ns-resize" : "ew-resize" }, u = t.navigatorGroup ?? (t.navigatorGroup = d.g("navigator").attr({ zIndex: 8, visibility: "hidden" }).add());
+          if ([!i, i, !i].forEach((c, f) => {
+            let l = t.shades[f] ?? (t.shades[f] = d.rect().addClass("highcharts-navigator-mask" + (f === 1 ? "-inside" : "-outside")).add(u));
+            s.styledMode || (l.attr({ fill: c ? e.maskFill : "rgba(0,0,0,0)" }), f === 1 && l.css(p));
+          }), t.outline || (t.outline = d.path().addClass("highcharts-navigator-outline").add(u)), s.styledMode || t.outline.attr({ "stroke-width": e.outlineWidth, stroke: e.outlineColor }), e.handles?.enabled) {
+            let c = e.handles, { height: f, width: l } = c;
+            [0, 1].forEach((r) => {
+              let n = c.symbols[r];
+              if (t.handles[r] && t.handles[r].symbolUrl === n) {
+                if (!t.handles[r].isImg && t.handles[r].symbolName !== n) {
+                  let h = oi[n].call(oi, -l / 2 - 1, 0, l, f);
+                  t.handles[r].attr({ d: h }), t.handles[r].symbolName = n;
+                }
+              } else t.handles[r]?.destroy(), t.handles[r] = d.symbol(n, -l / 2 - 1, 0, l, f, c), t.handles[r].attr({ zIndex: 7 - r }).addClass("highcharts-navigator-handle highcharts-navigator-handle-" + ["left", "right"][r]).add(u), t.addMouseEvents();
+              s.inverted && t.handles[r].attr({ rotation: 90, rotationOriginX: Math.floor(-l / 2), rotationOriginY: (f + l) / 2 }), s.styledMode || t.handles[r].attr({ fill: c.backgroundColor, stroke: c.borderColor, "stroke-width": c.lineWidth, width: c.width, height: c.height, x: -l / 2 - 1, y: 0 }).css(p);
+            });
+          }
+        }
+        update(t, e = !1) {
+          let i = this.chart, s = i.options.chart.inverted !== i.scrollbar?.options.vertical;
+          if (kt(!0, i.options.navigator, t), this.navigatorOptions = i.options.navigator || {}, this.setOpposite(), Mt(t.enabled) || s) return this.destroy(), this.navigatorEnabled = t.enabled || this.navigatorEnabled, this.init(i);
+          if (this.navigatorEnabled && (this.isDirty = !0, t.adaptToUpdatedData === !1 && this.baseSeries.forEach((o) => {
+            Vt(o, "updatedData", this.updatedDataHandler);
+          }, this), t.adaptToUpdatedData && this.baseSeries.forEach((o) => {
+            o.eventsToUnbind.push(Y(o, "updatedData", this.updatedDataHandler));
+          }, this), (t.series || t.baseSeries) && this.setBaseSeries(void 0, !1), t.height || t.xAxis || t.yAxis)) {
+            this.height = t.height ?? this.height;
+            let o = this.getXAxisOffsets();
+            this.xAxis.update({ ...t.xAxis, offsets: o, [i.inverted ? "width" : "height"]: this.height, [i.inverted ? "height" : "width"]: void 0 }, !1), this.yAxis.update({ ...t.yAxis, [i.inverted ? "width" : "height"]: this.height }, !1);
+          }
+          e && i.redraw();
+        }
+        render(t, e, i, s) {
+          let o = this.chart, d = this.xAxis, p = d.pointRange || 0, u = d.navigatorAxis.fake ? o.xAxis[0] : d, c = this.navigatorEnabled, f = this.rendered, l = o.inverted, r = o.xAxis[0].minRange, n = o.xAxis[0].options.maxRange, h = this.scrollButtonSize, g, m, x, b = this.scrollbarHeight, A, y;
+          if (this.hasDragged && !Mt(i)) return;
+          if (this.isDirty && this.renderElements(), t = Ut(t - p / 2), e = Ut(e + p / 2), !K(t) || !K(e)) if (f) i = 0, s = q(d.width, u.width);
+          else return;
+          this.left = q(d.left, o.plotLeft + h + (l ? o.plotWidth : 0));
+          let k = this.size = A = q(d.len, (l ? o.plotHeight : o.plotWidth) - 2 * h);
+          g = l ? b : A + 2 * h, i = q(i, d.toPixels(t, !0)), s = q(s, d.toPixels(e, !0)), K(i) && Math.abs(i) !== 1 / 0 || (i = 0, s = g);
+          let M = d.toValue(i, !0), v = d.toValue(s, !0), S = Math.abs(Ut(v - M));
+          S < r ? this.grabbedLeft ? i = d.toPixels(v - r - p, !0) : this.grabbedRight && (s = d.toPixels(M + r + p, !0)) : Mt(n) && Ut(S - p) > n && (this.grabbedLeft ? i = d.toPixels(v - n - p, !0) : this.grabbedRight && (s = d.toPixels(M + n + p, !0))), this.zoomedMax = ri(Math.max(i, s), 0, k), this.zoomedMin = ri(this.fixedWidth ? this.zoomedMax - this.fixedWidth : Math.min(i, s), 0, k), this.range = this.zoomedMax - this.zoomedMin, k = Math.round(this.zoomedMax);
+          let T = Math.round(this.zoomedMin);
+          c && (this.navigatorGroup.attr({ visibility: "inherit" }), y = f && !this.hasDragged ? "animate" : "attr", this.drawMasks(T, k, l, y), this.drawOutline(T, k, l, y), this.navigatorOptions.handles.enabled && (this.drawHandle(T, 0, l, y), this.drawHandle(k, 1, l, y))), this.scrollbar && (l ? (x = this.top - h, m = this.left - b + (c || !u.opposite ? 0 : (u.titleOffset || 0) + u.axisTitleMargin), b = A + 2 * h) : (x = this.top + (c ? this.height : -b), m = this.left - h), this.scrollbar.position(m, x, g, b), this.scrollbar.setRange(this.zoomedMin / (A || 1), this.zoomedMax / (A || 1))), this.rendered = !0, this.isDirty = !1, Me(this, "afterRender");
+        }
+        addMouseEvents() {
+          let t = this, e = t.chart, i = e.container, s = [], o, d;
+          t.mouseMoveHandler = o = function(p) {
+            t.onMouseMove(p);
+          }, t.mouseUpHandler = d = function(p) {
+            t.onMouseUp(p);
+          }, (s = t.getPartsEvents("mousedown")).push(Y(e.renderTo, "mousemove", o), Y(i.ownerDocument, "mouseup", d), Y(e.renderTo, "touchmove", o), Y(i.ownerDocument, "touchend", d)), s.concat(t.getPartsEvents("touchstart")), t.eventsToUnbind = s, t.series && t.series[0] && s.push(Y(t.series[0].xAxis, "foundExtremes", function() {
+            e.navigator.modifyNavigatorAxisExtremes();
+          }));
+        }
+        getPartsEvents(t) {
+          let e = this, i = [];
+          return ["shades", "handles"].forEach(function(s) {
+            e[s].forEach(function(o, d) {
+              i.push(Y(o.element, t, function(p) {
+                e[s + "Mousedown"](p, d);
+              }));
+            });
+          }), i;
+        }
+        shadesMousedown(t, e) {
+          t = this.chart.pointer?.normalize(t) || t;
+          let i = this.chart, s = this.xAxis, o = this.zoomedMin, d = this.size, p = this.range, u = this.left, c = t.chartX, f, l, r, n;
+          i.inverted && (c = t.chartY, u = this.top), e === 1 ? (this.grabbedCenter = c, this.fixedWidth = p, this.dragOffset = c - o) : (n = c - u - p / 2, e === 0 ? n = Math.max(0, n) : e === 2 && n + p >= d && (n = d - p, this.reversedExtremes ? (n -= p, l = this.getUnionExtremes().dataMin) : f = this.getUnionExtremes().dataMax), n !== o && (this.fixedWidth = p, Mt((r = s.navigatorAxis.toFixedRange(n, n + p, l, f)).min) && Me(this, "setRange", { min: Math.min(r.min, r.max), max: Math.max(r.min, r.max), redraw: !0, eventArguments: { trigger: "navigator" } })));
+        }
+        handlesMousedown(t, e) {
+          t = this.chart.pointer?.normalize(t) || t;
+          let i = this.chart, s = i.xAxis[0], o = this.reversedExtremes;
+          e === 0 ? (this.grabbedLeft = !0, this.otherHandlePos = this.zoomedMax, this.fixedExtreme = o ? s.min : s.max) : (this.grabbedRight = !0, this.otherHandlePos = this.zoomedMin, this.fixedExtreme = o ? s.max : s.min), i.setFixedRange(void 0);
+        }
+        onMouseMove(t) {
+          let e = this, i = e.chart, s = e.navigatorSize, o = e.range, d = e.dragOffset, p = i.inverted, u = e.left, c;
+          (!t.touches || t.touches[0].pageX !== 0) && (c = (t = i.pointer?.normalize(t) || t).chartX, p && (u = e.top, c = t.chartY), e.grabbedLeft ? (e.hasDragged = !0, e.render(0, 0, c - u, e.otherHandlePos)) : e.grabbedRight ? (e.hasDragged = !0, e.render(0, 0, e.otherHandlePos, c - u)) : e.grabbedCenter && (e.hasDragged = !0, c < d ? c = d : c > s + d - o && (c = s + d - o), e.render(0, 0, c - d, c - d + o)), e.hasDragged && e.scrollbar && q(e.scrollbar.options.liveRedraw, !co && !this.chart.boosted) && (t.DOMType = t.type, setTimeout(function() {
+            e.onMouseUp(t);
+          }, 0)));
+        }
+        onMouseUp(t) {
+          let e, i, s, o, d, p, u = this.chart, c = this.xAxis, f = this.scrollbar, l = t.DOMEvent || t, r = u.inverted, n = this.rendered && !this.hasDragged ? "animate" : "attr";
+          (this.hasDragged && (!f || !f.hasDragged) || t.trigger === "scrollbar") && (s = this.getUnionExtremes(), this.zoomedMin === this.otherHandlePos ? o = this.fixedExtreme : this.zoomedMax === this.otherHandlePos && (d = this.fixedExtreme), this.zoomedMax === this.size && (d = this.reversedExtremes ? s.dataMin : s.dataMax), this.zoomedMin === 0 && (o = this.reversedExtremes ? s.dataMax : s.dataMin), Mt((p = c.navigatorAxis.toFixedRange(this.zoomedMin, this.zoomedMax, o, d)).min) && Me(this, "setRange", { min: Math.min(p.min, p.max), max: Math.max(p.min, p.max), redraw: !0, animation: !this.hasDragged && null, eventArguments: { trigger: "navigator", triggerOp: "navigator-drag", DOMEvent: l } })), t.DOMType !== "mousemove" && t.DOMType !== "touchmove" && (this.grabbedLeft = this.grabbedRight = this.grabbedCenter = this.fixedWidth = this.fixedExtreme = this.otherHandlePos = this.hasDragged = this.dragOffset = null), this.navigatorEnabled && K(this.zoomedMin) && K(this.zoomedMax) && (i = Math.round(this.zoomedMin), e = Math.round(this.zoomedMax), this.shades && this.drawMasks(i, e, r, n), this.outline && this.drawOutline(i, e, r, n), this.navigatorOptions.handles.enabled && Object.keys(this.handles).length === this.handles.length && (this.drawHandle(i, 0, r, n), this.drawHandle(e, 1, r, n)));
+        }
+        removeEvents() {
+          this.eventsToUnbind && (this.eventsToUnbind.forEach(function(t) {
+            t();
+          }), this.eventsToUnbind = void 0), this.removeBaseSeriesEvents();
+        }
+        removeBaseSeriesEvents() {
+          let t = this.baseSeries || [];
+          this.navigatorEnabled && t[0] && (this.navigatorOptions.adaptToUpdatedData !== !1 && t.forEach(function(e) {
+            Vt(e, "updatedData", this.updatedDataHandler);
+          }, this), t[0].xAxis && Vt(t[0].xAxis, "foundExtremes", this.modifyBaseAxisExtremes));
+        }
+        getXAxisOffsets() {
+          return this.chart.inverted ? [this.scrollButtonSize, 0, -this.scrollButtonSize, 0] : [0, -this.scrollButtonSize, 0, this.scrollButtonSize];
+        }
+        init(t) {
+          let e = t.options, i = e.navigator || {}, s = i.enabled, o = e.scrollbar || {}, d = o.enabled, p = s && i.height || 0, u = d && o.height || 0, c = o.buttonsEnabled && u || 0;
+          this.handles = [], this.shades = [], this.chart = t, this.setBaseSeries(), this.height = p, this.scrollbarHeight = u, this.scrollButtonSize = c, this.scrollbarEnabled = d, this.navigatorEnabled = s, this.navigatorOptions = i, this.scrollbarOptions = o, this.setOpposite();
+          let f = this, l = f.baseSeries, r = t.xAxis.length, n = t.yAxis.length, h = l && l[0] && l[0].xAxis || t.xAxis[0] || { options: {} };
+          if (t.isDirtyBox = !0, f.navigatorEnabled) {
+            let g = this.getXAxisOffsets();
+            f.xAxis = new (fe())(t, kt({ breaks: h.options.breaks, ordinal: h.options.ordinal, overscroll: h.options.overscroll }, i.xAxis, { type: "datetime", yAxis: i.yAxis?.id, index: r, isInternal: !0, offset: 0, keepOrdinalPadding: !0, startOnTick: !1, endOnTick: !1, minPadding: h.options.ordinal ? 0 : h.options.minPadding, maxPadding: h.options.ordinal ? 0 : h.options.maxPadding, zoomEnabled: !1 }, t.inverted ? { offsets: g, width: p } : { offsets: g, height: p }), "xAxis"), f.yAxis = new (fe())(t, kt(i.yAxis, { alignTicks: !1, offset: 0, index: n, isInternal: !0, reversed: q(i.yAxis && i.yAxis.reversed, t.yAxis[0] && t.yAxis[0].reversed, !1), zoomEnabled: !1 }, t.inverted ? { width: p } : { height: p }), "yAxis"), l || i.series.data ? f.updateNavigatorSeries(!1) : t.series.length === 0 && (f.unbindRedraw = Y(t, "beforeRedraw", function() {
+              t.series.length > 0 && !f.series && (f.setBaseSeries(), f.unbindRedraw());
+            })), f.reversedExtremes = t.inverted && !f.xAxis.reversed || !t.inverted && f.xAxis.reversed, f.renderElements(), f.addMouseEvents();
+          } else f.xAxis = { chart: t, navigatorAxis: { fake: !0 }, translate: function(g, m) {
+            let x = t.xAxis[0], b = x.getExtremes(), A = x.len - 2 * c, y = _t("min", x.options.min, b.dataMin), k = _t("max", x.options.max, b.dataMax) - y;
+            return m ? g * k / A + y : A * (g - y) / k;
+          }, toPixels: function(g) {
+            return this.translate(g);
+          }, toValue: function(g) {
+            return this.translate(g, !0);
+          } }, f.xAxis.navigatorAxis.axis = f.xAxis, f.xAxis.navigatorAxis.toFixedRange = be.prototype.toFixedRange.bind(f.xAxis.navigatorAxis);
+          if (t.options.scrollbar?.enabled) {
+            let g = kt(t.options.scrollbar, { vertical: t.inverted });
+            K(g.margin) || (g.margin = t.inverted ? -3 : 3), t.scrollbar = f.scrollbar = new ct(t.renderer, g, t), Y(f.scrollbar, "changed", function(m) {
+              let x = f.size, b = x * this.to, A = x * this.from;
+              f.hasDragged = f.scrollbar.hasDragged, f.render(0, 0, A, b), this.shouldUpdateExtremes(m.DOMType) && setTimeout(function() {
+                f.onMouseUp(m);
+              });
+            });
+          }
+          f.addBaseSeriesEvents(), f.addChartEvents();
+        }
+        setOpposite() {
+          let t = this.navigatorOptions, e = this.navigatorEnabled, i = this.chart;
+          this.opposite = q(t.opposite, !!(!e && i.inverted));
+        }
+        getUnionExtremes(t) {
+          let e, i = this.chart.xAxis[0], s = this.chart.time, o = this.xAxis, d = o.options, p = i.options;
+          return t && i.dataMin === null || (e = { dataMin: q(s.parse(d?.min), _t("min", s.parse(p.min), i.dataMin, o.dataMin, o.min)), dataMax: q(s.parse(d?.max), _t("max", s.parse(p.max), i.dataMax, o.dataMax, o.max)) }), e;
+        }
+        setBaseSeries(t, e) {
+          let i = this.chart, s = this.baseSeries = [];
+          t = t || i.options && i.options.navigator.baseSeries || (i.series.length ? mo(i.series, (o) => !o.options.isInternal).index : 0), (i.series || []).forEach((o, d) => {
+            !o.options.isInternal && (o.options.showInNavigator || (d === t || o.options.id === t) && o.options.showInNavigator !== !1) && s.push(o);
+          }), this.xAxis && !this.xAxis.navigatorAxis.fake && this.updateNavigatorSeries(!0, e);
+        }
+        updateNavigatorSeries(t, e) {
+          let i = this, s = i.chart, o = i.baseSeries, d = { enableMouseTracking: !1, index: null, linkedTo: null, group: "nav", padXAxis: !1, xAxis: this.navigatorOptions.xAxis?.id, yAxis: this.navigatorOptions.yAxis?.id, showInLegend: !1, stacking: void 0, isInternal: !0, states: { inactive: { opacity: 1 } } }, p = i.series = (i.series || []).filter((r) => {
+            let n = r.baseSeries;
+            return !(0 > o.indexOf(n)) || (n && (Vt(n, "updatedData", i.updatedDataHandler), delete n.navigatorSeries), r.chart && r.destroy(), !1);
+          }), u, c, f = i.navigatorOptions.series, l;
+          o && o.length && o.forEach((r) => {
+            let n = r.navigatorSeries, h = fo({ color: r.color, visible: r.visible }, ai(f) ? ye.navigator.series : f);
+            if (n && i.navigatorOptions.adaptToUpdatedData === !1) return;
+            d.name = "Navigator " + o.length, l = (u = r.options || {}).navigatorOptions || {}, h.dataLabels = ni(h.dataLabels), (c = kt(u, d, h, l)).pointRange = q(h.pointRange, l.pointRange, ye.plotOptions[c.type || "line"].pointRange);
+            let g = l.data || h.data;
+            i.hasNavigatorData = i.hasNavigatorData || !!g, c.data = g || u.data?.slice(0), n && n.options ? n.update(c, e) : (r.navigatorSeries = s.initSeries(c), s.setSortedData(), r.navigatorSeries.baseSeries = r, p.push(r.navigatorSeries));
+          }), (f.data && !(o && o.length) || ai(f)) && (i.hasNavigatorData = !1, (f = ni(f)).forEach((r, n) => {
+            d.name = "Navigator " + (p.length + 1), (c = kt(ye.navigator.series, { color: s.series[n] && !s.series[n].options.isInternal && s.series[n].color || s.options.colors[n] || s.options.colors[0] }, d, r)).data = r.data, c.data && (i.hasNavigatorData = !0, p.push(s.initSeries(c)));
+          })), t && this.addBaseSeriesEvents();
+        }
+        addBaseSeriesEvents() {
+          let t = this, e = t.baseSeries || [];
+          e[0] && e[0].xAxis && e[0].eventsToUnbind.push(Y(e[0].xAxis, "foundExtremes", this.modifyBaseAxisExtremes)), e.forEach((i) => {
+            i.eventsToUnbind.push(Y(i, "show", function() {
+              this.navigatorSeries && this.navigatorSeries.setVisible(!0, !1);
+            })), i.eventsToUnbind.push(Y(i, "hide", function() {
+              this.navigatorSeries && this.navigatorSeries.setVisible(!1, !1);
+            })), this.navigatorOptions.adaptToUpdatedData !== !1 && i.xAxis && i.eventsToUnbind.push(Y(i, "updatedData", this.updatedDataHandler)), i.eventsToUnbind.push(Y(i, "remove", function() {
+              e && At(e, i), this.navigatorSeries && t.series && (At(t.series, this.navigatorSeries), Mt(this.navigatorSeries.options) && this.navigatorSeries.remove(!1), delete this.navigatorSeries);
+            }));
+          });
+        }
+        getBaseSeriesMin(t) {
+          return this.baseSeries.reduce(function(e, i) {
+            return Math.min(e, i.getColumn("x")[0] ?? e);
+          }, t);
+        }
+        modifyNavigatorAxisExtremes() {
+          let t = this.xAxis;
+          if (t.getExtremes !== void 0) {
+            let e = this.getUnionExtremes(!0);
+            e && (e.dataMin !== t.min || e.dataMax !== t.max) && (t.min = e.dataMin, t.max = e.dataMax);
+          }
+        }
+        modifyBaseAxisExtremes() {
+          let t, e, i = this.chart.navigator, s = this.getExtremes(), o = s.min, d = s.max, p = s.dataMin, u = s.dataMax, c = d - o, f = i.stickToMin, l = i.stickToMax, r = q(this.ordinal?.convertOverscroll(this.options.overscroll), 0), n = i.series && i.series[0], h = !!this.setExtremes;
+          !(this.eventArgs && this.eventArgs.trigger === "rangeSelectorButton") && (f && (t = (e = p) + c), l && (t = u + r, f || (e = Math.max(p, t - c, i.getBaseSeriesMin(n && n.xData ? n.xData[0] : -Number.MAX_VALUE)))), h && (f || l) && K(e) && (this.min = this.userMin = e, this.max = this.userMax = t)), i.stickToMin = i.stickToMax = null;
+        }
+        updatedDataHandler() {
+          let t = this.chart.navigator, e = this.navigatorSeries, i = t.reversedExtremes ? Math.round(t.zoomedMin) === 0 : Math.round(t.zoomedMax) >= Math.round(t.size);
+          t.stickToMax = q(this.chart.options.navigator && this.chart.options.navigator.stickToMax, i), t.stickToMin = t.shouldStickToMin(this, t), e && !t.hasNavigatorData && (e.options.pointStart = this.getColumn("x")[0], e.setData(this.options.data, !1, null, !1));
+        }
+        shouldStickToMin(t, e) {
+          let i = e.getBaseSeriesMin(t.getColumn("x")[0]), s = t.xAxis, o = s.max, d = s.min, p = s.options.range;
+          return !!(K(o) && K(d)) && (p && o - i > 0 ? o - i < p : d <= i);
+        }
+        addChartEvents() {
+          this.eventsToUnbind || (this.eventsToUnbind = []), this.eventsToUnbind.push(Y(this.chart, "redraw", function() {
+            let t = this.navigator, e = t && (t.baseSeries && t.baseSeries[0] && t.baseSeries[0].xAxis || this.xAxis[0]);
+            e && t.render(e.min, e.max);
+          }), Y(this.chart, "getMargins", function() {
+            let t = this.navigator, e = t.opposite ? "plotTop" : "marginBottom";
+            this.inverted && (e = t.opposite ? "marginRight" : "plotLeft"), this[e] = (this[e] || 0) + (t.navigatorEnabled || !this.inverted ? t.height + (this.scrollbar?.options.margin || 0) + t.scrollbarHeight : 0) + (t.navigatorOptions.margin || 0);
+          }), Y(jt, "setRange", function(t) {
+            this.chart.xAxis[0].setExtremes(t.min, t.max, t.redraw, t.animation, t.eventArguments);
+          }));
+        }
+        destroy() {
+          this.removeEvents(), this.xAxis && (At(this.chart.xAxis, this.xAxis), At(this.chart.axes, this.xAxis)), this.yAxis && (At(this.chart.yAxis, this.yAxis), At(this.chart.axes, this.yAxis)), (this.series || []).forEach((t) => {
+            t.destroy && t.destroy();
+          }), ["series", "xAxis", "yAxis", "shades", "outline", "scrollbarTrack", "scrollbarRifles", "scrollbarGroup", "scrollbar", "navigatorGroup", "rendered"].forEach((t) => {
+            this[t] && this[t].destroy && this[t].destroy(), this[t] = null;
+          }), [this.handles].forEach((t) => {
+            go(t);
+          }), this.baseSeries.forEach((t) => {
+            t.navigatorSeries = void 0;
+          }), this.navigatorEnabled = !1;
+        }
+      }
+      (re = le || (le = {})).setLength = function(a, t, e) {
+        return Array.isArray(a) ? (a.length = t, a) : a[e ? "subarray" : "slice"](0, t);
+      }, re.splice = function(a, t, e, i, s = []) {
+        if (Array.isArray(a)) return Array.isArray(s) || (s = Array.from(s)), { removed: a.splice(t, e, ...s), array: a };
+        let o = Object.getPrototypeOf(a).constructor, d = a[i ? "subarray" : "slice"](t, t + e), p = new o(a.length - e + s.length);
+        return p.set(a.subarray(0, t), 0), p.set(s, t), p.set(a.subarray(t + e), t + s.length), { removed: d, array: p };
+      }, re.convertToNumber = function(a, t) {
+        switch (typeof a) {
+          case "boolean":
+            return +!!a;
+          case "number":
+            return isNaN(a) && !t ? null : a;
+          default:
+            return isNaN(a = parseFloat(`${a ?? ""}`)) && !t ? null : a;
+        }
+      };
+      let { setLength: xo, splice: li } = le, { fireEvent: Ae, objectEach: Gt, uniqueKey: It } = C(), hi = class {
+        constructor(a = {}) {
+          this.autoId = !a.id, this.columns = {}, this.id = a.id || It(), this.rowCount = 0, this.versionTag = It();
+          let t = 0;
+          Gt(a.columns || {}, (e, i) => {
+            this.columns[i] = e.slice(), t = Math.max(t, e.length);
+          }), this.applyRowCount(t);
+        }
+        applyRowCount(a) {
+          this.rowCount = a, Gt(this.columns, (t, e) => {
+            t.length !== a && (this.columns[e] = xo(t, a));
+          });
+        }
+        deleteRows(a, t = 1) {
+          if (t > 0 && a < this.rowCount) {
+            let e = 0;
+            Gt(this.columns, (i, s) => {
+              this.columns[s] = li(i, a, t).array, e = i.length;
+            }), this.rowCount = e;
+          }
+          Ae(this, "afterDeleteRows", { rowIndex: a, rowCount: t }), this.versionTag = It();
+        }
+        getColumn(a, t) {
+          return this.columns[a];
+        }
+        getColumns(a, t) {
+          return (a || Object.keys(this.columns)).reduce((e, i) => (e[i] = this.columns[i], e), {});
+        }
+        getRow(a, t) {
+          return (t || Object.keys(this.columns)).map((e) => this.columns[e]?.[a]);
+        }
+        setColumn(a, t = [], e = 0, i) {
+          this.setColumns({ [a]: t }, e, i);
+        }
+        setColumns(a, t, e) {
+          let i = this.rowCount;
+          Gt(a, (s, o) => {
+            this.columns[o] = s.slice(), i = s.length;
+          }), this.applyRowCount(i), e?.silent || (Ae(this, "afterSetColumns"), this.versionTag = It());
+        }
+        setRow(a, t = this.rowCount, e, i) {
+          let { columns: s } = this, o = e ? this.rowCount + 1 : t + 1, d = Object.keys(a);
+          if (i?.addColumns !== !1) for (let p = 0, u = d.length; p < u; p++) {
+            let c = d[p];
+            s[c] || (s[c] = []);
+          }
+          Gt(s, (p, u) => {
+            p || i?.addColumns === !1 || (p = Array(o)), p && (e ? p = li(p, t, 0, !0, [a[u] ?? null]).array : p[t] = a[u] ?? null, s[u] = p);
+          }), o > this.rowCount && this.applyRowCount(o), i?.silent || (Ae(this, "afterSetRows"), this.versionTag = It());
+        }
+        getModified() {
+          return this.modified || this;
+        }
+      }, { addEvent: gt, correctFloat: qt, css: bo, defined: rt, error: vo, isNumber: zt, pick: ke, timeUnits: yo, isString: Mo } = C();
+      (function(a) {
+        function t(r, n, h, g, m = [], x = 0, b) {
+          let A = {}, y = this.options.tickPixelInterval, k = this.chart.time, M = [], v, S, T, B, w, E = 0, P = [], O = -Number.MAX_VALUE;
+          if (!this.options.ordinal && !this.options.breaks || !m || m.length < 3 || n === void 0) return k.getTimeTicks.apply(k, arguments);
+          let D = m.length;
+          for (v = 0; v < D; v++) {
+            if (w = v && m[v - 1] > h, m[v] < n && (E = v), v === D - 1 || m[v + 1] - m[v] > 5 * x || w) {
+              if (m[v] > O) {
+                for (S = k.getTimeTicks(r, m[E], m[v], g); S.length && S[0] <= O; ) S.shift();
+                S.length && (O = S[S.length - 1]), M.push(P.length), P = P.concat(S);
+              }
+              E = v + 1;
+            }
+            if (w) break;
+          }
+          if (S) {
+            if (B = S.info, b && B.unitRange <= yo.hour) {
+              for (E = 1, v = P.length - 1; E < v; E++) k.dateFormat("%d", P[E]) !== k.dateFormat("%d", P[E - 1]) && (A[P[E]] = "day", T = !0);
+              T && (A[P[0]] = "day"), B.higherRanks = A;
+            }
+            B.segmentStarts = M, P.info = B;
+          } else vo(12, !1, this.chart);
+          if (b && rt(y)) {
+            let R = P.length, H = [], L = [], z, W, N, lt, Ot, _ = R;
+            for (; _--; ) W = this.translate(P[_]), N && (L[_] = N - W), H[_] = N = W;
+            for (L.sort((Bt, Qt) => Bt - Qt), (lt = L[Math.floor(L.length / 2)]) < 0.6 * y && (lt = null), _ = P[R - 1] > h ? R - 1 : R, N = void 0; _--; ) Ot = Math.abs(N - (W = H[_])), N && Ot < 0.8 * y && (lt === null || Ot < 0.8 * lt) ? (A[P[_]] && !A[P[_ + 1]] ? (z = _ + 1, N = W) : z = _, P.splice(z, 1)) : N = W;
+          }
+          return P;
+        }
+        function e(r) {
+          let n = this.ordinal.positions;
+          if (!n) return r;
+          let h = n.length - 1, g;
+          return r < 0 ? r = n[0] : r > h ? r = n[h] : (h = Math.floor(r), g = r - h), g !== void 0 && n[h] !== void 0 ? n[h] + (g ? g * (n[h + 1] - n[h]) : 0) : r;
+        }
+        function i(r) {
+          let n = this.ordinal, h = this.old ? this.old.min : this.min, g = this.old ? this.old.transA : this.transA, m = n.getExtendedPositions();
+          if (m?.length) {
+            let x = qt((r - h) * g + this.minPixelPadding), b = qt(n.getIndexOfPoint(x, m)), A = qt(b % 1);
+            if (b >= 0 && b <= m.length - 1) {
+              let y = m[Math.floor(b)], k = m[Math.ceil(b)];
+              return m[Math.floor(b)] + A * (k - y);
+            }
+          }
+          return r;
+        }
+        function s(r, n) {
+          let h = a.Additions.findIndexOf(r, n, !0);
+          if (r[h] === n) return h;
+          let g = (n - r[h]) / (r[h + 1] - r[h]);
+          return h + g;
+        }
+        function o() {
+          this.ordinal || (this.ordinal = new a.Additions(this));
+        }
+        function d() {
+          let { eventArgs: r, options: n } = this;
+          if (this.isXAxis && rt(n.overscroll) && n.overscroll !== 0 && zt(this.max) && zt(this.min) && (this.options.ordinal && !this.ordinal.originalOrdinalRange && this.ordinal.getExtendedPositions(!1), this.isFullRange = rt(this.dataMin) && rt(this.dataMax) && this.max - this.min == this.dataMax - this.dataMin, this.max === this.dataMax && (r?.trigger !== "pan" || this.isInternal) && r?.trigger !== "navigator")) {
+            let h = this.ordinal.convertOverscroll(n.overscroll);
+            this.max += h, !this.isInternal && rt(this.userMin) && r?.trigger !== "mousewheel" && (this.min += h);
+          }
+        }
+        function p() {
+          this.horiz && !this.isDirty && (this.isDirty = this.isOrdinal && this.chart.navigator && !this.chart.navigator.adaptToUpdatedData);
+        }
+        function u() {
+          this.ordinal && (this.ordinal.beforeSetTickPositions(), this.tickInterval = this.ordinal.postProcessTickInterval(this.tickInterval));
+        }
+        function c(r) {
+          let n = this.xAxis[0], h = n.ordinal.convertOverscroll(n.options.overscroll), g = r.originalEvent.chartX, m = this.options.chart.panning, x = !1;
+          if (m?.type !== "y" && n.options.ordinal && n.series.length && (!r.touches || r.touches.length <= 1)) {
+            let b, A, y = this.mouseDownX, k = n.getExtremes(), M = k.dataMin, v = k.dataMax, S = k.min, T = k.max, B = this.hoverPoints, w = n.closestPointRange || n.ordinal?.overscrollPointsRange, E = Math.round((y - g) / (n.translationSlope * (n.ordinal.slope || w))), P = n.ordinal.getExtendedPositions(), O = { ordinal: { positions: P, extendedOrdinalPositions: P } }, D = n.index2val, R = n.val2lin;
+            if (S <= M && E <= 0 || T >= v + h && E >= 0) return void r.preventDefault();
+            O.ordinal.positions ? Math.abs(E) > 1 && (B && B.forEach(function(H) {
+              H.setState();
+            }), A = O.ordinal.positions, h && (A = O.ordinal.positions = A.concat(n.ordinal.getOverscrollPositions())), v > A[A.length - 1] && A.push(v), this.setFixedRange(T - S), (b = n.navigatorAxis.toFixedRange(void 0, void 0, D.apply(O, [R.apply(O, [S, !0]) + E]), D.apply(O, [R.apply(O, [T, !0]) + E]))).min >= Math.min(A[0], S) && b.max <= Math.max(A[A.length - 1], T) + h && n.setExtremes(b.min, b.max, !0, !1, { trigger: "pan" }), this.mouseDownX = g, bo(this.container, { cursor: "move" })) : x = !0;
+          } else x = !0;
+          x || m && /y/.test(m.type) ? h && zt(n.dataMax) && (n.max = n.dataMax + h) : r.preventDefault();
+        }
+        function f() {
+          let r = this.xAxis;
+          r?.options.ordinal && (delete r.ordinal.index, delete r.ordinal.originalOrdinalRange);
+        }
+        function l(r, n) {
+          let h, g = this.ordinal, m = g.positions, x = g.slope, b;
+          if (!m) return r;
+          let A = m.length;
+          if (m[0] <= r && m[A - 1] >= r) h = s(m, r);
+          else {
+            if (b = g.getExtendedPositions?.(), !b?.length) return r;
+            let y = b.length;
+            x || (x = (b[y - 1] - b[0]) / y);
+            let k = s(b, m[0]);
+            if (r >= b[0] && r <= b[y - 1]) h = s(b, r) - k;
+            else {
+              if (!n) return r;
+              h = r < b[0] ? -k - (b[0] - r) / x : (r - b[y - 1]) / x + y - k;
+            }
+          }
+          return n ? h : x * (h || 0) + g.offset;
+        }
+        a.compose = function(r, n, h) {
+          let g = r.prototype;
+          return g.ordinal2lin || (g.getTimeTicks = t, g.index2val = e, g.lin2val = i, g.val2lin = l, g.ordinal2lin = g.val2lin, gt(r, "afterInit", o), gt(r, "foundExtremes", d), gt(r, "afterSetScale", p), gt(r, "initialAxisTranslation", u), gt(h, "pan", c), gt(h, "touchpan", c), gt(n, "updatedData", f)), r;
+        }, a.Additions = class {
+          constructor(r) {
+            this.index = {}, this.axis = r;
+          }
+          beforeSetTickPositions() {
+            let r = this.axis, n = r.ordinal, h = r.getExtremes(), g = h.min, m = h.max, x = r.brokenAxis?.hasBreaks, b = r.options.ordinal, A = r.options.overscroll && r.ordinal.convertOverscroll(r.options.overscroll) || 0, y, k, M, v, S, T, B, w = [], E = Number.MAX_VALUE, P = !1, O = !1, D = !1;
+            if (b || x) {
+              let R = 0;
+              if (r.series.forEach(function(H, L) {
+                let z = H.getColumn("x", !0);
+                if (k = [], L > 0 && H.options.id !== "highcharts-navigator-series" && z.length > 1 && (O = R !== z[1] - z[0]), R = z[1] - z[0], H.boosted && (D = H.boosted), H.reserveSpace() && (H.takeOrdinalPosition !== !1 || x) && (y = (w = w.concat(z)).length, w.sort(function(W, N) {
+                  return W - N;
+                }), E = Math.min(E, ke(H.closestPointRange, E)), y)) {
+                  for (L = 0; L < y - 1; ) w[L] !== w[L + 1] && k.push(w[L + 1]), L++;
+                  k[0] !== w[0] && k.unshift(w[0]), w = k;
+                }
+              }), r.ordinal.originalOrdinalRange || (r.ordinal.originalOrdinalRange = (w.length - 1) * E), O && D && (w.pop(), w.shift()), (y = w.length) > 2) {
+                for (M = w[1] - w[0], B = y - 1; B-- && !P; ) w[B + 1] - w[B] !== M && (P = !0);
+                !r.options.keepOrdinalPadding && (w[0] - g > M || m - A - w[y - 1] > M) && (P = !0);
+              } else r.options.overscroll && (y === 2 ? E = w[1] - w[0] : y === 1 ? (E = A, w = [w[0], w[0] + E]) : E = n.overscrollPointsRange);
+              P || r.forceOrdinal ? (r.options.overscroll && (n.overscrollPointsRange = E, w = w.concat(n.getOverscrollPositions())), n.positions = w, v = r.ordinal2lin(Math.max(g, w[0]), !0), S = Math.max(r.ordinal2lin(Math.min(m, w[w.length - 1]), !0), 1), n.slope = T = (m - g) / (S - v), n.offset = g - v * T) : (n.overscrollPointsRange = ke(r.closestPointRange, n.overscrollPointsRange), n.positions = r.ordinal.slope = n.offset = void 0);
+            }
+            r.isOrdinal = b && P, n.groupIntervalFactor = null;
+          }
+          static findIndexOf(r, n, h) {
+            let g = 0, m = r.length - 1, x;
+            for (; g < m; ) r[x = Math.ceil((g + m) / 2)] <= n ? g = x : m = x - 1;
+            return r[g] === n || h ? g : -1;
+          }
+          getExtendedPositions(r = !0) {
+            let n = this, h = n.axis, g = h.constructor.prototype, m = h.chart, x = h.series.reduce((v, S) => {
+              let T = S.currentDataGrouping;
+              return v + (T ? T.count + T.unitName : "raw");
+            }, ""), b = r ? h.ordinal.convertOverscroll(h.options.overscroll) : 0, A = h.getExtremes(), y, k, M = n.index;
+            return M || (M = n.index = {}), !M[x] && ((y = { series: [], chart: m, forceOrdinal: !1, getExtremes: function() {
+              return { min: A.dataMin, max: A.dataMax + b };
+            }, applyGrouping: g.applyGrouping, getGroupPixelWidth: g.getGroupPixelWidth, getTimeTicks: g.getTimeTicks, options: { ordinal: !0 }, ordinal: { getGroupIntervalFactor: this.getGroupIntervalFactor }, ordinal2lin: g.ordinal2lin, getIndexOfPoint: g.getIndexOfPoint, val2lin: g.val2lin }).ordinal.axis = y, h.series.forEach((v) => {
+              if (v.takeOrdinalPosition === !1) return;
+              k = { xAxis: y, chart: m, groupPixelWidth: v.groupPixelWidth, destroyGroupedData: C().noop, getColumn: v.getColumn, applyGrouping: v.applyGrouping, getProcessedData: v.getProcessedData, reserveSpace: v.reserveSpace, visible: v.visible };
+              let S = v.getColumn("x").concat(r ? n.getOverscrollPositions() : []);
+              k.dataTable = new hi({ columns: { x: S } }), k.options = { ...v.options, dataGrouping: v.currentDataGrouping ? { firstAnchor: v.options.dataGrouping?.firstAnchor, anchor: v.options.dataGrouping?.anchor, lastAnchor: v.options.dataGrouping?.firstAnchor, enabled: !0, forced: !0, approximation: "open", units: [[v.currentDataGrouping.unitName, [v.currentDataGrouping.count]]] } : { enabled: !1 } }, y.series.push(k), v.processData.apply(k);
+            }), y.applyGrouping({ hasExtremesChanged: !0 }), k?.closestPointRange !== k?.basePointRange && k.currentDataGrouping && (y.forceOrdinal = !0), h.ordinal.beforeSetTickPositions.apply({ axis: y }), !h.ordinal.originalOrdinalRange && y.ordinal.originalOrdinalRange && (h.ordinal.originalOrdinalRange = y.ordinal.originalOrdinalRange), y.ordinal.positions && (M[x] = y.ordinal.positions)), M[x];
+          }
+          getGroupIntervalFactor(r, n, h) {
+            let g = h.getColumn("x", !0), m = g.length, x = [], b, A, y = this.groupIntervalFactor;
+            if (!y) {
+              for (A = 0; A < m - 1; A++) x[A] = g[A + 1] - g[A];
+              x.sort(function(k, M) {
+                return k - M;
+              }), b = x[Math.floor(m / 2)], r = Math.max(r, g[0]), n = Math.min(n, g[m - 1]), this.groupIntervalFactor = y = m * b / (n - r);
+            }
+            return y;
+          }
+          getIndexOfPoint(r, n) {
+            let h = this.axis, g = h.min, m = h.minPixelPadding;
+            return s(n, g) + qt((r - m) / (h.translationSlope * (this.slope || h.closestPointRange || this.overscrollPointsRange)));
+          }
+          getOverscrollPositions() {
+            let r = this.axis, n = this.convertOverscroll(r.options.overscroll), h = this.overscrollPointsRange, g = [], m = r.dataMax;
+            if (rt(h)) for (; m < r.dataMax + n; ) g.push(m += h);
+            return g;
+          }
+          postProcessTickInterval(r) {
+            let n = this.axis, h = this.slope, g = n.closestPointRange;
+            return h && g ? n.options.breaks ? g || r : r / (h / g) : r;
+          }
+          convertOverscroll(r = 0) {
+            let n = this, h = n.axis, g = function(m) {
+              return ke(n.originalOrdinalRange, rt(h.dataMax) && rt(h.dataMin) ? h.dataMax - h.dataMin : 0) * m;
+            };
+            if (Mo(r)) {
+              let m = parseInt(r, 10);
+              if (h.isFullRange === !1 && zt(h.min) && zt(h.max) && (this.originalOrdinalRange = h.max - h.min), /%$/.test(r)) return g(m / 100);
+              if (/px/.test(r)) {
+                let x = Math.min(m, 0.9 * h.len) / h.len;
+                return g(x / (h.isFullRange ? 1 - x : 1));
+              }
+              return 0;
+            }
+            return r;
+          }
+        };
+      })(he || (he = {}));
+      let Ao = he, ko = { rangeSelectorZoom: "Zoom", rangeSelectorFrom: "", rangeSelectorTo: "→", rangeSelector: { allText: "All", allTitle: "View all", monthText: "{count}m", monthTitle: "View {count} {#eq count 1}month{else}months{/eq}", yearText: "{count}y", yearTitle: "View {count} {#eq count 1}year{else}years{/eq}", ytdText: "YTD", ytdTitle: "View year to date" } }, di = { allButtonsEnabled: !1, buttons: [{ type: "month", count: 1 }, { type: "month", count: 3 }, { type: "month", count: 6 }, { type: "ytd" }, { type: "year", count: 1 }, { type: "all" }], buttonSpacing: 5, dropdown: "responsive", enabled: void 0, verticalAlign: "top", buttonTheme: { width: 28, height: 18, padding: 2, zIndex: 7 }, floating: !1, x: 0, y: 0, height: void 0, inputBoxBorderColor: "none", inputBoxHeight: 17, inputBoxWidth: void 0, inputDateFormat: "%[ebY]", inputDateParser: void 0, inputEditDateFormat: "%Y-%m-%d", inputEnabled: !0, inputPosition: { align: "right", x: 0, y: 0 }, inputSpacing: 5, selected: void 0, buttonPosition: { align: "left", x: 0, y: 0 }, inputStyle: { color: "#334eff", cursor: "pointer", fontSize: "0.8em" }, labelStyle: { color: "#666666", fontSize: "0.8em" } }, { defaultOptions: pi } = C(), { composed: wo } = C(), { addEvent: ft, defined: So, extend: ui, isNumber: mt, merge: To, pick: ci, pushUnique: Eo } = C(), we = [];
+      function Oo() {
+        let a, t, e = this.range, i = e.type, s = this.max, o = this.chart.time, d = function(u, c) {
+          let f = o.toParts(u), l = f.slice();
+          i === "year" ? l[0] += c : l[1] += c;
+          let r = o.makeTime.apply(o, l), n = o.toParts(r);
+          return i === "month" && f[1] === n[1] && Math.abs(c) === 1 && (l[0] = f[0], l[1] = f[1], l[2] = 0), (r = o.makeTime.apply(o, l)) - u;
+        };
+        mt(e) ? (a = s - e, t = e) : e && (a = s + d(s, -(e.count || 1)), this.chart && this.chart.setFixedRange(s - a));
+        let p = ci(this.dataMin, 5e-324);
+        return mt(a) || (a = p), a <= p && (a = p, t === void 0 && (t = d(a, e.count)), this.newMax = Math.min(a + t, ci(this.dataMax, Number.MAX_VALUE))), mt(s) ? !mt(e) && e && e._offsetMin && (a += e._offsetMin) : a = void 0, a;
+      }
+      function Bo() {
+        this.rangeSelector?.redrawElements();
+      }
+      function Co() {
+        this.options.rangeSelector && this.options.rangeSelector.enabled && (this.rangeSelector = new se(this));
+      }
+      function Po() {
+        let a = this.rangeSelector;
+        if (a) {
+          mt(a.deferredYTDClick) && (a.clickButton(a.deferredYTDClick), delete a.deferredYTDClick);
+          let t = a.options.verticalAlign;
+          a.options.floating || (t === "bottom" ? this.extraBottomMargin = !0 : t === "top" && (this.extraTopMargin = !0));
+        }
+      }
+      function gi() {
+        let a, t = this.rangeSelector;
+        if (!t) return;
+        let e = this.xAxis[0].getExtremes(), i = this.legend, s = t && t.options.verticalAlign;
+        mt(e.min) && t.render(e.min, e.max), i.display && s === "top" && s === i.options.verticalAlign && (a = To(this.spacingBox), i.options.layout === "vertical" ? a.y = this.plotTop : a.y += t.getHeight(), i.group.placed = !1, i.align(a));
+      }
+      function Do() {
+        for (let a = 0, t = we.length; a < t; ++a) {
+          let e = we[a];
+          if (e[0] === this) {
+            e[1].forEach((i) => i()), we.splice(a, 1);
+            return;
+          }
+        }
+      }
+      function Ro() {
+        let a = this.rangeSelector;
+        if (a?.options?.enabled) {
+          let { min: t, max: e } = this.xAxis[0].getExtremes();
+          mt(t) && a.inputGroup && a.inputGroup.getBBox().width < 20 && a.render(t, e);
+          let i = a.getHeight(), s = a.options.verticalAlign;
+          a.options.floating || (s === "bottom" ? this.marginBottom += i : s !== "middle" && (this.plotTop += i));
+        }
+      }
+      function Go(a) {
+        let t = a.options.rangeSelector, e = this.extraBottomMargin, i = this.extraTopMargin, s = this.rangeSelector;
+        if (t && t.enabled && !So(s) && this.options.rangeSelector && (this.options.rangeSelector.enabled = !0, this.rangeSelector = s = new se(this)), this.extraBottomMargin = !1, this.extraTopMargin = !1, s) {
+          let o = t && t.verticalAlign || s.options && s.options.verticalAlign;
+          s.options.floating || (o === "bottom" ? this.extraBottomMargin = !0 : o !== "middle" && (this.extraTopMargin = !0)), (this.extraBottomMargin !== e || this.extraTopMargin !== i) && (this.isDirtyBox = !0);
+        }
+      }
+      let Io = function(a, t, e) {
+        if (se = e, Eo(wo, "RangeSelector")) {
+          let i = t.prototype;
+          a.prototype.minFromRange = Oo, ft(t, "afterGetContainer", Co), ft(t, "beforeRender", Po), ft(t, "destroy", Do), ft(t, "getMargins", Ro), ft(t, "redraw", gi), ft(t, "update", Go), ft(t, "beforeRedraw", Bo), i.callbacks.push(gi), ui(pi, { rangeSelector: di }), ui(pi.lang, ko);
+        }
+      };
+      var zo = I(28), fi = I.n(zo), Lo = I(984), Se = I.n(Lo);
+      let { defaultOptions: Te } = C(), { format: mi } = Se(), { addEvent: $, createElement: Lt, css: et, defined: it, destroyObjectProperties: Wo, discardElement: Xo, extend: xi, fireEvent: wt, isNumber: U, isString: Ee, merge: at, objectEach: Ho, pick: J, splat: Yo } = C();
+      function bi(a) {
+        let t = (s) => RegExp(`%[[a-zA-Z]*${s}`).test(a);
+        if (Ee(a) ? a.indexOf("%L") !== -1 : a.fractionalSecondDigits) return "text";
+        let e = Ee(a) ? ["a", "A", "d", "e", "w", "b", "B", "m", "o", "y", "Y"].some(t) : a.dateStyle || a.day || a.month || a.year, i = Ee(a) ? ["H", "k", "I", "l", "M", "S"].some(t) : a.timeStyle || a.hour || a.minute || a.second;
+        return e && i ? "datetime-local" : e ? "date" : i ? "time" : "text";
+      }
+      class Wt {
+        static compose(t, e) {
+          Io(t, e, Wt);
+        }
+        constructor(t) {
+          this.isDirty = !1, this.buttonOptions = [], this.initialButtonGroupWidth = 0, this.maxButtonWidth = () => {
+            let e = 0;
+            return this.buttons.forEach((i) => {
+              let s = i.getBBox();
+              s.width > e && (e = s.width);
+            }), e;
+          }, this.init(t);
+        }
+        clickButton(t, e) {
+          let i = this.chart, s = this.buttonOptions[t], o = i.xAxis[0], d = i.scroller && i.scroller.getUnionExtremes() || o || {}, p = s.type, u = s.dataGrouping, c = d.dataMin, f = d.dataMax, l, r = U(o?.max) ? Math.round(Math.min(o.max, f ?? o.max)) : void 0, n, h = s._range, g, m, x, b = !0;
+          if (c !== null && f !== null) {
+            if (this.setSelected(t), u && (this.forcedDataGrouping = !0, fe().prototype.setDataGrouping.call(o || { chart: this.chart }, u, !1), this.frozenStates = s.preserveDataGrouping), p === "month" || p === "year") o ? (m = { range: s, max: r, chart: i, dataMin: c, dataMax: f }, l = o.minFromRange.call(m), U(m.newMax) && (r = m.newMax), b = !1) : h = s;
+            else if (h) U(r) && (r = Math.min((l = Math.max(r - h, c)) + h, f), b = !1);
+            else if (p === "ytd") if (o) !o.hasData() || U(f) && U(c) || (c = Number.MAX_VALUE, f = -Number.MAX_VALUE, i.series.forEach((A) => {
+              let y = A.getColumn("x");
+              y.length && (c = Math.min(y[0], c), f = Math.max(y[y.length - 1], f));
+            }), e = !1), U(f) && U(c) && (l = g = (x = this.getYTDExtremes(f, c)).min, r = x.max);
+            else {
+              this.deferredYTDClick = t;
+              return;
+            }
+            else p === "all" && o && (i.navigator && i.navigator.baseSeries[0] && (i.navigator.baseSeries[0].xAxis.options.range = void 0), l = c, r = f);
+            if (b && s._offsetMin && it(l) && (l += s._offsetMin), s._offsetMax && it(r) && (r += s._offsetMax), this.dropdown && (this.dropdown.selectedIndex = t + 1), o) (U(l) || U(r)) && (o.setExtremes(l, r, J(e, !0), void 0, { trigger: "rangeSelectorButton", rangeSelectorButton: s }), i.setFixedRange(s._range));
+            else {
+              n = Yo(i.options.xAxis || {})[0];
+              let A = $(i, "afterCreateAxes", function() {
+                let y = i.xAxis[0];
+                y.range = y.options.range = h, y.min = y.options.min = g;
+              });
+              $(i, "load", function() {
+                let y = i.xAxis[0];
+                i.setFixedRange(s._range), y.options.range = n.range, y.options.min = n.min, A();
+              });
+            }
+            wt(this, "afterBtnClick");
+          }
+        }
+        setSelected(t) {
+          this.selected = this.options.selected = t;
+        }
+        init(t) {
+          let e = this, i = t.options.rangeSelector, s = t.options.lang, o = i.buttons, d = i.selected, p = function() {
+            let u = e.minInput, c = e.maxInput;
+            u && u.blur && wt(u, "blur"), c && c.blur && wt(c, "blur");
+          };
+          e.chart = t, e.options = i, e.buttons = [], e.buttonOptions = o.map((u) => (u.type && s.rangeSelector && (u.text ?? (u.text = s.rangeSelector[`${u.type}Text`]), u.title ?? (u.title = s.rangeSelector[`${u.type}Title`])), u.text = mi(u.text, { count: u.count || 1 }), u.title = mi(u.title, { count: u.count || 1 }), u)), this.eventsToUnbind = [], this.eventsToUnbind.push($(t.container, "mousedown", p)), this.eventsToUnbind.push($(t, "resize", p)), o.forEach(e.computeButtonRange), d !== void 0 && o[d] && this.clickButton(d, !1), this.eventsToUnbind.push($(t, "load", function() {
+            t.xAxis && t.xAxis[0] && $(t.xAxis[0], "setExtremes", function(u) {
+              U(this.max) && U(this.min) && this.max - this.min !== t.fixedRange && u.trigger !== "rangeSelectorButton" && u.trigger !== "updatedData" && e.forcedDataGrouping && !e.frozenStates && this.setDataGrouping(!1, !1);
+            });
+          })), this.createElements();
+        }
+        updateButtonStates() {
+          let t = this, e = this.chart, i = this.dropdown, s = this.dropdownLabel, o = e.xAxis[0], d = Math.round(o.max - o.min), p = !o.hasVisibleSeries, u = 24 * 36e5, c = e.scroller && e.scroller.getUnionExtremes() || o, f = c.dataMin, l = c.dataMax, r = t.getYTDExtremes(l, f), n = r.min, h = r.max, g = t.selected, m = t.options.allButtonsEnabled, x = Array(t.buttonOptions.length).fill(0), b = U(g), A = t.buttons, y = !1, k = null;
+          t.buttonOptions.forEach((M, v) => {
+            let S = M._range, T = M.type, B = M.count || 1, w = M._offsetMax - M._offsetMin, E = v === g, P = S > l - f, O = S < o.minRange, D = !1, R = S === d;
+            if (E && P && (y = !0), o.isOrdinal && o.ordinal?.positions && S && d < S) {
+              let z = o.ordinal.positions;
+              z[z.length - 1] - z[0] > S && (R = !0);
+            } else (T === "month" || T === "year") && d + 36e5 >= { month: 28, year: 365 }[T] * u * B - w && d - 36e5 <= { month: 31, year: 366 }[T] * u * B + w ? R = !0 : T === "ytd" ? (R = h - n + w === d, D = !E) : T === "all" && (R = o.max - o.min >= l - f);
+            let H = !m && !(y && T === "all") && (P || O || p), L = y && T === "all" || !D && R || E && t.frozenStates;
+            H ? x[v] = 3 : L && (!b || v === g) && (k = v);
+          }), k !== null ? (x[k] = 2, t.setSelected(k), this.dropdown && (this.dropdown.selectedIndex = k + 1)) : (t.setSelected(), this.dropdown && (this.dropdown.selectedIndex = -1), s && (s.setState(0), s.attr({ text: (Te.lang.rangeSelectorZoom || "") + " ▾" })));
+          for (let M = 0; M < x.length; M++) {
+            let v = x[M], S = A[M];
+            if (S.state !== v && (S.setState(v), i)) {
+              i.options[M + 1].disabled = v === 3, v === 2 && (s && (s.setState(2), s.attr({ text: t.buttonOptions[M].text + " ▾" })), i.selectedIndex = M + 1);
+              let T = s.getBBox();
+              et(i, { width: `${T.width}px`, height: `${T.height}px` });
+            }
+          }
+        }
+        computeButtonRange(t) {
+          let e = t.type, i = t.count || 1, s = { millisecond: 1, second: 1e3, minute: 6e4, hour: 36e5, day: 864e5, week: 6048e5 };
+          s[e] ? t._range = s[e] * i : (e === "month" || e === "year") && (t._range = 24 * { month: 30, year: 365 }[e] * 36e5 * i), t._offsetMin = J(t.offsetMin, 0), t._offsetMax = J(t.offsetMax, 0), t._range += t._offsetMax - t._offsetMin;
+        }
+        getInputValue(t) {
+          let e = t === "min" ? this.minInput : this.maxInput, i = this.chart.options.rangeSelector, s = this.chart.time;
+          return e ? (e.type === "text" && i.inputDateParser || this.defaultInputDateParser)(e.value, s.timezone === "UTC", s) : 0;
+        }
+        setInputValue(t, e) {
+          let i = this.options, s = this.chart.time, o = t === "min" ? this.minInput : this.maxInput, d = t === "min" ? this.minDateBox : this.maxDateBox;
+          if (o) {
+            o.setAttribute("type", bi(i.inputDateFormat || "%e %b %Y"));
+            let p = o.getAttribute("data-hc-time"), u = it(p) ? Number(p) : void 0;
+            if (it(e)) {
+              let c = u;
+              it(c) && o.setAttribute("data-hc-time-previous", c), o.setAttribute("data-hc-time", e), u = e;
+            }
+            o.value = s.dateFormat(this.inputTypeFormats[o.type] || i.inputEditDateFormat, u), d && d.attr({ text: s.dateFormat(i.inputDateFormat, u) });
+          }
+        }
+        setInputExtremes(t, e, i) {
+          let s = t === "min" ? this.minInput : this.maxInput;
+          if (s) {
+            let o = this.inputTypeFormats[s.type], d = this.chart.time;
+            if (o) {
+              let p = d.dateFormat(o, e);
+              s.min !== p && (s.min = p);
+              let u = d.dateFormat(o, i);
+              s.max !== u && (s.max = u);
+            }
+          }
+        }
+        showInput(t) {
+          let e = t === "min" ? this.minDateBox : this.maxDateBox, i = t === "min" ? this.minInput : this.maxInput;
+          if (i && e && this.inputGroup) {
+            let s = i.type === "text", { translateX: o = 0, translateY: d = 0 } = this.inputGroup, { x: p = 0, width: u = 0, height: c = 0 } = e, { inputBoxWidth: f } = this.options;
+            et(i, { width: s ? u + (f ? -2 : 20) + "px" : "auto", height: c - 2 + "px", border: "2px solid silver" }), s && f ? et(i, { left: o + p + "px", top: d + "px" }) : et(i, { left: Math.min(Math.round(p + o - (i.offsetWidth - u) / 2), this.chart.chartWidth - i.offsetWidth) + "px", top: d - (i.offsetHeight - c) / 2 + "px" });
+          }
+        }
+        hideInput(t) {
+          let e = t === "min" ? this.minInput : this.maxInput;
+          e && et(e, { top: "-9999em", border: 0, width: "1px", height: "1px" });
+        }
+        defaultInputDateParser(t, e, i) {
+          return i?.parse(t) || 0;
+        }
+        drawInput(t) {
+          let { chart: e, div: i, inputGroup: s } = this, o = this, d = e.renderer.style || {}, p = e.renderer, u = e.options.rangeSelector, c = Te.lang, f = t === "min";
+          function l(x) {
+            let { maxInput: b, minInput: A } = o, y = e.xAxis[0], k = e.scroller?.getUnionExtremes() || y, M = k.dataMin, v = k.dataMax, S = e.xAxis[0].getExtremes()[x], T = o.getInputValue(x);
+            U(T) && T !== S && (f && b && U(M) ? T > Number(b.getAttribute("data-hc-time")) ? T = void 0 : T < M && (T = M) : A && U(v) && (T < Number(A.getAttribute("data-hc-time")) ? T = void 0 : T > v && (T = v)), T !== void 0 && y.setExtremes(f ? T : y.min, f ? y.max : T, void 0, void 0, { trigger: "rangeSelectorInput" }));
+          }
+          let r = c[f ? "rangeSelectorFrom" : "rangeSelectorTo"] || "", n = p.label(r, 0).addClass("highcharts-range-label").attr({ padding: 2 * !!r, height: r ? u.inputBoxHeight : 0 }).add(s), h = p.label("", 0).addClass("highcharts-range-input").attr({ padding: 2, width: u.inputBoxWidth, height: u.inputBoxHeight, "text-align": "center" }).on("click", function() {
+            o.showInput(t), o[t + "Input"].focus();
+          });
+          e.styledMode || h.attr({ stroke: u.inputBoxBorderColor, "stroke-width": 1 }), h.add(s);
+          let g = Lt("input", { name: t, className: "highcharts-range-selector" }, void 0, i);
+          g.setAttribute("type", bi(u.inputDateFormat || "%e %b %Y")), e.styledMode || (n.css(at(d, u.labelStyle)), h.css(at({ color: "#333333" }, d, u.inputStyle)), et(g, xi({ position: "absolute", border: 0, boxShadow: "0 0 15px rgba(0,0,0,0.3)", width: "1px", height: "1px", padding: 0, textAlign: "center", fontSize: d.fontSize, fontFamily: d.fontFamily, top: "-9999em" }, u.inputStyle))), g.onfocus = () => {
+            o.showInput(t);
+          }, g.onblur = () => {
+            g === C().doc.activeElement && l(t), o.hideInput(t), o.setInputValue(t), g.blur();
+          };
+          let m = !1;
+          return g.onchange = () => {
+            m || (l(t), o.hideInput(t), g.blur());
+          }, g.onkeypress = (x) => {
+            x.keyCode === 13 && l(t);
+          }, g.onkeydown = (x) => {
+            m = !0, (x.key === "ArrowUp" || x.key === "ArrowDown" || x.key === "Tab") && l(t);
+          }, g.onkeyup = () => {
+            m = !1;
+          }, { dateBox: h, input: g, label: n };
+        }
+        getPosition() {
+          let t = this.chart, e = t.options.rangeSelector, i = e.verticalAlign === "top" ? t.plotTop - t.axisOffset[0] : 0;
+          return { buttonTop: i + e.buttonPosition.y, inputTop: i + e.inputPosition.y - 10 };
+        }
+        getYTDExtremes(t, e) {
+          let i = this.chart.time, s = i.toParts(t)[0];
+          return { max: t, min: Math.max(e, i.makeTime(s, 0)) };
+        }
+        createElements() {
+          let t = this.chart, e = t.renderer, i = t.container, s = t.options, o = s.rangeSelector, d = o.inputEnabled, p = J(s.chart.style?.zIndex, 0) + 1;
+          o.enabled !== !1 && (this.group = e.g("range-selector-group").attr({ zIndex: 7 }).add(), this.div = Lt("div", void 0, { position: "relative", height: 0, zIndex: p }), this.buttonOptions.length && this.renderButtons(), i.parentNode && i.parentNode.insertBefore(this.div, i), d && this.createInputs());
+        }
+        createInputs() {
+          this.inputGroup = this.chart.renderer.g("input-group").add(this.group);
+          let t = this.drawInput("min");
+          this.minDateBox = t.dateBox, this.minLabel = t.label, this.minInput = t.input;
+          let e = this.drawInput("max");
+          this.maxDateBox = e.dateBox, this.maxLabel = e.label, this.maxInput = e.input;
+        }
+        render(t, e) {
+          if (this.options.enabled === !1) return;
+          let i = this.chart, s = i.options.rangeSelector;
+          if (s.inputEnabled) {
+            this.inputGroup || this.createInputs(), this.setInputValue("min", t), this.setInputValue("max", e), this.chart.styledMode || (this.maxLabel?.css(s.labelStyle), this.minLabel?.css(s.labelStyle));
+            let o = i.scroller && i.scroller.getUnionExtremes() || i.xAxis[0] || {};
+            if (it(o.dataMin) && it(o.dataMax)) {
+              let d = i.xAxis[0].minRange || 0;
+              this.setInputExtremes("min", o.dataMin, Math.min(o.dataMax, this.getInputValue("max")) - d), this.setInputExtremes("max", Math.max(o.dataMin, this.getInputValue("min")) + d, o.dataMax);
+            }
+            if (this.inputGroup) {
+              let d = 0;
+              [this.minLabel, this.minDateBox, this.maxLabel, this.maxDateBox].forEach((p) => {
+                if (p) {
+                  let { width: u } = p.getBBox();
+                  u && (p.attr({ x: d }), d += u + s.inputSpacing);
+                }
+              });
+            }
+          } else this.inputGroup && (this.inputGroup.destroy(), delete this.inputGroup);
+          !this.chart.styledMode && this.zoomText && this.zoomText.css(s.labelStyle), this.alignElements(), this.updateButtonStates();
+        }
+        renderButtons() {
+          var t;
+          let { chart: e, options: i } = this, s = Te.lang, o = e.renderer, d = at(i.buttonTheme), p = d && d.states;
+          delete d.width, delete d.states, this.buttonGroup = o.g("range-selector-buttons").add(this.group);
+          let u = this.dropdown = Lt("select", void 0, { position: "absolute", padding: 0, border: 0, cursor: "pointer", opacity: 1e-4 }, this.div), c = e.userOptions.rangeSelector?.buttonTheme;
+          this.dropdownLabel = o.button("", 0, 0, () => {
+          }, at(d, { "stroke-width": J(d["stroke-width"], 0), width: "auto", paddingLeft: J(i.buttonTheme.paddingLeft, c?.padding, 8), paddingRight: J(i.buttonTheme.paddingRight, c?.padding, 8) }), p && p.hover, p && p.select, p && p.disabled).hide().add(this.group), $(u, "touchstart", () => {
+            u.style.fontSize = "16px";
+          });
+          let f = C().isMS ? "mouseover" : "mouseenter", l = C().isMS ? "mouseout" : "mouseleave";
+          $(u, f, () => {
+            wt(this.dropdownLabel.element, f);
+          }), $(u, l, () => {
+            wt(this.dropdownLabel.element, l);
+          }), $(u, "change", () => {
+            wt(this.buttons[u.selectedIndex - 1].element, "click");
+          }), this.zoomText = o.label(s.rangeSelectorZoom || "", 0).attr({ padding: i.buttonTheme.padding, height: i.buttonTheme.height, paddingLeft: 0, paddingRight: 0 }).add(this.buttonGroup), this.chart.styledMode || (this.zoomText.css(i.labelStyle), (t = i.buttonTheme)["stroke-width"] ?? (t["stroke-width"] = 0)), Lt("option", { textContent: this.zoomText.textStr, disabled: !0 }, void 0, u), this.createButtons();
+        }
+        createButtons() {
+          let { options: t } = this, e = at(t.buttonTheme), i = e && e.states, s = e.width || 28;
+          delete e.width, delete e.states, this.buttonOptions.forEach((o, d) => {
+            this.createButton(o, d, s, i);
+          });
+        }
+        createButton(t, e, i, s) {
+          let { dropdown: o, buttons: d, chart: p, options: u } = this, c = p.renderer, f = at(u.buttonTheme);
+          o?.add(Lt("option", { textContent: t.title || t.text }), e + 2), d[e] = c.button(t.text ?? "", 0, 0, (l) => {
+            let r, n = t.events && t.events.click;
+            n && (r = n.call(t, l)), r !== !1 && this.clickButton(e), this.isActive = !0;
+          }, f, s && s.hover, s && s.select, s && s.disabled).attr({ "text-align": "center", width: i }).add(this.buttonGroup), t.title && d[e].attr("title", t.title);
+        }
+        alignElements() {
+          let { buttonGroup: t, buttons: e, chart: i, group: s, inputGroup: o, options: d, zoomText: p } = this, u = i.options, c = u.exporting && u.exporting.enabled !== !1 && u.navigation && u.navigation.buttonOptions, { buttonPosition: f, inputPosition: l, verticalAlign: r } = d, n = (g, m, x) => c && this.titleCollision(i) && r === "top" && x && m.y - g.getBBox().height - 12 < (c.y || 0) + (c.height || 0) + i.spacing[0] ? -40 : 0, h = i.plotLeft;
+          if (s && f && l) {
+            let g = f.x - i.spacing[3];
+            if (t) {
+              if (this.positionButtons(), !this.initialButtonGroupWidth) {
+                let S = 0;
+                p && (S += p.getBBox().width + 5), e.forEach((T, B) => {
+                  S += T.width || 0, B !== e.length - 1 && (S += d.buttonSpacing);
+                }), this.initialButtonGroupWidth = S;
+              }
+              h -= i.spacing[3];
+              let v = n(t, f, f.align === "right" || l.align === "right");
+              this.alignButtonGroup(v), this.buttonGroup?.translateY && this.dropdownLabel.attr({ y: this.buttonGroup.translateY }), s.placed = t.placed = i.hasLoaded;
+            }
+            let m = 0;
+            d.inputEnabled && o && (m = n(o, l, f.align === "right" || l.align === "right"), l.align === "left" ? g = h : l.align === "right" && (g = -Math.max(i.axisOffset[1], -m)), o.align({ y: l.y, width: o.getBBox().width, align: l.align, x: l.x + g - 2 }, !0, i.spacingBox), o.placed = i.hasLoaded), this.handleCollision(m), s.align({ verticalAlign: r }, !0, i.spacingBox);
+            let x = s.alignAttr.translateY, b = s.getBBox().height + 20, A = 0;
+            if (r === "bottom") {
+              let v = i.legend && i.legend.options;
+              A = x - (b = b + (v && v.verticalAlign === "bottom" && v.enabled && !v.floating ? i.legend.legendHeight + J(v.margin, 10) : 0) - 20) - (d.floating ? 0 : d.y) - (i.titleOffset ? i.titleOffset[2] : 0) - 10;
+            }
+            r === "top" ? (d.floating && (A = 0), i.titleOffset && i.titleOffset[0] && (A = i.titleOffset[0]), A += i.margin[0] - i.spacing[0] || 0) : r === "middle" && (l.y === f.y ? A = x : (l.y || f.y) && (l.y < 0 || f.y < 0 ? A -= Math.min(l.y, f.y) : A = x - b)), s.translate(d.x, d.y + Math.floor(A));
+            let { minInput: y, maxInput: k, dropdown: M } = this;
+            d.inputEnabled && y && k && (y.style.marginTop = s.translateY + "px", k.style.marginTop = s.translateY + "px"), M && (M.style.marginTop = s.translateY + "px");
+          }
+        }
+        redrawElements() {
+          let t = this.chart, { inputBoxHeight: e, inputBoxBorderColor: i } = this.options;
+          if (this.maxDateBox?.attr({ height: e }), this.minDateBox?.attr({ height: e }), t.styledMode || (this.maxDateBox?.attr({ stroke: i }), this.minDateBox?.attr({ stroke: i })), this.isDirty) {
+            this.isDirty = !1, this.isCollapsed = void 0;
+            let s = this.options.buttons ?? [], o = Math.min(s.length, this.buttonOptions.length), { dropdown: d, options: p } = this, u = at(p.buttonTheme), c = u && u.states, f = u.width || 28;
+            if (s.length < this.buttonOptions.length) for (let l = this.buttonOptions.length - 1; l >= s.length; l--)
+              this.buttons.pop()?.destroy(), this.dropdown?.options.remove(l + 1);
+            for (let l = o - 1; l >= 0; l--) {
+              let r = s[l];
+              this.buttons[l].destroy(), d?.options.remove(l + 1), this.createButton(r, l, f, c), this.computeButtonRange(r);
+            }
+            if (s.length > this.buttonOptions.length) for (let l = this.buttonOptions.length; l < s.length; l++) this.createButton(s[l], l, f, c), this.computeButtonRange(s[l]);
+            this.buttonOptions = this.options.buttons ?? [], it(this.options.selected) && this.buttons.length && this.clickButton(this.options.selected, !1);
+          }
+        }
+        alignButtonGroup(t, e) {
+          let { chart: i, options: s, buttonGroup: o, dropdown: d, dropdownLabel: p } = this, { buttonPosition: u } = s, c = i.plotLeft - i.spacing[3], f = u.x - i.spacing[3], l = i.plotLeft;
+          u.align === "right" ? (f += t - c, this.hasVisibleDropdown && (l = i.chartWidth + t - this.maxButtonWidth() - 20)) : u.align === "center" && (f -= c / 2, this.hasVisibleDropdown && (l = i.chartWidth / 2 - this.maxButtonWidth())), d && et(d, { left: l + "px", top: o?.translateY + "px" }), p?.attr({ x: l }), o && o.align({ y: u.y, width: J(e, this.initialButtonGroupWidth), align: u.align, x: f }, !0, i.spacingBox);
+        }
+        positionButtons() {
+          let { buttons: t, chart: e, options: i, zoomText: s } = this, o = e.hasLoaded ? "animate" : "attr", { buttonPosition: d } = i, p = e.plotLeft, u = p;
+          s && s.visibility !== "hidden" && (s[o]({ x: J(p + d.x, p) }), u += d.x + s.getBBox().width + 5);
+          for (let c = 0, f = this.buttonOptions.length; c < f; ++c) t[c].visibility !== "hidden" ? (t[c][o]({ x: u }), u += (t[c].width || 0) + i.buttonSpacing) : t[c][o]({ x: p });
+        }
+        handleCollision(t) {
+          let { chart: e, buttonGroup: i, inputGroup: s, initialButtonGroupWidth: o } = this, { buttonPosition: d, dropdown: p, inputPosition: u } = this.options, c = () => {
+            s && i && s.attr({ translateX: s.alignAttr.translateX + (e.axisOffset[1] >= -t ? 0 : -t), translateY: s.alignAttr.translateY + i.getBBox().height + 10 });
+          };
+          s && i ? u.align === d.align ? (c(), o > e.plotWidth + t - 20 ? this.collapseButtons() : this.expandButtons()) : o - t + s.getBBox().width > e.plotWidth ? p === "responsive" || p === "always" ? this.collapseButtons() : c() : this.expandButtons() : i && p === "responsive" && (o > e.plotWidth ? this.collapseButtons() : this.expandButtons()), i && (p === "always" && this.collapseButtons(), p === "never" && this.expandButtons()), this.alignButtonGroup(t);
+        }
+        collapseButtons() {
+          let { buttons: t, zoomText: e } = this;
+          this.isCollapsed !== !0 && (this.isCollapsed = !0, e.hide(), t.forEach((i) => void i.hide()), this.showDropdown());
+        }
+        expandButtons() {
+          let { buttons: t, zoomText: e } = this;
+          this.isCollapsed !== !1 && (this.isCollapsed = !1, this.hideDropdown(), e.show(), t.forEach((i) => void i.show()), this.positionButtons());
+        }
+        showDropdown() {
+          let { buttonGroup: t, dropdownLabel: e, dropdown: i } = this;
+          t && i && (e.show(), et(i, { visibility: "inherit" }), this.hasVisibleDropdown = !0);
+        }
+        hideDropdown() {
+          let { dropdown: t } = this;
+          t && (this.dropdownLabel.hide(), et(t, { visibility: "hidden" }), this.hasVisibleDropdown = !1);
+        }
+        getHeight() {
+          let t = this.options, e = this.group, i = t.inputPosition, s = t.buttonPosition, o = t.y, d = s.y, p = i.y, u = 0;
+          if (t.height) return t.height;
+          this.alignElements(), u = e ? e.getBBox(!0).height + 13 + o : 0;
+          let c = Math.min(p, d);
+          return (p < 0 && d < 0 || p > 0 && d > 0) && (u += Math.abs(c)), u;
+        }
+        titleCollision(t) {
+          return !(t.options.title.text || t.options.subtitle.text);
+        }
+        update(t, e = !0) {
+          let i = this.chart;
+          if (at(!0, this.options, t), this.options.selected && this.options.selected >= this.options.buttons.length && (this.options.selected = void 0, i.options.rangeSelector.selected = void 0), it(t.enabled)) return this.destroy(), this.init(i);
+          this.isDirty = !!t.buttons || !!t.buttonTheme, e && this.render();
+        }
+        destroy() {
+          let t = this, e = t.minInput, i = t.maxInput;
+          t.eventsToUnbind && (t.eventsToUnbind.forEach((s) => s()), t.eventsToUnbind = void 0), Wo(t.buttons), e && (e.onfocus = e.onblur = e.onchange = null), i && (i.onfocus = i.onblur = i.onchange = null), Ho(t, function(s, o) {
+            s && o !== "chart" && (s instanceof fi() ? s.destroy() : s instanceof window.HTMLElement && Xo(s), delete t[o]), s !== Wt.prototype[o] && (t[o] = null);
+          }, this), this.buttons = [];
+        }
+      }
+      xi(Wt.prototype, { inputTypeFormats: { "datetime-local": "%Y-%m-%dT%H:%M:%S", date: "%Y-%m-%d", time: "%H:%M:%S" } });
+      var No = I(960), vi = I.n(No);
+      let { format: Fo } = Se(), { getOptions: yi } = C(), { setFixedRange: Uo } = $e, { addEvent: xt, clamp: Vo, crisp: Mi, defined: Oe, extend: _o, find: jo, isNumber: nt, isString: qo, merge: St, pick: st, splat: Ai } = C();
+      function Be(a, t, e) {
+        return a === "xAxis" ? { minPadding: 0, maxPadding: 0, overscroll: 0, ordinal: !0 } : a === "yAxis" ? { labels: { y: -2 }, opposite: e.opposite ?? t.opposite ?? !0, showLastLabel: !!(t.categories || t.type === "category"), title: { text: void 0 } } : {};
+      }
+      function ki(a, t) {
+        if (a === "xAxis") {
+          let e = st(t.navigator?.enabled, ve.enabled, !0), i = { type: "datetime", categories: void 0 };
+          return e && (i.startOnTick = !1, i.endOnTick = !1), i;
+        }
+        return {};
+      }
+      class Ce extends vi() {
+        init(t, e) {
+          let i = yi(), s = t.xAxis, o = t.yAxis, d = st(t.navigator?.enabled, ve.enabled, !0);
+          t.xAxis = t.yAxis = void 0;
+          let p = St({ chart: { panning: { enabled: !0, type: "x" }, zooming: { pinchType: "x", mouseWheel: { type: "x" } } }, navigator: { enabled: d }, scrollbar: { enabled: st(Nt.enabled, !0) }, rangeSelector: { enabled: st(di.enabled, !0) }, title: { text: null }, tooltip: { split: st(i.tooltip?.split, !0), crosshairs: !0 }, legend: { enabled: !1 } }, t, { isStock: !0 });
+          t.xAxis = s, t.yAxis = o, p.xAxis = Ai(t.xAxis || {}).map((u) => St(Be("xAxis", u, i.xAxis), u, ki("xAxis", t))), p.yAxis = Ai(t.yAxis || {}).map((u) => St(Be("yAxis", u, i.yAxis), u)), super.init(p, e);
+        }
+        createAxis(t, e) {
+          return e.axis = St(Be(t, e.axis, yi()[t]), e.axis, ki(t, this.userOptions)), super.createAxis(t, e);
+        }
+      }
+      xt(vi(), "update", function(a) {
+        let t = a.options;
+        "scrollbar" in t && this.navigator && (St(!0, this.options.scrollbar, t.scrollbar), this.navigator.update({ enabled: !!this.navigator.navigatorEnabled }), delete t.scrollbar);
+      }), function(a) {
+        function t(c) {
+          if (!(this.crosshair?.label?.enabled && this.cross && nt(this.min) && nt(this.max))) return;
+          let f = this.chart, l = this.logarithmic, r = this.crosshair.label, n = this.horiz, h = this.opposite, g = this.left, m = this.top, x = this.width, b = this.options.tickPosition === "inside", A = this.crosshair.snap !== !1, y = c.e || this.cross?.e, k = c.point, M = this.crossLabel, v, S, T = r.format, B = "", w, E = 0, P = this.min, O = this.max;
+          l && (P = l.lin2log(this.min), O = l.lin2log(this.max));
+          let D = n ? "center" : h ? this.labelAlign === "right" ? "right" : "left" : this.labelAlign === "left" ? "left" : "center";
+          !M && (M = this.crossLabel = f.renderer.label("", 0, void 0, r.shape || "callout").addClass("highcharts-crosshair-label highcharts-color-" + (k?.series ? k.series.colorIndex : this.series[0] && this.series[0].colorIndex)).attr({ align: r.align || D, padding: st(r.padding, 8), r: st(r.borderRadius, 3), zIndex: 2 }).add(this.labelGroup), f.styledMode || M.attr({ fill: r.backgroundColor || k?.series?.color || "#666666", stroke: r.borderColor || "", "stroke-width": r.borderWidth || 0 }).css(_o({ color: "#ffffff", fontWeight: "normal", fontSize: "0.7em", textAlign: "center" }, r.style || {}))), n ? (v = A ? (k.plotX || 0) + g : y.chartX, S = m + (h ? 0 : this.height)) : (v = g + this.offset + (h ? x : 0), S = A ? (k.plotY || 0) + m : y.chartY), T || r.formatter || (this.dateTime && (B = "%b %d, %Y"), T = "{value" + (B ? ":" + B : "") + "}");
+          let R = A ? this.isXAxis ? k.x : k.y : this.toValue(n ? y.chartX : y.chartY), H = k?.series ? k.series.isPointInside(k) : nt(R) && R > P && R < O, L = "";
+          T ? L = Fo(T, { value: R }, f) : r.formatter && nt(R) && (L = r.formatter.call(this, R)), M.attr({ text: L, x: v, y: S, visibility: H ? "inherit" : "hidden" });
+          let z = M.getBBox();
+          !nt(M.x) || n || h || (v = M.x - z.width / 2), nt(M.y) && (n ? (b && !h || !b && h) && (S = M.y - z.height) : S = M.y - z.height / 2), w = n ? { left: g, right: g + this.width } : { left: this.labelAlign === "left" ? g : 0, right: this.labelAlign === "right" ? g + this.width : f.chartWidth };
+          let W = M.translateX || 0;
+          W < w.left && (E = w.left - W), W + z.width >= w.right && (E = -(W + z.width - w.right)), M.attr({ x: Math.max(0, v + E), y: Math.max(0, S), anchorX: n ? v : this.opposite ? 0 : f.chartWidth, anchorY: n ? this.opposite ? f.chartHeight : 0 : S + z.height / 2 });
+        }
+        function e() {
+          this.crossLabel && (this.crossLabel = this.crossLabel.hide());
+        }
+        function i(c) {
+          let f = this.chart, l = this.options, r = f._labelPanes = f._labelPanes || {}, n = l.labels;
+          if (f.options.isStock && this.coll === "yAxis") {
+            let h = l.top + "," + l.height;
+            !r[h] && n.enabled && (n.distance === 15 && this.side === 1 && (n.distance = 0), n.align === void 0 && (n.align = "right"), r[h] = this, c.align = "right", c.preventDefault());
+          }
+        }
+        function s() {
+          let c = this.chart, f = this.options && this.options.top + "," + this.options.height;
+          f && c._labelPanes && c._labelPanes[f] === this && delete c._labelPanes[f];
+        }
+        function o(c) {
+          let f = this.isLinked && !this.series && this.linkedParent ? this.linkedParent.series : this.series, { chart: l, horiz: r } = this, n = l.renderer, h = [], { acrossPanes: g = !0, force: m, translatedValue: x, value: b } = c, A = (this.isXAxis ? l.yAxis : l.xAxis) || [];
+          function y(S, T, B) {
+            h.push(["M", r ? S : T, r ? T : S], ["L", r ? S : B, r ? B : S]);
+          }
+          let k = [], M, v;
+          if (l.options.isStock && (this.coll === "xAxis" || this.coll === "yAxis")) {
+            let S, T;
+            for (let B of (c.preventDefault(), S = this.coll === "xAxis" ? "yAxis" : "xAxis", T = this.options[S], k = g && !this.options.isInternal ? A.filter((w) => !w.options.isInternal) : nt(T) ? [l[S][T]] : qo(T) ? [l.get(T)] : f.map((w) => w[S]), A)) if (!B.options.isInternal) {
+              let w = B.isXAxis ? "yAxis" : "xAxis";
+              this === (Oe(B.options[w]) && l[w][B.options[w]]) && k.push(B);
+            }
+            for (let B of (M = k.length ? [] : [this.isXAxis ? l.yAxis[0] : l.xAxis[0]], k)) M.indexOf(B) !== -1 || jo(M, (w) => w.pos === B.pos && w.len === B.len) || M.push(B);
+            if (nt(v = st(x, this.translate(b || 0, void 0, void 0, c.old)))) {
+              let B, w = r ? v + this.pos : this.pos + this.len - v;
+              if (m !== "pass" && (w < this.pos || w > this.pos + this.len) && (m ? w = Vo(w, this.pos, this.pos + this.len) : B = !0), !B) {
+                let E = r ? "top" : "left", P = r ? "height" : "width";
+                if (!g && (this.options[E] || this.options[P])) y(w, this[E], this[E] + this[P]);
+                else for (let O of M) y(w, O.pos, O.pos + O.len);
+              }
+            }
+            c.path = h.length > 0 ? n.crispPolyLine(h, c.lineWidth || 1) : void 0;
+          }
+        }
+        function d(c) {
+          if (this.chart.options.isStock) {
+            let f;
+            this.is("column") || this.is("columnrange") ? f = { borderWidth: 0, shadow: !1 } : this.is("scatter") || this.is("sma") || (f = { marker: { enabled: !1, radius: 2 } }), f && (c.plotOptions[this.type] = St(c.plotOptions[this.type], f));
+          }
+        }
+        function p() {
+          let c = this.chart, f = this.options.dataGrouping;
+          return this.allowDG !== !1 && f && st(f.enabled, c.options.isStock);
+        }
+        function u(c, f) {
+          for (let l = 0; l < c.length; l += 2) {
+            let r = c[l], n = c[l + 1];
+            Oe(r[1]) && r[1] === n[1] && (r[1] = n[1] = Mi(r[1], f)), Oe(r[2]) && r[2] === n[2] && (r[2] = n[2] = Mi(r[2], f));
+          }
+          return c;
+        }
+        a.compose = function(c, f, l, r) {
+          let n = l.prototype;
+          n.forceCropping || (xt(f, "afterDrawCrosshair", t), xt(f, "afterHideCrosshair", e), xt(f, "autoLabelAlign", i), xt(f, "destroy", s), xt(f, "getPlotLinePath", o), c.prototype.setFixedRange = Uo, n.forceCropping = p, xt(l, "setOptions", d), r.prototype.crispPolyLine = u);
+        }, a.stockChart = function(c, f, l) {
+          return new a(c, f, l);
+        };
+      }(Ce || (Ce = {}));
+      let wi = Ce, { column: { prototype: { pointClass: Zo } } } = j().seriesTypes, { column: Si } = j().seriesTypes, { crisp: Ti, extend: Ei, merge: Ko } = C(), { defaultOptions: $o } = C();
+      class Pe extends Si {
+        extendStem(t, e, i) {
+          let s = t[0], o = t[1];
+          typeof s[2] == "number" && (s[2] = Math.max(i + e, s[2])), typeof o[2] == "number" && (o[2] = Math.min(i - e, o[2]));
+        }
+        getPointPath(t, e) {
+          let i = e.strokeWidth(), s = t.series, o = Ti(t.plotX || 0, i), d = Math.round(t.shapeArgs.width / 2), p = [["M", o, Math.round(t.yBottom)], ["L", o, Math.round(t.plotHigh)]];
+          if (t.close !== null) {
+            let u = Ti(t.plotClose, i);
+            p.push(["M", o, u], ["L", o + d, u]), s.extendStem(p, i / 2, u);
+          }
+          return p;
+        }
+        drawSinglePoint(t) {
+          let e = t.series, i = e.chart, s, o = t.graphic;
+          t.plotY !== void 0 && (o || (t.graphic = o = i.renderer.path().add(e.group)), i.styledMode || o.attr(e.pointAttribs(t, t.selected && "select")), s = e.getPointPath(t, o), o[o ? "animate" : "attr"]({ d: s }).addClass(t.getClassName(), !0));
+        }
+        drawPoints() {
+          this.points.forEach(this.drawSinglePoint);
+        }
+        init() {
+          super.init.apply(this, arguments), this.options.stacking = void 0;
+        }
+        pointAttribs(t, e) {
+          let i = super.pointAttribs.call(this, t, e);
+          return delete i.fill, i;
+        }
+        toYData(t) {
+          return [t.high, t.low, t.close];
+        }
+        translate() {
+          let t = this, e = t.yAxis, i = this.pointArrayMap && this.pointArrayMap.slice() || [], s = i.map((o) => `plot${o.charAt(0).toUpperCase() + o.slice(1)}`);
+          s.push("yBottom"), i.push("low"), super.translate.apply(t), t.points.forEach(function(o) {
+            i.forEach(function(d, p) {
+              let u = o[d];
+              u !== null && (t.dataModify && (u = t.dataModify.modifyValue(u)), o[s[p]] = e.toPixels(u, !0));
+            }), o.tooltipPos[1] = o.plotHigh + e.pos - t.chart.plotTop;
+          });
+        }
+      }
+      Pe.defaultOptions = Ko(Si.defaultOptions, { lineWidth: 1, tooltip: { pointFormat: '<span style="color:{point.color}">●</span> <b> {series.name}</b><br/>{series.chart.options.lang.stockHigh}: {point.high}<br/>{series.chart.options.lang.stockLow}: {point.low}<br/>{series.chart.options.lang.stockClose}: {point.close}<br/>' }, threshold: null, states: { hover: { lineWidth: 3 } }, stickyTracking: !0 }), Ei(Pe.prototype, { pointClass: class extends Zo {
+      }, animate: null, directTouch: !1, keysAffectYAxis: ["low", "high"], pointArrayMap: ["high", "low", "close"], pointAttrToOptions: { stroke: "color", "stroke-width": "lineWidth" }, pointValKey: "close" }), Ei($o.lang, { stockOpen: "Open", stockHigh: "High", stockLow: "Low", stockClose: "Close" }), j().registerSeriesType("hlc", Pe);
+      let { seriesTypes: { hlc: Jo } } = j();
+      class Qo extends Jo.prototype.pointClass {
+        getClassName() {
+          return super.getClassName.call(this) + (this.open < this.close ? " highcharts-point-up" : " highcharts-point-down");
+        }
+        resolveUpColor() {
+          this.open < this.close && !this.options.color && this.series.options.upColor && (this.color = this.series.options.upColor);
+        }
+        resolveColor() {
+          super.resolveColor(), this.series.is("heikinashi") || this.resolveUpColor();
+        }
+        getZone() {
+          let t = super.getZone();
+          return this.resolveUpColor(), t;
+        }
+        applyOptions() {
+          return super.applyOptions.apply(this, arguments), this.resolveColor && this.resolveColor(), this;
+        }
+      }
+      let { composed: tr } = C(), { hlc: Oi } = j().seriesTypes, { addEvent: Bi, crisp: Ci, extend: Pi, merge: er, pushUnique: ir } = C();
+      function sr(a) {
+        let t = a.options, e = t.dataGrouping;
+        e && t.useOhlcData && t.id !== "highcharts-navigator-series" && (e.approximation = "ohlc");
+      }
+      function or(a) {
+        let t = a.options;
+        t.useOhlcData && t.id !== "highcharts-navigator-series" && Pi(this, { pointValKey: bt.prototype.pointValKey, pointArrayMap: bt.prototype.pointArrayMap, toYData: bt.prototype.toYData });
+      }
+      class bt extends Oi {
+        static compose(t) {
+          ir(tr, "OHLCSeries") && (Bi(t, "afterSetOptions", sr), Bi(t, "init", or));
+        }
+        getPointPath(t, e) {
+          let i = super.getPointPath(t, e), s = e.strokeWidth(), o = Ci(t.plotX || 0, s), d = Math.round(t.shapeArgs.width / 2);
+          if (t.open !== null) {
+            let p = Ci(t.plotOpen, s);
+            i.push(["M", o, p], ["L", o - d, p]), super.extendStem(i, s / 2, p);
+          }
+          return i;
+        }
+        pointAttribs(t, e) {
+          let i = super.pointAttribs.call(this, t, e), s = this.options;
+          return delete i.fill, !t.options.color && s.upColor && t.open < t.close && (i.stroke = s.upColor), i;
+        }
+        toYData(t) {
+          return [t.open, t.high, t.low, t.close];
+        }
+      }
+      bt.defaultOptions = er(Oi.defaultOptions, { tooltip: { pointFormat: '<span style="color:{point.color}">●</span> <b> {series.name}</b><br/>{series.chart.options.lang.stockOpen}: {point.open}<br/>{series.chart.options.lang.stockHigh}: {point.high}<br/>{series.chart.options.lang.stockLow}: {point.low}<br/>{series.chart.options.lang.stockClose}: {point.close}<br/>' } }), Pi(bt.prototype, { pointClass: Qo, pointArrayMap: ["open", "high", "low", "close"] }), j().registerSeriesType("ohlc", bt);
+      let { column: rr, ohlc: De } = j().seriesTypes, { crisp: Re, merge: ar } = C();
+      class Di extends De {
+        pointAttribs(t, e) {
+          let i = rr.prototype.pointAttribs.call(this, t, e), s = this.options, o = t.open < t.close, d = s.lineColor || this.color, p = t.color || this.color;
+          if (i["stroke-width"] = s.lineWidth, i.fill = t.options.color || o && s.upColor || p, i.stroke = t.options.lineColor || o && s.upLineColor || d, e) {
+            let u = s.states[e];
+            i.fill = u.color || i.fill, i.stroke = u.lineColor || i.stroke, i["stroke-width"] = u.lineWidth || i["stroke-width"];
+          }
+          return i;
+        }
+        drawPoints() {
+          let t = this.points, e = this.chart, i = this.yAxis.reversed;
+          for (let s of t) {
+            let o = s.graphic, d, p, u, c, f, l, r, n, h, g = !o;
+            if (s.plotY !== void 0) {
+              o || (s.graphic = o = e.renderer.path().add(this.group)), this.chart.styledMode || o.attr(this.pointAttribs(s, s.selected && "select")).shadow(this.options.shadow);
+              let m = o.strokeWidth();
+              r = Re(s.plotX || 0, m), u = Math.min(d = s.plotOpen, p = s.plotClose), c = Math.max(d, p), h = Math.round(s.shapeArgs.width / 2), f = i ? c !== s.yBottom : Math.round(u) !== Math.round(s.plotHigh || 0), l = i ? Math.round(u) !== Math.round(s.plotHigh || 0) : c !== s.yBottom, u = Re(u, m), c = Re(c, m), (n = []).push(["M", r - h, c], ["L", r - h, u], ["L", r + h, u], ["L", r + h, c], ["Z"], ["M", r, u], ["L", r, f ? Math.round(i ? s.yBottom : s.plotHigh) : u], ["M", r, c], ["L", r, l ? Math.round(i ? s.plotHigh : s.yBottom) : c]), o[g ? "attr" : "animate"]({ d: n }).addClass(s.getClassName(), !0);
+            }
+          }
+        }
+      }
+      Di.defaultOptions = ar(De.defaultOptions, { tooltip: De.defaultOptions.tooltip }, { states: { hover: { lineWidth: 2 } }, threshold: null, lineColor: "#000000", lineWidth: 1, upColor: "#ffffff", stickyTracking: !0 }), j().registerSeriesType("candlestick", Di);
+      let { column: { prototype: { pointClass: nr } } } = j().seriesTypes, { isNumber: lr } = C(), hr = class extends nr {
+        constructor() {
+          super(...arguments), this.ttBelow = !1;
+        }
+        isValid() {
+          return lr(this.y) || this.y === void 0;
+        }
+        hasNewShapeType() {
+          let a = this.options.shape || this.series.options.shape;
+          return this.graphic && a && a !== this.graphic.symbolKey;
+        }
+      };
+      (function(a) {
+        let t = [];
+        function e(s, o, d, p, u) {
+          let c = u && u.anchorX || s, f = u && u.anchorY || o, l = this.circle(c - 1, f - 1, 2, 2);
+          return l.push(["M", c, f], ["L", s, o + p], ["L", s, o], ["L", s + d, o], ["L", s + d, o + p], ["L", s, o + p], ["Z"]), l;
+        }
+        function i(s, o) {
+          s[o + "pin"] = function(d, p, u, c, f) {
+            let l, r = f && f.anchorX, n = f && f.anchorY;
+            if (o === "circle" && c > u && (d -= Math.round((c - u) / 2), u = c), l = s[o](d, p, u, c, f), r && n) {
+              let h = r;
+              if (o === "circle") h = d + u / 2;
+              else {
+                let m = l[0], x = l[1];
+                m[0] === "M" && x[0] === "L" && (h = (m[1] + x[1]) / 2);
+              }
+              let g = p > n ? p : p + c;
+              l.push(["M", h, g], ["L", r, n]), l = l.concat(s.circle(r - 1, n - 1, 2, 2));
+            }
+            return l;
+          };
+        }
+        a.compose = function(s) {
+          if (t.indexOf(s) === -1) {
+            t.push(s);
+            let d = s.prototype.symbols;
+            d.flag = e, i(d, "circle"), i(d, "square");
+          }
+          let o = Ze().getRendererType();
+          t.indexOf(o) && t.push(o);
+        };
+      })(de || (de = {}));
+      let dr = de;
+      var pr = I(448), ur = I.n(pr);
+      let { composed: cr } = C(), { prototype: gr } = ur(), { prototype: fr } = Ye(), { defined: Ge, pushUnique: mr, stableSort: xr } = C();
+      var Ie = pe || (pe = {});
+      function Ri(a) {
+        return fr.getPlotBox.call(this.options.onSeries && this.chart.get(this.options.onSeries) || this, a);
+      }
+      function Gi() {
+        gr.translate.apply(this);
+        let a = this, t = a.options, e = a.chart, i = a.points, s = t.onSeries, o = s && e.get(s), d = o && o.options.step, p = o && o.points, u = e.inverted, c = a.xAxis, f = a.yAxis, l = i.length - 1, r, n, h = t.onKey || "y", g = p && p.length, m = 0, x, b, A, y, k;
+        if (o && o.visible && g) {
+          for (m = (o.pointXOffset || 0) + (o.barW || 0) / 2, y = o.currentDataGrouping, b = p[g - 1].x + (y ? y.totalRange : 0), xr(i, (M, v) => M.x - v.x), h = "plot" + h[0].toUpperCase() + h.substr(1); g-- && i[l]; ) if (x = p[g], (r = i[l]).y = x.y, x.x <= r.x && x[h] !== void 0) {
+            if (r.x <= b && (r.plotY = x[h], x.x < r.x && !d && (A = p[g + 1])) && A[h] !== void 0) if (Ge(r.plotX) && o.is("spline")) {
+              let M = [x.plotX || 0, x.plotY || 0], v = [A.plotX || 0, A.plotY || 0], S = x.controlPoints?.high || M, T = A.controlPoints?.low || v, B = (O, D) => Math.pow(1 - O, 3) * M[D] + 3 * (1 - O) * (1 - O) * O * S[D] + 3 * (1 - O) * O * O * T[D] + O * O * O * v[D], w = 0, E = 1, P;
+              for (let O = 0; O < 100; O++) {
+                let D = (w + E) / 2, R = B(D, 0);
+                if (R === null) break;
+                if (0.25 > Math.abs(R - r.plotX)) {
+                  P = D;
+                  break;
+                }
+                R < r.plotX ? w = D : E = D;
+              }
+              Ge(P) && (r.plotY = B(P, 1), r.y = f.toValue(r.plotY, !0));
+            } else k = (r.x - x.x) / (A.x - x.x), r.plotY += k * (A[h] - x[h]), r.y += k * (A.y - x.y);
+            if (l--, g++, l < 0) break;
+          }
+        }
+        i.forEach((M, v) => {
+          let S;
+          M.plotX += m, (M.plotY === void 0 || u) && (M.plotX >= 0 && M.plotX <= c.len ? u ? (M.plotY = c.translate(M.x, 0, 1, 0, 1), M.plotX = Ge(M.y) ? f.translate(M.y, 0, 0, 0, 1) : 0) : M.plotY = (c.opposite ? 0 : a.yAxis.len) + c.offset : M.shapeArgs = {}), (n = i[v - 1]) && n.plotX === M.plotX && (n.stackIndex === void 0 && (n.stackIndex = 0), S = n.stackIndex + 1), M.stackIndex = S;
+        }), this.onSeries = o;
+      }
+      Ie.compose = function(a) {
+        if (mr(cr, "OnSeries")) {
+          let t = a.prototype;
+          t.getPlotBox = Ri, t.translate = Gi;
+        }
+        return a;
+      }, Ie.getPlotBox = Ri, Ie.translate = Gi;
+      let br = pe, { noop: vr } = C(), { distribute: yr } = C(), { series: Ii, seriesTypes: { column: zi } } = j(), { addEvent: Mr, defined: Ar, extend: kr, isNumber: wr, merge: Li, objectEach: Sr, wrap: Tr } = C();
+      class Tt extends zi {
+        animate(t) {
+          t && this.setClip();
+        }
+        drawPoints() {
+          let t, e, i, s, o, d, p, u, c, f, l, r = this.points, n = this.chart, h = n.renderer, g = n.inverted, m = this.options, x = m.y, b = this.yAxis, A = {}, y = [], k = wr(m.borderRadius) ? m.borderRadius : 0;
+          for (s = r.length; s--; ) o = r[s], f = (g ? o.plotY : o.plotX) > this.xAxis.len, t = o.plotX, p = o.stackIndex, i = o.options.shape || m.shape, (e = o.plotY) !== void 0 && (e = o.plotY + x - (p !== void 0 && p * m.stackDistance)), o.anchorX = p ? void 0 : o.plotX, u = p ? void 0 : o.plotY, l = i !== "flag", d = o.graphic, e !== void 0 && t >= 0 && !f ? (d && o.hasNewShapeType() && (d = d.destroy()), d || (d = o.graphic = h.label("", 0, void 0, i, void 0, void 0, m.useHTML).addClass(o.getClassName()).add(this.markerGroup), o.graphic.div && (o.graphic.div.point = o), d.isNew = !0), d.attr({ align: l ? "center" : "left", width: m.width, height: m.height, "text-align": m.textAlign, r: k }), n.styledMode || d.attr(this.pointAttribs(o)).css(Li(m.style, o.style)).shadow(m.shadow), t > 0 && (t -= d.strokeWidth() % 2), c = { y: e, anchorY: u }, m.allowOverlapX && (c.x = t, c.anchorX = o.anchorX), d.attr({ text: o.options.title ?? m.title ?? "A" })[d.isNew ? "attr" : "animate"](c), m.allowOverlapX || (A[o.plotX] ? A[o.plotX].size = Math.max(A[o.plotX].size, d.width || 0) : A[o.plotX] = { align: 0.5 * !!l, size: d.width || 0, target: t, anchorX: t }), o.tooltipPos = [t, e + b.pos - n.plotTop]) : d && (o.graphic = d.destroy());
+          if (!m.allowOverlapX) {
+            let M = 100;
+            for (let v of (Sr(A, function(S) {
+              S.plotX = S.anchorX, y.push(S), M = Math.max(S.size, M);
+            }), yr(y, g ? b.len : this.xAxis.len, M), r)) {
+              let S = v.plotX, T = v.graphic, B = T && A[S];
+              B && T && (Ar(B.pos) ? T[T.isNew ? "attr" : "animate"]({ x: B.pos + (B.align || 0) * B.size, anchorX: v.anchorX }).show().isNew = !1 : T.hide().isNew = !0);
+            }
+          }
+          m.useHTML && this.markerGroup && Tr(this.markerGroup, "on", function(M) {
+            return fi().prototype.on.apply(M.apply(this, [].slice.call(arguments, 1)), [].slice.call(arguments, 1));
+          });
+        }
+        drawTracker() {
+          let t = this.points;
+          for (let e of (super.drawTracker(), t)) {
+            let i = e.graphic;
+            i && (e.unbindMouseOver && e.unbindMouseOver(), e.unbindMouseOver = Mr(i.element, "mouseover", function() {
+              for (let s of (e.stackIndex > 0 && !e.raised && (e._y = i.y, i.attr({ y: e._y - 8 }), e.raised = !0), t)) s !== e && s.raised && s.graphic && (s.graphic.attr({ y: s._y }), s.raised = !1);
+            }));
+          }
+        }
+        pointAttribs(t, e) {
+          let i = this.options, s = t && t.color || this.color, o = i.lineColor, d = t && t.lineWidth, p = t && t.fillColor || i.fillColor;
+          return e && (p = i.states[e].fillColor, o = i.states[e].lineColor, d = i.states[e].lineWidth), { fill: p || s, stroke: o || s, "stroke-width": d || i.lineWidth || 0 };
+        }
+        setClip() {
+          Ii.prototype.setClip.apply(this, arguments), this.options.clip !== !1 && this.sharedClipKey && this.markerGroup && this.markerGroup.clip(this.chart.sharedClips[this.sharedClipKey]);
+        }
+      }
+      Tt.compose = dr.compose, Tt.defaultOptions = Li(zi.defaultOptions, { borderRadius: 0, pointRange: 0, allowOverlapX: !1, shape: "flag", stackDistance: 12, textAlign: "center", tooltip: { pointFormat: "{point.text}" }, threshold: null, y: -30, fillColor: "#ffffff", lineWidth: 1, states: { hover: { lineColor: "#000000", fillColor: "#ccd3ff" } }, style: { color: "#000000", fontSize: "0.7em", fontWeight: "bold" } }), br.compose(Tt), kr(Tt.prototype, { allowDG: !1, forceCrop: !0, invertible: !1, noSharedTooltip: !0, pointClass: hr, sorted: !1, takeOrdinalPosition: !1, trackerGroups: ["markerGroup"], buildKDTree: vr, init: Ii.prototype.init }), j().registerSeriesType("flags", Tt);
+      var Er = I(184), Or = I.n(Er);
+      let { addEvent: Et, find: Br, fireEvent: Wi, isArray: Cr, isNumber: F, pick: Zt } = C();
+      (function(a) {
+        function t() {
+          this.brokenAxis !== void 0 && this.brokenAxis.setBreaks(this.options.breaks, !1);
+        }
+        function e() {
+          Object.keys(this.options.breaks?.[0] || {}).length && (this.options.ordinal = !1);
+        }
+        function i() {
+          let f = this.brokenAxis;
+          if (f?.hasBreaks) {
+            let l = this.tickPositions, r = this.tickPositions.info, n = [];
+            for (let h = 0; h < l.length; h++) f.isInAnyBreak(l[h]) || n.push(l[h]);
+            this.tickPositions = n, this.tickPositions.info = r;
+          }
+        }
+        function s() {
+          this.brokenAxis || (this.brokenAxis = new c(this));
+        }
+        function o() {
+          let { isDirty: f, options: { connectNulls: l }, points: r, xAxis: n, yAxis: h } = this;
+          if (f) {
+            let g = r.length;
+            for (; g--; ) {
+              let m = r[g], x = (m.y !== null || l !== !1) && (n?.brokenAxis?.isInAnyBreak(m.x, !0) || h?.brokenAxis?.isInAnyBreak(m.y, !0));
+              m.visible = !x && m.options.visible !== !1;
+            }
+          }
+        }
+        function d() {
+          this.drawBreaks(this.xAxis, ["x"]), this.drawBreaks(this.yAxis, Zt(this.pointArrayMap, ["y"]));
+        }
+        function p(f, l) {
+          let r, n, h, g = this, m = g.points;
+          if (f?.brokenAxis?.hasBreaks) {
+            let x = f.brokenAxis;
+            l.forEach(function(b) {
+              r = x?.breakArray || [], n = f.isXAxis ? f.min : Zt(g.options.threshold, f.min), m.forEach(function(A) {
+                h = A["stack" + b.toUpperCase()] ?? A[b], r.forEach(function(y) {
+                  if (F(n) && F(h)) {
+                    let k = "";
+                    n < y.from && h > y.to || n > y.from && h < y.from ? k = "pointBreak" : (n < y.from && h > y.from && h < y.to || n > y.from && h > y.to && h < y.from) && (k = "pointInBreak"), k && Wi(f, k, { point: A, brk: y });
+                  }
+                });
+              });
+            });
+          }
+        }
+        function u() {
+          let f = this.currentDataGrouping, l = f?.gapSize, r = this.points.slice(), n = this.yAxis, h = this.options.gapSize, g = r.length - 1;
+          if (h && g > 0) {
+            let m, x;
+            for (this.options.gapUnit !== "value" && (h *= this.basePointRange), l && l > h && l >= this.basePointRange && (h = l); g--; ) if (x && x.visible !== !1 || (x = r[g + 1]), m = r[g], x.visible !== !1 && m.visible !== !1) {
+              if (x.x - m.x > h) {
+                let b = (m.x + x.x) / 2;
+                r.splice(g + 1, 0, { isNull: !0, x: b }), n.stacking && this.options.stacking && ((n.stacking.stacks[this.stackKey][b] = new (Or())(n, n.options.stackLabels, !1, b, this.stack ?? "")).total = 0);
+              }
+              x = m;
+            }
+          }
+          return this.getGraphPath(r);
+        }
+        a.compose = function(f, l) {
+          if (!f.keepProps.includes("brokenAxis")) {
+            f.keepProps.push("brokenAxis"), Et(f, "init", s), Et(f, "afterInit", t), Et(f, "afterSetTickPositions", i), Et(f, "afterSetOptions", e);
+            let r = l.prototype;
+            r.drawBreaks = p, r.gappedPath = u, Et(l, "afterGeneratePoints", o), Et(l, "afterRender", d);
+          }
+          return f;
+        };
+        class c {
+          static isInBreak(l, r) {
+            let n = l.repeat || 1 / 0, h = l.from, g = l.to - l.from, m = r >= h ? (r - h) % n : n - (h - r) % n;
+            return l.inclusive ? m <= g : m < g && m !== 0;
+          }
+          static lin2Val(l) {
+            let r = this.min || 0, n = this.brokenAxis, h = n?.breakArray;
+            if (!h?.length || !F(l)) return l;
+            let g = l;
+            if (l > r) for (let m of h) {
+              if (m.from > g) break;
+              (m.to <= g && m.to > r || c.isInBreak(m, g)) && (g += m.len);
+            }
+            else if (l < r) for (let m of h) {
+              if (m.from > r) break;
+              (m.from >= g && m.from < r || c.isInBreak(m, g)) && (g -= m.len);
+            }
+            return g;
+          }
+          static val2Lin(l) {
+            let r = this.min || 0, n = this.brokenAxis, h = n?.breakArray;
+            if (!h?.length || !F(l)) return l;
+            let g = l;
+            if (l > r)
+              for (let m of h) if (m.to <= l && m.to > r) g -= m.len;
+              else {
+                if (m.from > l) break;
+                if (c.isInBreak(m, l)) {
+                  g -= l - m.from;
+                  break;
+                }
+              }
+            else if (l < r)
+              for (let m of h) if (m.from >= l && m.from < r) g += m.len;
+              else {
+                if (m.from > r) break;
+                if (c.isInBreak(m, l)) {
+                  g += m.to - l;
+                  break;
+                }
+              }
+            return g;
+          }
+          constructor(l) {
+            this.axis = l;
+          }
+          findBreakAt(l, r) {
+            return Br(r, function(n) {
+              return n.from < l && l < n.to;
+            });
+          }
+          isInAnyBreak(l, r) {
+            let n = this.axis, h = n.options.breaks || [], g = h.length, m, x, b;
+            if (g && F(l)) {
+              for (; g--; ) c.isInBreak(h[g], l) && (m = !0, x || (x = Zt(h[g].showPoints, !n.isXAxis)));
+              b = m && r ? m && !x : m;
+            }
+            return b;
+          }
+          setBreaks(l, r) {
+            let n = this, h = n.axis, g = h.chart.time, m = Cr(l) && !!Object.keys(l?.[0] || {}).length;
+            h.isDirty = (n.hasBreaks ?? !1) !== m, n.hasBreaks = m, l?.forEach((x) => {
+              x.from = g.parse(x.from) || 0, x.to = g.parse(x.to) || 0;
+            }), l !== h.options.breaks && (h.options.breaks = h.userOptions.breaks = l), h.forceRedraw = !0, h.series.forEach(function(x) {
+              x.isDirty = !0;
+            }), m || h.val2lin !== c.val2Lin || (delete h.val2lin, delete h.lin2val), m && (h.userOptions.ordinal = !1, h.lin2val = c.lin2Val, h.val2lin = c.val2Lin, h.setExtremes = function(x, b, A, y, k) {
+              if (n.hasBreaks && !h.treeGrid?.tree) {
+                let M, v = this.brokenAxis.breakArray || [];
+                for (; M = n.findBreakAt(x, v); ) x = M.to;
+                for (; M = n.findBreakAt(b, v); ) b = M.from;
+                b < x && (b = x);
+              }
+              h.constructor.prototype.setExtremes.call(this, x, b, A, y, k);
+            }, h.setAxisTranslation = function() {
+              if (h.constructor.prototype.setAxisTranslation.call(this), n.unitLength = void 0, n.hasBreaks) {
+                let x = h.options.breaks || [], b = [], A = [], y = h.pointRangePadding ?? 0, k = 0, M, v, S = h.userMin ?? h.min, T = h.userMax ?? h.max, B = h.dataMin ?? S, w = h.dataMax ?? T, E, P;
+                F(h.threshold) && (B = Math.min(B ?? h.threshold, h.threshold), w = Math.max(w ?? h.threshold, h.threshold)), h.treeGrid?.tree || x.forEach(function(O) {
+                  v = O.repeat || 1 / 0, F(S) && F(T) && (c.isInBreak(O, S) && (S += O.to % v - S % v), c.isInBreak(O, T) && (T -= T % v - O.from % v));
+                }), F(B) && F(w) && x.forEach(function(O) {
+                  for (E = O.from, v = O.repeat || 1 / 0; E - v > B; ) E -= v;
+                  for (; E < B; ) E += v;
+                  for (P = E; P < w; P += v) b.push({ value: P, move: "in" }), b.push({ value: P + O.to - O.from, move: "out", size: O.breakSize });
+                }), b.sort(function(O, D) {
+                  return O.value === D.value ? (O.move !== "in") - (D.move !== "in") : O.value - D.value;
+                }), M = 0, E = B, b.forEach((O) => {
+                  (M += O.move === "in" ? 1 : -1) === 1 && O.move === "in" && (E = O.value), M === 0 && F(E) && (A.push({ from: E, to: O.value, len: O.value - E - (O.size || 0) }), F(S) && F(T) && E < T && O.value > S && (k += O.value - E - (O.size || 0)));
+                }), n.breakArray = A, F(S) && F(T) && F(h.min) && (n.unitLength = T - S - k + y, Wi(h, "afterBreaks"), h.staticScale ? h.transA = h.staticScale : n.unitLength && (h.transA *= (T - h.min + y) / n.unitLength), y && (h.minPixelPadding = h.transA * (h.minPointOffset || 0)), h.min = S, h.max = T);
+              }
+            }), Zt(r, !0) && h.chart.redraw();
+          }
+        }
+        a.Additions = c;
+      })(ue || (ue = {}));
+      let Pr = ue, Xt = C();
+      Xt.BrokenAxis = Xt.BrokenAxis || Pr, Xt.BrokenAxis.compose(Xt.Axis, Xt.Series);
+      let V = {}, { arrayMax: Dr, arrayMin: Rr, correctFloat: Gr, extend: Ir, isNumber: Q } = C();
+      function Xi(a) {
+        let t = a.length, e = Hi(a);
+        return Q(e) && t && (e = Gr(e / t)), e;
+      }
+      function Hi(a) {
+        let t = a.length, e;
+        if (!t && a.hasNulls) e = null;
+        else if (t) for (e = 0; t--; ) e += a[t];
+        return e;
+      }
+      let Yi = { average: Xi, averages: function() {
+        let a = [];
+        return [].forEach.call(arguments, function(t) {
+          a.push(Xi(t));
+        }), a[0] === void 0 ? void 0 : a;
+      }, close: function(a) {
+        return a.length ? a[a.length - 1] : a.hasNulls ? null : void 0;
+      }, high: function(a) {
+        return a.length ? Dr(a) : a.hasNulls ? null : void 0;
+      }, hlc: function(a, t, e) {
+        if (a = V.high(a), t = V.low(t), e = V.close(e), Q(a) || Q(t) || Q(e)) return [a, t, e];
+      }, low: function(a) {
+        return a.length ? Rr(a) : a.hasNulls ? null : void 0;
+      }, ohlc: function(a, t, e, i) {
+        if (a = V.open(a), t = V.high(t), e = V.low(e), i = V.close(i), Q(a) || Q(t) || Q(e) || Q(i)) return [a, t, e, i];
+      }, open: function(a) {
+        return a.length ? a[0] : a.hasNulls ? null : void 0;
+      }, range: function(a, t) {
+        return a = V.low(a), t = V.high(t), Q(a) || Q(t) ? [a, t] : a === null && t === null ? null : void 0;
+      }, sum: Hi };
+      Ir(V, Yi);
+      let Kt = { groupPixelWidth: 2, dateTimeLabelFormats: { millisecond: ["%[AebHMSL]", "%[AebHMSL]", "-%[HMSL]"], second: ["%[AebHMS]", "%[AebHMS]", "-%[HMS]"], minute: ["%[AebHM]", "%[AebHM]", "-%[HM]"], hour: ["%[AebHM]", "%[AebHM]", "-%[HM]"], day: ["%[AebY]", "%[Aeb]", "-%[AebY]"], week: ["%v %[AebY]", "%[Aeb]", "-%[AebY]"], month: ["%[BY]", "%[B]", "-%[BY]"], year: ["%Y", "%Y", "-%Y"] } }, Ni = { line: {}, spline: {}, area: {}, areaspline: {}, arearange: {}, column: { groupPixelWidth: 10 }, columnrange: { groupPixelWidth: 10 }, candlestick: { groupPixelWidth: 10 }, ohlc: { groupPixelWidth: 5 }, hlc: { groupPixelWidth: 5 }, heikinashi: { groupPixelWidth: 10 } }, zr = [["millisecond", [1, 2, 5, 10, 20, 25, 50, 100, 200, 500]], ["second", [1, 2, 5, 10, 15, 30]], ["minute", [1, 2, 5, 10, 15, 30]], ["hour", [1, 2, 3, 4, 6, 8, 12]], ["day", [1]], ["week", [1]], ["month", [1, 3, 6]], ["year", null]], { addEvent: Fi, extend: Lr, merge: Wr, pick: Ui } = C();
+      function Vi(a) {
+        let t = this, e = t.series;
+        e.forEach(function(i) {
+          i.groupPixelWidth = void 0;
+        }), e.forEach(function(i) {
+          i.groupPixelWidth = t.getGroupPixelWidth && t.getGroupPixelWidth(), i.groupPixelWidth && (i.hasProcessed = !0), i.applyGrouping(!!a.hasExtremesChanged);
+        });
+      }
+      function Xr() {
+        let a = this.series, t = a.length, e = 0, i = !1, s, o;
+        for (; t--; ) (o = a[t].options.dataGrouping) && (e = Math.max(e, Ui(o.groupPixelWidth, Kt.groupPixelWidth)), s = (a[t].dataTable.getModified() || a[t].dataTable).rowCount, (a[t].groupPixelWidth || s > this.chart.plotSizeX / e || s && o.forced) && (i = !0));
+        return i ? e : 0;
+      }
+      function Hr() {
+        this.series.forEach(function(a) {
+          a.hasProcessed = !1;
+        });
+      }
+      function Yr(a, t) {
+        let e;
+        if (t = Ui(t, !0), a || (a = { forced: !1, units: null }), this instanceof We) for (e = this.series.length; e--; ) this.series[e].update({ dataGrouping: a }, !1);
+        else this.chart.options.series.forEach(function(i) {
+          i.dataGrouping = typeof a == "boolean" ? a : Wr(a, i.dataGrouping);
+        });
+        this.ordinal && (this.ordinal.slope = void 0), t && this.chart.redraw();
+      }
+      let Nr = function(a) {
+        We = a;
+        let t = a.prototype;
+        t.applyGrouping || (Fi(a, "afterSetScale", Hr), Fi(a, "postProcessData", Vi), Lr(t, { applyGrouping: Vi, getGroupPixelWidth: Xr, setDataGrouping: Yr }));
+      }, { addEvent: Fr, getMagnitude: Ur, normalizeTickInterval: Vr, timeUnits: $t } = C();
+      (function(a) {
+        function t() {
+          return this.chart.time.getTimeTicks.apply(this.chart.time, arguments);
+        }
+        function e() {
+          if (this.type !== "datetime") {
+            this.dateTime = void 0;
+            return;
+          }
+          this.dateTime || (this.dateTime = new i(this));
+        }
+        a.compose = function(s) {
+          return s.keepProps.includes("dateTime") || (s.keepProps.push("dateTime"), s.prototype.getTimeTicks = t, Fr(s, "afterSetType", e)), s;
+        };
+        class i {
+          constructor(o) {
+            this.axis = o;
+          }
+          normalizeTimeTickInterval(o, d) {
+            let p = d || [["millisecond", [1, 2, 5, 10, 20, 25, 50, 100, 200, 500]], ["second", [1, 2, 5, 10, 15, 30]], ["minute", [1, 2, 5, 10, 15, 30]], ["hour", [1, 2, 3, 4, 6, 8, 12]], ["day", [1, 2]], ["week", [1, 2]], ["month", [1, 2, 3, 4, 6]], ["year", null]], u = p[p.length - 1], c = $t[u[0]], f = u[1], l;
+            for (l = 0; l < p.length && (c = $t[(u = p[l])[0]], f = u[1], !p[l + 1] || !(o <= (c * f[f.length - 1] + $t[p[l + 1][0]]) / 2)); l++) ;
+            c === $t.year && o < 5 * c && (f = [1, 2, 5]);
+            let r = Vr(o / c, f, u[0] === "year" ? Math.max(Ur(o / c), 1) : 1);
+            return { unitRange: c, count: r, unitName: u[0] };
+          }
+          getXDateFormat(o, d) {
+            let { axis: p } = this, u = p.chart.time;
+            return p.closestPointRange ? u.getDateFormat(p.closestPointRange, o, p.options.startOfWeek, d) || u.resolveDTLFormat(d.year).main : u.resolveDTLFormat(d.day).main;
+          }
+        }
+        a.Additions = i;
+      })(ce || (ce = {}));
+      let _r = ce, { series: { prototype: _i } } = j(), { addEvent: ze, defined: Ht, error: ji, extend: jr, isNumber: Z, merge: Le, pick: qr, splat: Zr } = C(), Kr = _i.generatePoints;
+      function $r(a) {
+        var t, e, i;
+        let s, o, d = this.chart, p = this.options.dataGrouping, u = this.allowDG !== !1 && p && qr(p.enabled, d.options.isStock), c = this.reserveSpace(), f = this.currentDataGrouping, l, r, n = !1;
+        u && !this.requireSorting && (this.requireSorting = n = !0);
+        let h = (t = this, e = a, !!(t.isCartesian && !t.isDirty && !t.xAxis.isDirty && !t.yAxis.isDirty && !e) || !u);
+        if (n && (this.requireSorting = !1), h) return;
+        this.destroyGroupedData();
+        let g = p.groupAll ? this.dataTable : this.dataTable.getModified() || this.dataTable, m = this.getColumn("x", !p.groupAll), x = d.plotSizeX, b = this.xAxis, A = b.getExtremes(), y = b.options.ordinal, k = this.groupPixelWidth;
+        if (k && m && g.rowCount && x && Z(A.min)) {
+          o = !0, this.isDirty = !0, this.points = null;
+          let M = A.min, v = A.max, S = y && b.ordinal && b.ordinal.getGroupIntervalFactor(M, v, this) || 1, T = k * (v - M) / x * S, B = b.getTimeTicks(_r.Additions.prototype.normalizeTimeTickInterval(T, p.units || zr), Math.min(M, m[0]), Math.max(v, m[m.length - 1]), b.options.startOfWeek, m, this.closestPointRange), w = _i.groupData.apply(this, [g, B, p.approximation]), E = w.modified, P = E.getColumn("x", !0), O = 0;
+          for (p?.smoothed && E.rowCount && (p.firstAnchor = "firstPoint", p.anchor = "middle", p.lastAnchor = "lastPoint", ji(32, !1, d, { "dataGrouping.smoothed": "use dataGrouping.anchor" })), s = 1; s < B.length; s++) B.info.segmentStarts && B.info.segmentStarts.indexOf(s) !== -1 || (O = Math.max(B[s] - B[s - 1], O));
+          (l = B.info).gapSize = O, this.closestPointRange = B.info.totalRange, this.groupMap = w.groupMap, this.currentDataGrouping = l, function(D, R, H) {
+            let L = D.options.dataGrouping, z = D.currentDataGrouping && D.currentDataGrouping.gapSize, W = D.getColumn("x");
+            if (!(L && W.length && z && D.groupMap)) return;
+            let N = R.length - 1, lt = L.anchor, Ot = L.firstAnchor, _ = L.lastAnchor, Bt = R.length - 1, Qt = 0;
+            if (Ot && W[0] >= R[0]) {
+              let ht;
+              Qt++;
+              let ts = D.groupMap[0].start, es = D.groupMap[0].length;
+              Z(ts) && Z(es) && (ht = ts + (es - 1)), R[0] = { start: R[0], middle: R[0] + 0.5 * z, end: R[0] + z, firstPoint: W[0], lastPoint: ht && W[ht] }[Ot];
+            }
+            if (N > 0 && _ && z && R[N] >= H - z) {
+              Bt--;
+              let ht = D.groupMap[D.groupMap.length - 1].start;
+              R[N] = { start: R[N], middle: R[N] + 0.5 * z, end: R[N] + z, firstPoint: ht && W[ht], lastPoint: W[W.length - 1] }[_];
+            }
+            if (lt && lt !== "start") {
+              let ht = z * { middle: 0.5, end: 1 }[lt];
+              for (; Bt >= Qt; ) R[Bt] += ht, Bt--;
+            }
+          }(this, P || [], v), c && P && (Ht((i = P)[0]) && Z(b.min) && Z(b.dataMin) && i[0] < b.min && ((!Ht(b.options.min) && b.min <= b.dataMin || b.min === b.dataMin) && (b.min = Math.min(i[0], b.min)), b.dataMin = Math.min(i[0], b.dataMin)), Ht(i[i.length - 1]) && Z(b.max) && Z(b.dataMax) && i[i.length - 1] > b.max && ((!Ht(b.options.max) && Z(b.dataMax) && b.max >= b.dataMax || b.max === b.dataMax) && (b.max = Math.max(i[i.length - 1], b.max)), b.dataMax = Math.max(i[i.length - 1], b.dataMax))), p.groupAll && (this.allGroupedTable = E, P = (E = (r = this.cropData(E, b.min || 0, b.max || 0)).modified).getColumn("x"), this.cropStart = r.start), this.dataTable.modified = E;
+        } else this.groupMap = void 0, this.currentDataGrouping = void 0;
+        this.hasGroupedData = o, this.preventGraphAnimation = (f && f.totalRange) !== (l && l.totalRange);
+      }
+      function qi() {
+        this.groupedData && (this.groupedData.forEach(function(a, t) {
+          a && (this.groupedData[t] = a.destroy ? a.destroy() : null);
+        }, this), this.groupedData.length = 0, delete this.allGroupedTable);
+      }
+      function Jr() {
+        Kr.apply(this), this.destroyGroupedData(), this.groupedData = this.hasGroupedData ? this.points : null;
+      }
+      function Qr() {
+        return this.is("arearange") ? "range" : this.is("ohlc") ? "ohlc" : this.is("hlc") ? "hlc" : this.is("column") || this.options.cumulative ? "sum" : "average";
+      }
+      function Zi(a, t, e) {
+        let i = a.getColumn("x", !0) || [], s = a.getColumn("y", !0), o = this, d = o.data, p = o.options && o.options.data, u = [], c = new hi(), f = [], l = a.rowCount, r = !!s, n = [], h = o.pointArrayMap, g = h && h.length, m = ["x"].concat(h || ["y"]), x = (h || ["y"]).map(() => []), b = this.options.dataGrouping && this.options.dataGrouping.groupAll, A, y, k, M = 0, v = 0, S = typeof e == "function" ? e : e && V[e] ? V[e] : V[o.getDGApproximation && o.getDGApproximation() || "average"];
+        if (g) {
+          let w = h.length;
+          for (; w--; ) n.push([]);
+        } else n.push([]);
+        let T = g || 1;
+        for (let w = 0; w <= l; w++) if (!(i[w] < t[0])) {
+          for (; t[M + 1] !== void 0 && i[w] >= t[M + 1] || w === l; ) {
+            if (A = t[M], o.dataGroupInfo = { start: b ? v : o.cropStart + v, length: n[0].length, groupStart: A }, k = S.apply(o, n), o.pointClass && !Ht(o.dataGroupInfo.options) && (o.dataGroupInfo.options = Le(o.pointClass.prototype.optionsToObject.call({ series: o }, o.options.data[o.cropStart + v])), m.forEach(function(E) {
+              delete o.dataGroupInfo.options[E];
+            })), k !== void 0) {
+              u.push(A);
+              let E = Zr(k);
+              for (let P = 0; P < E.length; P++) x[P].push(E[P]);
+              f.push(o.dataGroupInfo);
+            }
+            v = w;
+            for (let E = 0; E < T; E++) n[E].length = 0, n[E].hasNulls = !1;
+            if (M += 1, w === l) break;
+          }
+          if (w === l) break;
+          if (h) {
+            let E, P = b ? w : o.cropStart + w, O = d && d[P] || o.pointClass.prototype.applyOptions.apply({ series: o }, [p[P]]);
+            for (let D = 0; D < g; D++) Z(E = O[h[D]]) ? n[D].push(E) : E === null && (n[D].hasNulls = !0);
+          } else Z(y = r ? s[w] : null) ? n[0].push(y) : y === null && (n[0].hasNulls = !0);
+        }
+        let B = { x: u };
+        return (h || ["y"]).forEach((w, E) => {
+          B[w] = x[E];
+        }), c.setColumns(B), { groupMap: f, modified: c };
+      }
+      function ta(a) {
+        let t = a.options, e = this.type, i = this.chart.options.plotOptions, s = this.useCommonDataGrouping && Kt, o = C().defaultOptions.plotOptions[e].dataGrouping;
+        if (i && (Ni[e] || s)) {
+          let d = this.chart.rangeSelector;
+          o || (o = Le(Kt, Ni[e])), t.dataGrouping = Le(s, o, i.series && i.series.dataGrouping, i[e].dataGrouping, this.userOptions.dataGrouping, !t.isInternal && d && Z(d.selected) && d.buttonOptions[d.selected].dataGrouping);
+        }
+      }
+      let ea = function(a) {
+        let t = a.prototype;
+        t.applyGrouping || (ze(a.prototype.pointClass, "update", function() {
+          if (this.dataGroup) return ji(24, !1, this.series.chart), !1;
+        }), ze(a, "afterSetOptions", ta), ze(a, "destroy", qi), jr(t, { applyGrouping: $r, destroyGroupedData: qi, generatePoints: Jr, getDGApproximation: Qr, groupData: Zi }));
+      }, { format: ia } = Se(), { composed: sa } = C(), { addEvent: oa, extend: ra, isNumber: aa, pick: na, pushUnique: la } = C();
+      function ha(a) {
+        let t = this.chart, e = t.time, i = a.point, s = i.series, o = s.options, d = s.tooltipOptions, p = o.dataGrouping, u = s.xAxis, c = d.xDateFormat || "", f, l, r, n, h, g = d[a.isFooter ? "footerFormat" : "headerFormat"];
+        if (u && u.options.type === "datetime" && p && aa(i.key)) {
+          l = s.currentDataGrouping, r = p.dateTimeLabelFormats || Kt.dateTimeLabelFormats, l ? (n = r[l.unitName], l.count === 1 ? c = n[0] : (c = n[1], f = n[2])) : !c && r && u.dateTime && (c = u.dateTime.getXDateFormat(i.x, d.dateTimeLabelFormats));
+          let m = na(s.groupMap?.[i.index].groupStart, i.key), x = m + (l?.totalRange || 0) - 1;
+          h = e.dateFormat(c, m), f && (h += e.dateFormat(f, x)), s.chart.styledMode && (g = this.styledModeFormat(g)), a.text = ia(g, { point: ra(i, { key: h }), series: s }, t), a.preventDefault();
+        }
+      }
+      /**
+      * @license Highstock JS v12.5.0 (2026-01-12)
+      * @module highcharts/modules/datagrouping
+      * @requires highcharts
+      *
+      * Data grouping module
+      *
+      * (c) 2010-2026 Highsoft AS
+      * Author: Torstein Hønsi
+      *
+      * A commercial license may be required depending on use.
+      * See www.highcharts.com/license
+      */
+      let ot = C();
+      ot.dataGrouping = ot.dataGrouping || {}, ot.dataGrouping.approximationDefaults = ot.dataGrouping.approximationDefaults || Yi, ot.dataGrouping.approximations = ot.dataGrouping.approximations || V, { compose: function(a, t, e) {
+        Nr(a), ea(t), e && la(sa, "DataGrouping") && oa(e, "headerFormatter", ha);
+      }, groupData: Zi }.compose(ot.Axis, ot.Series, ot.Tooltip);
+      let { defined: Ea, isNumber: Ki, pick: da } = C(), { addEvent: $i, isObject: pa, pick: ua, defined: ca, merge: ga } = C(), { getAssignedAxis: Ji } = { getAssignedAxis: function(a) {
+        return a.filter((t) => {
+          let e = t.axis.getExtremes(), i = e.min, s = e.max, o = da(t.axis.minPointOffset, 0);
+          return Ki(i) && Ki(s) && t.value >= i - o && t.value <= s + o && !t.axis.options.isInternal;
+        })[0];
+      } }, Qi = [], fa = { enabled: !0, sensitivity: 1.1, showResetButton: !1 }, ma = function(a, t, e, i, s, o, d) {
+        let p = ua(d.type, a.zooming.type, ""), u = [];
+        p === "x" ? u = e : p === "y" ? u = i : p === "xy" && (u = a.axes);
+        let c = a.transform({ axes: u, to: { x: s - 5, y: o - 5, width: 10, height: 10 }, from: { x: s - 5 * t, y: o - 5 * t, width: 10 * t, height: 10 * t }, trigger: "mousewheel", allowResetButton: d.showResetButton });
+        return c && (ca(oe) && clearTimeout(oe), oe = setTimeout(() => {
+          a.pointer?.drop();
+        }, 400)), c;
+      };
+      function xa() {
+        var a;
+        let t = (pa(a = this.zooming.mouseWheel) || (a = { enabled: a ?? !0 }), ga(fa, a));
+        t.enabled && $i(this.container, "wheel", (e) => {
+          e = this.pointer?.normalize(e) || e;
+          let { pointer: i } = this, s = i && !i.inClass(e.target, "highcharts-no-mousewheel");
+          if (this.isInsidePlot(e.chartX - this.plotLeft, e.chartY - this.plotTop) && s) {
+            let o = t.sensitivity || 1.1, d = e.detail || (e.deltaY || 0) / 120, p = Ji(i.getCoordinates(e).xAxis), u = Ji(i.getCoordinates(e).yAxis);
+            ma(this, Math.pow(o, d), p ? [p.axis] : this.xAxis, u ? [u.axis] : this.yAxis, e.chartX, e.chartY, t) && e.preventDefault?.();
+          }
+        });
+      }
+      /**
+      * @license Highcharts JS v12.5.0 (2026-01-12)
+      * @module highcharts/modules/mouse-wheel-zoom
+      * @requires highcharts
+      *
+      * Mousewheel zoom module
+      *
+      * (c) 2023-2026 Highsoft AS
+      * Author: Askel Eirik Johansson
+      *
+      * A commercial license may be required depending on use.
+      * See www.highcharts.com/license
+      */
+      let Jt = C();
+      Jt.MouseWheelZoom = Jt.MouseWheelZoom || { compose: function(a) {
+        Qi.indexOf(a) === -1 && (Qi.push(a), $i(a, "afterGetContainer", xa));
+      } }, Jt.MouseWheelZoom.compose(Jt.Chart);
+      let G = C();
+      G.Navigator = G.Navigator || jt, G.OrdinalAxis = G.OrdinalAxis || Ao, G.RangeSelector = G.RangeSelector || Wt, G.Scrollbar = G.Scrollbar || ct, G.stockChart = G.stockChart || wi.stockChart, G.StockChart = G.StockChart || G.stockChart, G.extend(G.StockChart, wi), Ss.compose(G.Series, G.Axis, G.Point), Tt.compose(G.Renderer), bt.compose(G.Series), G.Navigator.compose(G.Chart, G.Axis, G.Series), G.OrdinalAxis.compose(G.Axis, G.Series, G.Chart), G.RangeSelector.compose(G.Axis, G.Chart), G.Scrollbar.compose(G.Axis), G.StockChart.compose(G.Chart, G.Axis, G.Series, G.SVGRenderer);
+      let ba = C();
+      return He.default;
+    })());
+  }(te)), te.exports;
+}
+var ss = Aa();
+const ka = /* @__PURE__ */ va(ss), Ba = /* @__PURE__ */ ya({
+  __proto__: null,
+  default: ka
+}, [ss]);
+export {
+  Ba as s
+};