@mobileaction/action-kit 1.58.13 → 1.58.14-beta.20260413125648

package/dist/annotations-BRcbfcny.js

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