@mobileaction/action-kit 1.45.0 → 1.45.2

package/dist/annotations-DJexnIAc.js

@@ -0,0 +1,1257 @@
+import { g as Ze } from "./index-BlFaxM2B.js";
+function _e(U, Z) {
+  for (var E = 0; E < Z.length; E++) {
+    const B = Z[E];
+    if (typeof B != "string" && !Array.isArray(B)) {
+      for (const I in B)
+        if (I !== "default" && !(I in U)) {
+          const W = Object.getOwnPropertyDescriptor(B, I);
+          W && Object.defineProperty(U, I, W.get ? W : {
+            enumerable: !0,
+            get: () => B[I]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(U, Symbol.toStringTag, { value: "Module" }));
+}
+var $ = { exports: {} }, Je = $.exports, ui;
+function Qe() {
+  return ui || (ui = 1, function(U, Z) {
+    (function(E, B) {
+      U.exports = B(E._Highcharts, E._Highcharts.SeriesRegistry, E._Highcharts.Templating, E._Highcharts.AST);
+    })(typeof window > "u" ? Je : window, (E, B, I, W) => (() => {
+      var _, J, Q, tt, fi = { 512: (o) => {
+        o.exports = B;
+      }, 660: (o) => {
+        o.exports = W;
+      }, 944: (o) => {
+        o.exports = E;
+      }, 984: (o) => {
+        o.exports = I;
+      } }, ft = {};
+      function A(o) {
+        var t = ft[o];
+        if (t !== void 0) return t.exports;
+        var i = ft[o] = { exports: {} };
+        return fi[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 mt = {};
+      A.d(mt, { default: () => $e });
+      var mi = A(944), x = A.n(mi);
+      let { addEvent: H, erase: xt, find: xi, fireEvent: yi, pick: vi, wrap: bi } = x();
+      function yt(o, t) {
+        let i = this.initAnnotation(o);
+        return this.options.annotations.push(i.options), vi(t, !0) && (i.redraw(), i.graphic.attr({ opacity: 1 })), i;
+      }
+      function Ai() {
+        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(), H(o, "redraw", o.drawAnnotations), H(o, "destroy", function() {
+          o.plotBoxClip.destroy(), o.controlPointsGroup.destroy();
+        }), H(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 && o.options.exporting.csv && o.options.exporting.csv.annotations && o.options.exporting.csv.annotations.itemDelimiter, h = o.options.exporting && o.options.exporting.csv && o.options.exporting.csv.annotations && o.options.exporting.csv.annotations.join;
+          i.forEach((g) => {
+            g.options.labelOptions && g.options.labelOptions.includeInDataExport && g.labels.forEach((f) => {
+              if (f.options.text) {
+                let d = f.options.text;
+                f.points.forEach((p) => {
+                  let u = p.x, m = p.series.xAxis ? p.series.xAxis.index : -1, y = !1;
+                  if (m === -1) {
+                    let v = t.dataRows[0].length, b = Array(v);
+                    for (let D = 0; D < v; ++D) b[D] = "";
+                    b.push(d), b.xValues = [], b.xValues[m] = u, t.dataRows.push(b), y = !0;
+                  }
+                  if (y || t.dataRows.forEach((v) => {
+                    !y && v.xValues && m !== void 0 && u === v.xValues[m] && (h && v.length > a ? v[v.length - 1] += r + d : v.push(d), y = !0);
+                  }), !y) {
+                    let v = t.dataRows[0].length, b = Array(v);
+                    for (let D = 0; D < v; ++D) b[D] = "";
+                    b[0] = u, b.push(d), b.xValues = [], m !== void 0 && (b.xValues[m] = u), 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 f = function(d) {
+              let p;
+              return e && (p = e(d)) !== !1 ? p : (p = n + " " + d, s ? { columnTitle: p, topLevelColumnTitle: p } : p);
+            }(g + 1);
+            s ? (t.dataRows[0].push(f.topLevelColumnTitle), t.dataRows[1].push(f.columnTitle)) : t.dataRows[0].push(f);
+          }
+        });
+      }
+      function ki() {
+        this.plotBoxClip.attr(this.plotBox), this.annotations.forEach((o) => {
+          o.redraw(), o.graphic.animate({ opacity: 1 }, o.animationConfig);
+        });
+      }
+      function wi(o) {
+        let t = this.annotations, i = o.coll === "annotations" ? o : xi(t, function(e) {
+          return e.options.id === o;
+        });
+        i && (yi(i, "remove"), xt(this.options.annotations, i.options), xt(t, i), i.destroy());
+      }
+      function Ei() {
+        this.annotations = [], this.options.annotations || (this.options.annotations = []);
+      }
+      function Pi(o) {
+        this.chart.hasDraggedAnnotation || o.apply(this, Array.prototype.slice.call(arguments, 1));
+      }
+      (_ || (_ = {})).compose = function(o, t, i) {
+        let e = t.prototype;
+        if (!e.addAnnotation) {
+          let s = i.prototype;
+          H(t, "afterInit", Ei), e.addAnnotation = yt, e.callbacks.push(Ai), e.collectionsWithInit.annotations = [yt], e.collectionsWithUpdate.push("annotations"), e.drawAnnotations = ki, e.removeAnnotation = wi, e.initAnnotation = function(n) {
+            let a = new (o.types[n.type] || o)(this, n);
+            return this.annotations.push(a), a;
+          }, bi(s, "onContainerMouseDown", Pi);
+        }
+      };
+      let Ci = _, { defined: Oi } = x(), { doc: vt, isTouchDevice: j } = x(), { addEvent: S, fireEvent: it, objectEach: Bi, pick: bt, removeEvent: Mi } = x(), At = class {
+        addEvents() {
+          let o = this, t = function(i) {
+            S(i, j ? "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);
+          }), Bi(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 ? (S(o.graphic.element, e, s, { passive: !1 }), o.graphic.div && S(o.graphic.div, e, s, { passive: !1 })) : S(o, e, s, { passive: !1 });
+          }), o.options.draggable && (S(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 || it(o, "add");
+        }
+        destroy() {
+          this.removeDocEvents(), Mi(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 = S(vt, j || e ? "touchmove" : "mousemove", function(a) {
+            t.hasDragged = !0, (a = i?.normalize(a) || a).prevChartX = s, a.prevChartY = n, it(t, "drag", a), s = a.chartX, n = a.chartY;
+          }, j || e ? { passive: !1 } : void 0), t.removeMouseUp = S(vt, j || e ? "touchend" : "mouseup", function() {
+            let a = bt(t.target && t.target.annotation, t.target);
+            a && (a.cancelClick = t.hasDragged), t.cancelClick = t.hasDragged, t.chart.hasDraggedAnnotation = !1, t.hasDragged && it(bt(a, t), "afterUpdate"), t.hasDragged = !1, t.onMouseUp();
+          }, j || e ? { passive: !1 } : void 0);
+        }
+        onMouseUp() {
+          this.removeDocEvents();
+        }
+        removeDocEvents() {
+          this.removeDrag && (this.removeDrag = this.removeDrag()), this.removeMouseUp && (this.removeMouseUp = this.removeMouseUp());
+        }
+      }, { merge: Ni, pick: Ti } = x(), kt = class extends At {
+        constructor(o, t, i, e) {
+          super(), this.nonDOMEvents = ["drag"], this.chart = o, this.target = t, this.options = i, this.index = Ti(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 = Ni(!0, this.options, o);
+          this.destroy(), this.constructor(t, i, s, e), this.render(t.controlPointsGroup), this.redraw();
+        }
+      };
+      var Di = A(512), wt = A.n(Di);
+      let { series: { prototype: Li } } = wt(), { defined: et, fireEvent: Ii } = x();
+      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: Li.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() ? 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 = et(t) && t >= 0 && t <= e.len), s && (n.isInsidePlot = n.isInsidePlot && et(i) && i >= 0 && i <= s.len), Ii(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 : et(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 d = this.controlPoints, p = this.options.controlPoints || [];
+          p.forEach((u, m) => {
+            let y = x().merge(this.options.controlPointOptions, u);
+            y.index || (y.index = m), p[m] = y, d.push(new kt(this.chart, this, y));
+          });
+        }
+        function i(d) {
+          let p = d.series.getPlotBox(), u = d.series.chart, m = d.mock ? d.toAnchor() : u.tooltip && u.tooltip.getAnchor.call({ chart: d.series.chart }, d) || [0, 0, 0, 0], y = { x: m[0] + (this.options.x || 0), y: m[1] + (this.options.y || 0), height: m[2] || 0, width: m[3] || 0 };
+          return { relativePosition: y, absolutePosition: x().merge(y, { x: y.x + (d.mock ? p.translateX : u.plotLeft), y: y.y + (d.mock ? p.translateY : u.plotTop) }) };
+        }
+        function e() {
+          this.controlPoints.forEach((d) => d.destroy()), this.chart = null, this.controlPoints = null, this.points = null, this.options = null, this.annotation && (this.annotation = null);
+        }
+        function s() {
+          let d = this.options;
+          return d.points || d.point && x().splat(d.point);
+        }
+        function n() {
+          let d, p, u = this.getPointsOptions(), m = this.points, y = u && u.length || 0;
+          for (d = 0; d < y; d++) {
+            if (!(p = this.point(u[d], m[d]))) {
+              m.length = 0;
+              return;
+            }
+            p.mock && p.refresh(), m[d] = p;
+          }
+          return m;
+        }
+        function a(d, p) {
+          if (d && d.series) return d;
+          if (!p || p.series === null) {
+            if (x().isObject(d)) p = new Y(this.chart, this, d);
+            else if (x().isString(d)) p = this.chart.get(d) || null;
+            else if (typeof d == "function") {
+              let u = d.call(p, this);
+              p = u.series ? u : new Y(this.chart, this, d);
+            }
+          }
+          return p;
+        }
+        function r(d) {
+          this.controlPoints.forEach((p) => p.redraw(d));
+        }
+        function h() {
+          this.controlPoints.forEach((d) => d.render());
+        }
+        function c(d, p, u, m, y) {
+          if (this.chart.inverted) {
+            let v = p;
+            p = u, u = v;
+          }
+          this.points.forEach((v, b) => this.transformPoint(d, p, u, m, y, b), this);
+        }
+        function l(d, p, u, m, y, v) {
+          let b = this.points[v];
+          b.mock || (b = this.points[v] = Y.fromPoint(b)), b[d](p, u, m, y);
+        }
+        function g(d, p) {
+          this.transform("translate", null, null, d, p);
+        }
+        function f(d, p, u) {
+          this.transformPoint("translate", null, null, d, p, u);
+        }
+        o.compose = function(d) {
+          let p = d.prototype;
+          p.addControlPoints || x().merge(!0, p, { addControlPoints: t, anchor: i, destroyControlTarget: e, getPointsOptions: s, linkPoints: n, point: a, redrawControlPoints: r, renderControlPoints: h, transform: c, transformPoint: l, translate: g, translatePoint: f });
+        };
+      })(J || (J = {}));
+      let Et = J, { merge: Pt } = x();
+      class Ct {
+        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(...t) {
+          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 = Pt(!0, this.options, t), s = this.graphic.parentGroup, n = this.constructor;
+          this.destroy(), Pt(!0, this, new n(i, e, this.index, this.itemType)), this.render(s), this.redraw();
+        }
+      }
+      Et.compose(Ct);
+      let F = Ct, { defaultMarkers: Si } = { 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: Yi, defined: Xi, extend: Fi, merge: z, uniqueKey: Ri } = x(), Ui = Bt("marker-end"), Wi = Bt("marker-start"), Ot = "rgba(192,192,192," + (x().svg ? 1e-4 : 2e-3) + ")";
+      function Bt(o) {
+        return function(t) {
+          this.attr(o, "url(#" + t + ")");
+        };
+      }
+      function ji() {
+        this.options.defs = z(Si, this.options.defs || {});
+      }
+      function qi(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 R extends F {
+        static compose(t, i) {
+          let e = i.prototype;
+          e.addMarker || (Yi(t, "afterGetContainer", ji), e.addMarker = qi);
+        }
+        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" ? s.push([c, r.x, r.y]) : 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: Ot, fill: Ot, "stroke-width": this.graphic.strokeWidth() + 2 * i.snap }), super.render(), Fi(this.graphic, { markerStartSetter: Wi, markerEndSetter: Ui }), 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 = Xi(n) && n !== "none" ? n : i.stroke;
+          ["markerStart", "markerEnd"].forEach(function(r) {
+            let h, c, l, g, f = i[r];
+            if (f) {
+              for (l in s) if ((f === ((h = s[l]).attributes && h.attributes.id) || f === h.id) && h.tagName === "marker") {
+                c = h;
+                break;
+              }
+              c && (g = t[r] = e.renderer.addMarker((i.id || Ri()) + "-" + f, z(c, { color: a })), t.attr(r, g.getAttribute("id")));
+            }
+          });
+        }
+      }
+      R.attrsMap = { dashStyle: "dashstyle", strokeWidth: "stroke-width", stroke: "stroke", fill: "fill", zIndex: "zIndex" };
+      let { merge: Hi } = x();
+      class Mt extends F {
+        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);
+        }
+      }
+      Mt.attrsMap = Hi(R.attrsMap, { width: "width", height: "height" });
+      let { merge: zi } = x();
+      class Nt extends F {
+        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;
+        }
+      }
+      Nt.attrsMap = zi(R.attrsMap, { r: "r" });
+      let { merge: Vi, defined: st } = x();
+      class Tt extends F {
+        constructor(t, i, e) {
+          super(t, i, e, "shape"), this.type = "ellipse";
+        }
+        init(t, i, e) {
+          st(i.yAxis) && i.points.forEach((s) => {
+            s.yAxis = i.yAxis;
+          }), st(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 st(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);
+        }
+      }
+      Tt.attrsMap = Vi(R.attrsMap, { ry: "ry" });
+      var Gi = A(984), Dt = A.n(Gi);
+      let { format: Ki } = Dt(), { extend: $i, getAlignFactor: Lt, isNumber: It, pick: Zi } = x();
+      function _i(o, t, i, e, s) {
+        let n = s && s.anchorX, a = s && s.anchorY, r, h, c = i / 2;
+        return It(n) && It(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 P extends F {
+        static alignedPosition(t, i) {
+          return { x: Math.round((i.x || 0) + (t.x || 0) + (i.width - (t.width || 0)) * Lt(t.align)), y: Math.round((i.y || 0) + (t.y || 0) + (i.height - (t.height || 0)) * Lt(t.verticalAlign)) };
+        }
+        static compose(t) {
+          t.prototype.symbols.connector = _i;
+        }
+        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, f = (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 = f + h) < 0 && (r === "bottom" ? l.verticalAlign = "top" : l.y = (l.y || 0) - n), (n = f + 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) {
+          let e = this.annotation.chart, s = this.annotation.userOptions, n = e.annotations.indexOf(this.annotation), a = e.options.annotations[n];
+          if (e.inverted) {
+            let r = t;
+            t = i, i = r;
+          }
+          this.options.x += t, this.options.y += i, a[this.collection][this.index].x = this.options.x, a[this.collection][this.index].y = this.options.y, s[this.collection][this.index].x = this.options.x, s[this.collection][this.index].y = this.options.y;
+        }
+        render(t) {
+          let i = this.options, e = this.attrsFromOptions(i), s = i.style;
+          this.graphic = this.annotation.chart.renderer.label("", 0, -9999, i.shape, null, null, i.useHTML, null, "annotation-label").attr(e).add(t), this.annotation.chart.styledMode || (s.color === "contrast" && (s.color = this.annotation.chart.renderer.getContrast(P.shapesWithoutBackground.indexOf(i.shape) > -1 ? "#FFFFFF" : i.backgroundColor)), 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) {
+            this.redraw(t);
+            return;
+          }
+          s.attr({ text: e ? Ki(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, f, d = n.series.visible && Y.prototype.isInsidePlot.call(n);
+          if (i && d) {
+            let { width: p = 0, height: u = 0 } = i;
+            a.distance && s ? c = s.getPosition.call({ chart: e, distance: Zi(a.distance, 16), getPlayingField: s.getPlayingField, pointer: s.pointer }, p, u, { 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 = P.alignedPosition($i(a, { width: p, height: u }), l), this.options.overflow === "justify" && (c = P.alignedPosition(P.justifiedOptions(e, i, a, c), l))), a.crop && (g = c.x - e.plotLeft, f = c.y - e.plotTop, d = e.isInsidePlot(g, f) && e.isInsidePlot(g + p, f + u));
+          }
+          return d ? c : null;
+        }
+      }
+      P.attrsMap = { backgroundColor: "fill", borderColor: "stroke", borderWidth: "stroke-width", zIndex: "zIndex", borderRadius: "r", padding: "padding" }, P.shapesWithoutBackground = ["connector"];
+      class St extends F {
+        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 = P.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);
+        }
+      }
+      St.attrsMap = { width: "width", height: "height", zIndex: "zIndex" };
+      var Ji = A(660), ot = A.n(Ji);
+      let { addEvent: Yt, createElement: Xt } = x(), Qi = 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 Xt("div", { className: t }, void 0, o);
+        }
+        addCloseButton(o = "highcharts-popup-close") {
+          let t = this, i = this.iconsURL, e = Xt("button", { className: o }, void 0, this.container);
+          return e.style["background-image"] = "url(" + (i.match(/png|svg|jpeg|jpg|gif/ig) ? i : i + "close.svg") + ")", ["click", "touchstart"].forEach((s) => {
+            Yt(e, s, t.closeButtonEvents.bind(t));
+          }), Yt(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 = ot().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: nt, isFirefox: te } = x(), { createElement: q, isArray: Ft, isObject: Rt, objectEach: ie, pick: ee, stableSort: se } = x();
+      function Ut(o, t, i, e, s, n) {
+        let a, r;
+        if (!t) return;
+        let h = this.addInput, c = this.lang;
+        ie(e, (l, g) => {
+          a = i !== "" ? i + "." + g : g, Rt(l) && (!Ft(l) || Ft(l) && Rt(l[0]) ? ((r = c[g] || g).match(/\d/g) || s.push([!0, r, o]), Ut.call(this, o, t, a, l, s, !1)) : s.push([this, a, "annotation", o, l]));
+        }), n && (se(s, (l) => l[1].match(/format/g) ? -1 : 1), te && s.reverse(), s.forEach((l) => {
+          l[0] === !0 ? q("span", { className: "highcharts-annotation-title" }, void 0, l[2]).appendChild(nt.createTextNode(l[1])) : (l[4] = { value: l[4][0], type: l[4][1] }, h.apply(l[0], l.splice(1)));
+        }));
+      }
+      let { doc: V } = x(), { seriesTypes: Wt } = wt(), { addEvent: at, createElement: k, defined: G, isArray: rt, isObject: oe, objectEach: jt, stableSort: ne } = x();
+      (function(o) {
+        o[o["params.algorithm"] = 0] = "params.algorithm", o[o["params.average"] = 1] = "params.average";
+      })(Q || (Q = {}));
+      let ae = { "algorithm-pivotpoints": ["standard", "fibonacci", "camarilla"], "average-disparityindex": ["sma", "ema", "dema", "tema", "wma"] };
+      function qt(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 re(o, t, i, e) {
+        let s = t.params || t.options.params;
+        e.innerHTML = ot().emptyHTML, k("h3", { className: "highcharts-indicator-title" }, void 0, e).appendChild(V.createTextNode(Gt(t, i).indicatorFullName)), k("input", { type: "hidden", name: "highcharts-type-" + i, value: i }, void 0, e), Kt.call(this, i, "series", o, e, t, t.linkedParent && t.linkedParent.options.id), s.volumeSeriesID && Kt.call(this, i, "volume", o, e, t, t.linkedParent && s.volumeSeriesID), Ht.call(this, o, "params", s, i, e);
+      }
+      function ht(o, t, i, e) {
+        function s(u, m) {
+          let y = p.parentNode.children[1];
+          re.call(n, o, u, m, p), y && (y.style.display = "block"), c && u.options && k("input", { type: "hidden", name: "highcharts-id-" + m, value: u.options.id }, void 0, p).setAttribute("highcharts-data-series-id", u.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, f = [];
+        c || rt(l) ? rt(l) && (f = ce.call(this, l)) : f = le.call(this, l, e), ne(f, (u, m) => {
+          let y = u.indicatorFullName.toLowerCase(), v = m.indicatorFullName.toLowerCase();
+          return y < v ? -1 : +(y > v);
+        }), r.children[1] && r.children[1].remove();
+        let d = k("ul", { className: "highcharts-indicator-list" }, void 0, r), p = h.querySelectorAll(".highcharts-popup-rhs-col-wrapper")[0];
+        if (f.forEach((u) => {
+          let { indicatorFullName: m, indicatorType: y, series: v } = u;
+          g = k("li", { className: "highcharts-indicator-list" }, void 0, d);
+          let b = k("button", { className: "highcharts-indicator-list-item", textContent: m }, void 0, g);
+          ["click", "touchstart"].forEach((D) => {
+            at(b, D, function() {
+              s(v, y);
+            });
+          });
+        }), f.length > 0) {
+          let { series: u, indicatorType: m } = f[0];
+          s(u, m);
+        } else c || (ot().setElementHTML(p.parentNode.children[0], a.noFilterMatch || ""), p.parentNode.children[1].style.display = "none");
+      }
+      function Ht(o, t, i, e, s) {
+        if (!o) return;
+        let n = this.addInput;
+        jt(i, (a, r) => {
+          let h = t + "." + r;
+          if (G(a) && h)
+            if (oe(a) && (n.call(this, h, e, s, {}), Ht.call(this, o, h, a, e, s)), h in Q) {
+              let c = zt.call(this, e, h, s);
+              Vt.call(this, o, t, c, e, r, a);
+            } else h === "params.volumeSeriesID" || rt(a) || n.call(this, h, e, s, { value: a, type: "number" });
+        });
+      }
+      function he(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) {
+          ht.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"), at(r, "input", function() {
+          a(this.value), this.value.length ? h.style.display = "inline-block" : h.style.display = "none";
+        }), ["click", "touchstart"].forEach((c) => {
+          at(h, c, function() {
+            r.value = "", a(""), h.style.display = "none";
+          });
+        });
+      }
+      function zt(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(V.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 Vt(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(V.createTextNode(c)));
+        }) : e && s && ae[s + "-" + e].forEach((r) => {
+          k("option", { value: r }, void 0, i).appendChild(V.createTextNode(r));
+        }), G(n) && (i.value = n);
+      }
+      function le(o, t) {
+        let i, e = this.chart && this.chart.options.lang, s = e && e.navigation && e.navigation.popup && e.navigation.popup.indicatorAliases, n = [];
+        return jt(o, (a, r) => {
+          let h = a && a.options;
+          if (a.params || h && h.params) {
+            let { indicatorFullName: c, indicatorType: l } = Gt(a, r);
+            if (t) {
+              let g = RegExp(t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i"), f = s && s[l] && s[l].join(" ") || "";
+              (c.match(g) || f.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 ce(o) {
+        let t = [];
+        return o.forEach((i) => {
+          i.is("sma") && t.push({ indicatorFullName: i.name, indicatorType: i.type, series: i });
+        }), t;
+      }
+      function Gt(o, t) {
+        let i = o.options, e = Wt[t] && Wt[t].prototype.nameBase || t.toUpperCase(), s = t;
+        return i && i.type && (s = o.options.type, e = o.name), { indicatorFullName: e, indicatorType: s };
+      }
+      function Kt(o, t, i, e, s, n) {
+        if (!i) return;
+        let a = zt.call(this, o, t, e);
+        Vt.call(this, i, t, a, void 0, void 0, void 0, s), G(n) && (a.value = n);
+      }
+      let { doc: pe } = x(), { addEvent: de, createElement: $t } = x();
+      function Zt() {
+        return $t("div", { className: "highcharts-tab-item-content highcharts-no-mousewheel" }, void 0, this.container);
+      }
+      function _t(o, t) {
+        let i = this.container, e = this.lang, s = "highcharts-tab-item";
+        t === 0 && (s += " highcharts-tab-disabled");
+        let n = $t("button", { className: s }, void 0, i);
+        return n.appendChild(pe.createTextNode(e[o + "Button"] || o)), n.setAttribute("highcharts-data-tab-type", o), n;
+      }
+      function ue() {
+        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 Jt(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 ge(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) => {
+            de(i, s, function() {
+              ue.call(t), Jt.call(t, this, e);
+            });
+          });
+        });
+      }
+      let { doc: lt } = x(), { getOptions: fe } = x(), { addEvent: ct, createElement: pt, extend: me, fireEvent: Qt, pick: xe } = x();
+      class ti extends Qi {
+        constructor(t, i, e) {
+          super(t, i), this.chart = e, this.lang = (fe().lang.navigation || {}).popup || {}, ct(this.container, "mousedown", () => {
+            let s = e && e.navigationBindings && e.navigationBindings.activeAnnotation;
+            if (s) {
+              s.cancelClick = !0;
+              let n = ct(lt, "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 + "-" + xe(s.htmlFor, a);
+          a.match(/^\d+$/) || pt("label", { htmlFor: h, className: s.labelClassName }, void 0, e).appendChild(lt.createTextNode(r[a] || a));
+          let c = pt("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;
+            Qt(t, "closePopup"), t && t.selectedButtonElement && Qt(t, "deselectButton", { button: t.selectedButtonElement });
+          } else super.closeButtonEvents();
+        }
+        addButton(t, i, e, s, n) {
+          let a = pt("button", void 0, void 0, t);
+          return a.appendChild(lt.createTextNode(i)), n && ["click", "touchstart"].forEach((r) => {
+            ct(a, r, () => (this.closePopup(), n(function(h, c) {
+              let l = Array.prototype.slice.call(h.querySelectorAll("input")), g = Array.prototype.slice.call(h.querySelectorAll("select")), f = h.querySelectorAll("#highcharts-select-series > option:checked")[0], d = h.querySelectorAll("#highcharts-select-volume > option:checked")[0], p = { actionType: c, linkedTo: f && f.getAttribute("value") || "", fields: {} };
+              return l.forEach((u) => {
+                let m = u.getAttribute("highcharts-data-name");
+                u.getAttribute("highcharts-data-series-id") ? p.seriesId = u.value : m ? p.fields[m] = u.value : p.type = u.value;
+              }), g.forEach((u) => {
+                let m = u.id;
+                if (m !== "highcharts-select-series" && m !== "highcharts-select-volume") {
+                  let y = m.split("highcharts-select-")[1];
+                  p.fields[y] = u.value;
+                }
+              }), d && (p.fields["params.volumeSeriesID"] = d.getAttribute("value") || ""), p;
+            }(s, e))));
+          }), 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");
+        }
+      }
+      me(ti.prototype, { annotations: { addForm: function(o, t, i, e) {
+        if (!o) return;
+        let s = this.container, n = this.lang, a = q("h2", { className: "highcharts-popup-main-title" }, void 0, s);
+        a.appendChild(nt.createTextNode(n[t.langKey] || t.langKey || "")), a = q("div", { className: "highcharts-popup-lhs-col highcharts-popup-lhs-full" }, void 0, s);
+        let r = q("div", { className: "highcharts-popup-bottom-row" }, void 0, s);
+        Ut.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 = q("p", { className: "highcharts-annotation-label" }, void 0, s);
+        r.setAttribute("aria-label", "Annotation type"), r.appendChild(nt.createTextNode(ee(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", h.style["background-image"] = "url(" + this.iconsURL + "edit.svg)", h = this.addButton(s, e.removeButton || "Remove", "remove", s, i), h.className += " highcharts-annotation-remove-button", h.style["background-image"] = "url(" + this.iconsURL + "destroy.svg)";
+      } }, 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");
+        qt(n[0]), he.call(this, o, n[0]), ht.call(this, o, n[0], "add"), e = n[0].querySelectorAll(".highcharts-popup-rhs-col")[0], this.addButton(e, s.addButton || "add", "add", e, i), qt(n[1]), ht.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 = _t.call(this, "add");
+        _t.call(this, "edit", t), Zt.call(this), Zt.call(this), ge.call(this, t), Jt.call(this, i, 0);
+      } } });
+      let { composed: ye } = x(), { addEvent: ii, pushUnique: ve, wrap: be } = x();
+      function Ae() {
+        this.popup && this.popup.closePopup();
+      }
+      function ke(o) {
+        this.popup || (this.popup = new ti(this.chart.container, this.chart.options.navigation.iconsURL || this.chart.options.stockTools && this.chart.options.stockTools.gui.iconsURL || "https://code.highcharts.com/12.2.0/gfx/stock-icons/", this.chart)), this.popup.showForm(o.formType, this.chart, o.options, o.onSubmit);
+      }
+      function we(o, t) {
+        this.inClass(t.target, "highcharts-popup") || o.apply(this, Array.prototype.slice.call(arguments, 1));
+      }
+      let Ee = { compose: function(o, t) {
+        ve(ye, "Popup") && (ii(o, "closePopup", Ae), ii(o, "showPopup", ke), be(t.prototype, "onContainerMouseDown", we));
+      } }, { getDeferredAnimation: Pe } = x(), { destroyObjectProperties: Ce, erase: ei, fireEvent: si, merge: L, pick: dt, splat: Oe } = x();
+      function ut(o, t) {
+        let i = {};
+        return ["labels", "shapes"].forEach((e) => {
+          let s = o[e], n = t[e];
+          s && (n ? i[e] = Oe(n).map((a, r) => L(s[r], a)) : i[e] = o[e]);
+        }), i;
+      }
+      class w extends At {
+        static compose(t, i, e, s) {
+          Ci.compose(w, t, e), P.compose(s), R.compose(t, s), i.compose(w, t), Ee.compose(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.options = L(this.defaultOptions, i), this.userOptions = i;
+          let e = ut(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);
+            L(!0, t[e], s.options);
+          });
+        }
+        addShapes() {
+          let t = this.options.shapes || [];
+          t.forEach((i, e) => {
+            let s = this.initShape(i, e);
+            L(!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, ei(t.labelCollectors, this.labelCollector), super.destroy(), this.destroyControlTarget(), Ce(this, t);
+        }
+        destroyItem(t) {
+          ei(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 = ut(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 = Pe(s, n);
+        }
+        initLabel(t, i) {
+          let e = new P(this, L(this.options.labelOptions, { controlPointOptions: this.options.controlPointOptions }, t), i);
+          return e.itemType = "label", this.labels.push(e), e;
+        }
+        initShape(t, i) {
+          let e = L(this.options.shapeOptions, { controlPointOptions: this.options.controlPointOptions }, t), s = new w.shapesMap[e.type](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) {
+          t.linkPoints(), t.shouldBeDrawn() ? (t.graphic || this.renderItem(t), t.redraw(dt(i, !0) && t.graphic.placed), t.points.length && function(e) {
+            let s = e.graphic, n = e.points.some((a) => a.series.visible !== !1 && a.visible !== !1);
+            s && (n ? s.visibility === "hidden" && s.show() : s.hide());
+          }(t)) : 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").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 || []).concat(this.options.shapes || []).reduce((s, n) => {
+            let a = n && (n.point || n.points && 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) {
+          this.options = L(this.defaultOptions, t);
+        }
+        setVisibility(t) {
+          let i = this.options, e = this.chart.navigationBindings, s = dt(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" && si(e, "closePopup");
+          }
+          i.visible = s;
+        }
+        update(t, i) {
+          let e = this.chart, s = ut(this.userOptions, t), n = e.annotations.indexOf(this), a = L(!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, dt(i, !0) && e.drawAnnotations(), si(this, "afterUpdate"), this.isUpdating = !1;
+        }
+      }
+      w.ControlPoint = kt, w.MockPoint = Y, w.shapesMap = { rect: Mt, circle: Nt, ellipse: Tt, path: R, image: St }, w.types = {}, w.prototype.defaultOptions = { 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 Oi(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: {}, zIndex: 6 }, w.prototype.nonDOMEvents = ["add", "afterUpdate", "drag", "remove"], Et.compose(w), function(o) {
+        o.compose = function(i) {
+          return i.navigation || (i.navigation = new t(i)), i;
+        };
+        class t {
+          constructor(e) {
+            this.updates = [], this.chart = e;
+          }
+          addUpdate(e) {
+            this.chart.navigation.updates.push(e);
+          }
+          update(e, s) {
+            this.updates.forEach((n) => {
+              n.call(this.chart, e, s);
+            });
+          }
+        }
+        o.Additions = t;
+      }(tt || (tt = {}));
+      let Be = tt, { defined: Me, isNumber: oi, pick: Ne } = x(), Te = { backgroundColor: "string", borderColor: "string", borderRadius: "string", color: "string", fill: "string", fontSize: "string", labels: "string", name: "string", stroke: "string", title: "string" }, ni = { getAssignedAxis: function(o) {
+        return o.filter((t) => {
+          let i = t.axis.getExtremes(), e = i.min, s = i.max, n = Ne(t.axis.minPointOffset, 0);
+          return oi(e) && oi(s) && t.value >= e - n && t.value <= s + n && !t.axis.options.isInternal;
+        })[0];
+      }, getFieldType: function(o, t) {
+        let i = Te[o], e = typeof t;
+        return Me(i) && (e = i), { string: "text", number: "number", boolean: "checkbox" }[e];
+      } }, { getAssignedAxis: C } = ni, { isNumber: ai, merge: K } = x(), De = { 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 && C(t.xAxis), e = t && C(t.yAxis), s = this.chart.options.navigation;
+        if (i && e) return this.chart.addAnnotation(K({ 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 (ai(s.xAxis) && ai(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 && C(t.xAxis), e = t && C(t.yAxis), s = this.chart.options.navigation;
+        if (i && e) return this.chart.addAnnotation(K({ 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 && C(t.xAxis), e = t && C(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(K({ 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 && C(s.xAxis), a = s && C(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 && C(t.xAxis), e = t && C(t.yAxis), s = this.chart.options.navigation;
+        if (i && e) return this.chart.addAnnotation(K({ 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: Le } = x(), { format: Ie } = Dt(), { composed: Se, doc: Ye, win: Xe } = x(), { getAssignedAxis: ri, getFieldType: hi } = ni, { addEvent: O, attr: Fe, defined: Re, fireEvent: X, isArray: gt, isFunction: Ue, isNumber: We, isObject: li, merge: ci, objectEach: M, pick: pi, pushUnique: je } = x();
+      function qe() {
+        this.chart.navigationBindings && this.chart.navigationBindings.deselectAnnotation();
+      }
+      function He() {
+        this.navigationBindings && this.navigationBindings.destroy();
+      }
+      function ze() {
+        let o = this.options;
+        o && o.navigation && o.navigation.bindings && (this.navigationBindings = new N(this, o.navigation), this.navigationBindings.initEvents(), this.navigationBindings.initUpdate());
+      }
+      function Ve() {
+        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];
+            M(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 Ge() {
+        this.deselectAnnotation();
+      }
+      function Ke() {
+        this.selectedButtonElement = null;
+      }
+      function di(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), X(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);
+            }
+          } })) : X(r, "closePopup"), n.activeAnnotation = !0;
+        }
+        ci(!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 N {
+        static compose(t, i) {
+          je(Se, "NavigationBindings") && (O(t, "remove", qe), di(t), M(t.types, (e) => {
+            di(e);
+          }), O(i, "destroy", He), O(i, "load", ze), O(i, "render", Ve), O(N, "closePopup", Ge), O(N, "deselectButton", Ke), Le(De));
+        }
+        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 = Ye.getElementsByClassName(this.options.bindingsClassName || ""));
+        }
+        getCoords(t) {
+          let i = this.chart.pointer?.getCoordinates(t);
+          return [i && ri(i.xAxis), i && ri(i.yAxis)];
+        }
+        initEvents() {
+          let t = this, i = t.chart, e = t.container, s = t.options;
+          t.boundClassNames = {}, M(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);
+            }));
+          }), M(s.events || {}, (n, a) => {
+            Ue(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, x().isTouchDevice ? "touchmove" : "mousemove", function(n) {
+            t.bindingsContainerMouseMove(this, n);
+          }, x().isTouchDevice ? { passive: !1 } : void 0));
+        }
+        initUpdate() {
+          let t = this;
+          Be.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), X(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, X(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 = Xe.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) : X(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] : (X(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]) : (X(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 M(t, (e, s) => {
+            let n = parseFloat(e), a = s.split("."), r = a.length - 1;
+            if (!We(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 = pi(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 = N.annotationsEditable, s = e.nestedOptions, n = pi(i.type, i.shapes && i.shapes[0] && i.shapes[0].type, i.labels && i.labels[0] && i.labels[0].type, "label"), a = N.annotationsNonEditable[i.langKey] || [], r = { langKey: i.langKey, type: n };
+          function h(c, l, g, f, d) {
+            let p;
+            g && Re(c) && a.indexOf(l) === -1 && ((g.indexOf && g.indexOf(l)) >= 0 || g[l] || g === !0) && (gt(c) ? (f[l] = [], c.forEach((u, m) => {
+              li(u) ? (f[l][m] = {}, M(u, (y, v) => {
+                h(y, v, s[l], f[l][m], l);
+              })) : h(u, 0, s[l], f[l], l);
+            })) : li(c) ? (p = {}, gt(f) ? (f.push(p), p[l] = {}, p = p[l]) : f[l] = p, M(c, (u, m) => {
+              h(u, m, l === 0 ? g : s[l], p, l);
+            })) : l === "format" ? f[l] = [Ie(c, t.labels[0].points[0]).toString(), "text"] : gt(f) ? f.push([c, hi(d, c)]) : f[l] = [c, hi(l, c)]);
+          }
+          return M(i, (c, l) => {
+            l === "typeOptions" ? (r[l] = {}, M(i[l], (g, f) => {
+              h(g, f, s, r[l], f);
+            })) : h(c, l, e[n], r, l);
+          }), r;
+        }
+        getClickedClassNames(t, i) {
+          let e = i.target, s = [], n;
+          for (; e && e.tagName && ((n = Fe(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 = ci(!0, this.options, t), this.removeEvents(), this.initEvents();
+        }
+        removeEvents() {
+          this.eventsToUnbind.forEach((t) => t());
+        }
+        destroy() {
+          this.removeEvents();
+        }
+      }
+      N.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"] }, N.annotationsNonEditable = { rectangle: ["crosshairX", "crosshairY", "labelOptions"], ellipse: ["labelOptions"], circle: ["labelOptions"] };
+      let T = x();
+      T.Annotation = T.Annotation || w, T.NavigationBindings = T.NavigationBindings || N, T.Annotation.compose(T.Chart, T.NavigationBindings, T.Pointer, T.SVGRenderer);
+      let $e = x();
+      return mt.default;
+    })());
+  }($)), $.exports;
+}
+var gi = Qe();
+const ts = /* @__PURE__ */ Ze(gi), es = /* @__PURE__ */ _e({
+  __proto__: null,
+  default: ts
+}, [gi]);
+export {
+  es as a
+};