@mobileaction/action-kit 1.58.12 → 1.58.14

package/dist/map-f19ptDB7.js

@@ -0,0 +1,2648 @@
+import { t as e } from "./chunk-BdsCSvBP.js";
+//#region node_modules/highcharts/modules/map.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	(function(n, r) {
+		typeof e == "object" && typeof t == "object" ? t.exports = r(n._Highcharts, n._Highcharts.Axis, n._Highcharts.Color, n._Highcharts.LegendSymbol, n._Highcharts.SeriesRegistry, n._Highcharts.SVGElement, n._Highcharts.Series, n._Highcharts.Chart, n._Highcharts.SVGRenderer, n._Highcharts.Templating, n._Highcharts.Series.types.scatter, n._Highcharts.Point) : typeof define == "function" && define.amd ? define("highcharts/modules/map", ["highcharts/highcharts"], function(e) {
+			return r(e, e.Axis, e.Color, e.LegendSymbol, e.SeriesRegistry, e.SVGElement, e.Series, e.Chart, e.SVGRenderer, e.Templating, e.Series, ["types"], ["scatter"], e.Point);
+		}) : typeof e == "object" ? e["highcharts/modules/map"] = r(n._Highcharts, n._Highcharts.Axis, n._Highcharts.Color, n._Highcharts.LegendSymbol, n._Highcharts.SeriesRegistry, n._Highcharts.SVGElement, n._Highcharts.Series, n._Highcharts.Chart, n._Highcharts.SVGRenderer, n._Highcharts.Templating, n._Highcharts.Series.types.scatter, n._Highcharts.Point) : n.Highcharts = r(n.Highcharts, n.Highcharts.Axis, n.Highcharts.Color, n.Highcharts.LegendSymbol, n.Highcharts.SeriesRegistry, n.Highcharts.SVGElement, n.Highcharts.Series, n.Highcharts.Chart, n.Highcharts.SVGRenderer, n.Highcharts.Templating, n.Highcharts.Series.types.scatter, n.Highcharts.Point);
+	})("u" < typeof window ? e : window, (e, t, n, r, i, a, o, s, c, l, u, d) => (() => {
+		let f;
+		var p, m, h, g, _, v, y, b, x, S, C, ee = {
+			28: (e) => {
+				e.exports = a;
+			},
+			260: (e) => {
+				e.exports = d;
+			},
+			500: (e) => {
+				e.exports = r;
+			},
+			512: (e) => {
+				e.exports = i;
+			},
+			532: (e) => {
+				e.exports = t;
+			},
+			540: (e) => {
+				e.exports = c;
+			},
+			620: (e) => {
+				e.exports = n;
+			},
+			632: (e) => {
+				e.exports = u;
+			},
+			820: (e) => {
+				e.exports = o;
+			},
+			944: (t) => {
+				t.exports = e;
+			},
+			960: (e) => {
+				e.exports = s;
+			},
+			984: (e) => {
+				e.exports = l;
+			}
+		}, te = {};
+		function w(e) {
+			var t = te[e];
+			if (t !== void 0) return t.exports;
+			var n = te[e] = { exports: {} };
+			return ee[e](n, n.exports, w), n.exports;
+		}
+		w.n = (e) => {
+			var t = e && e.__esModule ? () => e.default : () => e;
+			return w.d(t, { a: t }), t;
+		}, w.d = (e, t) => {
+			for (var n in t) w.o(t, n) && !w.o(e, n) && Object.defineProperty(e, n, {
+				enumerable: !0,
+				get: t[n]
+			});
+		}, w.o = (e, t) => Object.prototype.hasOwnProperty.call(e, t);
+		var ne = {};
+		w.d(ne, { default: () => pi });
+		var re = w(944), T = w.n(re), ie = w(532), ae = w.n(ie), oe = w(620), se = w.n(oe);
+		let { parse: ce } = se(), { merge: le } = T();
+		(p = _ ||= {}).initDataClasses = function(e) {
+			let t = this.chart, n = this.legendItem = this.legendItem || {}, r = this.options, i = e.dataClasses || [], a, o, s = t.options.chart.colorCount, c = 0, l;
+			this.dataClasses = o = [], n.labels = [];
+			for (let e = 0, n = i.length; e < n; ++e) a = le(a = i[e]), o.push(a), (t.styledMode || !a.color) && (r.dataClassColor === "category" ? (t.styledMode || (s = (l = t.options.colors || []).length, a.color = l[c]), a.colorIndex = c, ++c === s && (c = 0)) : a.color = ce(r.minColor).tweenTo(ce(r.maxColor), n < 2 ? .5 : e / (n - 1)));
+		}, p.initStops = function() {
+			let e = this.options, t = this.stops = e.stops || [[0, e.minColor || ""], [1, e.maxColor || ""]];
+			for (let e = 0, n = t.length; e < n; ++e) t[e].color = ce(t[e][1]);
+		}, p.normalizedValue = function(e) {
+			let t = this.max || 0, n = this.min || 0;
+			return this.logarithmic && (e = this.logarithmic.log2lin(e)), 1 - (t - e) / (t - n || 1);
+		}, p.toColor = function(e, t) {
+			let n, r, i, a, o, s, c = this.dataClasses, l = this.stops;
+			if (c) {
+				for (s = c.length; s--;) if (r = (o = c[s]).from, i = o.to, (r === void 0 || e >= r) && (i === void 0 || e <= i)) {
+					a = o.color, t && (t.dataClass = s, t.colorIndex = o.colorIndex);
+					break;
+				}
+			} else {
+				for (n = this.normalizedValue(e), s = l.length; s-- && !(n > l[s][0]););
+				r = l[s] || l[s + 1], n = 1 - ((i = l[s + 1] || r)[0] - n) / (i[0] - r[0] || 1), a = r.color.tweenTo(i.color, n);
+			}
+			return a;
+		};
+		let ue = _, { parse: de } = se(), { addEvent: E, extend: fe, merge: pe, pick: me, splat: he } = T();
+		(function(e) {
+			let t;
+			function n() {
+				let { userOptions: e } = this;
+				this.colorAxis = [], e.colorAxis && (e.colorAxis = he(e.colorAxis), e.colorAxis.map((e) => new t(this, e)));
+			}
+			function r(e) {
+				let t = this.chart.colorAxis || [], n = (t) => {
+					let n = e.allItems.indexOf(t);
+					n !== -1 && (this.destroyItem(e.allItems[n]), e.allItems.splice(n, 1));
+				}, r = [], i, a;
+				for (t.forEach(function(e) {
+					i = e.options, i?.showInLegend && (i.dataClasses && i.visible ? r = r.concat(e.getDataClassLegendSymbols()) : i.visible && r.push(e), e.series.forEach(function(e) {
+						(!e.options.showInLegend || i.dataClasses) && (e.options.legendType === "point" ? e.points.forEach(function(e) {
+							n(e);
+						}) : n(e));
+					}));
+				}), a = r.length; a--;) e.allItems.unshift(r[a]);
+			}
+			function i(e) {
+				e.visible && e.item.legendColor && e.item.legendItem.symbol.attr({ fill: e.item.legendColor });
+			}
+			function a(e) {
+				this.chart.colorAxis?.forEach((t) => {
+					t.update({}, e.redraw);
+				});
+			}
+			function o() {
+				(this.chart.colorAxis?.length || this.colorAttribs) && this.translateColors();
+			}
+			function s() {
+				let e = this.axisTypes;
+				e ? e.indexOf("colorAxis") === -1 && e.push("colorAxis") : this.axisTypes = ["colorAxis"];
+			}
+			function c(e) {
+				let t = this, n = e ? "show" : "hide";
+				t.visible = t.options.visible = !!e, ["graphic", "dataLabel"].forEach(function(e) {
+					t[e] && t[e][n]();
+				}), this.series.buildKDTree();
+			}
+			function l() {
+				let e = this, t = this.getPointsCollection(), n = this.options.nullColor, r = this.colorAxis, i = this.colorKey;
+				t.forEach((t) => {
+					let a = t.getNestedProperty(i), o = t.options.color || (t.isNull || t.value === null ? n : r && a !== void 0 ? r.toColor(a, t) : t.color || e.color);
+					o && t.color !== o && (t.color = o, e.options.legendType === "point" && t.legendItem && t.legendItem.label && e.chart.legend.colorizeItem(t, t.visible));
+				});
+			}
+			function u() {
+				this.elem.attr("fill", de(this.start).tweenTo(de(this.end), this.pos), void 0, !0);
+			}
+			function d() {
+				this.elem.attr("stroke", de(this.start).tweenTo(de(this.end), this.pos), void 0, !0);
+			}
+			e.compose = function(e, f, p, m, h) {
+				var g;
+				let _, v = f.prototype, y = p.prototype, b = h.prototype;
+				v.collectionsWithUpdate.includes("colorAxis") || (t = e, v.collectionsWithUpdate.push("colorAxis"), v.collectionsWithInit.colorAxis = [v.addColorAxis], E(f, "afterCreateAxes", n), _ = (g = f).prototype.createAxis, g.prototype.createAxis = function(e, n) {
+					if (e !== "colorAxis") return _.apply(this, arguments);
+					let r = new t(this, pe(n.axis, {
+						index: this[e].length,
+						isX: !1
+					}));
+					return this.isDirtyLegend = !0, this.axes.forEach((e) => {
+						e.series = [];
+					}), this.series.forEach((e) => {
+						e.bindAxes(), e.isDirtyData = !0;
+					}), me(n.redraw, !0) && this.redraw(n.animation), r;
+				}, y.fillSetter = u, y.strokeSetter = d, E(m, "afterGetAllItems", r), E(m, "afterColorizeItem", i), E(m, "afterUpdate", a), fe(b, {
+					optionalAxis: "colorAxis",
+					translateColors: l
+				}), fe(b.pointClass.prototype, { setVisible: c }), E(h, "afterTranslate", o, { order: 1 }), E(h, "bindAxes", s));
+			}, e.pointSetVisible = c;
+		})(v ||= {});
+		let ge = v;
+		var _e = w(500), ve = w.n(_e), ye = w(512), D = w.n(ye);
+		let { defaultOptions: be } = T(), { series: xe } = D(), { defined: Se, extend: Ce, fireEvent: we, isArray: Te, isNumber: Ee, merge: De, pick: O, relativeLength: Oe } = T();
+		be.colorAxis = De(be.xAxis, {
+			lineWidth: 0,
+			minPadding: 0,
+			maxPadding: 0,
+			gridLineColor: "#ffffff",
+			gridLineWidth: 1,
+			tickPixelInterval: 72,
+			startOnTick: !0,
+			endOnTick: !0,
+			offset: 0,
+			marker: {
+				animation: { duration: 50 },
+				width: .01,
+				color: "#999999"
+			},
+			labels: {
+				distance: 8,
+				overflow: "justify",
+				rotation: 0
+			},
+			minColor: "#e6e9ff",
+			maxColor: "#0022ff",
+			tickLength: 5,
+			showInLegend: !0
+		});
+		class k extends ae() {
+			static compose(e, t, n, r) {
+				ge.compose(k, e, t, n, r);
+			}
+			constructor(e, t) {
+				super(e, t), this.coll = "colorAxis", this.visible = !0, this.init(e, t);
+			}
+			init(e, t) {
+				let n = e.options.legend || {}, r = t.layout ? t.layout !== "vertical" : n.layout !== "vertical";
+				this.side = t.side || r ? 2 : 1, this.reversed = t.reversed, this.opposite = !r, super.init(e, t, "colorAxis"), this.userOptions = t, Te(e.userOptions.colorAxis) && (e.userOptions.colorAxis[this.index] = t), t.dataClasses && this.initDataClasses(t), this.initStops(), this.horiz = r, this.zoomEnabled = !1;
+			}
+			hasData() {
+				return !!(this.tickPositions || []).length;
+			}
+			setTickPositions() {
+				if (!this.dataClasses) return super.setTickPositions();
+			}
+			setOptions(e) {
+				let t = De(be.colorAxis, e, {
+					showEmpty: !1,
+					title: null,
+					visible: this.chart.options.legend.enabled && !1 !== e.visible
+				});
+				super.setOptions(t), this.options.crosshair = this.options.marker;
+			}
+			setAxisSize() {
+				let e = this.chart, t = this.legendItem?.symbol, { width: n, height: r } = this.getSize();
+				t && (this.left = +t.attr("x"), this.top = +t.attr("y"), this.width = n = +t.attr("width"), this.height = r = +t.attr("height"), this.right = e.chartWidth - this.left - n, this.bottom = e.chartHeight - this.top - r, this.pos = this.horiz ? this.left : this.top), this.len = (this.horiz ? n : r) || k.defaultLegendLength;
+			}
+			getOffset() {
+				let e = this.legendItem?.group, t = this.chart.axisOffset[this.side];
+				if (e) {
+					this.axisParent = e, super.getOffset();
+					let n = this.chart.legend;
+					n.allItems.forEach(function(e) {
+						e instanceof k && e.drawLegendSymbol(n, e);
+					}), n.render(), this.chart.getMargins(!0), this.chart.series.some((e) => e.isDrilling) || (this.isDirty = !0), this.added ||= !0, this.labelLeft = 0, this.labelRight = this.width, this.chart.axisOffset[this.side] = t;
+				}
+			}
+			setLegendColor() {
+				let e = this.horiz, t = this.reversed, n = +!!t, r = +!t, i = e ? [
+					n,
+					0,
+					r,
+					0
+				] : [
+					0,
+					r,
+					0,
+					n
+				];
+				this.legendColor = {
+					linearGradient: {
+						x1: i[0],
+						y1: i[1],
+						x2: i[2],
+						y2: i[3]
+					},
+					stops: this.stops
+				};
+			}
+			drawLegendSymbol(e, t) {
+				let n = t.legendItem || {}, r = e.padding, i = e.options, a = this.options.labels, o = O(i.itemDistance, 10), s = this.horiz, { width: c, height: l } = this.getSize(), u = O(i.labelPadding, s ? 16 : 30);
+				this.setLegendColor(), n.symbol ||= this.chart.renderer.symbol("roundedRect").attr({
+					r: i.symbolRadius ?? 3,
+					zIndex: 1
+				}).add(n.group), n.symbol.attr({
+					x: 0,
+					y: (e.baseline || 0) - 11,
+					width: c,
+					height: l
+				}), n.labelWidth = c + r + (s ? o : O(a.x, a.distance) + (this.maxLabelLength || 0)), n.labelHeight = l + r + (s ? u : 0);
+			}
+			setState(e) {
+				this.series.forEach(function(t) {
+					t.setState(e);
+				});
+			}
+			setVisible() {}
+			getSeriesExtremes() {
+				let e = this.series, t, n, r, i, a = e.length;
+				for (this.dataMin = Infinity, this.dataMax = -Infinity; a--;) {
+					for (let o of (n = (i = e[a]).colorKey = O(i.options.colorKey, i.colorKey, i.pointValKey, i.zoneAxis, "y"), r = i[n + "Min"] && i[n + "Max"], [
+						n,
+						"value",
+						"y"
+					])) if ((t = i.getColumn(o)).length) break;
+					if (r) i.minColorValue = i[n + "Min"], i.maxColorValue = i[n + "Max"];
+					else {
+						let e = xe.prototype.getExtremes.call(i, t);
+						i.minColorValue = e.dataMin, i.maxColorValue = e.dataMax;
+					}
+					Se(i.minColorValue) && Se(i.maxColorValue) && (this.dataMin = Math.min(this.dataMin, i.minColorValue), this.dataMax = Math.max(this.dataMax, i.maxColorValue)), r || xe.prototype.applyExtremes.call(i);
+				}
+			}
+			drawCrosshair(e, t) {
+				let n, r = this.legendItem || {}, i = t?.plotX, a = t?.plotY, o = this.pos, s = this.len;
+				t && ((n = this.toPixels(t.getNestedProperty(t.series.colorKey))) < o ? n = o - 2 : n > o + s && (n = o + s + 2), t.plotX = n, t.plotY = this.len - n, super.drawCrosshair(e, t), t.plotX = i, t.plotY = a, this.cross && !this.cross.addedToColorAxis && r.group && (this.cross.addClass("highcharts-coloraxis-marker").add(r.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, n = e.translatedValue, r = this.top;
+				return Ee(n) ? this.horiz ? [
+					[
+						"M",
+						n - 4,
+						r - 6
+					],
+					[
+						"L",
+						n + 4,
+						r - 6
+					],
+					[
+						"L",
+						n,
+						r
+					],
+					["Z"]
+				] : [
+					[
+						"M",
+						t,
+						n
+					],
+					[
+						"L",
+						t - 6,
+						n + 6
+					],
+					[
+						"L",
+						t - 6,
+						n - 6
+					],
+					["Z"]
+				] : super.getPlotLinePath(e);
+			}
+			update(e, t) {
+				let n = this.chart.legend;
+				this.series.forEach((e) => {
+					e.isDirtyData = !0;
+				}), (e.dataClasses && n.allItems || this.dataClasses) && this.destroyItems(), super.update(e, t), this.legendItem?.label && (this.setLegendColor(), n.colorizeItem(this, !0));
+			}
+			destroyItems() {
+				let e = this.chart, t = this.legendItem || {};
+				if (t.label) e.legend.destroyItem(this);
+				else if (t.labels) for (let n of t.labels) e.legend.destroyItem(n);
+				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, n = t.chart, r = t.legendItem && t.legendItem.labels || [], i = n.options.legend, a = O(i.valueDecimals, -1), o = O(i.valueSuffix, ""), s = (e) => t.series.reduce((t, n) => (t.push(...n.points.filter((t) => t.dataClass === e)), t), []);
+				return r.length || t.dataClasses.forEach((i, c) => {
+					let l = i.from, u = i.to, { numberFormatter: d } = n, f = !0;
+					e = "", l === void 0 ? e = "< " : u === void 0 && (e = "> "), l !== void 0 && (e += d(l, a) + o), l !== void 0 && u !== void 0 && (e += " - "), u !== void 0 && (e += d(u, a) + o), r.push(Ce({
+						chart: n,
+						name: e,
+						options: {},
+						drawLegendSymbol: ve().rectangle,
+						visible: !0,
+						isDataClass: !0,
+						setState: (e) => {
+							for (let t of s(c)) t.setState(e);
+						},
+						setVisible: function() {
+							this.visible = f = t.visible = !f;
+							let e = [];
+							for (let t of s(c)) t.setVisible(f), t.hiddenInDataClass = !f, e.indexOf(t.series) === -1 && e.push(t.series);
+							n.legend.colorizeItem(this, f), e.forEach((e) => {
+								we(e, "afterDataClassLegendClick");
+							});
+						}
+					}, i));
+				}), r;
+			}
+			getSize() {
+				let { chart: e, horiz: t } = this, { height: n, width: r } = this.options, { legend: i } = e.options;
+				return {
+					width: O(Se(r) ? Oe(r, e.chartWidth) : void 0, i?.symbolWidth, t ? k.defaultLegendLength : 12),
+					height: O(Se(n) ? Oe(n, e.chartHeight) : void 0, i?.symbolHeight, t ? 12 : k.defaultLegendLength)
+				};
+			}
+		}
+		k.defaultLegendLength = 200, k.keepProps = ["legendItem"], Ce(k.prototype, ue), Array.prototype.push.apply(ae().keepProps, k.keepProps);
+		let A = T();
+		A.ColorAxis = A.ColorAxis || k, A.ColorAxis.compose(A.Chart, A.Fx, A.Legend, A.Series);
+		let ke = {
+			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(.5);
+						},
+						text: "+",
+						y: 0
+					},
+					zoomOut: {
+						onclick: function() {
+							this.mapZoom(2);
+						},
+						text: "-",
+						y: 28
+					}
+				},
+				mouseWheelSensitivity: 1.1
+			}
+		}, { defined: Ae, extend: je, pick: Me, wrap: Ne } = T();
+		(function(e) {
+			let t, n = 0;
+			function r(e) {
+				let t = this.chart;
+				e = this.normalize(e), t.options.mapNavigation.enableDoubleClickZoomTo ? t.pointer.inClass(e.target, "highcharts-tracker") && t.hoverPoint && t.hoverPoint.zoomTo() : t.isInsidePlot(e.chartX - t.plotLeft, e.chartY - t.plotTop) && t.mapZoom(.5, void 0, void 0, e.chartX, e.chartY);
+			}
+			function i(e) {
+				let r = this.chart, i = Ae((e = this.normalize(e)).wheelDelta) && -e.wheelDelta / 120 || e.deltaY || e.detail;
+				Math.abs(i) >= 1 && (n += Math.abs(i), t && clearTimeout(t), t = setTimeout(() => {
+					n = 0;
+				}, 50)), n < 10 && r.isInsidePlot(e.chartX - r.plotLeft, e.chartY - r.plotTop) && r.mapView && r.mapView.zoomBy(-((r.options.mapNavigation.mouseWheelSensitivity - 1) * i), void 0, [e.chartX, e.chartY], !(1 > Math.abs(i)) && void 0);
+			}
+			function a(e, t, n) {
+				let r = this.chart;
+				if (t = e.call(this, t, n), r && r.mapView) {
+					let e = r.mapView.pixelsToLonLat({
+						x: t.chartX - r.plotLeft,
+						y: t.chartY - r.plotTop
+					});
+					e && je(t, e);
+				}
+				return t;
+			}
+			function o(e) {
+				let t = this.chart.options.mapNavigation;
+				t && Me(t.enableTouchZoom, t.enabled) && (this.chart.zooming.pinchType = "xy"), e.apply(this, [].slice.call(arguments, 1));
+			}
+			e.compose = function(e) {
+				let t = e.prototype;
+				t.onContainerDblClick || (je(t, {
+					onContainerDblClick: r,
+					onContainerMouseWheel: i
+				}), Ne(t, "normalize", a), Ne(t, "zoomOption", o));
+			};
+		})(y ||= {});
+		let Pe = y;
+		function Fe(e, t, n, r, i) {
+			if (i) {
+				let e = i?.r || 0;
+				i.brBoxY = t - e, i.brBoxHeight = r + e;
+			}
+			return f.roundedRect(e, t, n, r, i);
+		}
+		function Ie(e, t, n, r, i) {
+			return i && (i.brBoxHeight = r + (i?.r || 0)), f.roundedRect(e, t, n, r, i);
+		}
+		let Le = function(e) {
+			(f = e.prototype.symbols).bottombutton = Fe, f.topbutton = Ie;
+		}, { setOptions: Re } = T(), { composed: ze } = T(), { addEvent: j, extend: Be, merge: Ve, objectEach: He, pick: Ue, pushUnique: We } = T();
+		function Ge(e) {
+			e && (e.preventDefault?.(), e.stopPropagation?.(), e.cancelBubble = !0);
+		}
+		class Ke {
+			static compose(e, t, n) {
+				Pe.compose(t), Le(n), We(ze, "Map.Navigation") && (j(e, "beforeRender", function() {
+					this.mapNavigation = new Ke(this), this.mapNavigation.update();
+				}), Re(ke));
+			}
+			constructor(e) {
+				this.chart = e, this.navButtons = [];
+			}
+			update(e) {
+				let t = this, n = t.chart, r = t.navButtons, i = function(e) {
+					this.handler.call(n, e), Ge(e);
+				}, a = n.options.mapNavigation;
+				for (e && (a = n.options.mapNavigation = Ve(n.options.mapNavigation, e)); r.length;) r.pop()?.destroy();
+				!n.renderer.forExport && Ue(a.enableButtons, a.enabled) && (t.navButtonsGroup ||= n.renderer.g().attr({ zIndex: 7 }).add(), He(a.buttons, (e, o) => {
+					let s = { padding: (e = Ve(a.buttonOptions, e)).padding };
+					!n.styledMode && e.theme && (Be(s, e.theme), s.style = Ve(e.theme.style, e.style));
+					let { text: c, width: l = 0, height: u = 0, padding: d = 0 } = e, f = n.renderer.button(c !== "+" && c !== "-" && c || "", 0, 0, i, s, void 0, void 0, void 0, o === "zoomIn" ? "topbutton" : "bottombutton").addClass("highcharts-map-navigation highcharts-" + {
+						zoomIn: "zoom-in",
+						zoomOut: "zoom-out"
+					}[o]).attr({
+						width: l,
+						height: u,
+						title: n.options.lang[o],
+						zIndex: 5
+					}).add(t.navButtonsGroup);
+					if (c === "+" || c === "-") {
+						let t = l + 1, r = [[
+							"M",
+							d + 3,
+							d + u / 2
+						], [
+							"L",
+							d + t - 3,
+							d + u / 2
+						]];
+						c === "+" && r.push([
+							"M",
+							d + t / 2,
+							d + 3
+						], [
+							"L",
+							d + t / 2,
+							d + u - 3
+						]), n.renderer.path(r).addClass("highcharts-button-symbol").attr(n.styledMode ? {} : {
+							stroke: e.style?.color,
+							"stroke-width": 3,
+							"stroke-linecap": "round"
+						}).add(f);
+					}
+					if (f.handler = e.onclick, j(f.element, "dblclick", Ge), r.push(f), Be(e, {
+						width: f.width,
+						height: 2 * (f.height || 0)
+					}), n.hasLoaded) f.align(e, !1, e.alignTo);
+					else {
+						let t = j(n, "load", () => {
+							f.element && f.align(e, !1, e.alignTo), t();
+						});
+					}
+				}), n.hasLoaded || j(n, "render", function() {
+					let e = n.exporting?.group?.getBBox();
+					if (e) {
+						let n = t.navButtonsGroup.getBBox();
+						if (!(n.x >= e.x + e.width || n.x + n.width <= e.x || n.y >= e.y + e.height || n.y + n.height <= e.y)) {
+							let r = -n.y - n.height + e.y - 5, i = e.y + e.height - n.y + 5, o = a.buttonOptions && a.buttonOptions.verticalAlign;
+							t.navButtonsGroup.attr({ translateY: o === "bottom" ? r : i });
+						}
+					}
+				})), this.updateEvents(a);
+			}
+			updateEvents(e) {
+				let t = this.chart;
+				Ue(e.enableDoubleClickZoom, e.enabled) || e.enableDoubleClickZoomTo ? this.unbindDblClick = this.unbindDblClick || j(t.container, "dblclick", function(e) {
+					t.pointer.onContainerDblClick(e);
+				}) : this.unbindDblClick &&= this.unbindDblClick(), Ue(e.enableMouseWheelZoom, e.enabled) ? this.unbindMouseWheel = this.unbindMouseWheel || j(t.container, "wheel", function(e) {
+					if (!t.pointer.inClass(e.target, "highcharts-no-mousewheel")) {
+						let n = t.mapView?.zoom;
+						t.pointer.onContainerMouseWheel(e), n !== t.mapView?.zoom && Ge(e);
+					}
+					return !1;
+				}) : this.unbindMouseWheel &&= this.unbindMouseWheel();
+			}
+		}
+		var qe = w(28), Je = w.n(qe);
+		let { column: { prototype: Ye } } = D().seriesTypes, { addEvent: Xe, defined: Ze } = T();
+		var Qe = b ||= {};
+		function $e(e) {
+			let t = this.series, n = t.chart.renderer;
+			this.moveToTopOnHover && this.graphic && (t.stateMarkerGraphic ||= new (Je())(n, "use").css({ pointerEvents: "none" }).add(this.graphic.parentGroup), e?.state === "hover" ? (this.graphic.attr({ id: this.id }), t.stateMarkerGraphic.attr({
+				href: `${n.url}#${this.id}`,
+				visibility: "visible"
+			})) : t.stateMarkerGraphic.attr({ href: "" }));
+		}
+		Qe.pointMembers = {
+			dataLabelOnNull: !0,
+			moveToTopOnHover: !0,
+			isValid: function() {
+				return this.value !== null && this.value !== Infinity && this.value !== -Infinity && (this.value === void 0 || !isNaN(this.value));
+			}
+		}, Qe.seriesMembers = {
+			colorKey: "value",
+			axisTypes: [
+				"xAxis",
+				"yAxis",
+				"colorAxis"
+			],
+			parallelArrays: [
+				"x",
+				"y",
+				"value"
+			],
+			pointArrayMap: ["value"],
+			trackerGroups: [
+				"group",
+				"markerGroup",
+				"dataLabelsGroup"
+			],
+			colorAttribs: function(e) {
+				let t = {};
+				return Ze(e.color) && (!e.state || e.state === "normal") && (t[this.colorProp || "fill"] = e.color), t;
+			},
+			pointAttribs: Ye.pointAttribs
+		}, Qe.compose = function(e) {
+			return Xe(e.prototype.pointClass, "afterSetState", $e), e;
+		};
+		let M = b;
+		var et = w(820), tt = w.n(et);
+		let { deg2rad: nt } = T(), { fireEvent: rt, isNumber: it, pick: at, relativeLength: ot } = T();
+		(m = x ||= {}).getCenter = function() {
+			let e = this.options, t = this.chart, n = 2 * (e.slicedOffset || 0), r = t.plotWidth - 2 * n, i = t.plotHeight - 2 * n, a = e.center, o = Math.min(r, i), s = e.thickness, c, l = e.size, u = e.innerSize || 0, d, f;
+			typeof l == "string" && (l = parseFloat(l)), typeof u == "string" && (u = parseFloat(u));
+			let p = [
+				at(a?.[0], "50%"),
+				at(a?.[1], "50%"),
+				at(l && l < 0 ? void 0 : e.size, "100%"),
+				at(u && u < 0 ? void 0 : e.innerSize || 0, "0%")
+			];
+			for (!t.angular || this instanceof tt() || (p[3] = 0), d = 0; d < 4; ++d) f = p[d], c = d < 2 || d === 2 && /%$/.test(f), p[d] = ot(f, [
+				r,
+				i,
+				o,
+				p[2]
+			][d]) + (c ? n : 0);
+			return p[3] > p[2] && (p[3] = p[2]), it(s) && 2 * s < p[2] && s > 0 && (p[3] = p[2] - 2 * s), rt(this, "afterGetCenter", { positions: p }), p;
+		}, m.getStartAndEndRadians = function(e, t) {
+			let n = it(e) ? e : 0, r = it(t) && t > n && t - n < 360 ? t : n + 360;
+			return {
+				start: nt * (n + -90),
+				end: nt * (r + -90)
+			};
+		};
+		let st = x;
+		var ct = w(960), lt = w.n(ct), ut = w(540), dt = w.n(ut);
+		let { getOptions: ft } = T(), { isNumber: pt, merge: mt, pick: ht } = T();
+		class gt extends lt() {
+			init(e, t) {
+				let n = ft().credits, r = mt({
+					chart: {
+						panning: {
+							enabled: !0,
+							type: "xy"
+						},
+						type: "map"
+					},
+					credits: {
+						mapText: ht(n.mapText, " © <a href=\"{geojson.copyrightUrl}\">{geojson.copyrightShort}</a>"),
+						mapTextFull: ht(n.mapTextFull, "{geojson.copyright}")
+					},
+					mapView: {},
+					tooltip: { followTouchMove: !1 }
+				}, e);
+				super.init(r, t);
+			}
+			mapZoom(e, t, n, r, i) {
+				this.mapView && (pt(e) && (e = Math.log(e) / Math.log(.5)), this.mapView.zoomBy(e, pt(t) && pt(n) ? this.mapView.projection.inverse([t, n]) : void 0, pt(r) && pt(i) ? [r, i] : void 0));
+			}
+			update(e) {
+				e.chart && "map" in e.chart && this.mapView?.recommendMapView(this, [e.chart.map, ...(this.options.series || []).map((e) => e.mapData)], !0), super.update.apply(this, arguments);
+			}
+		}
+		(h = gt ||= {}).maps = {}, h.mapChart = function(e, t, n) {
+			return new h(e, t, n);
+		}, h.splitPath = function(e) {
+			let t;
+			return t = typeof e == "string" ? (e = e.replace(/([A-Z])/gi, " $1 ").replace(/^\s*/, "").replace(/\s*$/, "")).split(/[ ,;]+/).map((e) => /[A-Z]/i.test(e) ? e : parseFloat(e)) : e, dt().prototype.pathToSegments(t);
+		};
+		let _t = gt, vt = { boundsFromPath: function(e) {
+			let t = -Number.MAX_VALUE, n = Number.MAX_VALUE, r = -Number.MAX_VALUE, i = Number.MAX_VALUE, a;
+			if (e.forEach((e) => {
+				let o = e[e.length - 2], s = e[e.length - 1];
+				typeof o == "number" && typeof s == "number" && (n = Math.min(n, o), t = Math.max(t, o), i = Math.min(i, s), r = Math.max(r, s), a = !0);
+			}), a) return {
+				x1: n,
+				y1: i,
+				x2: t,
+				y2: r
+			};
+		} }, { boundsFromPath: yt } = vt, bt = D().seriesTypes.scatter.prototype.pointClass, { extend: xt, isNumber: N, pick: St } = T();
+		class Ct extends bt {
+			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 n = this.series, r = super.applyOptions(e, t), i = n.joinBy;
+				if (n.mapData && n.mapMap) {
+					let e = i[1], t = super.getNestedProperty(e), a = t !== void 0 && n.mapMap[t];
+					a ? xt(r, {
+						...a,
+						name: r.name ?? a.name
+					}) : n.pointArrayMap.indexOf("value") !== -1 && (r.value = r.value || null);
+				}
+				return r;
+			}
+			getProjectedBounds(e) {
+				let t = yt(Ct.getProjectedPath(this, e)), n = this.properties, r = this.series.chart.mapView;
+				if (t) {
+					let i = n?.["hc-middle-lon"], a = n?.["hc-middle-lat"];
+					if (r && N(i) && N(a)) {
+						let n = e.forward([i, a]);
+						t.midX = n[0], t.midY = n[1];
+					} else {
+						let e = n?.["hc-middle-x"], r = n?.["hc-middle-y"];
+						t.midX = t.x1 + (t.x2 - t.x1) * St(this.middleX, N(e) ? e : .5);
+						let i = St(this.middleY, N(r) ? r : .5);
+						this.geometry || (i = 1 - i), t.midY = t.y2 - (t.y2 - t.y1) * i;
+					}
+					return t;
+				}
+			}
+			onMouseOver(e) {
+				T().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, n = t.mapView, r = this.bounds;
+				if (n && r) {
+					let i = N(this.insetIndex) && n.insets[this.insetIndex];
+					if (i) {
+						let e = i.projectedUnitsToPixels({
+							x: r.x1,
+							y: r.y1
+						}), t = i.projectedUnitsToPixels({
+							x: r.x2,
+							y: r.y2
+						}), a = n.pixelsToProjectedUnits({
+							x: e.x,
+							y: e.y
+						}), o = n.pixelsToProjectedUnits({
+							x: t.x,
+							y: t.y
+						});
+						r = {
+							x1: a.x,
+							y1: a.y,
+							x2: o.x,
+							y2: o.y
+						};
+					}
+					n.fitToBounds(r, void 0, !1), this.series.isDirty = !0, t.redraw(e);
+				}
+			}
+		}
+		xt(Ct.prototype, {
+			dataLabelOnNull: M.pointMembers.dataLabelOnNull,
+			moveToTopOnHover: M.pointMembers.moveToTopOnHover,
+			isValid: M.pointMembers.isValid
+		});
+		let { isNumber: wt } = T(), Tt = {
+			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 Et = w(984), Dt = w.n(Et);
+		let { win: Ot } = T(), { format: kt } = Dt(), { error: At, extend: jt, merge: Mt, wrap: Nt } = T();
+		(function(e) {
+			function t(e) {
+				return this.mapView?.lonLatToProjectedUnits(e);
+			}
+			function n(e) {
+				return this.mapView?.projectedUnitsToLonLat(e);
+			}
+			function r(e, t) {
+				let n = this.options.chart.proj4 || Ot.proj4;
+				if (!n) return void At(21, !1, this);
+				let { jsonmarginX: r = 0, jsonmarginY: i = 0, jsonres: a = 1, scale: o = 1, xoffset: s = 0, xpan: c = 0, yoffset: l = 0, ypan: u = 0 } = t, d = n(t.crs, [e.lon, e.lat]), f = t.cosAngle || t.rotation && Math.cos(t.rotation), p = t.sinAngle || t.rotation && Math.sin(t.rotation), m = t.rotation ? [d[0] * f + d[1] * p, -d[0] * p + d[1] * f] : d;
+				return {
+					x: ((m[0] - s) * o + c) * a + r,
+					y: -(((l - m[1]) * o + u) * a - i)
+				};
+			}
+			function i(e, t) {
+				let n = this.options.chart.proj4 || Ot.proj4;
+				if (!n) return void At(21, !1, this);
+				if (e.y === null) return;
+				let { jsonmarginX: r = 0, jsonmarginY: i = 0, jsonres: a = 1, scale: o = 1, xoffset: s = 0, xpan: c = 0, yoffset: l = 0, ypan: u = 0 } = t, d = {
+					x: ((e.x - r) / a - c) / o + s,
+					y: ((e.y - i) / a + u) / o + l
+				}, f = t.cosAngle || t.rotation && Math.cos(t.rotation), p = t.sinAngle || t.rotation && Math.sin(t.rotation), m = n(t.crs, "WGS84", t.rotation ? {
+					x: d.x * f + -(d.y * p),
+					y: d.x * p + d.y * f
+				} : d);
+				return {
+					lat: m.y,
+					lon: m.x
+				};
+			}
+			function a(e, t) {
+				t ||= Object.keys(e.objects)[0];
+				let n = e.objects[t];
+				if (n["hc-decoded-geojson"] && n["hc-decoded-geojson"].title === e.title) return n["hc-decoded-geojson"];
+				let r = e.arcs;
+				if (e.transform) {
+					let t, n, i, a = e.arcs, { scale: o, translate: s } = e.transform;
+					r = [];
+					for (let e = 0, c = a.length; e < c; ++e) {
+						let c = a[e];
+						r.push(t = []), n = 0, i = 0;
+						for (let e = 0, r = c.length; e < r; ++e) t.push([(n += c[e][0]) * o[0] + s[0], (i += c[e][1]) * o[1] + s[1]]);
+					}
+				}
+				let i = (e) => typeof e[0] == "number" ? e.reduce((e, t, n) => {
+					let i = t < 0 ? r[~t] : r[t];
+					return t < 0 ? (i = i.slice(0, n === 0 ? i.length : i.length - 1)).reverse() : n && (i = i.slice(1)), e.concat(i);
+				}, []) : e.map(i), a = n.geometries, o = [];
+				for (let e = 0, t = a.length; e < t; ++e) o.push({
+					type: "Feature",
+					properties: a[e].properties,
+					geometry: {
+						type: a[e].type,
+						coordinates: a[e].coordinates || i(a[e].arcs)
+					}
+				});
+				let s = {
+					type: "FeatureCollection",
+					copyright: e.copyright,
+					copyrightShort: e.copyrightShort,
+					copyrightUrl: e.copyrightUrl,
+					features: o,
+					"hc-recommended-mapview": n["hc-recommended-mapview"],
+					bbox: e.bbox,
+					title: e.title
+				};
+				return n["hc-decoded-geojson"] = s, s;
+			}
+			function o(e, t) {
+				t = Mt(!0, this.options.credits, t), e.call(this, t), this.credits && this.mapCreditsFull && this.credits.attr({ title: this.mapCreditsFull });
+			}
+			e.compose = function(e) {
+				let a = e.prototype;
+				a.transformFromLatLon || (a.fromLatLonToPoint = t, a.fromPointToLatLon = n, a.transformFromLatLon = r, a.transformToLatLon = i, Nt(a, "addCredits", o));
+			}, e.geojson = function(e, t = "map", n) {
+				let r = [], i = e.type === "Topology" ? a(e) : e, o = i.features;
+				for (let e = 0, n = o.length; e < n; ++e) {
+					let n, i = o[e], a = i.geometry || {}, s = a.type, c = a.coordinates, l = i.properties;
+					if ((t === "map" || t === "mapbubble") && (s === "Polygon" || s === "MultiPolygon") || t === "mapline" && (s === "LineString" || s === "MultiLineString") ? c.length && (n = { geometry: {
+						coordinates: c,
+						type: s
+					} }) : t === "mappoint" && s === "Point" && c.length && (n = { geometry: {
+						coordinates: c,
+						type: s
+					} }), n) {
+						let e = l && (l.name || l.NAME), t = l && l.lon, i = l && l.lat;
+						r.push(jt(n, {
+							lat: typeof i == "number" ? i : void 0,
+							lon: typeof t == "number" ? t : void 0,
+							name: typeof e == "string" ? e : void 0,
+							properties: l
+						}));
+					}
+				}
+				return n && i.copyrightShort && (n.chart.mapCredits = kt(n.chart.options.credits?.mapText, { geojson: i }), n.chart.mapCreditsFull = kt(n.chart.options.credits?.mapTextFull, { geojson: i })), r;
+			}, e.topo2geo = a;
+		})(S ||= {});
+		let Pt = S;
+		(g = C ||= {}).getCenterOfPoints = function(e) {
+			let t = e.reduce((e, t) => (e.x += t.x, e.y += t.y, e), {
+				x: 0,
+				y: 0
+			});
+			return {
+				x: t.x / e.length,
+				y: t.y / e.length
+			};
+		}, g.getDistanceBetweenPoints = function(e, t) {
+			return Math.sqrt((t.x - e.x) ** 2 + (t.y - e.y) ** 2);
+		}, g.getAngleBetweenPoints = function(e, t) {
+			return Math.atan2(t.x - e.x, t.y - e.y);
+		}, g.pointInPolygon = function({ x: e, y: t }, n) {
+			let r = n.length, i, a, o = !1;
+			for (i = 0, a = r - 1; i < r; a = i++) {
+				let [r, s] = n[i], [c, l] = n[a];
+				s > t != l > t && e < (c - r) * (t - s) / (l - s) + r && (o = !o);
+			}
+			return o;
+		};
+		let Ft = C;
+		function It(e, t, n = !0) {
+			let r = t[t.length - 1], i, a, o, s = e;
+			for (let e = 0; e < t.length; e++) {
+				let c = s;
+				i = t[e], s = [], a = n ? c[c.length - 1] : c[0];
+				for (let e = 0; e < c.length; e++) Lt(r, i, o = c[e]) ? (Lt(r, i, a) || s.push(Rt(r, i, a, o)), s.push(o)) : Lt(r, i, a) && s.push(Rt(r, i, a, o)), a = o;
+				r = i;
+			}
+			return s;
+		}
+		function Lt(e, t, n) {
+			return (t[0] - e[0]) * (n[1] - e[1]) > (t[1] - e[1]) * (n[0] - e[0]);
+		}
+		function Rt(e, t, n, r) {
+			let i = [e[0] - t[0], e[1] - t[1]], a = [n[0] - r[0], n[1] - r[1]], o = e[0] * t[1] - e[1] * t[0], s = n[0] * r[1] - n[1] * r[0], c = 1 / (i[0] * a[1] - i[1] * a[0]), l = [(o * a[0] - s * i[0]) * c, (o * a[1] - s * i[1]) * c];
+			return l.isIntersection = !0, l;
+		}
+		let P = Math.sign || ((e) => e === 0 ? 0 : e > 0 ? 1 : -1), F = Math.PI / 180, I = Math.PI / 2, zt = (e) => Math.tan((I + e) / 2), Bt = class {
+			constructor(e) {
+				let t = (e.parallels || []).map((e) => e * F), n = t[0] || 0, r = t[1] ?? n, i = Math.cos(n);
+				typeof e.projectedBounds == "object" && (this.projectedBounds = e.projectedBounds);
+				let a = n === r ? Math.sin(n) : Math.log(i / Math.cos(r)) / Math.log(zt(r) / zt(n));
+				1e-10 > Math.abs(a) && (a = 1e-10 * (P(a) || 1)), this.n = a, this.c = i * zt(n) ** +a / a;
+			}
+			forward(e) {
+				let { c: t, n, projectedBounds: r } = this, i = e[0] * F, a = e[1] * F;
+				t > 0 ? a < -I + 1e-6 && (a = -I + 1e-6) : a > I - 1e-6 && (a = I - 1e-6);
+				let o = t / zt(a) ** +n, s = o * Math.sin(n * i) * 63.78137, c = (t - o * Math.cos(n * i)) * 63.78137, l = [s, c];
+				return r && (s < r.x1 || s > r.x2 || c < r.y1 || c > r.y2) && (l.outside = !0), l;
+			}
+			inverse(e) {
+				let { c: t, n } = this, r = e[0] / 63.78137, i = t - e[1] / 63.78137, a = P(n) * Math.sqrt(r * r + i * i), o = Math.atan2(r, Math.abs(i)) * P(i);
+				return i * n < 0 && (o -= Math.PI * P(r) * P(i)), [o / n / F, (2 * Math.atan((t / a) ** (1 / n)) - I) / F];
+			}
+		}, Vt = Math.sqrt(3) / 2, Ht = class {
+			constructor() {
+				this.bounds = {
+					x1: -200.37508342789243,
+					x2: 200.37508342789243,
+					y1: -97.52595454902263,
+					y2: 97.52595454902263
+				};
+			}
+			forward(e) {
+				let t = Math.PI / 180, n = Math.asin(Vt * Math.sin(e[1] * t)), r = n * n, i = r * r * r;
+				return [e[0] * t * Math.cos(n) * 74.03120656864502 / (Vt * (1.340264 + -.24331799999999998 * r + i * (.0062510000000000005 + .034164 * r))), 74.03120656864502 * n * (1.340264 + -.081106 * r + i * (893e-6 + .003796 * r))];
+			}
+			inverse(e) {
+				let t = e[0] / 74.03120656864502, n = e[1] / 74.03120656864502, r = 180 / Math.PI, i = n, a, o, s, c;
+				for (let e = 0; e < 12 && (o = (a = i * i) * a * a, s = i * (1.340264 + -.081106 * a + o * (893e-6 + .003796 * a)) - n, i -= c = s / (1.340264 + -.24331799999999998 * a + o * (.0062510000000000005 + .034164 * a)), !(1e-9 > Math.abs(c))); ++e);
+				o = (a = i * i) * a * a;
+				let l = r * Vt * t * (1.340264 + -.24331799999999998 * a + o * (.0062510000000000005 + .034164 * a)) / Math.cos(i), u = r * Math.asin(Math.sin(i) / Vt);
+				return Math.abs(l) > 180 ? [NaN, NaN] : [l, u];
+			}
+		}, Ut = Math.PI / 4, Wt = Math.PI / 180, Gt = class {
+			constructor() {
+				this.bounds = {
+					x1: -200.37508342789243,
+					x2: 200.37508342789243,
+					y1: -146.91480769173063,
+					y2: 146.91480769173063
+				};
+			}
+			forward(e) {
+				return [e[0] * Wt * 63.78137, 79.7267125 * Math.log(Math.tan(Ut + .4 * e[1] * Wt))];
+			}
+			inverse(e) {
+				return [e[0] / 63.78137 / Wt, 2.5 * (Math.atan(Math.exp(.8 * (e[1] / 63.78137))) - Ut) / Wt];
+			}
+		}, Kt = Math.PI / 180, qt = class {
+			constructor() {
+				this.antimeridianCutting = !1, this.bounds = {
+					x1: -63.78460826781007,
+					x2: 63.78460826781007,
+					y1: -63.78460826781007,
+					y2: 63.78460826781007
+				};
+			}
+			forward(e) {
+				let t = e[0], n = e[1] * Kt, r = [Math.cos(n) * Math.sin(t * Kt) * 63.78460826781007, 63.78460826781007 * Math.sin(n)];
+				return (t < -90 || t > 90) && (r.outside = !0), r;
+			}
+			inverse(e) {
+				let t = e[0] / 63.78460826781007, n = e[1] / 63.78460826781007, r = Math.sqrt(t * t + n * n), i = Math.asin(r), a = Math.sin(i);
+				return [Math.atan2(t * a, r * Math.cos(i)) / Kt, Math.asin(r && n * a / r) / Kt];
+			}
+		}, Jt = Math.PI / 180, Yt = class {
+			constructor() {
+				this.bounds = {
+					x1: -200.37508342789243,
+					x2: 200.37508342789243,
+					y1: -200.3750834278071,
+					y2: 200.3750834278071
+				}, this.maxLatitude = 85.0511287798;
+			}
+			forward(e) {
+				let t = Math.sin(e[1] * Jt), n = [63.78137 * e[0] * Jt, 63.78137 * Math.log((1 + t) / (1 - t)) / 2];
+				return Math.abs(e[1]) > this.maxLatitude && (n.outside = !0), n;
+			}
+			inverse(e) {
+				return [e[0] / (63.78137 * Jt), (2 * Math.atan(Math.exp(e[1] / 63.78137)) - Math.PI / 2) / Jt];
+			}
+		}, { clipLineString: Xt, clipPolygon: Zt } = {
+			clipLineString: function(e, t) {
+				let n = [], r = It(e, t, !1);
+				for (let e = 1; e < r.length; e++) r[e].isIntersection && r[e - 1].isIntersection && (n.push(r.splice(0, e)), e = 0), e === r.length - 1 && n.push(r);
+				return n;
+			},
+			clipPolygon: It
+		}, { clamp: Qt, erase: $t } = T(), L = 2 * Math.PI / 360, R = (e) => (e < -180 && (e += 360), e > 180 && (e -= 360), e), en = (e) => (1 - Math.cos(e)) / 2;
+		class z {
+			static add(e, t) {
+				z.registry[e] = t;
+			}
+			static distance(e, t) {
+				let n, r, i, a, o, { atan2: s, sqrt: c } = Math, l = (n = Math.cos, r = e[1] * L, i = e[0] * L, a = t[1] * L, o = t[0] * L, en(a - r) + n(r) * n(a) * en(o - i));
+				return 6371e3 * (2 * s(c(l), c(1 - l)));
+			}
+			static geodesic(e, t, n, r = 5e5) {
+				let { atan2: i, cos: a, sin: o, sqrt: s } = Math, c = z.distance, l = e[1] * L, u = e[0] * L, d = t[1] * L, f = t[0] * L, p = a(l) * a(u), m = a(d) * a(f), h = a(l) * o(u), g = a(d) * o(f), _ = o(l), v = o(d), y = c(e, t), b = y / 6371e3, x = o(b), S = Math.round(y / r), C = [];
+				if (n && C.push(e), S > 1) {
+					let e = 1 / S;
+					for (let t = e; t < .999; t += e) {
+						let e = o((1 - t) * b) / x, n = o(t * b) / x, r = e * p + n * m, a = e * h + n * g, c = i(e * _ + n * v, s(r * r + a * a)), l = i(a, r);
+						C.push([l / L, c / L]);
+					}
+				}
+				return n && C.push(t), C;
+			}
+			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 n = z.geodesic(e[t], e[t + 1]);
+					n.length && e.splice(t + 1, 0, ...n);
+				}
+			}
+			static toString(e) {
+				let { name: t, rotation: n } = e || {};
+				return [t, n && n.join(",")].join(";");
+			}
+			constructor(e = {}) {
+				this.hasCoordinates = !1, this.hasGeoProjection = !1, this.maxLatitude = 90, this.options = e;
+				let { name: t, projectedBounds: n, rotation: r } = e;
+				this.rotator = r ? this.getRotator(r) : void 0;
+				let i = t ? z.registry[t] : void 0;
+				i && (this.def = new i(e));
+				let { def: a, rotator: o } = this;
+				a && (this.maxLatitude = a.maxLatitude || 90, this.hasGeoProjection = !0), o && a ? (this.forward = (e) => a.forward(o.forward(e)), this.inverse = (e) => o.inverse(a.inverse(e))) : a ? (this.forward = (e) => a.forward(e), this.inverse = (e) => a.inverse(e)) : o && (this.forward = o.forward, this.inverse = o.inverse), this.bounds = n === "world" ? a && a.bounds : n;
+			}
+			lineIntersectsBounds(e) {
+				let { x1: t, x2: n, y1: r, y2: i } = this.bounds || {}, a = (e, t, n) => {
+					let [r, i] = e, a = +!t;
+					if (typeof n == "number" && r[t] >= n != i[t] >= n) {
+						let e = (n - r[t]) / (i[t] - r[t]), o = r[a] + e * (i[a] - r[a]);
+						return t ? [o, n] : [n, o];
+					}
+				}, o, s = e[0];
+				return ((o = a(e, 0, t)) || (o = a(e, 0, n))) && (s = o, e[1] = o), ((o = a(e, 1, r)) || (o = a(e, 1, i))) && (s = o), s;
+			}
+			getRotator(e) {
+				let t = e[0] * L, n = (e[1] || 0) * L, r = (e[2] || 0) * L, i = Math.cos(n), a = Math.sin(n), o = Math.cos(r), s = Math.sin(r);
+				if (t !== 0 || n !== 0 || r !== 0) return {
+					forward: (e) => {
+						let n = e[0] * L + t, r = e[1] * L, c = Math.cos(r), l = Math.cos(n) * c, u = Math.sin(n) * c, d = Math.sin(r), f = d * i + l * a;
+						return [Math.atan2(u * o - f * s, l * i - d * a) / L, Math.asin(f * o + u * s) / L];
+					},
+					inverse: (e) => {
+						let n = e[0] * L, r = e[1] * L, c = Math.cos(r), l = Math.cos(n) * c, u = Math.sin(n) * c, d = Math.sin(r), f = d * o - u * s;
+						return [(Math.atan2(u * o + d * s, l * i + f * a) - t) / L, Math.asin(f * i - l * a) / L];
+					}
+				};
+			}
+			forward(e) {
+				return e;
+			}
+			inverse(e) {
+				return e;
+			}
+			cutOnAntimeridian(e, t) {
+				let n, r = [], i = [e];
+				for (let n = 0, i = e.length; n < i; ++n) {
+					let i = e[n], a = e[n - 1];
+					if (!n) {
+						if (!t) continue;
+						a = e[e.length - 1];
+					}
+					let o = a[0], s = i[0];
+					if ((o < -90 || o > 90) && (s < -90 || s > 90) && o > 0 != s > 0) {
+						let e = Qt((180 - (o + 360) % 360) / ((s + 360) % 360 - (o + 360) % 360), 0, 1), t = a[1] + e * (i[1] - a[1]);
+						r.push({
+							i: n,
+							lat: t,
+							direction: o < 0 ? 1 : -1,
+							previousLonLat: a,
+							lonLat: i
+						});
+					}
+				}
+				if (r.length) if (t) {
+					r.length % 2 == 1 && (n = r.slice().sort((e, t) => Math.abs(t.lat) - Math.abs(e.lat))[0], $t(r, n));
+					let t = r.length - 2;
+					for (; t >= 0;) {
+						let n = r[t].i, a = R(180 + 1e-6 * r[t].direction), o = R(180 - 1e-6 * r[t].direction), s = e.splice(n, r[t + 1].i - n, ...z.geodesic([a, r[t].lat], [a, r[t + 1].lat], !0));
+						s.push(...z.geodesic([o, r[t + 1].lat], [o, r[t].lat], !0)), i.push(s), t -= 2;
+					}
+					if (n) for (let e = 0; e < i.length; e++) {
+						let { direction: t, lat: r } = n, a = i[e], o = a.indexOf(n.lonLat);
+						if (o > -1) {
+							let e = (r < 0 ? -1 : 1) * this.maxLatitude, i = R(180 + 1e-6 * t), s = R(180 - 1e-6 * t), c = z.geodesic([i, r], [i, e], !0);
+							for (let n = i + 120 * t; n > -180 && n < 180; n += 120 * t) c.push([n, e]);
+							c.push(...z.geodesic([s, e], [s, n.lat], !0)), a.splice(o, 0, ...c);
+							break;
+						}
+					}
+				} else {
+					let t = r.length;
+					for (; t--;) {
+						let n = r[t].i, a = e.splice(n, e.length, [R(180 + 1e-6 * r[t].direction), r[t].lat]);
+						a.unshift([R(180 - 1e-6 * r[t].direction), r[t].lat]), i.push(a);
+					}
+				}
+				return i;
+			}
+			path(e) {
+				let t, { bounds: n, def: r, rotator: i } = this, a = [], o = e.type === "Polygon" || e.type === "MultiPolygon", s = this.hasGeoProjection, c = !r || !1 !== r.antimeridianCutting, l = c ? i : void 0, u = c && r || this;
+				n && (t = [
+					[n.x1, n.y1],
+					[n.x2, n.y1],
+					[n.x2, n.y2],
+					[n.x1, n.y2]
+				]);
+				let d = (e) => {
+					let r = e.map((e) => {
+						if (c) {
+							l && (e = l.forward(e));
+							let t = e[0];
+							1e-6 > Math.abs(t - 180) && (t = t < 180 ? 179.999999 : 180.000001), e = [t, e[1]];
+						}
+						return e;
+					}), i = [r];
+					s && (z.insertGeodesics(r), c && (i = this.cutOnAntimeridian(r, o))), i.forEach((e) => {
+						let r, i;
+						if (e.length < 2) return;
+						let l = !1, d = !1, f = (e) => {
+							l ? a.push([
+								"L",
+								e[0],
+								e[1]
+							]) : (a.push([
+								"M",
+								e[0],
+								e[1]
+							]), l = !0);
+						}, p = !1, m = !1, h = e.map((e) => {
+							let t = u.forward(e);
+							return t.outside ? p = !0 : m = !0, t[1] === Infinity ? t[1] = 1e10 : t[1] === -Infinity && (t[1] = -1e10), t;
+						});
+						if (c) {
+							if (o && h.push(h[0]), p) {
+								if (!m) return;
+								if (t) {
+									if (o) h = Zt(h, t);
+									else if (n) return void Xt(h, t).forEach((e) => {
+										l = !1, e.forEach(f);
+									});
+								}
+							}
+							h.forEach(f);
+						} else for (let t = 0; t < h.length; t++) {
+							let n = e[t], a = h[t];
+							a.outside ? d = !0 : (o && !r && (r = n, e.push(n), h.push(a)), d && i && (o && s ? z.geodesic(i, n).forEach((e) => f(u.forward(e))) : l = !1), f(a), i = n, d = !1);
+						}
+					});
+				};
+				return e.type === "LineString" ? d(e.coordinates) : e.type === "MultiLineString" ? e.coordinates.forEach((e) => d(e)) : e.type === "Polygon" ? (e.coordinates.forEach((e) => d(e)), a.length && a.push(["Z"])) : e.type === "MultiPolygon" && (e.coordinates.forEach((e) => {
+					e.forEach((e) => d(e));
+				}), a.length && a.push(["Z"])), a;
+			}
+		}
+		z.registry = {
+			EqualEarth: Ht,
+			LambertConformalConic: Bt,
+			Miller: Gt,
+			Orthographic: qt,
+			WebMercator: Yt
+		};
+		let { composed: tn } = T(), { pointInPolygon: nn } = Ft, { topo2geo: rn } = Pt, { boundsFromPath: an } = vt, { addEvent: B, clamp: on, crisp: sn, fireEvent: cn, isArray: ln, isNumber: V, isObject: un, isString: dn, merge: H, pick: fn, pushUnique: pn, relativeLength: U } = T(), mn = {};
+		function hn(e, t) {
+			let { width: n, height: r } = t;
+			return Math.log(400.979322 / Math.max((e.x2 - e.x1) / (n / 256), (e.y2 - e.y1) / (r / 256))) / Math.log(2);
+		}
+		function gn(e) {
+			e.seriesOptions.mapData && this.mapView?.recommendMapView(this, [this.options.chart.map, e.seriesOptions.mapData], this.options.drilldown?.mapZooming);
+		}
+		class W {
+			static compose(e) {
+				pn(tn, "MapView") && (mn = e.maps, B(e, "afterInit", function() {
+					this.mapView = new W(this, this.options.mapView);
+				}, { order: 0 }), B(e, "addSeriesAsDrilldown", gn), B(e, "afterDrillUp", gn));
+			}
+			static compositeBounds(e) {
+				if (e.length) return e.slice(1).reduce((e, t) => (e.x1 = Math.min(e.x1, t.x1), e.y1 = Math.min(e.y1, t.y1), e.x2 = Math.max(e.x2, t.x2), e.y2 = Math.max(e.y2, t.y2), e), H(e[0]));
+			}
+			static mergeInsets(e, t) {
+				let n = (e) => {
+					let t = {};
+					return e.forEach((e, n) => {
+						t[e && e.id || `i${n}`] = e;
+					}), t;
+				}, r = H(n(e), n(t));
+				return Object.keys(r).map((e) => r[e]);
+			}
+			constructor(e, t) {
+				this.allowTransformAnimation = !0, this.eventsToUnbind = [], this.insets = [], this.padding = [
+					0,
+					0,
+					0,
+					0
+				], this.recommendedMapView = {}, this instanceof _n || this.recommendMapView(e, [e.options.chart.map, ...(e.options.series || []).map((e) => e.mapData)]), this.userOptions = t || {};
+				let n = H(Tt, this.recommendedMapView, t), r = this.recommendedMapView?.insets, i = t && t.insets;
+				r && i && (n.insets = W.mergeInsets(r, i)), this.chart = e, this.center = n.center, this.options = n, this.projection = new z(n.projection), this.playingField = e.plotBox, this.zoom = n.zoom || 0, this.minZoom = n.minZoom, this.createInsets(), this.eventsToUnbind.push(B(e, "afterSetChartSize", () => {
+					this.playingField = this.getField(), (this.minZoom === void 0 || this.minZoom === this.zoom) && (this.fitToBounds(void 0, void 0, !1), !this.chart.hasRendered && V(this.userOptions.zoom) && (this.zoom = this.userOptions.zoom), this.userOptions.center && H(!0, this.center, this.userOptions.center));
+				})), this.setUpEvents();
+			}
+			createInsets() {
+				let e = this.options, t = e.insets;
+				t && t.forEach((t) => {
+					let n = new _n(this, H(e.insetOptions, t));
+					this.insets.push(n);
+				});
+			}
+			fitToBounds(e, t, n = !0, r) {
+				let i = e || this.getProjectedBounds();
+				if (i) {
+					let a = fn(t, e ? 0 : this.options.padding), o = this.getField(!1), s = ln(a) ? a : [
+						a,
+						a,
+						a,
+						a
+					];
+					this.padding = [
+						U(s[0], o.height),
+						U(s[1], o.width),
+						U(s[2], o.height),
+						U(s[3], o.width)
+					], this.playingField = this.getField();
+					let c = hn(i, this.playingField);
+					e || (this.minZoom = c);
+					let l = this.projection.inverse([(i.x2 + i.x1) / 2, (i.y2 + i.y1) / 2]);
+					this.setView(l, c, n, r);
+				}
+			}
+			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 (dn(e)) return mn[e] && mn[e].type === "Topology" ? rn(mn[e]) : mn[e];
+				if (un(e, !0)) {
+					if (e.type === "FeatureCollection") return e;
+					if (e.type === "Topology") return rn(e);
+				}
+			}
+			getMapBBox() {
+				let e = this.getProjectedBounds(), t = this.getScale();
+				if (e) {
+					let n = this.padding, r = this.projectedUnitsToPixels({
+						x: e.x1,
+						y: e.y2
+					});
+					return {
+						width: (e.x2 - e.x1) * t + n[1] + n[3],
+						height: (e.y2 - e.y1) * t + n[0] + n[2],
+						x: r.x - n[3],
+						y: r.y - n[0]
+					};
+				}
+			}
+			getProjectedBounds() {
+				let e = this.projection, t = this.chart.series.reduce((e, t) => {
+					let n = t.getProjectedBounds && t.getProjectedBounds();
+					return n && !1 !== t.options.affectsMapView && e.push(n), e;
+				}, []), n = this.options.fitToGeometry;
+				if (n) {
+					if (!this.fitToGeometryCache) if (n.type === "MultiPoint") {
+						let t = n.coordinates.map((t) => e.forward(t)), r = t.map((e) => e[0]), i = t.map((e) => e[1]);
+						this.fitToGeometryCache = {
+							x1: Math.min.apply(0, r),
+							x2: Math.max.apply(0, r),
+							y1: Math.min.apply(0, i),
+							y2: Math.max.apply(0, i)
+						};
+					} else this.fitToGeometryCache = an(e.path(n));
+					return this.fitToGeometryCache;
+				}
+				return this.projection.bounds || W.compositeBounds(t);
+			}
+			getScale() {
+				return 256 / 400.979322 * 2 ** this.zoom;
+			}
+			getSVGTransform() {
+				let { x: e, y: t, width: n, height: r } = this.playingField, i = this.projection.forward(this.center), a = this.projection.hasCoordinates ? -1 : 1, o = this.getScale(), s = o * a;
+				return {
+					scaleX: o,
+					scaleY: s,
+					translateX: e + n / 2 - i[0] * o,
+					translateY: t + r / 2 - i[1] * s
+				};
+			}
+			lonLatToPixels(e) {
+				let t = this.lonLatToProjectedUnits(e);
+				if (t) return this.projectedUnitsToPixels(t);
+			}
+			lonLatToProjectedUnits(e) {
+				let t = this.chart, n = t.mapTransforms;
+				if (n) {
+					for (let r in n) if (Object.hasOwnProperty.call(n, r) && n[r].hitZone) {
+						let i = t.transformFromLatLon(e, n[r]);
+						if (i && nn(i, n[r].hitZone.coordinates[0])) return i;
+					}
+					return t.transformFromLatLon(e, n.default);
+				}
+				for (let t of this.insets) if (t.options.geoBounds && nn({
+					x: e.lon,
+					y: e.lat
+				}, t.options.geoBounds.coordinates[0])) {
+					let n = t.projection.forward([e.lon, e.lat]), r = t.projectedUnitsToPixels({
+						x: n[0],
+						y: n[1]
+					});
+					return this.pixelsToProjectedUnits(r);
+				}
+				let r = this.projection.forward([e.lon, e.lat]);
+				if (!r.outside) return {
+					x: r[0],
+					y: r[1]
+				};
+			}
+			pixelsToLonLat(e) {
+				return this.projectedUnitsToLonLat(this.pixelsToProjectedUnits(e));
+			}
+			pixelsToProjectedUnits(e) {
+				let { x: t, y: n } = e, r = this.getScale(), i = this.projection.forward(this.center), a = this.playingField, o = a.x + a.width / 2, s = a.y + a.height / 2;
+				return {
+					x: i[0] + (t - o) / r,
+					y: i[1] - (n - s) / r
+				};
+			}
+			projectedUnitsToLonLat(e) {
+				let t = this.chart, n = t.mapTransforms;
+				if (n) {
+					for (let r in n) if (Object.hasOwnProperty.call(n, r) && n[r].hitZone && nn(e, n[r].hitZone.coordinates[0])) return t.transformToLatLon(e, n[r]);
+					return t.transformToLatLon(e, n.default);
+				}
+				let r = this.projectedUnitsToPixels(e);
+				for (let e of this.insets) if (e.hitZone && nn(r, e.hitZone.coordinates[0])) {
+					let t = e.pixelsToProjectedUnits(r), n = e.projection.inverse([t.x, t.y]);
+					return {
+						lon: n[0],
+						lat: n[1]
+					};
+				}
+				let i = this.projection.inverse([e.x, e.y]);
+				return {
+					lon: i[0],
+					lat: i[1]
+				};
+			}
+			projectedUnitsToPixels(e) {
+				let t = this.getScale(), n = this.projection.forward(this.center), r = this.playingField, i = r.x + r.width / 2, a = r.y + r.height / 2;
+				return {
+					x: i - t * (n[0] - e.x),
+					y: a + t * (n[1] - e.y)
+				};
+			}
+			recommendMapView(e, t, n = !1) {
+				this.recommendedMapView = {};
+				let r = t.map((e) => this.getGeoMap(e)), i = [];
+				r.forEach((e) => {
+					if (e && (Object.keys(this.recommendedMapView).length || (this.recommendedMapView = e["hc-recommended-mapview"] || {}), e.bbox)) {
+						let [t, n, r, a] = e.bbox;
+						i.push({
+							x1: t,
+							y1: n,
+							x2: r,
+							y2: a
+						});
+					}
+				});
+				let a = i.length && W.compositeBounds(i);
+				cn(this, "onRecommendMapView", {
+					geoBounds: a,
+					chart: e
+				}, function() {
+					if (a && this.recommendedMapView) {
+						if (!this.recommendedMapView.projection) {
+							let { x1: e, y1: t, x2: n, y2: r } = a;
+							this.recommendedMapView.projection = n - e > 180 && r - t > 90 ? {
+								name: "EqualEarth",
+								parallels: [0, 0],
+								rotation: [0]
+							} : {
+								name: "LambertConformalConic",
+								parallels: [t, r],
+								rotation: [-(e + n) / 2]
+							};
+						}
+						this.recommendedMapView.insets || (this.recommendedMapView.insets = void 0);
+					}
+				}), this.geoMap = r[0], n && e.hasRendered && !e.userOptions.mapView?.projection && this.recommendedMapView && this.update(this.recommendedMapView);
+			}
+			redraw(e) {
+				this.chart.series.forEach((e) => {
+					e.useMapGeometry && (e.isDirty = !0);
+				}), this.chart.redraw(e);
+			}
+			setView(e, t, n = !0, r) {
+				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)), V(t) && (this.zoom = t));
+				let i = this.getProjectedBounds();
+				if (i) {
+					let e = this.projection.forward(this.center), { x: t, y: n, width: r, height: a } = this.playingField, o = this.getScale(), s = this.projectedUnitsToPixels({
+						x: i.x1,
+						y: i.y1
+					}), c = this.projectedUnitsToPixels({
+						x: i.x2,
+						y: i.y2
+					}), l = [(i.x1 + i.x2) / 2, (i.y1 + i.y2) / 2];
+					if (!this.chart.series.some((e) => e.isDrilling)) {
+						let i = s.x, u = c.y, d = c.x, f = s.y;
+						d - i < r ? e[0] = l[0] : i < t && d < t + r ? e[0] += Math.max(i - t, d - r - t) / o : d > t + r && i > t && (e[0] += Math.min(d - r - t, i - t) / o), f - u < a ? e[1] = l[1] : u < n && f < n + a ? e[1] -= Math.max(u - n, f - a - n) / o : f > n + a && u > n && (e[1] -= Math.min(f - a - n, u - n) / o), this.center = this.projection.inverse(e);
+					}
+					this.insets.forEach((e) => {
+						e.options.field && (e.hitZone = e.getHitZone(), e.playingField = e.getField());
+					}), this.render();
+				}
+				cn(this, "afterSetView"), n && this.redraw(r);
+			}
+			setUpEvents() {
+				let e, t, n, { chart: r } = this, i = (i) => {
+					let { lastTouches: a, pinchDown: o } = r.pointer, s = this.projection, c = i.touches, { mouseDownX: l, mouseDownY: u } = r, d = 0;
+					if (o?.length === 1 ? (l = o[0].chartX, u = o[0].chartY) : o?.length === 2 && (l = (o[0].chartX + o[1].chartX) / 2, u = (o[0].chartY + o[1].chartY) / 2), c?.length === 2 && a && (d = Math.log(Math.sqrt((a[0].chartX - a[1].chartX) ** 2 + (a[0].chartY - a[1].chartY) ** 2) / Math.sqrt((c[0].chartX - c[1].chartX) ** 2 + (c[0].chartY - c[1].chartY) ** 2)) / Math.log(.5)), V(l) && V(u)) {
+						let a = `${l},${u}`, { chartX: o, chartY: f } = i.originalEvent;
+						c?.length === 2 && (o = (c[0].chartX + c[1].chartX) / 2, f = (c[0].chartY + c[1].chartY) / 2), a !== t && (t = a, e = this.projection.forward(this.center), n = (this.projection.options.rotation || [0, 0]).slice());
+						let p = s.def && s.def.bounds, m = p && hn(p, this.playingField) || -Infinity;
+						if (s.options.name === "Orthographic" && 2 > (c?.length || 0) && (this.minZoom || Infinity) < 1.3 * m) {
+							let e = 440 / (this.getScale() * Math.min(r.plotWidth, r.plotHeight));
+							if (n) {
+								let t = (l - o) * e - n[0], i = on(-n[1] - (u - f) * e, -80, 80), a = this.zoom;
+								this.update({ projection: { rotation: [-t, -i] } }, !1), this.fitToBounds(void 0, void 0, !1), this.zoom = a, r.redraw(!1);
+							}
+						} else if (V(o) && V(f)) {
+							let t = this.getScale(), n = this.projection.hasCoordinates ? 1 : -1, r = this.projection.inverse([e[0] + (l - o) / t, e[1] - (u - f) / t * n]);
+							isNaN(r[0] + r[1]) || this.zoomBy(d, r, void 0, !1);
+						}
+						i.preventDefault();
+					}
+				};
+				B(r, "pan", i), B(r, "touchpan", i), B(r, "selection", (e) => {
+					if (e.resetSelection) this.zoomBy();
+					else {
+						let t = e.x - r.plotLeft, n = e.y - r.plotTop, { y: i, x: a } = this.pixelsToProjectedUnits({
+							x: t,
+							y: n
+						}), { y: o, x: s } = this.pixelsToProjectedUnits({
+							x: t + e.width,
+							y: n + e.height
+						});
+						this.fitToBounds({
+							x1: a,
+							y1: i,
+							x2: s,
+							y2: o
+						}, void 0, !0, !e.originalEvent.touches && void 0), /^touch/.test(e.originalEvent.type) || r.showResetZoom(), e.preventDefault();
+					}
+				});
+			}
+			render() {
+				this.group ||= this.chart.renderer.g("map-view").attr({ zIndex: 4 }).add();
+			}
+			update(e, t = !0, n) {
+				let r = e.projection, i = r && z.toString(r) !== z.toString(this.options.projection), a = !1;
+				H(!0, this.userOptions, e), H(!0, this.options, e), "insets" in e && (this.insets.forEach((e) => e.destroy()), this.insets.length = 0, a = !0), (i || "fitToGeometry" in e) && delete this.fitToGeometryCache, (i || a) && (this.chart.series.forEach((e) => {
+					let t = e.transformGroups;
+					if (e.clearBounds && e.clearBounds(), e.isDirty = !0, e.isDirtyData = !0, a && t) for (; t.length > 1;) {
+						let e = t.pop();
+						e && e.destroy();
+					}
+				}), i && (this.projection = new z(this.options.projection)), a && this.createInsets(), !e.center && Object.hasOwnProperty.call(e, "zoom") && !V(e.zoom) && this.fitToBounds(void 0, void 0, !1)), e.center || V(e.zoom) ? this.setView(this.options.center, e.zoom, !1) : "fitToGeometry" in e && this.fitToBounds(void 0, void 0, !1), t && this.chart.redraw(n);
+			}
+			zoomBy(e, t, n, r) {
+				let i = this.chart, a = this.projection.forward(this.center);
+				if (typeof e == "number") {
+					let o, s, c, l = this.zoom + e;
+					if (n) {
+						let [e, t] = n, r = this.getScale(), o = e - i.plotLeft - i.plotWidth / 2, l = t - i.plotTop - i.plotHeight / 2;
+						s = a[0] + o / r, c = a[1] + l / r;
+					}
+					if (typeof s == "number" && typeof c == "number") {
+						let e = 1 - 2 ** this.zoom / 2 ** l, t = a[0] - s, n = a[1] - c;
+						a[0] -= t * e, a[1] += n * e, o = this.projection.inverse(a);
+					}
+					this.setView(t || o, l, void 0, r);
+				} else this.fitToBounds(void 0, void 0, void 0, r);
+			}
+		}
+		class _n extends W {
+			constructor(e, t) {
+				if (super(e.chart, t), this.id = t.id, this.mapView = e, this.options = H({ center: [0, 0] }, e.options.insetOptions, t), this.allBounds = [], this.options.geoBounds) {
+					let t = e.projection.path(this.options.geoBounds);
+					this.geoBoundsProjectedBox = an(t), this.geoBoundsProjectedPolygon = t.map((e) => [e[1] || 0, e[2] || 0]);
+				}
+			}
+			getField(e = !0) {
+				let t = this.hitZone;
+				if (t) {
+					let n = e ? this.padding : [
+						0,
+						0,
+						0,
+						0
+					], r = t.coordinates[0], i = r.map((e) => e[0]), a = r.map((e) => e[1]), o = Math.min.apply(0, i) + n[3], s = Math.max.apply(0, i) - n[1], c = Math.min.apply(0, a) + n[0], l = Math.max.apply(0, a) - n[2];
+					if (V(o) && V(c)) return {
+						x: o,
+						y: c,
+						width: s - o,
+						height: l - c
+					};
+				}
+				return super.getField.call(this, e);
+			}
+			getHitZone() {
+				let { chart: e, mapView: t, options: n } = this, { coordinates: r } = n.field || {};
+				if (r) {
+					let i = r[0];
+					if (n.units === "percent") {
+						let r = n.relativeTo === "mapBoundingBox" && t.getMapBBox() || H(e.plotBox, {
+							x: 0,
+							y: 0
+						});
+						i = i.map((e) => [U(`${e[0]}%`, r.width, r.x), U(`${e[1]}%`, r.height, r.y)]);
+					}
+					return {
+						type: "Polygon",
+						coordinates: [i]
+					};
+				}
+			}
+			getProjectedBounds() {
+				return W.compositeBounds(this.allBounds);
+			}
+			isInside(e) {
+				let { geoBoundsProjectedBox: t, geoBoundsProjectedPolygon: n } = this;
+				return !!(t && e.x >= t.x1 && e.x <= t.x2 && e.y >= t.y1 && e.y <= t.y2 && n && nn(e, n));
+			}
+			render() {
+				let { chart: e, mapView: t, options: n } = this, r = n.borderPath || n.field;
+				if (r && t.group) {
+					let i = !0;
+					this.border || (this.border = e.renderer.path().addClass("highcharts-mapview-inset-border").add(t.group), i = !1), e.styledMode || this.border.attr({
+						stroke: n.borderColor,
+						"stroke-width": n.borderWidth
+					});
+					let a = this.border.strokeWidth(), o = n.relativeTo === "mapBoundingBox" && t.getMapBBox() || t.playingField, s = (r.coordinates || []).reduce((t, r) => r.reduce((t, r, i) => {
+						let [s, c] = r;
+						return n.units === "percent" && (s = e.plotLeft + U(`${s}%`, o.width, o.x), c = e.plotTop + U(`${c}%`, o.height, o.y)), s = sn(s, a), c = sn(c, a), t.push(i === 0 ? [
+							"M",
+							s,
+							c
+						] : [
+							"L",
+							s,
+							c
+						]), t;
+					}, t), []);
+					this.border[i ? "animate" : "attr"]({ d: s });
+				}
+			}
+			destroy() {
+				this.border &&= this.border.destroy(), this.eventsToUnbind.forEach((e) => e());
+			}
+			setUpEvents() {}
+		}
+		let { animObject: vn, stop: yn } = T(), { noop: bn } = T(), { splitPath: xn } = _t, { column: Sn, scatter: Cn } = D().seriesTypes, { extend: wn, find: Tn, fireEvent: En, getNestedProperty: Dn, isArray: On, defined: kn, isNumber: G, isObject: An, merge: jn, objectEach: Mn, pick: Nn, splat: Pn } = T();
+		class Fn extends Cn {
+			constructor() {
+				super(...arguments), this.processedData = [];
+			}
+			animate(e) {
+				let { chart: t, group: n } = this, r = vn(this.options.animation);
+				e ? n.attr({
+					translateX: t.plotLeft + t.plotWidth / 2,
+					translateY: t.plotTop + t.plotHeight / 2,
+					scaleX: .001,
+					scaleY: .001
+				}) : n.animate({
+					translateX: t.plotLeft,
+					translateY: t.plotTop,
+					scaleX: 1,
+					scaleY: 1
+				}, r);
+			}
+			clearBounds() {
+				this.points.forEach((e) => {
+					delete e.bounds, delete e.insetIndex, delete e.projectedPath;
+				}), delete this.bounds;
+			}
+			doFullTranslate() {
+				return !!(this.isDirtyData || this.chart.isResizing || !this.hasRendered);
+			}
+			drawMapDataLabels() {
+				super.drawDataLabels(), this.dataLabelsGroups?.forEach((e) => e?.clip(this.chart.clipRect));
+			}
+			drawPoints() {
+				let e = this, { chart: t, group: n, transformGroups: r = [] } = this, { mapView: i, renderer: a } = t;
+				if (i) {
+					this.transformGroups = r, r[0] ||= a.g().add(n);
+					for (let e = 0, t = i.insets.length; e < t; ++e) r[e + 1] || r.push(a.g().add(n));
+					this.doFullTranslate() && (this.points.forEach((e) => {
+						let { graphic: t } = e;
+						e.group = r[typeof e.insetIndex == "number" ? e.insetIndex + 1 : 0], t && t.parentGroup !== e.group && t.add(e.group);
+					}), Sn.prototype.drawPoints.apply(this), this.points.forEach((n) => {
+						let r = n.graphic;
+						if (r) {
+							let i = r.animate, a = "";
+							n.name && (a += "highcharts-name-" + n.name.replace(/ /g, "-").toLowerCase()), n.properties?.["hc-key"] && (a += " highcharts-key-" + n.properties["hc-key"].toString().toLowerCase()), a && r.addClass(a), t.styledMode && r.css(this.pointAttribs(n, n.selected && "select" || void 0)), r.attr({ visibility: !n.visible && (n.visible || n.isNull) ? "hidden" : "inherit" }), r.animate = function(n, a, o) {
+								let s = G(n["stroke-width"]) && !G(r["stroke-width"]), c = G(r["stroke-width"]) && !G(n["stroke-width"]);
+								if (s || c) {
+									let i = Nn(e.getStrokeWidth(e.options), 1) / (t.mapView?.getScale() || 1);
+									s && (r["stroke-width"] = i), c && (n["stroke-width"] = i);
+								}
+								return i.call(r, n, a, c ? function() {
+									r.element.removeAttribute("stroke-width"), delete r["stroke-width"], o && o.apply(this, arguments);
+								} : o);
+							};
+						}
+					})), r.forEach((n, r) => {
+						let o = (r === 0 ? i : i.insets[r - 1]).getSVGTransform(), s = Nn(this.getStrokeWidth(this.options), 1), c = o.scaleX, l = o.scaleY > 0 ? 1 : -1, u = (t) => {
+							(e.points || []).forEach((e) => {
+								let n, r = e.graphic;
+								r?.["stroke-width"] && (n = this.getStrokeWidth(e.options)) && r.attr({ "stroke-width": n / t });
+							});
+						};
+						if (a.globalAnimation && t.hasRendered && i.allowTransformAnimation) {
+							let e = Number(n.attr("translateX")), t = Number(n.attr("translateY")), r = Number(n.attr("scaleX")), i = (i, a) => {
+								let d = r + (c - r) * a.pos;
+								n.attr({
+									translateX: e + (o.translateX - e) * a.pos,
+									translateY: t + (o.translateY - t) * a.pos,
+									scaleX: d,
+									scaleY: d * l,
+									"stroke-width": s / d
+								}), u(d);
+							}, d = jn(vn(a.globalAnimation)), f = d.step;
+							d.step = function() {
+								f && f.apply(this, arguments), i.apply(this, arguments);
+							}, n.attr({ animator: 0 }).animate({ animator: 1 }, d, (function() {
+								typeof a.globalAnimation != "boolean" && a.globalAnimation.complete && a.globalAnimation.complete({ applyDrilldown: !0 }), En(this, "mapZoomComplete");
+							}).bind(this));
+						} else yn(n), n.attr(jn(o, { "stroke-width": s / c })), u(c);
+					}), this.isDrilling || this.drawMapDataLabels();
+				}
+			}
+			getProjectedBounds() {
+				if (!this.bounds && this.chart.mapView) {
+					let { insets: e, projection: t } = this.chart.mapView, n = [];
+					(this.points || []).forEach((r) => {
+						if (r.path || r.geometry) {
+							if (typeof r.path == "string" ? r.path = xn(r.path) : On(r.path) && r.path[0] === "M" && (r.path = this.chart.renderer.pathToSegments(r.path)), !r.bounds) {
+								let n = r.getProjectedBounds(t);
+								if (n) {
+									r.labelrank = Nn(r.labelrank, (n.x2 - n.x1) * (n.y2 - n.y1));
+									let { midX: t, midY: i } = n;
+									if (e && G(t) && G(i)) {
+										let a = Tn(e, (e) => e.isInside({
+											x: t,
+											y: i
+										}));
+										a && (delete r.projectedPath, (n = r.getProjectedBounds(a.projection)) && a.allBounds.push(n), r.insetIndex = e.indexOf(a));
+									}
+									r.bounds = n;
+								}
+							}
+							r.bounds && r.insetIndex === void 0 && n.push(r.bounds);
+						}
+					}), this.bounds = W.compositeBounds(n);
+				}
+				return this.bounds;
+			}
+			getStrokeWidth(e) {
+				return e[this.pointAttrToOptions?.["stroke-width"] || "borderWidth"];
+			}
+			hasData() {
+				return !!this.dataTable.rowCount;
+			}
+			pointAttribs(e, t) {
+				let { mapView: n, styledMode: r } = e.series.chart, i = r ? this.colorAttribs(e) : Sn.prototype.pointAttribs.call(this, e, t), a = this.getStrokeWidth(e.options);
+				if (t) {
+					let n = jn(this.options.states?.[t], e.options.states?.[t] || {}), r = this.getStrokeWidth(n);
+					kn(r) && (a = r), i.stroke = n.borderColor ?? e.color;
+				}
+				a && n && (a /= n.getScale());
+				let o = this.getStrokeWidth(this.options);
+				return i.dashstyle && n && G(o) && (a = o / n.getScale()), e.visible || (i.fill = this.options.nullColor), e.isNull && this.options.nullInteraction && (i.opacity = 1), kn(a) ? i["stroke-width"] = a : delete i["stroke-width"], i["stroke-linecap"] = i["stroke-linejoin"] = this.options.linecap, i;
+			}
+			updateData() {
+				return !this.processedData && super.updateData.apply(this, arguments);
+			}
+			setData(e, t = !0, n, r) {
+				delete this.bounds, super.setData(e, !1, void 0, r), this.processData(), this.generatePoints(), t && this.chart.redraw(n);
+			}
+			dataColumnKeys() {
+				return this.pointArrayMap;
+			}
+			processData() {
+				let e, t, n, r = this.options, i = r.data, a = this.chart, o = a.options.chart, s = this.joinBy, c = r.keys || this.pointArrayMap, l = [], u = {}, d = this.chart.mapView, f = d && (An(r.mapData, !0) ? d.getGeoMap(r.mapData) : d.geoMap), p = a.mapTransforms = o.mapTransforms || f?.["hc-transform"] || a.mapTransforms;
+				p && Mn(p, (e) => {
+					e.rotation && (e.cosAngle = Math.cos(e.rotation), e.sinAngle = Math.sin(e.rotation));
+				}), On(r.mapData) ? n = r.mapData : f && f.type === "FeatureCollection" && (this.mapTitle = f.title, n = T().geojson(f, this.type, this)), this.processedData = [];
+				let m = this.processedData;
+				if (i) {
+					let e;
+					for (let t = 0, n = i.length; t < n; ++t) {
+						if (G(e = i[t])) m[t] = { value: e };
+						else if (On(e)) {
+							let n = 0;
+							m[t] = {}, !r.keys && e.length > c.length && typeof e[0] == "string" && (m[t]["hc-key"] = e[0], ++n);
+							for (let r = 0; r < c.length; ++r, ++n) c[r] && e[n] !== void 0 && (c[r].indexOf(".") > 0 ? Ct.prototype.setNestedProperty(m[t], e[n], c[r]) : m[t][c[r]] = e[n]);
+						} else m[t] = i[t];
+						s && s[0] === "_i" && (m[t]._i = t);
+					}
+				}
+				if (n) {
+					this.mapData = n, this.mapMap = {};
+					for (let r = 0; r < n.length; r++) t = (e = n[r]).properties, e._i = r, s[0] && t && t[s[0]] && (e[s[0]] = t[s[0]]), u[e[s[0]]] = e;
+					if (this.mapMap = u, s[1]) {
+						let e = s[1];
+						m.forEach((t) => {
+							let n = Dn(e, t);
+							u[n] && l.push(u[n]);
+						});
+					}
+					if (r.allAreas) {
+						if (s[1]) {
+							let e = s[1];
+							m.forEach((t) => {
+								l.push(Dn(e, t));
+							});
+						}
+						let e = "|" + l.map(function(e) {
+							return e && e[s[0]];
+						}).join("|") + "|";
+						n.forEach((t) => {
+							s[0] && e.indexOf("|" + t[s[0]] + "|") !== -1 || m.push(jn(t, { value: null }));
+						});
+					}
+				}
+				this.dataTable.rowCount = m.length;
+			}
+			setOptions(e) {
+				let t = super.setOptions(e), n = t.joinBy;
+				return t.joinBy === null && (n = "_i"), n && (this.joinBy = Pn(n), this.joinBy[1] || (this.joinBy[1] = this.joinBy[0])), t;
+			}
+			translate() {
+				let e = this.doFullTranslate(), t = this.chart.mapView, n = t?.projection;
+				if (this.chart.hasRendered && (this.isDirtyData || !this.hasRendered) && (this.processData(), this.generatePoints(), delete this.bounds, !t || t.userOptions.center || G(t.userOptions.zoom) || t.zoom !== t.minZoom ? this.getProjectedBounds() : t.fitToBounds(void 0, void 0, !1)), t) {
+					let r = t.getSVGTransform();
+					this.points.forEach((i) => {
+						let a = G(i.insetIndex) && t.insets[i.insetIndex].getSVGTransform() || r;
+						a && i.bounds && G(i.bounds.midX) && G(i.bounds.midY) && (i.plotX = i.bounds.midX * a.scaleX + a.translateX, i.plotY = i.bounds.midY * a.scaleY + a.translateY), e && (i.shapeType = "path", i.shapeArgs = { d: Ct.getProjectedPath(i, n) }), !i.hiddenInDataClass && (i.projectedPath && !i.projectedPath.length ? i.setVisible(!1) : i.visible || i.setVisible(!0));
+					});
+				}
+				En(this, "afterTranslate");
+			}
+			update(e) {
+				e.mapData && this.chart.mapView?.recommendMapView(this.chart, [this.chart.options.chart.map, ...(this.chart.options.series || []).map((t, n) => n === this._i ? e.mapData : t.mapData)], !0), super.update.apply(this, arguments);
+			}
+		}
+		Fn.defaultOptions = jn(Cn.defaultOptions, {
+			affectsMapView: !0,
+			animation: !1,
+			dataLabels: {
+				crop: !1,
+				formatter: function() {
+					let { numberFormatter: e } = this.series.chart, { value: t } = this.point;
+					return wt(t) ? e(t, -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"
+		}), wn(Fn.prototype, {
+			type: "map",
+			axisTypes: M.seriesMembers.axisTypes,
+			colorAttribs: M.seriesMembers.colorAttribs,
+			colorKey: M.seriesMembers.colorKey,
+			directTouch: !0,
+			drawDataLabels: bn,
+			drawGraph: bn,
+			forceDL: !0,
+			getCenter: st.getCenter,
+			getExtremesFromAll: !0,
+			getSymbol: bn,
+			isCartesian: !1,
+			parallelArrays: M.seriesMembers.parallelArrays,
+			pointArrayMap: M.seriesMembers.pointArrayMap,
+			pointClass: Ct,
+			preserveAspectRatio: !0,
+			searchPoint: bn,
+			trackerGroups: M.seriesMembers.trackerGroups,
+			useMapGeometry: !0
+		}), M.compose(Fn), D().registerSeriesType("map", Fn);
+		let In = Fn, { extend: Ln, merge: Rn } = T();
+		class zn extends In {
+			pointAttribs(e, t) {
+				let n = super.pointAttribs(e, t);
+				return n.fill = this.options.fillColor, n;
+			}
+		}
+		zn.defaultOptions = Rn(In.defaultOptions, {
+			lineWidth: 1,
+			fillColor: "none",
+			legendSymbol: "lineMarker"
+		}), Ln(zn.prototype, {
+			type: "mapline",
+			colorProp: "stroke",
+			pointAttrToOptions: {
+				stroke: "color",
+				"stroke-width": "lineWidth"
+			}
+		}), D().registerSeriesType("mapline", zn);
+		let { scatter: Bn } = D().seriesTypes, { isNumber: Vn } = T();
+		class Hn extends Bn.prototype.pointClass {
+			isValid() {
+				return !!(this.options.geometry || Vn(this.x) && Vn(this.y) || Vn(this.options.lon) && Vn(this.options.lat));
+			}
+		}
+		w(632);
+		let { noop: Un } = T(), { map: Wn, scatter: Gn } = D().seriesTypes, { extend: Kn, fireEvent: qn, isNumber: K, merge: Jn } = T();
+		class Yn extends Gn {
+			constructor() {
+				super(...arguments), this.clearBounds = Wn.prototype.clearBounds;
+			}
+			drawDataLabels() {
+				super.drawDataLabels(), this.dataLabelsGroups?.forEach((e) => {
+					e?.clip(this.chart.clipRect);
+				});
+			}
+			projectPoint(e) {
+				let t = this.chart.mapView;
+				if (t) {
+					let { geometry: n, lon: r, lat: i } = e, a = n && n.type === "Point" && n.coordinates;
+					if (K(r) && K(i) && (a = [r, i]), 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: n } = e.projection;
+					this.points.forEach((r) => {
+						let i, { x: a, y: o } = r, s = K(r.insetIndex) && e.insets[r.insetIndex].getSVGTransform() || t, c = this.projectPoint(r.options) || r.properties && this.projectPoint(r.properties);
+						if (c ? (a = c.x, o = c.y) : r.bounds && (a = r.bounds.midX, o = r.bounds.midY, s && K(a) && K(o) && (r.plotX = a * s.scaleX + s.translateX, r.plotY = o * s.scaleY + s.translateY, i = !0)), K(a) && K(o)) {
+							if (!i) {
+								let t = e.projectedUnitsToPixels({
+									x: a,
+									y: o
+								});
+								r.plotX = t.x, r.plotY = n ? t.y : this.chart.plotHeight - t.y;
+							}
+						} else r.y = r.plotX = r.plotY = void 0;
+						r.isInside = this.isPointInside(r), r.zone = this.zones.length ? r.getZone() : void 0;
+					});
+				}
+				qn(this, "afterTranslate");
+			}
+		}
+		Yn.defaultOptions = Jn(Gn.defaultOptions, {
+			dataLabels: {
+				crop: !1,
+				defer: !1,
+				enabled: !0,
+				formatter: function() {
+					return this.point.name;
+				},
+				overflow: !1,
+				style: { color: "#000000" }
+			},
+			legendSymbol: "lineMarker",
+			stickyTracking: !0,
+			tooltip: { pointFormat: "{#if point.name}{point.name}{else}Lat: {point.lat}, Lon: {point.lon}{/if}" }
+		}), dt().prototype.symbols.mapmarker = (e, t, n, r, i) => {
+			let a, o, s = i && i.context === "legend";
+			s ? (a = e + n / 2, o = t + r) : i && typeof i.anchorX == "number" && typeof i.anchorY == "number" ? (a = i.anchorX, o = i.anchorY) : (a = e + n / 2, o = t + r / 2, t -= r);
+			let c = s ? r / 3 : r / 2;
+			return [
+				[
+					"M",
+					a,
+					o
+				],
+				[
+					"C",
+					a,
+					o,
+					a - c,
+					t + 1.5 * c,
+					a - c,
+					t + c
+				],
+				[
+					"A",
+					c,
+					c,
+					1,
+					1,
+					1,
+					a + c,
+					t + c
+				],
+				[
+					"C",
+					a + c,
+					t + 1.5 * c,
+					a,
+					o,
+					a,
+					o
+				],
+				["Z"]
+			];
+		}, Kn(Yn.prototype, {
+			type: "mappoint",
+			axisTypes: ["colorAxis"],
+			forceDL: !0,
+			isCartesian: !1,
+			pointClass: Hn,
+			searchPoint: Un,
+			useMapGeometry: !0
+		}), D().registerSeriesType("mappoint", Yn);
+		let Xn = {
+			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: Zn } = T(), { arrayMax: Qn, arrayMin: $n, isNumber: er, merge: tr, pick: q, stableSort: nr } = T(), rr = class {
+			constructor(e, t) {
+				this.setState = Zn, this.init(e, t);
+			}
+			init(e, t) {
+				this.options = e, this.visible = !0, this.chart = t.chart, this.legend = t;
+			}
+			addToLegend(e) {
+				e.splice(this.options.legendIndex, 0, this);
+			}
+			drawLegendSymbol(e) {
+				let t, n = q(e.options.itemDistance, 20), r = this.legendItem || {}, i = this.options, a = i.ranges, o = i.connectorDistance;
+				if (!a || !a.length || !er(a[0].value)) {
+					e.options.bubbleLegend.autoRanges = !0;
+					return;
+				}
+				nr(a, function(e, t) {
+					return t.value - e.value;
+				}), this.ranges = a, this.setOptions(), this.render();
+				let s = this.getMaxLabelSize(), c = this.ranges[0].radius, l = 2 * c;
+				t = (t = o - c + s.width) > 0 ? t : 0, this.maxLabel = s, this.movementX = i.labels.align === "left" ? t : 0, r.labelWidth = l + t + n, r.labelHeight = l + s.height / 2;
+			}
+			setOptions() {
+				let e = this.ranges, t = this.options, n = this.chart.series[t.seriesIndex], r = this.legend.baseline, i = {
+					zIndex: t.zIndex,
+					"stroke-width": t.borderWidth
+				}, a = {
+					zIndex: t.zIndex,
+					"stroke-width": t.connectorWidth
+				}, o = {
+					align: this.legend.options.rtl || t.labels.align === "left" ? "right" : "left",
+					zIndex: t.zIndex
+				}, s = n.options.marker.fillOpacity, c = this.chart.styledMode;
+				e.forEach(function(l, u) {
+					c || (i.stroke = q(l.borderColor, t.borderColor, n.color), i.fill = l.color || t.color, i.fill || (i.fill = n.color, i["fill-opacity"] = s ?? 1), a.stroke = q(l.connectorColor, t.connectorColor, n.color)), e[u].radius = this.getRangeRadius(l.value), e[u] = tr(e[u], { center: e[0].radius - e[u].radius + r }), c || tr(!0, e[u], {
+						bubbleAttribs: tr(i),
+						connectorAttribs: tr(a),
+						labelAttribs: o
+					});
+				}, this);
+			}
+			getRangeRadius(e) {
+				let t = this.options, n = this.options.seriesIndex, r = this.chart.series[n], i = t.ranges[0].value, a = t.ranges[t.ranges.length - 1].value, o = t.minSize, s = t.maxSize;
+				return r.getRadius.call(this, a, i, o, s, e);
+			}
+			render() {
+				let e = this.legendItem || {}, t = this.chart.renderer, n = this.options.zThreshold;
+				for (let r of (this.symbols ||= {
+					connectors: [],
+					bubbleItems: [],
+					labels: []
+				}, e.symbol = t.g("bubble-legend"), e.label = t.g("bubble-legend-item").css(this.legend.itemStyle || {}), e.symbol.translateX = 0, e.symbol.translateY = 0, e.symbol.add(e.label), e.label.add(e.group), this.ranges)) r.value >= n && this.renderRange(r);
+				this.hideOverlappingLabels();
+			}
+			renderRange(e) {
+				let t = this.ranges[0], n = this.legend, r = this.options, i = r.labels, a = this.chart, o = a.series[r.seriesIndex], s = a.renderer, c = this.symbols, l = c.labels, u = e.center, d = Math.abs(e.radius), f = r.connectorDistance || 0, p = i.align, m = n.options.rtl, h = r.borderWidth, g = r.connectorWidth, _ = t.radius || 0, v = u - d - h / 2 + g / 2, y = (v % 1 ? 1 : .5) - (g % 2 ? 0 : .5), b = s.styledMode, x = m || p === "left" ? -f : f;
+				p === "center" && (x = 0, r.connectorDistance = 0, e.labelAttribs.align = "center"), c.bubbleItems.push(s.circle(_, u + y, d).attr(b ? {} : e.bubbleAttribs).addClass((b ? "highcharts-color-" + o.colorIndex + " " : "") + "highcharts-bubble-legend-symbol " + (r.className || "")).add(this.legendItem.symbol)), c.connectors.push(s.path(s.crispLine([[
+					"M",
+					_,
+					v
+				], [
+					"L",
+					_ + x,
+					v
+				]], r.connectorWidth)).attr(b ? {} : e.connectorAttribs).addClass((b ? "highcharts-color-" + this.options.seriesIndex + " " : "") + "highcharts-bubble-legend-connectors " + (r.connectorClassName || "")).add(this.legendItem.symbol));
+				let S = s.text(this.formatLabel(e)).attr(b ? {} : e.labelAttribs).css(b ? {} : i.style).addClass("highcharts-bubble-legend-labels " + (r.labels.className || "")).add(this.legendItem.symbol), C = {
+					x: _ + x + r.labels.x,
+					y: v + r.labels.y + .4 * S.getBBox().height
+				};
+				S.attr(C), l.push(S), S.placed = !0, S.alignAttr = C;
+			}
+			getMaxLabelSize() {
+				let e, t;
+				return this.symbols.labels.forEach(function(n) {
+					t = n.getBBox(!0), e = e ? t.width > e.width ? t : e : t;
+				}), e || {};
+			}
+			formatLabel(e) {
+				let t = this.options, n = t.labels.formatter, r = t.labels.format, { numberFormatter: i } = this.chart;
+				return r ? Dt().format(r, e, this.chart) : n ? n.call(e) : i(e.value, 1);
+			}
+			hideOverlappingLabels() {
+				let e = this.chart, t = this.options.labels.allowOverlap, n = this.symbols;
+				!t && n && (e.hideOverlappingLabels(n.labels), n.labels.forEach(function(e, t) {
+					e.newOpacity ? e.newOpacity !== e.oldOpacity && n.connectors[t].show() : n.connectors[t].hide();
+				}));
+			}
+			getRanges() {
+				let e = this.legend.bubbleLegend, t = e.chart.series, n = e.options.ranges, r, i, a = Number.MAX_VALUE, o = -Number.MAX_VALUE;
+				return t.forEach(function(e) {
+					e.isBubble && !e.ignoreSeries && (i = e.getColumn("z").filter(er)).length && (a = q(e.options.zMin, Math.min(a, Math.max($n(i), !1 === e.options.displayNegative ? e.options.zThreshold : -Number.MAX_VALUE))), o = q(e.options.zMax, Math.max(o, Qn(i))));
+				}), r = a === o ? [{ value: o }] : [
+					{ value: a },
+					{ value: (a + o) / 2 },
+					{
+						value: o,
+						autoRanges: !0
+					}
+				], n.length && n[0].radius && r.reverse(), r.forEach(function(e, t) {
+					n && n[t] && (r[t] = tr(n[t], e));
+				}), r;
+			}
+			predictBubbleSizes() {
+				let e = this.chart, t = e.legend.options, n = t.floating, r = t.layout === "horizontal", i = r ? e.legend.lastLineHeight : 0, a = e.plotSizeX, o = e.plotSizeY, s = e.series[this.options.seriesIndex], c = s.getPxExtremes(), l = Math.ceil(c.minPxSize), u = Math.ceil(c.maxPxSize), d = Math.min(o, a), f, p = s.options.maxSize;
+				return n || !/%$/.test(p) ? f = u : (f = (d + i) * (p = parseFloat(p)) / 100 / (p / 100 + 1), (r && o - f >= a || !r && a - f >= o) && (f = u)), [l, Math.ceil(f)];
+			}
+			updateRanges(e, t) {
+				let n = this.legend.options.bubbleLegend;
+				n.minSize = e, n.maxSize = t, n.ranges = this.getRanges();
+			}
+			correctSizes() {
+				let e = this.legend, t = this.chart.series[this.options.seriesIndex].getPxExtremes();
+				Math.abs(Math.ceil(t.maxPxSize) - this.options.maxSize) > 1 && (this.updateRanges(this.options.minSize, t.maxPxSize), e.render());
+			}
+		}, { setOptions: ir } = T(), { composed: ar } = T(), { addEvent: or, objectEach: sr, pushUnique: cr, wrap: lr } = T();
+		function ur(e, t, n) {
+			let r, i, a, o = this.legend, s = dr(this) >= 0;
+			o && o.options.enabled && o.bubbleLegend && o.options.bubbleLegend.autoRanges && s ? (r = o.bubbleLegend.options, i = o.bubbleLegend.predictBubbleSizes(), o.bubbleLegend.updateRanges(i[0], i[1]), r.placed || (o.group.placed = !1, o.allItems.forEach((e) => {
+				(a = e.legendItem || {}).group && (a.group.translateY = void 0);
+			})), o.render(), r.placed || (this.getMargins(), this.axes.forEach((e) => {
+				e.setScale(), e.updateNames(), sr(e.ticks, function(e) {
+					e.isNew = !0, e.isNewLabel = !0;
+				});
+			}), this.getMargins()), r.placed = !0, e.call(this, t, n), o.bubbleLegend.correctSizes(), hr(o, fr(o))) : (e.call(this, t, n), o && o.options.enabled && o.bubbleLegend && (o.render(), hr(o, fr(o))));
+		}
+		function dr(e) {
+			let t = e.series, n = 0;
+			for (; n < t.length;) {
+				if (t[n] && t[n].isBubble && t[n].visible && t[n].dataTable.rowCount) return n;
+				n++;
+			}
+			return -1;
+		}
+		function fr(e) {
+			let t = e.allItems, n = [], r = t.length, i, a, o, s = 0, c = 0;
+			for (s = 0; s < r; s++) if (a = t[s].legendItem || {}, o = (t[s + 1] || {}).legendItem || {}, a.labelHeight && (t[s].itemHeight = a.labelHeight), t[s] === t[r - 1] || a.y !== o.y) {
+				for (n.push({ height: 0 }), i = n[n.length - 1]; c <= s; c++) t[c].itemHeight > i.height && (i.height = t[c].itemHeight);
+				i.step = s;
+			}
+			return n;
+		}
+		function pr(e) {
+			let t = this.bubbleLegend, n = this.options, r = n.bubbleLegend, i = dr(this.chart);
+			t && t.ranges && t.ranges.length && (r.ranges.length && (r.autoRanges = !!r.ranges[0].autoRanges), this.destroyItem(t)), i >= 0 && n.enabled && r.enabled && (r.seriesIndex = i, this.bubbleLegend = new rr(r, this), this.bubbleLegend.addToLegend(e.allItems));
+		}
+		function mr(e) {
+			let t;
+			if (e.defaultPrevented) return !1;
+			let n = e.legendItem, r = this.chart, i = n.visible;
+			this && this.bubbleLegend && (n.visible = !i, n.ignoreSeries = i, t = dr(r) >= 0, this.bubbleLegend.visible !== t && (this.update({ bubbleLegend: { enabled: t } }), this.bubbleLegend.visible = t), n.visible = i);
+		}
+		function hr(e, t) {
+			let n = e.allItems, r = e.options.rtl, i, a, o, s, c = 0;
+			n.forEach((e, n) => {
+				(s = e.legendItem || {}).group && (i = s.group.translateX || 0, a = s.y || 0, ((o = e.movementX) || r && e.ranges) && (o = r ? i - e.options.maxSize / 2 : i + o, s.group.attr({ translateX: o })), n > t[c].step && c++, s.group.attr({ translateY: Math.round(a + t[c].height / 2) }), s.y = a + t[c].height / 2);
+			});
+		}
+		let gr = function(e, t) {
+			cr(ar, "Series.BubbleLegend") && (ir({ legend: { bubbleLegend: Xn } }), lr(e.prototype, "drawChartBox", ur), or(t, "afterGetAllItems", pr), or(t, "itemClick", mr));
+		};
+		var _r = w(260), vr = w.n(_r);
+		let { seriesTypes: { scatter: { prototype: { pointClass: yr } } } } = D(), { extend: br } = T();
+		class xr extends yr {
+			haloPath(e) {
+				let t = (e && this.marker && this.marker.radius || 0) + e;
+				if (this.series.chart.inverted) {
+					let e = this.pos() || [0, 0], { xAxis: n, yAxis: r, chart: i } = this.series, a = 2 * t;
+					return i.renderer.symbols.circle((n?.len || 0) - e[1] - t, (r?.len || 0) - e[0] - t, a, a);
+				}
+				return vr().prototype.haloPath.call(this, t);
+			}
+		}
+		br(xr.prototype, { ttBelow: !1 });
+		let Sr = xr, { composed: Cr, noop: wr } = T(), { series: Tr, seriesTypes: { column: { prototype: Er }, scatter: Dr } } = D(), { addEvent: Or, arrayMax: kr, arrayMin: Ar, clamp: jr, extend: Mr, isNumber: J, merge: Nr, pick: Y, pushUnique: Pr } = T();
+		function Fr() {
+			let e = this.len, { coll: t, isXAxis: n, min: r } = this, i = (this.max || 0) - (r || 0), a = 0, o = e, s = e / i, c;
+			(t === "xAxis" || t === "yAxis") && (this.series.forEach((e) => {
+				if (e.bubblePadding && e.reserveSpace()) {
+					this.allowZoomOutside = !0, c = !0;
+					let t = e.getColumn(n ? "x" : "y");
+					if (n && ((e.onPoint || e).getRadii(0, 0, e), e.onPoint && (e.radii = e.onPoint.radii)), i > 0) {
+						let n = t.length;
+						for (; n--;) if (J(t[n]) && this.dataMin <= t[n] && t[n] <= this.max) {
+							let i = e.radii && e.radii[n] || 0;
+							a = Math.min((t[n] - r) * s - i, a), o = Math.max((t[n] - r) * s + i, o);
+						}
+					}
+				}
+			}), c && i > 0 && !this.logarithmic && (o -= e, s *= (e + Math.max(0, a) - Math.min(o, e)) / e, [[
+				"min",
+				"userMin",
+				a
+			], [
+				"max",
+				"userMax",
+				o
+			]].forEach((e) => {
+				Y(this.options[e[0]], this[e[1]]) === void 0 && (this[e[0]] += e[2] / s);
+			})));
+		}
+		function Ir() {
+			let { ticks: e, tickPositions: t, dataMin: n = 0, dataMax: r = 0, categories: i } = this, a = this.options.type;
+			if ((i?.length || a === "category") && this.series.find((e) => e.bubblePadding)) {
+				let i = t.length;
+				for (; i--;) {
+					let a = e[t[i]], o = a.pos || 0;
+					(o > r || o < n) && a.label?.hide();
+				}
+			}
+		}
+		class X extends Dr {
+			static compose(e, t, n) {
+				gr(t, n), Pr(Cr, "Series.Bubble") && (Or(e, "foundExtremes", Fr), Or(e, "afterRender", Ir));
+			}
+			animate(e) {
+				!e && this.points.length < this.options.animationLimit && this.points.forEach(function(e) {
+					let { graphic: t, plotX: n = 0, plotY: r = 0 } = e;
+					t && t.width && (this.hasRendered || t.attr({
+						x: n,
+						y: r,
+						width: 1,
+						height: 1
+					}), t.animate(this.markerAttribs(e), this.options.animation));
+				}, this);
+			}
+			getRadii() {
+				let e = this.getColumn("z"), t = this.getColumn("y"), n = [], r, i, a, o = this.chart.bubbleZExtremes, { minPxSize: s, maxPxSize: c } = this.getPxExtremes();
+				if (!o) {
+					let e, t = Number.MAX_VALUE, n = -Number.MAX_VALUE;
+					this.chart.series.forEach((r) => {
+						if (r.bubblePadding && r.reserveSpace()) {
+							let i = (r.onPoint || r).getZExtremes();
+							i && (t = Math.min(Y(t, i.zMin), i.zMin), n = Math.max(Y(n, i.zMax), i.zMax), e = !0);
+						}
+					}), e ? (o = {
+						zMin: t,
+						zMax: n
+					}, this.chart.bubbleZExtremes = o) : o = {
+						zMin: 0,
+						zMax: 0
+					};
+				}
+				for (i = 0, r = e.length; i < r; i++) a = e[i], n.push(this.getRadius(o.zMin, o.zMax, s, c, a, t && t[i]));
+				this.radii = n;
+			}
+			getRadius(e, t, n, r, i, a) {
+				let o = this.options, s = o.sizeBy !== "width", c = o.zThreshold, l = t - e, u = .5;
+				if (a === null || i === null) return null;
+				if (J(i)) {
+					if (o.sizeByAbsoluteValue && (i = Math.abs(i - c), t = l = Math.max(t - c, Math.abs(e - c)), e = 0), i < e) return n / 2 - 1;
+					l > 0 && (u = (i - e) / l);
+				}
+				return s && u >= 0 && (u = Math.sqrt(u)), Math.ceil(n + u * (r - n)) / 2;
+			}
+			hasData() {
+				return !!this.dataTable.rowCount;
+			}
+			markerAttribs(e, t) {
+				let n = super.markerAttribs(e, t), { height: r = 0, width: i = 0 } = n;
+				return this.chart.inverted ? Mr(n, {
+					x: (e.plotX || 0) - i / 2,
+					y: (e.plotY || 0) - r / 2
+				}) : n;
+			}
+			pointAttribs(e, t) {
+				let n = this.options.marker?.fillOpacity, r = Tr.prototype.pointAttribs.call(this, e, t);
+				return r["fill-opacity"] = n ?? 1, r;
+			}
+			translate() {
+				super.translate.call(this), this.getRadii(), this.translateBubble();
+			}
+			translateBubble() {
+				let { data: e, options: t, radii: n } = this, { minPxSize: r } = this.getPxExtremes(), i = e.length;
+				for (; i--;) {
+					let a = e[i], o = n ? n[i] : 0;
+					this.zoneAxis === "z" && (a.negative = (a.z || 0) < (t.zThreshold || 0)), J(o) && o >= r / 2 ? (a.marker = Mr(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 = (t) => {
+					let n;
+					return typeof t == "string" && (n = /%$/.test(t), t = parseInt(t, 10)), n ? e * t / 100 : t;
+				}, n = t(Y(this.options.minSize, 8));
+				return {
+					minPxSize: n,
+					maxPxSize: Math.max(t(Y(this.options.maxSize, "20%")), n)
+				};
+			}
+			getZExtremes() {
+				let e = this.options, t = this.getColumn("z").filter(J);
+				if (t.length) {
+					let n = Y(e.zMin, jr(Ar(t), !1 === e.displayNegative ? e.zThreshold || 0 : -Number.MAX_VALUE, Number.MAX_VALUE)), r = Y(e.zMax, kr(t));
+					if (J(n) && J(r)) return {
+						zMin: n,
+						zMax: r
+					};
+				}
+			}
+			searchKDTree(e, t, n, r = wr, i = wr) {
+				return r = (e, t, n) => {
+					let r = e[n] || 0, i = t[n] || 0, a, o = !1;
+					return r === i ? a = e.index > t.index ? e : t : r < 0 && i < 0 ? (a = r - (e.marker?.radius || 0) >= i - (t.marker?.radius || 0) ? e : t, o = !0) : a = r < i ? e : t, [a, o];
+				}, i = (e, t, n) => !n && e > t || e < t, super.searchKDTree(e, t, n, r, i);
+			}
+		}
+		X.defaultOptions = Nr(Dr.defaultOptions, {
+			dataLabels: {
+				formatter: function() {
+					let { numberFormatter: e } = this.series.chart, { z: t } = this.point;
+					return J(t) ? e(t, -1) : "";
+				},
+				inside: !0,
+				verticalAlign: "middle"
+			},
+			animationLimit: 250,
+			marker: {
+				lineColor: null,
+				lineWidth: 1,
+				fillOpacity: .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"
+		}), Mr(X.prototype, {
+			alignDataLabel: Er.alignDataLabel,
+			applyZones: wr,
+			bubblePadding: !0,
+			isBubble: !0,
+			keysAffectYAxis: ["y"],
+			pointArrayMap: ["y", "z"],
+			pointClass: Sr,
+			parallelArrays: [
+				"x",
+				"y",
+				"z"
+			],
+			trackerGroups: ["group", "dataLabelsGroup"],
+			specialGroup: "group",
+			zoneAxis: "z"
+		}), Or(X, "updatedData", (e) => {
+			delete e.target.chart.bubbleZExtremes;
+		}), Or(X, "remove", (e) => {
+			delete e.target.chart.bubbleZExtremes;
+		}), D().registerSeriesType("bubble", X);
+		let Lr = X, { seriesTypes: { map: { prototype: { pointClass: { prototype: Rr } } } } } = D(), { extend: zr } = T();
+		class Br extends Sr {
+			isValid() {
+				return typeof this.z == "number";
+			}
+		}
+		zr(Br.prototype, {
+			applyOptions: Rr.applyOptions,
+			getProjectedBounds: Rr.getProjectedBounds
+		});
+		let { seriesTypes: { map: { prototype: Z }, mappoint: { prototype: Vr } } } = D(), { extend: Hr, merge: Ur } = T();
+		class Wr extends Lr {
+			constructor() {
+				super(...arguments), this.clearBounds = Z.clearBounds;
+			}
+			searchPoint(e, t) {
+				return this.searchKDTree({
+					plotX: e.chartX - this.chart.plotLeft,
+					plotY: e.chartY - this.chart.plotTop
+				}, t, e);
+			}
+			translate() {
+				Vr.translate.call(this), this.getRadii(), this.translateBubble();
+			}
+		}
+		Wr.defaultOptions = Ur(Lr.defaultOptions, {
+			lineWidth: 0,
+			animationLimit: 500,
+			joinBy: "hc-key",
+			tooltip: { pointFormat: "{point.name}: {point.z}" },
+			stickyTracking: !0
+		}), Hr(Wr.prototype, {
+			type: "mapbubble",
+			axisTypes: ["colorAxis"],
+			getProjectedBounds: Z.getProjectedBounds,
+			isCartesian: !1,
+			pointArrayMap: ["z"],
+			pointClass: Br,
+			processData: Z.processData,
+			projectPoint: Vr.projectPoint,
+			kdAxisArray: ["plotX", "plotY"],
+			setData: Z.setData,
+			setOptions: Z.setOptions,
+			updateData: Z.updateData,
+			useMapGeometry: !0,
+			xyFromShape: !0
+		}), D().registerSeriesType("mapbubble", Wr);
+		let { scatter: { prototype: { pointClass: Gr } } } = D().seriesTypes, { clamp: Kr, defined: qr, extend: Jr, pick: Yr } = T();
+		class Xr extends Gr {
+			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, n = (t.colsize || 1) / 2, r = (t.rowsize || 1) / 2, i = e.xAxis, a = e.yAxis, o = this.options.marker || e.options.marker, s = e.pointPlacementToXValue(), c = Yr(this.pointPadding, t.pointPadding, 0), l = {
+					x1: Kr(Math.round(i.len - i.translate(this.x - n, !1, !0, !1, !0, -s)), -i.len, 2 * i.len),
+					x2: Kr(Math.round(i.len - i.translate(this.x + n, !1, !0, !1, !0, -s)), -i.len, 2 * i.len),
+					y1: Kr(Math.round(a.translate(this.y - r, !1, !0, !1, !0)), -a.len, 2 * a.len),
+					y2: Kr(Math.round(a.translate(this.y + r, !1, !0, !1, !0)), -a.len, 2 * a.len)
+				};
+				for (let e of [["width", "x"], ["height", "y"]]) {
+					let t = e[0], n = e[1], r = n + "1", s = n + "2", u = Math.abs(l[r] - l[s]), d = o && o.lineWidth || 0, f = Math.abs(l[r] + l[s]) / 2, p = o && o[t];
+					if (qr(p) && p < u) {
+						let e = p / 2 + d / 2;
+						l[r] = f - e, l[s] = f + e;
+					}
+					c && ((n === "x" && i.reversed || n === "y" && !a.reversed) && (r = s, s = n + "1"), l[r] += c, l[s] -= c);
+				}
+				return l;
+			}
+			haloPath(e) {
+				if (!e) return [];
+				let { x: t = 0, y: n = 0, width: r = 0, height: i = 0 } = this.shapeArgs || {};
+				return [
+					[
+						"M",
+						t - e,
+						n - e
+					],
+					[
+						"L",
+						t - e,
+						n + i + e
+					],
+					[
+						"L",
+						t + r + e,
+						n + i + e
+					],
+					[
+						"L",
+						t + r + e,
+						n - e
+					],
+					["Z"]
+				];
+			}
+			isValid() {
+				return this.value !== Infinity && this.value !== -Infinity;
+			}
+		}
+		Jr(Xr.prototype, {
+			dataLabelOnNull: !0,
+			moveToTopOnHover: !0,
+			ttBelow: !1
+		});
+		let { isNumber: Zr } = T(), { doc: Qr } = T(), { defined: $r, pick: ei } = T(), { series: Q, seriesTypes: { column: ti, scatter: ni } } = D(), { prototype: { symbols: ri } } = dt(), { addEvent: ii, extend: ai, fireEvent: oi, isNumber: si, merge: ci, pick: li } = T(), { colorFromPoint: ui, getContext: di } = {
+			colorFromPoint: function(e, t) {
+				let n = t.series.colorAxis;
+				if (n) {
+					let r = n.toColor(e || 0, t).split(")")[0].split("(")[1].split(",").map((e) => ei(parseFloat(e), parseInt(e, 10)));
+					return r[3] = 255 * ei(r[3], 1), $r(e) && t.visible || (r[3] = 0), r;
+				}
+				return [
+					0,
+					0,
+					0,
+					0
+				];
+			},
+			getContext: function(e) {
+				let { canvas: t, context: n } = e;
+				return t && n ? (n.clearRect(0, 0, t.width, t.height), n) : (e.canvas = Qr.createElement("canvas"), e.context = e.canvas.getContext("2d", { willReadFrequently: !0 }) || void 0, e.context);
+			}
+		};
+		class fi extends ni {
+			constructor() {
+				super(...arguments), this.valueMax = NaN, this.valueMin = NaN, this.isDirtyCanvas = !0;
+			}
+			drawPoints() {
+				let e = this, t = e.options, n = t.interpolation, r = t.marker || {};
+				if (n) {
+					let { image: t, chart: n, xAxis: r, yAxis: i } = e, { reversed: a = !1, len: o } = r, { reversed: s = !1, len: c } = i, l = {
+						width: o,
+						height: c
+					};
+					if (!t || e.isDirtyData || e.isDirtyCanvas) {
+						let o = di(e), { canvas: c, options: { colsize: u = 1, rowsize: d = 1 }, points: f, points: { length: p } } = e, m = n.colorAxis && n.colorAxis[0];
+						if (c && o && m) {
+							let { min: m, max: h } = r.getExtremes(), { min: g, max: _ } = i.getExtremes(), v = h - m, y = _ - g, b = Math.round(v / u / 8 * 8), x = Math.round(y / d / 8 * 8), [S, C] = [[
+								b,
+								b / v,
+								a,
+								"ceil"
+							], [
+								x,
+								x / y,
+								!s,
+								"floor"
+							]].map(([e, t, n, r]) => n ? (n) => Math[r](e - t * n) : (e) => Math[r](t * e)), ee = c.width = b + 1, te = ee * (c.height = x + 1), w = (p - 1) / te, ne = new Uint8ClampedArray(4 * te), re = (e, t) => 4 * Math.ceil(ee * C(t - g) + S(e - m));
+							e.buildKDTree();
+							for (let e = 0; e < te; e++) {
+								let t = f[Math.ceil(w * e)], { x: n, y: r } = t;
+								ne.set(ui(t.value, t), re(n, r));
+							}
+							o.putImageData(new ImageData(ne, ee), 0, 0), t ? t.attr({
+								...l,
+								href: c.toDataURL("image/png", 1)
+							}) : (e.directTouch = !1, e.image = n.renderer.image(c.toDataURL("image/png", 1)).attr(l).add(e.group));
+						}
+						e.isDirtyCanvas = !1;
+					} else (t.width !== o || t.height !== c) && t.attr(l);
+				} else (r.enabled || e._hasPointMarkers) && (Q.prototype.drawPoints.call(e), e.points.forEach((t) => {
+					t.graphic && (t.graphic[e.chart.styledMode ? "css" : "animate"](e.colorAttribs(t)), t.value === null && t.graphic.addClass("highcharts-null-point"));
+				}));
+			}
+			getExtremes() {
+				let { dataMin: e, dataMax: t } = Q.prototype.getExtremes.call(this, this.getColumn("value"));
+				return si(e) && (this.valueMin = e), si(t) && (this.valueMax = t), Q.prototype.getExtremes.call(this);
+			}
+			getValidPoints(e, t) {
+				return Q.prototype.getValidPoints.call(this, e, t, !0);
+			}
+			hasData() {
+				return !!this.dataTable.rowCount;
+			}
+			init() {
+				super.init.apply(this, arguments);
+				let e = this.options;
+				e.pointRange = li(e.pointRange, e.colsize || 1), this.yAxis.axisPointRange = e.rowsize || 1, ri.ellipse = ri.circle, e.marker && si(e.borderRadius) && (e.marker.r = e.borderRadius);
+			}
+			markerAttribs(e, t) {
+				let n = e.shapeArgs || {};
+				if (e.hasImage) return {
+					x: e.plotX,
+					y: e.plotY
+				};
+				if (t && t !== "normal") {
+					let r = e.options.marker || {}, i = (this.options.marker || {}).states?.[t] || {}, a = r.states?.[t] || {}, o = (a.width || i.width || n.width || 0) + (a.widthPlus || i.widthPlus || 0), s = (a.height || i.height || n.height || 0) + (a.heightPlus || i.heightPlus || 0);
+					return {
+						x: (n.x || 0) + ((n.width || 0) - o) / 2,
+						y: (n.y || 0) + ((n.height || 0) - s) / 2,
+						width: o,
+						height: s
+					};
+				}
+				return n;
+			}
+			pointAttribs(e, t) {
+				let n = Q.prototype.pointAttribs.call(this, e, t), r = this.options || {}, i = this.chart.options.plotOptions || {}, a = i.series || {}, o = i.heatmap || {}, s = e?.options.borderColor || r.borderColor || o.borderColor || a.borderColor, c = e?.options.borderWidth || r.borderWidth || o.borderWidth || a.borderWidth || n["stroke-width"];
+				if (n.stroke = e?.marker?.lineColor || r.marker?.lineColor || s || this.color, n["stroke-width"] = c, t && t !== "normal") {
+					let i = ci(r.states?.[t], r.marker?.states?.[t], e?.options.marker?.states?.[t] || {});
+					n.fill = i.color || se().parse(n.fill).brighten(i.brightness || 0).get(), n.stroke = i.lineColor || n.stroke;
+				}
+				return n;
+			}
+			translate() {
+				let { borderRadius: e, marker: t } = this.options, n = t?.symbol || "rect", r = ri[n] ? n : "rect", i = ["circle", "square"].indexOf(r) !== -1;
+				for (let t of (this.generatePoints(), this.points)) {
+					let a = t.getCellAttributes(), o = Math.min(a.x1, a.x2), s = Math.min(a.y1, a.y2), c = Math.max(Math.abs(a.x2 - a.x1), 0), l = Math.max(Math.abs(a.y2 - a.y1), 0);
+					if (t.hasImage = (t.marker?.symbol || n || "").indexOf("url") === 0, i) {
+						let e = Math.abs(c - l);
+						o = Math.min(a.x1, a.x2) + (c < l ? 0 : e / 2), s = Math.min(a.y1, a.y2) + (c < l ? e / 2 : 0), c = l = Math.min(c, l);
+					}
+					t.hasImage && (t.marker = {
+						width: c,
+						height: l
+					}), t.plotX = t.clientX = (a.x1 + a.x2) / 2, t.plotY = (a.y1 + a.y2) / 2, t.shapeType = "path", t.shapeArgs = ci(!0, {
+						x: o,
+						y: s,
+						width: c,
+						height: l
+					}, { d: ri[r](o, s, c, l, { r: si(e) ? e : 0 }) });
+				}
+				oi(this, "afterTranslate");
+			}
+		}
+		fi.defaultOptions = ci(ni.defaultOptions, {
+			animation: !1,
+			borderRadius: 0,
+			borderWidth: 0,
+			interpolation: !1,
+			nullColor: "#f7f7f7",
+			dataLabels: {
+				formatter: function() {
+					let { numberFormatter: e } = this.series.chart, { value: t } = this.point;
+					return Zr(t) ? e(t, -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: .2
+			} },
+			legendSymbol: "rectangle"
+		}), ii(fi, "afterDataClassLegendClick", function() {
+			this.isDirtyCanvas = !0, this.drawPoints(), this.options.enableMouseTracking && this.drawTracker();
+		}), ai(fi.prototype, {
+			axisTypes: M.seriesMembers.axisTypes,
+			colorKey: M.seriesMembers.colorKey,
+			directTouch: !0,
+			getExtremesFromAll: !0,
+			keysAffectYAxis: ["y"],
+			parallelArrays: M.seriesMembers.parallelArrays,
+			pointArrayMap: ["y", "value"],
+			pointClass: Xr,
+			specialGroup: "group",
+			trackerGroups: M.seriesMembers.trackerGroups,
+			alignDataLabel: ti.prototype.alignDataLabel,
+			colorAttribs: M.seriesMembers.colorAttribs,
+			getSymbol: Q.prototype.getSymbol
+		}), M.compose(fi), D().registerSeriesType("heatmap", fi);
+		let $ = T();
+		$.ColorMapComposition = M, $.MapChart = $.MapChart || _t, $.MapNavigation = $.MapNavigation || Ke, $.MapView = $.MapView || W, $.Projection = $.Projection || z, $.mapChart = $.Map = $.MapChart.mapChart, $.maps = $.MapChart.maps, $.geojson = Pt.geojson, $.topo2geo = Pt.topo2geo, Pt.compose($.Chart), Wr.compose($.Axis, $.Chart, $.Legend), Ke.compose(_t, $.Pointer, $.SVGRenderer), W.compose(_t);
+		let pi = T();
+		return ne.default;
+	})());
+}));
+//#endregion
+export default t();