@8wave/ai-elements 0.84.0 → 0.85.0

package/dist/_chunks/PkToolShowLocation-BDVFw7qK.js

@@ -0,0 +1,1140 @@
+import { $ as e, B as t, C as n, D as r, E as i, F as a, Ht as o, I as s, Kt as c, L as l, O as u, Q as d, Z as f, _ as p, b as m, bt as h, ct as g, dt as _, et as v, h as y, ht as b, j as x, k as S, lt as C, pt as w, v as T, w as E, x as D, z as O } from "./vue.runtime.esm-bundler-B-iHWsf4.js";
+import { i as ee } from "./dist-Dplp2WfI.js";
+import { c as te, n as ne, o as re, r as ie, s as ae } from "./index.es-9_Td6lnP.js";
+import { _ as oe, g as se } from "./src-L9Jq1dyr.js";
+import { AttributionControl as k, FullscreenControl as A, GeolocateControl as ce, LngLat as j, LogoControl as le, Map as ue, Marker as de, NavigationControl as fe, Popup as pe, ScaleControl as M } from "https://cdn.jsdelivr.net/npm/maplibre-gl@5/+esm";
+//#region ../../node_modules/.pnpm/@indoorequal+vue-maplibre-gl@8.4.2_maplibre-gl@5.24.0_vue@3.5.35_typescript@6.0.3_/node_modules/@indoorequal/vue-maplibre-gl/dist/vue-maplibre-gl.es.js
+var N = Symbol("map"), P = Symbol("isLoaded"), F = Symbol("isInitialized"), I = Symbol("componentId"), L = Symbol("sourceId"), R = Symbol("sourceLayerRegistry"), z = Symbol("marker"), B = /* @__PURE__ */ "error.load.idle.remove.render.resize.webglcontextlost.webglcontextrestored.dataloading.data.tiledataloading.sourcedataloading.styledataloading.sourcedata.styledata.styleimagemissing.dataabort.sourcedataabort.boxzoomcancel.boxzoomstart.boxzoomend.touchcancel.touchmove.touchend.touchstart.click.contextmenu.dblclick.mousemove.mouseup.mousedown.mouseout.mouseover.movestart.move.moveend.zoomstart.zoom.zoomend.rotatestart.rotate.rotateend.dragstart.drag.dragend.pitchstart.pitch.pitchend.wheel.terrain.cooperativegestureprevented".split(".");
+function me(e, t, n, r) {
+	return (i) => n.emit(r, {
+		type: i.type,
+		map: t,
+		component: e,
+		event: i
+	});
+}
+function he(e, t) {
+	let n = j.convert(e), r = j.convert(t);
+	return n.lng === r.lng && n.lat === r.lat;
+}
+var V = /* @__PURE__ */ ((e) => (e.TOP_LEFT = "top-left", e.TOP_RIGHT = "top-right", e.BOTTOM_LEFT = "bottom-left", e.BOTTOM_RIGHT = "bottom-right", e))(V || {}), H = Object.values(V), U = /* @__PURE__ */ new Map(), ge = Symbol("default");
+function _e(e, t, n = ge) {
+	let r = U.get(n);
+	return r || (r = _({
+		isLoaded: !1,
+		isMounted: !1,
+		language: null
+	}), U.set(n, r)), r.isLoaded = t.value?.loaded() || !1, r.isMounted = !1, r.component = e, r.map = t.value, r;
+}
+var ve = i({
+	name: "MglMap",
+	props: {
+		width: {
+			type: [Number, String],
+			default: "100%"
+		},
+		height: {
+			type: [Number, String],
+			default: "100%"
+		},
+		attributionControl: {
+			type: [Boolean, Object],
+			default: void 0
+		},
+		bearing: { type: Number },
+		bearingSnap: { type: Number },
+		bounds: { type: [Array, Object] },
+		boxZoom: {
+			type: Boolean,
+			default: void 0
+		},
+		center: { type: [Array, Object] },
+		clickTolerance: { type: Number },
+		collectResourceTiming: {
+			type: Boolean,
+			default: void 0
+		},
+		crossSourceCollisions: {
+			type: Boolean,
+			default: void 0
+		},
+		dragPan: {
+			type: Boolean,
+			default: void 0
+		},
+		dragRotate: {
+			type: Boolean,
+			default: void 0
+		},
+		doubleClickZoom: {
+			type: Boolean,
+			default: void 0
+		},
+		hash: {
+			type: [Boolean, String],
+			default: void 0
+		},
+		fadeDuration: { type: Number },
+		fitBoundsOptions: { type: Object },
+		interactive: {
+			type: Boolean,
+			default: void 0
+		},
+		keyboard: {
+			type: Boolean,
+			default: void 0
+		},
+		locale: { type: Object },
+		localIdeographFontFamily: { type: String },
+		logoPosition: {
+			type: [String],
+			validator: (e) => e in V
+		},
+		maxBounds: { type: [Array, Object] },
+		maxPitch: { type: Number },
+		maxZoom: { type: Number },
+		minPitch: { type: Number },
+		minZoom: { type: Number },
+		pitch: { type: Number },
+		pitchWithRotate: {
+			type: Boolean,
+			default: void 0
+		},
+		canvasContextAttributes: { type: Object },
+		refreshExpiredTiles: {
+			type: Boolean,
+			default: void 0
+		},
+		renderWorldCopies: {
+			type: Boolean,
+			default: void 0
+		},
+		scrollZoom: {
+			type: Boolean,
+			default: void 0
+		},
+		mapStyle: { type: [String, Object] },
+		trackResize: {
+			type: Boolean,
+			default: void 0
+		},
+		transformRequest: { type: Function },
+		transformCameraUpdate: { type: Function },
+		touchZoomRotate: {
+			type: Boolean,
+			default: void 0
+		},
+		touchPitch: {
+			type: Boolean,
+			default: void 0
+		},
+		zoom: { type: Number },
+		maxTileCacheSize: { type: Number },
+		mapKey: { type: [String, Symbol] },
+		pixelRatio: { type: Number },
+		validateStyle: {
+			type: Boolean,
+			default: void 0
+		},
+		cooperativeGestures: { type: Boolean }
+	},
+	emits: /* @__PURE__ */ "map:error.map:load.map:idle.map:remove.map:render.map:resize.map:webglcontextlost.map:webglcontextrestored.map:dataloading.map:data.map:tiledataloading.map:sourcedataloading.map:styledataloading.map:sourcedata.map:styledata.map:styleimagemissing.map:dataabort.map:sourcedataabort.map:boxzoomcancel.map:boxzoomstart.map:boxzoomend.map:touchcancel.map:touchmove.map:touchend.map:touchstart.map:click.map:contextmenu.map:dblclick.map:mousemove.map:mouseup.map:mousedown.map:mouseout.map:mouseover.map:movestart.map:move.map:moveend.map:zoomstart.map:zoom.map:zoomend.map:rotatestart.map:rotate.map:rotateend.map:dragstart.map:drag.map:dragend.map:pitchstart.map:pitch.map:pitchend.map:wheel.map:terrain.map:cooperativegestureprevented.map:projectiontransition.update:center.update:zoom.update:pitch.update:bearing".split("."),
+	slots: Object,
+	setup(e, n) {
+		let i = C(r()), o = b(), c = b(), u = w(!1), f = w(!1), p = /* @__PURE__ */ new Map(), m = _e(i, c, e.mapKey);
+		t(N, c), t(P, f), t(F, u), t(I, i.uid), t(L, ""), d(() => e.bearing, (e) => {
+			e && c.value?.setBearing(e);
+		}), d(() => e.bounds, (t) => {
+			t && c.value?.fitBounds(t, e.fitBoundsOptions);
+		}), d(() => e.center, (e) => {
+			let t = c.value?.getCenter();
+			e && t && !he(e, t) && c.value?.setCenter(e);
+		}), d(() => e.maxBounds, (e) => {
+			e && c.value?.setMaxBounds(e);
+		}), d(() => e.maxPitch, (e) => {
+			e && c.value?.setMaxPitch(e);
+		}), d(() => e.maxZoom, (e) => {
+			e && c.value?.setMaxZoom(e);
+		}), d(() => e.minPitch, (e) => {
+			e && c.value?.setMinPitch(e);
+		}), d(() => e.minZoom, (e) => {
+			e && c.value?.setMinZoom(e);
+		}), d(() => e.pitch, (e) => {
+			e && c.value?.setPitch(e);
+		}), d(() => e.renderWorldCopies, (e) => {
+			e && c.value?.setRenderWorldCopies(e);
+		}), d(() => e.mapStyle, (e) => {
+			e && c.value?.setStyle(e);
+		}), d(() => e.transformRequest, (e) => {
+			e && c.value?.setTransformRequest(e);
+		}), d(() => e.zoom, (e) => {
+			e && c.value?.setZoom(e);
+		}), d(() => e.zoom, (e) => {
+			e && c.value?.setZoom(e);
+		});
+		function h() {
+			m.isMounted = !0;
+			let t = {
+				...e,
+				style: e.mapStyle,
+				container: o.value
+			};
+			for (let e of Object.keys(t)) t[e] === void 0 && delete t[e];
+			if (c.value = C(new ue(t)), m.map = c.value, u.value = !0, p.set("__load", () => (f.value = !0, m.isLoaded = !0)), c.value.on("load", p.get("__load")), p.set("__moveend", () => n.emit("update:center", c.value.getCenter())), c.value.on("moveend", p.get("__moveend")), p.set("__zoomend", () => n.emit("update:zoom", c.value.getZoom())), c.value.on("zoomend", p.get("__zoomend")), p.set("__pitchend", () => n.emit("update:pitch", c.value.getPitch())), c.value.on("pitchend", p.get("__pitchend")), p.set("__rotateend", () => n.emit("update:bearing", c.value.getBearing())), c.value.on("rotateend", p.get("__rotateend")), i.vnode.props) {
+				for (let e of B) if (i.vnode.props["onMap:" + e]) {
+					let t = `map:${e}`, r = me(i, c.value, n, t);
+					p.set(e, r), c.value.on(e, r);
+				}
+			}
+			c.value.getCanvas().addEventListener("webglcontextlost", _);
+		}
+		async function g() {
+			m.isMounted = !1, m.isLoaded = !1, f.value = !1, c.value && (c.value.getCanvas().removeEventListener("webglcontextlost", _), u.value = !1, p.forEach((e, t) => {
+				c.value.off(t.startsWith("__") ? t.substring(2) : t, e);
+			}), c.value.remove());
+		}
+		function _() {
+			g(), a(h);
+		}
+		return l(h), s(g), n.expose({ map: c }), () => [S("div", {
+			ref: o,
+			style: {
+				height: e.height,
+				width: e.width
+			}
+		}), u.value && n.slots.default ? n.slots.default({}) : void 0];
+	},
+	render() {
+		return null;
+	}
+});
+function ye(e, t, n) {
+	d(e, (e) => {
+		e && H.indexOf(e) === -1 || (t.value?.hasControl(n) && t.value.removeControl(n), t.value?.addControl(n, e));
+	}, { immediate: !0 });
+}
+function W(e, t) {
+	let n = x(N), r = x(F), i = b();
+	return i.value = e(), ye(() => t.position, n, i.value), s(() => r.value && n.value?.removeControl(i.value)), {
+		control: i,
+		map: n
+	};
+}
+i({
+	name: "MglAttributionControl",
+	props: {
+		position: {
+			type: String,
+			validator: (e) => H.indexOf(e) !== -1
+		},
+		compact: Boolean,
+		customAttribution: [String, Array]
+	},
+	setup(e) {
+		W(() => new k({
+			compact: e.compact,
+			customAttribution: e.customAttribution
+		}), e);
+	},
+	render() {
+		return null;
+	}
+});
+var be = class {
+	constructor(e, t) {
+		this.isAdded = e, this.container = document.createElement("div"), this.setClasses(t);
+	}
+	container;
+	getDefaultPosition() {
+		return V.TOP_LEFT;
+	}
+	onAdd() {
+		return a(() => this.isAdded.value = !0), this.container;
+	}
+	onRemove() {
+		this.isAdded.value = !1, this.container.remove();
+	}
+	setClasses(e) {
+		this.container.className = e;
+	}
+};
+i({
+	name: "MglCustomControl",
+	props: {
+		position: {
+			type: String,
+			validator: (e) => H.indexOf(e) !== -1
+		},
+		class: {
+			type: String,
+			default: "maplibregl-ctrl maplibregl-ctrl-group"
+		}
+	},
+	slots: Object,
+	setup(e, { slots: t }) {
+		let n = w(!1), { control: r } = W(() => new be(n, e.class), e);
+		return d(() => e.class, () => r.value.setClasses(e.class)), () => n.value ? S(y, { to: r.value.container }, t.default?.({})) : m("custom-component");
+	},
+	render() {
+		return null;
+	}
+}), i({
+	name: "MglFullscreenControl",
+	props: {
+		position: {
+			type: String,
+			validator: (e) => H.indexOf(e) !== -1
+		},
+		container: {
+			type: Object,
+			default: null
+		}
+	},
+	setup(e) {
+		let { control: t, map: n } = W(() => new A({ container: e.container || void 0 }), e);
+		function r() {
+			a(() => n.value?.resize());
+		}
+		t.value.on("fullscreenstart", r), t.value.on("fullscreenend", r), s(() => {
+			t.value.off("fullscreenstart", r), t.value.off("fullscreenend", r);
+		});
+	},
+	render() {
+		return null;
+	}
+});
+var xe = i({
+	name: "MglGeolocateControl",
+	props: {
+		position: {
+			type: String,
+			default: V.TOP_RIGHT,
+			validator: (e) => H.indexOf(e) !== -1
+		},
+		positionOptions: {
+			type: Object,
+			default: () => ({
+				enableHighAccuracy: !1,
+				timeout: 6e3
+			})
+		},
+		fitBoundsOptions: {
+			type: Object,
+			default: () => ({ maxZoom: 15 })
+		},
+		trackUserLocation: {
+			type: Boolean,
+			default: !1
+		},
+		showAccuracyCircle: {
+			type: Boolean,
+			default: !0
+		},
+		showUserLocation: {
+			type: Boolean,
+			default: !0
+		}
+	},
+	emits: [
+		"trackuserlocationstart",
+		"trackuserlocationend",
+		"userlocationlostfocus",
+		"userlocationfocus",
+		"geolocate",
+		"error",
+		"outofmaxbounds"
+	],
+	setup(e, t) {
+		let { control: n } = W(() => new ce({
+			positionOptions: e.positionOptions,
+			fitBoundsOptions: e.fitBoundsOptions,
+			trackUserLocation: e.trackUserLocation,
+			showAccuracyCircle: e.showAccuracyCircle,
+			showUserLocation: e.showUserLocation
+		}), e);
+		function r(e) {
+			let r = (n) => {
+				t.emit(e, n);
+			};
+			n.value.on(e, r), s(() => {
+				n.value.off(e, r);
+			});
+		}
+		r("trackuserlocationstart"), r("trackuserlocationend"), r("userlocationlostfocus"), r("userlocationfocus"), r("geolocate"), r("error"), r("outofmaxbounds");
+	},
+	render() {
+		return null;
+	}
+}), Se = i({
+	name: "MglNavigationControl",
+	props: {
+		position: {
+			type: String,
+			validator: (e) => H.indexOf(e) !== -1
+		},
+		showCompass: {
+			type: Boolean,
+			default: !0
+		},
+		showZoom: {
+			type: Boolean,
+			default: !0
+		},
+		visualizePitch: Boolean
+	},
+	setup(e) {
+		W(() => new fe({
+			showCompass: e.showCompass,
+			showZoom: e.showZoom,
+			visualizePitch: e.visualizePitch
+		}), e);
+	},
+	render() {
+		return null;
+	}
+}), G = /* @__PURE__ */ ((e) => (e.IMPERIAL = "imperial", e.METRIC = "metric", e.NAUTICAL = "nautical", e))(G || {}), Ce = Object.values(G), we = i({
+	name: "MglScaleControl",
+	props: {
+		position: {
+			type: String,
+			validator: (e) => H.indexOf(e) !== -1
+		},
+		maxWidth: {
+			type: Number,
+			default: 100
+		},
+		unit: {
+			type: String,
+			default: "metric",
+			validator: (e) => Ce.indexOf(e) !== -1
+		}
+	},
+	setup(e) {
+		W(() => new M({
+			maxWidth: e.maxWidth,
+			unit: e.unit
+		}), e);
+	},
+	render() {
+		return null;
+	}
+});
+i({
+	name: "MglLogoControl",
+	props: {
+		position: {
+			type: String,
+			validator: (e) => H.indexOf(e) !== -1
+		},
+		compact: { type: Boolean }
+	},
+	setup(e) {
+		W(() => new le({ compact: e.compact }), e);
+	},
+	render() {
+		return null;
+	}
+});
+var Te = i({
+	name: "MglMarker",
+	emits: [
+		"dragstart",
+		"drag",
+		"dragend",
+		"update:coordinates"
+	],
+	props: {
+		coordinates: {
+			type: [Object, Array],
+			required: !0
+		},
+		className: String,
+		offset: [Object, Array],
+		anchor: String,
+		color: String,
+		draggable: Boolean,
+		clickTolerance: Number,
+		rotation: Number,
+		rotationAlignment: String,
+		pitchAlignment: String,
+		scale: Number,
+		opacity: String,
+		opacityWhenCovered: String,
+		subpixelPositioning: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	setup(e, { slots: n, emit: r }) {
+		let i = x(N), a = b(), o = w(), c = w(!1), u = /* @__PURE__ */ new Map();
+		function f(e, t) {
+			let n = (n) => {
+				t && t(), r(e, n);
+			};
+			a.value.on(e, n), u.set(e, n);
+		}
+		return t(z, a), l(() => {
+			let t = { ...e };
+			n.marker && (t.element = o.value), a.value = new de(t), a.value.setLngLat(e.coordinates).addTo(i.value), f("dragstart"), f("drag", () => {
+				r("update:coordinates", a.value?.getLngLat());
+			}), f("dragend", () => {
+				r("update:coordinates", a.value?.getLngLat());
+			}), c.value = !0;
+		}), d(() => e.coordinates, (e) => a.value?.setLngLat(e), { deep: !0 }), d(() => e.draggable, (e) => a.value?.setDraggable(e)), d(() => e.offset, (e) => a.value?.setOffset(e || [0, 0])), d(() => e.pitchAlignment, (e) => a.value?.setPitchAlignment(e || "auto")), d(() => e.rotation, (e) => a.value?.setRotation(e)), d(() => e.rotationAlignment, (e) => a.value?.setRotationAlignment(e || "auto")), d(() => e.opacity, (t) => a.value?.setOpacity(t, e.opacityWhenCovered)), d(() => e.opacityWhenCovered, (t) => a.value?.setOpacity(e.opacity, t)), d(() => e.subpixelPositioning, (e) => a.value?.setSubpixelPositioning(e)), d(() => e.className, (e, t) => {
+			t && a.value?.removeClassName(t), e && a.value?.addClassName(e);
+		}), s(() => {
+			u.forEach((e, t) => {
+				a.value?.off(t, e);
+			}), a.value?.remove();
+		}), () => [S("div", n.default && c.value ? n.default({}) : void 0), S("div", { ref: o }, n.marker ? n.marker() : void 0)];
+	},
+	render() {
+		return null;
+	}
+}), Ee = i({
+	name: "MglPopup",
+	emits: ["open", "close"],
+	props: {
+		coordinates: {
+			type: [Object, Array],
+			required: !1
+		},
+		closeButton: {
+			type: Boolean,
+			required: !1,
+			default: !0
+		},
+		closeOnClick: {
+			type: Boolean,
+			required: !1,
+			default: !0
+		},
+		closeOnMove: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		focusAfterOpen: {
+			type: Boolean,
+			required: !1,
+			default: !0
+		},
+		anchor: {
+			type: String,
+			required: !1
+		},
+		offset: {
+			type: [
+				Number,
+				Object,
+				Array
+			],
+			required: !1
+		},
+		className: {
+			type: String,
+			required: !1
+		},
+		maxWidth: {
+			type: String,
+			default: "240px"
+		},
+		subpixelPositioning: {
+			type: Boolean,
+			default: !1
+		},
+		text: {
+			type: String,
+			required: !1
+		}
+	},
+	setup(e, { slots: t, emit: n, expose: r }) {
+		let i = x(N), a = x(z, void 0), o = w(), c = new pe(e);
+		a && a.value ? a.value.setPopup(c) : e.coordinates && i && c.setLngLat(e.coordinates).addTo(i.value), e.text && c.setText(e.text);
+		function u(e) {
+			let t = () => n(e);
+			c.on(e, t), s(() => {
+				c.off(e, t);
+			});
+		}
+		return u("open"), u("close"), r({ remove() {
+			c.remove();
+		} }), d(() => e.coordinates, (e) => {
+			e && c.setLngLat(e);
+		}, { deep: !0 }), d(() => e.text, (e) => c.setText(e || "")), d(() => e.offset, (e) => c.setOffset(e)), d(() => e.maxWidth, (e) => c.setMaxWidth(e)), d(() => e.className, (e, t) => {
+			t && c.removeClassName(t), e && c.addClassName(e);
+		}), d(() => e.subpixelPositioning, (e) => c.setSubpixelPositioning(e)), l(() => {
+			o.value && !e.text && c.setDOMContent(o.value);
+		}), s(() => {
+			c.remove();
+		}), () => [S("div", { ref: o }, t.default ? t.default() : void 0)];
+	},
+	render() {
+		return null;
+	}
+});
+i({
+	name: "MglImage",
+	props: {
+		id: {
+			type: String,
+			required: !0
+		},
+		image: Object,
+		url: String,
+		options: Object
+	},
+	setup(e) {
+		let t = x(N);
+		if (!e.url && !e.image) return f(`${e.id} image: missing prop url or image`), () => [];
+		if (!t.value.hasImage(e.id)) return (async () => {
+			let n = e.image;
+			e.url && (n = (await t.value.loadImage(e.url)).data), t.value.addImage(e.id, n, e.options);
+		})(), () => [];
+	}
+});
+var K = class {
+	unmountHandlers = /* @__PURE__ */ new Map();
+	registerUnmountHandler(e, t) {
+		this.unmountHandlers.set(e, t);
+	}
+	unregisterUnmountHandler(e) {
+		this.unmountHandlers.delete(e);
+	}
+	unmount() {
+		this.unmountHandlers.forEach((e) => e());
+	}
+}, q = class e {
+	static REFS = /* @__PURE__ */ new Map();
+	static genSourceOpts(e) {
+		let t = { ...e };
+		for (let e of Object.keys(t)) (t[e] === void 0 || e === "sourceId") && delete t[e];
+		return t;
+	}
+	static getSourceRef(t, n) {
+		let r = typeof n == "string", i = String(t) + (r ? n : ""), a = e.REFS.get(i);
+		return a || (a = w(r ? null : void 0), e.REFS.set(i, a)), a;
+	}
+};
+function J(e, t, n) {
+	let r = x(N), i = x(P);
+	function a() {
+		i.value && (r.value.addSource(t.sourceId, q.genSourceOpts(t)), e.value = r.value.getSource(t.sourceId));
+	}
+	return d(i, a, { immediate: !0 }), r.value.on("style.load", a), s(() => {
+		i.value && (n.unmount(), r.value.removeSource(t.sourceId)), r.value.off("style.load", a);
+	});
+}
+i({
+	name: "MglCanvasSource",
+	props: {
+		sourceId: {
+			type: String,
+			required: !0
+		},
+		coordinates: Array,
+		animate: Boolean,
+		canvas: [Object, String]
+	},
+	slots: Object,
+	setup(e, { slots: n }) {
+		let r = x(I), i = q.getSourceRef(r, e.sourceId), a = new K(), o = {
+			...e,
+			type: "canvas"
+		};
+		return t(L, e.sourceId), t(R, a), J(i, o, a), d([g(e.coordinates) ? e.coordinates : () => e.coordinates, i], ([e, t]) => {
+			t?.setCoordinates(e);
+		}, { immediate: !0 }), () => [m("Canvas Source"), i.value && n.default ? n.default({}) : void 0];
+	}
+}), i({
+	name: "MglGeoJsonSource",
+	props: {
+		sourceId: {
+			type: String,
+			required: !0
+		},
+		data: {
+			type: [Object, String],
+			required: !0
+		},
+		maxzoom: Number,
+		attribution: String,
+		buffer: Number,
+		tolerance: Number,
+		cluster: Boolean,
+		clusterRadius: Number,
+		clusterMaxZoom: Number,
+		clusterMinPoints: Number,
+		clusterProperties: Object,
+		lineMetrics: Boolean,
+		generateId: Boolean,
+		promoteId: [Object, String],
+		filter: [
+			Array,
+			String,
+			Object
+		]
+	},
+	slots: Object,
+	setup(e, { slots: n }) {
+		let r = x(I), i = q.getSourceRef(r, e.sourceId), a = new K(), o = {
+			...e,
+			type: "geojson"
+		};
+		return t(L, e.sourceId), t(R, a), J(i, o, a), d([g(e.data) ? e.data : () => e.data, i], ([e, t]) => {
+			t?.setData(e || {
+				type: "FeatureCollection",
+				features: []
+			});
+		}, { immediate: !0 }), () => [m("GeoJSON Source"), i.value && n.default ? n.default({}) : void 0];
+	}
+}), i({
+	name: "MglImageSource",
+	props: {
+		sourceId: {
+			type: String,
+			required: !0
+		},
+		url: String,
+		coordinates: Array
+	},
+	slots: Object,
+	setup(e, { slots: n }) {
+		let r = x(I), i = q.getSourceRef(r, e.sourceId), a = new K(), o = {
+			...e,
+			type: "image"
+		};
+		return t(L, e.sourceId), t(R, a), J(i, o, a), d([g(e.coordinates) ? e.coordinates : () => e.coordinates, i], ([e, t]) => {
+			t?.setCoordinates(e);
+		}, { immediate: !0 }), () => [m("Image Source"), i.value && n.default ? n.default({}) : void 0];
+	}
+}), i({
+	name: "MglRasterSource",
+	props: {
+		sourceId: {
+			type: String,
+			required: !0
+		},
+		url: String,
+		tiles: Array,
+		bounds: Array,
+		minzoom: Number,
+		maxzoom: Number,
+		tileSize: Number,
+		scheme: String,
+		attribution: String,
+		volatile: Boolean
+	},
+	slots: Object,
+	setup(e, { slots: n }) {
+		let r = x(I), i = q.getSourceRef(r, e.sourceId), a = new K(), o = {
+			...e,
+			type: "raster"
+		};
+		return t(L, e.sourceId), t(R, a), J(i, o, a), () => [m("Raster Source"), i.value && n.default ? n.default({}) : void 0];
+	}
+}), i({
+	name: "MglRasterDemSource",
+	props: {
+		sourceId: {
+			type: String,
+			required: !0
+		},
+		url: String,
+		tiles: Array,
+		bounds: Array,
+		minzoom: Number,
+		maxzoom: Number,
+		tileSize: Number,
+		attribution: String,
+		encoding: String,
+		volatile: Boolean,
+		redFactor: Number,
+		blueFactor: Number,
+		greenFactor: Number,
+		baseShift: Number
+	},
+	slots: Object,
+	setup(e, { slots: n }) {
+		let r = x(I), i = q.getSourceRef(r, e.sourceId), a = new K(), o = {
+			...e,
+			type: "raster-dem"
+		};
+		return t(L, e.sourceId), t(R, a), J(i, o, a), () => [m("RasterDem Source"), i.value && n.default ? n.default({}) : void 0];
+	}
+}), i({
+	name: "MglVectorSource",
+	props: {
+		sourceId: {
+			type: String,
+			required: !0
+		},
+		url: String,
+		tiles: Array,
+		bounds: {
+			type: Array,
+			validator: function(e) {
+				return e.length === 4;
+			}
+		},
+		scheme: String,
+		minzoom: Number,
+		maxzoom: Number,
+		attribution: String,
+		promoteId: [Object, String],
+		volatile: Boolean
+	},
+	slots: Object,
+	setup(e, { slots: n }) {
+		let r = x(I), i = q.getSourceRef(r, e.sourceId), a = new K(), o = {
+			...e,
+			type: "vector"
+		};
+		return t(L, e.sourceId), t(R, a), J(i, o, a), d([g(e.tiles) ? e.tiles : () => e.tiles, i], ([e, t]) => {
+			t?.setTiles(e || []);
+		}, { immediate: !0 }), d([g(e.url) ? e.url : () => e.url, i], ([e, t]) => {
+			t?.setUrl(e || "");
+		}, { immediate: !0 }), () => [m("Vector Source"), i.value && n.default ? n.default({}) : void 0];
+	}
+}), i({
+	name: "MglVideoSource",
+	props: {
+		sourceId: {
+			type: String,
+			required: !0
+		},
+		urls: Array,
+		coordinates: Array
+	},
+	slots: Object,
+	setup(e, { slots: n }) {
+		let r = x(I), i = q.getSourceRef(r, e.sourceId), a = new K(), o = {
+			...e,
+			type: "video"
+		};
+		return t(L, e.sourceId), t(R, a), J(i, o, a), d([g(e.coordinates) ? e.coordinates : () => e.coordinates, i], ([e, t]) => {
+			t?.setCoordinates(e);
+		}, { immediate: !0 }), () => [m("Video Source"), i.value && n.default ? n.default({}) : void 0];
+	}
+});
+var Y = [
+	"click",
+	"dblclick",
+	"mousedown",
+	"mouseup",
+	"mousemove",
+	"mouseenter",
+	"mouseleave",
+	"mouseover",
+	"mouseout",
+	"contextmenu",
+	"touchstart",
+	"touchend",
+	"touchcancel"
+];
+function X() {
+	return {
+		layerId: {
+			type: String,
+			required: !0
+		},
+		source: { type: String },
+		metadata: { type: [
+			Object,
+			Array,
+			String,
+			Number
+		] },
+		sourceLayer: { type: String },
+		minzoom: { type: Number },
+		maxzoom: { type: Number },
+		filter: { type: Object },
+		before: { type: String },
+		layout: { type: Object },
+		paint: { type: Object }
+	};
+}
+function De(e, t, n, r) {
+	let i = {
+		id: e,
+		type: t,
+		source: n.source || r,
+		metadata: n.metadata,
+		minzoom: n.minzoom,
+		maxzoom: n.maxzoom,
+		"source-layer": n.sourceLayer,
+		filter: n.filter,
+		paint: n.paint,
+		layout: n.layout
+	};
+	for (let e of Object.keys(i)) i[e] === void 0 && delete i[e];
+	return i;
+}
+function Oe(e, t, n) {
+	if (n.props) for (let r of Y) {
+		let i = "on" + r.charAt(0).toUpperCase() + r.substr(1);
+		n.props[i] && e.on(r, t, n.props[i]);
+	}
+}
+function ke(e, t, n) {
+	if (n.props) for (let r of Y) {
+		let i = "on" + r.charAt(0).toUpperCase() + r.substr(1);
+		n.props[i] && e.off(r, t, n.props[i]);
+	}
+}
+function Z(e, t) {
+	let n = x(N), r = x(P), i = x(R);
+	function a() {
+		r.value && (t && ke(n.value, e, t.vnode), n.value.getLayer(e) && n.value.removeLayer(e));
+	}
+	i.registerUnmountHandler(e, a), s(() => {
+		i.unregisterUnmountHandler(e), a();
+	});
+}
+i({
+	name: "MglBackgroundLayer",
+	props: {
+		layerId: {
+			type: String,
+			required: !0
+		},
+		metadata: [
+			Object,
+			Array,
+			String,
+			Number
+		],
+		minzoom: Number,
+		maxzoom: Number,
+		before: String,
+		layout: Object,
+		paint: Object
+	},
+	emits: [...Y],
+	setup(e) {
+		let t = x(N), n = x(P);
+		return Z(e.layerId), d(() => e.layout, (n) => {
+			if (n) for (let [r, i] of Object.entries(n)) t.value.setLayoutProperty(e.layerId, r, i);
+		}), d(() => e.paint, (n) => {
+			if (n) for (let [r, i] of Object.entries(n)) t.value.setPaintProperty(e.layerId, r, i);
+		}), d(n, (n) => {
+			n && t.value.addLayer({
+				id: e.layerId,
+				type: "background",
+				metadata: e.metadata,
+				minzoom: e.minzoom,
+				maxzoom: e.maxzoom,
+				layout: e.layout,
+				paint: e.paint
+			}, e.before || void 0);
+		}, { immediate: !0 }), () => m("Background Layer");
+	}
+});
+function Q(e, t) {
+	let n = x(L);
+	if (!n && !t.source) {
+		f(`${e} Layer: layer must be used inside source tag or source prop must be set`);
+		return;
+	}
+	let i = r(), a = x(N), o = x(P), s = x(I), c = q.getSourceRef(s, t.source || n);
+	return Z(t.layerId, i), d(() => t.minzoom, () => a.value.setLayerZoomRange(t.layerId, t.minzoom || 0, t.maxzoom || 24)), d(() => t.maxzoom, () => a.value.setLayerZoomRange(t.layerId, t.minzoom || 0, t.maxzoom || 24)), d(() => t.layout, (e) => {
+		if (e) for (let [n, r] of Object.entries(e)) a.value.setLayoutProperty(t.layerId, n, r);
+	}, { deep: !0 }), d(() => t.paint, (e) => {
+		if (e) for (let [n, r] of Object.entries(e)) a.value.setPaintProperty(t.layerId, n, r);
+	}, { deep: !0 }), d(() => t.filter, (e) => a.value.setFilter(t.layerId, e), { deep: !0 }), d([o, c], ([r, o]) => {
+		r && (o || o === void 0) && (a.value.addLayer(De(t.layerId, e, t, n), t.before || void 0), Oe(a.value, t.layerId, i.vnode));
+	}, { immediate: !0 }), () => m(`${e} Layer`);
+}
+i({
+	name: "MglCircleLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("circle", e);
+	}
+}), i({
+	name: "MglFillLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("fill", e);
+	}
+}), i({
+	name: "MglFillExtrusionLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("fill-extrusion", e);
+	}
+}), i({
+	name: "MglHeatmapLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("heatmap", e);
+	}
+}), i({
+	name: "MglHillshadeLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("hillshade", e);
+	}
+}), i({
+	name: "MglLineLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("line", e);
+	}
+}), i({
+	name: "MglRasterLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("raster", e);
+	}
+}), i({
+	name: "MglSymbolLayer",
+	props: X(),
+	emits: [...Y],
+	setup(e) {
+		return Q("symbol", e);
+	}
+});
+var Ae = {
+	key: 0,
+	class: "border border-surface-3 rounded-xl w-full overflow-hidden"
+}, je = { class: "px-sm py-6 bg-surface-1 text-12 border-b border-surface-3 text-word-3 flex items-center gap-8" }, Me = { class: "font-bold" }, $ = {
+	key: 0,
+	class: "h-224 border-b border-surface-3"
+}, Ne = { class: "flex flex-col leading-normal text-12 pr-12" }, Pe = { class: "font-semibold" }, Fe = {
+	key: 0,
+	class: "text-word-3"
+}, Ie = { class: "p-sm flex flex-col gap-4" }, Le = { class: "font-semibold text-word-1 text-14" }, Re = { class: "text-12 text-word-3" }, ze = {
+	key: 0,
+	class: "text-12 text-word-4"
+}, Be = /* @__PURE__ */ i({
+	__name: "PkToolShowLocation",
+	props: {
+		part: { type: null },
+		isDark: { type: Boolean },
+		mainColor: { type: String },
+		forwardGeocode: { type: Function }
+	},
+	setup(t) {
+		let i = t, { copy: a, copied: s } = ee(), d = p(() => i.part), f = w(null), g = {
+			light: "https://basemaps.cartocdn.com/gl/positron-gl-style/style.json",
+			dark: "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json"
+		};
+		l(() => {
+			oe("https://cdn.jsdelivr.net/npm/maplibre-gl@5/dist/maplibre-gl.css", se(r()?.proxy?.$el));
+		});
+		let _ = p(() => i.isDark ? g.dark : g.light);
+		e(async () => {
+			let e = d.value.input;
+			if (!(!e || e.latitude != null || !e.address) && i.forwardGeocode) try {
+				let t = await i.forwardGeocode(e.address);
+				t && (f.value = [t.longitude, t.latitude]);
+			} catch {}
+		});
+		let y = p(() => d.value.input?.latitude != null && d.value.input?.longitude != null || f.value != null), b = p(() => d.value.input?.latitude != null && d.value.input?.longitude != null ? [d.value.input.longitude, d.value.input.latitude] : f.value ?? [0, 0]), x = () => y.value ? `${b.value[1]},${b.value[0]}` : d.value.input?.address ?? "", S = () => {
+			d.value.input && window.open(`https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(x())}`, "_blank");
+		}, C = () => {
+			d.value.input && window.open(`https://maps.apple.com/?daddr=${encodeURIComponent(x())}`, "_blank");
+		}, k = () => {
+			let e = d.value.input;
+			e && (y.value ? window.open(`https://waze.com/ul?ll=${b.value[1]},${b.value[0]}&navigate=yes`, "_blank") : window.open(`https://waze.com/ul?q=${encodeURIComponent(e.address)}&navigate=yes`, "_blank"));
+		}, A = () => {
+			let e = d.value.input;
+			e && a(`${e.name}\n${e.address}`);
+		};
+		return (e, r) => {
+			let i = re, a = te, l = ie, f = ae, p = ne;
+			return d.value?.input ? (O(), D("div", Ae, [
+				T("div", je, [
+					E(i, {
+						name: "ri:map-pin-line",
+						class: "text-16"
+					}),
+					T("strong", Me, c(e.$t("label.location")), 1),
+					E(p, {
+						modifiers: "compact",
+						class: "ml-auto shrink-0"
+					}, {
+						default: v(() => [E(a, {
+							modifiers: "action-quiet-small",
+							icon: h(s) ? "ri:check-line" : "ri:file-copy-line",
+							label: h(s) ? e.$t("action.copied") : e.$t("action.copy"),
+							onClick: A
+						}, null, 8, ["icon", "label"]), E(f, o(u({
+							placement: "bottom-end",
+							modifiers: "menu",
+							flip: !0,
+							offset: 3,
+							strategy: "fixed"
+						})), {
+							items: v(() => [
+								E(l, { onClick: S }, {
+									default: v(() => [E(i, { name: "ri:map-2-line" }), r[0] ||= n(" Google Maps ", -1)]),
+									_: 1
+								}),
+								E(l, { onClick: C }, {
+									default: v(() => [E(i, { name: "ri:map-line" }), r[1] ||= n(" Apple Maps ", -1)]),
+									_: 1
+								}),
+								E(l, { onClick: k }, {
+									default: v(() => [E(i, { name: "ri:navigation-line" }), r[2] ||= n(" Waze ", -1)]),
+									_: 1
+								})
+							]),
+							default: v(() => [E(a, {
+								icon: "ri:direction-line",
+								modifiers: "action-quiet-small",
+								label: e.$t("action.getDirections")
+							}, null, 8, ["label"])]),
+							_: 1
+						}, 16)]),
+						_: 1
+					})
+				]),
+				y.value ? (O(), D("div", $, [E(h(ve), {
+					"map-style": _.value,
+					zoom: 12,
+					center: b.value,
+					"scroll-zoom": !1,
+					"attribution-control": !1
+				}, {
+					default: v(() => [
+						E(h(Se), {
+							position: "top-right",
+							"show-compass": !1
+						}),
+						E(h(xe), { position: "top-right" }),
+						E(h(we), { position: "bottom-left" }),
+						E(h(Te), {
+							coordinates: b.value,
+							color: t.mainColor
+						}, {
+							default: v(() => [E(h(Ee), { "close-button": !1 }, {
+								default: v(() => [T("div", Ne, [T("p", Pe, c(d.value.input.name), 1), d.value.input.address ? (O(), D("p", Fe, c(d.value.input.address), 1)) : m("", !0)])]),
+								_: 1
+							})]),
+							_: 1
+						}, 8, ["coordinates", "color"])
+					]),
+					_: 1
+				}, 8, ["map-style", "center"])])) : m("", !0),
+				T("div", Ie, [
+					T("p", Le, c(d.value.input.name), 1),
+					T("p", Re, c(d.value.input.address), 1),
+					d.value.input.additionalInfo ? (O(), D("p", ze, c(d.value.input.additionalInfo), 1)) : m("", !0)
+				])
+			])) : m("", !0);
+		};
+	}
+});
+//#endregion
+export { Be as default };
+
+//# sourceMappingURL=PkToolShowLocation-BDVFw7qK.js.map