@mobileaction/action-kit 1.58.11 → 1.58.12-beta.20260410074915

package/dist/annotations-Bi0ijjZw.js

@@ -0,0 +1,1903 @@
+import { t as e } from "./chunk-BdsCSvBP.js";
+//#region node_modules/highcharts/modules/annotations.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	(function(n, r) {
+		typeof e == "object" && typeof t == "object" ? t.exports = r(n._Highcharts, n._Highcharts.SeriesRegistry, n._Highcharts.Templating, n._Highcharts.AST) : typeof define == "function" && define.amd ? define("highcharts/modules/annotations", ["highcharts/highcharts"], function(e) {
+			return r(e, e.SeriesRegistry, e.Templating, e.AST);
+		}) : typeof e == "object" ? e["highcharts/modules/annotations"] = r(n._Highcharts, n._Highcharts.SeriesRegistry, n._Highcharts.Templating, n._Highcharts.AST) : n.Highcharts = r(n.Highcharts, n.Highcharts.SeriesRegistry, n.Highcharts.Templating, n.Highcharts.AST);
+	})("u" < typeof window ? e : window, (e, t, n, r) => (() => {
+		var i, a, o, s, c, l = {
+			512: (e) => {
+				e.exports = t;
+			},
+			660: (e) => {
+				e.exports = r;
+			},
+			944: (t) => {
+				t.exports = e;
+			},
+			984: (e) => {
+				e.exports = n;
+			}
+		}, u = {};
+		function d(e) {
+			var t = u[e];
+			if (t !== void 0) return t.exports;
+			var n = u[e] = { exports: {} };
+			return l[e](n, n.exports, d), n.exports;
+		}
+		d.n = (e) => {
+			var t = e && e.__esModule ? () => e.default : () => e;
+			return d.d(t, { a: t }), t;
+		}, d.d = (e, t) => {
+			for (var n in t) d.o(t, n) && !d.o(e, n) && Object.defineProperty(e, n, {
+				enumerable: !0,
+				get: t[n]
+			});
+		}, d.o = (e, t) => Object.prototype.hasOwnProperty.call(e, t);
+		var f = {};
+		d.d(f, { default: () => jn });
+		var p = d(944), m = d.n(p);
+		let { addEvent: h, erase: ee, find: te, fireEvent: ne, isArray: re, isObject: ie, pick: ae, wrap: oe } = m();
+		function se(e, t) {
+			let n = this.initAnnotation(e);
+			return this.options.annotations.push(n.options), ae(t, !0) && (n.redraw(), n.graphic.attr({ opacity: 1 })), n;
+		}
+		function ce() {
+			let e = this;
+			e.plotBoxClip = this.renderer.clipRect(this.plotBox), e.controlPointsGroup = e.renderer.g("control-points").attr({ zIndex: 99 }).clip(e.plotBoxClip).add(), e.options.annotations.forEach((t, n) => {
+				if (!e.annotations.some((e) => e.options === t)) {
+					let r = e.initAnnotation(t);
+					e.options.annotations[n] = r.options;
+				}
+			}), e.drawAnnotations(), h(e, "redraw", e.drawAnnotations), h(e, "destroy", function() {
+				e.plotBoxClip.destroy(), e.controlPointsGroup.destroy();
+			}), h(e, "exportData", function(t) {
+				let n = e.annotations, r = (this.options.exporting && this.options.exporting.csv || {}).columnHeaderFormatter, i = !t.dataRows[1].xValues, a = e.options.lang && e.options.lang.exportData && e.options.lang.exportData.annotationHeader, o = t.dataRows[0].length, s = e.options.exporting?.csv?.annotations?.itemDelimiter, c = e.options.exporting?.csv?.annotations?.join;
+				n.forEach((e) => {
+					e.options.labelOptions?.includeInDataExport && e.labels.forEach((e) => {
+						if (e.options.text) {
+							let n = e.options.text;
+							e.points.forEach((e) => {
+								let r = e.x, i = e.series.xAxis ? e.series.xAxis.index : -1, a = !1;
+								if (i === -1) {
+									let e = t.dataRows[0].length, o = Array(e);
+									for (let t = 0; t < e; ++t) o[t] = "";
+									o.push(n), o.xValues = [], o.xValues[i] = r, t.dataRows.push(o), a = !0;
+								}
+								if (a || t.dataRows.forEach((e) => {
+									!a && e.xValues && i !== void 0 && r === e.xValues[i] && (c && e.length > o ? e[e.length - 1] += s + n : e.push(n), a = !0);
+								}), !a) {
+									let e = t.dataRows[0].length, a = Array(e);
+									for (let t = 0; t < e; ++t) a[t] = "";
+									a[0] = r, a.push(n), a.xValues = [], i !== void 0 && (a.xValues[i] = r), t.dataRows.push(a);
+								}
+							});
+						}
+					});
+				});
+				let l = 0;
+				t.dataRows.forEach((e) => {
+					l = Math.max(l, e.length);
+				});
+				let u = l - t.dataRows[0].length;
+				for (let e = 0; e < u; e++) {
+					let n = function(e) {
+						let t;
+						return r && !1 !== (t = r(e)) ? t : (t = a + " " + e, i ? {
+							columnTitle: t,
+							topLevelColumnTitle: t
+						} : t);
+					}(e + 1);
+					i ? (t.dataRows[0].push(n.topLevelColumnTitle), t.dataRows[1].push(n.columnTitle)) : t.dataRows[0].push(n);
+				}
+			});
+		}
+		function le() {
+			this.plotBoxClip.attr(this.plotBox), this.annotations.forEach((e) => {
+				e.redraw(), e.graphic.animate({ opacity: 1 }, e.animationConfig);
+			});
+		}
+		function ue(e) {
+			let t = this.annotations, n = e.coll === "annotations" ? e : te(t, function(t) {
+				return t.options.id === e;
+			});
+			n && (ne(n, "remove"), ee(this.options.annotations, n.options), ee(t, n), n.destroy());
+		}
+		function de() {
+			let e = this.options.annotations, t = this.userOptions.annotations;
+			this.annotations = [], re(this.options.annotations) || (this.options.annotations = []), ie(t, !0) && ie(e, !0) && this.options.annotations.push(e);
+		}
+		function fe(e) {
+			this.chart.hasDraggedAnnotation || e.apply(this, Array.prototype.slice.call(arguments, 1));
+		}
+		(a ||= {}).compose = function(e, t, n) {
+			let r = t.prototype;
+			if (!r.addAnnotation) {
+				let i = n.prototype;
+				h(t, "afterInit", de), r.addAnnotation = se, r.callbacks.push(ce), r.collectionsWithInit.annotations = [se], r.collectionsWithUpdate.push("annotations"), r.drawAnnotations = le, r.removeAnnotation = ue, r.initAnnotation = function(t) {
+					let n = new (e.types[t.type] || e)(this, t);
+					return this.annotations.push(n), n;
+				}, oe(i, "onContainerMouseDown", fe);
+			}
+		};
+		let pe = a, { defined: me } = m(), he = {
+			visible: !0,
+			animation: {},
+			crop: !0,
+			draggable: "xy",
+			labelOptions: {
+				align: "center",
+				allowOverlap: !1,
+				backgroundColor: "rgba(0, 0, 0, 0.75)",
+				borderColor: "#000000",
+				borderRadius: 3,
+				borderWidth: 1,
+				className: "highcharts-no-tooltip",
+				crop: !1,
+				formatter: function() {
+					return me(this.y) ? "" + this.y : "Annotation label";
+				},
+				includeInDataExport: !0,
+				overflow: "justify",
+				padding: 5,
+				shadow: !1,
+				shape: "callout",
+				style: {
+					fontSize: "0.7em",
+					fontWeight: "normal",
+					color: "contrast"
+				},
+				useHTML: !1,
+				verticalAlign: "bottom",
+				x: 0,
+				y: -16
+			},
+			shapeOptions: {
+				stroke: "rgba(0, 0, 0, 0.75)",
+				strokeWidth: 1,
+				fill: "rgba(0, 0, 0, 0.75)",
+				r: 0,
+				snap: 2
+			},
+			controlPointOptions: {
+				events: {},
+				style: {
+					cursor: "pointer",
+					fill: "#ffffff",
+					stroke: "#000000",
+					"stroke-width": 2
+				},
+				height: 10,
+				symbol: "circle",
+				visible: !1,
+				width: 10
+			},
+			events: {},
+			typeOptions: {},
+			types: {},
+			zIndex: 6
+		}, { doc: ge, isTouchDevice: g } = m(), { addEvent: _, fireEvent: v, objectEach: _e, pick: ve, removeEvent: ye } = m(), be = class {
+			addEvents() {
+				let e = this, t = function(t) {
+					_(t, g ? "touchstart" : "mousedown", (t) => {
+						e.onMouseDown(t);
+					}, { passive: !1 });
+				};
+				if (t(this.graphic.element), (e.labels || []).forEach((e) => {
+					e.options.useHTML && e.graphic.text && !e.graphic.text.foreignObject && t(e.graphic.text.element);
+				}), _e(e.options.events, (t, n) => {
+					let r = function(r) {
+						n === "click" && e.cancelClick || t.call(e, e.chart.pointer?.normalize(r), e.target);
+					};
+					(e.nonDOMEvents || []).indexOf(n) === -1 ? (_(e.graphic.element, n, r, { passive: !1 }), e.graphic.div && _(e.graphic.div, n, r, { passive: !1 })) : _(e, n, r, { passive: !1 });
+				}), e.options.draggable && (_(e, "drag", e.onDrag), !e.graphic.renderer.styledMode)) {
+					let t = { cursor: {
+						x: "ew-resize",
+						y: "ns-resize",
+						xy: "move"
+					}[e.options.draggable] };
+					e.graphic.css(t), (e.labels || []).forEach((e) => {
+						e.options.useHTML && e.graphic.text && !e.graphic.text.foreignObject && e.graphic.text.css(t);
+					});
+				}
+				e.isUpdating || v(e, "add");
+			}
+			destroy() {
+				this.removeDocEvents(), ye(this), this.hcEvents = null;
+			}
+			mouseMoveToRadians(e, t, n) {
+				let r = e.prevChartY - n, i = e.prevChartX - t, a = e.chartY - n, o = e.chartX - t, s;
+				return this.chart.inverted && (s = i, i = r, r = s, s = o, o = a, a = s), Math.atan2(a, o) - Math.atan2(r, i);
+			}
+			mouseMoveToScale(e, t, n) {
+				let r = e.prevChartX - t, i = e.prevChartY - n, a = e.chartX - t, o = e.chartY - n, s = (a || 1) / (r || 1), c = (o || 1) / (i || 1);
+				if (this.chart.inverted) {
+					let e = c;
+					c = s, s = e;
+				}
+				return {
+					x: s,
+					y: c
+				};
+			}
+			mouseMoveToTranslation(e) {
+				let t = e.chartX - e.prevChartX, n = e.chartY - e.prevChartY, r;
+				return this.chart.inverted && (r = n, n = t, t = r), {
+					x: t,
+					y: n
+				};
+			}
+			onDrag(e) {
+				if (this.chart.isInsidePlot(e.chartX - this.chart.plotLeft, e.chartY - this.chart.plotTop, { visiblePlotOnly: !0 })) {
+					let t = this.mouseMoveToTranslation(e);
+					this.options.draggable === "x" && (t.y = 0), this.options.draggable === "y" && (t.x = 0), this.points.length ? this.translate(t.x, t.y) : (this.shapes.forEach((e) => e.translate(t.x, t.y)), this.labels.forEach((e) => e.translate(t.x, t.y))), this.redraw(!1);
+				}
+			}
+			onMouseDown(e) {
+				if (e.preventDefault && e.preventDefault(), e.button === 2) return;
+				let t = this, n = t.chart.pointer, r = e?.sourceCapabilities?.firesTouchEvents || !1, i = (e = n?.normalize(e) || e).chartX, a = e.chartY;
+				t.cancelClick = !1, t.chart.hasDraggedAnnotation = !0, t.removeDrag = _(ge, g || r ? "touchmove" : "mousemove", function(e) {
+					t.hasDragged = !0, (e = n?.normalize(e) || e).prevChartX = i, e.prevChartY = a, v(t, "drag", e), i = e.chartX, a = e.chartY;
+				}, g || r ? { passive: !1 } : void 0), t.removeMouseUp = _(ge, g || r ? "touchend" : "mouseup", function() {
+					let e = ve(t.target && t.target.annotation, t.target);
+					e && (e.cancelClick = t.hasDragged), t.cancelClick = t.hasDragged, t.chart.hasDraggedAnnotation = !1, t.hasDragged && v(ve(e, t), "afterUpdate"), t.hasDragged = !1, t.onMouseUp();
+				}, g || r ? { passive: !1 } : void 0);
+			}
+			onMouseUp() {
+				this.removeDocEvents();
+			}
+			removeDocEvents() {
+				this.removeDrag &&= this.removeDrag(), this.removeMouseUp &&= this.removeMouseUp();
+			}
+		}, { merge: xe, pick: Se } = m(), Ce = class extends be {
+			constructor(e, t, n, r) {
+				super(), this.nonDOMEvents = ["drag"], this.chart = e, this.target = t, this.options = n, this.index = Se(n.index, r);
+			}
+			destroy() {
+				super.destroy(), this.graphic &&= this.graphic.destroy(), this.chart = null, this.target = null, this.options = null;
+			}
+			redraw(e) {
+				this.graphic[e ? "animate" : "attr"](this.options.positioner.call(this, this.target));
+			}
+			render() {
+				let e = this.chart, t = this.options;
+				this.graphic = e.renderer.symbol(t.symbol, 0, 0, t.width, t.height).add(e.controlPointsGroup).css(t.style), this.setVisibility(t.visible), this.addEvents();
+			}
+			setVisibility(e) {
+				this.graphic[e ? "show" : "hide"](), this.options.visible = e;
+			}
+			update(e) {
+				let t = this.chart, n = this.target, r = this.index, i = xe(!0, this.options, e);
+				this.destroy(), this.constructor(t, n, i, r), this.render(t.controlPointsGroup), this.redraw();
+			}
+		};
+		var we = d(512), Te = d.n(we);
+		let { series: { prototype: Ee } } = Te(), { defined: y, fireEvent: De } = m();
+		class b {
+			static fromPoint(e) {
+				return new b(e.series.chart, null, {
+					x: e.x,
+					y: e.y,
+					xAxis: e.series.xAxis,
+					yAxis: e.series.yAxis
+				});
+			}
+			static pointToPixels(e, t) {
+				let n = e.series, r = n.chart, i = e.plotX || 0, a = e.plotY || 0, o;
+				return r.inverted && (e.mock ? (i = e.plotY, a = e.plotX) : (i = r.plotWidth - (e.plotY || 0), a = r.plotHeight - (e.plotX || 0))), n && !t && (i += (o = n.getPlotBox()).translateX, a += o.translateY), {
+					x: i,
+					y: a
+				};
+			}
+			static pointToOptions(e) {
+				return {
+					x: e.x,
+					y: e.y,
+					xAxis: e.series.xAxis,
+					yAxis: e.series.yAxis
+				};
+			}
+			constructor(e, t, n) {
+				this.mock = !0, this.point = this, this.series = {
+					visible: !0,
+					chart: e,
+					getPlotBox: Ee.getPlotBox
+				}, this.target = t || null, this.options = n, this.applyOptions(this.getOptions());
+			}
+			applyOptions(e) {
+				this.command = e.command, this.setAxis(e, "x"), this.setAxis(e, "y"), this.refresh();
+			}
+			getOptions() {
+				return this.hasDynamicOptions() && typeof this.options == "function" ? this.options(this.target) : this.options;
+			}
+			hasDynamicOptions() {
+				return typeof this.options == "function";
+			}
+			isInsidePlot() {
+				let e = this.plotX, t = this.plotY, n = this.series.xAxis, r = this.series.yAxis, i = {
+					x: e,
+					y: t,
+					isInsidePlot: !0,
+					options: {}
+				};
+				return n && (i.isInsidePlot = y(e) && e >= 0 && e <= n.len), r && (i.isInsidePlot = i.isInsidePlot && y(t) && t >= 0 && t <= r.len), De(this.series.chart, "afterIsInsidePlot", i), i.isInsidePlot;
+			}
+			refresh() {
+				let e = this.series, t = e.xAxis, n = e.yAxis, r = this.getOptions();
+				t ? (this.x = r.x, this.plotX = t.toPixels(r.x, !0)) : (this.x = void 0, this.plotX = r.x), n ? (this.y = r.y, this.plotY = n.toPixels(r.y, !0)) : (this.y = null, this.plotY = r.y), this.isInside = this.isInsidePlot();
+			}
+			refreshOptions() {
+				let e = this.series, t = e.xAxis, n = e.yAxis;
+				this.x = this.options.x = t ? this.options.x = t.toValue(this.plotX, !0) : this.plotX, this.y = this.options.y = n ? n.toValue(this.plotY, !0) : this.plotY;
+			}
+			rotate(e, t, n) {
+				if (!this.hasDynamicOptions()) {
+					let r = Math.cos(n), i = Math.sin(n), a = this.plotX - e, o = this.plotY - t;
+					this.plotX = a * r - o * i + e, this.plotY = a * i + o * r + t, this.refreshOptions();
+				}
+			}
+			scale(e, t, n, r) {
+				if (!this.hasDynamicOptions()) {
+					let i = this.plotX * n, a = this.plotY * r;
+					this.plotX = (1 - n) * e + i, this.plotY = (1 - r) * t + a, this.refreshOptions();
+				}
+			}
+			setAxis(e, t) {
+				let n = t + "Axis", r = e[n], i = this.series.chart;
+				this.series[n] = typeof r == "object" ? r : y(r) ? i[n][r] || i.get(r) : null;
+			}
+			toAnchor() {
+				let e = [
+					this.plotX,
+					this.plotY,
+					0,
+					0
+				];
+				return this.series.chart.inverted && (e[0] = this.plotY, e[1] = this.plotX), e;
+			}
+			translate(e, t, n, r) {
+				this.hasDynamicOptions() || (this.plotX += n, this.plotY += r, this.refreshOptions());
+			}
+		}
+		(function(e) {
+			function t() {
+				let e = this.controlPoints, t = this.options.controlPoints || [];
+				t.forEach((n, r) => {
+					let i = m().merge(this.options.controlPointOptions, n);
+					i.index ||= r, t[r] = i, e.push(new Ce(this.chart, this, i));
+				});
+			}
+			function n(e) {
+				let t = e.series.getPlotBox(), n = e.series.chart, r = e.mock ? e.toAnchor() : n.tooltip && n.tooltip.getAnchor.call({ chart: e.series.chart }, e) || [
+					0,
+					0,
+					0,
+					0
+				], i = {
+					x: r[0] + (this.options.x || 0),
+					y: r[1] + (this.options.y || 0),
+					height: r[2] || 0,
+					width: r[3] || 0
+				};
+				return {
+					relativePosition: i,
+					absolutePosition: m().merge(i, {
+						x: i.x + (e.mock ? t.translateX : n.plotLeft),
+						y: i.y + (e.mock ? t.translateY : n.plotTop)
+					})
+				};
+			}
+			function r() {
+				this.controlPoints.forEach((e) => e.destroy()), this.chart = null, this.controlPoints = null, this.points = null, this.options = null, this.annotation &&= null;
+			}
+			function i() {
+				let e = this.options;
+				return e.points || e.point && m().splat(e.point);
+			}
+			function a() {
+				let e, t, n = this.getPointsOptions(), r = this.points, i = n?.length || 0;
+				for (e = 0; e < i; e++) {
+					if (!(t = this.point(n[e], r[e]))) {
+						r.length = 0;
+						return;
+					}
+					t.mock && t.refresh(), r[e] = t;
+				}
+				return r;
+			}
+			function o(e, t) {
+				if (e && e.series) return e;
+				if (!t || t.series === null) {
+					if (m().isObject(e)) t = new b(this.chart, this, e);
+					else if (m().isString(e)) t = this.chart.get(e) || null;
+					else if (typeof e == "function") {
+						let n = e.call(t, this);
+						t = n.series ? n : new b(this.chart, this, e);
+					}
+				}
+				return t;
+			}
+			function s(e) {
+				this.controlPoints.forEach((t) => t.redraw(e));
+			}
+			function c() {
+				this.controlPoints.forEach((e) => e.render());
+			}
+			function l(e, t, n, r, i) {
+				if (this.chart.inverted) {
+					let e = t;
+					t = n, n = e;
+				}
+				this.points.forEach((a, o) => this.transformPoint(e, t, n, r, i, o), this);
+			}
+			function u(e, t, n, r, i, a) {
+				let o = this.points[a];
+				o.mock || (o = this.points[a] = b.fromPoint(o)), o[e](t, n, r, i);
+			}
+			function d(e, t) {
+				this.transform("translate", null, null, e, t);
+			}
+			function f(e, t, n) {
+				this.transformPoint("translate", null, null, e, t, n);
+			}
+			e.compose = function(e) {
+				let p = e.prototype;
+				p.addControlPoints || m().merge(!0, p, {
+					addControlPoints: t,
+					anchor: n,
+					destroyControlTarget: r,
+					getPointsOptions: i,
+					linkPoints: a,
+					point: o,
+					redrawControlPoints: s,
+					renderControlPoints: c,
+					transform: l,
+					transformPoint: u,
+					translate: d,
+					translatePoint: f
+				});
+			};
+		})(o ||= {});
+		let Oe = o, { merge: ke } = m();
+		class Ae {
+			constructor(e, t, n, r) {
+				this.annotation = e, this.chart = e.chart, this.collection = r === "label" ? "labels" : "shapes", this.controlPoints = [], this.options = t, this.points = [], this.index = n, this.itemType = r, this.init(e, t, n);
+			}
+			attr() {
+				this.graphic.attr.apply(this.graphic, arguments);
+			}
+			attrsFromOptions(e) {
+				let t, n, r = this.constructor.attrsMap, i = {}, a = this.chart.styledMode;
+				for (t in e) n = r[t], r[t] === void 0 || a && [
+					"fill",
+					"stroke",
+					"stroke-width"
+				].indexOf(n) !== -1 || (i[n] = e[t]);
+				return i;
+			}
+			destroy() {
+				this.graphic &&= this.graphic.destroy(), this.tracker &&= this.tracker.destroy(), this.destroyControlTarget();
+			}
+			init(e, t, n) {
+				this.annotation = e, this.chart = e.chart, this.options = t, this.points = [], this.controlPoints = [], this.index = n, this.linkPoints(), this.addControlPoints();
+			}
+			redraw(e) {
+				this.redrawControlPoints(e);
+			}
+			render(e) {
+				this.options.className && this.graphic && this.graphic.addClass(this.options.className), this.renderControlPoints();
+			}
+			rotate(e, t, n) {
+				this.transform("rotate", e, t, n);
+			}
+			scale(e, t, n, r) {
+				this.transform("scale", e, t, n, r);
+			}
+			setControlPointsVisibility(e) {
+				this.controlPoints.forEach((t) => {
+					t.setVisibility(e);
+				});
+			}
+			shouldBeDrawn() {
+				return !!this.points.length;
+			}
+			translateShape(e, t, n) {
+				let r = this.annotation.chart, i = this.annotation.userOptions, a = r.annotations.indexOf(this.annotation), o = r.options.annotations[a];
+				this.translatePoint(e, t, 0), n && this.translatePoint(e, t, 1), o[this.collection][this.index].point = this.options.point, i[this.collection][this.index].point = this.options.point;
+			}
+			update(e) {
+				let t = this.annotation, n = ke(!0, this.options, e), r = this.graphic.parentGroup, i = this.constructor;
+				this.destroy(), ke(!0, this, new i(t, n, this.index, this.itemType)), this.render(r), this.redraw();
+			}
+		}
+		Oe.compose(Ae);
+		let x = Ae, { defaultMarkers: je } = { defaultMarkers: {
+			arrow: {
+				tagName: "marker",
+				attributes: {
+					id: "arrow",
+					refY: 5,
+					refX: 9,
+					markerWidth: 10,
+					markerHeight: 10
+				},
+				children: [{
+					tagName: "path",
+					attributes: {
+						d: "M 0 0 L 10 5 L 0 10 Z",
+						"stroke-width": 0
+					}
+				}]
+			},
+			"reverse-arrow": {
+				tagName: "marker",
+				attributes: {
+					id: "reverse-arrow",
+					refY: 5,
+					refX: 1,
+					markerWidth: 10,
+					markerHeight: 10
+				},
+				children: [{
+					tagName: "path",
+					attributes: {
+						d: "M 0 5 L 10 0 L 10 10 Z",
+						"stroke-width": 0
+					}
+				}]
+			}
+		} }, { addEvent: Me, defined: Ne, extend: Pe, merge: S, uniqueKey: Fe } = m(), Ie = w("marker-end"), Le = w("marker-start"), C = "rgba(192,192,192," + (m().svg ? 1e-4 : .002) + ")";
+		function w(e) {
+			return function(t) {
+				this.attr(e, "url(#" + t + ")");
+			};
+		}
+		function Re() {
+			this.options.defs = S(je, this.options.defs || {});
+		}
+		function ze(e, t) {
+			let n = { attributes: { id: e } }, r = {
+				stroke: t.color || "none",
+				fill: t.color || "rgba(0, 0, 0, 0.75)"
+			};
+			n.children = t.children && t.children.map(function(e) {
+				return S(r, e);
+			});
+			let i = S(!0, { attributes: {
+				markerWidth: 20,
+				markerHeight: 20,
+				refX: 0,
+				refY: 0,
+				orient: "auto"
+			} }, t, n), a = this.definition(i);
+			return a.id = e, a;
+		}
+		class T extends x {
+			static compose(e, t) {
+				let n = t.prototype;
+				n.addMarker ||= (Me(e, "afterGetContainer", Re), ze);
+			}
+			constructor(e, t, n) {
+				super(e, t, n, "shape"), this.type = "path";
+			}
+			toD() {
+				let e = this.options.d;
+				if (e) return typeof e == "function" ? e.call(this) : e;
+				let t = this.points, n = t.length, r = [], i = n, a = t[0], o = i && this.anchor(a).absolutePosition, s = 0, c;
+				if (o) for (r.push([
+					"M",
+					o.x,
+					o.y
+				]); ++s < n && i;) c = (a = t[s]).command || "L", o = this.anchor(a).absolutePosition, c === "M" || c === "L" ? r.push([
+					c,
+					o.x,
+					o.y
+				]) : c === "Z" && r.push([c]), i = a.series.visible;
+				return i && this.graphic ? this.chart.renderer.crispLine(r, this.graphic.strokeWidth()) : null;
+			}
+			shouldBeDrawn() {
+				return super.shouldBeDrawn() || !!this.options.d;
+			}
+			render(e) {
+				let t = this.options, n = this.attrsFromOptions(t);
+				this.graphic = this.annotation.chart.renderer.path([[
+					"M",
+					0,
+					0
+				]]).attr(n).add(e), this.tracker = this.annotation.chart.renderer.path([[
+					"M",
+					0,
+					0
+				]]).addClass("highcharts-tracker-line").attr({ zIndex: 2 }).add(e), this.annotation.chart.styledMode || this.tracker.attr({
+					"stroke-linejoin": "round",
+					stroke: C,
+					fill: C,
+					"stroke-width": this.graphic.strokeWidth() + 2 * t.snap
+				}), super.render(), Pe(this.graphic, {
+					markerStartSetter: Le,
+					markerEndSetter: Ie
+				}), this.setMarkers(this);
+			}
+			redraw(e) {
+				if (this.graphic) {
+					let t = this.toD(), n = e ? "animate" : "attr";
+					t ? (this.graphic[n]({ d: t }), this.tracker[n]({ d: t })) : (this.graphic.attr({ d: "M 0 -9000000000" }), this.tracker.attr({ d: "M 0 -9000000000" })), this.graphic.placed = this.tracker.placed = !!t;
+				}
+				super.redraw(e);
+			}
+			setMarkers(e) {
+				let t = e.options, n = e.chart, r = n.options.defs, i = t.fill, a = Ne(i) && i !== "none" ? i : t.stroke;
+				["markerStart", "markerEnd"].forEach(function(i) {
+					let o, s, c, l, u = t[i];
+					if (u) {
+						for (c in r) if ((u === ((o = r[c]).attributes && o.attributes.id) || u === o.id) && o.tagName === "marker") {
+							s = o;
+							break;
+						}
+						s && (l = e[i] = n.renderer.addMarker((t.id || Fe()) + "-" + u, S(s, { color: a })), e.attr(i, l.getAttribute("id")));
+					}
+				});
+			}
+		}
+		T.attrsMap = {
+			dashStyle: "dashstyle",
+			strokeWidth: "stroke-width",
+			stroke: "stroke",
+			fill: "fill",
+			zIndex: "zIndex"
+		};
+		let { merge: Be } = m();
+		class Ve extends x {
+			constructor(e, t, n) {
+				super(e, t, n, "shape"), this.type = "rect", this.translate = super.translateShape;
+			}
+			render(e) {
+				let t = this.attrsFromOptions(this.options);
+				this.graphic = this.annotation.chart.renderer.rect(0, -9e9, 0, 0).attr(t).add(e), super.render();
+			}
+			redraw(e) {
+				if (this.graphic) {
+					let t = this.anchor(this.points[0]).absolutePosition;
+					t ? this.graphic[e ? "animate" : "attr"]({
+						x: t.x,
+						y: t.y,
+						width: this.options.width,
+						height: this.options.height
+					}) : this.attr({
+						x: 0,
+						y: -9e9
+					}), this.graphic.placed = !!t;
+				}
+				super.redraw(e);
+			}
+		}
+		Ve.attrsMap = Be(T.attrsMap, {
+			width: "width",
+			height: "height"
+		});
+		let { merge: He } = m();
+		class Ue extends x {
+			constructor(e, t, n) {
+				super(e, t, n, "shape"), this.type = "circle", this.translate = super.translateShape;
+			}
+			redraw(e) {
+				if (this.graphic) {
+					let t = this.anchor(this.points[0]).absolutePosition;
+					t ? this.graphic[e ? "animate" : "attr"]({
+						x: t.x,
+						y: t.y,
+						r: this.options.r
+					}) : this.graphic.attr({
+						x: 0,
+						y: -9e9
+					}), this.graphic.placed = !!t;
+				}
+				super.redraw.call(this, e);
+			}
+			render(e) {
+				let t = this.attrsFromOptions(this.options);
+				this.graphic = this.annotation.chart.renderer.circle(0, -9e9, 0).attr(t).add(e), super.render();
+			}
+			setRadius(e) {
+				this.options.r = e;
+			}
+		}
+		Ue.attrsMap = He(T.attrsMap, { r: "r" });
+		let { merge: We, defined: E } = m();
+		class Ge extends x {
+			constructor(e, t, n) {
+				super(e, t, n, "shape"), this.type = "ellipse";
+			}
+			init(e, t, n) {
+				E(t.yAxis) && t.points.forEach((e) => {
+					e.yAxis = t.yAxis;
+				}), E(t.xAxis) && t.points.forEach((e) => {
+					e.xAxis = t.xAxis;
+				}), super.init(e, t, n);
+			}
+			render(e) {
+				this.graphic = this.annotation.chart.renderer.createElement("ellipse").attr(this.attrsFromOptions(this.options)).add(e), super.render();
+			}
+			translate(e, t) {
+				super.translateShape(e, t, !0);
+			}
+			getDistanceFromLine(e, t, n, r) {
+				return Math.abs((t.y - e.y) * n - (t.x - e.x) * r + t.x * e.y - t.y * e.x) / Math.sqrt((t.y - e.y) * (t.y - e.y) + (t.x - e.x) * (t.x - e.x));
+			}
+			getAttrs(e, t) {
+				let n = e.x, r = e.y, i = t.x, a = t.y, o = (n + i) / 2, s = Math.sqrt((n - i) * (n - i) / 4 + (r - a) * (r - a) / 4), c = 180 * Math.atan((a - r) / (i - n)) / Math.PI;
+				return o < n && (c += 180), {
+					cx: o,
+					cy: (r + a) / 2,
+					rx: s,
+					ry: this.getRY(),
+					angle: c
+				};
+			}
+			getRY() {
+				let e = this.getYAxis();
+				return E(e) ? Math.abs(e.toPixels(this.options.ry) - e.toPixels(0)) : this.options.ry;
+			}
+			getYAxis() {
+				let e = this.options.yAxis;
+				return this.chart.yAxis[e];
+			}
+			getAbsolutePosition(e) {
+				return this.anchor(e).absolutePosition;
+			}
+			redraw(e) {
+				if (this.graphic) {
+					let t = this.getAbsolutePosition(this.points[0]), n = this.getAbsolutePosition(this.points[1]), r = this.getAttrs(t, n);
+					t ? this.graphic[e ? "animate" : "attr"]({
+						cx: r.cx,
+						cy: r.cy,
+						rx: r.rx,
+						ry: r.ry,
+						rotation: r.angle,
+						rotationOriginX: r.cx,
+						rotationOriginY: r.cy
+					}) : this.graphic.attr({
+						x: 0,
+						y: -9e9
+					}), this.graphic.placed = !!t;
+				}
+				super.redraw(e);
+			}
+			setYRadius(e) {
+				let t = this.annotation.userOptions.shapes;
+				this.options.ry = e, t && t[0] && (t[0].ry = e, t[0].ry = e);
+			}
+		}
+		Ge.attrsMap = We(T.attrsMap, { ry: "ry" });
+		var Ke = d(984), qe = d.n(Ke);
+		let { format: Je } = qe(), { extend: Ye, getAlignFactor: Xe, isNumber: Ze, pick: Qe } = m();
+		function $e(e, t, n, r, i) {
+			let a = i && i.anchorX, o = i && i.anchorY, s, c, l = n / 2;
+			return Ze(a) && Ze(o) && (s = [[
+				"M",
+				a,
+				o
+			]], (c = t - o) < 0 && (c = -r - c), c < n && (l = a < e + n / 2 ? c : n - c), o > t + r ? s.push([
+				"L",
+				e + l,
+				t + r
+			]) : o < t ? s.push([
+				"L",
+				e + l,
+				t
+			]) : a < e ? s.push([
+				"L",
+				e,
+				t + r / 2
+			]) : a > e + n && s.push([
+				"L",
+				e + n,
+				t + r / 2
+			])), s || [];
+		}
+		class D extends x {
+			static alignedPosition(e, t) {
+				return {
+					x: Math.round((t.x || 0) + (e.x || 0) + (t.width - (e.width || 0)) * Xe(e.align)),
+					y: Math.round((t.y || 0) + (e.y || 0) + (t.height - (e.height || 0)) * Xe(e.verticalAlign))
+				};
+			}
+			static compose(e) {
+				e.prototype.symbols.connector = $e;
+			}
+			static justifiedOptions(e, t, n, r) {
+				let i, a = n.align, o = n.verticalAlign, s = t.box ? 0 : t.padding || 0, c = t.getBBox(), l = {
+					align: a,
+					verticalAlign: o,
+					x: n.x,
+					y: n.y,
+					width: t.width,
+					height: t.height
+				}, u = (r.x || 0) - e.plotLeft, d = (r.y || 0) - e.plotTop;
+				return (i = u + s) < 0 && (a === "right" ? l.align = "left" : l.x = (l.x || 0) - i), (i = u + c.width - s) > e.plotWidth && (a === "left" ? l.align = "right" : l.x = (l.x || 0) + e.plotWidth - i), (i = d + s) < 0 && (o === "bottom" ? l.verticalAlign = "top" : l.y = (l.y || 0) - i), (i = d + c.height - s) > e.plotHeight && (o === "top" ? l.verticalAlign = "bottom" : l.y = (l.y || 0) + e.plotHeight - i), l;
+			}
+			constructor(e, t, n) {
+				super(e, t, n, "label");
+			}
+			translatePoint(e, t) {
+				super.translatePoint(e, t, 0);
+			}
+			translate(e, t) {
+				var n, r;
+				let i = this.annotation.chart, a = this.annotation.userOptions, o = i.annotations.indexOf(this.annotation), s = i.options.annotations[o];
+				if (i.inverted) {
+					let n = e;
+					e = t, t = n;
+				}
+				(n = this.options).x || (n.x = 0), (r = this.options).y || (r.y = 0), this.options.x += e, this.options.y += t, s[this.collection][this.index].x = this.options.x, s[this.collection][this.index].y = this.options.y, a[this.collection][this.index].x = this.options.x, a[this.collection][this.index].y = this.options.y;
+			}
+			render(e) {
+				let t = this.options, n = this.attrsFromOptions(t), r = t.style, i = this.annotation.chart.options.chart, a = i.plotBackgroundColor || i.backgroundColor;
+				if (this.graphic = this.annotation.chart.renderer.label("", 0, -9999, t.shape, void 0, void 0, t.useHTML, void 0, "annotation-label").attr(n).add(e), !this.annotation.chart.styledMode) {
+					if (r?.color === "contrast") {
+						let e = !t.shape || D.shapesWithoutBackground.indexOf(t.shape) > -1 || t.backgroundColor === "none" ? a : t.backgroundColor;
+						r.color = this.annotation.chart.renderer.getContrast(typeof e == "string" ? e : typeof a == "string" ? a : "#ffffff");
+					}
+					this.graphic.css(t.style || {}).shadow(t.shadow);
+				}
+				this.graphic.labelrank = t.labelrank, super.render();
+			}
+			redraw(e) {
+				let t = this.options, n = this.text || t.format || t.text, r = this.graphic, i = this.points[0];
+				if (!r) return void this.redraw(e);
+				r.attr({ text: n ? Je(String(n), i, this.annotation.chart) : t.formatter.call(i, this) });
+				let a = this.anchor(i), o = this.position(a);
+				o ? (r.alignAttr = o, o.anchorX = a.absolutePosition.x, o.anchorY = a.absolutePosition.y, r[e ? "animate" : "attr"](o)) : r.attr({
+					x: 0,
+					y: -9999
+				}), r.placed = !!o, super.redraw(e);
+			}
+			anchor(e) {
+				let t = super.anchor.apply(this, arguments), n = this.options.x || 0, r = this.options.y || 0;
+				return t.absolutePosition.x -= n, t.absolutePosition.y -= r, t.relativePosition.x -= n, t.relativePosition.y -= r, t;
+			}
+			position(e) {
+				let t = this.graphic, n = this.annotation.chart, r = n.tooltip, i = this.points[0], a = this.options, o = e.absolutePosition, s = e.relativePosition, c, l, u, d, f = i.series.visible && b.prototype.isInsidePlot.call(i);
+				if (t && f) {
+					let { width: e = 0, height: p = 0 } = t;
+					a.distance && r ? c = r.getPosition.call({
+						chart: n,
+						distance: Qe(a.distance, 16),
+						getPlayingField: r.getPlayingField,
+						pointer: r.pointer
+					}, e, p, {
+						plotX: s.x,
+						plotY: s.y,
+						negative: i.negative,
+						ttBelow: i.ttBelow,
+						h: s.height || s.width
+					}) : a.positioner ? c = a.positioner.call(this) : (l = {
+						x: o.x,
+						y: o.y,
+						width: 0,
+						height: 0
+					}, c = D.alignedPosition(Ye(a, {
+						width: e,
+						height: p
+					}), l), this.options.overflow === "justify" && (c = D.alignedPosition(D.justifiedOptions(n, t, a, c), l))), a.crop && (u = c.x - n.plotLeft, d = c.y - n.plotTop, f = n.isInsidePlot(u, d) && n.isInsidePlot(u + e, d + p));
+				}
+				return f ? c : null;
+			}
+		}
+		D.attrsMap = {
+			backgroundColor: "fill",
+			borderColor: "stroke",
+			borderWidth: "stroke-width",
+			zIndex: "zIndex",
+			borderRadius: "r",
+			padding: "padding"
+		}, D.shapesWithoutBackground = ["connector"];
+		class et extends x {
+			constructor(e, t, n) {
+				super(e, t, n, "shape"), this.type = "image", this.translate = super.translateShape;
+			}
+			render(e) {
+				let t = this.attrsFromOptions(this.options), n = this.options;
+				this.graphic = this.annotation.chart.renderer.image(n.src, 0, -9e9, n.width, n.height).attr(t).add(e), this.graphic.width = n.width, this.graphic.height = n.height, super.render();
+			}
+			redraw(e) {
+				if (this.graphic) {
+					let t = this.anchor(this.points[0]), n = D.prototype.position.call(this, t);
+					n ? this.graphic[e ? "animate" : "attr"]({
+						x: n.x,
+						y: n.y
+					}) : this.graphic.attr({
+						x: 0,
+						y: -9e9
+					}), this.graphic.placed = !!n;
+				}
+				super.redraw(e);
+			}
+		}
+		et.attrsMap = {
+			width: "width",
+			height: "height",
+			zIndex: "zIndex"
+		};
+		var tt = d(660), O = d.n(tt);
+		let { addEvent: nt, createElement: k } = m(), rt = class {
+			constructor(e, t) {
+				this.iconsURL = t, this.container = this.createPopupContainer(e), this.closeButton = this.addCloseButton();
+			}
+			createPopupContainer(e, t = "highcharts-popup highcharts-no-tooltip") {
+				return k("div", { className: t }, void 0, e);
+			}
+			addCloseButton(e = "highcharts-popup-close") {
+				let t = this, n = this.iconsURL, r = k("button", { className: e }, void 0, this.container);
+				return k("span", { className: "highcharts-icon" }, { backgroundImage: "url(" + (n.match(/png|svg|jpeg|jpg|gif/gi) ? n : n + "close.svg") + ")" }, r), ["click", "touchstart"].forEach((e) => {
+					nt(r, e, t.closeButtonEvents.bind(t));
+				}), nt(document, "keydown", function(e) {
+					e.code === "Escape" && t.closeButtonEvents();
+				}), r;
+			}
+			closeButtonEvents() {
+				this.closePopup();
+			}
+			showPopup(e = "highcharts-annotation-toolbar") {
+				let t = this.container, n = this.closeButton;
+				this.type = void 0, t.innerHTML = O().emptyHTML, t.className.indexOf(e) >= 0 && (t.classList.remove(e), t.removeAttribute("style")), t.appendChild(n), t.style.display = "block", t.style.height = "";
+			}
+			closePopup() {
+				this.container.style.display = "none";
+			}
+		}, { doc: A, isFirefox: it } = m(), { createElement: j, isArray: at, isObject: ot, objectEach: st, pick: ct, stableSort: lt } = m();
+		function ut(e, t, n, r, i, a) {
+			let o, s;
+			if (!t) return;
+			let c = this.addInput, l = this.lang;
+			st(r, (r, a) => {
+				o = n === "" ? a : n + "." + a, ot(r) && (!at(r) || at(r) && ot(r[0]) ? ((s = l[a] || a).match(/\d/g) || i.push([
+					!0,
+					s,
+					e
+				]), ut.call(this, e, t, o, r, i, !1)) : i.push([
+					this,
+					o,
+					"annotation",
+					e,
+					r
+				]));
+			}), a && (lt(i, (e) => e[1].match(/format/g) ? -1 : 1), it && i.reverse(), i.forEach((e) => {
+				!0 === e[0] ? j("span", { className: "highcharts-annotation-title" }, void 0, e[2]).appendChild(A.createTextNode(e[1])) : (e[4] = {
+					value: e[4][0],
+					type: e[4][1]
+				}, c.apply(e[0], e.splice(1)));
+			}));
+		}
+		let { doc: M } = m(), { seriesTypes: dt } = Te(), { addEvent: N, createElement: P, defined: F, isArray: I, isObject: ft, objectEach: pt, stableSort: mt } = m();
+		(i = s ||= {})[i["params.algorithm"] = 0] = "params.algorithm", i[i["params.average"] = 1] = "params.average";
+		let ht = {
+			"algorithm-pivotpoints": [
+				"standard",
+				"fibonacci",
+				"camarilla"
+			],
+			"average-disparityindex": [
+				"sma",
+				"ema",
+				"dema",
+				"tema",
+				"wma"
+			]
+		};
+		function gt(e) {
+			let t = P("div", { className: "highcharts-popup-lhs-col" }, void 0, e), n = P("div", { className: "highcharts-popup-rhs-col" }, void 0, e);
+			return P("div", { className: "highcharts-popup-rhs-col-wrapper" }, void 0, n), {
+				lhsCol: t,
+				rhsCol: n
+			};
+		}
+		function _t(e, t, n, r) {
+			let i = t.params || t.options.params;
+			r.innerHTML = O().emptyHTML, P("h3", { className: "highcharts-indicator-title" }, void 0, r).appendChild(M.createTextNode(wt(t, n).indicatorFullName)), P("input", {
+				type: "hidden",
+				name: "highcharts-type-" + n,
+				value: n
+			}, void 0, r), Tt.call(this, n, "series", e, r, t, t.linkedParent && t.linkedParent.options.id), i.volumeSeriesID && Tt.call(this, n, "volume", e, r, t, t.linkedParent && i.volumeSeriesID), vt.call(this, e, "params", i, n, r);
+		}
+		function L(e, t, n, r) {
+			function i(t, n) {
+				let r = m.parentNode.children[1];
+				_t.call(a, e, t, n, m), r && (r.style.display = "block"), l && t.options && P("input", {
+					type: "hidden",
+					name: "highcharts-id-" + n,
+					value: t.options.id
+				}, void 0, m).setAttribute("highcharts-data-series-id", t.options.id);
+			}
+			let a = this, o = a.lang, s = t.querySelectorAll(".highcharts-popup-lhs-col")[0], c = t.querySelectorAll(".highcharts-popup-rhs-col")[0], l = n === "edit", u = l ? e.series : e.options.plotOptions || {};
+			if (!e && u) return;
+			let d, f = [];
+			l || I(u) ? I(u) && (f = Ct.call(this, u)) : f = St.call(this, u, r), mt(f, (e, t) => {
+				let n = e.indicatorFullName.toLowerCase(), r = t.indicatorFullName.toLowerCase();
+				return n < r ? -1 : +(n > r);
+			}), s.children[1] && s.children[1].remove();
+			let p = P("ul", { className: "highcharts-indicator-list" }, void 0, s), m = c.querySelectorAll(".highcharts-popup-rhs-col-wrapper")[0];
+			if (f.forEach((e) => {
+				let { indicatorFullName: t, indicatorType: n, series: r } = e;
+				d = P("li", { className: "highcharts-indicator-list" }, void 0, p);
+				let a = P("button", {
+					className: "highcharts-indicator-list-item",
+					textContent: t
+				}, void 0, d);
+				["click", "touchstart"].forEach((e) => {
+					N(a, e, function() {
+						i(r, n);
+					});
+				});
+			}), f.length > 0) {
+				let { series: e, indicatorType: t } = f[0];
+				i(e, t);
+			} else l || (O().setElementHTML(m.parentNode.children[0], o.noFilterMatch || ""), m.parentNode.children[1].style.display = "none");
+		}
+		function vt(e, t, n, r, i) {
+			if (!e) return;
+			let a = this.addInput;
+			pt(n, (n, o) => {
+				let c = t + "." + o;
+				if (F(n) && c) if (ft(n) && (a.call(this, c, r, i, {}), vt.call(this, e, c, n, r, i)), c in s) {
+					let a = bt.call(this, r, c, i);
+					xt.call(this, e, t, a, r, o, n);
+				} else c === "params.volumeSeriesID" || I(n) || a.call(this, c, r, i, {
+					value: n,
+					type: "number"
+				});
+			});
+		}
+		function yt(e, t) {
+			let n = this, r = t.querySelectorAll(".highcharts-popup-lhs-col")[0], i = this.lang.clearFilter, a = P("div", { className: "highcharts-input-wrapper" }, void 0, r), o = function(t) {
+				L.call(n, e, n.container, "add", t);
+			}, s = this.addInput("searchIndicators", "input", a, {
+				value: "",
+				type: "text",
+				htmlFor: "search-indicators",
+				labelClassName: "highcharts-input-search-indicators-label"
+			}), c = P("a", { textContent: i }, void 0, a);
+			s.classList.add("highcharts-input-search-indicators"), c.classList.add("clear-filter-button"), N(s, "input", function() {
+				o(this.value), this.value.length ? c.style.display = "inline-block" : c.style.display = "none";
+			}), ["click", "touchstart"].forEach((e) => {
+				N(c, e, function() {
+					s.value = "", o(""), c.style.display = "none";
+				});
+			});
+		}
+		function bt(e, t, n) {
+			let r = t.split("."), i = r[r.length - 1], a = "highcharts-" + t + "-type-" + e, o = this.lang;
+			P("label", { htmlFor: a }, null, n).appendChild(M.createTextNode(o[i] || t));
+			let s = P("select", {
+				name: a,
+				className: "highcharts-popup-field",
+				id: "highcharts-select-" + t
+			}, null, n);
+			return s.setAttribute("id", "highcharts-select-" + t), s;
+		}
+		function xt(e, t, n, r, i, a, o) {
+			t === "series" || t === "volume" ? e.series.forEach((e) => {
+				let r = e.options, i = r.name || r.params ? e.name : r.id || "";
+				r.id !== "highcharts-navigator-series" && r.id !== (o && o.options && o.options.id) && (F(a) || t !== "volume" || e.type !== "column" || (a = r.id), P("option", { value: r.id }, void 0, n).appendChild(M.createTextNode(i)));
+			}) : r && i && ht[i + "-" + r].forEach((e) => {
+				P("option", { value: e }, void 0, n).appendChild(M.createTextNode(e));
+			}), F(a) && (n.value = a);
+		}
+		function St(e, t) {
+			let n, r = this.chart && this.chart.options.lang, i = r && r.navigation && r.navigation.popup && r.navigation.popup.indicatorAliases, a = [];
+			return pt(e, (e, r) => {
+				let o = e && e.options;
+				if (e.params || o && o.params) {
+					let { indicatorFullName: o, indicatorType: s } = wt(e, r);
+					if (t) {
+						let r = RegExp(t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i"), c = i && i[s] && i[s].join(" ") || "";
+						(o.match(r) || c.match(r)) && (n = {
+							indicatorFullName: o,
+							indicatorType: s,
+							series: e
+						}, a.push(n));
+					} else n = {
+						indicatorFullName: o,
+						indicatorType: s,
+						series: e
+					}, a.push(n);
+				}
+			}), a;
+		}
+		function Ct(e) {
+			let t = [];
+			return e.forEach((e) => {
+				e.is("sma") && t.push({
+					indicatorFullName: e.name,
+					indicatorType: e.type,
+					series: e
+				});
+			}), t;
+		}
+		function wt(e, t) {
+			let n = e.options, r = dt[t] && dt[t].prototype.nameBase || t.toUpperCase(), i = t;
+			return n && n.type && (i = e.options.type, r = e.name), {
+				indicatorFullName: r,
+				indicatorType: i
+			};
+		}
+		function Tt(e, t, n, r, i, a) {
+			if (!n) return;
+			let o = bt.call(this, e, t, r);
+			xt.call(this, n, t, o, void 0, void 0, void 0, i), F(a) && (o.value = a);
+		}
+		let { doc: Et } = m(), { addEvent: Dt, createElement: Ot } = m();
+		function kt() {
+			return Ot("div", { className: "highcharts-tab-item-content highcharts-no-mousewheel" }, void 0, this.container);
+		}
+		function At(e, t) {
+			let n = this.container, r = this.lang, i = "highcharts-tab-item";
+			t === 0 && (i += " highcharts-tab-disabled");
+			let a = Ot("button", { className: i }, void 0, n);
+			return a.appendChild(Et.createTextNode(r[e + "Button"] || e)), a.setAttribute("highcharts-data-tab-type", e), a;
+		}
+		function jt() {
+			let e = this.container, t = e.querySelectorAll(".highcharts-tab-item"), n = e.querySelectorAll(".highcharts-tab-item-content");
+			for (let e = 0; e < t.length; e++) t[e].classList.remove("highcharts-tab-item-active"), n[e].classList.remove("highcharts-tab-item-show");
+		}
+		function Mt(e, t) {
+			let n = this.container.querySelectorAll(".highcharts-tab-item-content");
+			e.className += " highcharts-tab-item-active", n[t].className += " highcharts-tab-item-show";
+		}
+		function Nt(e) {
+			let t = this;
+			this.container.querySelectorAll(".highcharts-tab-item").forEach((n, r) => {
+				(e !== 0 || n.getAttribute("highcharts-data-tab-type") !== "edit") && ["click", "touchstart"].forEach((e) => {
+					Dt(n, e, function() {
+						jt.call(t), Mt.call(t, this, r);
+					});
+				});
+			});
+		}
+		let { doc: R } = m(), { getOptions: Pt } = m(), { addEvent: z, createElement: B, extend: Ft, fireEvent: It, pick: Lt } = m();
+		class Rt extends rt {
+			constructor(e, t, n) {
+				super(e, t), this.chart = n, this.lang = (Pt().lang.navigation || {}).popup || {}, z(this.container, "mousedown", () => {
+					let e = n && n.navigationBindings && n.navigationBindings.activeAnnotation;
+					if (e) {
+						e.cancelClick = !0;
+						let t = z(R, "click", () => {
+							setTimeout(() => {
+								e.cancelClick = !1;
+							}, 0), t();
+						});
+					}
+				});
+			}
+			addInput(e, t, n, r) {
+				let i = e.split("."), a = i[i.length - 1], o = this.lang, s = "highcharts-" + t + "-" + Lt(r.htmlFor, a);
+				a.match(/^\d+$/) || B("label", {
+					htmlFor: s,
+					className: r.labelClassName
+				}, void 0, n).appendChild(R.createTextNode(o[a] || a));
+				let c = B("input", {
+					name: s,
+					value: r.value,
+					type: r.type,
+					className: "highcharts-popup-field"
+				}, void 0, n);
+				return c.setAttribute("highcharts-data-name", e), c;
+			}
+			closeButtonEvents() {
+				if (this.chart) {
+					let e = this.chart.navigationBindings;
+					It(e, "closePopup"), e && e.selectedButtonElement && It(e, "deselectButton", { button: e.selectedButtonElement });
+				} else super.closeButtonEvents();
+			}
+			addButton(e, t, n, r, i) {
+				let a = B("button", void 0, void 0, e);
+				return a.appendChild(R.createTextNode(t)), i && ["click", "touchstart"].forEach((e) => {
+					z(a, e, () => {
+						let e, t, a, o, s;
+						return this.closePopup(), i((e = Array.prototype.slice.call(r.querySelectorAll("input")), t = Array.prototype.slice.call(r.querySelectorAll("select")), a = r.querySelectorAll("#highcharts-select-series > option:checked")[0], o = r.querySelectorAll("#highcharts-select-volume > option:checked")[0], s = {
+							actionType: n,
+							linkedTo: a && a.getAttribute("value") || "",
+							fields: {}
+						}, e.forEach((e) => {
+							let t = e.getAttribute("highcharts-data-name");
+							e.getAttribute("highcharts-data-series-id") ? s.seriesId = e.value : t ? s.fields[t] = e.value : s.type = e.value;
+						}), t.forEach((e) => {
+							let t = e.id;
+							if (t !== "highcharts-select-series" && t !== "highcharts-select-volume") {
+								let n = t.split("highcharts-select-")[1];
+								s.fields[n] = e.value;
+							}
+						}), o && (s.fields["params.volumeSeriesID"] = o.getAttribute("value") || ""), s));
+					});
+				}), a;
+			}
+			showForm(e, t, n, r) {
+				t && (this.showPopup(), e === "indicators" && this.indicators.addForm.call(this, t, n, r), e === "annotation-toolbar" && this.annotations.addToolbar.call(this, t, n, r), e === "annotation-edit" && this.annotations.addForm.call(this, t, n, r), e === "flag" && this.annotations.addForm.call(this, t, n, r, !0), this.type = e, this.container.style.height = this.container.offsetHeight + "px");
+			}
+		}
+		Ft(Rt.prototype, {
+			annotations: {
+				addForm: function(e, t, n, r) {
+					if (!e) return;
+					let i = this.container, a = this.lang, o = j("h2", { className: "highcharts-popup-main-title" }, void 0, i);
+					o.appendChild(A.createTextNode(a[t.langKey] || t.langKey || "")), o = j("div", { className: "highcharts-popup-lhs-col highcharts-popup-lhs-full" }, void 0, i);
+					let s = j("div", { className: "highcharts-popup-bottom-row" }, void 0, i);
+					ut.call(this, o, e, "", t, [], !0), this.addButton(s, r ? a.addButton || "Add" : a.saveButton || "Save", r ? "add" : "save", i, n);
+				},
+				addToolbar: function(e, t, n) {
+					let r = this.lang, i = this.container, a = this.showForm, o = "highcharts-annotation-toolbar";
+					i.className.indexOf(o) === -1 && (i.className += " " + o + " highcharts-no-mousewheel"), e && (i.style.top = e.plotTop + 10 + "px");
+					let s = j("p", { className: "highcharts-annotation-label" }, void 0, i);
+					s.setAttribute("aria-label", "Annotation type"), s.appendChild(A.createTextNode(ct(r[t.langKey] || t.langKey, t.shapes && t.shapes[0].type, "")));
+					let c = this.addButton(i, r.editButton || "Edit", "edit", i, () => {
+						a.call(this, "annotation-edit", e, t, n);
+					});
+					c.className += " highcharts-annotation-edit-button", j("span", { className: "highcharts-icon" }, { backgroundImage: `url(${this.iconsURL}edit.svg)` }, c), c = this.addButton(i, r.removeButton || "Remove", "remove", i, n), c.className += " highcharts-annotation-remove-button", j("span", { className: "highcharts-icon" }, { backgroundImage: `url(${this.iconsURL}destroy.svg)` }, c);
+				}
+			},
+			indicators: {
+				addForm: function(e, t, n) {
+					let r, i = this.lang;
+					if (!e) return;
+					this.tabs.init.call(this, e);
+					let a = this.container.querySelectorAll(".highcharts-tab-item-content");
+					gt(a[0]), yt.call(this, e, a[0]), L.call(this, e, a[0], "add"), r = a[0].querySelectorAll(".highcharts-popup-rhs-col")[0], this.addButton(r, i.addButton || "add", "add", r, n), gt(a[1]), L.call(this, e, a[1], "edit"), r = a[1].querySelectorAll(".highcharts-popup-rhs-col")[0], this.addButton(r, i.saveButton || "save", "edit", r, n), this.addButton(r, i.removeButton || "remove", "remove", r, n);
+				},
+				getAmount: function() {
+					let e = 0;
+					return this.series.forEach((t) => {
+						(t.params || t.options.params) && e++;
+					}), e;
+				}
+			},
+			tabs: { init: function(e) {
+				if (!e) return;
+				let t = this.indicators.getAmount.call(e), n = At.call(this, "add");
+				At.call(this, "edit", t), kt.call(this), kt.call(this), Nt.call(this, t), Mt.call(this, n, 0);
+			} }
+		});
+		let { composed: zt } = m(), { addEvent: Bt, pushUnique: Vt, wrap: Ht } = m();
+		function Ut() {
+			this.popup && this.popup.closePopup();
+		}
+		function Wt(e) {
+			this.popup ||= new Rt(this.chart.container, this.chart.options.navigation.iconsURL || this.chart.options.stockTools && this.chart.options.stockTools.gui.iconsURL || "https://code.highcharts.com/12.5.0/gfx/stock-icons/", this.chart), this.popup.showForm(e.formType, this.chart, e.options, e.onSubmit);
+		}
+		function Gt(e, t) {
+			this.inClass(t.target, "highcharts-popup") || e.apply(this, Array.prototype.slice.call(arguments, 1));
+		}
+		let Kt = function(e, t) {
+			Vt(zt, "Popup") && (Bt(e, "closePopup", Ut), Bt(e, "showPopup", Wt), Ht(t.prototype, "onContainerMouseDown", Gt));
+		}, { getDeferredAnimation: qt } = m(), { defaultOptions: Jt } = m(), { destroyObjectProperties: Yt, erase: Xt, fireEvent: Zt, merge: V, pick: H, splat: Qt } = m();
+		function U(e, t) {
+			let n = {};
+			return ["labels", "shapes"].forEach((r) => {
+				let i = e[r], a = t[r];
+				i && (a ? n[r] = Qt(a).map((e, t) => V(i[t], e)) : n[r] = e[r]);
+			}), n;
+		}
+		class W extends be {
+			static compose(e, t, n, r) {
+				pe.compose(W, e, n), D.compose(r), T.compose(e, r), t.compose(W, e), Kt(t, n);
+			}
+			constructor(e, t) {
+				super(), this.coll = "annotations", this.chart = e, this.points = [], this.controlPoints = [], this.coll = "annotations", this.index = -1, this.labels = [], this.shapes = [], this.setOptions(t), this.userOptions = t;
+				let n = U(this.options, t);
+				this.options.labels = n.labels, this.options.shapes = n.shapes, this.init(e, this.options);
+			}
+			addClipPaths() {
+				this.setClipAxes(), this.clipXAxis && this.clipYAxis && this.options.crop && (this.clipRect = this.chart.renderer.clipRect(this.getClipBox()));
+			}
+			addLabels() {
+				let e = this.options.labels || [];
+				e.forEach((t, n) => {
+					let r = this.initLabel(t, n);
+					V(!0, e[n], r.options);
+				});
+			}
+			addShapes() {
+				let e = this.options.shapes || [];
+				e.forEach((t, n) => {
+					let r = this.initShape(t, n);
+					V(!0, e[n], r.options);
+				});
+			}
+			destroy() {
+				let e = this.chart, t = function(e) {
+					e.destroy();
+				};
+				this.labels.forEach(t), this.shapes.forEach(t), this.clipXAxis = null, this.clipYAxis = null, Xt(e.labelCollectors, this.labelCollector), super.destroy(), this.destroyControlTarget(), Yt(this, e);
+			}
+			destroyItem(e) {
+				Xt(this[e.itemType + "s"], e), e.destroy();
+			}
+			getClipBox() {
+				if (this.clipXAxis && this.clipYAxis) return {
+					x: this.clipXAxis.left,
+					y: this.clipYAxis.top,
+					width: this.clipXAxis.width,
+					height: this.clipYAxis.height
+				};
+			}
+			initProperties(e, t) {
+				this.setOptions(t);
+				let n = U(this.options, t);
+				this.options.labels = n.labels, this.options.shapes = n.shapes, this.chart = e, this.points = [], this.controlPoints = [], this.coll = "annotations", this.userOptions = t, this.labels = [], this.shapes = [];
+			}
+			init(e, t, n = this.index) {
+				let r = this.chart, i = this.options.animation;
+				this.index = n, this.linkPoints(), this.addControlPoints(), this.addShapes(), this.addLabels(), this.setLabelCollector(), this.animationConfig = qt(r, i);
+			}
+			initLabel(e, t) {
+				this.options.labelOptions?.align;
+				let n = new D(this, V(this.options.labelOptions, { controlPointOptions: this.options.controlPointOptions }, e), t);
+				return n.itemType = "label", this.labels.push(n), n;
+			}
+			initShape(e, t) {
+				let n = V(this.options.shapeOptions, { controlPointOptions: this.options.controlPointOptions }, e), r = new W.shapesMap[n.type || "rect"](this, n, t);
+				return r.itemType = "shape", this.shapes.push(r), r;
+			}
+			redraw(e) {
+				this.linkPoints(), this.graphic || this.render(), this.clipRect && this.clipRect.animate(this.getClipBox()), this.redrawItems(this.shapes, e), this.redrawItems(this.labels, e), this.redrawControlPoints(e);
+			}
+			redrawItem(e, t) {
+				if (e.linkPoints(), e.shouldBeDrawn()) {
+					let n, r;
+					e.graphic || this.renderItem(e), e.redraw(H(t, !0) && e.graphic.placed), e.points.length && (n = e.graphic, r = e.points.some((e) => !1 !== e.series.visible && !1 !== e.visible), n && (r ? n.visibility === "hidden" && n.show() : n.hide()));
+				} else this.destroyItem(e);
+			}
+			redrawItems(e, t) {
+				let n = e.length;
+				for (; n--;) this.redrawItem(e[n], t);
+			}
+			remove() {
+				return this.chart.removeAnnotation(this);
+			}
+			render() {
+				let e = this.chart.renderer;
+				this.graphic = e.g("annotation").addClass(this.options.className || "").attr({
+					opacity: 0,
+					zIndex: this.options.zIndex,
+					visibility: this.options.visible ? "inherit" : "hidden"
+				}).add(), this.shapesGroup = e.g("annotation-shapes").add(this.graphic), this.options.crop && this.shapesGroup.clip(this.chart.plotBoxClip), this.labelsGroup = e.g("annotation-labels").attr({
+					translateX: 0,
+					translateY: 0
+				}).add(this.graphic), this.addClipPaths(), this.clipRect && this.graphic.clip(this.clipRect), this.renderItems(this.shapes), this.renderItems(this.labels), this.addEvents(), this.renderControlPoints();
+			}
+			renderItem(e) {
+				e.render(e.itemType === "label" ? this.labelsGroup : this.shapesGroup);
+			}
+			renderItems(e) {
+				let t = e.length;
+				for (; t--;) this.renderItem(e[t]);
+			}
+			setClipAxes() {
+				let e = this.chart.xAxis, t = this.chart.yAxis, n = [...this.options.labels ?? [], ...this.options.shapes ?? []].reduce((n, r) => {
+					let i = r && (r.point || "points" in r && r.points?.[0]);
+					return [e[i && i.xAxis] || n[0], t[i && i.yAxis] || n[1]];
+				}, []);
+				this.clipXAxis = n[0], this.clipYAxis = n[1];
+			}
+			setControlPointsVisibility(e) {
+				let t = function(t) {
+					t.setControlPointsVisibility(e);
+				};
+				this.controlPoints.forEach((t) => {
+					t.setVisibility(e);
+				}), this.shapes.forEach(t), this.labels.forEach(t);
+			}
+			setLabelCollector() {
+				let e = this;
+				e.labelCollector = function() {
+					return e.labels.reduce(function(e, t) {
+						return t.options.allowOverlap || e.push(t.graphic), e;
+					}, []);
+				}, e.chart.labelCollectors.push(e.labelCollector);
+			}
+			setOptions(e) {
+				var t;
+				this.options = V(this.defaultOptions, e.type && this.defaultOptions.types?.[e.type] || {}, e), (t = this.options).typeOptions || (t.typeOptions = {});
+			}
+			setVisibility(e) {
+				let t = this.options, n = this.chart.navigationBindings, r = H(e, !t.visible);
+				if (this.graphic.attr("visibility", r ? "inherit" : "hidden"), !r) {
+					let e = function(e) {
+						e.setControlPointsVisibility(r);
+					};
+					this.shapes.forEach(e), this.labels.forEach(e), n.activeAnnotation === this && n.popup && n.popup.type === "annotation-toolbar" && Zt(n, "closePopup");
+				}
+				t.visible = r;
+			}
+			update(e, t) {
+				let n = this.chart, r = U(this.userOptions, e), i = n.annotations.indexOf(this), a = V(!0, this.userOptions, e);
+				a.labels = r.labels, a.shapes = r.shapes, this.destroy(), this.initProperties(n, a), this.init(n, a), n.options.annotations[i] = this.options, this.isUpdating = !0, H(t, !0) && n.drawAnnotations(), Zt(this, "afterUpdate"), this.isUpdating = !1;
+			}
+		}
+		W.ControlPoint = Ce, W.MockPoint = b, W.shapesMap = {
+			rect: Ve,
+			circle: Ue,
+			ellipse: Ge,
+			path: T,
+			image: et
+		}, W.types = {}, W.prototype.defaultOptions = he, Jt.annotations = he, W.prototype.nonDOMEvents = [
+			"add",
+			"afterUpdate",
+			"drag",
+			"remove"
+		], Oe.compose(W);
+		var $t = c ||= {};
+		$t.compose = function(e) {
+			return e.navigation ||= new en(e), e;
+		};
+		class en {
+			constructor(e) {
+				this.updates = [], this.chart = e;
+			}
+			addUpdate(e) {
+				this.chart.navigation.updates.push(e);
+			}
+			update(e, t) {
+				this.updates.forEach((n) => {
+					n.call(this.chart, e, t);
+				});
+			}
+		}
+		$t.Additions = en;
+		let tn = c, { defined: nn, isNumber: rn, pick: an } = m(), on = {
+			backgroundColor: "string",
+			borderColor: "string",
+			borderRadius: "string",
+			color: "string",
+			fill: "string",
+			fontSize: "string",
+			labels: "string",
+			name: "string",
+			stroke: "string",
+			title: "string"
+		}, sn = {
+			annotationsFieldsTypes: on,
+			getAssignedAxis: function(e) {
+				return e.filter((e) => {
+					let t = e.axis.getExtremes(), n = t.min, r = t.max, i = an(e.axis.minPointOffset, 0);
+					return rn(n) && rn(r) && e.value >= n - i && e.value <= r + i && !e.axis.options.isInternal;
+				})[0];
+			},
+			getFieldType: function(e, t) {
+				let n = on[e], r = typeof t;
+				return nn(n) && (r = n), {
+					string: "text",
+					number: "number",
+					boolean: "checkbox"
+				}[r];
+			}
+		}, { getAssignedAxis: G } = sn, { isNumber: cn, merge: K } = m(), ln = {
+			lang: { navigation: { popup: {
+				simpleShapes: "Simple shapes",
+				lines: "Lines",
+				circle: "Circle",
+				ellipse: "Ellipse",
+				rectangle: "Rectangle",
+				label: "Label",
+				shapeOptions: "Shape options",
+				typeOptions: "Details",
+				fill: "Fill",
+				format: "Text",
+				strokeWidth: "Line width",
+				stroke: "Line color",
+				title: "Title",
+				name: "Name",
+				labelOptions: "Label options",
+				labels: "Labels",
+				backgroundColor: "Background color",
+				backgroundColors: "Background colors",
+				borderColor: "Border color",
+				borderRadius: "Border radius",
+				borderWidth: "Border width",
+				style: "Style",
+				padding: "Padding",
+				fontSize: "Font size",
+				color: "Color",
+				height: "Height",
+				shapes: "Shape options"
+			} } },
+			navigation: {
+				bindingsClassName: "highcharts-bindings-container",
+				bindings: {
+					circleAnnotation: {
+						className: "highcharts-circle-annotation",
+						start: function(e) {
+							let t = this.chart.pointer?.getCoordinates(e), n = t && G(t.xAxis), r = t && G(t.yAxis), i = this.chart.options.navigation;
+							if (n && r) return this.chart.addAnnotation(K({
+								langKey: "circle",
+								type: "basicAnnotation",
+								shapes: [{
+									type: "circle",
+									point: {
+										x: n.value,
+										y: r.value,
+										xAxis: n.axis.index,
+										yAxis: r.axis.index
+									},
+									r: 5
+								}]
+							}, i.annotationsOptions, i.bindings.circleAnnotation.annotationsOptions));
+						},
+						steps: [function(e, t) {
+							let n, r = t.options.shapes, i = r && r[0] && r[0].point || {};
+							if (cn(i.xAxis) && cn(i.yAxis)) {
+								let t = this.chart.inverted, r = this.chart.xAxis[i.xAxis].toPixels(i.x), a = this.chart.yAxis[i.yAxis].toPixels(i.y);
+								n = Math.max(Math.sqrt((t ? a - e.chartX : r - e.chartX) ** 2 + (t ? r - e.chartY : a - e.chartY) ** 2), 5);
+							}
+							t.update({ shapes: [{ r: n }] });
+						}]
+					},
+					ellipseAnnotation: {
+						className: "highcharts-ellipse-annotation",
+						start: function(e) {
+							let t = this.chart.pointer?.getCoordinates(e), n = t && G(t.xAxis), r = t && G(t.yAxis), i = this.chart.options.navigation;
+							if (n && r) return this.chart.addAnnotation(K({
+								langKey: "ellipse",
+								type: "basicAnnotation",
+								shapes: [{
+									type: "ellipse",
+									xAxis: n.axis.index,
+									yAxis: r.axis.index,
+									points: [{
+										x: n.value,
+										y: r.value
+									}, {
+										x: n.value,
+										y: r.value
+									}],
+									ry: 1
+								}]
+							}, i.annotationsOptions, i.bindings.ellipseAnnotation.annotationsOptions));
+						},
+						steps: [function(e, t) {
+							let n = t.shapes[0], r = n.getAbsolutePosition(n.points[1]);
+							n.translatePoint(e.chartX - r.x, e.chartY - r.y, 1), n.redraw(!1);
+						}, function(e, t) {
+							let n = t.shapes[0], r = n.getAbsolutePosition(n.points[0]), i = n.getAbsolutePosition(n.points[1]), a = n.getDistanceFromLine(r, i, e.chartX, e.chartY), o = n.getYAxis(), s = Math.abs(o.toValue(0) - o.toValue(a));
+							n.setYRadius(s), n.redraw(!1);
+						}]
+					},
+					rectangleAnnotation: {
+						className: "highcharts-rectangle-annotation",
+						start: function(e) {
+							let t = this.chart.pointer?.getCoordinates(e), n = t && G(t.xAxis), r = t && G(t.yAxis);
+							if (!n || !r) return;
+							let i = n.value, a = r.value, o = n.axis.index, s = r.axis.index, c = this.chart.options.navigation;
+							return this.chart.addAnnotation(K({
+								langKey: "rectangle",
+								type: "basicAnnotation",
+								shapes: [{
+									type: "path",
+									points: [
+										{
+											xAxis: o,
+											yAxis: s,
+											x: i,
+											y: a
+										},
+										{
+											xAxis: o,
+											yAxis: s,
+											x: i,
+											y: a
+										},
+										{
+											xAxis: o,
+											yAxis: s,
+											x: i,
+											y: a
+										},
+										{
+											xAxis: o,
+											yAxis: s,
+											x: i,
+											y: a
+										},
+										{ command: "Z" }
+									]
+								}]
+							}, c.annotationsOptions, c.bindings.rectangleAnnotation.annotationsOptions));
+						},
+						steps: [function(e, t) {
+							let n = t.options.shapes, r = n && n[0] && n[0].points || [], i = this.chart.pointer?.getCoordinates(e), a = i && G(i.xAxis), o = i && G(i.yAxis);
+							if (a && o) {
+								let e = a.value, n = o.value;
+								r[1].x = e, r[2].x = e, r[2].y = n, r[3].y = n, t.update({ shapes: [{ points: r }] });
+							}
+						}]
+					},
+					labelAnnotation: {
+						className: "highcharts-label-annotation",
+						start: function(e) {
+							let t = this.chart.pointer?.getCoordinates(e), n = t && G(t.xAxis), r = t && G(t.yAxis), i = this.chart.options.navigation;
+							if (n && r) return this.chart.addAnnotation(K({
+								langKey: "label",
+								type: "basicAnnotation",
+								labelOptions: {
+									format: "{y:.2f}",
+									overflow: "none",
+									crop: !0
+								},
+								labels: [{ point: {
+									xAxis: n.axis.index,
+									yAxis: r.axis.index,
+									x: n.value,
+									y: r.value
+								} }]
+							}, i.annotationsOptions, i.bindings.labelAnnotation.annotationsOptions));
+						}
+					}
+				},
+				events: {},
+				annotationsOptions: { animation: { defer: 0 } }
+			}
+		}, { setOptions: un } = m(), { format: dn } = qe(), { composed: fn, doc: pn, win: mn } = m(), { getAssignedAxis: hn, getFieldType: gn } = sn, { addEvent: q, attr: _n, defined: vn, fireEvent: J, isArray: Y, isFunction: yn, isNumber: bn, isObject: xn, merge: Sn, objectEach: X, pick: Cn, pushUnique: wn } = m();
+		function Tn() {
+			this.chart.navigationBindings && this.chart.navigationBindings.deselectAnnotation();
+		}
+		function En() {
+			this.navigationBindings && this.navigationBindings.destroy();
+		}
+		function Dn() {
+			let e = this.options;
+			e && e.navigation && e.navigation.bindings && (this.navigationBindings = new Q(this, e.navigation), this.navigationBindings.initEvents(), this.navigationBindings.initUpdate());
+		}
+		function On() {
+			let e = this.navigationBindings, t = "highcharts-disabled-btn";
+			if (this && e) {
+				let n = !1;
+				if (this.series.forEach((e) => {
+					!e.options.isInternal && e.visible && (n = !0);
+				}), this.navigationBindings && this.navigationBindings.container && this.navigationBindings.container[0]) {
+					let r = this.navigationBindings.container[0];
+					X(e.boundClassNames, (e, i) => {
+						let a = r.querySelectorAll("." + i);
+						if (a) for (let r = 0; r < a.length; r++) {
+							let i = a[r], o = i.className;
+							e.noDataState === "normal" || n ? o.indexOf(t) !== -1 && i.classList.remove(t) : o.indexOf(t) === -1 && (i.className += " " + t);
+						}
+					});
+				}
+			}
+		}
+		function kn() {
+			this.deselectAnnotation();
+		}
+		function An() {
+			this.selectedButtonElement = null;
+		}
+		function Z(e) {
+			let t, n, r = e.prototype.defaultOptions.events && e.prototype.defaultOptions.events.click;
+			function i(e) {
+				let t = this, n = t.chart.navigationBindings, i = n.activeAnnotation;
+				r && r.call(t, e), i === t ? J(n, "closePopup") : (n.deselectAnnotation(), n.activeAnnotation = t, t.setControlPointsVisibility(!0), J(n, "showPopup", {
+					annotation: t,
+					formType: "annotation-toolbar",
+					options: n.annotationToFields(t),
+					onSubmit: function(e) {
+						if (e.actionType === "remove") n.activeAnnotation = !1, n.chart.removeAnnotation(t);
+						else {
+							let r = {};
+							n.fieldsToOptions(e.fields, r), n.deselectAnnotation();
+							let i = r.typeOptions;
+							t.options.type === "measure" && (i.crosshairY.enabled = i.crosshairY.strokeWidth !== 0, i.crosshairX.enabled = i.crosshairX.strokeWidth !== 0), t.update(r);
+						}
+					}
+				})), e.activeAnnotation = !0;
+			}
+			Sn(!0, e.prototype.defaultOptions.events, {
+				click: i,
+				touchstart: function(e) {
+					t = e.touches[0].clientX, n = e.touches[0].clientY;
+				},
+				touchend: function(e) {
+					t && Math.sqrt((t - e.changedTouches[0].clientX) ** 2 + (n - e.changedTouches[0].clientY) ** 2) >= 4 || i.call(this, e);
+				}
+			});
+		}
+		class Q {
+			static compose(e, t) {
+				wn(fn, "NavigationBindings") && (q(e, "remove", Tn), Z(e), X(e.types, (e) => {
+					Z(e);
+				}), q(t, "destroy", En), q(t, "load", Dn), q(t, "render", On), q(Q, "closePopup", kn), q(Q, "deselectButton", An), un(ln));
+			}
+			constructor(e, t) {
+				this.boundClassNames = void 0, this.chart = e, this.options = t, this.eventsToUnbind = [], this.container = this.chart.container.getElementsByClassName(this.options.bindingsClassName || ""), this.container.length || (this.container = pn.getElementsByClassName(this.options.bindingsClassName || ""));
+			}
+			getCoords(e) {
+				let t = this.chart.pointer?.getCoordinates(e);
+				return [t && hn(t.xAxis), t && hn(t.yAxis)];
+			}
+			initEvents() {
+				let e = this, t = e.chart, n = e.container, r = e.options;
+				e.boundClassNames = {}, X(r.bindings || {}, (t) => {
+					e.boundClassNames[t.className] = t;
+				}), [].forEach.call(n, (t) => {
+					e.eventsToUnbind.push(q(t, "click", (n) => {
+						let r = e.getButtonEvents(t, n);
+						r && !r.button.classList.contains("highcharts-disabled-btn") && e.bindingsButtonClick(r.button, r.events, n);
+					}));
+				}), X(r.events || {}, (t, n) => {
+					yn(t) && e.eventsToUnbind.push(q(e, n, t, { passive: !1 }));
+				}), e.eventsToUnbind.push(q(t.container, "click", function(n) {
+					!t.cancelClick && t.isInsidePlot(n.chartX - t.plotLeft, n.chartY - t.plotTop, { visiblePlotOnly: !0 }) && e.bindingsChartClick(this, n);
+				})), e.eventsToUnbind.push(q(t.container, m().isTouchDevice ? "touchmove" : "mousemove", function(t) {
+					e.bindingsContainerMouseMove(this, t);
+				}, m().isTouchDevice ? { passive: !1 } : void 0));
+			}
+			initUpdate() {
+				let e = this;
+				tn.compose(this.chart).navigation.addUpdate((t) => {
+					e.update(t);
+				});
+			}
+			bindingsButtonClick(e, t, n) {
+				let r = this.chart, i = r.renderer.boxWrapper, a = !0;
+				this.selectedButtonElement && (this.selectedButtonElement.classList === e.classList && (a = !1), J(this, "deselectButton", { button: this.selectedButtonElement }), this.nextEvent && (this.currentUserDetails && this.currentUserDetails.coll === "annotations" && r.removeAnnotation(this.currentUserDetails), this.mouseMoveEvent = this.nextEvent = !1)), a ? (this.selectedButton = t, this.selectedButtonElement = e, J(this, "selectButton", { button: e }), t.init && t.init.call(this, e, n), (t.start || t.steps) && r.renderer.boxWrapper.addClass("highcharts-draw-mode")) : (r.stockTools && e.classList.remove("highcharts-active"), i.removeClass("highcharts-draw-mode"), this.nextEvent = !1, this.mouseMoveEvent = !1, this.selectedButton = null);
+			}
+			bindingsChartClick(e, t) {
+				e = this.chart;
+				let n = this.activeAnnotation, r = this.selectedButton, i = e.renderer.boxWrapper;
+				n && (n.cancelClick || t.activeAnnotation || !t.target.parentNode || function(e, t) {
+					let n = mn.Element.prototype, r = n.matches || n.msMatchesSelector || n.webkitMatchesSelector, i = null;
+					if (n.closest) i = n.closest.call(e, t);
+					else do {
+						if (r.call(e, t)) return e;
+						e = e.parentElement || e.parentNode;
+					} while (e !== null && e.nodeType === 1);
+					return i;
+				}(t.target, ".highcharts-popup") ? n.cancelClick && setTimeout(() => {
+					n.cancelClick = !1;
+				}, 0) : J(this, "closePopup")), r && r.start && (this.nextEvent ? (this.nextEvent(t, this.currentUserDetails), this.steps && (this.stepIndex++, r.steps[this.stepIndex] ? this.mouseMoveEvent = this.nextEvent = r.steps[this.stepIndex] : (J(this, "deselectButton", { button: this.selectedButtonElement }), i.removeClass("highcharts-draw-mode"), r.end && r.end.call(this, t, this.currentUserDetails), this.nextEvent = !1, this.mouseMoveEvent = !1, this.selectedButton = null))) : (this.currentUserDetails = r.start.call(this, t), this.currentUserDetails && r.steps ? (this.stepIndex = 0, this.steps = !0, this.mouseMoveEvent = this.nextEvent = r.steps[this.stepIndex]) : (J(this, "deselectButton", { button: this.selectedButtonElement }), i.removeClass("highcharts-draw-mode"), this.steps = !1, this.selectedButton = null, r.end && r.end.call(this, t, this.currentUserDetails))));
+			}
+			bindingsContainerMouseMove(e, t) {
+				this.mouseMoveEvent && this.mouseMoveEvent(t, this.currentUserDetails);
+			}
+			fieldsToOptions(e, t) {
+				return X(e, (e, n) => {
+					let r = parseFloat(e), i = n.split("."), a = i.length - 1;
+					if (!bn(r) || e.match(/px|em/g) || n.match(/format/g) || (e = r), e !== "undefined") {
+						let n = t;
+						i.forEach((t, r) => {
+							if (t !== "__proto__" && t !== "constructor") {
+								let o = Cn(i[r + 1], "");
+								a === r ? n[t] = e : (n[t] || (n[t] = o.match(/\d/g) ? [] : {}), n = n[t]);
+							}
+						});
+					}
+				}), t;
+			}
+			deselectAnnotation() {
+				this.activeAnnotation &&= (this.activeAnnotation.setControlPointsVisibility(!1), !1);
+			}
+			annotationToFields(e) {
+				let t = e.options, n = Q.annotationsEditable, r = n.nestedOptions, i = Cn(t.type, t.shapes?.[0]?.type, t.labels?.[0]?.type, "label"), a = Q.annotationsNonEditable[t.langKey] || [], o = {
+					langKey: t.langKey,
+					type: i
+				};
+				function s(t, n, i, o, c) {
+					let l;
+					i && vn(t) && a.indexOf(n) === -1 && ((i.indexOf && i.indexOf(n)) >= 0 || i[n] || !0 === i) && (Y(t) ? (o[n] = [], t.forEach((e, t) => {
+						xn(e) ? (o[n][t] = {}, X(e, (e, i) => {
+							s(e, i, r[n], o[n][t], n);
+						})) : s(e, 0, r[n], o[n], n);
+					})) : xn(t) ? (l = {}, Y(o) ? (o.push(l), l[n] = {}, l = l[n]) : o[n] = l, X(t, (e, t) => {
+						s(e, t, n === 0 ? i : r[n], l, n);
+					})) : n === "format" ? o[n] = [dn(t, e.labels[0].points[0]).toString(), "text"] : Y(o) ? o.push([t, gn(c, t)]) : o[n] = [t, gn(n, t)]);
+				}
+				return X(t, (e, a) => {
+					a === "typeOptions" && o.type !== "basicAnnotation" ? (o[a] = {}, X(t[a], (e, t) => {
+						s(e, t, r, o[a], t);
+					})) : s(e, a, n[i], o, a);
+				}), o;
+			}
+			getClickedClassNames(e, t) {
+				let n = t.target, r = [], i;
+				for (; n && n.tagName && ((i = _n(n, "class")) && (r = r.concat(i.split(" ").map((e) => [e, n]))), (n = n.parentNode) !== e););
+				return r;
+			}
+			getButtonEvents(e, t) {
+				let n, r = this;
+				return this.getClickedClassNames(e, t).forEach((e) => {
+					r.boundClassNames[e[0]] && !n && (n = {
+						events: r.boundClassNames[e[0]],
+						button: e[1]
+					});
+				}), n;
+			}
+			update(e) {
+				this.options = Sn(!0, this.options, e), this.removeEvents(), this.initEvents();
+			}
+			removeEvents() {
+				this.eventsToUnbind.forEach((e) => e());
+			}
+			destroy() {
+				this.removeEvents();
+			}
+		}
+		Q.annotationsEditable = {
+			nestedOptions: {
+				labelOptions: [
+					"style",
+					"format",
+					"backgroundColor"
+				],
+				labels: ["style"],
+				label: ["style"],
+				style: ["fontSize", "color"],
+				background: [
+					"fill",
+					"strokeWidth",
+					"stroke"
+				],
+				innerBackground: [
+					"fill",
+					"strokeWidth",
+					"stroke"
+				],
+				outerBackground: [
+					"fill",
+					"strokeWidth",
+					"stroke"
+				],
+				shapeOptions: [
+					"fill",
+					"strokeWidth",
+					"stroke"
+				],
+				shapes: [
+					"fill",
+					"strokeWidth",
+					"stroke"
+				],
+				line: ["strokeWidth", "stroke"],
+				backgroundColors: [!0],
+				connector: [
+					"fill",
+					"strokeWidth",
+					"stroke"
+				],
+				crosshairX: ["strokeWidth", "stroke"],
+				crosshairY: ["strokeWidth", "stroke"]
+			},
+			circle: ["shapes"],
+			ellipse: ["shapes"],
+			verticalLine: [],
+			label: ["labelOptions"],
+			measure: [
+				"background",
+				"crosshairY",
+				"crosshairX"
+			],
+			fibonacci: [],
+			tunnel: [
+				"background",
+				"line",
+				"height"
+			],
+			pitchfork: ["innerBackground", "outerBackground"],
+			rect: ["shapes"],
+			crookedLine: [],
+			basicAnnotation: ["shapes", "labelOptions"]
+		}, Q.annotationsNonEditable = {
+			rectangle: [
+				"crosshairX",
+				"crosshairY",
+				"labelOptions"
+			],
+			ellipse: ["labelOptions"],
+			circle: ["labelOptions"]
+		};
+		let $ = m();
+		$.Annotation = $.Annotation || W, $.NavigationBindings = $.NavigationBindings || Q, $.Annotation.compose($.Chart, $.NavigationBindings, $.Pointer, $.SVGRenderer);
+		let jn = m();
+		return f.default;
+	})());
+}));
+//#endregion
+export default t();