@mobileaction/action-kit 1.58.12 → 1.58.13

package/dist/stock-BFrkgkl6.js

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