@mobileaction/action-kit 1.45.0 → 1.45.2

package/dist/map-D9nlD3zg.js

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