@mobileaction/action-kit 1.58.14 → 1.58.15

package/dist/map-BoKWY9W5.js

@@ -0,0 +1,1731 @@
+import { g as ar } from "./index-DWdWcgJ-.js";
+function nr(ne, $e) {
+  for (var S = 0; S < $e.length; S++) {
+    const Y = $e[S];
+    if (typeof Y != "string" && !Array.isArray(Y)) {
+      for (const Z in Y)
+        if (Z !== "default" && !(Z in ne)) {
+          const le = Object.getOwnPropertyDescriptor(Y, Z);
+          le && Object.defineProperty(ne, Z, le.get ? le : {
+            enumerable: !0,
+            get: () => Y[Z]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(ne, Symbol.toStringTag, { value: "Module" }));
+}
+var He = { exports: {} }, lr = He.exports, Pi;
+function hr() {
+  return Pi || (Pi = 1, (function(ne, $e) {
+    /**
+    * Highmaps JS v12.5.0 (2026-01-12)
+    * @module highcharts/modules/map
+    * @requires highcharts
+    *
+    * Highmaps as a plugin for Highcharts or Highcharts Stock.
+    *
+    * (c) 2011-2026 Highsoft AS
+    * Author: Torstein Honsi
+    *
+    * A commercial license may be required depending on use.
+    * See www.highcharts.com/license
+    */
+    (function(S, Y) {
+      ne.exports = Y(S._Highcharts, S._Highcharts.Axis, S._Highcharts.Color, S._Highcharts.LegendSymbol, S._Highcharts.SeriesRegistry, S._Highcharts.SVGElement, S._Highcharts.Series, S._Highcharts.Chart, S._Highcharts.SVGRenderer, S._Highcharts.Templating, S._Highcharts.Series.types.scatter, S._Highcharts.Point);
+    })("u" < typeof window ? lr : window, (S, Y, Z, le, Li, Ai, ji, ki, zi, Si, Ii, Bi) => (() => {
+      let Pe;
+      var Te, Ct, Le, Ae, Ke, qe, _e, Je, Qe, et, tt, Ei = { 28: (l) => {
+        l.exports = Ai;
+      }, 260: (l) => {
+        l.exports = Bi;
+      }, 500: (l) => {
+        l.exports = le;
+      }, 512: (l) => {
+        l.exports = Li;
+      }, 532: (l) => {
+        l.exports = Y;
+      }, 540: (l) => {
+        l.exports = zi;
+      }, 620: (l) => {
+        l.exports = Z;
+      }, 632: (l) => {
+        l.exports = Ii;
+      }, 820: (l) => {
+        l.exports = ji;
+      }, 944: (l) => {
+        l.exports = S;
+      }, 960: (l) => {
+        l.exports = ki;
+      }, 984: (l) => {
+        l.exports = Si;
+      } }, Pt = {};
+      function C(l) {
+        var e = Pt[l];
+        if (e !== void 0) return e.exports;
+        var t = Pt[l] = { exports: {} };
+        return Ei[l](t, t.exports, C), t.exports;
+      }
+      C.n = (l) => {
+        var e = l && l.__esModule ? () => l.default : () => l;
+        return C.d(e, { a: e }), e;
+      }, C.d = (l, e) => {
+        for (var t in e) C.o(e, t) && !C.o(l, t) && Object.defineProperty(l, t, { enumerable: !0, get: e[t] });
+      }, C.o = (l, e) => Object.prototype.hasOwnProperty.call(l, e);
+      var Tt = {};
+      C.d(Tt, { default: () => sr });
+      var Di = C(944), v = C.n(Di), Oi = C(532), Lt = C.n(Oi), Vi = C(620), it = C.n(Vi);
+      let { parse: st } = it(), { merge: Ni } = v();
+      (Te = Ke || (Ke = {})).initDataClasses = function(l) {
+        let e = this.chart, t = this.legendItem = this.legendItem || {}, i = this.options, o = l.dataClasses || [], r, a, s = e.options.chart.colorCount, n = 0, h;
+        this.dataClasses = a = [], t.labels = [];
+        for (let p = 0, d = o.length; p < d; ++p) r = Ni(r = o[p]), a.push(r), (e.styledMode || !r.color) && (i.dataClassColor === "category" ? (e.styledMode || (s = (h = e.options.colors || []).length, r.color = h[n]), r.colorIndex = n, ++n === s && (n = 0)) : r.color = st(i.minColor).tweenTo(st(i.maxColor), d < 2 ? 0.5 : p / (d - 1)));
+      }, Te.initStops = function() {
+        let l = this.options, e = this.stops = l.stops || [[0, l.minColor || ""], [1, l.maxColor || ""]];
+        for (let t = 0, i = e.length; t < i; ++t) e[t].color = st(e[t][1]);
+      }, Te.normalizedValue = function(l) {
+        let e = this.max || 0, t = this.min || 0;
+        return this.logarithmic && (l = this.logarithmic.log2lin(l)), 1 - (e - l) / (e - t || 1);
+      }, Te.toColor = function(l, e) {
+        let t, i, o, r, a, s, n = this.dataClasses, h = this.stops;
+        if (n) {
+          for (s = n.length; s--; ) if (i = (a = n[s]).from, o = a.to, (i === void 0 || l >= i) && (o === void 0 || l <= o)) {
+            r = a.color, e && (e.dataClass = s, e.colorIndex = a.colorIndex);
+            break;
+          }
+        } else {
+          for (t = this.normalizedValue(l), s = h.length; s-- && !(t > h[s][0]); ) ;
+          i = h[s] || h[s + 1], t = 1 - ((o = h[s + 1] || i)[0] - t) / (o[0] - i[0] || 1), r = i.color.tweenTo(o.color, t);
+        }
+        return r;
+      };
+      let Xi = Ke, { parse: je } = it(), { addEvent: Q, extend: At, merge: Yi, pick: Gi, splat: Ri } = v();
+      (function(l) {
+        let e;
+        function t() {
+          let { userOptions: c } = this;
+          this.colorAxis = [], c.colorAxis && (c.colorAxis = Ri(c.colorAxis), c.colorAxis.map((m) => new e(this, m)));
+        }
+        function i(c) {
+          let m = this.chart.colorAxis || [], f = (b) => {
+            let x = c.allItems.indexOf(b);
+            x !== -1 && (this.destroyItem(c.allItems[x]), c.allItems.splice(x, 1));
+          }, u = [], g, y;
+          for (m.forEach(function(b) {
+            g = b.options, g?.showInLegend && (g.dataClasses && g.visible ? u = u.concat(b.getDataClassLegendSymbols()) : g.visible && u.push(b), b.series.forEach(function(x) {
+              (!x.options.showInLegend || g.dataClasses) && (x.options.legendType === "point" ? x.points.forEach(function(M) {
+                f(M);
+              }) : f(x));
+            }));
+          }), y = u.length; y--; ) c.allItems.unshift(u[y]);
+        }
+        function o(c) {
+          c.visible && c.item.legendColor && c.item.legendItem.symbol.attr({ fill: c.item.legendColor });
+        }
+        function r(c) {
+          this.chart.colorAxis?.forEach((m) => {
+            m.update({}, c.redraw);
+          });
+        }
+        function a() {
+          (this.chart.colorAxis?.length || this.colorAttribs) && this.translateColors();
+        }
+        function s() {
+          let c = this.axisTypes;
+          c ? c.indexOf("colorAxis") === -1 && c.push("colorAxis") : this.axisTypes = ["colorAxis"];
+        }
+        function n(c) {
+          let m = this, f = c ? "show" : "hide";
+          m.visible = m.options.visible = !!c, ["graphic", "dataLabel"].forEach(function(u) {
+            m[u] && m[u][f]();
+          }), this.series.buildKDTree();
+        }
+        function h() {
+          let c = this, m = this.getPointsCollection(), f = this.options.nullColor, u = this.colorAxis, g = this.colorKey;
+          m.forEach((y) => {
+            let b = y.getNestedProperty(g), x = y.options.color || (y.isNull || y.value === null ? f : u && b !== void 0 ? u.toColor(b, y) : y.color || c.color);
+            x && y.color !== x && (y.color = x, c.options.legendType === "point" && y.legendItem && y.legendItem.label && c.chart.legend.colorizeItem(y, y.visible));
+          });
+        }
+        function p() {
+          this.elem.attr("fill", je(this.start).tweenTo(je(this.end), this.pos), void 0, !0);
+        }
+        function d() {
+          this.elem.attr("stroke", je(this.start).tweenTo(je(this.end), this.pos), void 0, !0);
+        }
+        l.compose = function(c, m, f, u, g) {
+          var y;
+          let b, x = m.prototype, M = f.prototype, w = g.prototype;
+          x.collectionsWithUpdate.includes("colorAxis") || (e = c, x.collectionsWithUpdate.push("colorAxis"), x.collectionsWithInit.colorAxis = [x.addColorAxis], Q(m, "afterCreateAxes", t), b = (y = m).prototype.createAxis, y.prototype.createAxis = function(P, j) {
+            if (P !== "colorAxis") return b.apply(this, arguments);
+            let L = new e(this, Yi(j.axis, { index: this[P].length, isX: !1 }));
+            return this.isDirtyLegend = !0, this.axes.forEach((T) => {
+              T.series = [];
+            }), this.series.forEach((T) => {
+              T.bindAxes(), T.isDirtyData = !0;
+            }), Gi(j.redraw, !0) && this.redraw(j.animation), L;
+          }, M.fillSetter = p, M.strokeSetter = d, Q(u, "afterGetAllItems", i), Q(u, "afterColorizeItem", o), Q(u, "afterUpdate", r), At(w, { optionalAxis: "colorAxis", translateColors: h }), At(w.pointClass.prototype, { setVisible: n }), Q(g, "afterTranslate", a, { order: 1 }), Q(g, "bindAxes", s));
+        }, l.pointSetVisible = n;
+      })(qe || (qe = {}));
+      let Fi = qe;
+      var Wi = C(500), Ui = C.n(Wi), Zi = C(512), I = C.n(Zi);
+      let { defaultOptions: ot } = v(), { series: jt } = I(), { defined: ke, extend: kt, fireEvent: Hi, isArray: $i, isNumber: Ki, merge: zt, pick: F, relativeLength: St } = v();
+      ot.colorAxis = zt(ot.xAxis, { lineWidth: 0, minPadding: 0, maxPadding: 0, gridLineColor: "#ffffff", gridLineWidth: 1, tickPixelInterval: 72, startOnTick: !0, endOnTick: !0, offset: 0, marker: { animation: { duration: 50 }, width: 0.01, color: "#999999" }, labels: { distance: 8, overflow: "justify", rotation: 0 }, minColor: "#e6e9ff", maxColor: "#0022ff", tickLength: 5, showInLegend: !0 });
+      class O extends Lt() {
+        static compose(e, t, i, o) {
+          Fi.compose(O, e, t, i, o);
+        }
+        constructor(e, t) {
+          super(e, t), this.coll = "colorAxis", this.visible = !0, this.init(e, t);
+        }
+        init(e, t) {
+          let i = e.options.legend || {}, o = t.layout ? t.layout !== "vertical" : i.layout !== "vertical";
+          this.side = t.side || o ? 2 : 1, this.reversed = t.reversed, this.opposite = !o, super.init(e, t, "colorAxis"), this.userOptions = t, $i(e.userOptions.colorAxis) && (e.userOptions.colorAxis[this.index] = t), t.dataClasses && this.initDataClasses(t), this.initStops(), this.horiz = o, this.zoomEnabled = !1;
+        }
+        hasData() {
+          return !!(this.tickPositions || []).length;
+        }
+        setTickPositions() {
+          if (!this.dataClasses) return super.setTickPositions();
+        }
+        setOptions(e) {
+          let t = zt(ot.colorAxis, e, { showEmpty: !1, title: null, visible: this.chart.options.legend.enabled && e.visible !== !1 });
+          super.setOptions(t), this.options.crosshair = this.options.marker;
+        }
+        setAxisSize() {
+          let e = this.chart, t = this.legendItem?.symbol, { width: i, height: o } = this.getSize();
+          t && (this.left = +t.attr("x"), this.top = +t.attr("y"), this.width = i = +t.attr("width"), this.height = o = +t.attr("height"), this.right = e.chartWidth - this.left - i, this.bottom = e.chartHeight - this.top - o, this.pos = this.horiz ? this.left : this.top), this.len = (this.horiz ? i : o) || O.defaultLegendLength;
+        }
+        getOffset() {
+          let e = this.legendItem?.group, t = this.chart.axisOffset[this.side];
+          if (e) {
+            this.axisParent = e, super.getOffset();
+            let i = this.chart.legend;
+            i.allItems.forEach(function(o) {
+              o instanceof O && o.drawLegendSymbol(i, o);
+            }), i.render(), this.chart.getMargins(!0), this.chart.series.some((o) => o.isDrilling) || (this.isDirty = !0), this.added || (this.added = !0), this.labelLeft = 0, this.labelRight = this.width, this.chart.axisOffset[this.side] = t;
+          }
+        }
+        setLegendColor() {
+          let e = this.horiz, t = this.reversed, i = +!!t, o = +!t, r = e ? [i, 0, o, 0] : [0, o, 0, i];
+          this.legendColor = { linearGradient: { x1: r[0], y1: r[1], x2: r[2], y2: r[3] }, stops: this.stops };
+        }
+        drawLegendSymbol(e, t) {
+          let i = t.legendItem || {}, o = e.padding, r = e.options, a = this.options.labels, s = F(r.itemDistance, 10), n = this.horiz, { width: h, height: p } = this.getSize(), d = F(r.labelPadding, n ? 16 : 30);
+          this.setLegendColor(), i.symbol || (i.symbol = this.chart.renderer.symbol("roundedRect").attr({ r: r.symbolRadius ?? 3, zIndex: 1 }).add(i.group)), i.symbol.attr({ x: 0, y: (e.baseline || 0) - 11, width: h, height: p }), i.labelWidth = h + o + (n ? s : F(a.x, a.distance) + (this.maxLabelLength || 0)), i.labelHeight = p + o + (n ? d : 0);
+        }
+        setState(e) {
+          this.series.forEach(function(t) {
+            t.setState(e);
+          });
+        }
+        setVisible() {
+        }
+        getSeriesExtremes() {
+          let e = this.series, t, i, o, r, a = e.length;
+          for (this.dataMin = 1 / 0, this.dataMax = -1 / 0; a--; ) {
+            for (let s of (i = (r = e[a]).colorKey = F(r.options.colorKey, r.colorKey, r.pointValKey, r.zoneAxis, "y"), o = r[i + "Min"] && r[i + "Max"], [i, "value", "y"])) if ((t = r.getColumn(s)).length) break;
+            if (o) r.minColorValue = r[i + "Min"], r.maxColorValue = r[i + "Max"];
+            else {
+              let s = jt.prototype.getExtremes.call(r, t);
+              r.minColorValue = s.dataMin, r.maxColorValue = s.dataMax;
+            }
+            ke(r.minColorValue) && ke(r.maxColorValue) && (this.dataMin = Math.min(this.dataMin, r.minColorValue), this.dataMax = Math.max(this.dataMax, r.maxColorValue)), o || jt.prototype.applyExtremes.call(r);
+          }
+        }
+        drawCrosshair(e, t) {
+          let i, o = this.legendItem || {}, r = t?.plotX, a = t?.plotY, s = this.pos, n = this.len;
+          t && ((i = this.toPixels(t.getNestedProperty(t.series.colorKey))) < s ? i = s - 2 : i > s + n && (i = s + n + 2), t.plotX = i, t.plotY = this.len - i, super.drawCrosshair(e, t), t.plotX = r, t.plotY = a, this.cross && !this.cross.addedToColorAxis && o.group && (this.cross.addClass("highcharts-coloraxis-marker").add(o.group), this.cross.addedToColorAxis = !0, this.chart.styledMode || typeof this.crosshair != "object" || this.cross.attr({ fill: this.crosshair.color })));
+        }
+        getPlotLinePath(e) {
+          let t = this.left, i = e.translatedValue, o = this.top;
+          return Ki(i) ? this.horiz ? [["M", i - 4, o - 6], ["L", i + 4, o - 6], ["L", i, o], ["Z"]] : [["M", t, i], ["L", t - 6, i + 6], ["L", t - 6, i - 6], ["Z"]] : super.getPlotLinePath(e);
+        }
+        update(e, t) {
+          let i = this.chart.legend;
+          this.series.forEach((o) => {
+            o.isDirtyData = !0;
+          }), (e.dataClasses && i.allItems || this.dataClasses) && this.destroyItems(), super.update(e, t), this.legendItem?.label && (this.setLegendColor(), i.colorizeItem(this, !0));
+        }
+        destroyItems() {
+          let e = this.chart, t = this.legendItem || {};
+          if (t.label) e.legend.destroyItem(this);
+          else if (t.labels) for (let i of t.labels) e.legend.destroyItem(i);
+          e.isDirtyLegend = !0;
+        }
+        destroy() {
+          this.chart.isDirtyLegend = !0, this.destroyItems(), super.destroy(...[].slice.call(arguments));
+        }
+        remove(e) {
+          this.destroyItems(), super.remove(e);
+        }
+        getDataClassLegendSymbols() {
+          let e, t = this, i = t.chart, o = t.legendItem && t.legendItem.labels || [], r = i.options.legend, a = F(r.valueDecimals, -1), s = F(r.valueSuffix, ""), n = (h) => t.series.reduce((p, d) => (p.push(...d.points.filter((c) => c.dataClass === h)), p), []);
+          return o.length || t.dataClasses.forEach((h, p) => {
+            let d = h.from, c = h.to, { numberFormatter: m } = i, f = !0;
+            e = "", d === void 0 ? e = "< " : c === void 0 && (e = "> "), d !== void 0 && (e += m(d, a) + s), d !== void 0 && c !== void 0 && (e += " - "), c !== void 0 && (e += m(c, a) + s), o.push(kt({ chart: i, name: e, options: {}, drawLegendSymbol: Ui().rectangle, visible: !0, isDataClass: !0, setState: (u) => {
+              for (let g of n(p)) g.setState(u);
+            }, setVisible: function() {
+              this.visible = f = t.visible = !f;
+              let u = [];
+              for (let g of n(p)) g.setVisible(f), g.hiddenInDataClass = !f, u.indexOf(g.series) === -1 && u.push(g.series);
+              i.legend.colorizeItem(this, f), u.forEach((g) => {
+                Hi(g, "afterDataClassLegendClick");
+              });
+            } }, h));
+          }), o;
+        }
+        getSize() {
+          let { chart: e, horiz: t } = this, { height: i, width: o } = this.options, { legend: r } = e.options;
+          return { width: F(ke(o) ? St(o, e.chartWidth) : void 0, r?.symbolWidth, t ? O.defaultLegendLength : 12), height: F(ke(i) ? St(i, e.chartHeight) : void 0, r?.symbolHeight, t ? 12 : O.defaultLegendLength) };
+        }
+      }
+      O.defaultLegendLength = 200, O.keepProps = ["legendItem"], kt(O.prototype, Xi), Array.prototype.push.apply(Lt().keepProps, O.keepProps);
+      let H = v();
+      H.ColorAxis = H.ColorAxis || O, H.ColorAxis.compose(H.Chart, H.Fx, H.Legend, H.Series);
+      let qi = { lang: { zoomIn: "Zoom in", zoomOut: "Zoom out" }, mapNavigation: { buttonOptions: { alignTo: "plotBox", align: "left", verticalAlign: "top", x: 0, width: 18, height: 18, padding: 5, style: { color: "#666666", fontSize: "1em", fontWeight: "bold" }, theme: { fill: "#ffffff", stroke: "#e6e6e6", "stroke-width": 1, "text-align": "center" } }, buttons: { zoomIn: { onclick: function() {
+        this.mapZoom(0.5);
+      }, text: "+", y: 0 }, zoomOut: { onclick: function() {
+        this.mapZoom(2);
+      }, text: "-", y: 28 } }, mouseWheelSensitivity: 1.1 } }, { defined: _i, extend: It, pick: Ji, wrap: Bt } = v();
+      (function(l) {
+        let e, t = 0;
+        function i(s) {
+          let n = this.chart;
+          s = this.normalize(s), n.options.mapNavigation.enableDoubleClickZoomTo ? n.pointer.inClass(s.target, "highcharts-tracker") && n.hoverPoint && n.hoverPoint.zoomTo() : n.isInsidePlot(s.chartX - n.plotLeft, s.chartY - n.plotTop) && n.mapZoom(0.5, void 0, void 0, s.chartX, s.chartY);
+        }
+        function o(s) {
+          let n = this.chart, h = _i((s = this.normalize(s)).wheelDelta) && -s.wheelDelta / 120 || s.deltaY || s.detail;
+          Math.abs(h) >= 1 && (t += Math.abs(h), e && clearTimeout(e), e = setTimeout(() => {
+            t = 0;
+          }, 50)), t < 10 && n.isInsidePlot(s.chartX - n.plotLeft, s.chartY - n.plotTop) && n.mapView && n.mapView.zoomBy(-((n.options.mapNavigation.mouseWheelSensitivity - 1) * h), void 0, [s.chartX, s.chartY], !(1 > Math.abs(h)) && void 0);
+        }
+        function r(s, n, h) {
+          let p = this.chart;
+          if (n = s.call(this, n, h), p && p.mapView) {
+            let d = p.mapView.pixelsToLonLat({ x: n.chartX - p.plotLeft, y: n.chartY - p.plotTop });
+            d && It(n, d);
+          }
+          return n;
+        }
+        function a(s) {
+          let n = this.chart.options.mapNavigation;
+          n && Ji(n.enableTouchZoom, n.enabled) && (this.chart.zooming.pinchType = "xy"), s.apply(this, [].slice.call(arguments, 1));
+        }
+        l.compose = function(s) {
+          let n = s.prototype;
+          n.onContainerDblClick || (It(n, { onContainerDblClick: i, onContainerMouseWheel: o }), Bt(n, "normalize", r), Bt(n, "zoomOption", a));
+        };
+      })(_e || (_e = {}));
+      let Qi = _e;
+      function es(l, e, t, i, o) {
+        if (o) {
+          let r = o?.r || 0;
+          o.brBoxY = e - r, o.brBoxHeight = i + r;
+        }
+        return Pe.roundedRect(l, e, t, i, o);
+      }
+      function ts(l, e, t, i, o) {
+        if (o) {
+          let r = o?.r || 0;
+          o.brBoxHeight = i + r;
+        }
+        return Pe.roundedRect(l, e, t, i, o);
+      }
+      let is = function(l) {
+        (Pe = l.prototype.symbols).bottombutton = es, Pe.topbutton = ts;
+      }, { setOptions: ss } = v(), { composed: os } = v(), { addEvent: ee, extend: Et, merge: rt, objectEach: rs, pick: at, pushUnique: as } = v();
+      function nt(l) {
+        l && (l.preventDefault?.(), l.stopPropagation?.(), l.cancelBubble = !0);
+      }
+      class ze {
+        static compose(e, t, i) {
+          Qi.compose(t), is(i), as(os, "Map.Navigation") && (ee(e, "beforeRender", function() {
+            this.mapNavigation = new ze(this), this.mapNavigation.update();
+          }), ss(qi));
+        }
+        constructor(e) {
+          this.chart = e, this.navButtons = [];
+        }
+        update(e) {
+          let t = this, i = t.chart, o = t.navButtons, r = function(s) {
+            this.handler.call(i, s), nt(s);
+          }, a = i.options.mapNavigation;
+          for (e && (a = i.options.mapNavigation = rt(i.options.mapNavigation, e)); o.length; ) o.pop()?.destroy();
+          !i.renderer.forExport && at(a.enableButtons, a.enabled) && (t.navButtonsGroup || (t.navButtonsGroup = i.renderer.g().attr({ zIndex: 7 }).add()), rs(a.buttons, (s, n) => {
+            let h = { padding: (s = rt(a.buttonOptions, s)).padding };
+            !i.styledMode && s.theme && (Et(h, s.theme), h.style = rt(s.theme.style, s.style));
+            let { text: p, width: d = 0, height: c = 0, padding: m = 0 } = s, f = i.renderer.button(p !== "+" && p !== "-" && p || "", 0, 0, r, h, void 0, void 0, void 0, n === "zoomIn" ? "topbutton" : "bottombutton").addClass("highcharts-map-navigation highcharts-" + { zoomIn: "zoom-in", zoomOut: "zoom-out" }[n]).attr({ width: d, height: c, title: i.options.lang[n], zIndex: 5 }).add(t.navButtonsGroup);
+            if (p === "+" || p === "-") {
+              let u = d + 1, g = [["M", m + 3, m + c / 2], ["L", m + u - 3, m + c / 2]];
+              p === "+" && g.push(["M", m + u / 2, m + 3], ["L", m + u / 2, m + c - 3]), i.renderer.path(g).addClass("highcharts-button-symbol").attr(i.styledMode ? {} : { stroke: s.style?.color, "stroke-width": 3, "stroke-linecap": "round" }).add(f);
+            }
+            if (f.handler = s.onclick, ee(f.element, "dblclick", nt), o.push(f), Et(s, { width: f.width, height: 2 * (f.height || 0) }), i.hasLoaded) f.align(s, !1, s.alignTo);
+            else {
+              let u = ee(i, "load", () => {
+                f.element && f.align(s, !1, s.alignTo), u();
+              });
+            }
+          }), i.hasLoaded || ee(i, "render", function() {
+            let s = i.exporting?.group?.getBBox();
+            if (s) {
+              let n = t.navButtonsGroup.getBBox();
+              if (!(n.x >= s.x + s.width || n.x + n.width <= s.x || n.y >= s.y + s.height || n.y + n.height <= s.y)) {
+                let h = -n.y - n.height + s.y - 5, p = s.y + s.height - n.y + 5, d = a.buttonOptions && a.buttonOptions.verticalAlign;
+                t.navButtonsGroup.attr({ translateY: d === "bottom" ? h : p });
+              }
+            }
+          })), this.updateEvents(a);
+        }
+        updateEvents(e) {
+          let t = this.chart;
+          at(e.enableDoubleClickZoom, e.enabled) || e.enableDoubleClickZoomTo ? this.unbindDblClick = this.unbindDblClick || ee(t.container, "dblclick", function(i) {
+            t.pointer.onContainerDblClick(i);
+          }) : this.unbindDblClick && (this.unbindDblClick = this.unbindDblClick()), at(e.enableMouseWheelZoom, e.enabled) ? this.unbindMouseWheel = this.unbindMouseWheel || ee(t.container, "wheel", function(i) {
+            if (!t.pointer.inClass(i.target, "highcharts-no-mousewheel")) {
+              let o = t.mapView?.zoom;
+              t.pointer.onContainerMouseWheel(i), o !== t.mapView?.zoom && nt(i);
+            }
+            return !1;
+          }) : this.unbindMouseWheel && (this.unbindMouseWheel = this.unbindMouseWheel());
+        }
+      }
+      var ns = C(28), ls = C.n(ns);
+      let { column: { prototype: hs } } = I().seriesTypes, { addEvent: ps, defined: ds } = v();
+      var lt = Je || (Je = {});
+      function cs(l) {
+        let e = this.series, t = e.chart.renderer;
+        this.moveToTopOnHover && this.graphic && (e.stateMarkerGraphic || (e.stateMarkerGraphic = new (ls())(t, "use").css({ pointerEvents: "none" }).add(this.graphic.parentGroup)), l?.state === "hover" ? (this.graphic.attr({ id: this.id }), e.stateMarkerGraphic.attr({ href: `${t.url}#${this.id}`, visibility: "visible" })) : e.stateMarkerGraphic.attr({ href: "" }));
+      }
+      lt.pointMembers = { dataLabelOnNull: !0, moveToTopOnHover: !0, isValid: function() {
+        return this.value !== null && this.value !== 1 / 0 && this.value !== -1 / 0 && (this.value === void 0 || !isNaN(this.value));
+      } }, lt.seriesMembers = { colorKey: "value", axisTypes: ["xAxis", "yAxis", "colorAxis"], parallelArrays: ["x", "y", "value"], pointArrayMap: ["value"], trackerGroups: ["group", "markerGroup", "dataLabelsGroup"], colorAttribs: function(l) {
+        let e = {};
+        return ds(l.color) && (!l.state || l.state === "normal") && (e[this.colorProp || "fill"] = l.color), e;
+      }, pointAttribs: hs.pointAttribs }, lt.compose = function(l) {
+        return ps(l.prototype.pointClass, "afterSetState", cs), l;
+      };
+      let B = Je;
+      var us = C(820), ms = C.n(us);
+      let { deg2rad: Dt } = v(), { fireEvent: gs, isNumber: ht, pick: Se, relativeLength: fs } = v();
+      (Ct = Qe || (Qe = {})).getCenter = function() {
+        let l = this.options, e = this.chart, t = 2 * (l.slicedOffset || 0), i = e.plotWidth - 2 * t, o = e.plotHeight - 2 * t, r = l.center, a = Math.min(i, o), s = l.thickness, n, h = l.size, p = l.innerSize || 0, d, c;
+        typeof h == "string" && (h = parseFloat(h)), typeof p == "string" && (p = parseFloat(p));
+        let m = [Se(r?.[0], "50%"), Se(r?.[1], "50%"), Se(h && h < 0 ? void 0 : l.size, "100%"), Se(p && p < 0 ? void 0 : l.innerSize || 0, "0%")];
+        for (!e.angular || this instanceof ms() || (m[3] = 0), d = 0; d < 4; ++d) c = m[d], n = d < 2 || d === 2 && /%$/.test(c), m[d] = fs(c, [i, o, a, m[2]][d]) + (n ? t : 0);
+        return m[3] > m[2] && (m[3] = m[2]), ht(s) && 2 * s < m[2] && s > 0 && (m[3] = m[2] - 2 * s), gs(this, "afterGetCenter", { positions: m }), m;
+      }, Ct.getStartAndEndRadians = function(l, e) {
+        let t = ht(l) ? l : 0, i = ht(e) && e > t && e - t < 360 ? e : t + 360;
+        return { start: Dt * (t + -90), end: Dt * (i + -90) };
+      };
+      let ys = Qe;
+      var bs = C(960), xs = C.n(bs), Ms = C(540), pt = C.n(Ms);
+      let { getOptions: vs } = v(), { isNumber: he, merge: ws, pick: Ot } = v();
+      class dt extends xs() {
+        init(e, t) {
+          let i = vs().credits, o = ws({ chart: { panning: { enabled: !0, type: "xy" }, type: "map" }, credits: { mapText: Ot(i.mapText, ' © <a href="{geojson.copyrightUrl}">{geojson.copyrightShort}</a>'), mapTextFull: Ot(i.mapTextFull, "{geojson.copyright}") }, mapView: {}, tooltip: { followTouchMove: !1 } }, e);
+          super.init(o, t);
+        }
+        mapZoom(e, t, i, o, r) {
+          this.mapView && (he(e) && (e = Math.log(e) / Math.log(0.5)), this.mapView.zoomBy(e, he(t) && he(i) ? this.mapView.projection.inverse([t, i]) : void 0, he(o) && he(r) ? [o, r] : void 0));
+        }
+        update(e) {
+          e.chart && "map" in e.chart && this.mapView?.recommendMapView(this, [e.chart.map, ...(this.options.series || []).map((t) => t.mapData)], !0), super.update.apply(this, arguments);
+        }
+      }
+      (Le = dt || (dt = {})).maps = {}, Le.mapChart = function(l, e, t) {
+        return new Le(l, e, t);
+      }, Le.splitPath = function(l) {
+        let e;
+        return e = typeof l == "string" ? (l = l.replace(/([A-Z])/gi, " $1 ").replace(/^\s*/, "").replace(/\s*$/, "")).split(/[ ,;]+/).map((t) => /[A-Z]/i.test(t) ? t : parseFloat(t)) : l, pt().prototype.pathToSegments(e);
+      };
+      let Ie = dt, Vt = { boundsFromPath: function(l) {
+        let e = -Number.MAX_VALUE, t = Number.MAX_VALUE, i = -Number.MAX_VALUE, o = Number.MAX_VALUE, r;
+        if (l.forEach((a) => {
+          let s = a[a.length - 2], n = a[a.length - 1];
+          typeof s == "number" && typeof n == "number" && (t = Math.min(t, s), e = Math.max(e, s), o = Math.min(o, n), i = Math.max(i, n), r = !0);
+        }), r) return { x1: t, y1: o, x2: e, y2: i };
+      } }, { boundsFromPath: Cs } = Vt, Ps = I().seriesTypes.scatter.prototype.pointClass, { extend: Nt, isNumber: pe, pick: Xt } = v();
+      class te extends Ps {
+        static getProjectedPath(e, t) {
+          return e.projectedPath || (t && e.geometry ? (t.hasCoordinates = !0, e.projectedPath = t.path(e.geometry)) : e.projectedPath = e.path), e.projectedPath || [];
+        }
+        applyOptions(e, t) {
+          let i = this.series, o = super.applyOptions(e, t), r = i.joinBy;
+          if (i.mapData && i.mapMap) {
+            let a = r[1], s = super.getNestedProperty(a), n = s !== void 0 && i.mapMap[s];
+            n ? Nt(o, { ...n, name: o.name ?? n.name }) : i.pointArrayMap.indexOf("value") !== -1 && (o.value = o.value || null);
+          }
+          return o;
+        }
+        getProjectedBounds(e) {
+          let t = Cs(te.getProjectedPath(this, e)), i = this.properties, o = this.series.chart.mapView;
+          if (t) {
+            let r = i?.["hc-middle-lon"], a = i?.["hc-middle-lat"];
+            if (o && pe(r) && pe(a)) {
+              let s = e.forward([r, a]);
+              t.midX = s[0], t.midY = s[1];
+            } else {
+              let s = i?.["hc-middle-x"], n = i?.["hc-middle-y"];
+              t.midX = t.x1 + (t.x2 - t.x1) * Xt(this.middleX, pe(s) ? s : 0.5);
+              let h = Xt(this.middleY, pe(n) ? n : 0.5);
+              this.geometry || (h = 1 - h), t.midY = t.y2 - (t.y2 - t.y1) * h;
+            }
+            return t;
+          }
+        }
+        onMouseOver(e) {
+          v().clearTimeout(this.colorInterval), !this.isNull && this.visible || this.series.options.nullInteraction ? super.onMouseOver.call(this, e) : this.series.onMouseOut();
+        }
+        setVisible(e) {
+          this.visible = this.options.visible = !!e, this.dataLabel && this.dataLabel[e ? "show" : "hide"](), this.graphic && this.graphic.attr(this.series.pointAttribs(this));
+        }
+        zoomTo(e) {
+          let t = this.series.chart, i = t.mapView, o = this.bounds;
+          if (i && o) {
+            let r = pe(this.insetIndex) && i.insets[this.insetIndex];
+            if (r) {
+              let a = r.projectedUnitsToPixels({ x: o.x1, y: o.y1 }), s = r.projectedUnitsToPixels({ x: o.x2, y: o.y2 }), n = i.pixelsToProjectedUnits({ x: a.x, y: a.y }), h = i.pixelsToProjectedUnits({ x: s.x, y: s.y });
+              o = { x1: n.x, y1: n.y, x2: h.x, y2: h.y };
+            }
+            i.fitToBounds(o, void 0, !1), this.series.isDirty = !0, t.redraw(e);
+          }
+        }
+      }
+      Nt(te.prototype, { dataLabelOnNull: B.pointMembers.dataLabelOnNull, moveToTopOnHover: B.pointMembers.moveToTopOnHover, isValid: B.pointMembers.isValid });
+      let { isNumber: Ts } = v(), Ls = { center: [0, 0], fitToGeometry: void 0, maxZoom: void 0, padding: 0, projection: { name: void 0, parallels: void 0, rotation: void 0 }, zoom: void 0, insetOptions: { borderColor: "#cccccc", borderWidth: 1, padding: "10%", relativeTo: "mapBoundingBox", units: "percent" } };
+      var As = C(984), Yt = C.n(As);
+      let { win: Gt } = v(), { format: Rt } = Yt(), { error: Ft, extend: js, merge: ks, wrap: zs } = v();
+      (function(l) {
+        function e(s) {
+          return this.mapView?.lonLatToProjectedUnits(s);
+        }
+        function t(s) {
+          return this.mapView?.projectedUnitsToLonLat(s);
+        }
+        function i(s, n) {
+          let h = this.options.chart.proj4 || Gt.proj4;
+          if (!h) return void Ft(21, !1, this);
+          let { jsonmarginX: p = 0, jsonmarginY: d = 0, jsonres: c = 1, scale: m = 1, xoffset: f = 0, xpan: u = 0, yoffset: g = 0, ypan: y = 0 } = n, b = h(n.crs, [s.lon, s.lat]), x = n.cosAngle || n.rotation && Math.cos(n.rotation), M = n.sinAngle || n.rotation && Math.sin(n.rotation), w = n.rotation ? [b[0] * x + b[1] * M, -b[0] * M + b[1] * x] : b;
+          return { x: ((w[0] - f) * m + u) * c + p, y: -(((g - w[1]) * m + y) * c - d) };
+        }
+        function o(s, n) {
+          let h = this.options.chart.proj4 || Gt.proj4;
+          if (!h) return void Ft(21, !1, this);
+          if (s.y === null) return;
+          let { jsonmarginX: p = 0, jsonmarginY: d = 0, jsonres: c = 1, scale: m = 1, xoffset: f = 0, xpan: u = 0, yoffset: g = 0, ypan: y = 0 } = n, b = { x: ((s.x - p) / c - u) / m + f, y: ((s.y - d) / c + y) / m + g }, x = n.cosAngle || n.rotation && Math.cos(n.rotation), M = n.sinAngle || n.rotation && Math.sin(n.rotation), w = h(n.crs, "WGS84", n.rotation ? { x: b.x * x + -(b.y * M), y: b.x * M + b.y * x } : b);
+          return { lat: w.y, lon: w.x };
+        }
+        function r(s, n) {
+          n || (n = Object.keys(s.objects)[0]);
+          let h = s.objects[n];
+          if (h["hc-decoded-geojson"] && h["hc-decoded-geojson"].title === s.title) return h["hc-decoded-geojson"];
+          let p = s.arcs;
+          if (s.transform) {
+            let u, g, y, b = s.arcs, { scale: x, translate: M } = s.transform;
+            p = [];
+            for (let w = 0, P = b.length; w < P; ++w) {
+              let j = b[w];
+              p.push(u = []), g = 0, y = 0;
+              for (let L = 0, T = j.length; L < T; ++L) u.push([(g += j[L][0]) * x[0] + M[0], (y += j[L][1]) * x[1] + M[1]]);
+            }
+          }
+          let d = (u) => typeof u[0] == "number" ? u.reduce((g, y, b) => {
+            let x = y < 0 ? p[~y] : p[y];
+            return y < 0 ? (x = x.slice(0, b === 0 ? x.length : x.length - 1)).reverse() : b && (x = x.slice(1)), g.concat(x);
+          }, []) : u.map(d), c = h.geometries, m = [];
+          for (let u = 0, g = c.length; u < g; ++u) m.push({ type: "Feature", properties: c[u].properties, geometry: { type: c[u].type, coordinates: c[u].coordinates || d(c[u].arcs) } });
+          let f = { type: "FeatureCollection", copyright: s.copyright, copyrightShort: s.copyrightShort, copyrightUrl: s.copyrightUrl, features: m, "hc-recommended-mapview": h["hc-recommended-mapview"], bbox: s.bbox, title: s.title };
+          return h["hc-decoded-geojson"] = f, f;
+        }
+        function a(s, n) {
+          n = ks(!0, this.options.credits, n), s.call(this, n), this.credits && this.mapCreditsFull && this.credits.attr({ title: this.mapCreditsFull });
+        }
+        l.compose = function(s) {
+          let n = s.prototype;
+          n.transformFromLatLon || (n.fromLatLonToPoint = e, n.fromPointToLatLon = t, n.transformFromLatLon = i, n.transformToLatLon = o, zs(n, "addCredits", a));
+        }, l.geojson = function(s, n = "map", h) {
+          let p = [], d = s.type === "Topology" ? r(s) : s, c = d.features;
+          for (let m = 0, f = c.length; m < f; ++m) {
+            let u, g = c[m], y = g.geometry || {}, b = y.type, x = y.coordinates, M = g.properties;
+            if ((n === "map" || n === "mapbubble") && (b === "Polygon" || b === "MultiPolygon") || n === "mapline" && (b === "LineString" || b === "MultiLineString") ? x.length && (u = { geometry: { coordinates: x, type: b } }) : n === "mappoint" && b === "Point" && x.length && (u = { geometry: { coordinates: x, type: b } }), u) {
+              let w = M && (M.name || M.NAME), P = M && M.lon, j = M && M.lat;
+              p.push(js(u, { lat: typeof j == "number" ? j : void 0, lon: typeof P == "number" ? P : void 0, name: typeof w == "string" ? w : void 0, properties: M }));
+            }
+          }
+          return h && d.copyrightShort && (h.chart.mapCredits = Rt(h.chart.options.credits?.mapText, { geojson: d }), h.chart.mapCreditsFull = Rt(h.chart.options.credits?.mapTextFull, { geojson: d })), p;
+        }, l.topo2geo = r;
+      })(et || (et = {}));
+      let Be = et;
+      (Ae = tt || (tt = {})).getCenterOfPoints = function(l) {
+        let e = l.reduce((t, i) => (t.x += i.x, t.y += i.y, t), { x: 0, y: 0 });
+        return { x: e.x / l.length, y: e.y / l.length };
+      }, Ae.getDistanceBetweenPoints = function(l, e) {
+        return Math.sqrt(Math.pow(e.x - l.x, 2) + Math.pow(e.y - l.y, 2));
+      }, Ae.getAngleBetweenPoints = function(l, e) {
+        return Math.atan2(e.x - l.x, e.y - l.y);
+      }, Ae.pointInPolygon = function({ x: l, y: e }, t) {
+        let i = t.length, o, r, a = !1;
+        for (o = 0, r = i - 1; o < i; r = o++) {
+          let [s, n] = t[o], [h, p] = t[r];
+          n > e != p > e && l < (h - s) * (e - n) / (p - n) + s && (a = !a);
+        }
+        return a;
+      };
+      let Ss = tt;
+      function Wt(l, e, t = !0) {
+        let i = e[e.length - 1], o, r, a, s = l;
+        for (let n = 0; n < e.length; n++) {
+          let h = s;
+          o = e[n], s = [], r = t ? h[h.length - 1] : h[0];
+          for (let p = 0; p < h.length; p++) ct(i, o, a = h[p]) ? (ct(i, o, r) || s.push(Ut(i, o, r, a)), s.push(a)) : ct(i, o, r) && s.push(Ut(i, o, r, a)), r = a;
+          i = o;
+        }
+        return s;
+      }
+      function ct(l, e, t) {
+        return (e[0] - l[0]) * (t[1] - l[1]) > (e[1] - l[1]) * (t[0] - l[0]);
+      }
+      function Ut(l, e, t, i) {
+        let o = [l[0] - e[0], l[1] - e[1]], r = [t[0] - i[0], t[1] - i[1]], a = l[0] * e[1] - l[1] * e[0], s = t[0] * i[1] - t[1] * i[0], n = 1 / (o[0] * r[1] - o[1] * r[0]), h = [(a * r[0] - s * o[0]) * n, (a * r[1] - s * o[1]) * n];
+        return h.isIntersection = !0, h;
+      }
+      let de = Math.sign || ((l) => l === 0 ? 0 : l > 0 ? 1 : -1), ce = Math.PI / 180, ie = Math.PI / 2, Ee = (l) => Math.tan((ie + l) / 2), Is = class {
+        constructor(l) {
+          const e = (l.parallels || []).map((a) => a * ce), t = e[0] || 0, i = e[1] ?? t, o = Math.cos(t);
+          typeof l.projectedBounds == "object" && (this.projectedBounds = l.projectedBounds);
+          let r = t === i ? Math.sin(t) : Math.log(o / Math.cos(i)) / Math.log(Ee(i) / Ee(t));
+          1e-10 > Math.abs(r) && (r = 1e-10 * (de(r) || 1)), this.n = r, this.c = o * Math.pow(Ee(t), r) / r;
+        }
+        forward(l) {
+          let { c: e, n: t, projectedBounds: i } = this, o = l[0] * ce, r = l[1] * ce;
+          e > 0 ? r < -ie + 1e-6 && (r = -ie + 1e-6) : r > ie - 1e-6 && (r = ie - 1e-6);
+          let a = e / Math.pow(Ee(r), t), s = a * Math.sin(t * o) * 63.78137, n = (e - a * Math.cos(t * o)) * 63.78137, h = [s, n];
+          return i && (s < i.x1 || s > i.x2 || n < i.y1 || n > i.y2) && (h.outside = !0), h;
+        }
+        inverse(l) {
+          let { c: e, n: t } = this, i = l[0] / 63.78137, o = e - l[1] / 63.78137, r = de(t) * Math.sqrt(i * i + o * o), a = Math.atan2(i, Math.abs(o)) * de(o);
+          return o * t < 0 && (a -= Math.PI * de(i) * de(o)), [a / t / ce, (2 * Math.atan(Math.pow(e / r, 1 / t)) - ie) / ce];
+        }
+      }, De = Math.sqrt(3) / 2, Bs = class {
+        constructor() {
+          this.bounds = { x1: -200.37508342789243, x2: 200.37508342789243, y1: -97.52595454902263, y2: 97.52595454902263 };
+        }
+        forward(l) {
+          let e = Math.PI / 180, t = Math.asin(De * Math.sin(l[1] * e)), i = t * t, o = i * i * i;
+          return [l[0] * e * Math.cos(t) * 74.03120656864502 / (De * (1.340264 + -0.24331799999999998 * i + o * (0.0062510000000000005 + 0.034164 * i))), 74.03120656864502 * t * (1.340264 + -0.081106 * i + o * (893e-6 + 3796e-6 * i))];
+        }
+        inverse(l) {
+          let e = l[0] / 74.03120656864502, t = l[1] / 74.03120656864502, i = 180 / Math.PI, o = t, r, a, s, n;
+          for (let d = 0; d < 12 && (a = (r = o * o) * r * r, s = o * (1.340264 + -0.081106 * r + a * (893e-6 + 3796e-6 * r)) - t, o -= n = s / (1.340264 + -0.24331799999999998 * r + a * (0.0062510000000000005 + 0.034164 * r)), !(1e-9 > Math.abs(n))); ++d) ;
+          a = (r = o * o) * r * r;
+          let h = i * De * e * (1.340264 + -0.24331799999999998 * r + a * (0.0062510000000000005 + 0.034164 * r)) / Math.cos(o), p = i * Math.asin(Math.sin(o) / De);
+          return Math.abs(h) > 180 ? [NaN, NaN] : [h, p];
+        }
+      }, Zt = Math.PI / 4, Oe = Math.PI / 180, Es = class {
+        constructor() {
+          this.bounds = { x1: -200.37508342789243, x2: 200.37508342789243, y1: -146.91480769173063, y2: 146.91480769173063 };
+        }
+        forward(l) {
+          return [l[0] * Oe * 63.78137, 79.7267125 * Math.log(Math.tan(Zt + 0.4 * l[1] * Oe))];
+        }
+        inverse(l) {
+          return [l[0] / 63.78137 / Oe, 2.5 * (Math.atan(Math.exp(0.8 * (l[1] / 63.78137))) - Zt) / Oe];
+        }
+      }, Ve = Math.PI / 180, Ds = class {
+        constructor() {
+          this.antimeridianCutting = !1, this.bounds = { x1: -63.78460826781007, x2: 63.78460826781007, y1: -63.78460826781007, y2: 63.78460826781007 };
+        }
+        forward(l) {
+          let e = l[0], t = l[1] * Ve, i = [Math.cos(t) * Math.sin(e * Ve) * 63.78460826781007, 63.78460826781007 * Math.sin(t)];
+          return (e < -90 || e > 90) && (i.outside = !0), i;
+        }
+        inverse(l) {
+          let e = l[0] / 63.78460826781007, t = l[1] / 63.78460826781007, i = Math.sqrt(e * e + t * t), o = Math.asin(i), r = Math.sin(o);
+          return [Math.atan2(e * r, i * Math.cos(o)) / Ve, Math.asin(i && t * r / i) / Ve];
+        }
+      }, Ne = Math.PI / 180, Os = class {
+        constructor() {
+          this.bounds = { x1: -200.37508342789243, x2: 200.37508342789243, y1: -200.3750834278071, y2: 200.3750834278071 }, this.maxLatitude = 85.0511287798;
+        }
+        forward(l) {
+          let e = Math.sin(l[1] * Ne), t = [63.78137 * l[0] * Ne, 63.78137 * Math.log((1 + e) / (1 - e)) / 2];
+          return Math.abs(l[1]) > this.maxLatitude && (t.outside = !0), t;
+        }
+        inverse(l) {
+          return [l[0] / (63.78137 * Ne), (2 * Math.atan(Math.exp(l[1] / 63.78137)) - Math.PI / 2) / Ne];
+        }
+      }, { clipLineString: Vs, clipPolygon: Ns } = { clipLineString: function(l, e) {
+        let t = [], i = Wt(l, e, !1);
+        for (let o = 1; o < i.length; o++) i[o].isIntersection && i[o - 1].isIntersection && (t.push(i.splice(0, o)), o = 0), o === i.length - 1 && t.push(i);
+        return t;
+      }, clipPolygon: Wt }, { clamp: Xs, erase: Ys } = v(), k = 2 * Math.PI / 360, se = (l) => (l < -180 && (l += 360), l > 180 && (l -= 360), l), Ht = (l) => (1 - Math.cos(l)) / 2;
+      class E {
+        static add(e, t) {
+          E.registry[e] = t;
+        }
+        static distance(e, t) {
+          let i, o, r, a, s, { atan2: n, sqrt: h } = Math, p = (i = Math.cos, o = e[1] * k, r = e[0] * k, a = t[1] * k, s = t[0] * k, Ht(a - o) + i(o) * i(a) * Ht(s - r));
+          return 6371e3 * (2 * n(h(p), h(1 - p)));
+        }
+        static geodesic(e, t, i, o = 5e5) {
+          let { atan2: r, cos: a, sin: s, sqrt: n } = Math, h = E.distance, p = e[1] * k, d = e[0] * k, c = t[1] * k, m = t[0] * k, f = a(p) * a(d), u = a(c) * a(m), g = a(p) * s(d), y = a(c) * s(m), b = s(p), x = s(c), M = h(e, t), w = M / 6371e3, P = s(w), j = Math.round(M / o), L = [];
+          if (i && L.push(e), j > 1) {
+            let T = 1 / j;
+            for (let z = T; z < 0.999; z += T) {
+              let V = s((1 - z) * w) / P, R = s(z * w) / P, Me = V * f + R * u, ve = V * g + R * y, we = r(V * b + R * x, n(Me * Me + ve * ve)), Ce = r(ve, Me);
+              L.push([Ce / k, we / k]);
+            }
+          }
+          return i && L.push(t), L;
+        }
+        static insertGeodesics(e) {
+          let t = e.length - 1;
+          for (; t--; ) if (Math.max(Math.abs(e[t][0] - e[t + 1][0]), Math.abs(e[t][1] - e[t + 1][1])) > 10) {
+            let i = E.geodesic(e[t], e[t + 1]);
+            i.length && e.splice(t + 1, 0, ...i);
+          }
+        }
+        static toString(e) {
+          let { name: t, rotation: i } = e || {};
+          return [t, i && i.join(",")].join(";");
+        }
+        constructor(e = {}) {
+          this.hasCoordinates = !1, this.hasGeoProjection = !1, this.maxLatitude = 90, this.options = e;
+          const { name: t, projectedBounds: i, rotation: o } = e;
+          this.rotator = o ? this.getRotator(o) : void 0;
+          const r = t ? E.registry[t] : void 0;
+          r && (this.def = new r(e));
+          const { def: a, rotator: s } = this;
+          a && (this.maxLatitude = a.maxLatitude || 90, this.hasGeoProjection = !0), s && a ? (this.forward = (n) => a.forward(s.forward(n)), this.inverse = (n) => s.inverse(a.inverse(n))) : a ? (this.forward = (n) => a.forward(n), this.inverse = (n) => a.inverse(n)) : s && (this.forward = s.forward, this.inverse = s.inverse), this.bounds = i === "world" ? a && a.bounds : i;
+        }
+        lineIntersectsBounds(e) {
+          let { x1: t, x2: i, y1: o, y2: r } = this.bounds || {}, a = (h, p, d) => {
+            let [c, m] = h, f = +!p;
+            if (typeof d == "number" && c[p] >= d != m[p] >= d) {
+              let u = (d - c[p]) / (m[p] - c[p]), g = c[f] + u * (m[f] - c[f]);
+              return p ? [g, d] : [d, g];
+            }
+          }, s, n = e[0];
+          return ((s = a(e, 0, t)) || (s = a(e, 0, i))) && (n = s, e[1] = s), ((s = a(e, 1, o)) || (s = a(e, 1, r))) && (n = s), n;
+        }
+        getRotator(e) {
+          let t = e[0] * k, i = (e[1] || 0) * k, o = (e[2] || 0) * k, r = Math.cos(i), a = Math.sin(i), s = Math.cos(o), n = Math.sin(o);
+          if (t !== 0 || i !== 0 || o !== 0) return { forward: (h) => {
+            let p = h[0] * k + t, d = h[1] * k, c = Math.cos(d), m = Math.cos(p) * c, f = Math.sin(p) * c, u = Math.sin(d), g = u * r + m * a;
+            return [Math.atan2(f * s - g * n, m * r - u * a) / k, Math.asin(g * s + f * n) / k];
+          }, inverse: (h) => {
+            let p = h[0] * k, d = h[1] * k, c = Math.cos(d), m = Math.cos(p) * c, f = Math.sin(p) * c, u = Math.sin(d), g = u * s - f * n;
+            return [(Math.atan2(f * s + u * n, m * r + g * a) - t) / k, Math.asin(g * r - m * a) / k];
+          } };
+        }
+        forward(e) {
+          return e;
+        }
+        inverse(e) {
+          return e;
+        }
+        cutOnAntimeridian(e, t) {
+          let i, o = [], r = [e];
+          for (let a = 0, s = e.length; a < s; ++a) {
+            let n = e[a], h = e[a - 1];
+            if (!a) {
+              if (!t) continue;
+              h = e[e.length - 1];
+            }
+            let p = h[0], d = n[0];
+            if ((p < -90 || p > 90) && (d < -90 || d > 90) && p > 0 != d > 0) {
+              let c = Xs((180 - (p + 360) % 360) / ((d + 360) % 360 - (p + 360) % 360), 0, 1), m = h[1] + c * (n[1] - h[1]);
+              o.push({ i: a, lat: m, direction: p < 0 ? 1 : -1, previousLonLat: h, lonLat: n });
+            }
+          }
+          if (o.length) if (t) {
+            o.length % 2 == 1 && (i = o.slice().sort((s, n) => Math.abs(n.lat) - Math.abs(s.lat))[0], Ys(o, i));
+            let a = o.length - 2;
+            for (; a >= 0; ) {
+              let s = o[a].i, n = se(180 + 1e-6 * o[a].direction), h = se(180 - 1e-6 * o[a].direction), p = e.splice(s, o[a + 1].i - s, ...E.geodesic([n, o[a].lat], [n, o[a + 1].lat], !0));
+              p.push(...E.geodesic([h, o[a + 1].lat], [h, o[a].lat], !0)), r.push(p), a -= 2;
+            }
+            if (i) for (let s = 0; s < r.length; s++) {
+              let { direction: n, lat: h } = i, p = r[s], d = p.indexOf(i.lonLat);
+              if (d > -1) {
+                let c = (h < 0 ? -1 : 1) * this.maxLatitude, m = se(180 + 1e-6 * n), f = se(180 - 1e-6 * n), u = E.geodesic([m, h], [m, c], !0);
+                for (let g = m + 120 * n; g > -180 && g < 180; g += 120 * n) u.push([g, c]);
+                u.push(...E.geodesic([f, c], [f, i.lat], !0)), p.splice(d, 0, ...u);
+                break;
+              }
+            }
+          } else {
+            let a = o.length;
+            for (; a--; ) {
+              let s = o[a].i, n = e.splice(s, e.length, [se(180 + 1e-6 * o[a].direction), o[a].lat]);
+              n.unshift([se(180 - 1e-6 * o[a].direction), o[a].lat]), r.push(n);
+            }
+          }
+          return r;
+        }
+        path(e) {
+          let t, { bounds: i, def: o, rotator: r } = this, a = [], s = e.type === "Polygon" || e.type === "MultiPolygon", n = this.hasGeoProjection, h = !o || o.antimeridianCutting !== !1, p = h ? r : void 0, d = h && o || this;
+          i && (t = [[i.x1, i.y1], [i.x2, i.y1], [i.x2, i.y2], [i.x1, i.y2]]);
+          let c = (m) => {
+            let f = m.map((g) => {
+              if (h) {
+                p && (g = p.forward(g));
+                let y = g[0];
+                1e-6 > Math.abs(y - 180) && (y = y < 180 ? 179.999999 : 180.000001), g = [y, g[1]];
+              }
+              return g;
+            }), u = [f];
+            n && (E.insertGeodesics(f), h && (u = this.cutOnAntimeridian(f, s))), u.forEach((g) => {
+              let y, b;
+              if (g.length < 2) return;
+              let x = !1, M = !1, w = (T) => {
+                x ? a.push(["L", T[0], T[1]]) : (a.push(["M", T[0], T[1]]), x = !0);
+              }, P = !1, j = !1, L = g.map((T) => {
+                let z = d.forward(T);
+                return z.outside ? P = !0 : j = !0, z[1] === 1 / 0 ? z[1] = 1e10 : z[1] === -1 / 0 && (z[1] = -1e10), z;
+              });
+              if (h) {
+                if (s && L.push(L[0]), P) {
+                  if (!j) return;
+                  if (t) {
+                    if (s) L = Ns(L, t);
+                    else if (i) return void Vs(L, t).forEach((T) => {
+                      x = !1, T.forEach(w);
+                    });
+                  }
+                }
+                L.forEach(w);
+              } else for (let T = 0; T < L.length; T++) {
+                let z = g[T], V = L[T];
+                V.outside ? M = !0 : (s && !y && (y = z, g.push(z), L.push(V)), M && b && (s && n ? E.geodesic(b, z).forEach((R) => w(d.forward(R))) : x = !1), w(V), b = z, M = !1);
+              }
+            });
+          };
+          return e.type === "LineString" ? c(e.coordinates) : e.type === "MultiLineString" ? e.coordinates.forEach((m) => c(m)) : e.type === "Polygon" ? (e.coordinates.forEach((m) => c(m)), a.length && a.push(["Z"])) : e.type === "MultiPolygon" && (e.coordinates.forEach((m) => {
+            m.forEach((f) => c(f));
+          }), a.length && a.push(["Z"])), a;
+        }
+      }
+      E.registry = { EqualEarth: Bs, LambertConformalConic: Is, Miller: Es, Orthographic: Ds, WebMercator: Os };
+      let { composed: Gs } = v(), { pointInPolygon: ue } = Ss, { topo2geo: $t } = Be, { boundsFromPath: Kt } = Vt, { addEvent: $, clamp: Rs, crisp: qt, fireEvent: _t, isArray: Fs, isNumber: N, isObject: Ws, isString: Us, merge: G, pick: Zs, pushUnique: Hs, relativeLength: W } = v(), me = {};
+      function Jt(l, e) {
+        let { width: t, height: i } = e;
+        return Math.log(400.979322 / Math.max((l.x2 - l.x1) / (t / 256), (l.y2 - l.y1) / (i / 256))) / Math.log(2);
+      }
+      function Qt(l) {
+        l.seriesOptions.mapData && this.mapView?.recommendMapView(this, [this.options.chart.map, l.seriesOptions.mapData], this.options.drilldown?.mapZooming);
+      }
+      class X {
+        static compose(e) {
+          Hs(Gs, "MapView") && (me = e.maps, $(e, "afterInit", function() {
+            this.mapView = new X(this, this.options.mapView);
+          }, { order: 0 }), $(e, "addSeriesAsDrilldown", Qt), $(e, "afterDrillUp", Qt));
+        }
+        static compositeBounds(e) {
+          if (e.length) return e.slice(1).reduce((t, i) => (t.x1 = Math.min(t.x1, i.x1), t.y1 = Math.min(t.y1, i.y1), t.x2 = Math.max(t.x2, i.x2), t.y2 = Math.max(t.y2, i.y2), t), G(e[0]));
+        }
+        static mergeInsets(e, t) {
+          let i = (r) => {
+            let a = {};
+            return r.forEach((s, n) => {
+              a[s && s.id || `i${n}`] = s;
+            }), a;
+          }, o = G(i(e), i(t));
+          return Object.keys(o).map((r) => o[r]);
+        }
+        constructor(e, t) {
+          this.allowTransformAnimation = !0, this.eventsToUnbind = [], this.insets = [], this.padding = [0, 0, 0, 0], this.recommendedMapView = {}, this instanceof ei || this.recommendMapView(e, [e.options.chart.map, ...(e.options.series || []).map((a) => a.mapData)]), this.userOptions = t || {};
+          const i = G(Ls, this.recommendedMapView, t), o = this.recommendedMapView?.insets, r = t && t.insets;
+          o && r && (i.insets = X.mergeInsets(o, r)), this.chart = e, this.center = i.center, this.options = i, this.projection = new E(i.projection), this.playingField = e.plotBox, this.zoom = i.zoom || 0, this.minZoom = i.minZoom, this.createInsets(), this.eventsToUnbind.push($(e, "afterSetChartSize", () => {
+            this.playingField = this.getField(), (this.minZoom === void 0 || this.minZoom === this.zoom) && (this.fitToBounds(void 0, void 0, !1), !this.chart.hasRendered && N(this.userOptions.zoom) && (this.zoom = this.userOptions.zoom), this.userOptions.center && G(!0, this.center, this.userOptions.center));
+          })), this.setUpEvents();
+        }
+        createInsets() {
+          let e = this.options, t = e.insets;
+          t && t.forEach((i) => {
+            let o = new ei(this, G(e.insetOptions, i));
+            this.insets.push(o);
+          });
+        }
+        fitToBounds(e, t, i = !0, o) {
+          let r = e || this.getProjectedBounds();
+          if (r) {
+            let a = Zs(t, e ? 0 : this.options.padding), s = this.getField(!1), n = Fs(a) ? a : [a, a, a, a];
+            this.padding = [W(n[0], s.height), W(n[1], s.width), W(n[2], s.height), W(n[3], s.width)], this.playingField = this.getField();
+            let h = Jt(r, this.playingField);
+            e || (this.minZoom = h);
+            let p = this.projection.inverse([(r.x2 + r.x1) / 2, (r.y2 + r.y1) / 2]);
+            this.setView(p, h, i, o);
+          }
+        }
+        getField(e = !0) {
+          let t = e ? this.padding : [0, 0, 0, 0];
+          return { x: t[3], y: t[0], width: this.chart.plotWidth - t[1] - t[3], height: this.chart.plotHeight - t[0] - t[2] };
+        }
+        getGeoMap(e) {
+          if (Us(e)) return me[e] && me[e].type === "Topology" ? $t(me[e]) : me[e];
+          if (Ws(e, !0)) {
+            if (e.type === "FeatureCollection") return e;
+            if (e.type === "Topology") return $t(e);
+          }
+        }
+        getMapBBox() {
+          let e = this.getProjectedBounds(), t = this.getScale();
+          if (e) {
+            let i = this.padding, o = this.projectedUnitsToPixels({ x: e.x1, y: e.y2 });
+            return { width: (e.x2 - e.x1) * t + i[1] + i[3], height: (e.y2 - e.y1) * t + i[0] + i[2], x: o.x - i[3], y: o.y - i[0] };
+          }
+        }
+        getProjectedBounds() {
+          let e = this.projection, t = this.chart.series.reduce((o, r) => {
+            let a = r.getProjectedBounds && r.getProjectedBounds();
+            return a && r.options.affectsMapView !== !1 && o.push(a), o;
+          }, []), i = this.options.fitToGeometry;
+          if (i) {
+            if (!this.fitToGeometryCache) if (i.type === "MultiPoint") {
+              let o = i.coordinates.map((s) => e.forward(s)), r = o.map((s) => s[0]), a = o.map((s) => s[1]);
+              this.fitToGeometryCache = { x1: Math.min.apply(0, r), x2: Math.max.apply(0, r), y1: Math.min.apply(0, a), y2: Math.max.apply(0, a) };
+            } else this.fitToGeometryCache = Kt(e.path(i));
+            return this.fitToGeometryCache;
+          }
+          return this.projection.bounds || X.compositeBounds(t);
+        }
+        getScale() {
+          return 256 / 400.979322 * Math.pow(2, this.zoom);
+        }
+        getSVGTransform() {
+          let { x: e, y: t, width: i, height: o } = this.playingField, r = this.projection.forward(this.center), a = this.projection.hasCoordinates ? -1 : 1, s = this.getScale(), n = s * a, h = e + i / 2 - r[0] * s, p = t + o / 2 - r[1] * n;
+          return { scaleX: s, scaleY: n, translateX: h, translateY: p };
+        }
+        lonLatToPixels(e) {
+          let t = this.lonLatToProjectedUnits(e);
+          if (t) return this.projectedUnitsToPixels(t);
+        }
+        lonLatToProjectedUnits(e) {
+          let t = this.chart, i = t.mapTransforms;
+          if (i) {
+            for (let r in i) if (Object.hasOwnProperty.call(i, r) && i[r].hitZone) {
+              let a = t.transformFromLatLon(e, i[r]);
+              if (a && ue(a, i[r].hitZone.coordinates[0])) return a;
+            }
+            return t.transformFromLatLon(e, i.default);
+          }
+          for (let r of this.insets) if (r.options.geoBounds && ue({ x: e.lon, y: e.lat }, r.options.geoBounds.coordinates[0])) {
+            let a = r.projection.forward([e.lon, e.lat]), s = r.projectedUnitsToPixels({ x: a[0], y: a[1] });
+            return this.pixelsToProjectedUnits(s);
+          }
+          let o = this.projection.forward([e.lon, e.lat]);
+          if (!o.outside) return { x: o[0], y: o[1] };
+        }
+        pixelsToLonLat(e) {
+          return this.projectedUnitsToLonLat(this.pixelsToProjectedUnits(e));
+        }
+        pixelsToProjectedUnits(e) {
+          let { x: t, y: i } = e, o = this.getScale(), r = this.projection.forward(this.center), a = this.playingField, s = a.x + a.width / 2, n = a.y + a.height / 2;
+          return { x: r[0] + (t - s) / o, y: r[1] - (i - n) / o };
+        }
+        projectedUnitsToLonLat(e) {
+          let t = this.chart, i = t.mapTransforms;
+          if (i) {
+            for (let a in i) if (Object.hasOwnProperty.call(i, a) && i[a].hitZone && ue(e, i[a].hitZone.coordinates[0])) return t.transformToLatLon(e, i[a]);
+            return t.transformToLatLon(e, i.default);
+          }
+          let o = this.projectedUnitsToPixels(e);
+          for (let a of this.insets) if (a.hitZone && ue(o, a.hitZone.coordinates[0])) {
+            let s = a.pixelsToProjectedUnits(o), n = a.projection.inverse([s.x, s.y]);
+            return { lon: n[0], lat: n[1] };
+          }
+          let r = this.projection.inverse([e.x, e.y]);
+          return { lon: r[0], lat: r[1] };
+        }
+        projectedUnitsToPixels(e) {
+          let t = this.getScale(), i = this.projection.forward(this.center), o = this.playingField, r = o.x + o.width / 2, a = o.y + o.height / 2;
+          return { x: r - t * (i[0] - e.x), y: a + t * (i[1] - e.y) };
+        }
+        recommendMapView(e, t, i = !1) {
+          this.recommendedMapView = {};
+          let o = t.map((s) => this.getGeoMap(s)), r = [];
+          o.forEach((s) => {
+            if (s && (Object.keys(this.recommendedMapView).length || (this.recommendedMapView = s["hc-recommended-mapview"] || {}), s.bbox)) {
+              let [n, h, p, d] = s.bbox;
+              r.push({ x1: n, y1: h, x2: p, y2: d });
+            }
+          });
+          let a = r.length && X.compositeBounds(r);
+          _t(this, "onRecommendMapView", { geoBounds: a, chart: e }, function() {
+            if (a && this.recommendedMapView) {
+              if (!this.recommendedMapView.projection) {
+                let { x1: s, y1: n, x2: h, y2: p } = a;
+                this.recommendedMapView.projection = h - s > 180 && p - n > 90 ? { name: "EqualEarth", parallels: [0, 0], rotation: [0] } : { name: "LambertConformalConic", parallels: [n, p], rotation: [-(s + h) / 2] };
+              }
+              this.recommendedMapView.insets || (this.recommendedMapView.insets = void 0);
+            }
+          }), this.geoMap = o[0], i && e.hasRendered && !e.userOptions.mapView?.projection && this.recommendedMapView && this.update(this.recommendedMapView);
+        }
+        redraw(e) {
+          this.chart.series.forEach((t) => {
+            t.useMapGeometry && (t.isDirty = !0);
+          }), this.chart.redraw(e);
+        }
+        setView(e, t, i = !0, o) {
+          e && (this.center = e), typeof t == "number" && (typeof this.minZoom == "number" && (t = Math.max(t, this.minZoom)), typeof this.options.maxZoom == "number" && (t = Math.min(t, this.options.maxZoom)), N(t) && (this.zoom = t));
+          let r = this.getProjectedBounds();
+          if (r) {
+            let a = this.projection.forward(this.center), { x: s, y: n, width: h, height: p } = this.playingField, d = this.getScale(), c = this.projectedUnitsToPixels({ x: r.x1, y: r.y1 }), m = this.projectedUnitsToPixels({ x: r.x2, y: r.y2 }), f = [(r.x1 + r.x2) / 2, (r.y1 + r.y2) / 2];
+            if (!this.chart.series.some((u) => u.isDrilling)) {
+              let u = c.x, g = m.y, y = m.x, b = c.y;
+              y - u < h ? a[0] = f[0] : u < s && y < s + h ? a[0] += Math.max(u - s, y - h - s) / d : y > s + h && u > s && (a[0] += Math.min(y - h - s, u - s) / d), b - g < p ? a[1] = f[1] : g < n && b < n + p ? a[1] -= Math.max(g - n, b - p - n) / d : b > n + p && g > n && (a[1] -= Math.min(b - p - n, g - n) / d), this.center = this.projection.inverse(a);
+            }
+            this.insets.forEach((u) => {
+              u.options.field && (u.hitZone = u.getHitZone(), u.playingField = u.getField());
+            }), this.render();
+          }
+          _t(this, "afterSetView"), i && this.redraw(o);
+        }
+        setUpEvents() {
+          let e, t, i, { chart: o } = this, r = (a) => {
+            let { lastTouches: s, pinchDown: n } = o.pointer, h = this.projection, p = a.touches, { mouseDownX: d, mouseDownY: c } = o, m = 0;
+            if (n?.length === 1 ? (d = n[0].chartX, c = n[0].chartY) : n?.length === 2 && (d = (n[0].chartX + n[1].chartX) / 2, c = (n[0].chartY + n[1].chartY) / 2), p?.length === 2 && s && (m = Math.log(Math.sqrt(Math.pow(s[0].chartX - s[1].chartX, 2) + Math.pow(s[0].chartY - s[1].chartY, 2)) / Math.sqrt(Math.pow(p[0].chartX - p[1].chartX, 2) + Math.pow(p[0].chartY - p[1].chartY, 2))) / Math.log(0.5)), N(d) && N(c)) {
+              let f = `${d},${c}`, { chartX: u, chartY: g } = a.originalEvent;
+              p?.length === 2 && (u = (p[0].chartX + p[1].chartX) / 2, g = (p[0].chartY + p[1].chartY) / 2), f !== t && (t = f, e = this.projection.forward(this.center), i = (this.projection.options.rotation || [0, 0]).slice());
+              let y = h.def && h.def.bounds, b = y && Jt(y, this.playingField) || -1 / 0;
+              if (h.options.name === "Orthographic" && 2 > (p?.length || 0) && (this.minZoom || 1 / 0) < 1.3 * b) {
+                let x = 440 / (this.getScale() * Math.min(o.plotWidth, o.plotHeight));
+                if (i) {
+                  let M = (d - u) * x - i[0], w = Rs(-i[1] - (c - g) * x, -80, 80), P = this.zoom;
+                  this.update({ projection: { rotation: [-M, -w] } }, !1), this.fitToBounds(void 0, void 0, !1), this.zoom = P, o.redraw(!1);
+                }
+              } else if (N(u) && N(g)) {
+                let x = this.getScale(), M = this.projection.hasCoordinates ? 1 : -1, w = this.projection.inverse([e[0] + (d - u) / x, e[1] - (c - g) / x * M]);
+                isNaN(w[0] + w[1]) || this.zoomBy(m, w, void 0, !1);
+              }
+              a.preventDefault();
+            }
+          };
+          $(o, "pan", r), $(o, "touchpan", r), $(o, "selection", (a) => {
+            if (a.resetSelection) this.zoomBy();
+            else {
+              let s = a.x - o.plotLeft, n = a.y - o.plotTop, { y: h, x: p } = this.pixelsToProjectedUnits({ x: s, y: n }), { y: d, x: c } = this.pixelsToProjectedUnits({ x: s + a.width, y: n + a.height });
+              this.fitToBounds({ x1: p, y1: h, x2: c, y2: d }, void 0, !0, !a.originalEvent.touches && void 0), /^touch/.test(a.originalEvent.type) || o.showResetZoom(), a.preventDefault();
+            }
+          });
+        }
+        render() {
+          this.group || (this.group = this.chart.renderer.g("map-view").attr({ zIndex: 4 }).add());
+        }
+        update(e, t = !0, i) {
+          let o = e.projection, r = o && E.toString(o) !== E.toString(this.options.projection), a = !1;
+          G(!0, this.userOptions, e), G(!0, this.options, e), "insets" in e && (this.insets.forEach((s) => s.destroy()), this.insets.length = 0, a = !0), (r || "fitToGeometry" in e) && delete this.fitToGeometryCache, (r || a) && (this.chart.series.forEach((s) => {
+            let n = s.transformGroups;
+            if (s.clearBounds && s.clearBounds(), s.isDirty = !0, s.isDirtyData = !0, a && n) for (; n.length > 1; ) {
+              let h = n.pop();
+              h && h.destroy();
+            }
+          }), r && (this.projection = new E(this.options.projection)), a && this.createInsets(), !e.center && Object.hasOwnProperty.call(e, "zoom") && !N(e.zoom) && this.fitToBounds(void 0, void 0, !1)), e.center || N(e.zoom) ? this.setView(this.options.center, e.zoom, !1) : "fitToGeometry" in e && this.fitToBounds(void 0, void 0, !1), t && this.chart.redraw(i);
+        }
+        zoomBy(e, t, i, o) {
+          let r = this.chart, a = this.projection.forward(this.center);
+          if (typeof e == "number") {
+            let s, n, h, p = this.zoom + e;
+            if (i) {
+              let [d, c] = i, m = this.getScale(), f = d - r.plotLeft - r.plotWidth / 2, u = c - r.plotTop - r.plotHeight / 2;
+              n = a[0] + f / m, h = a[1] + u / m;
+            }
+            if (typeof n == "number" && typeof h == "number") {
+              let d = 1 - Math.pow(2, this.zoom) / Math.pow(2, p), c = a[0] - n, m = a[1] - h;
+              a[0] -= c * d, a[1] += m * d, s = this.projection.inverse(a);
+            }
+            this.setView(t || s, p, void 0, o);
+          } else this.fitToBounds(void 0, void 0, void 0, o);
+        }
+      }
+      class ei extends X {
+        constructor(e, t) {
+          if (super(e.chart, t), this.id = t.id, this.mapView = e, this.options = G({ center: [0, 0] }, e.options.insetOptions, t), this.allBounds = [], this.options.geoBounds) {
+            const i = e.projection.path(this.options.geoBounds);
+            this.geoBoundsProjectedBox = Kt(i), this.geoBoundsProjectedPolygon = i.map((o) => [o[1] || 0, o[2] || 0]);
+          }
+        }
+        getField(e = !0) {
+          let t = this.hitZone;
+          if (t) {
+            let i = e ? this.padding : [0, 0, 0, 0], o = t.coordinates[0], r = o.map((d) => d[0]), a = o.map((d) => d[1]), s = Math.min.apply(0, r) + i[3], n = Math.max.apply(0, r) - i[1], h = Math.min.apply(0, a) + i[0], p = Math.max.apply(0, a) - i[2];
+            if (N(s) && N(h)) return { x: s, y: h, width: n - s, height: p - h };
+          }
+          return super.getField.call(this, e);
+        }
+        getHitZone() {
+          let { chart: e, mapView: t, options: i } = this, { coordinates: o } = i.field || {};
+          if (o) {
+            let r = o[0];
+            if (i.units === "percent") {
+              let a = i.relativeTo === "mapBoundingBox" && t.getMapBBox() || G(e.plotBox, { x: 0, y: 0 });
+              r = r.map((s) => [W(`${s[0]}%`, a.width, a.x), W(`${s[1]}%`, a.height, a.y)]);
+            }
+            return { type: "Polygon", coordinates: [r] };
+          }
+        }
+        getProjectedBounds() {
+          return X.compositeBounds(this.allBounds);
+        }
+        isInside(e) {
+          let { geoBoundsProjectedBox: t, geoBoundsProjectedPolygon: i } = this;
+          return !!(t && e.x >= t.x1 && e.x <= t.x2 && e.y >= t.y1 && e.y <= t.y2 && i && ue(e, i));
+        }
+        render() {
+          let { chart: e, mapView: t, options: i } = this, o = i.borderPath || i.field;
+          if (o && t.group) {
+            let r = !0;
+            this.border || (this.border = e.renderer.path().addClass("highcharts-mapview-inset-border").add(t.group), r = !1), e.styledMode || this.border.attr({ stroke: i.borderColor, "stroke-width": i.borderWidth });
+            let a = this.border.strokeWidth(), s = i.relativeTo === "mapBoundingBox" && t.getMapBBox() || t.playingField, n = (o.coordinates || []).reduce((h, p) => p.reduce((d, c, m) => {
+              let [f, u] = c;
+              return i.units === "percent" && (f = e.plotLeft + W(`${f}%`, s.width, s.x), u = e.plotTop + W(`${u}%`, s.height, s.y)), f = qt(f, a), u = qt(u, a), d.push(m === 0 ? ["M", f, u] : ["L", f, u]), d;
+            }, h), []);
+            this.border[r ? "animate" : "attr"]({ d: n });
+          }
+        }
+        destroy() {
+          this.border && (this.border = this.border.destroy()), this.eventsToUnbind.forEach((e) => e());
+        }
+        setUpEvents() {
+        }
+      }
+      let { animObject: ti, stop: $s } = v(), { noop: Xe } = v(), { splitPath: Ks } = Ie, { column: ii, scatter: si } = I().seriesTypes, { extend: qs, find: _s, fireEvent: oi, getNestedProperty: ri, isArray: ut, defined: ai, isNumber: D, isObject: Js, merge: ge, objectEach: Qs, pick: mt, splat: eo } = v();
+      class fe extends si {
+        constructor() {
+          super(...arguments), this.processedData = [];
+        }
+        animate(e) {
+          let { chart: t, group: i } = this, o = ti(this.options.animation);
+          e ? i.attr({ translateX: t.plotLeft + t.plotWidth / 2, translateY: t.plotTop + t.plotHeight / 2, scaleX: 1e-3, scaleY: 1e-3 }) : i.animate({ translateX: t.plotLeft, translateY: t.plotTop, scaleX: 1, scaleY: 1 }, o);
+        }
+        clearBounds() {
+          this.points.forEach((e) => {
+            delete e.bounds, delete e.insetIndex, delete e.projectedPath;
+          }), delete this.bounds;
+        }
+        doFullTranslate() {
+          return !!(this.isDirtyData || this.chart.isResizing || !this.hasRendered);
+        }
+        drawMapDataLabels() {
+          super.drawDataLabels(), this.dataLabelsGroups?.forEach((e) => e?.clip(this.chart.clipRect));
+        }
+        drawPoints() {
+          let e = this, { chart: t, group: i, transformGroups: o = [] } = this, { mapView: r, renderer: a } = t;
+          if (r) {
+            this.transformGroups = o, o[0] || (o[0] = a.g().add(i));
+            for (let s = 0, n = r.insets.length; s < n; ++s) o[s + 1] || o.push(a.g().add(i));
+            this.doFullTranslate() && (this.points.forEach((s) => {
+              let { graphic: n } = s;
+              s.group = o[typeof s.insetIndex == "number" ? s.insetIndex + 1 : 0], n && n.parentGroup !== s.group && n.add(s.group);
+            }), ii.prototype.drawPoints.apply(this), this.points.forEach((s) => {
+              let n = s.graphic;
+              if (n) {
+                let h = n.animate, p = "";
+                s.name && (p += "highcharts-name-" + s.name.replace(/ /g, "-").toLowerCase()), s.properties?.["hc-key"] && (p += " highcharts-key-" + s.properties["hc-key"].toString().toLowerCase()), p && n.addClass(p), t.styledMode && n.css(this.pointAttribs(s, s.selected && "select" || void 0)), n.attr({ visibility: !s.visible && (s.visible || s.isNull) ? "hidden" : "inherit" }), n.animate = function(d, c, m) {
+                  let f = D(d["stroke-width"]) && !D(n["stroke-width"]), u = D(n["stroke-width"]) && !D(d["stroke-width"]);
+                  if (f || u) {
+                    let g = mt(e.getStrokeWidth(e.options), 1) / (t.mapView?.getScale() || 1);
+                    f && (n["stroke-width"] = g), u && (d["stroke-width"] = g);
+                  }
+                  return h.call(n, d, c, u ? function() {
+                    n.element.removeAttribute("stroke-width"), delete n["stroke-width"], m && m.apply(this, arguments);
+                  } : m);
+                };
+              }
+            })), o.forEach((s, n) => {
+              let h = (n === 0 ? r : r.insets[n - 1]).getSVGTransform(), p = mt(this.getStrokeWidth(this.options), 1), d = h.scaleX, c = h.scaleY > 0 ? 1 : -1, m = (f) => {
+                (e.points || []).forEach((u) => {
+                  let g, y = u.graphic;
+                  y?.["stroke-width"] && (g = this.getStrokeWidth(u.options)) && y.attr({ "stroke-width": g / f });
+                });
+              };
+              if (a.globalAnimation && t.hasRendered && r.allowTransformAnimation) {
+                let f = Number(s.attr("translateX")), u = Number(s.attr("translateY")), g = Number(s.attr("scaleX")), y = (M, w) => {
+                  let P = g + (d - g) * w.pos;
+                  s.attr({ translateX: f + (h.translateX - f) * w.pos, translateY: u + (h.translateY - u) * w.pos, scaleX: P, scaleY: P * c, "stroke-width": p / P }), m(P);
+                }, b = ge(ti(a.globalAnimation)), x = b.step;
+                b.step = function() {
+                  x && x.apply(this, arguments), y.apply(this, arguments);
+                }, s.attr({ animator: 0 }).animate({ animator: 1 }, b, (function() {
+                  typeof a.globalAnimation != "boolean" && a.globalAnimation.complete && a.globalAnimation.complete({ applyDrilldown: !0 }), oi(this, "mapZoomComplete");
+                }).bind(this));
+              } else $s(s), s.attr(ge(h, { "stroke-width": p / d })), m(d);
+            }), this.isDrilling || this.drawMapDataLabels();
+          }
+        }
+        getProjectedBounds() {
+          if (!this.bounds && this.chart.mapView) {
+            let { insets: e, projection: t } = this.chart.mapView, i = [];
+            (this.points || []).forEach((o) => {
+              if (o.path || o.geometry) {
+                if (typeof o.path == "string" ? o.path = Ks(o.path) : ut(o.path) && o.path[0] === "M" && (o.path = this.chart.renderer.pathToSegments(o.path)), !o.bounds) {
+                  let r = o.getProjectedBounds(t);
+                  if (r) {
+                    o.labelrank = mt(o.labelrank, (r.x2 - r.x1) * (r.y2 - r.y1));
+                    let { midX: a, midY: s } = r;
+                    if (e && D(a) && D(s)) {
+                      let n = _s(e, (h) => h.isInside({ x: a, y: s }));
+                      n && (delete o.projectedPath, (r = o.getProjectedBounds(n.projection)) && n.allBounds.push(r), o.insetIndex = e.indexOf(n));
+                    }
+                    o.bounds = r;
+                  }
+                }
+                o.bounds && o.insetIndex === void 0 && i.push(o.bounds);
+              }
+            }), this.bounds = X.compositeBounds(i);
+          }
+          return this.bounds;
+        }
+        getStrokeWidth(e) {
+          let t = this.pointAttrToOptions;
+          return e[t?.["stroke-width"] || "borderWidth"];
+        }
+        hasData() {
+          return !!this.dataTable.rowCount;
+        }
+        pointAttribs(e, t) {
+          let { mapView: i, styledMode: o } = e.series.chart, r = o ? this.colorAttribs(e) : ii.prototype.pointAttribs.call(this, e, t), a = this.getStrokeWidth(e.options);
+          if (t) {
+            let n = ge(this.options.states?.[t], e.options.states?.[t] || {}), h = this.getStrokeWidth(n);
+            ai(h) && (a = h), r.stroke = n.borderColor ?? e.color;
+          }
+          a && i && (a /= i.getScale());
+          let s = this.getStrokeWidth(this.options);
+          return r.dashstyle && i && D(s) && (a = s / i.getScale()), e.visible || (r.fill = this.options.nullColor), e.isNull && this.options.nullInteraction && (r.opacity = 1), ai(a) ? r["stroke-width"] = a : delete r["stroke-width"], r["stroke-linecap"] = r["stroke-linejoin"] = this.options.linecap, r;
+        }
+        updateData() {
+          return !this.processedData && super.updateData.apply(this, arguments);
+        }
+        setData(e, t = !0, i, o) {
+          delete this.bounds, super.setData(e, !1, void 0, o), this.processData(), this.generatePoints(), t && this.chart.redraw(i);
+        }
+        dataColumnKeys() {
+          return this.pointArrayMap;
+        }
+        processData() {
+          let e, t, i, o = this.options, r = o.data, a = this.chart, s = a.options.chart, n = this.joinBy, h = o.keys || this.pointArrayMap, p = [], d = {}, c = this.chart.mapView, m = c && (Js(o.mapData, !0) ? c.getGeoMap(o.mapData) : c.geoMap), f = a.mapTransforms = s.mapTransforms || m?.["hc-transform"] || a.mapTransforms;
+          f && Qs(f, (g) => {
+            g.rotation && (g.cosAngle = Math.cos(g.rotation), g.sinAngle = Math.sin(g.rotation));
+          }), ut(o.mapData) ? i = o.mapData : m && m.type === "FeatureCollection" && (this.mapTitle = m.title, i = v().geojson(m, this.type, this)), this.processedData = [];
+          let u = this.processedData;
+          if (r) {
+            let g;
+            for (let y = 0, b = r.length; y < b; ++y) {
+              if (D(g = r[y])) u[y] = { value: g };
+              else if (ut(g)) {
+                let x = 0;
+                u[y] = {}, !o.keys && g.length > h.length && typeof g[0] == "string" && (u[y]["hc-key"] = g[0], ++x);
+                for (let M = 0; M < h.length; ++M, ++x) h[M] && g[x] !== void 0 && (h[M].indexOf(".") > 0 ? te.prototype.setNestedProperty(u[y], g[x], h[M]) : u[y][h[M]] = g[x]);
+              } else u[y] = r[y];
+              n && n[0] === "_i" && (u[y]._i = y);
+            }
+          }
+          if (i) {
+            this.mapData = i, this.mapMap = {};
+            for (let g = 0; g < i.length; g++) t = (e = i[g]).properties, e._i = g, n[0] && t && t[n[0]] && (e[n[0]] = t[n[0]]), d[e[n[0]]] = e;
+            if (this.mapMap = d, n[1]) {
+              let g = n[1];
+              u.forEach((y) => {
+                let b = ri(g, y);
+                d[b] && p.push(d[b]);
+              });
+            }
+            if (o.allAreas) {
+              if (n[1]) {
+                let y = n[1];
+                u.forEach((b) => {
+                  p.push(ri(y, b));
+                });
+              }
+              let g = "|" + p.map(function(y) {
+                return y && y[n[0]];
+              }).join("|") + "|";
+              i.forEach((y) => {
+                n[0] && g.indexOf("|" + y[n[0]] + "|") !== -1 || u.push(ge(y, { value: null }));
+              });
+            }
+          }
+          this.dataTable.rowCount = u.length;
+        }
+        setOptions(e) {
+          let t = super.setOptions(e), i = t.joinBy;
+          return t.joinBy === null && (i = "_i"), i && (this.joinBy = eo(i), this.joinBy[1] || (this.joinBy[1] = this.joinBy[0])), t;
+        }
+        translate() {
+          let e = this.doFullTranslate(), t = this.chart.mapView, i = t?.projection;
+          if (this.chart.hasRendered && (this.isDirtyData || !this.hasRendered) && (this.processData(), this.generatePoints(), delete this.bounds, !t || t.userOptions.center || D(t.userOptions.zoom) || t.zoom !== t.minZoom ? this.getProjectedBounds() : t.fitToBounds(void 0, void 0, !1)), t) {
+            let o = t.getSVGTransform();
+            this.points.forEach((r) => {
+              let a = D(r.insetIndex) && t.insets[r.insetIndex].getSVGTransform() || o;
+              a && r.bounds && D(r.bounds.midX) && D(r.bounds.midY) && (r.plotX = r.bounds.midX * a.scaleX + a.translateX, r.plotY = r.bounds.midY * a.scaleY + a.translateY), e && (r.shapeType = "path", r.shapeArgs = { d: te.getProjectedPath(r, i) }), !r.hiddenInDataClass && (r.projectedPath && !r.projectedPath.length ? r.setVisible(!1) : r.visible || r.setVisible(!0));
+            });
+          }
+          oi(this, "afterTranslate");
+        }
+        update(e) {
+          e.mapData && this.chart.mapView?.recommendMapView(this.chart, [this.chart.options.chart.map, ...(this.chart.options.series || []).map((t, i) => i === this._i ? e.mapData : t.mapData)], !0), super.update.apply(this, arguments);
+        }
+      }
+      fe.defaultOptions = ge(si.defaultOptions, { affectsMapView: !0, animation: !1, dataLabels: { crop: !1, formatter: function() {
+        let { numberFormatter: l } = this.series.chart, { value: e } = this.point;
+        return Ts(e) ? l(e, -1) : this.point.name || "";
+      }, inside: !0, overflow: !1, padding: 0, verticalAlign: "middle" }, linecap: "round", marker: null, nullColor: "#f7f7f7", stickyTracking: !1, tooltip: { followPointer: !0, pointFormat: "{point.name}: {point.value}<br/>" }, turboThreshold: 0, allAreas: !0, borderColor: "#e6e6e6", borderWidth: 1, joinBy: "hc-key", states: { hover: { halo: void 0, borderColor: "#666666", borderWidth: 2 }, normal: { animation: !0 }, select: { color: "#cccccc" } }, legendSymbol: "rectangle" }), qs(fe.prototype, { type: "map", axisTypes: B.seriesMembers.axisTypes, colorAttribs: B.seriesMembers.colorAttribs, colorKey: B.seriesMembers.colorKey, directTouch: !0, drawDataLabels: Xe, drawGraph: Xe, forceDL: !0, getCenter: ys.getCenter, getExtremesFromAll: !0, getSymbol: Xe, isCartesian: !1, parallelArrays: B.seriesMembers.parallelArrays, pointArrayMap: B.seriesMembers.pointArrayMap, pointClass: te, preserveAspectRatio: !0, searchPoint: Xe, trackerGroups: B.seriesMembers.trackerGroups, useMapGeometry: !0 }), B.compose(fe), I().registerSeriesType("map", fe);
+      let ni = fe, { extend: to, merge: io } = v();
+      class gt extends ni {
+        pointAttribs(e, t) {
+          let i = super.pointAttribs(e, t);
+          return i.fill = this.options.fillColor, i;
+        }
+      }
+      gt.defaultOptions = io(ni.defaultOptions, { lineWidth: 1, fillColor: "none", legendSymbol: "lineMarker" }), to(gt.prototype, { type: "mapline", colorProp: "stroke", pointAttrToOptions: { stroke: "color", "stroke-width": "lineWidth" } }), I().registerSeriesType("mapline", gt);
+      let { scatter: so } = I().seriesTypes, { isNumber: Ye } = v();
+      class oo extends so.prototype.pointClass {
+        isValid() {
+          return !!(this.options.geometry || Ye(this.x) && Ye(this.y) || Ye(this.options.lon) && Ye(this.options.lat));
+        }
+      }
+      C(632);
+      let { noop: ro } = v(), { map: ao, scatter: li } = I().seriesTypes, { extend: no, fireEvent: lo, isNumber: K, merge: ho } = v();
+      class ft extends li {
+        constructor() {
+          super(...arguments), this.clearBounds = ao.prototype.clearBounds;
+        }
+        drawDataLabels() {
+          super.drawDataLabels(), this.dataLabelsGroups?.forEach((e) => {
+            e?.clip(this.chart.clipRect);
+          });
+        }
+        projectPoint(e) {
+          let t = this.chart.mapView;
+          if (t) {
+            let { geometry: i, lon: o, lat: r } = e, a = i && i.type === "Point" && i.coordinates;
+            if (K(o) && K(r) && (a = [o, r]), a) return t.lonLatToProjectedUnits({ lon: a[0], lat: a[1] });
+          }
+        }
+        translate() {
+          let e = this.chart.mapView;
+          if (this.generatePoints(), this.getProjectedBounds && this.isDirtyData && (delete this.bounds, this.getProjectedBounds()), e) {
+            let t = e.getSVGTransform(), { hasCoordinates: i } = e.projection;
+            this.points.forEach((o) => {
+              let r, { x: a, y: s } = o, n = K(o.insetIndex) && e.insets[o.insetIndex].getSVGTransform() || t, h = this.projectPoint(o.options) || o.properties && this.projectPoint(o.properties);
+              if (h ? (a = h.x, s = h.y) : o.bounds && (a = o.bounds.midX, s = o.bounds.midY, n && K(a) && K(s) && (o.plotX = a * n.scaleX + n.translateX, o.plotY = s * n.scaleY + n.translateY, r = !0)), K(a) && K(s)) {
+                if (!r) {
+                  let p = e.projectedUnitsToPixels({ x: a, y: s });
+                  o.plotX = p.x, o.plotY = i ? p.y : this.chart.plotHeight - p.y;
+                }
+              } else o.y = o.plotX = o.plotY = void 0;
+              o.isInside = this.isPointInside(o), o.zone = this.zones.length ? o.getZone() : void 0;
+            });
+          }
+          lo(this, "afterTranslate");
+        }
+      }
+      ft.defaultOptions = ho(li.defaultOptions, { dataLabels: { crop: !1, defer: !1, enabled: !0, formatter: function() {
+        return this.point.name;
+      }, overflow: !1, style: { color: "#000000" } }, legendSymbol: "lineMarker", stickyTracking: !0, tooltip: { pointFormat: "{#if point.name}{point.name}{else}Lat: {point.lat}, Lon: {point.lon}{/if}" } }), pt().prototype.symbols.mapmarker = (l, e, t, i, o) => {
+        let r, a, s = o && o.context === "legend";
+        s ? (r = l + t / 2, a = e + i) : o && typeof o.anchorX == "number" && typeof o.anchorY == "number" ? (r = o.anchorX, a = o.anchorY) : (r = l + t / 2, a = e + i / 2, e -= i);
+        let n = s ? i / 3 : i / 2;
+        return [["M", r, a], ["C", r, a, r - n, e + 1.5 * n, r - n, e + n], ["A", n, n, 1, 1, 1, r + n, e + n], ["C", r + n, e + 1.5 * n, r, a, r, a], ["Z"]];
+      }, no(ft.prototype, { type: "mappoint", axisTypes: ["colorAxis"], forceDL: !0, isCartesian: !1, pointClass: oo, searchPoint: ro, useMapGeometry: !0 }), I().registerSeriesType("mappoint", ft);
+      let po = { borderColor: void 0, borderWidth: 2, className: void 0, color: void 0, connectorClassName: void 0, connectorColor: void 0, connectorDistance: 60, connectorWidth: 1, enabled: !1, labels: { className: void 0, allowOverlap: !1, format: "", formatter: void 0, align: "right", style: { fontSize: "0.9em", color: "#000000" }, x: 0, y: 0 }, maxSize: 60, minSize: 10, legendIndex: 0, ranges: { value: void 0, borderColor: void 0, color: void 0, connectorColor: void 0 }, sizeBy: "area", sizeByAbsoluteValue: !1, zIndex: 1, zThreshold: 0 }, { noop: co } = v(), { arrayMax: uo, arrayMin: mo, isNumber: hi, merge: ye, pick: be, stableSort: go } = v(), fo = class {
+        constructor(l, e) {
+          this.setState = co, this.init(l, e);
+        }
+        init(l, e) {
+          this.options = l, this.visible = !0, this.chart = e.chart, this.legend = e;
+        }
+        addToLegend(l) {
+          l.splice(this.options.legendIndex, 0, this);
+        }
+        drawLegendSymbol(l) {
+          let e, t = be(l.options.itemDistance, 20), i = this.legendItem || {}, o = this.options, r = o.ranges, a = o.connectorDistance;
+          if (!r || !r.length || !hi(r[0].value)) {
+            l.options.bubbleLegend.autoRanges = !0;
+            return;
+          }
+          go(r, function(p, d) {
+            return d.value - p.value;
+          }), this.ranges = r, this.setOptions(), this.render();
+          let s = this.getMaxLabelSize(), n = this.ranges[0].radius, h = 2 * n;
+          e = (e = a - n + s.width) > 0 ? e : 0, this.maxLabel = s, this.movementX = o.labels.align === "left" ? e : 0, i.labelWidth = h + e + t, i.labelHeight = h + s.height / 2;
+        }
+        setOptions() {
+          let l = this.ranges, e = this.options, t = this.chart.series[e.seriesIndex], i = this.legend.baseline, o = { zIndex: e.zIndex, "stroke-width": e.borderWidth }, r = { zIndex: e.zIndex, "stroke-width": e.connectorWidth }, a = { align: this.legend.options.rtl || e.labels.align === "left" ? "right" : "left", zIndex: e.zIndex }, s = t.options.marker.fillOpacity, n = this.chart.styledMode;
+          l.forEach(function(h, p) {
+            n || (o.stroke = be(h.borderColor, e.borderColor, t.color), o.fill = h.color || e.color, o.fill || (o.fill = t.color, o["fill-opacity"] = s ?? 1), r.stroke = be(h.connectorColor, e.connectorColor, t.color)), l[p].radius = this.getRangeRadius(h.value), l[p] = ye(l[p], { center: l[0].radius - l[p].radius + i }), n || ye(!0, l[p], { bubbleAttribs: ye(o), connectorAttribs: ye(r), labelAttribs: a });
+          }, this);
+        }
+        getRangeRadius(l) {
+          let e = this.options, t = this.options.seriesIndex, i = this.chart.series[t], o = e.ranges[0].value, r = e.ranges[e.ranges.length - 1].value, a = e.minSize, s = e.maxSize;
+          return i.getRadius.call(this, r, o, a, s, l);
+        }
+        render() {
+          let l = this.legendItem || {}, e = this.chart.renderer, t = this.options.zThreshold;
+          for (let i of (this.symbols || (this.symbols = { connectors: [], bubbleItems: [], labels: [] }), l.symbol = e.g("bubble-legend"), l.label = e.g("bubble-legend-item").css(this.legend.itemStyle || {}), l.symbol.translateX = 0, l.symbol.translateY = 0, l.symbol.add(l.label), l.label.add(l.group), this.ranges)) i.value >= t && this.renderRange(i);
+          this.hideOverlappingLabels();
+        }
+        renderRange(l) {
+          let e = this.ranges[0], t = this.legend, i = this.options, o = i.labels, r = this.chart, a = r.series[i.seriesIndex], s = r.renderer, n = this.symbols, h = n.labels, p = l.center, d = Math.abs(l.radius), c = i.connectorDistance || 0, m = o.align, f = t.options.rtl, u = i.borderWidth, g = i.connectorWidth, y = e.radius || 0, b = p - d - u / 2 + g / 2, x = (b % 1 ? 1 : 0.5) - (g % 2 ? 0 : 0.5), M = s.styledMode, w = f || m === "left" ? -c : c;
+          m === "center" && (w = 0, i.connectorDistance = 0, l.labelAttribs.align = "center"), n.bubbleItems.push(s.circle(y, p + x, d).attr(M ? {} : l.bubbleAttribs).addClass((M ? "highcharts-color-" + a.colorIndex + " " : "") + "highcharts-bubble-legend-symbol " + (i.className || "")).add(this.legendItem.symbol)), n.connectors.push(s.path(s.crispLine([["M", y, b], ["L", y + w, b]], i.connectorWidth)).attr(M ? {} : l.connectorAttribs).addClass((M ? "highcharts-color-" + this.options.seriesIndex + " " : "") + "highcharts-bubble-legend-connectors " + (i.connectorClassName || "")).add(this.legendItem.symbol));
+          let P = s.text(this.formatLabel(l)).attr(M ? {} : l.labelAttribs).css(M ? {} : o.style).addClass("highcharts-bubble-legend-labels " + (i.labels.className || "")).add(this.legendItem.symbol), j = { x: y + w + i.labels.x, y: b + i.labels.y + 0.4 * P.getBBox().height };
+          P.attr(j), h.push(P), P.placed = !0, P.alignAttr = j;
+        }
+        getMaxLabelSize() {
+          let l, e;
+          return this.symbols.labels.forEach(function(t) {
+            e = t.getBBox(!0), l = l ? e.width > l.width ? e : l : e;
+          }), l || {};
+        }
+        formatLabel(l) {
+          let e = this.options, t = e.labels.formatter, i = e.labels.format, { numberFormatter: o } = this.chart;
+          return i ? Yt().format(i, l, this.chart) : t ? t.call(l) : o(l.value, 1);
+        }
+        hideOverlappingLabels() {
+          let l = this.chart, e = this.options.labels.allowOverlap, t = this.symbols;
+          !e && t && (l.hideOverlappingLabels(t.labels), t.labels.forEach(function(i, o) {
+            i.newOpacity ? i.newOpacity !== i.oldOpacity && t.connectors[o].show() : t.connectors[o].hide();
+          }));
+        }
+        getRanges() {
+          let l = this.legend.bubbleLegend, e = l.chart.series, t = l.options.ranges, i, o, r = Number.MAX_VALUE, a = -Number.MAX_VALUE;
+          return e.forEach(function(s) {
+            s.isBubble && !s.ignoreSeries && (o = s.getColumn("z").filter(hi)).length && (r = be(s.options.zMin, Math.min(r, Math.max(mo(o), s.options.displayNegative === !1 ? s.options.zThreshold : -Number.MAX_VALUE))), a = be(s.options.zMax, Math.max(a, uo(o))));
+          }), i = r === a ? [{ value: a }] : [{ value: r }, { value: (r + a) / 2 }, { value: a, autoRanges: !0 }], t.length && t[0].radius && i.reverse(), i.forEach(function(s, n) {
+            t && t[n] && (i[n] = ye(t[n], s));
+          }), i;
+        }
+        predictBubbleSizes() {
+          let l = this.chart, e = l.legend.options, t = e.floating, i = e.layout === "horizontal", o = i ? l.legend.lastLineHeight : 0, r = l.plotSizeX, a = l.plotSizeY, s = l.series[this.options.seriesIndex], n = s.getPxExtremes(), h = Math.ceil(n.minPxSize), p = Math.ceil(n.maxPxSize), d = Math.min(a, r), c, m = s.options.maxSize;
+          return t || !/%$/.test(m) ? c = p : (c = (d + o) * (m = parseFloat(m)) / 100 / (m / 100 + 1), (i && a - c >= r || !i && r - c >= a) && (c = p)), [h, Math.ceil(c)];
+        }
+        updateRanges(l, e) {
+          let t = this.legend.options.bubbleLegend;
+          t.minSize = l, t.maxSize = e, t.ranges = this.getRanges();
+        }
+        correctSizes() {
+          let l = this.legend, e = this.chart.series[this.options.seriesIndex].getPxExtremes();
+          Math.abs(Math.ceil(e.maxPxSize) - this.options.maxSize) > 1 && (this.updateRanges(this.options.minSize, e.maxPxSize), l.render());
+        }
+      }, { setOptions: yo } = v(), { composed: bo } = v(), { addEvent: pi, objectEach: xo, pushUnique: Mo, wrap: vo } = v();
+      function wo(l, e, t) {
+        let i, o, r, a = this.legend, s = yt(this) >= 0;
+        a && a.options.enabled && a.bubbleLegend && a.options.bubbleLegend.autoRanges && s ? (i = a.bubbleLegend.options, o = a.bubbleLegend.predictBubbleSizes(), a.bubbleLegend.updateRanges(o[0], o[1]), i.placed || (a.group.placed = !1, a.allItems.forEach((n) => {
+          (r = n.legendItem || {}).group && (r.group.translateY = void 0);
+        })), a.render(), i.placed || (this.getMargins(), this.axes.forEach((n) => {
+          n.setScale(), n.updateNames(), xo(n.ticks, function(h) {
+            h.isNew = !0, h.isNewLabel = !0;
+          });
+        }), this.getMargins()), i.placed = !0, l.call(this, e, t), a.bubbleLegend.correctSizes(), ci(a, di(a))) : (l.call(this, e, t), a && a.options.enabled && a.bubbleLegend && (a.render(), ci(a, di(a))));
+      }
+      function yt(l) {
+        let e = l.series, t = 0;
+        for (; t < e.length; ) {
+          if (e[t] && e[t].isBubble && e[t].visible && e[t].dataTable.rowCount) return t;
+          t++;
+        }
+        return -1;
+      }
+      function di(l) {
+        let e = l.allItems, t = [], i = e.length, o, r, a, s = 0, n = 0;
+        for (s = 0; s < i; s++) if (r = e[s].legendItem || {}, a = (e[s + 1] || {}).legendItem || {}, r.labelHeight && (e[s].itemHeight = r.labelHeight), e[s] === e[i - 1] || r.y !== a.y) {
+          for (t.push({ height: 0 }), o = t[t.length - 1]; n <= s; n++) e[n].itemHeight > o.height && (o.height = e[n].itemHeight);
+          o.step = s;
+        }
+        return t;
+      }
+      function Co(l) {
+        let e = this.bubbleLegend, t = this.options, i = t.bubbleLegend, o = yt(this.chart);
+        e && e.ranges && e.ranges.length && (i.ranges.length && (i.autoRanges = !!i.ranges[0].autoRanges), this.destroyItem(e)), o >= 0 && t.enabled && i.enabled && (i.seriesIndex = o, this.bubbleLegend = new fo(i, this), this.bubbleLegend.addToLegend(l.allItems));
+      }
+      function Po(l) {
+        let e;
+        if (l.defaultPrevented) return !1;
+        let t = l.legendItem, i = this.chart, o = t.visible;
+        this && this.bubbleLegend && (t.visible = !o, t.ignoreSeries = o, e = yt(i) >= 0, this.bubbleLegend.visible !== e && (this.update({ bubbleLegend: { enabled: e } }), this.bubbleLegend.visible = e), t.visible = o);
+      }
+      function ci(l, e) {
+        let t = l.allItems, i = l.options.rtl, o, r, a, s, n = 0;
+        t.forEach((h, p) => {
+          (s = h.legendItem || {}).group && (o = s.group.translateX || 0, r = s.y || 0, ((a = h.movementX) || i && h.ranges) && (a = i ? o - h.options.maxSize / 2 : o + a, s.group.attr({ translateX: a })), p > e[n].step && n++, s.group.attr({ translateY: Math.round(r + e[n].height / 2) }), s.y = r + e[n].height / 2);
+        });
+      }
+      let To = function(l, e) {
+        Mo(bo, "Series.BubbleLegend") && (yo({ legend: { bubbleLegend: po } }), vo(l.prototype, "drawChartBox", wo), pi(e, "afterGetAllItems", Co), pi(e, "itemClick", Po));
+      };
+      var Lo = C(260), Ao = C.n(Lo);
+      let { seriesTypes: { scatter: { prototype: { pointClass: jo } } } } = I(), { extend: ko } = v();
+      class ui extends jo {
+        haloPath(e) {
+          let t = (e && this.marker && this.marker.radius || 0) + e;
+          if (this.series.chart.inverted) {
+            let i = this.pos() || [0, 0], { xAxis: o, yAxis: r, chart: a } = this.series, s = 2 * t;
+            return a.renderer.symbols.circle((o?.len || 0) - i[1] - t, (r?.len || 0) - i[0] - t, s, s);
+          }
+          return Ao().prototype.haloPath.call(this, t);
+        }
+      }
+      ko(ui.prototype, { ttBelow: !1 });
+      let mi = ui, { composed: zo, noop: bt } = v(), { series: So, seriesTypes: { column: { prototype: Io }, scatter: gi } } = I(), { addEvent: Ge, arrayMax: Bo, arrayMin: Eo, clamp: Do, extend: xt, isNumber: q, merge: Oo, pick: _, pushUnique: Vo } = v();
+      function No() {
+        let l = this.len, { coll: e, isXAxis: t, min: i } = this, o = (this.max || 0) - (i || 0), r = 0, a = l, s = l / o, n;
+        (e === "xAxis" || e === "yAxis") && (this.series.forEach((h) => {
+          if (h.bubblePadding && h.reserveSpace()) {
+            this.allowZoomOutside = !0, n = !0;
+            let p = h.getColumn(t ? "x" : "y");
+            if (t && ((h.onPoint || h).getRadii(0, 0, h), h.onPoint && (h.radii = h.onPoint.radii)), o > 0) {
+              let d = p.length;
+              for (; d--; ) if (q(p[d]) && this.dataMin <= p[d] && p[d] <= this.max) {
+                let c = h.radii && h.radii[d] || 0;
+                r = Math.min((p[d] - i) * s - c, r), a = Math.max((p[d] - i) * s + c, a);
+              }
+            }
+          }
+        }), n && o > 0 && !this.logarithmic && (a -= l, s *= (l + Math.max(0, r) - Math.min(a, l)) / l, [["min", "userMin", r], ["max", "userMax", a]].forEach((h) => {
+          _(this.options[h[0]], this[h[1]]) === void 0 && (this[h[0]] += h[2] / s);
+        })));
+      }
+      function Xo() {
+        let { ticks: l, tickPositions: e, dataMin: t = 0, dataMax: i = 0, categories: o } = this, r = this.options.type;
+        if ((o?.length || r === "category") && this.series.find((a) => a.bubblePadding)) {
+          let a = e.length;
+          for (; a--; ) {
+            let s = l[e[a]], n = s.pos || 0;
+            (n > i || n < t) && s.label?.hide();
+          }
+        }
+      }
+      class oe extends gi {
+        static compose(e, t, i) {
+          To(t, i), Vo(zo, "Series.Bubble") && (Ge(e, "foundExtremes", No), Ge(e, "afterRender", Xo));
+        }
+        animate(e) {
+          !e && this.points.length < this.options.animationLimit && this.points.forEach(function(t) {
+            let { graphic: i, plotX: o = 0, plotY: r = 0 } = t;
+            i && i.width && (this.hasRendered || i.attr({ x: o, y: r, width: 1, height: 1 }), i.animate(this.markerAttribs(t), this.options.animation));
+          }, this);
+        }
+        getRadii() {
+          let e = this.getColumn("z"), t = this.getColumn("y"), i = [], o, r, a, s = this.chart.bubbleZExtremes, { minPxSize: n, maxPxSize: h } = this.getPxExtremes();
+          if (!s) {
+            let p, d = Number.MAX_VALUE, c = -Number.MAX_VALUE;
+            this.chart.series.forEach((m) => {
+              if (m.bubblePadding && m.reserveSpace()) {
+                let f = (m.onPoint || m).getZExtremes();
+                f && (d = Math.min(_(d, f.zMin), f.zMin), c = Math.max(_(c, f.zMax), f.zMax), p = !0);
+              }
+            }), p ? (s = { zMin: d, zMax: c }, this.chart.bubbleZExtremes = s) : s = { zMin: 0, zMax: 0 };
+          }
+          for (r = 0, o = e.length; r < o; r++) a = e[r], i.push(this.getRadius(s.zMin, s.zMax, n, h, a, t && t[r]));
+          this.radii = i;
+        }
+        getRadius(e, t, i, o, r, a) {
+          let s = this.options, n = s.sizeBy !== "width", h = s.zThreshold, p = t - e, d = 0.5;
+          if (a === null || r === null) return null;
+          if (q(r)) {
+            if (s.sizeByAbsoluteValue && (r = Math.abs(r - h), t = p = Math.max(t - h, Math.abs(e - h)), e = 0), r < e) return i / 2 - 1;
+            p > 0 && (d = (r - e) / p);
+          }
+          return n && d >= 0 && (d = Math.sqrt(d)), Math.ceil(i + d * (o - i)) / 2;
+        }
+        hasData() {
+          return !!this.dataTable.rowCount;
+        }
+        markerAttribs(e, t) {
+          let i = super.markerAttribs(e, t), { height: o = 0, width: r = 0 } = i;
+          return this.chart.inverted ? xt(i, { x: (e.plotX || 0) - r / 2, y: (e.plotY || 0) - o / 2 }) : i;
+        }
+        pointAttribs(e, t) {
+          let i = this.options.marker, o = i?.fillOpacity, r = So.prototype.pointAttribs.call(this, e, t);
+          return r["fill-opacity"] = o ?? 1, r;
+        }
+        translate() {
+          super.translate.call(this), this.getRadii(), this.translateBubble();
+        }
+        translateBubble() {
+          let { data: e, options: t, radii: i } = this, { minPxSize: o } = this.getPxExtremes(), r = e.length;
+          for (; r--; ) {
+            let a = e[r], s = i ? i[r] : 0;
+            this.zoneAxis === "z" && (a.negative = (a.z || 0) < (t.zThreshold || 0)), q(s) && s >= o / 2 ? (a.marker = xt(a.marker, { radius: s, width: 2 * s, height: 2 * s }), a.dlBox = { x: a.plotX - s, y: a.plotY - s, width: 2 * s, height: 2 * s }) : (a.shapeArgs = a.plotY = a.dlBox = void 0, a.isInside = !1);
+          }
+        }
+        getPxExtremes() {
+          let e = Math.min(this.chart.plotWidth, this.chart.plotHeight), t = (r) => {
+            let a;
+            return typeof r == "string" && (a = /%$/.test(r), r = parseInt(r, 10)), a ? e * r / 100 : r;
+          }, i = t(_(this.options.minSize, 8)), o = Math.max(t(_(this.options.maxSize, "20%")), i);
+          return { minPxSize: i, maxPxSize: o };
+        }
+        getZExtremes() {
+          let e = this.options, t = this.getColumn("z").filter(q);
+          if (t.length) {
+            let i = _(e.zMin, Do(Eo(t), e.displayNegative === !1 ? e.zThreshold || 0 : -Number.MAX_VALUE, Number.MAX_VALUE)), o = _(e.zMax, Bo(t));
+            if (q(i) && q(o)) return { zMin: i, zMax: o };
+          }
+        }
+        searchKDTree(e, t, i, o = bt, r = bt) {
+          return o = (a, s, n) => {
+            let h = a[n] || 0, p = s[n] || 0, d, c = !1;
+            return h === p ? d = a.index > s.index ? a : s : h < 0 && p < 0 ? (d = h - (a.marker?.radius || 0) >= p - (s.marker?.radius || 0) ? a : s, c = !0) : d = h < p ? a : s, [d, c];
+          }, r = (a, s, n) => !n && a > s || a < s, super.searchKDTree(e, t, i, o, r);
+        }
+      }
+      oe.defaultOptions = Oo(gi.defaultOptions, { dataLabels: { formatter: function() {
+        let { numberFormatter: l } = this.series.chart, { z: e } = this.point;
+        return q(e) ? l(e, -1) : "";
+      }, inside: !0, verticalAlign: "middle" }, animationLimit: 250, marker: { lineColor: null, lineWidth: 1, fillOpacity: 0.5, radius: null, states: { hover: { radiusPlus: 0 } }, symbol: "circle" }, minSize: 8, maxSize: "20%", softThreshold: !1, states: { hover: { halo: { size: 5 } } }, tooltip: { pointFormat: "({point.x}, {point.y}), Size: {point.z}" }, turboThreshold: 0, zThreshold: 0, zoneAxis: "z" }), xt(oe.prototype, { alignDataLabel: Io.alignDataLabel, applyZones: bt, bubblePadding: !0, isBubble: !0, keysAffectYAxis: ["y"], pointArrayMap: ["y", "z"], pointClass: mi, parallelArrays: ["x", "y", "z"], trackerGroups: ["group", "dataLabelsGroup"], specialGroup: "group", zoneAxis: "z" }), Ge(oe, "updatedData", (l) => {
+        delete l.target.chart.bubbleZExtremes;
+      }), Ge(oe, "remove", (l) => {
+        delete l.target.chart.bubbleZExtremes;
+      }), I().registerSeriesType("bubble", oe);
+      let fi = oe, { seriesTypes: { map: { prototype: { pointClass: { prototype: yi } } } } } = I(), { extend: Yo } = v();
+      class bi extends mi {
+        isValid() {
+          return typeof this.z == "number";
+        }
+      }
+      Yo(bi.prototype, { applyOptions: yi.applyOptions, getProjectedBounds: yi.getProjectedBounds });
+      let { seriesTypes: { map: { prototype: re }, mappoint: { prototype: xi } } } = I(), { extend: Go, merge: Ro } = v();
+      class Re extends fi {
+        constructor() {
+          super(...arguments), this.clearBounds = re.clearBounds;
+        }
+        searchPoint(e, t) {
+          return this.searchKDTree({ plotX: e.chartX - this.chart.plotLeft, plotY: e.chartY - this.chart.plotTop }, t, e);
+        }
+        translate() {
+          xi.translate.call(this), this.getRadii(), this.translateBubble();
+        }
+      }
+      Re.defaultOptions = Ro(fi.defaultOptions, { lineWidth: 0, animationLimit: 500, joinBy: "hc-key", tooltip: { pointFormat: "{point.name}: {point.z}" }, stickyTracking: !0 }), Go(Re.prototype, { type: "mapbubble", axisTypes: ["colorAxis"], getProjectedBounds: re.getProjectedBounds, isCartesian: !1, pointArrayMap: ["z"], pointClass: bi, processData: re.processData, projectPoint: xi.projectPoint, kdAxisArray: ["plotX", "plotY"], setData: re.setData, setOptions: re.setOptions, updateData: re.updateData, useMapGeometry: !0, xyFromShape: !0 }), I().registerSeriesType("mapbubble", Re);
+      let { scatter: { prototype: { pointClass: Fo } } } = I().seriesTypes, { clamp: Fe, defined: Wo, extend: Uo, pick: Zo } = v();
+      class Mi extends Fo {
+        applyOptions(e, t) {
+          return (this.isNull || this.value === null) && delete this.color, super.applyOptions(e, t), this.formatPrefix = this.isNull || this.value === null ? "null" : "point", this;
+        }
+        getCellAttributes() {
+          let e = this.series, t = e.options, i = (t.colsize || 1) / 2, o = (t.rowsize || 1) / 2, r = e.xAxis, a = e.yAxis, s = this.options.marker || e.options.marker, n = e.pointPlacementToXValue(), h = Zo(this.pointPadding, t.pointPadding, 0), p = { x1: Fe(Math.round(r.len - r.translate(this.x - i, !1, !0, !1, !0, -n)), -r.len, 2 * r.len), x2: Fe(Math.round(r.len - r.translate(this.x + i, !1, !0, !1, !0, -n)), -r.len, 2 * r.len), y1: Fe(Math.round(a.translate(this.y - o, !1, !0, !1, !0)), -a.len, 2 * a.len), y2: Fe(Math.round(a.translate(this.y + o, !1, !0, !1, !0)), -a.len, 2 * a.len) };
+          for (let d of [["width", "x"], ["height", "y"]]) {
+            let c = d[0], m = d[1], f = m + "1", u = m + "2", g = Math.abs(p[f] - p[u]), y = s && s.lineWidth || 0, b = Math.abs(p[f] + p[u]) / 2, x = s && s[c];
+            if (Wo(x) && x < g) {
+              let M = x / 2 + y / 2;
+              p[f] = b - M, p[u] = b + M;
+            }
+            h && ((m === "x" && r.reversed || m === "y" && !a.reversed) && (f = u, u = m + "1"), p[f] += h, p[u] -= h);
+          }
+          return p;
+        }
+        haloPath(e) {
+          if (!e) return [];
+          let { x: t = 0, y: i = 0, width: o = 0, height: r = 0 } = this.shapeArgs || {};
+          return [["M", t - e, i - e], ["L", t - e, i + r + e], ["L", t + o + e, i + r + e], ["L", t + o + e, i - e], ["Z"]];
+        }
+        isValid() {
+          return this.value !== 1 / 0 && this.value !== -1 / 0;
+        }
+      }
+      Uo(Mi.prototype, { dataLabelOnNull: !0, moveToTopOnHover: !0, ttBelow: !1 });
+      let { isNumber: Ho } = v(), { doc: $o } = v(), { defined: Ko, pick: vi } = v(), { series: ae, seriesTypes: { column: qo, scatter: wi } } = I(), { prototype: { symbols: We } } = pt(), { addEvent: _o, extend: Jo, fireEvent: Qo, isNumber: Ue, merge: Mt, pick: er } = v(), { colorFromPoint: tr, getContext: ir } = { colorFromPoint: function(l, e) {
+        let t = e.series.colorAxis;
+        if (t) {
+          let i = t.toColor(l || 0, e).split(")")[0].split("(")[1].split(",").map((o) => vi(parseFloat(o), parseInt(o, 10)));
+          return i[3] = 255 * vi(i[3], 1), Ko(l) && e.visible || (i[3] = 0), i;
+        }
+        return [0, 0, 0, 0];
+      }, getContext: function(l) {
+        let { canvas: e, context: t } = l;
+        return e && t ? (t.clearRect(0, 0, e.width, e.height), t) : (l.canvas = $o.createElement("canvas"), l.context = l.canvas.getContext("2d", { willReadFrequently: !0 }) || void 0, l.context);
+      } };
+      class xe extends wi {
+        constructor() {
+          super(...arguments), this.valueMax = NaN, this.valueMin = NaN, this.isDirtyCanvas = !0;
+        }
+        drawPoints() {
+          let e = this, t = e.options, i = t.interpolation, o = t.marker || {};
+          if (i) {
+            let { image: r, chart: a, xAxis: s, yAxis: n } = e, { reversed: h = !1, len: p } = s, { reversed: d = !1, len: c } = n, m = { width: p, height: c };
+            if (!r || e.isDirtyData || e.isDirtyCanvas) {
+              let f = ir(e), { canvas: u, options: { colsize: g = 1, rowsize: y = 1 }, points: b, points: { length: x } } = e, M = a.colorAxis && a.colorAxis[0];
+              if (u && f && M) {
+                let { min: w, max: P } = s.getExtremes(), { min: j, max: L } = n.getExtremes(), T = P - w, z = L - j, V = Math.round(T / g / 8 * 8), R = Math.round(z / y / 8 * 8), [Me, ve] = [[V, V / T, h, "ceil"], [R, R / z, !d, "floor"]].map(([J, U, vt, Ze]) => vt ? (wt) => Math[Ze](J - U * wt) : (wt) => Math[Ze](U * wt)), we = u.width = V + 1, Ce = we * (u.height = R + 1), or = (x - 1) / Ce, Ci = new Uint8ClampedArray(4 * Ce), rr = (J, U) => 4 * Math.ceil(we * ve(U - j) + Me(J - w));
+                e.buildKDTree();
+                for (let J = 0; J < Ce; J++) {
+                  let U = b[Math.ceil(or * J)], { x: vt, y: Ze } = U;
+                  Ci.set(tr(U.value, U), rr(vt, Ze));
+                }
+                f.putImageData(new ImageData(Ci, we), 0, 0), r ? r.attr({ ...m, href: u.toDataURL("image/png", 1) }) : (e.directTouch = !1, e.image = a.renderer.image(u.toDataURL("image/png", 1)).attr(m).add(e.group));
+              }
+              e.isDirtyCanvas = !1;
+            } else (r.width !== p || r.height !== c) && r.attr(m);
+          } else (o.enabled || e._hasPointMarkers) && (ae.prototype.drawPoints.call(e), e.points.forEach((r) => {
+            r.graphic && (r.graphic[e.chart.styledMode ? "css" : "animate"](e.colorAttribs(r)), r.value === null && r.graphic.addClass("highcharts-null-point"));
+          }));
+        }
+        getExtremes() {
+          let { dataMin: e, dataMax: t } = ae.prototype.getExtremes.call(this, this.getColumn("value"));
+          return Ue(e) && (this.valueMin = e), Ue(t) && (this.valueMax = t), ae.prototype.getExtremes.call(this);
+        }
+        getValidPoints(e, t) {
+          return ae.prototype.getValidPoints.call(this, e, t, !0);
+        }
+        hasData() {
+          return !!this.dataTable.rowCount;
+        }
+        init() {
+          super.init.apply(this, arguments);
+          let e = this.options;
+          e.pointRange = er(e.pointRange, e.colsize || 1), this.yAxis.axisPointRange = e.rowsize || 1, We.ellipse = We.circle, e.marker && Ue(e.borderRadius) && (e.marker.r = e.borderRadius);
+        }
+        markerAttribs(e, t) {
+          let i = e.shapeArgs || {};
+          if (e.hasImage) return { x: e.plotX, y: e.plotY };
+          if (t && t !== "normal") {
+            let o = e.options.marker || {}, r = this.options.marker || {}, a = r.states?.[t] || {}, s = o.states?.[t] || {}, n = (s.width || a.width || i.width || 0) + (s.widthPlus || a.widthPlus || 0), h = (s.height || a.height || i.height || 0) + (s.heightPlus || a.heightPlus || 0);
+            return { x: (i.x || 0) + ((i.width || 0) - n) / 2, y: (i.y || 0) + ((i.height || 0) - h) / 2, width: n, height: h };
+          }
+          return i;
+        }
+        pointAttribs(e, t) {
+          let i = ae.prototype.pointAttribs.call(this, e, t), o = this.options || {}, r = this.chart.options.plotOptions || {}, a = r.series || {}, s = r.heatmap || {}, n = e?.options.borderColor || o.borderColor || s.borderColor || a.borderColor, h = e?.options.borderWidth || o.borderWidth || s.borderWidth || a.borderWidth || i["stroke-width"];
+          if (i.stroke = e?.marker?.lineColor || o.marker?.lineColor || n || this.color, i["stroke-width"] = h, t && t !== "normal") {
+            let p = Mt(o.states?.[t], o.marker?.states?.[t], e?.options.marker?.states?.[t] || {});
+            i.fill = p.color || it().parse(i.fill).brighten(p.brightness || 0).get(), i.stroke = p.lineColor || i.stroke;
+          }
+          return i;
+        }
+        translate() {
+          let { borderRadius: e, marker: t } = this.options, i = t?.symbol || "rect", o = We[i] ? i : "rect", r = ["circle", "square"].indexOf(o) !== -1;
+          for (let a of (this.generatePoints(), this.points)) {
+            let s = a.getCellAttributes(), n = Math.min(s.x1, s.x2), h = Math.min(s.y1, s.y2), p = Math.max(Math.abs(s.x2 - s.x1), 0), d = Math.max(Math.abs(s.y2 - s.y1), 0);
+            if (a.hasImage = (a.marker?.symbol || i).indexOf("url") === 0, r) {
+              let c = Math.abs(p - d);
+              n = Math.min(s.x1, s.x2) + (p < d ? 0 : c / 2), h = Math.min(s.y1, s.y2) + (p < d ? c / 2 : 0), p = d = Math.min(p, d);
+            }
+            a.hasImage && (a.marker = { width: p, height: d }), a.plotX = a.clientX = (s.x1 + s.x2) / 2, a.plotY = (s.y1 + s.y2) / 2, a.shapeType = "path", a.shapeArgs = Mt(!0, { x: n, y: h, width: p, height: d }, { d: We[o](n, h, p, d, { r: Ue(e) ? e : 0 }) });
+          }
+          Qo(this, "afterTranslate");
+        }
+      }
+      xe.defaultOptions = Mt(wi.defaultOptions, { animation: !1, borderRadius: 0, borderWidth: 0, interpolation: !1, nullColor: "#f7f7f7", dataLabels: { formatter: function() {
+        let { numberFormatter: l } = this.series.chart, { value: e } = this.point;
+        return Ho(e) ? l(e, -1) : "";
+      }, inside: !0, verticalAlign: "middle", crop: !1, overflow: "allow", padding: 0 }, marker: { symbol: "rect", radius: 0, lineColor: void 0, states: { hover: { lineWidthPlus: 0 }, select: {} } }, clip: !0, pointRange: null, tooltip: { pointFormat: "{point.x}, {point.y}: {point.value}<br/>" }, states: { hover: { halo: !1, brightness: 0.2 } }, legendSymbol: "rectangle" }), _o(xe, "afterDataClassLegendClick", function() {
+        this.isDirtyCanvas = !0, this.drawPoints(), this.options.enableMouseTracking && this.drawTracker();
+      }), Jo(xe.prototype, { axisTypes: B.seriesMembers.axisTypes, colorKey: B.seriesMembers.colorKey, directTouch: !0, getExtremesFromAll: !0, keysAffectYAxis: ["y"], parallelArrays: B.seriesMembers.parallelArrays, pointArrayMap: ["y", "value"], pointClass: Mi, specialGroup: "group", trackerGroups: B.seriesMembers.trackerGroups, alignDataLabel: qo.prototype.alignDataLabel, colorAttribs: B.seriesMembers.colorAttribs, getSymbol: ae.prototype.getSymbol }), B.compose(xe), I().registerSeriesType("heatmap", xe);
+      let A = v();
+      A.ColorMapComposition = B, A.MapChart = A.MapChart || Ie, A.MapNavigation = A.MapNavigation || ze, A.MapView = A.MapView || X, A.Projection = A.Projection || E, A.mapChart = A.Map = A.MapChart.mapChart, A.maps = A.MapChart.maps, A.geojson = Be.geojson, A.topo2geo = Be.topo2geo, Be.compose(A.Chart), Re.compose(A.Axis, A.Chart, A.Legend), ze.compose(Ie, A.Pointer, A.SVGRenderer), X.compose(Ie);
+      let sr = v();
+      return Tt.default;
+    })());
+  })(He)), He.exports;
+}
+var Ti = hr();
+const pr = /* @__PURE__ */ ar(Ti), cr = /* @__PURE__ */ nr({
+  __proto__: null,
+  default: pr
+}, [Ti]);
+export {
+  cr as m
+};