@8wave/ai-elements 0.69.0 → 0.70.0

package/dist/_chunks/vue-leaflet.es-BT-uRmMx.js

@@ -1,1738 +0,0 @@
-import { B as e, E as t, F as n, H as r, Ht as i, I as a, K as o, L as s, M as c, R as l, Y as u, Z as d, _ as f, b as p, ct as m, ft as h, h as g, j as _, k as ee, o as v, v as y, x as b, yt as x, z as S } from "./vue.runtime.esm-bundler-ljsQ8m_k.js";
-import { Circle as te, CircleMarker as ne, Control as C, DivIcon as w, DomEvent as T, DomUtil as re, FeatureGroup as ie, GeoJSON as ae, GridLayer as oe, Icon as se, ImageOverlay as ce, LatLng as le, LatLngBounds as ue, LayerGroup as de, Map as fe, Marker as pe, Polygon as me, Polyline as he, Popup as ge, Rectangle as _e, SVGOverlay as ve, TileLayer as ye, Tooltip as be, Util as E, VideoOverlay as xe } from "https://cdn.jsdelivr.net/npm/leaflet@2.0.0-alpha.1/dist/leaflet-src.js";
-//#region ../../node_modules/.pnpm/@maxel01+vue-leaflet@1.0.0-beta.7_leaflet@2.0.0-alpha_vue@3.5.32_typescript@6.0.2_/node_modules/@maxel01/vue-leaflet/dist/vue-leaflet.es.js
-var Se = /* @__PURE__ */ Symbol("getMapObject"), D = /* @__PURE__ */ Symbol("addLayer"), O = /* @__PURE__ */ Symbol("removeLayer"), k = /* @__PURE__ */ Symbol("registerControl"), Ce = /* @__PURE__ */ Symbol("registerLayerControl"), we = /* @__PURE__ */ Symbol("canSetParentHtml"), Te = /* @__PURE__ */ Symbol("setParentHtml"), Ee = /* @__PURE__ */ Symbol("setIcon"), A = /* @__PURE__ */ Symbol("bindPopup"), j = /* @__PURE__ */ Symbol("bindTooltip"), De = /* @__PURE__ */ Symbol("unbindPopup"), Oe = /* @__PURE__ */ Symbol("unbindTooltip"), M = { experimental: {
-	useResetWebpackIcon: !0,
-	skipUndefinedProps: !1
-} };
-function ke(e) {
-	e.experimental = {
-		...M.experimental,
-		...e.experimental
-	}, Object.assign(M, e);
-}
-var N = (e, t) => {
-	for (let [n, r] of Object.entries(t)) e.on(n, r);
-}, P = (e) => {
-	for (let [, t] of Object.entries(e)) F(t?.cancel) && t.cancel();
-}, Ae = (e) => !e || typeof e.charAt != "function" ? e : e.charAt(0).toUpperCase() + e.slice(1), F = (e) => typeof e == "function", I = (e, t, n) => {
-	let r = [];
-	for (let i in n) {
-		if (M.experimental.skipUndefinedProps && n[i] === void 0) continue;
-		let a = "set" + Ae(i), o = e[a];
-		if (F(o)) {
-			d(() => n[i], (e, t) => {
-				o(e, t);
-			});
-			continue;
-		}
-		F(t[a]) ? d(() => n[i], (e) => {
-			t[a](e);
-		}) : i !== "options" && r.push(i);
-	}
-	return r;
-}, L = (e, t = {}) => {
-	let n = { ...t };
-	for (let t in e) t === "options" || e[t] === void 0 || (n[t] = e[t]);
-	return n;
-}, R = (e) => {
-	let t = {}, n = {};
-	for (let r in e) if (r.startsWith("on") && !r.startsWith("onUpdate") && r !== "onReady") {
-		let n = r.slice(2).toLocaleLowerCase(), i = e[r];
-		F(i) && (t[n] = i);
-	} else n[r] = e[r];
-	return {
-		listeners: t,
-		attrs: n
-	};
-}, je = async (e) => {
-	if (!M.experimental.useResetWebpackIcon) return;
-	let t = await Promise.all([
-		import("https://cdn.jsdelivr.net/npm/leaflet@2.0.0-alpha.1/dist/leaflet-src.js/dist/images/marker-icon-2x.png"),
-		import("https://cdn.jsdelivr.net/npm/leaflet@2.0.0-alpha.1/dist/leaflet-src.js/dist/images/marker-icon.png"),
-		import("https://cdn.jsdelivr.net/npm/leaflet@2.0.0-alpha.1/dist/leaflet-src.js/dist/images/marker-shadow.png")
-	]);
-	delete e.Default.prototype._getIconUrl, e.Default.mergeOptions({
-		iconRetinaUrl: t[0].default,
-		iconUrl: t[1].default,
-		shadowUrl: t[2].default
-	});
-}, z = (t) => {
-	let n = h((...e) => console.warn(`Method ${String(t)} has been invoked without being replaced`)), r = (...e) => n.value(...e);
-	return r.wrapped = n, e(t, r), r;
-}, B = (e, t) => e.wrapped.value = t, V = (e) => {
-	let t = _(e);
-	if (t === void 0) throw Error(`Attempt to inject ${e.description} before it was provided.`);
-	return t;
-}, H = { options: () => ({}) }, U = (e) => ({
-	options: e.options,
-	methods: {}
-}), W = {
-	...H,
-	visible: !0
-}, G = (t, n, r) => {
-	let i = V(D), a = V(O), { options: o, methods: s } = U(t), c = L(t, o);
-	function u(e) {
-		r("update:visible", e);
-	}
-	let d = () => i({
-		leafletObject: n.value,
-		updateVisibleProp: u,
-		layerType: t.layerType
-	}), f = () => a({
-		leafletObject: n.value,
-		updateVisibleProp: u,
-		layerType: t.layerType
-	}), p = {
-		...s,
-		setAttribution(e) {
-			f(), n.value && (n.value.options.attribution = e), t.visible && d();
-		},
-		setName() {
-			f(), t.visible && d();
-		},
-		setLayerType() {
-			f(), t.visible && d();
-		},
-		setVisible(e) {
-			n.value && (e ? d() : f());
-		},
-		bindPopup(e) {
-			if (!n.value || !F(n.value.bindPopup)) {
-				console.warn("Attempt to bind popup before bindPopup method available on layer.");
-				return;
-			}
-			e && n.value.bindPopup(e);
-		},
-		bindTooltip(e) {
-			if (!n.value || !F(n.value.bindTooltip)) {
-				console.warn("Attempt to bind tooltip before bindTooltip method available on layer.");
-				return;
-			}
-			e && n.value.bindTooltip(e);
-		},
-		unbindTooltip() {
-			n.value && (F(n.value.closeTooltip) && n.value.closeTooltip(), F(n.value.unbindTooltip) && n.value.unbindTooltip());
-		},
-		unbindPopup() {
-			n.value && (F(n.value.closePopup) && n.value.closePopup(), F(n.value.unbindPopup) && n.value.unbindPopup());
-		},
-		updateVisibleProp: u
-	};
-	return e(A, p.bindPopup), e(j, p.bindTooltip), e(De, p.unbindPopup), e(Oe, p.unbindTooltip), l(() => {
-		p.unbindPopup(), p.unbindTooltip(), f();
-	}), {
-		options: c,
-		methods: p
-	};
-}, Me = {
-	...W,
-	interactive: void 0,
-	bubblingPointerEvents: void 0
-}, Ne = (e, t, n) => {
-	let { options: r, methods: i } = G(e, t, n);
-	return {
-		options: L(e, r),
-		methods: i
-	};
-}, K = {
-	...Me,
-	stroke: void 0,
-	fill: void 0
-}, Pe = (e, t, n) => {
-	let { options: r, methods: i } = Ne(e, t, n);
-	return {
-		options: L(e, r),
-		methods: {
-			...i,
-			setStroke(e) {
-				t.value?.setStyle({ stroke: e });
-			},
-			setColor(e) {
-				t.value?.setStyle({ color: e });
-			},
-			setWeight(e) {
-				t.value?.setStyle({ weight: e });
-			},
-			setOpacity(e) {
-				t.value?.setStyle({ opacity: e });
-			},
-			setLineCap(e) {
-				t.value?.setStyle({ lineCap: e });
-			},
-			setLineJoin(e) {
-				t.value?.setStyle({ lineJoin: e });
-			},
-			setDashArray(e) {
-				t.value?.setStyle({ dashArray: e });
-			},
-			setDashOffset(e) {
-				t.value?.setStyle({ dashOffset: e });
-			},
-			setFill(e) {
-				t.value?.setStyle({ fill: e });
-			},
-			setFillColor(e) {
-				t.value?.setStyle({ fillColor: e });
-			},
-			setFillOpacity(e) {
-				t.value?.setStyle({ fillOpacity: e });
-			},
-			setFillRule(e) {
-				t.value?.setStyle({ fillRule: e });
-			},
-			setClassName(e) {
-				t.value?.setStyle({ className: e });
-			}
-		}
-	};
-}, Fe = {
-	...K,
-	options: () => ({ radius: 10 })
-}, Ie = (e, t, n) => {
-	let { options: r, methods: i } = Pe(e, t, n);
-	return {
-		options: L(e, r),
-		methods: {
-			...i,
-			setRadius(e) {
-				t.value?.setRadius(e);
-			},
-			setLatLng(e) {
-				t.value?.setLatLng(e);
-			}
-		}
-	};
-}, Le = { ...Fe }, Re = (e, t, n) => {
-	let { options: r, methods: i } = Ie(e, t, n);
-	return {
-		options: L(e, r),
-		methods: { ...i }
-	};
-}, ze = {
-	key: 0,
-	style: { display: "none" }
-}, Be = /* @__PURE__ */ t({
-	name: "LCircle",
-	__name: "LCircle",
-	props: /* @__PURE__ */ c({
-		radius: {},
-		latLng: {},
-		stroke: { type: Boolean },
-		color: {},
-		weight: {},
-		opacity: {},
-		lineCap: {},
-		lineJoin: {},
-		dashArray: {},
-		dashOffset: {},
-		fill: { type: Boolean },
-		fillColor: {},
-		fillOpacity: {},
-		fillRule: {},
-		className: {},
-		interactive: { type: Boolean },
-		bubblingPointerEvents: { type: Boolean },
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Le),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { options: i, methods: l } = Re(a, e, c);
-			return s(async () => {
-				e.value = m(new te(a.latLng, i));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(l, e.value, a), r({
-					...a,
-					...l,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", ze, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), Ve = {
-	key: 0,
-	style: { display: "none" }
-}, He = /* @__PURE__ */ t({
-	name: "LCircleMarker",
-	__name: "LCircleMarker",
-	props: /* @__PURE__ */ c({
-		radius: {},
-		latLng: {},
-		stroke: { type: Boolean },
-		color: {},
-		weight: {},
-		opacity: {},
-		lineCap: {},
-		lineJoin: {},
-		dashArray: {},
-		dashOffset: {},
-		fill: { type: Boolean },
-		fillColor: {},
-		fillOpacity: {},
-		fillRule: {},
-		className: {},
-		interactive: { type: Boolean },
-		bubblingPointerEvents: { type: Boolean },
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Fe),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { options: i, methods: l } = Ie(a, e, c);
-			return s(async () => {
-				e.value = m(new ne(a.latLng, i));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(l, e.value, a), r({
-					...a,
-					...l,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				leafletObject: e,
-				ready: t
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", Ve, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), q = { ...H }, Ue = {
-	...q,
-	disableClickPropagation: !0,
-	disableScrollPropagation: !1
-}, J = (e, t) => {
-	let { options: n, methods: r } = U(e), i = L(e, n), a = {
-		...r,
-		setPosition(e) {
-			t.value?.setPosition(e);
-		}
-	};
-	return l(() => {
-		t.value?.remove();
-	}), {
-		options: i,
-		methods: a
-	};
-}, We = /* @__PURE__ */ t({
-	name: "LControl",
-	__name: "LControl",
-	props: /* @__PURE__ */ c({
-		disableClickPropagation: { type: Boolean },
-		disableScrollPropagation: { type: Boolean },
-		position: {},
-		options: {}
-	}, Ue),
-	emits: ["ready"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, o = i, { root: c, leafletObject: l } = u();
-		t({
-			root: c,
-			leafletObject: l
-		});
-		function u() {
-			let e = h(), t = h(), r = V(k), { options: i, methods: c } = J(a, e);
-			return s(async () => {
-				class s extends C {
-					onAdd() {
-						return t.value;
-					}
-				}
-				e.value = m(new s(i)), I(c, e.value, a), r({ leafletObject: e.value }), a.disableClickPropagation && t.value && T.disableClickPropagation(t.value), a.disableScrollPropagation && t.value && T.disableScrollPropagation(t.value), n(() => o("ready", e.value));
-			}), {
-				root: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => (S(), b("div", {
-			ref_key: "root",
-			ref: c
-		}, [r(e.$slots, "default")], 512));
-	}
-}), Ge = { ...q }, Ke = (e, t) => {
-	let { options: n, methods: r } = J(e, t);
-	return {
-		options: L(e, n),
-		methods: {
-			...r,
-			setPrefix(e) {
-				t.value?.setPrefix(e);
-			}
-		}
-	};
-}, qe = /* @__PURE__ */ t({
-	name: "LControlAttribution",
-	__name: "LControlAttribution",
-	props: /* @__PURE__ */ c({
-		prefix: { type: [String, Boolean] },
-		position: {},
-		options: {}
-	}, Ge),
-	emits: ["ready"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { leafletObject: o } = c();
-		t({ leafletObject: o });
-		function c() {
-			let e = h(), t = V(k), { options: r, methods: o } = Ke(i, e);
-			return s(async () => {
-				e.value = m(new C.Attribution(r)), I(o, e.value, i), t({ leafletObject: e.value }), n(() => a("ready", e.value));
-			}), { leafletObject: e };
-		}
-		return (e, t) => null;
-	}
-}), Je = {
-	...q,
-	collapsed: void 0,
-	autoZIndex: void 0,
-	hideSingleBase: void 0,
-	sortLayers: void 0
-}, Ye = (e, t) => {
-	let { options: n } = J(e, t);
-	return {
-		options: L(e, n),
-		methods: {
-			addLayer(e) {
-				e.leafletObject && (e.layerType === "base" ? t.value?.addBaseLayer(e.leafletObject, e.name || "") : e.layerType === "overlay" && t.value?.addOverlay(e.leafletObject, e.name || ""));
-			},
-			removeLayer(e) {
-				e.leafletObject && t.value?.removeLayer(e.leafletObject);
-			}
-		}
-	};
-}, Xe = /* @__PURE__ */ t({
-	name: "LControlLayers",
-	__name: "LControlLayers",
-	props: /* @__PURE__ */ c({
-		collapsed: { type: Boolean },
-		autoZIndex: { type: Boolean },
-		hideSingleBase: { type: Boolean },
-		sortLayers: { type: Boolean },
-		sortFunction: { type: Function },
-		position: {},
-		options: {}
-	}, Je),
-	emits: ["ready"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { leafletObject: o } = c();
-		t({ leafletObject: o });
-		function c() {
-			let e = h(), t = V(Ce), { options: r, methods: o } = Ye(i, e);
-			return s(async () => {
-				e.value = m(new C.Layers(void 0, void 0, r)), I(o, e.value, i), t({
-					...i,
-					...o,
-					leafletObject: e.value
-				}), n(() => a("ready", e.value));
-			}), { leafletObject: e };
-		}
-		return (e, t) => null;
-	}
-}), Ze = {
-	...q,
-	metric: void 0,
-	imperial: void 0,
-	updateWhenIdle: void 0
-}, Qe = (e, t) => {
-	let { options: n, methods: r } = J(e, t);
-	return {
-		options: L(e, n),
-		methods: r
-	};
-}, $e = /* @__PURE__ */ t({
-	name: "LControlScale",
-	__name: "LControlScale",
-	props: /* @__PURE__ */ c({
-		maxWidth: {},
-		metric: { type: Boolean },
-		imperial: { type: Boolean },
-		updateWhenIdle: { type: Boolean },
-		position: {},
-		options: {}
-	}, Ze),
-	emits: ["ready"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { leafletObject: o } = c();
-		t({ leafletObject: o });
-		function c() {
-			let e = h(), t = V(k), { options: r, methods: o } = Qe(i, e);
-			return s(async () => {
-				e.value = m(new C.Scale(r)), I(o, e.value, i), t({ leafletObject: e.value }), n(() => a("ready", e.value));
-			}), { leafletObject: e };
-		}
-		return (e, t) => null;
-	}
-}), et = { ...q }, tt = (e, t) => {
-	let { options: n, methods: r } = J(e, t);
-	return {
-		options: L(e, n),
-		methods: r
-	};
-}, nt = /* @__PURE__ */ t({
-	name: "LControlZoom",
-	__name: "LControlZoom",
-	props: /* @__PURE__ */ c({
-		zoomInText: {},
-		zoomInTitle: {},
-		zoomOutText: {},
-		zoomOutTitle: {},
-		position: {},
-		options: {}
-	}, et),
-	emits: ["ready"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { leafletObject: o } = c();
-		t({ leafletObject: o });
-		function c() {
-			let e = h(), t = V(k), { options: r, methods: o } = tt(i, e);
-			return s(async () => {
-				e.value = m(new C.Zoom(r)), I(o, e.value, i), t({ leafletObject: e.value }), n(() => a("ready", e.value));
-			}), { leafletObject: e };
-		}
-		return (e, t) => null;
-	}
-}), rt = { ...H }, it = /* @__PURE__ */ t({
-	name: "LIcon",
-	__name: "LIcon",
-	props: /* @__PURE__ */ c({
-		iconUrl: {},
-		iconRetinaUrl: {},
-		iconSize: {},
-		iconAnchor: {},
-		popupAnchor: {},
-		tooltipAnchor: {},
-		shadowUrl: {},
-		shadowRetinaUrl: {},
-		shadowSize: {},
-		shadowAnchor: {},
-		bgPos: {},
-		className: {},
-		options: {}
-	}, rt),
-	setup(e, { expose: t }) {
-		let i = e, { root: a } = c();
-		t({ root: a });
-		function c() {
-			let e = h(), { scheduleCreateIcon: t, scheduleHtmlSwap: n } = l(), r = {
-				setIconUrl: t,
-				setIconRetinaUrl: t,
-				setIconSize: t,
-				setIconAnchor: t,
-				setPopupAnchor: t,
-				setTooltipAnchor: t,
-				setShadowUrl: t,
-				setShadowRetinaUrl: t,
-				setShadowAnchor: t,
-				setBgPos: t,
-				setClassName: t,
-				setHtml: t
-			};
-			return s(async () => {
-				I(r, {}, i), new MutationObserver(n).observe(e.value, {
-					attributes: !0,
-					childList: !0,
-					characterData: !0,
-					subtree: !0
-				}), t();
-			}), { root: e };
-		}
-		function l() {
-			let e = V(we), t = V(Te), r = V(Ee), s = o(), c, l = (n, a, o) => {
-				let l = n && n.innerHTML.replace(/* @__PURE__ */ RegExp("<!--[\\s\\S]*?-->", "g"), "");
-				if (!a) {
-					o && c && e() && t(l);
-					return;
-				}
-				let { listeners: u } = R(s);
-				c && T.off(c, u);
-				let { options: d } = U(i), f = L(i, d);
-				l && (f.html = l), c = f.html ? new w(f) : new se(f), T.on(c, u), r(c);
-			};
-			return {
-				scheduleCreateIcon: () => {
-					n(() => {
-						a.value && l(a.value, !0, !1);
-					});
-				},
-				scheduleHtmlSwap: () => {
-					n(() => {
-						a.value && l(a.value, !1, !0);
-					});
-				}
-			};
-		}
-		return (e, t) => (S(), b("div", {
-			ref_key: "root",
-			ref: a
-		}, [r(e.$slots, "default")], 512));
-	}
-}), Y = {
-	...W,
-	interactive: void 0,
-	crossOrigin: void 0
-}, X = (e, t, n) => {
-	let { options: r, methods: i } = G(e, t, n);
-	return {
-		options: L(e, r),
-		methods: {
-			...i,
-			setOpacity(e) {
-				return t.value?.setOpacity(e);
-			},
-			setUrl(e) {
-				return t.value?.setUrl(e);
-			},
-			setBounds(e) {
-				return t.value?.setBounds(e);
-			},
-			getBounds() {
-				return t.value?.getBounds();
-			},
-			getElement() {
-				return t.value?.getElement();
-			},
-			bringToFront() {
-				return t.value?.bringToFront();
-			},
-			bringToBack() {
-				return t.value?.bringToBack();
-			},
-			setZIndex(e) {
-				return t.value?.setZIndex(e);
-			}
-		}
-	};
-}, at = {
-	key: 0,
-	style: { display: "none" }
-}, ot = /* @__PURE__ */ t({
-	name: "LImageOverlay",
-	__name: "LImageOverlay",
-	props: /* @__PURE__ */ c({
-		url: {},
-		opacity: {},
-		alt: {},
-		interactive: { type: Boolean },
-		crossOrigin: { type: Boolean },
-		errorOverlayUrl: {},
-		zIndex: {},
-		className: {},
-		bounds: {},
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Y),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { options: i, methods: l } = X(a, e, c);
-			return s(async () => {
-				e.value = m(new ce(a.url, a.bounds, i));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(l, e.value, a), r({
-					...a,
-					...l,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", at, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), Z = W, Q = (t, n, r) => {
-	let { options: i, methods: a } = G(t, n, r), o = L(t, i), s = {
-		...a,
-		addLayer(e) {
-			n.value?.addLayer(e.leafletObject);
-		},
-		removeLayer(e) {
-			n.value?.removeLayer(e.leafletObject);
-		}
-	};
-	return e(D, s.addLayer), e(O, s.removeLayer), {
-		options: o,
-		methods: s
-	};
-}, st = Z, ct = (e, t, n) => {
-	let { options: r, methods: i } = Q(e, t, n);
-	return {
-		options: L(e, r),
-		methods: { ...i }
-	};
-}, lt = {
-	key: 0,
-	style: { display: "none" }
-}, ut = /* @__PURE__ */ t({
-	name: "LFeatureGroup",
-	__name: "LFeatureGroup",
-	props: /* @__PURE__ */ c({
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, st),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { methods: i, options: l } = ct(a, e, c);
-			return s(async () => {
-				e.value = m(new ie(void 0, l));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(i, e.value, a), r({
-					...a,
-					...i,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", lt, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), dt = Z, ft = (e, t, n) => {
-	let { options: r, methods: i } = Q(e, t, n), a = L(e, r);
-	return Object.prototype.hasOwnProperty.call(e, "optionsStyle") && (a.style = e.optionsStyle), {
-		options: a,
-		methods: {
-			...i,
-			setGeojson(e) {
-				t.value?.clearLayers(), t.value?.addData(e);
-			},
-			setOptionsStyle(e) {
-				t.value?.setStyle(e);
-			},
-			getGeoJSONData() {
-				return t.value?.toGeoJSON();
-			},
-			getBounds() {
-				return t.value?.getBounds();
-			}
-		}
-	};
-}, pt = /* @__PURE__ */ t({
-	name: "LGeoJson",
-	__name: "LGeoJson",
-	props: /* @__PURE__ */ c({
-		geojson: {},
-		optionsStyle: { type: Function },
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, dt),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { ready: c, leafletObject: l } = u();
-		t({
-			ready: c,
-			leafletObject: l
-		});
-		function u() {
-			let e = h(), t = h(!1), r = V(D), { methods: c, options: l } = ft(i, e, a);
-			return s(async () => {
-				e.value = m(new ae(i.geojson, l));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(c, e.value, i), r({
-					...i,
-					...c,
-					leafletObject: e.value
-				}), t.value = !0, n(() => a("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => null;
-	}
-}), mt = {
-	...W,
-	noWrap: void 0
-}, ht = mt, gt = (e, t, n) => {
-	let { options: r, methods: i } = G(e, t, n), a = L(e, r), o = {
-		...i,
-		setTileComponent() {
-			t.value?.redraw();
-		}
-	};
-	return l(() => {
-		t.value?.off();
-	}), {
-		options: a,
-		methods: o
-	};
-};
-function _t(e) {
-	class t extends oe {
-		tileComponents = {};
-		constructor(e) {
-			super(e), this.on("tileunload", this._unloadTile, this);
-		}
-		createTile(t) {
-			let n = this._tileCoordsToKey(t), r = re.create("div");
-			return this.tileComponents[n] = r, v(ee({
-				setup: e,
-				props: ["coords"]
-			}, { coords: t }), r), r;
-		}
-		_unloadTile(e) {
-			let t = this._tileCoordsToKey(e.coords), n = this.tileComponents[t];
-			n && (n.innerHTML = "", this.tileComponents[t] = void 0);
-		}
-	}
-	return t;
-}
-var vt = /* @__PURE__ */ t({
-	name: "LGridLayer",
-	__name: "LGridLayer",
-	props: /* @__PURE__ */ c({
-		childRender: { type: Function },
-		opacity: {},
-		zIndex: {},
-		tileSize: {},
-		noWrap: { type: Boolean },
-		minZoom: {},
-		maxZoom: {},
-		className: {},
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, ht),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { leafletObject: c, root: l, ready: u } = d();
-		t({
-			leafletObject: c,
-			root: l,
-			ready: u
-		});
-		function d() {
-			let e = h(), t = h(), r = h(!1), c = V(D), { options: l, methods: u } = gt(i, e, a);
-			return s(async () => {
-				e.value = m(new (_t(i.childRender))(l));
-				let { listeners: t } = R(o());
-				e.value.on(t), I(u, e.value, i), c({
-					...i,
-					...u,
-					leafletObject: e.value
-				}), r.value = !0, n(() => a("ready", e.value));
-			}), {
-				leafletObject: e,
-				root: t,
-				ready: r
-			};
-		}
-		return (e, t) => null;
-	}
-}), yt = {
-	key: 0,
-	style: { display: "none" }
-}, bt = /* @__PURE__ */ t({
-	name: "LLayerGroup",
-	__name: "LLayerGroup",
-	props: /* @__PURE__ */ c({
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Z),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { methods: i } = Q(a, e, c);
-			return s(async () => {
-				e.value = m(new de(void 0, a.options));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(i, e.value, a), r({
-					...a,
-					...i,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", yt, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), xt = (e, t = 100) => {
-	let n = null, r = ((...r) => {
-		n !== null && clearTimeout(n), n = setTimeout(() => {
-			n = null, e(...r);
-		}, t);
-	});
-	return r.cancel = () => {
-		n !== null && (clearTimeout(n), n = null);
-	}, r;
-}, St = {
-	...H,
-	width: "100%",
-	height: "100%",
-	worldCopyJump: void 0,
-	inertia: void 0,
-	zoomAnimation: void 0,
-	fadeAnimation: void 0,
-	markerZoomAnimation: void 0,
-	noBlockingAnimations: void 0
-}, Ct = (e) => U(e), wt = /* @__PURE__ */ t({
-	name: "LMap",
-	inheritAttrs: !1,
-	__name: "LMap",
-	props: /* @__PURE__ */ c({
-		width: {},
-		height: {},
-		center: {},
-		bounds: {},
-		maxBounds: {},
-		zoom: {},
-		minZoom: {},
-		maxZoom: {},
-		paddingBottomRight: {},
-		paddingTopLeft: {},
-		padding: {},
-		worldCopyJump: { type: Boolean },
-		crs: {},
-		maxBoundsViscosity: {},
-		inertia: { type: Boolean },
-		inertiaDeceleration: {},
-		inertiaMaxSpeed: {},
-		easeLinearity: {},
-		zoomAnimation: { type: Boolean },
-		zoomAnimationThreshold: {},
-		fadeAnimation: { type: Boolean },
-		markerZoomAnimation: { type: Boolean },
-		noBlockingAnimations: { type: Boolean },
-		beforeMapMount: { type: Function },
-		options: {}
-	}, St),
-	emits: [
-		"ready",
-		"update:zoom",
-		"update:center",
-		"update:bounds"
-	],
-	setup(e, { expose: t, emit: c }) {
-		let l = e, { root: u, leafletObject: d, ready: g } = T(), { zoomPanOptions: _, fitBoundsOptions: ee } = re(), { methods: v, layersInControl: y } = ie(), { listeners: te, attrs: ne, eventHandlers: C } = ae();
-		oe();
-		let w = c;
-		t({
-			root: u,
-			ready: g,
-			leafletObject: d,
-			attrs: ne,
-			...v
-		});
-		function T() {
-			let e = h(), t = h(), r = h(!1), { options: i } = Ct(l), o = L(l, i);
-			return s(async () => {
-				try {
-					l.beforeMapMount && await l.beforeMapMount();
-				} catch (e) {
-					console.error(`The following error occurred running the provided beforeMapMount hook ${e}`);
-				}
-				await je(se), t.value = m(new fe(e.value, o)), I(v, t.value, l), N(t.value, C), N(t.value, te), r.value = !0, n(() => w("ready", t.value));
-			}), a(() => {
-				P(C), t.value?.off(), t.value?.remove();
-			}), {
-				root: e,
-				leafletObject: t,
-				ready: r
-			};
-		}
-		function re() {
-			let e = f(() => {
-				let e = {};
-				return l.noBlockingAnimations && (e.animate = !1), e;
-			});
-			return {
-				zoomPanOptions: e,
-				fitBoundsOptions: f(() => {
-					let t = e.value;
-					return t.padding = l.padding ? l.padding : void 0, t.paddingTopLeft = l.paddingTopLeft ? l.paddingTopLeft : void 0, t.paddingBottomRight = l.paddingBottomRight ? l.paddingBottomRight : void 0, t;
-				})
-			};
-		}
-		function ie() {
-			let e = h([]), t = h(), n = h([]);
-			function r() {
-				return d.value;
-			}
-			function i(r) {
-				r.layerType !== void 0 && (t.value === void 0 ? n.value.push(r) : e.value.find((e) => E.stamp(e.leafletObject) === E.stamp(r.leafletObject)) || (t.value.addLayer(r), e.value.push(r))), r.leafletObject && r.visible !== !1 && d.value.addLayer(r.leafletObject);
-			}
-			function a(r) {
-				r.layerType !== void 0 && (t.value === void 0 ? n.value = n.value.filter((e) => e.name !== r.name) : (t.value.removeLayer(r), e.value = e.value.filter((e) => E.stamp(e.leafletObject) !== E.stamp(r.leafletObject)))), r.leafletObject && d.value.removeLayer(r.leafletObject);
-			}
-			function o(e) {
-				t.value = e, n.value.forEach((e) => {
-					t.value.addLayer(e);
-				}), n.value = [], s(e);
-			}
-			function s(e) {
-				d.value.addControl(e.leafletObject);
-			}
-			function c(e) {
-				e !== d.value.getZoom() && d.value.setZoom(e, _.value);
-			}
-			function l(e) {
-				let t = d.value.getBounds();
-				d.value.options.crs = e, d.value.fitBounds(t, {
-					animate: !1,
-					padding: [0, 0]
-				});
-			}
-			function u(e) {
-				d.value.fitBounds(e, ee.value);
-			}
-			let f = h();
-			function p(e) {
-				if (!e) return;
-				let t = new ue(e);
-				t.isValid() && !(f.value || d.value.getBounds()).equals(t, 0) && (f.value = t, u(t));
-			}
-			let m = h();
-			function g(e) {
-				if (!e) return;
-				let t = new le(...e), n = m.value || d.value.getCenter();
-				(n.lat !== t.lat || n.lng !== t.lng) && (m.value = t, d.value.panTo(t, _.value));
-			}
-			return {
-				methods: {
-					getMapObject: r,
-					addLayer: i,
-					removeLayer: a,
-					registerLayerControl: o,
-					registerControl: s,
-					setZoom: c,
-					setCrs: l,
-					fitBounds: u,
-					setBounds: p,
-					setCenter: g
-				},
-				layersInControl: e
-			};
-		}
-		function ae() {
-			let { listeners: e, attrs: t } = R(o());
-			return {
-				listeners: e,
-				attrs: t,
-				eventHandlers: {
-					moveend: xt((e) => {
-						d.value && (w("update:zoom", d.value.getZoom()), w("update:center", d.value.getCenter()), w("update:bounds", d.value.getBounds()));
-					}),
-					overlayadd(e) {
-						y.value.find((t) => t.name === e.name)?.updateVisibleProp(!0);
-					},
-					overlayremove(e) {
-						y.value.find((t) => t.name === e.name)?.updateVisibleProp(!1);
-					}
-				}
-			};
-		}
-		function oe() {
-			let e = z(Se), t = z(D), n = z(O), r = z(k), i = z(Ce);
-			s(() => {
-				B(e, v.getMapObject), B(t, v.addLayer), B(n, v.removeLayer), B(r, v.registerControl), B(i, v.registerLayerControl);
-			});
-		}
-		return (e, t) => (S(), b("div", {
-			ref_key: "root",
-			ref: u,
-			style: i({
-				width: l.width,
-				height: l.height
-			})
-		}, [x(g) ? r(e.$slots, "default", { key: 0 }) : p("", !0)], 4));
-	}
-}), Tt = ["Symbol(Comment)", "Symbol(Text)"], Et = ["LTooltip", "LPopup"], Dt = {
-	...W,
-	draggable: void 0
-}, Ot = (e, t, n) => {
-	let { options: r, methods: i } = G(e, t, n);
-	return {
-		options: L(e, r),
-		methods: {
-			...i,
-			setDraggable(e) {
-				e ? t.value?.dragging?.enable() : t.value?.dragging?.disable();
-			},
-			latLngSync(e) {
-				e.latlng && (n("update:latLng", e.latlng), n("update:lat-lng", e.latlng));
-			},
-			setLatLng(e) {
-				if (t.value) {
-					let n = t.value.getLatLng();
-					(!n || !n.equals(e)) && t.value.setLatLng(e);
-				}
-			}
-		}
-	};
-}, kt = (e) => {
-	let t = e.default?.();
-	return !!t?.length && t.some(At);
-};
-function At(e) {
-	return Tt.includes(e.type.toString()) ? !1 : typeof e.type == "object" && "__name" in e.type && !Et.includes(e.type.__name || "");
-}
-var jt = {
-	key: 0,
-	style: { display: "none" }
-}, Mt = /* @__PURE__ */ t({
-	name: "LMarker",
-	__name: "LMarker",
-	props: /* @__PURE__ */ c({
-		draggable: { type: Boolean },
-		icon: {},
-		zIndexOffset: {},
-		latLng: {},
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Dt),
-	emits: [
-		"ready",
-		"update:latLng",
-		"update:lat-lng",
-		"update:visible"
-	],
-	setup(t, { expose: i, emit: c }) {
-		let l = t, d = c, { leafletObject: f, ready: g } = _();
-		ee(), i({
-			ready: g,
-			leafletObject: f
-		});
-		function _() {
-			let e = h(), t = h(!1), r = V(D), { options: i, methods: c } = Ot(l, e, d), { listeners: f, eventHandlers: p } = g();
-			function g() {
-				let { listeners: e } = R(o());
-				return {
-					listeners: e,
-					eventHandlers: { move: xt(c.latLngSync) }
-				};
-			}
-			return s(async () => {
-				kt(u()) && (i.icon = new w({ className: "" })), e.value = m(new pe(l.latLng, i)), N(e.value, f), N(e.value, p), I(c, e.value, l), r({
-					...l,
-					...c,
-					leafletObject: e.value
-				}), t.value = !0, n(() => d("ready", e.value));
-			}), a(() => P(p)), {
-				leafletObject: e,
-				ready: t
-			};
-		}
-		function ee() {
-			e(we, () => !!f.value?.getElement()), e(Te, (e) => {
-				let t = F(f.value?.getElement) && f.value?.getElement();
-				t && (t.innerHTML = e);
-			}), e(Ee, (e) => {
-				if (e && f.value?.setIcon) return f.value.setIcon(e);
-			});
-		}
-		return (e, t) => x(g) ? (S(), b("div", jt, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), Nt = {
-	...K,
-	noClip: void 0
-}, Pt = (e, t, n) => {
-	let { options: r, methods: i } = Pe(e, t, n);
-	return {
-		options: L(e, r),
-		methods: {
-			...i,
-			setSmoothFactor(e) {
-				t.value?.setStyle({ smoothFactor: e });
-			},
-			setNoClip(e) {
-				t.value?.setStyle({ noClip: e });
-			},
-			addLatLng(e) {
-				t.value?.addLatLng(e);
-			}
-		}
-	};
-}, $ = { ...Nt }, Ft = (e, t, n) => {
-	let { options: r, methods: i } = Pt(e, t, n);
-	return {
-		options: L(e, r),
-		methods: {
-			...i,
-			toGeoJSON(e) {
-				return t.value?.toGeoJSON(e);
-			}
-		}
-	};
-}, It = {
-	key: 0,
-	style: { display: "none" }
-}, Lt = /* @__PURE__ */ t({
-	name: "LPolygon",
-	__name: "LPolygon",
-	props: /* @__PURE__ */ c({
-		latLngs: {},
-		smoothFactor: {},
-		noClip: { type: Boolean },
-		stroke: { type: Boolean },
-		color: {},
-		weight: {},
-		opacity: {},
-		lineCap: {},
-		lineJoin: {},
-		dashArray: {},
-		dashOffset: {},
-		fill: { type: Boolean },
-		fillColor: {},
-		fillOpacity: {},
-		fillRule: {},
-		className: {},
-		interactive: { type: Boolean },
-		bubblingPointerEvents: { type: Boolean },
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, $),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { options: i, methods: l } = Ft(a, e, c);
-			return s(async () => {
-				e.value = m(new me(a.latLngs, i));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(l, e.value, a), r({
-					...a,
-					...l,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", It, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), Rt = {
-	key: 0,
-	style: { display: "none" }
-}, zt = /* @__PURE__ */ t({
-	name: "LPolyline",
-	__name: "LPolyline",
-	props: /* @__PURE__ */ c({
-		latLngs: {},
-		smoothFactor: {},
-		noClip: { type: Boolean },
-		stroke: { type: Boolean },
-		color: {},
-		weight: {},
-		opacity: {},
-		lineCap: {},
-		lineJoin: {},
-		dashArray: {},
-		dashOffset: {},
-		fill: { type: Boolean },
-		fillColor: {},
-		fillOpacity: {},
-		fillRule: {},
-		className: {},
-		interactive: { type: Boolean },
-		bubblingPointerEvents: { type: Boolean },
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Nt),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { options: i, methods: l } = Pt(a, e, c);
-			return s(async () => {
-				e.value = m(new he(a.latLngs, i));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(l, e.value, a), r({
-					...a,
-					...l,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", Rt, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), Bt = {
-	...H,
-	content: void 0
-}, Vt = (e, t) => {
-	let { options: n, methods: r } = U(e);
-	return {
-		options: n,
-		methods: {
-			...r,
-			setContent(e) {
-				t.value && e != null && t.value.setContent(e);
-			}
-		}
-	};
-}, Ht = { ...Bt }, Ut = (e, t) => {
-	let { options: n, methods: r } = Vt(e, t);
-	return {
-		options: n,
-		methods: r
-	};
-}, Wt = /* @__PURE__ */ t({
-	name: "LPopup",
-	__name: "LPopup",
-	props: /* @__PURE__ */ c({
-		latLng: {},
-		content: {},
-		options: {}
-	}, Ht),
-	emits: ["ready"],
-	setup(e, { expose: t, emit: i }) {
-		let c = e, l = i, { root: u, leafletObject: d } = f();
-		t({
-			root: u,
-			leafletObject: d
-		});
-		function f() {
-			let e = h(), t = h(null), r = V(A), i = V(De), { options: u, methods: d } = Ut(c, e);
-			return s(async () => {
-				e.value = m(new ge(u)), c.latLng !== void 0 && e.value.setLatLng(c.latLng), I(d, e.value, c);
-				let { listeners: i } = R(o());
-				e.value.on(i), e.value.setContent(c.content || t.value), r(e.value), n(() => l("ready", e.value));
-			}), a(() => {
-				i();
-			}), {
-				root: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => (S(), b("div", {
-			ref_key: "root",
-			ref: u
-		}, [r(e.$slots, "default")], 512));
-	}
-}), Gt = { ...$ }, Kt = (e, t, n) => {
-	let { options: r, methods: i } = Ft(e, t, n);
-	return {
-		options: L(e, r),
-		methods: {
-			...i,
-			setBounds(e) {
-				t.value?.setBounds(e);
-			},
-			setLatLngs(e) {
-				t.value?.setBounds(e);
-			}
-		}
-	};
-}, qt = {
-	key: 0,
-	style: { display: "none" }
-}, Jt = /* @__PURE__ */ t({
-	name: "LRectangle",
-	__name: "LRectangle",
-	props: /* @__PURE__ */ c({
-		latLngs: {},
-		bounds: {},
-		smoothFactor: {},
-		noClip: { type: Boolean },
-		stroke: { type: Boolean },
-		color: {},
-		weight: {},
-		opacity: {},
-		lineCap: {},
-		lineJoin: {},
-		dashArray: {},
-		dashOffset: {},
-		fill: { type: Boolean },
-		fillColor: {},
-		fillOpacity: {},
-		fillRule: {},
-		className: {},
-		interactive: { type: Boolean },
-		bubblingPointerEvents: { type: Boolean },
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Gt),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u } = d();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(!1), r = V(D), { options: i, methods: l } = Kt(a, e, c);
-			return s(async () => {
-				if (!a.bounds && !a.latLngs) throw Error("Specify bounds or LatLngs for a valid rectangle.");
-				e.value = m(new _e(a.bounds ? new ue(a.bounds) : new ue(a.latLngs), i));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(l, e.value, a), r({
-					...a,
-					...l,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => x(l) ? (S(), b("div", qt, [r(e.$slots, "default")])) : p("", !0);
-	}
-}), Yt = { ...Y }, Xt = (e, t, n) => {
-	let { options: r, methods: i } = X(e, t, n);
-	return {
-		options: L(e, r),
-		methods: { ...i }
-	};
-}, Zt = {
-	key: 0,
-	style: { display: "none" }
-}, Qt = /* @__PURE__ */ t({
-	name: "LSVGOverlay",
-	__name: "LSVGOverlay",
-	props: /* @__PURE__ */ c({
-		svg: {},
-		opacity: {},
-		alt: {},
-		interactive: { type: Boolean },
-		crossOrigin: { type: Boolean },
-		errorOverlayUrl: {},
-		zIndex: {},
-		className: {},
-		bounds: {},
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, Yt),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u, svgRoot: d } = _();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function _() {
-			let e = h(), t = h(!1), r = h(), i = f(() => {
-				let e = r.value?.firstElementChild;
-				return e?.tagName === "svg" ? e : void 0;
-			}), l = V(D), { options: u, methods: d } = Xt(a, e, c);
-			return s(async () => {
-				if (!i.value && !a.svg) {
-					console.warn("Missing svg prop or slot: LSVGOverlay has not been created.");
-					return;
-				}
-				e.value = m(new ve(i.value ? i.value : a.svg, a.bounds, u));
-				let { listeners: r } = R(o());
-				e.value.on(r), I(d, e.value, a), l({
-					...a,
-					...d,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e,
-				svgRoot: r
-			};
-		}
-		return (e, t) => (S(), b(g, null, [x(l) ? (S(), b("div", Zt, [r(e.$slots, "default")])) : p("", !0), y("div", {
-			style: { display: "none" },
-			ref_key: "svgRoot",
-			ref: d
-		}, [r(e.$slots, "svg")], 512)], 64));
-	}
-}), $t = {
-	...mt,
-	tms: void 0,
-	detectRetina: void 0,
-	tileLayerClass: (e, t) => new ye(e, t)
-}, en = (e, t, n) => {
-	let { options: r, methods: i } = gt(e, t, n);
-	return {
-		options: L(e, r),
-		methods: { ...i }
-	};
-}, tn = /* @__PURE__ */ t({
-	name: "LTileLayer",
-	__name: "LTileLayer",
-	props: /* @__PURE__ */ c({
-		tms: { type: Boolean },
-		subdomains: {},
-		detectRetina: { type: Boolean },
-		url: {},
-		tileLayerClass: { type: Function },
-		opacity: {},
-		zIndex: {},
-		tileSize: {},
-		noWrap: { type: Boolean },
-		minZoom: {},
-		maxZoom: {},
-		className: {},
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, $t),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { leafletObject: c } = l();
-		t({ leafletObject: c });
-		function l() {
-			let e = h(), t = V(D), { options: r, methods: c } = en(i, e, a);
-			return s(async () => {
-				e.value = m(i.tileLayerClass(i.url, r));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(c, e.value, i), t({
-					...i,
-					...c,
-					leafletObject: e.value
-				}), n(() => a("ready", e.value));
-			}), { leafletObject: e };
-		}
-		return (e, t) => null;
-	}
-}), nn = { ...Bt }, rn = (e, t) => {
-	let { options: n, methods: r } = Vt(e, t), i = V(Oe);
-	return a(() => {
-		i();
-	}), {
-		options: n,
-		methods: r
-	};
-}, an = /* @__PURE__ */ t({
-	name: "LTooltip",
-	__name: "LTooltip",
-	props: /* @__PURE__ */ c({
-		content: {},
-		options: {}
-	}, nn),
-	emits: ["ready"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { root: l, leafletObject: u } = d();
-		t({
-			root: l,
-			leafletObject: u
-		});
-		function d() {
-			let e = h(), t = h(), r = V(j), { options: i, methods: l } = rn(a, e);
-			return s(async () => {
-				e.value = m(new be(i)), I(l, e.value, a);
-				let { listeners: s } = R(o());
-				e.value.on(s), e.value.setContent(a.content || t.value), r(e.value), n(() => c("ready", e.value));
-			}), {
-				root: t,
-				leafletObject: e
-			};
-		}
-		return (e, t) => (S(), b("div", {
-			ref_key: "root",
-			ref: l
-		}, [r(e.$slots, "default")], 512));
-	}
-}), on = { ...Y }, sn = (e, t, n) => {
-	let { options: r, methods: i } = X(e, t, n);
-	return {
-		options: L(e, r),
-		methods: { ...i }
-	};
-}, cn = {
-	key: 0,
-	style: { display: "none" }
-}, ln = /* @__PURE__ */ t({
-	name: "LVideoOverlay",
-	__name: "LVideoOverlay",
-	props: /* @__PURE__ */ c({
-		video: {},
-		opacity: {},
-		alt: {},
-		interactive: { type: Boolean },
-		crossOrigin: { type: Boolean },
-		errorOverlayUrl: {},
-		zIndex: {},
-		className: {},
-		bounds: {},
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, on),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: i }) {
-		let a = e, c = i, { ready: l, leafletObject: u, videoRoot: d } = _();
-		t({
-			ready: l,
-			leafletObject: u
-		});
-		function _() {
-			let e = h(), t = h(!1), r = h(), i = f(() => {
-				let e = r.value?.firstElementChild;
-				return e?.tagName === "svg" ? e : void 0;
-			}), l = V(D), { options: u, methods: d } = sn(a, e, c);
-			return s(async () => {
-				if (!i.value && !a.video) {
-					console.warn("Missing video prop or slot: VideoOverlay has not been created.");
-					return;
-				}
-				e.value = m(new xe(i.value ? i.value : a.video, a.bounds, u));
-				let { listeners: r } = R(o());
-				e.value.on(r), I(d, e.value, a), l({
-					...a,
-					...d,
-					leafletObject: e.value
-				}), t.value = !0, n(() => c("ready", e.value));
-			}), {
-				ready: t,
-				leafletObject: e,
-				videoRoot: r
-			};
-		}
-		return (e, t) => (S(), b(g, null, [x(l) ? (S(), b("div", cn, [r(e.$slots, "default")])) : p("", !0), y("div", {
-			style: { display: "none" },
-			ref_key: "videoRoot",
-			ref: d
-		}, [r(e.$slots, "video")], 512)], 64));
-	}
-}), un = {
-	...$t,
-	transparent: void 0,
-	uppercase: void 0
-}, dn = (e, t, n) => {
-	let { options: r, methods: i } = en(e, t, n);
-	return {
-		options: L(e, r),
-		methods: { ...i }
-	};
-}, fn = /* @__PURE__ */ t({
-	name: "LWmsTileLayer",
-	__name: "LWmsTileLayer",
-	props: /* @__PURE__ */ c({
-		layers: {},
-		styles: {},
-		format: {},
-		transparent: { type: Boolean },
-		version: {},
-		crs: {},
-		uppercase: { type: Boolean },
-		tms: { type: Boolean },
-		subdomains: {},
-		detectRetina: { type: Boolean },
-		url: {},
-		tileLayerClass: { type: Function },
-		opacity: {},
-		zIndex: {},
-		tileSize: {},
-		noWrap: { type: Boolean },
-		minZoom: {},
-		maxZoom: {},
-		className: {},
-		pane: {},
-		attribution: {},
-		name: {},
-		layerType: {},
-		visible: { type: Boolean },
-		options: {}
-	}, un),
-	emits: ["ready", "update:visible"],
-	setup(e, { expose: t, emit: r }) {
-		let i = e, a = r, { leafletObject: c } = l();
-		t({ leafletObject: c });
-		function l() {
-			let e = h(), t = V(D), { options: r, methods: c } = dn(i, e, a);
-			return s(async () => {
-				e.value = m(new ye.WMS(i.url, r));
-				let { listeners: s } = R(o());
-				e.value.on(s), I(c, e.value, i), t({
-					...i,
-					...c,
-					leafletObject: e.value
-				}), n(() => a("ready", e.value));
-			}), { leafletObject: e };
-		}
-		return (e, t) => null;
-	}
-});
-//#endregion
-export { D as AddLayerInjection, A as BindPopupInjection, j as BindTooltipInjection, we as CanSetParentHtmlInjection, _t as CreateVueGridLayer, Se as GetMapObjectInjection, Be as LCircle, He as LCircleMarker, We as LControl, qe as LControlAttribution, Xe as LControlLayers, $e as LControlScale, nt as LControlZoom, ut as LFeatureGroup, pt as LGeoJson, vt as LGridLayer, it as LIcon, ot as LImageOverlay, bt as LLayerGroup, wt as LMap, Mt as LMarker, Lt as LPolygon, zt as LPolyline, Wt as LPopup, Jt as LRectangle, Qt as LSVGOverlay, tn as LTileLayer, an as LTooltip, ln as LVideoOverlay, fn as LWmsTileLayer, k as RegisterControlInjection, Ce as RegisterLayerControlInjection, O as RemoveLayerInjection, Ee as SetIconInjection, Te as SetParentHtmlInjection, De as UnbindPopupInjection, Oe as UnbindTooltipInjection, V as assertInject, N as bindEventHandlers, P as cancelDebounces, Ae as capitalizeFirstLetter, Fe as circleMarkerPropsDefaults, Le as circlePropsDefaults, H as componentPropsDefaults, q as controlAbstractPropsDefaults, Ge as controlAttributionPropsDefaults, Je as controlLayersPropsDefaults, Ue as controlPropsDefaults, Ze as controlScalePropsDefaults, et as controlZoomPropsDefaults, st as featureGroupPropsDefaults, dt as geoJSONPropsDefaults, mt as gridLayerAbstractPropsDefaults, ht as gridLayerPropsDefaults, rt as iconPropsDefaults, Y as imageOverlayPropsDefaults, Me as interactiveLayerPropsDefaults, F as isFunction, Z as layerGroupPropsDefaults, W as layerPropsDefaults, St as mapPropsDefaults, Dt as markerPropsDefaults, K as pathPropsDefaults, $ as polygonPropsDefaults, Nt as polylinePropsDefaults, Bt as popperPropsDefaults, Ht as popupPropsDefaults, I as propsBinder, L as propsToLeafletOptions, z as provideLeafletWrapper, Gt as rectanglePropsDefaults, R as remapEvents, je as resetWebpackIcon, ke as setVueLeafletConfig, Re as setupCircle, Ie as setupCircleMarker, U as setupComponent, J as setupControl, Ke as setupControlAttribution, Ye as setupControlLayers, Qe as setupControlScale, tt as setupControlZoom, ct as setupFeatureGroup, ft as setupGeoJSON, gt as setupGridLayer, X as setupImageOverlay, Ne as setupInteractiveLayer, G as setupLayer, Q as setupLayerGroup, Ct as setupMap, Ot as setupMarker, Pe as setupPath, Ft as setupPolygon, Pt as setupPolyline, Vt as setupPopper, Ut as setupPopup, Kt as setupRectangle, Xt as setupSVGOverlay, en as setupTileLayer, rn as setupTooltip, sn as setupVideoOverlay, dn as setupWMSTileLayer, kt as shouldBlankIcon, Yt as svgOverlayPropsDefaults, $t as tileLayerPropsDefaults, nn as tooltipPropsDefaults, B as updateLeafletWrapper, on as videoOverlayPropsDefaults, M as vueLeafletConfig, un as wmsTileLayerPropsDefaults };
-
-//# sourceMappingURL=vue-leaflet.es-BT-uRmMx.js.map