@mobileaction/action-kit 1.59.1 → 1.60.1

package/dist/stock-CdKokTS_.js

@@ -0,0 +1,3733 @@
+import { t as e } from "./rolldown-runtime-B0aSnxlc.js";
+//#region node_modules/.pnpm/highcharts@12.6.0/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.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.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.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.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) => (() => {
+		let f, p, m, h;
+		var g, _, v, y, b, x, S, C = {
+			28: (e) => {
+				e.exports = s;
+			},
+			184: (e) => {
+				e.exports = d;
+			},
+			260: (e) => {
+				e.exports = t;
+			},
+			448: (e) => {
+				e.exports = u;
+			},
+			512: (e) => {
+				e.exports = a;
+			},
+			532: (e) => {
+				e.exports = r;
+			},
+			608: (e) => {
+				e.exports = o;
+			},
+			620: (e) => {
+				e.exports = i;
+			},
+			820: (e) => {
+				e.exports = n;
+			},
+			944: (t) => {
+				t.exports = e;
+			},
+			960: (e) => {
+				e.exports = l;
+			},
+			984: (e) => {
+				e.exports = c;
+			}
+		}, w = {};
+		function T(e) {
+			var t = w[e];
+			if (t !== void 0) return t.exports;
+			var n = w[e] = { exports: {} };
+			return C[e](n, n.exports, T), n.exports;
+		}
+		T.n = (e) => {
+			var t = e && e.__esModule ? () => e.default : () => e;
+			return T.d(t, { a: t }), t;
+		}, T.d = (e, t) => {
+			for (var n in t) T.o(t, n) && !T.o(e, n) && Object.defineProperty(e, n, {
+				enumerable: !0,
+				get: t[n]
+			});
+		}, T.o = (e, t) => Object.prototype.hasOwnProperty.call(e, t);
+		var E = {};
+		T.d(E, { default: () => Yn });
+		var D = T(944), O = T.n(D), ee = T(260), te = T.n(ee), ne = T(820), re = T.n(ne);
+		let { doc: ie, win: ae } = O();
+		function k(e, t, n, r = {}) {
+			let i = typeof e == "function" && e.prototype || e;
+			Object.hasOwnProperty.call(i, "hcEvents") || (i.hcEvents = {});
+			let a = i.hcEvents;
+			O().Point && e instanceof O().Point && e.series && e.series.chart && (e.series.chart.runTrackerClick = !0);
+			let o = e.addEventListener;
+			o && o.call(e, t, n, !!O().supportsPassiveEvents && {
+				passive: r.passive === void 0 ? t.indexOf("touch") !== -1 : r.passive,
+				capture: !1
+			}), a[t] || (a[t] = []);
+			let s = {
+				fn: n,
+				order: typeof r.order == "number" ? r.order : 1 / 0
+			};
+			return a[t].push(s), a[t].sort((e, t) => e.order - t.order), function() {
+				W(e, t, n);
+			};
+		}
+		function oe(e) {
+			let t = e.length, n = e[0];
+			for (; t--;) e[t] < n && (n = e[t]);
+			return n;
+		}
+		function se(e) {
+			let t = e.length, n = e[0];
+			for (; t--;) e[t] > n && (n = e[t]);
+			return n;
+		}
+		function ce(e, t, n) {
+			return e > t ? e < n ? e : n : t;
+		}
+		function A(e, t) {
+			return e > 0x5af3107a4000 ? e : parseFloat(e.toPrecision(t || 14));
+		}
+		function le(e, t, n, r, i) {
+			let a = ie.createElement(e);
+			return t && F(a, t), i && M(a, {
+				padding: "0",
+				border: "none",
+				margin: "0"
+			}), n && M(a, n), r && r.appendChild(a), a;
+		}
+		function j(e, t = 0, n) {
+			let r = t % 2 / 2, i = n ? -1 : 1;
+			return (Math.round(e * i - r) + r) * i;
+		}
+		function M(e, t) {
+			F(e.style, t);
+		}
+		function N(e) {
+			return e != null;
+		}
+		function ue(e, t, n) {
+			V(e, function(r, i) {
+				r !== t && r?.destroy && r.destroy(), (r?.destroy || !n) && delete e[i];
+			});
+		}
+		function P(e, t) {
+			let n = e.length;
+			for (; n--;) if (e[n] === t) {
+				e.splice(n, 1);
+				break;
+			}
+		}
+		function F(e, t) {
+			let n;
+			for (n in e ||= {}, t) e[n] = t[n];
+			return e;
+		}
+		function I(e, t, n, r) {
+			if (n ||= {}, ie?.createEvent && (e.dispatchEvent || e.fireEvent && e !== O())) {
+				let r = ie.createEvent("Events");
+				r.initEvent(t, !0, !0), n = F(r, n), e.dispatchEvent ? e.dispatchEvent(n) : e.fireEvent(t, n);
+			} else if (e.hcEvents) {
+				n.target || F(n, {
+					preventDefault: function() {
+						n.defaultPrevented = !0;
+					},
+					target: e,
+					type: t
+				});
+				let r = [], i = e, a = !1;
+				for (; i.hcEvents;) Object.hasOwnProperty.call(i, "hcEvents") && i.hcEvents[t] && (r.length && (a = !0), r.unshift.apply(r, i.hcEvents[t])), i = Object.getPrototypeOf(i);
+				a && r.sort((e, t) => e.order - t.order), r.forEach((t) => {
+					!1 === t.fn.call(e, n, e) && n.preventDefault();
+				});
+			}
+			r && !n.defaultPrevented && r.call(e, n);
+		}
+		function de(e) {
+			return 10 ** Math.floor(Math.log(e) / Math.LN10);
+		}
+		let fe = Array.prototype.find ? function(e, t) {
+			return e.find(t);
+		} : function(e, t) {
+			let n, r = e.length;
+			for (n = 0; n < r; n++) if (t(e[n], n)) return e[n];
+		};
+		function pe(e) {
+			return me(e) && typeof e.nodeType == "number";
+		}
+		function L(e) {
+			return typeof e == "number" && !isNaN(e) && e < 1 / 0 && e > -1 / 0;
+		}
+		function R(e) {
+			return typeof e == "string";
+		}
+		function z(e) {
+			let t = Object.prototype.toString.call(e);
+			return t === "[object Array]" || t === "[object Array Iterator]";
+		}
+		function me(e, t) {
+			return !!e && typeof e == "object" && (!t || !z(e));
+		}
+		function B(e, ...t) {
+			let n, r = [e, ...t], i = {}, a = function(e, t) {
+				return typeof e != "object" && (e = {}), V(t, function(n, r) {
+					if (r !== "__proto__" && r !== "constructor") {
+						let i;
+						!me(n, !0) || (i = n?.constructor, me(n, !0) && !pe(n) && i?.name && i.name !== "Object") || pe(n) ? e[r] = t[r] : e[r] = a(e[r] || {}, n);
+					}
+				}), e;
+			};
+			!0 === e && (i = r[1], r = Array.prototype.slice.call(r, 2));
+			let o = r.length;
+			for (n = 0; n < o; n++) i = a(i, r[n]);
+			return i;
+		}
+		function V(e, t, n) {
+			for (let r in e) Object.hasOwnProperty.call(e, r) && t.call(n || e[r], e[r], r, e);
+		}
+		function H() {
+			let e = arguments, t = e.length;
+			for (let n = 0; n < t; n++) {
+				let t = e[n];
+				if (t != null) return t;
+			}
+		}
+		function U(e, t) {
+			return 0 > e.indexOf(t) && !!e.push(t);
+		}
+		function W(e, t, n) {
+			function r(t, n) {
+				let r = e.removeEventListener;
+				r && r.call(e, t, n, !1);
+			}
+			function i(n) {
+				let i, a;
+				e.nodeName && (t ? (i = {})[t] = !0 : i = n, V(i, function(e, t) {
+					if (n[t]) for (a = n[t].length; a--;) r(t, n[t][a].fn);
+				}));
+			}
+			let a = typeof e == "function" && e.prototype || e;
+			if (Object.hasOwnProperty.call(a, "hcEvents")) {
+				let e = a.hcEvents;
+				if (t) {
+					let a = e[t] || [];
+					n ? (e[t] = a.filter(function(e) {
+						return n !== e.fn;
+					}), r(t, n)) : (i(e), e[t] = []);
+				} else i(e), delete a.hcEvents;
+			}
+		}
+		function G(e) {
+			return z(e) ? e : [e];
+		}
+		let { tooltipFormatter: he } = te().prototype;
+		(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" || R(t) || n.setCumulative(t, !1);
+				}), H(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], H(t.series.tooltipOptions.changeDecimals, 2)));
+				};
+				return N(t.change) && r("change"), N(t.cumulativeSum) && r("cumulativeSum"), he.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 re() && (this.options.compare = H(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 && z(n) && n.length >= 2 && (e = u.getCumulativeExtremes(n)), e && (t.dataMin = oe(e), t.dataMax = se(e));
+				}
+			}
+			function a(e, t) {
+				this.options.compare = this.userOptions.compare = e, this.update({}, H(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 (L(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 = H(e, !1), this.options.cumulative = this.userOptions.cumulative = e, this.update({}, H(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, k(e, "afterInit", r), k(e, "afterGetExtremes", i), k(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 = 1 / 0, n = -1 / 0;
+					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 / Math.abs(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 = A(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 && (r.cumulativeSum = !i || a ? e : void 0), e;
+						}
+						return 0;
+					};
+				}
+			}
+			e.Additions = u;
+		})(g ||= {});
+		let ge = g;
+		var _e = T(532), ve = T.n(_e);
+		let { isTouchDevice: ye } = O(), be = [];
+		function xe() {
+			this.navigator && this.navigator.setBaseSeries(null, !1);
+		}
+		function Se() {
+			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 = H(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 + H(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 Ce(e) {
+			!this.navigator && !this.scroller && (this.options.navigator.enabled || this.options.scrollbar.enabled) && (this.scroller = this.navigator = new f(this), H(e.redraw, !0) && this.redraw(e.animation));
+		}
+		function we() {
+			let e = this.options;
+			(e.navigator.enabled || e.scrollbar.enabled) && (this.scroller = this.navigator = new f(this));
+		}
+		function Te() {
+			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 Ee(e) {
+			let t = e.navigator;
+			if (t && e.xAxis[0]) {
+				let n = e.xAxis[0].getExtremes();
+				t.render(n.min, n.max);
+			}
+		}
+		function De(e) {
+			let t = e.options.navigator || {}, n = e.options.scrollbar || {};
+			!this.navigator && !this.scroller && (t.enabled || n.enabled) && (B(!0, this.options.navigator, t), B(!0, this.options.scrollbar, n), delete e.options.navigator, delete e.options.scrollbar);
+		}
+		let Oe = function(e, t) {
+			if (U(be, e)) {
+				let n = e.prototype;
+				f = t, n.callbacks.push(Ee), k(e, "afterAddSeries", xe), k(e, "afterSetChartSize", Se), k(e, "afterUpdate", Ce), k(e, "beforeRender", we), k(e, "beforeShowResetZoom", Te), k(e, "update", De);
+			}
+		}, { isTouchDevice: ke } = O();
+		function Ae() {
+			this.navigatorAxis ||= new Me(this);
+		}
+		function je(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" || ke && o === "xy") && this.options.range) {
+					let t = a.previousZoom;
+					N(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 Me {
+			static compose(e) {
+				e.keepProps.includes("navigatorAxis") || (e.keepProps.push("navigatorAxis"), k(e, "init", Ae), k(e, "setExtremes", je));
+			}
+			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 = H(n, i.translate(e, !0, !i.horiz)), s = H(r, i.translate(t, !0, !i.horiz));
+				return N(n) || (o = A(o + a)), N(r) || (s = A(s - a)), L(o) && L(s) || (o = s = void 0), {
+					min: o,
+					max: s
+				};
+			}
+		}
+		var Ne = T(620), Pe = T.n(Ne), Fe = T(512), K = T.n(Fe);
+		let { parse: Ie } = Pe(), { seriesTypes: Le } = K(), Re = {
+			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: Ie("#667aff").setOpacity(.3).get(),
+			outlineColor: "#999999",
+			outlineWidth: 1,
+			series: {
+				type: Le.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
+			}
+		}, ze = { "navigator-handle": function(e, t, n, r, i = {}) {
+			var a, o, s, c, l, u;
+			let d = i.width ? i.width / 2 : n, f = (a = i.borderRadius || 0, o = Math.min(2 * d, r), /%$/.test(a) ? o * parseFloat(a) / 100 + 0 : parseFloat(a));
+			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
+				],
+				...(s = -d - 1, c = 2 * d + 1, l = r, u = { r: f }, u?.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"]
+					];
+				}(s, .5, c, l, u) : [
+					[
+						"M",
+						s,
+						.5
+					],
+					[
+						"L",
+						s + c,
+						.5
+					],
+					[
+						"L",
+						s + c,
+						.5 + l
+					],
+					[
+						"L",
+						s,
+						.5 + l
+					],
+					["Z"]
+				])
+			];
+		} };
+		var Be = T(608), Ve = T.n(Be);
+		let He = { setFixedRange: function(e) {
+			let t = this.xAxis[0];
+			this.fixedRange = N(t.dataMax) && N(t.dataMin) && e ? Math.min(e, t.dataMax - t.dataMin) : e;
+		} }, { defaultOptions: Ue } = O(), { composed: We } = O(), { getRendererType: Ge } = Ve(), { setFixedRange: Ke } = He;
+		function qe() {
+			this.chart.navigator && !this.options.isInternal && this.chart.navigator.setBaseSeries(null, !1);
+		}
+		let Je = function(e, t, n) {
+			Me.compose(t), U(We, "Navigator") && (e.prototype.setFixedRange = Ke, F(Ge().prototype.symbols, ze), F(Ue, { navigator: Re }), k(n, "afterUpdate", qe));
+		}, { composed: Ye } = O();
+		(function(e) {
+			let t;
+			function n(e) {
+				let t = H(e.options?.min, e.min), n = H(e.options?.max, e.max);
+				return {
+					axisMin: t,
+					axisMax: n,
+					scrollMin: N(e.dataMin) ? Math.min(t, e.min ?? 1 / 0, e.dataMin, e.threshold ?? 1 / 0) : t,
+					scrollMax: e.treeGrid?.adjustedMax ?? (N(e.dataMax) ? Math.max(n, e.max ?? -1 / 0, e.dataMax, e.threshold ?? -1 / 0) : 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), k(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 (N(a) && N(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(A(i), A(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) || !N(this.min) || !N(this.max) || N(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) {
+				U(Ye, "Axis.Scrollbar") && (t = n, k(e, "afterGetOffset", r), k(e, "afterInit", i), k(e, "afterRender", a));
+			};
+		})(_ ||= {});
+		let Xe = _, Ze = {
+			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: Qe } = O(), { composed: $e } = O();
+		class q {
+			static compose(e) {
+				Xe.compose(e, q), U($e, "Scrollbar") && F(Qe, { scrollbar: Ze });
+			}
+			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) {
+					k.apply(null, e);
+				}), this._events = s;
+			}
+			buttonToMaxClick(e) {
+				let t = (this.to - this.from) * H(this.options.step, .2);
+				this.updatePosition(this.from + t, this.to + t), I(this, "changed", {
+					from: this.from,
+					to: this.to,
+					trigger: "scrollbar",
+					DOMEvent: e
+				});
+			}
+			buttonToMinClick(e) {
+				let t = A(this.to - this.from) * H(this.options.step, .2);
+				this.updatePosition(A(this.from - t), A(this.to - t)), I(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, ue(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(q.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 = B(Ze, Qe.scrollbar, t), this.options.margin = H(this.options.margin, 10), this.chart = n, this.size = H(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 && I(this, "changed", {
+					from: this.from,
+					to: this.to,
+					trigger: "scrollbar",
+					DOMType: e.type,
+					DOMEvent: e
+				}));
+			}
+			mouseUpHandler(e) {
+				this.hasDragged && I(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) {
+					W.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: -j(0, a),
+					y: -j(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(q.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(-j(0, this.scrollbarStrokeWidth), -j(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 (!N(s)) return;
+				let l = s * Math.min(t, 1);
+				n = Math.ceil(s * (e = Math.max(e, 0))), this.calculatedWidth = r = A(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 H(this.options.liveRedraw, O().svg && !O().isTouchDevice && !this.chart.boosted) || e === "mouseup" || e === "touchend" || !N(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), I(this, "changed", {
+					from: this.from,
+					to: this.to,
+					trigger: "scrollbar",
+					DOMEvent: e
+				});
+			}
+			update(e) {
+				this.destroy(), this.init(this.chart.renderer, B(!0, this.options, e), this.chart);
+			}
+			updatePosition(e, t) {
+				t > 1 && (e = A(1 - A(t - e)), t = 1), e < 0 && (t = A(t - e), e = 0), this.from = e, this.to = t;
+			}
+		}
+		q.defaultOptions = Ze;
+		let { defaultOptions: et } = O(), { isTouchDevice: tt } = O();
+		function nt(e, ...t) {
+			let n = [].filter.call(t, L);
+			if (n.length) return Math[e].apply(0, n);
+		}
+		class rt {
+			static compose(e, t, n) {
+				Oe(e, rt), Je(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 = !1, i = t.handles, { height: c, width: l } = i;
+					[0, 1].forEach((t) => {
+						let u = i.symbols[t];
+						(n ||= e.handles[t]?.symbolName !== u) && (e.handles[t]?.destroy(), e.handles[t] = a.symbol(u, -l / 2 - 1, 0, l, c, i), e.handles[t].attr({ zIndex: 7 - t }).addClass("highcharts-navigator-handle highcharts-navigator-handle-" + ["left", "right"][t]).add(s)), r.inverted && e.handles[t].attr({
+							rotation: 90,
+							rotationOriginX: Math.floor(-l / 2),
+							rotationOriginY: (c + l) / 2
+						}), r.styledMode || e.handles[t].attr({
+							fill: i.backgroundColor,
+							stroke: i.borderColor,
+							"stroke-width": i.lineWidth,
+							width: i.width,
+							height: i.height,
+							x: -l / 2 - 1,
+							y: 0
+						}).css(o);
+					}), n && (e.partsEventsToUnbind?.forEach((e) => {
+						e();
+					}), e.partsEventsToUnbind = [...e.getPartsEvents("mousedown"), ...e.getPartsEvents("touchstart")]);
+				}
+			}
+			update(e, t = !1) {
+				let n = this.chart, r = n.options.chart.inverted !== n.scrollbar?.options.vertical;
+				if (B(!0, n.options.navigator, e), this.navigatorOptions = n.options.navigator || {}, this.setOpposite(), N(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) => {
+					W(e, "updatedData", this.updatedDataHandler);
+				}, this), e.adaptToUpdatedData && this.baseSeries.forEach((e) => {
+					e.eventsToUnbind.push(k(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 && !N(n)) return;
+				if (this.isDirty && this.renderElements(), e = A(e - o / 2), t = A(t + o / 2), !L(e) || !L(t)) {
+					if (l) n = 0, r = H(a.width, s.width);
+					else return;
+				}
+				this.left = H(a.left, i.plotLeft + p + (u ? i.plotWidth : 0));
+				let b = this.size = v = H(a.len, (u ? i.plotHeight : i.plotWidth) - 2 * p);
+				m = u ? _ : v + 2 * p, n = H(n, a.toPixels(e, !0)), r = H(r, a.toPixels(t, !0)), L(n) && Math.abs(n) !== 1 / 0 || (n = 0, r = m);
+				let x = a.toValue(n, !0), S = a.toValue(r, !0), C = Math.abs(A(S - x));
+				N(d) && C < d ? this.grabbedLeft ? n = a.toPixels(S - d - o, !0) : this.grabbedRight && (r = a.toPixels(x + d + o, !0)) : N(f) && A(C - o) > f && (this.grabbedLeft ? n = a.toPixels(S - f - o, !0) : this.grabbedRight && (r = a.toPixels(x + f + o, !0))), this.zoomedMax = ce(Math.max(n, r), 0, b), this.zoomedMin = ce(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, I(this, "afterRender");
+			}
+			addMouseEvents() {
+				let e, t, n = this, r = n.chart, i = r.container, a = [];
+				n.mouseMoveHandler = e = function(e) {
+					n.onMouseMove(e);
+				}, n.mouseUpHandler = t = function(e) {
+					n.onMouseUp(e);
+				}, a.push(k(r.renderTo, "mousemove", e), k(i.ownerDocument, "mouseup", t), k(r.renderTo, "touchmove", e), k(i.ownerDocument, "touchend", t)), n.eventsToUnbind = a, n.series && n.series[0] && a.push(k(n.series[0].xAxis, "foundExtremes", function() {
+					r.navigator?.modifyNavigatorAxisExtremes();
+				}));
+			}
+			getPartsEvents(e) {
+				let t = this, n = [];
+				return ["shades", "handles"].forEach((r) => {
+					t[r].forEach(function(i, a) {
+						n.push(k(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, N((d = r.navigatorAxis.toFixedRange(f, f + o, u, l)).min) && I(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 && a && (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 && H(t.scrollbarOptions?.liveRedraw, !tt && !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), N((o = c.navigatorAxis.toFixedRange(this.zoomedMin, this.zoomedMax, i, a)).min) && I(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 && L(this.zoomedMin) && L(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?.forEach((e) => {
+					e();
+				}), this.eventsToUnbind = void 0, this.removeBaseSeriesEvents();
+			}
+			removeBaseSeriesEvents() {
+				let e = this.baseSeries || [];
+				this.navigatorEnabled && e[0] && (!1 !== this.navigatorOptions.adaptToUpdatedData && e.forEach(function(e) {
+					W(e, "updatedData", this.updatedDataHandler);
+				}, this), e[0].xAxis && W(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, B({
+						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, B(n.yAxis, {
+						alignTicks: !1,
+						offset: 0,
+						index: f,
+						isInternal: !0,
+						reversed: H(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 = k(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 = nt("min", r.options.min, i.dataMin), s = nt("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 = Me.prototype.toFixedRange.bind(l.xAxis.navigatorAxis);
+				if (e.options.scrollbar?.enabled) {
+					let t = B(e.options.scrollbar, { vertical: e.inverted });
+					L(t.margin) || (t.margin = e.inverted ? -3 : 3), e.scrollbar = l.scrollbar = new q(e.renderer, t, e), k(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 = H(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: H(r.parse(a?.min), nt("min", r.parse(o.min), n.dataMin, i.dataMin, i.min)),
+					dataMax: H(r.parse(a?.max), nt("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.navigator?.baseSeries || (n.series.length ? fe(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 !(t && 0 > i.indexOf(t)) || (t && (W(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 = F({
+						color: e.color,
+						visible: e.visible
+					}, z(l) ? et.navigator.series : l);
+					if (d && !1 === n.navigatorOptions.adaptToUpdatedData) return;
+					a.name = "Navigator " + i.length, u = (s = e.options || {}).navigatorOptions || {}, f.dataLabels = G(f.dataLabels), (c = B(s, a, f, u)).pointRange = H(f.pointRange, u.pointRange, et.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) || z(l)) && (n.hasNavigatorData = !1, (l = G(l)).forEach((e, t) => {
+					a.name = "Navigator " + (o.length + 1), (c = B(et.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(k(t[0].xAxis, "foundExtremes", this.modifyBaseAxisExtremes)), t.forEach((n) => {
+					n.eventsToUnbind.push(k(n, "show", function() {
+						this.navigatorSeries && this.navigatorSeries.setVisible(!0, !1);
+					})), n.eventsToUnbind.push(k(n, "hide", function() {
+						this.navigatorSeries && this.navigatorSeries.setVisible(!1, !1);
+					})), !1 !== this.navigatorOptions.adaptToUpdatedData && n.xAxis && n.eventsToUnbind.push(k(n, "updatedData", this.updatedDataHandler)), n.eventsToUnbind.push(k(n, "remove", function() {
+						t && P(t, n), this.navigatorSeries && e.series && (P(e.series, this.navigatorSeries), N(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 = H(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) && L(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 = H(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, void 0, !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 !!(L(i) && L(a)) && (o && i - n > 0 ? i - n < o : a <= n);
+			}
+			addChartEvents() {
+				this.eventsToUnbind ||= [], this.eventsToUnbind.push(k(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);
+				}), k(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);
+				}), k(this, "setRange", function(e) {
+					this.chart.xAxis[0].setExtremes(e.min, e.max, e.redraw, e.animation, e.eventArguments);
+				}));
+			}
+			destroy() {
+				this.removeEvents(), this.xAxis && (P(this.chart.xAxis, this.xAxis), P(this.chart.axes, this.xAxis)), this.yAxis && (P(this.chart.yAxis, this.yAxis), P(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) => {
+					ue(e);
+				}), this.baseSeries.forEach((e) => {
+					e.navigatorSeries = void 0;
+				}), this.navigatorEnabled = !1;
+			}
+		}
+		let { setLength: it, splice: at } = {
+			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;
+				}
+			},
+			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
+				};
+			}
+		}, ot = class {
+			constructor(e = {}) {
+				this.autoId = !e.id, this.columns = {}, this.id = e.id || (0, D.uniqueKey)(), this.rowCount = 0, this.versionTag = (0, D.uniqueKey)();
+				let t = 0;
+				V(e.columns || {}, (e, n) => {
+					this.columns[n] = e.slice(), t = Math.max(t, e.length);
+				}), this.applyRowCount(t);
+			}
+			applyRowCount(e) {
+				this.rowCount = e, V(this.columns, (t, n) => {
+					t.length !== e && (this.columns[n] = it(t, e));
+				});
+			}
+			deleteRows(e, t = 1) {
+				if (t > 0 && e < this.rowCount) {
+					let n = 0;
+					V(this.columns, (r, i) => {
+						this.columns[i] = at(r, e, t).array, n = r.length;
+					}), this.rowCount = n;
+				}
+				I(this, "afterDeleteRows", {
+					rowIndex: e,
+					rowCount: t
+				}), this.versionTag = (0, D.uniqueKey)();
+			}
+			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;
+				V(e, (e, t) => {
+					this.columns[t] = e.slice(), r = e.length;
+				}), this.applyRowCount(r), n?.silent || (I(this, "afterSetColumns"), this.versionTag = (0, D.uniqueKey)());
+			}
+			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] = []);
+				}
+				V(i, (o, s) => {
+					o || r?.addColumns === !1 || (o = Array(a)), o && (n ? o = at(o, t, 0, !0, [e[s] ?? null]).array : o[t] = e[s] ?? null, i[s] = o);
+				}), a > this.rowCount && this.applyRowCount(a), r?.silent || (I(this, "afterSetRows"), this.versionTag = (0, D.uniqueKey)());
+			}
+			getModified() {
+				return this.modified || this;
+			}
+		};
+		(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 <= D.timeUnits.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 (0, D.error)(12, !1, this.chart);
+				if (o && N(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 = A((e - n) * r + this.minPixelPadding), o = A(t.getIndexOfPoint(a, i)), s = A(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 && N(t.overscroll) && t.overscroll !== 0 && L(this.max) && L(this.min) && (this.options.ordinal && !this.ordinal.originalOrdinalRange && this.ordinal.getExtendedPositions(!1), this.isFullRange = N(this.dataMin) && N(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 && N(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, M(this.container, { cursor: "move" })) : a = !0;
+				} else a = !0;
+				a || i && /y/.test(i.type) ? n && L(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, k(e, "afterInit", a), k(e, "foundExtremes", o), k(e, "afterSetScale", s), k(e, "initialAxisTranslation", c), k(f, "pan", l), k(f, "touchpan", l), k(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, H(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 = H(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: O().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 ot({ 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) + A((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 (N(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 H(t.originalOrdinalRange, N(n.dataMax) && N(n.dataMin) ? n.dataMax - n.dataMin : 0) * e;
+					};
+					if (R(e)) {
+						let t = parseInt(e, 10);
+						if (!1 === n.isFullRange && L(n.min) && L(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;
+				}
+			};
+		})(v ||= {});
+		let st = v, ct = {
+			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"
+			}
+		}, lt = {
+			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: ut } = O(), { composed: dt } = O(), ft = [];
+		function pt() {
+			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;
+			};
+			L(n) ? (e = i - n, t = n) : n && (e = i + o(i, -(n.count || 1)), this.chart && this.chart.setFixedRange(i - e));
+			let s = H(this.dataMin, 5e-324);
+			return L(e) || (e = s), e <= s && (e = s, t === void 0 && (t = o(e, n.count)), this.newMax = Math.min(e + t, H(this.dataMax, Number.MAX_VALUE))), L(i) ? !L(n) && n && n._offsetMin && (e += n._offsetMin) : e = void 0, e;
+		}
+		function mt() {
+			this.rangeSelector?.redrawElements();
+		}
+		function ht() {
+			this.options.rangeSelector && this.options.rangeSelector.enabled && (this.rangeSelector = new p(this));
+		}
+		function gt() {
+			let e = this.rangeSelector;
+			if (e) {
+				L(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 _t() {
+			let e, t = this.rangeSelector;
+			if (!t) return;
+			let n = this.xAxis[0].getExtremes(), r = this.legend, i = t && t.options.verticalAlign;
+			L(n.min) && t.render(n.min, n.max), r?.display && i === "top" && i === r.options.verticalAlign && (e = B(this.spacingBox), r.options.layout === "vertical" ? e.y = this.plotTop : e.y += t.getHeight(), r.group.placed = !1, r.align(e));
+		}
+		function vt() {
+			for (let e = 0, t = ft.length; e < t; ++e) {
+				let t = ft[e];
+				if (t[0] === this) {
+					t[1].forEach((e) => e()), ft.splice(e, 1);
+					return;
+				}
+			}
+		}
+		function yt() {
+			let e = this.rangeSelector;
+			if (e?.options?.enabled) {
+				let { min: t, max: n } = this.xAxis[0].getExtremes();
+				L(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 bt(e) {
+			let t = e.options.rangeSelector, n = this.extraBottomMargin, r = this.extraTopMargin, i = this.rangeSelector;
+			if (t && t.enabled && !N(i) && this.options.rangeSelector && (this.options.rangeSelector.enabled = !0, this.rangeSelector = i = new p(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 xt = function(e, t, n) {
+			if (p = n, U(dt, "RangeSelector")) {
+				let n = t.prototype;
+				e.prototype.minFromRange = pt, k(t, "afterGetContainer", ht), k(t, "beforeRender", gt), k(t, "destroy", vt), k(t, "getMargins", yt), k(t, "redraw", _t), k(t, "update", bt), k(t, "beforeRedraw", mt), n.callbacks.push(_t), F(ut, { rangeSelector: lt }), F(ut.lang, ct);
+			}
+		};
+		var St = T(28), Ct = T.n(St), wt = T(984), Tt = T.n(wt);
+		let { defaultOptions: Et } = O(), { format: Dt } = Tt();
+		function Ot(e) {
+			let t = (t) => RegExp(`%[[a-zA-Z]*${t}`).test(e);
+			if (R(e) ? e.indexOf("%L") !== -1 : e.fractionalSecondDigits) return "text";
+			let n = R(e) ? [
+				"a",
+				"A",
+				"d",
+				"e",
+				"w",
+				"b",
+				"B",
+				"m",
+				"o",
+				"y",
+				"Y"
+			].some(t) : e.dateStyle || e.day || e.month || e.year, r = R(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 kt {
+			static compose(e, t) {
+				xt(e, t, kt);
+			}
+			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 = L(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), L(h.newMax) && (d = h.newMax), _ = !1) : p = r;
+					else if (p) L(d) && (d = Math.min((u = Math.max(d - p, c)) + p, l), _ = !1);
+					else if (o === "ytd") {
+						if (i) !i.hasData() || L(l) && L(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), L(l) && L(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 && N(u) && (u += r._offsetMin), r._offsetMax && N(d) && (d += r._offsetMax), this.dropdown && (this.dropdown.selectedIndex = e + 1), i) (L(u) || L(d)) && (i.setExtremes(u, d, H(t, !0), void 0, {
+						trigger: "rangeSelectorButton",
+						rangeSelectorButton: r
+					}), n.setFixedRange(r._range));
+					else {
+						f = G(n.options.xAxis || {})[0];
+						let e = k(n, "afterCreateAxes", function() {
+							let e = n.xAxis[0];
+							e.range = e.options.range = p, e.min = e.options.min = m;
+						});
+						k(n, "load", function() {
+							let t = n.xAxis[0];
+							n.setFixedRange(r._range), t.options.range = f.range, t.options.min = f.min, e();
+						});
+					}
+					I(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 && I(e, "blur"), n && n.blur && I(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 = Dt(e.text, { count: e.count || 1 }), e.title = Dt(e.title, { count: e.count || 1 }), e)), this.eventsToUnbind = [], this.eventsToUnbind.push(k(e.container, "mousedown", o)), this.eventsToUnbind.push(k(e, "resize", o)), i.forEach(t.computeButtonRange), a !== void 0 && i[a] && this.clickButton(a, !1), this.eventsToUnbind.push(k(e, "load", function() {
+					e.xAxis && e.xAxis[0] && k(e.xAxis[0], "setExtremes", function(n) {
+						L(this.max) && L(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 = 864e5, 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), _ = L(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: (Et.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();
+						M(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 = H(e.offsetMin, 0), e._offsetMax = H(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", Ot(n.inputDateFormat || "%e %b %Y"));
+					let e = i.getAttribute("data-hc-time"), o = N(e) ? Number(e) : void 0;
+					if (N(t)) {
+						let e = o;
+						N(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;
+					M(n, {
+						width: e ? o + (c ? -2 : 20) + "px" : "auto",
+						height: s - 2 + "px",
+						border: "2px solid silver"
+					}), e && c ? M(n, {
+						left: r + a + "px",
+						top: i + "px"
+					}) : M(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 && M(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 = Et.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);
+					L(d) && d !== u && (l && n && L(s) ? d > Number(n.getAttribute("data-hc-time")) ? d = void 0 : d < s && (d = s) : r && L(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 = le("input", {
+					name: e,
+					className: "highcharts-range-selector"
+				}, void 0, n);
+				m.setAttribute("type", Ot(s.inputDateFormat || "%e %b %Y")), t.styledMode || (f.css(B(a, s.labelStyle)), p.css(B({ color: "#333333" }, a, s.inputStyle)), M(m, F({
+					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 === O().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 = H(r.chart.style?.zIndex, 0) + 1;
+				!1 !== i.enabled && (this.group = t.g("range-selector-group").attr({ zIndex: 7 }).add(), this.div = le("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 (N(i.dataMin) && N(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 = Et.lang, i = t.renderer, a = B(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 = le("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, () => {}, B(a, {
+					"stroke-width": H(a["stroke-width"], 0),
+					width: "auto",
+					paddingLeft: H(n.buttonTheme.paddingLeft, c?.padding, 8),
+					paddingRight: H(n.buttonTheme.paddingRight, c?.padding, 8)
+				}), o && o.hover, o && o.select, o && o.disabled).hide().add(this.group), k(s, "touchstart", () => {
+					s.style.fontSize = "16px";
+				});
+				let l = O().isMS ? "mouseover" : "mouseenter", u = O().isMS ? "mouseout" : "mouseleave";
+				k(s, l, () => {
+					I(this.dropdownLabel.element, l);
+				}), k(s, u, () => {
+					I(this.dropdownLabel.element, u);
+				}), k(s, "change", () => {
+					I(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)), le("option", {
+					textContent: this.zoomText.textStr,
+					disabled: !0
+				}, void 0, s), this.createButtons();
+			}
+			createButtons() {
+				let { options: e } = this, t = B(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 = B(s.buttonTheme);
+				i?.add(le("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 + H(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 = B(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 ?? [], N(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 && M(a, {
+					left: u + "px",
+					top: i?.translateY + "px"
+				}), o?.attr({ x: u }), i && i.align({
+					y: s.y,
+					width: H(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: H(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(), M(n, { visibility: "inherit" }), this.hasVisibleDropdown = !0);
+			}
+			hideDropdown() {
+				let { dropdown: e } = this;
+				e && (this.dropdownLabel.hide(), M(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 (B(!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), N(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), ue(e.buttons), t && (t.onfocus = t.onblur = t.onchange = null), n && (n.onfocus = n.onblur = n.onchange = null), V(e, function(t, n) {
+					t && n !== "chart" && (t instanceof Ct() ? t.destroy() : t instanceof window.HTMLElement && t?.parentElement?.removeChild(t), delete e[n]), t !== kt.prototype[n] && (e[n] = null);
+				}, this), this.buttons = [];
+			}
+		}
+		F(kt.prototype, { inputTypeFormats: {
+			"datetime-local": "%Y-%m-%dT%H:%M:%S",
+			date: "%Y-%m-%d",
+			time: "%H:%M:%S"
+		} });
+		var At = T(960), jt = T.n(At);
+		let { format: Mt } = Tt(), { getOptions: Nt } = O(), { setFixedRange: Pt } = He;
+		function Ft(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 It(e, t) {
+			if (e === "xAxis") {
+				let e = H(t.navigator?.enabled, Re.enabled, !0), n = {
+					type: "datetime",
+					categories: void 0
+				};
+				return e && (n.startOnTick = !1, n.endOnTick = !1), n;
+			}
+			return {};
+		}
+		class Lt extends jt() {
+			init(e, t) {
+				let n = Nt(), r = e.xAxis, i = e.yAxis, a = H(e.navigator?.enabled, Re.enabled, !0);
+				e.xAxis = e.yAxis = void 0;
+				let o = B({
+					chart: {
+						panning: {
+							enabled: !0,
+							type: "x"
+						},
+						zooming: {
+							pinchType: "x",
+							mouseWheel: { type: "x" }
+						}
+					},
+					navigator: { enabled: a },
+					scrollbar: { enabled: H(Ze.enabled, !0) },
+					rangeSelector: { enabled: H(lt.enabled, !0) },
+					title: { text: null },
+					tooltip: {
+						split: H(n.tooltip?.split, !0),
+						crosshairs: !0
+					},
+					legend: { enabled: !1 }
+				}, e, { isStock: !0 });
+				e.xAxis = r, e.yAxis = i, o.xAxis = G(e.xAxis || {}).map((t) => B(Ft("xAxis", t, n.xAxis), t, It("xAxis", e))), o.yAxis = G(e.yAxis || {}).map((e) => B(Ft("yAxis", e, n.yAxis), e)), super.init(o, t);
+			}
+			createAxis(e, t) {
+				return t.axis = B(Ft(e, t.axis, Nt()[e]), t.axis, It(e, this.userOptions)), super.createAxis(e, t);
+			}
+		}
+		k(jt(), "update", function(e) {
+			let t = e.options;
+			"scrollbar" in t && this.navigator && (B(!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 && L(this.min) && L(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: H(r.padding, 8),
+					r: H(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(F({
+					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) : L(C) && C > b && C < x, T = "";
+				g ? T = Mt(g, { value: C }, t) : r.formatter && L(C) && (T = r.formatter.call(this, C, this)), p.attr({
+					text: T,
+					x: m,
+					y: h,
+					visibility: w ? "inherit" : "hidden"
+				});
+				let E = p.getBBox();
+				!L(p.x) || i || a || (m = p.x - E.width / 2), L(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) : L(g) ? [n[h][g]] : R(g) ? [n.get(g)] : t.map((e) => e[h]), u)) if (!r.options.isInternal) {
+						let e = r.isXAxis ? "yAxis" : "xAxis";
+						this === (N(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 || fe(p, (t) => t.pos === e.pos && t.len === e.len) || p.push(e);
+					if (L(m = H(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 = ce(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] = B(e.plotOptions[this.type], t));
+				}
+			}
+			function s() {
+				let e = this.chart, t = this.options.dataGrouping;
+				return !1 !== this.allowDG && t && H(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];
+					N(r[1]) && r[1] === i[1] && (r[1] = i[1] = j(r[1], t)), N(r[2]) && r[2] === i[2] && (r[2] = i[2] = j(r[2], t));
+				}
+				return e;
+			}
+			e.compose = function(e, l, u, d) {
+				let f = u.prototype;
+				f.forceCropping || (k(l, "afterDrawCrosshair", t), k(l, "afterHideCrosshair", n), k(l, "autoLabelAlign", r), k(l, "destroy", i), k(l, "getPlotLinePath", a), e.prototype.setFixedRange = Pt, f.forceCropping = s, k(u, "setOptions", o), d.prototype.crispPolyLine = c);
+			}, e.stockChart = function(t, n, r) {
+				return new e(t, n, r);
+			};
+		}(Lt ||= {});
+		let Rt = Lt, { column: { prototype: { pointClass: zt } } } = K().seriesTypes, { column: Bt } = K().seriesTypes, { defaultOptions: Vt } = O();
+		class Ht extends Bt {
+			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 = j(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 = j(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;
+				});
+			}
+		}
+		Ht.defaultOptions = B(Bt.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
+		}), F(Ht.prototype, {
+			pointClass: class extends zt {},
+			animate: null,
+			directTouch: !1,
+			keysAffectYAxis: ["low", "high"],
+			pointArrayMap: [
+				"high",
+				"low",
+				"close"
+			],
+			pointAttrToOptions: {
+				stroke: "color",
+				"stroke-width": "lineWidth"
+			},
+			pointValKey: "close"
+		}), F(Vt.lang, {
+			stockOpen: "Open",
+			stockHigh: "High",
+			stockLow: "Low",
+			stockClose: "Close"
+		}), K().registerSeriesType("hlc", Ht);
+		let { seriesTypes: { hlc: Ut } } = K();
+		class Wt extends Ut.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: Gt } = O(), { hlc: Kt } = K().seriesTypes;
+		function qt(e) {
+			let t = e.options, n = t.dataGrouping;
+			n && t.useOhlcData && t.id !== "highcharts-navigator-series" && (n.approximation = "ohlc");
+		}
+		function Jt(e) {
+			let t = e.options;
+			t.useOhlcData && t.id !== "highcharts-navigator-series" && F(this, {
+				pointValKey: J.prototype.pointValKey,
+				pointArrayMap: J.prototype.pointArrayMap,
+				toYData: J.prototype.toYData
+			});
+		}
+		class J extends Kt {
+			static compose(e) {
+				U(Gt, "OHLCSeries") && (k(e, "afterSetOptions", qt), k(e, "init", Jt));
+			}
+			getPointPath(e, t) {
+				let n = super.getPointPath(e, t), r = t.strokeWidth(), i = j(e.plotX || 0, r), a = Math.round(e.shapeArgs.width / 2);
+				if (e.open !== null) {
+					let t = j(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
+				];
+			}
+		}
+		J.defaultOptions = B(Kt.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/>" } }), F(J.prototype, {
+			pointClass: Wt,
+			pointArrayMap: [
+				"open",
+				"high",
+				"low",
+				"close"
+			]
+		}), K().registerSeriesType("ohlc", J);
+		let { column: Yt, ohlc: Xt } = K().seriesTypes;
+		class Zt extends Xt {
+			pointAttribs(e, t) {
+				let n = Yt.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 = j(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 = j(o, m), s = j(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);
+					}
+				}
+			}
+		}
+		Zt.defaultOptions = B(Xt.defaultOptions, { tooltip: Xt.defaultOptions.tooltip }, {
+			states: { hover: { lineWidth: 2 } },
+			threshold: null,
+			lineColor: "#000000",
+			lineWidth: 1,
+			upColor: "#ffffff",
+			stickyTracking: !0
+		}), K().registerSeriesType("candlestick", Zt);
+		let { column: { prototype: { pointClass: Qt } } } = K().seriesTypes, $t = class extends Qt {
+			constructor() {
+				super(...arguments), this.ttBelow = !1;
+			}
+			isValid() {
+				return L(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 = Ve().getRendererType();
+				t.indexOf(i) && t.push(i);
+			};
+		})(y ||= {});
+		let en = y;
+		var tn = T(448), nn = T.n(tn);
+		let { composed: rn } = O(), { prototype: an } = nn(), { prototype: on } = re();
+		var sn = b ||= {};
+		function cn(e) {
+			return on.getPlotBox.call(this.options.onSeries && this.chart.get(this.options.onSeries) || this, e);
+		}
+		function ln() {
+			an.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), function(e, t) {
+					let n, r, i = e.length;
+					for (r = 0; r < i; r++) e[r].safeI = r;
+					for (e.sort(function(e, r) {
+						return (n = t(e, r)) === 0 ? e.safeI - r.safeI : n;
+					}), r = 0; r < i; r++) delete e[r].safeI;
+				}(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 (N(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;
+							}
+							N(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 = N(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;
+		}
+		sn.compose = function(e) {
+			if (U(rn, "OnSeries")) {
+				let t = e.prototype;
+				t.getPlotBox = cn, t.translate = ln;
+			}
+			return e;
+		}, sn.getPlotBox = cn, sn.translate = ln;
+		let un = b, { noop: dn } = O(), { distribute: fn } = O(), { series: pn, seriesTypes: { column: mn } } = K();
+		class Y extends mn {
+			animate(e) {
+				e && this.setClip();
+			}
+			drawPoints() {
+				var e, t;
+				let n, r, i, a, o, s, c, l, u, d, f, p, m = this.points, h = this.chart, g = h.renderer, _ = h.inverted, v = this.options, y = v.y, b = this.yAxis, x = {}, S = [], C = L(v.borderRadius) ? v.borderRadius : 0;
+				for (a = m.length; a--;) o = m[a], d = (_ ? o.plotY : o.plotX) > this.xAxis.len, n = o.plotX, c = o.stackIndex, i = o.options.shape || v.shape, (r = o.plotY) !== void 0 && (r = o.plotY + y - (c !== void 0 && c * v.stackDistance)), o.anchorX = c ? void 0 : o.plotX, l = c ? void 0 : o.plotY, f = i !== "flag", s = o.graphic, r !== void 0 && n >= 0 && !d ? (s && o.hasNewShapeType() && (s = s.destroy()), s || (s = o.graphic = g.label("", 0, void 0, i, void 0, void 0, v.useHTML).addClass(o.getClassName()).add(this.markerGroup), o.graphic.div && (o.graphic.div.point = o), s.isNew = !0), s.attr({
+					align: f ? "center" : "left",
+					width: v.width,
+					height: v.height,
+					"text-align": v.textAlign,
+					r: C
+				}), h.styledMode || s.attr(this.pointAttribs(o)).css(B(v.style, o.style)).shadow(v.shadow), n > 0 && (n -= s.strokeWidth() % 2), u = {
+					y: r,
+					anchorY: l
+				}, v.allowOverlapX && (u.x = n, u.anchorX = o.anchorX), s.attr({ text: o.options.title ?? v.title ?? "A" })[s.isNew ? "attr" : "animate"](u), v.allowOverlapX || (x[o.plotX] ? x[o.plotX].size = Math.max(x[o.plotX].size, s.width || 0) : x[o.plotX] = {
+					align: .5 * !!f,
+					size: s.width || 0,
+					target: n,
+					anchorX: n
+				}), o.tooltipPos = [n, r + b.pos - h.plotTop]) : s && (o.graphic = s.destroy());
+				if (!v.allowOverlapX) {
+					let e = 100;
+					for (let t of (V(x, function(t) {
+						t.plotX = t.anchorX, S.push(t), e = Math.max(t.size, e);
+					}), fn(S, _ ? b.len : this.xAxis.len, e), m)) {
+						let e = t.plotX, n = t.graphic, r = n && x[e];
+						r && n && (N(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);
+					}
+				}
+				v.useHTML && this.markerGroup && (e = this.markerGroup, t = function(e) {
+					return Ct().prototype.on.apply(e.apply(this, [].slice.call(arguments, 1)), [].slice.call(arguments, 1));
+				}, p = e.on, e.on = function() {
+					let e = arguments, n = this;
+					return t.apply(this, [function() {
+						return p.apply(n, arguments.length ? arguments : e);
+					}].concat([].slice.call(arguments)));
+				});
+			}
+			drawTracker() {
+				let e = this.points;
+				for (let t of (super.drawTracker(), e)) {
+					let n = t.graphic;
+					n && (t.unbindMouseOver && t.unbindMouseOver(), t.unbindMouseOver = k(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() {
+				pn.prototype.setClip.apply(this, arguments), !1 !== this.options.clip && this.sharedClipKey && this.markerGroup && this.markerGroup.clip(this.chart.sharedClips[this.sharedClipKey]);
+			}
+		}
+		Y.compose = en.compose, Y.defaultOptions = B(mn.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"
+			}
+		}), un.compose(Y), F(Y.prototype, {
+			allowDG: !1,
+			forceCrop: !0,
+			invertible: !1,
+			noSharedTooltip: !0,
+			pointClass: $t,
+			sorted: !1,
+			takeOrdinalPosition: !1,
+			trackerGroups: ["markerGroup"],
+			buildKDTree: dn,
+			init: pn.prototype.init
+		}), K().registerSeriesType("flags", Y);
+		var hn = T(184), gn = T.n(hn);
+		(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, H(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 : H(a.options.threshold, e.min), o.forEach(function(a) {
+							i = a["stack" + t.toUpperCase()] ?? a[t], n.forEach(function(t) {
+								if (L(r) && L(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 && I(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 (gn())(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"), k(e, "init", i), k(e, "afterInit", t), k(e, "afterSetTickPositions", r), k(e, "afterSetOptions", n);
+					let u = l.prototype;
+					u.drawBreaks = s, u.gappedPath = c, k(l, "afterGeneratePoints", a), k(l, "afterRender", o);
+				}
+				return e;
+			};
+			class l {
+				static isInBreak(e, t) {
+					let n = e.repeat || 1 / 0, 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 || !L(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 || !L(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 fe(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 && L(e)) {
+						for (; i--;) l.isInBreak(r[i], e) && (a = !0, o ||= H(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 = z(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;
+							L(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 || 1 / 0, L(u) && L(d) && (l.isInBreak(e, u) && (u += e.to % c - u % c), l.isInBreak(e, d) && (d -= d % c - e.from % c));
+							}), L(f) && L(p) && e.forEach(function(e) {
+								for (m = e.from, c = e.repeat || 1 / 0; 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 && L(m) && (i.push({
+									from: m,
+									to: e.value,
+									len: e.value - m - (e.size || 0)
+								}), L(u) && L(d) && m < d && e.value > u && (o += e.value - m - (e.size || 0)));
+							}), n.breakArray = i, L(u) && L(d) && L(r.min) && (n.unitLength = d - u - o + a, I(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);
+						}
+					}), H(t, !0) && r.chart.redraw();
+				}
+			}
+			e.Additions = l;
+		})(x ||= {});
+		let _n = x, X = O();
+		X.BrokenAxis = X.BrokenAxis || _n, X.BrokenAxis.compose(X.Axis, X.Series);
+		let Z = {};
+		function vn(e) {
+			let t = e.length, n = yn(e);
+			return L(n) && t && (n = A(n / t)), n;
+		}
+		function yn(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 bn = {
+			average: vn,
+			averages: function() {
+				let e = [];
+				return [].forEach.call(arguments, function(t) {
+					e.push(vn(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 ? se(e) : e.hasNulls ? null : void 0;
+			},
+			hlc: function(e, t, n) {
+				if (e = Z.high(e), t = Z.low(t), n = Z.close(n), L(e) || L(t) || L(n)) return [
+					e,
+					t,
+					n
+				];
+			},
+			low: function(e) {
+				return e.length ? oe(e) : e.hasNulls ? null : void 0;
+			},
+			ohlc: function(e, t, n, r) {
+				if (e = Z.open(e), t = Z.high(t), n = Z.low(n), r = Z.close(r), L(e) || L(t) || L(n) || L(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 = Z.low(e), t = Z.high(t), L(e) || L(t) ? [e, t] : e === null && t === null ? null : void 0;
+			},
+			sum: yn
+		};
+		F(Z, bn);
+		let xn = {
+			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"
+				]
+			}
+		}, Sn = {
+			line: {},
+			spline: {},
+			area: {},
+			areaspline: {},
+			arearange: {},
+			column: { groupPixelWidth: 10 },
+			columnrange: { groupPixelWidth: 10 },
+			candlestick: { groupPixelWidth: 10 },
+			ohlc: { groupPixelWidth: 5 },
+			hlc: { groupPixelWidth: 5 },
+			heikinashi: { groupPixelWidth: 10 }
+		}, Cn = [
+			["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]
+		];
+		function wn(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 Tn() {
+			let e = this.series, t = e.length, n = 0, r = !1, i, a;
+			for (; t--;) (a = e[t].options.dataGrouping) && (n = Math.max(n, H(a.groupPixelWidth, xn.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 En() {
+			this.series.forEach(function(e) {
+				e.hasProcessed = !1;
+			});
+		}
+		function Dn(e, t) {
+			let n;
+			if (t = H(t, !0), e ||= {
+				forced: !1,
+				units: null
+			}, this instanceof m) 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 : B(e, t.dataGrouping);
+			});
+			this.ordinal && (this.ordinal.slope = void 0), t && this.chart.redraw();
+		}
+		let On = function(e) {
+			m = e;
+			let t = e.prototype;
+			t.applyGrouping || (k(e, "afterSetScale", En), k(e, "postProcessData", wn), F(t, {
+				applyGrouping: wn,
+				getGroupPixelWidth: Tn,
+				setDataGrouping: Dn
+			}));
+		};
+		(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, k(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 = D.timeUnits[r[0]], a = r[1], o, s;
+					for (o = 0; o < n.length; o++) if (r = n[o], i = D.timeUnits[r[0]], a = r[1], n[o + 1]) {
+						let t = (i * a[a.length - 1] + D.timeUnits[n[o + 1][0]]) / 2;
+						if (e <= t) {
+							s = t / e;
+							break;
+						}
+					}
+					i === D.timeUnits.year && e < 5 * i && (a = [
+						1,
+						2,
+						5
+					]);
+					let c = function(e, t, n, r, i) {
+						let a, o = e;
+						n = H(n, de(e));
+						let s = e / n;
+						for (t ||= [
+							1,
+							2,
+							2.5,
+							5,
+							10
+						], a = 0; a < t.length && (o = t[a], !(s <= (t[a] + (t[a + 1] || t[a])) / 2)); a++);
+						return A(o * n, -Math.round(Math.log(.001) / Math.LN10));
+					}(e / i, a, r[0] === "year" ? Math.max(de(e / i), 1) : 1);
+					return {
+						unitRange: i,
+						count: c,
+						unitName: r[0],
+						match: s
+					};
+				}
+				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;
+		})(S ||= {});
+		let kn = S, { series: { prototype: An } } = K(), jn = An.generatePoints;
+		function Mn(e) {
+			var t, n, r;
+			let i, a, o = this.chart, s = this.options.dataGrouping, c = !1 !== this.allowDG && s && H(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 && _ && L(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(kn.Additions.prototype.normalizeTimeTickInterval(c, s.units || Cn), Math.min(e, g[0]), Math.max(t, g[g.length - 1]), v.options.startOfWeek, g, this.closestPointRange), p = An.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", (0, D.error)(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;
+						L(r) && L(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 && (N((r = S)[0]) && L(v.min) && L(v.dataMin) && r[0] < v.min && ((!N(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)), N(r[r.length - 1]) && L(v.max) && L(v.dataMax) && r[r.length - 1] > v.max && ((!N(v.options.max) && L(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 Nn() {
+			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 Pn() {
+			jn.apply(this), this.destroyGroupedData(), this.groupedData = this.hasGroupedData ? this.points : null;
+		}
+		function Fn() {
+			return this.is("arearange") ? "range" : this.is("ohlc") ? "ohlc" : this.is("hlc") ? "hlc" : this.is("column") || this.options.cumulative ? "sum" : "average";
+		}
+		function In(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 ot(), 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 && Z[n] ? Z[n] : Z[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 && !N(a.dataGroupInfo.options) && (a.dataGroupInfo.options = B(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 = G(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++) L(t = r[m[e]]) ? p[e].push(t) : t === null && (p[e].hasNulls = !0);
+				} else L(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 Ln(e) {
+			let t = e.options, n = this.type, r = this.chart.options.plotOptions, i = this.useCommonDataGrouping && xn, a = O().defaultOptions.plotOptions[n].dataGrouping;
+			if (r && (Sn[n] || i)) {
+				let e = this.chart.rangeSelector;
+				a ||= B(xn, Sn[n]), t.dataGrouping = B(i, a, r.series && r.series.dataGrouping, r[n].dataGrouping, this.userOptions.dataGrouping, !t.isInternal && e && L(e.selected) && e.buttonOptions[e.selected].dataGrouping);
+			}
+		}
+		let Rn = function(e) {
+			let t = e.prototype;
+			t.applyGrouping || (k(e.prototype.pointClass, "update", function() {
+				if (this.dataGroup) return (0, D.error)(24, !1, this.series.chart), !1;
+			}), k(e, "afterSetOptions", Ln), k(e, "destroy", Nn), F(t, {
+				applyGrouping: Mn,
+				destroyGroupedData: Nn,
+				generatePoints: Pn,
+				getDGApproximation: Fn,
+				groupData: In
+			}));
+		}, { format: zn } = Tt(), { composed: Bn } = O();
+		function Vn(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 && L(r.key)) {
+				d = i.currentDataGrouping, f = s.dateTimeLabelFormats || xn.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 = H(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 = zn(h, {
+					point: F(r, { key: m }),
+					series: i
+				}, t), e.preventDefault();
+			}
+		}
+		let Q = O();
+		Q.dataGrouping = Q.dataGrouping || {}, Q.dataGrouping.approximationDefaults = Q.dataGrouping.approximationDefaults || bn, Q.dataGrouping.approximations = Q.dataGrouping.approximations || Z, {
+			compose: function(e, t, n) {
+				On(e), Rn(t), n && U(Bn, "DataGrouping") && k(n, "headerFormatter", Vn);
+			},
+			groupData: In
+		}.compose(Q.Axis, Q.Series, Q.Tooltip);
+		let Hn = {
+			backgroundColor: "color",
+			backgroundColors: "color",
+			borderColor: "color",
+			borderRadius: "string",
+			color: "color",
+			fill: "color",
+			fontSize: "string",
+			labels: "string",
+			name: "string",
+			stroke: "color",
+			title: "string"
+		}, { getAssignedAxis: Un } = {
+			annotationsFieldsTypes: Hn,
+			getAssignedAxis: function(e) {
+				return e.filter((e) => {
+					let t = e.axis.getExtremes(), n = t.min, r = t.max, i = H(e.axis.minPointOffset, 0);
+					return L(n) && L(r) && e.value >= n - i && e.value <= r + i && !e.axis.options.isInternal;
+				})[0];
+			},
+			getFieldType: function(e, t) {
+				let n = Hn[e], r = typeof t;
+				return N(n) && (r = n), {
+					string: "text",
+					number: "number",
+					boolean: "checkbox",
+					color: "color"
+				}[r];
+			}
+		}, Wn = [], Gn = {
+			enabled: !0,
+			sensitivity: 1.1,
+			showResetButton: !1
+		}, Kn = function(e, t, n, r, i, a, o) {
+			let s = H(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
+			});
+			if (l) {
+				var u;
+				N(h) && N(u = h) && clearTimeout(u), h = setTimeout(() => {
+					e.pointer?.drop();
+				}, 400);
+			}
+			return l;
+		};
+		function qn() {
+			var e;
+			let t = (me(e = this.zooming.mouseWheel) || (e = { enabled: e ?? !0 }), B(Gn, e));
+			t.enabled && k(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 = Un(n.getCoordinates(e).xAxis), o = Un(n.getCoordinates(e).yAxis);
+					Kn(this, r ** +i, a ? [a.axis] : this.xAxis, o ? [o.axis] : this.yAxis, e.chartX, e.chartY, t) && e.preventDefault?.();
+				}
+			});
+		}
+		let Jn = O();
+		Jn.MouseWheelZoom = Jn.MouseWheelZoom || { compose: function(e) {
+			Wn.indexOf(e) === -1 && (Wn.push(e), k(e, "afterGetContainer", qn));
+		} }, Jn.MouseWheelZoom.compose(Jn.Chart);
+		let $ = O();
+		$.Navigator = $.Navigator || rt, $.OrdinalAxis = $.OrdinalAxis || st, $.RangeSelector = $.RangeSelector || kt, $.Scrollbar = $.Scrollbar || q, $.stockChart = $.stockChart || Rt.stockChart, $.StockChart = $.StockChart || $.stockChart, F($.StockChart, Rt), ge.compose($.Series, $.Axis, $.Point), Y.compose($.Renderer), J.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 Yn = O();
+		return E.default;
+	})());
+}));
+//#endregion
+export default t();