@mobileaction/action-kit 0.0.0-beta-20260205072442

package/dist/stock-DyTZKEyb.js

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