@edugis-org/webmapx 0.1.0

package/dist-lib/maplibre-adapter-TFc3e0G9.js

@@ -0,0 +1,1190 @@
+import { t as e } from "./wms-url-builder-DIJLQ1v2.js";
+import { t } from "./wms-feature-info-C0RVMEQC.js";
+import { a as n, i as r, n as i, o as a, t as o } from "./deferred-query-service-BJDcngw6.js";
+import * as s from "maplibre-gl";
+//#region src/map/maplibre-services/MapCoreService.ts
+function c(e) {
+	return "sourceId" in e;
+}
+var l = class e {
+	constructor(e, t) {
+		this.store = e, this.eventBus = t, this.mapInstance = null, this.mapReadyCallbacks = [], this.lastContainerId = null, this.lastInitOptions = void 0, this.silentSourceIds = /* @__PURE__ */ new Set(), this.geoJSONData = /* @__PURE__ */ new Map(), this.initialConfig = {
+			center: [10.45, 51.17],
+			zoom: 4,
+			pitch: 0,
+			bearing: 0,
+			style: {
+				version: 8,
+				sources: {},
+				layers: []
+			}
+		};
+	}
+	getViewportState() {
+		return this.mapInstance ? {
+			center: this.mapInstance.getCenter().toArray(),
+			zoom: this.mapInstance.getZoom(),
+			bearing: this.mapInstance.getBearing(),
+			pitch: this.mapInstance.getPitch()
+		} : {
+			center: [0, 0],
+			zoom: 1,
+			bearing: 0,
+			pitch: 0
+		};
+	}
+	setViewport(e, t) {
+		this.mapInstance && this.mapInstance.flyTo({
+			center: e,
+			zoom: t
+		});
+	}
+	initialize(e, t) {
+		console.log(`[CORE SERVICE] Initializing MapLibre instance in #${e}`), this.lastContainerId = e, this.lastInitOptions = t;
+		let n = t?.center ?? this.initialConfig.center, r = t?.zoom ?? this.initialConfig.zoom, i = this.resolveContainer(e), a = t?.projection ? { projection: { type: t.projection } } : {}, o;
+		o = t?.style ? {
+			version: 8,
+			sources: t.style.sources || {},
+			layers: t.style.layers || [],
+			...t.style.glyphs && { glyphs: t.style.glyphs },
+			...t.style.sprite && { sprite: t.style.sprite },
+			...t.style.name && { name: t.style.name },
+			...a
+		} : t?.styleUrl ? t.styleUrl : {
+			...this.initialConfig.style,
+			...a
+		}, this.mapInstance = new s.Map({
+			container: i,
+			center: n,
+			zoom: r,
+			minZoom: t?.minZoom,
+			maxZoom: t?.maxZoom,
+			minPitch: t?.minPitch,
+			maxPitch: t?.maxPitch,
+			pitch: t?.pitch ?? this.initialConfig.pitch,
+			bearing: t?.bearing ?? this.initialConfig.bearing,
+			attributionControl: !1,
+			style: o
+		}), this.flushMapReadyCallbacks();
+		let l = this.mapInstance.getCanvasContainer();
+		l && (l.tabIndex = -1), this.mapInstance.on("load", () => {
+			let e = this.buildViewportFeature();
+			this.store.dispatch({
+				mapLoaded: !0,
+				zoomLevel: r,
+				mapCenter: n,
+				mapViewportBounds: e
+			}, "MAP"), this.applyGlobeFog();
+		}), this.mapInstance.on("dataloading", (e) => {
+			c(e) && e.sourceId && this.silentSourceIds.has(e.sourceId) || this.store.dispatch({ mapBusy: !0 }, "MAP");
+		}), this.mapInstance.on("idle", () => {
+			this.store.dispatch({ mapBusy: !1 }, "MAP");
+		}), this.mapInstance.on("zoomend", () => {
+			let e = this.mapInstance.getZoom(), t = this.buildViewportFeature();
+			this.store.dispatch({
+				zoomLevel: e,
+				mapViewportBounds: t
+			}, "MAP"), this.eventBus?.emit({
+				type: "zoom-end",
+				zoom: e
+			});
+		}), this.mapInstance.on("moveend", () => {
+			let e = this.mapInstance.getCenter().toArray(), t = this.mapInstance.getZoom(), n = this.buildViewportFeature();
+			this.store.dispatch({
+				mapCenter: e,
+				zoomLevel: t,
+				mapViewportBounds: n
+			}, "MAP"), this.emitViewChangeEnd();
+		}), this.mapInstance.on("move", () => {
+			this.dispatchViewportBoundsSnapshot(), this.emitViewChange();
+		}), this.attachPointerEvents(this.mapInstance);
+	}
+	attachPointerEvents(e) {
+		e.on("mousemove", (e) => {
+			let t = [e.lngLat.lng, e.lngLat.lat], n = [e.point.x, e.point.y], r = this.computePointerResolution(e);
+			this.eventBus?.emit({
+				type: "pointer-move",
+				coords: t,
+				pixel: n,
+				resolution: r,
+				originalEvent: e.originalEvent
+			}), this.store.dispatch({
+				pointerCoordinates: t,
+				pointerResolution: r
+			}, "MAP");
+		}), e.on("mousedown", (e) => {
+			let t = [e.lngLat.lng, e.lngLat.lat], n = [e.point.x, e.point.y];
+			this.eventBus?.emit({
+				type: "pointer-down",
+				coords: t,
+				pixel: n,
+				button: e.originalEvent.button,
+				originalEvent: e.originalEvent
+			});
+		}), e.on("mouseup", (e) => {
+			let t = [e.lngLat.lng, e.lngLat.lat], n = [e.point.x, e.point.y];
+			this.eventBus?.emit({
+				type: "pointer-up",
+				coords: t,
+				pixel: n,
+				button: e.originalEvent.button,
+				originalEvent: e.originalEvent
+			});
+		});
+		let t = e.getCanvas();
+		t.addEventListener("pointerdown", (n) => {
+			if (n.pointerType === "mouse") return;
+			let r = t.getBoundingClientRect(), i = [n.clientX - r.left, n.clientY - r.top], a = e.unproject(i), o = [a.lng, a.lat];
+			this.eventBus?.emit({
+				type: "pointer-down",
+				coords: o,
+				pixel: i,
+				button: 0,
+				originalEvent: n
+			});
+		}), t.addEventListener("pointermove", (n) => {
+			if (n.pointerType === "mouse") return;
+			let r = t.getBoundingClientRect(), i = [n.clientX - r.left, n.clientY - r.top], a = e.unproject(i), o = [a.lng, a.lat];
+			this.eventBus?.emit({
+				type: "pointer-move",
+				coords: o,
+				pixel: i,
+				resolution: null,
+				originalEvent: n
+			});
+		}), t.addEventListener("pointerup", (n) => {
+			if (n.pointerType === "mouse") return;
+			let r = t.getBoundingClientRect(), i = [n.clientX - r.left, n.clientY - r.top], a = e.unproject(i), o = [a.lng, a.lat];
+			this.eventBus?.emit({
+				type: "pointer-up",
+				coords: o,
+				pixel: i,
+				button: 0,
+				originalEvent: n
+			});
+		}), t.addEventListener("pointercancel", () => {
+			this.eventBus?.emit({ type: "pointer-cancel" });
+		}), e.on("mouseout", (e) => {
+			this.eventBus?.emit({
+				type: "pointer-leave",
+				originalEvent: e.originalEvent
+			}), this.store.dispatch({
+				pointerCoordinates: null,
+				pointerResolution: null
+			}, "MAP");
+		}), e.on("click", (e) => {
+			let t = [e.lngLat.lng, e.lngLat.lat], n = [e.point.x, e.point.y], r = this.computePointerResolution(e);
+			this.eventBus?.emit({
+				type: "click",
+				coords: t,
+				pixel: n,
+				resolution: r,
+				originalEvent: e.originalEvent
+			}), this.store.dispatch({
+				lastClickedCoordinates: t,
+				lastClickedResolution: r,
+				pointerCoordinates: t,
+				pointerResolution: r
+			}, "MAP");
+		}), e.on("dblclick", (e) => {
+			let t = [e.lngLat.lng, e.lngLat.lat], n = [e.point.x, e.point.y];
+			this.eventBus?.emit({
+				type: "dblclick",
+				coords: t,
+				pixel: n,
+				originalEvent: e.originalEvent
+			});
+		}), e.on("contextmenu", (e) => {
+			let t = [e.lngLat.lng, e.lngLat.lat], n = [e.point.x, e.point.y];
+			this.eventBus?.emit({
+				type: "contextmenu",
+				coords: t,
+				pixel: n,
+				originalEvent: e.originalEvent
+			});
+		});
+	}
+	computePointerResolution(e) {
+		if (!this.mapInstance || !e.point) return null;
+		let t = this.mapInstance, n = e.point, r = e.lngLat, i = t.unproject([n.x + 1, n.y]), a = t.unproject([n.x, n.y + 1]), o = Math.abs(i.lng - r.lng), s = Math.abs(a.lat - r.lat);
+		return !isFinite(o) || !isFinite(s) ? null : {
+			lng: Math.max(o, 1e-12),
+			lat: Math.max(s, 1e-12)
+		};
+	}
+	emitViewChange() {
+		if (!this.eventBus || !this.mapInstance) return;
+		let e = this.mapInstance.getCenter(), t = this.mapInstance.getBounds();
+		this.eventBus.emit({
+			type: "view-change",
+			center: [e.lng, e.lat],
+			zoom: this.mapInstance.getZoom(),
+			bearing: this.mapInstance.getBearing(),
+			pitch: this.mapInstance.getPitch(),
+			bounds: {
+				sw: [t.getSouthWest().lng, t.getSouthWest().lat],
+				ne: [t.getNorthEast().lng, t.getNorthEast().lat]
+			}
+		});
+	}
+	emitViewChangeEnd() {
+		if (!this.eventBus || !this.mapInstance) return;
+		let e = this.mapInstance.getCenter(), t = this.mapInstance.getBounds();
+		this.eventBus.emit({
+			type: "view-change-end",
+			center: [e.lng, e.lat],
+			zoom: this.mapInstance.getZoom(),
+			bearing: this.mapInstance.getBearing(),
+			pitch: this.mapInstance.getPitch(),
+			bounds: {
+				sw: [t.getSouthWest().lng, t.getSouthWest().lat],
+				ne: [t.getNorthEast().lng, t.getNorthEast().lat]
+			}
+		});
+	}
+	onMapReady(e) {
+		if (this.mapInstance) {
+			e(this.mapInstance);
+			return;
+		}
+		this.mapReadyCallbacks.push(e);
+	}
+	setZoom(e) {
+		this.mapInstance && this.mapInstance.setZoom(e);
+	}
+	getZoom() {
+		return this.mapInstance ? this.mapInstance.getZoom() : this.initialConfig.zoom;
+	}
+	addLayer(e, t) {
+		if (!this.mapInstance || e?.id && this.mapInstance.getLayer(e.id)) return !1;
+		if (t?.beforeLayerId) return this.mapInstance.addLayer(e, t.beforeLayerId), !0;
+		if (t?.afterLayerId) {
+			let n = this.mapInstance.getStyle(), r = Array.isArray(n?.layers) ? n.layers : [], i = r.findIndex((e) => e?.id === t.afterLayerId), a = i >= 0 && i + 1 < r.length ? r[i + 1]?.id : void 0;
+			return this.mapInstance.addLayer(e, a), !0;
+		}
+		return this.mapInstance.addLayer(e), !0;
+	}
+	removeLayer(e) {
+		this.mapInstance?.getLayer(e) && this.mapInstance.removeLayer(e);
+	}
+	static {
+		this.TERRAIN_SOURCE_ID = "webmapx-terrain-dem";
+	}
+	static {
+		this.TERRAIN_HILLSHADE_LAYER_ID = "webmapx-terrain-hillshade";
+	}
+	static {
+		this.TERRAIN_SOURCE_CONFIG = {
+			type: "raster-dem",
+			tiles: [
+				"https://t1.edugis.nl/mapproxy/nextzenelevation/wmts/nextzenelevation/webmercator/{z}/{x}/{y}.png",
+				"https://t2.edugis.nl/mapproxy/nextzenelevation/wmts/nextzenelevation/webmercator/{z}/{x}/{y}.png",
+				"https://t3.edugis.nl/mapproxy/nextzenelevation/wmts/nextzenelevation/webmercator/{z}/{x}/{y}.png",
+				"https://t4.edugis.nl/mapproxy/nextzenelevation/wmts/nextzenelevation/webmercator/{z}/{x}/{y}.png"
+			],
+			tileSize: 256,
+			encoding: "terrarium",
+			maxzoom: 15,
+			attribution: "NextZen"
+		};
+	}
+	setTerrainEnabled(t, n, r) {
+		if (!this.mapInstance || t && this.mapInstance.getProjection?.()?.type === "globe") return !1;
+		try {
+			if (t) {
+				let t = r ?? e.TERRAIN_SOURCE_ID;
+				this.mapInstance.getSource(t) || this.mapInstance.addSource(t, n ?? e.TERRAIN_SOURCE_CONFIG), this.mapInstance.setTerrain({
+					source: t,
+					exaggeration: 1
+				}), !r && !this.mapInstance.getLayer(e.TERRAIN_HILLSHADE_LAYER_ID) && this.mapInstance.addLayer({
+					id: e.TERRAIN_HILLSHADE_LAYER_ID,
+					type: "hillshade",
+					source: e.TERRAIN_SOURCE_ID,
+					paint: { "hillshade-exaggeration": .2 }
+				});
+			} else this.mapInstance.setTerrain(null), this.mapInstance.getLayer(e.TERRAIN_HILLSHADE_LAYER_ID) && this.mapInstance.removeLayer(e.TERRAIN_HILLSHADE_LAYER_ID);
+		} catch (e) {
+			return console.error("[MapLibre] setTerrain failed", e), this.mapInstance.setTerrain(null), !1;
+		}
+		return !0;
+	}
+	isTerrainEnabled() {
+		return this.mapInstance ? !!this.mapInstance.getTerrain() : null;
+	}
+	addSource(e, t) {
+		this.mapInstance?.addSource(e, t), t?.type === "geojson" && t.data && typeof t.data == "object" && this.geoJSONData.set(e, t.data);
+	}
+	removeSource(e) {
+		this.mapInstance?.getSource(e) && this.mapInstance.removeSource(e), this.geoJSONData.delete(e);
+	}
+	getSource(e) {
+		let t = this.mapInstance?.getSource(e);
+		if (!t) return;
+		let n = this;
+		return {
+			id: e,
+			setData: (r) => {
+				t.setData(r), n.geoJSONData.set(e, r);
+			}
+		};
+	}
+	project(e) {
+		if (!this.mapInstance) return console.warn("[CORE SERVICE - MapLibre] project called before map instance is ready."), [0, 0];
+		try {
+			let t = this.mapInstance.project(e);
+			return [t.x, t.y];
+		} catch {
+			return [0, 0];
+		}
+	}
+	unproject(e) {
+		if (!this.mapInstance) return console.warn("[CORE SERVICE - MapLibre] unproject called before map instance is ready."), null;
+		let t = [e[0], e[1]], n = this.mapInstance.unproject(t);
+		return [n.lng, n.lat];
+	}
+	fitBounds(e) {
+		if (this.mapInstance) try {
+			this.mapInstance.fitBounds([[e[0], e[1]], [e[2], e[3]]], {
+				padding: 40,
+				animate: !0
+			});
+		} catch {
+			let t = (e[0] + e[2]) / 2, n = (e[1] + e[3]) / 2;
+			this.setViewport([t, n], this.initialConfig.zoom);
+		}
+	}
+	setCursor(e) {
+		this.mapInstance && (this.mapInstance.getCanvas().style.cursor = e);
+	}
+	setPanEnabled(e) {
+		this.mapInstance && (e ? this.mapInstance.dragPan.enable() : this.mapInstance.dragPan.disable());
+	}
+	setTouchCaptureEnabled(e) {}
+	setDoubleClickZoomEnabled(e) {
+		this.mapInstance && (e ? this.mapInstance.doubleClickZoom.enable() : this.mapInstance.doubleClickZoom.disable());
+	}
+	setLayerVisibility(e, t) {
+		if (this.mapInstance) try {
+			this.mapInstance.setLayoutProperty(e, "visibility", t ? "visible" : "none");
+		} catch {}
+	}
+	getSourceData(e) {
+		let t = this.geoJSONData.get(e);
+		if (t) return t;
+		if (!this.mapInstance) return null;
+		let n = this.mapInstance.getSource(e);
+		if (!n || n.type !== "geojson") return null;
+		try {
+			let t = n.serialize();
+			if (!t) return null;
+			if (typeof t.data == "string") return t.data;
+			if (typeof t.data == "object") return this.geoJSONData.set(e, t.data), t.data;
+		} catch {}
+		return null;
+	}
+	suppressBusySignalForSource(e) {
+		this.silentSourceIds.add(e);
+	}
+	unsuppressBusySignalForSource(e) {
+		this.silentSourceIds.delete(e);
+	}
+	getNavigationCapabilities() {
+		return {
+			bearing: !0,
+			pitch: !0
+		};
+	}
+	getBearing() {
+		return this.mapInstance?.getBearing() ?? 0;
+	}
+	setBearing(e) {
+		this.mapInstance?.setBearing(e);
+	}
+	getPitch() {
+		return this.mapInstance?.getPitch() ?? 0;
+	}
+	setPitch(e) {
+		this.mapInstance?.setPitch(e);
+	}
+	resetNorth() {
+		this.mapInstance?.resetNorth();
+	}
+	resetNorthPitch() {
+		this.mapInstance?.resetNorthPitch();
+	}
+	applyGlobeFog() {
+		if (!this.mapInstance) return;
+		let e = this.mapInstance.getProjection?.()?.type === "globe", t = this.mapInstance.getCanvas?.();
+		t && (t.style.background = e ? "#000008" : "var(--color-background-secondary, #f4f4f4)");
+		try {
+			this.mapInstance.setSky(e ? { "sky-color": "#000000" } : void 0);
+		} catch {}
+	}
+	setProjection(e) {
+		if (!this.mapInstance) return !1;
+		try {
+			let t = typeof e == "string" ? { type: e } : {
+				type: e.name,
+				center: e.center,
+				parallels: e.parallels
+			};
+			return this.mapInstance.setProjection(t), this.applyGlobeFog(), !0;
+		} catch {
+			return !1;
+		}
+	}
+	getProjection() {
+		if (!this.mapInstance) return { name: "mercator" };
+		try {
+			let e = this.mapInstance.getProjection();
+			return {
+				name: e?.type ?? e?.name ?? "mercator",
+				...e?.center ? { center: e.center } : {},
+				...e?.parallels ? { parallels: e.parallels } : {}
+			};
+		} catch {
+			return { name: "mercator" };
+		}
+	}
+	dispatchViewportBoundsSnapshot() {
+		let e = this.buildViewportFeature();
+		this.store.dispatch({ mapViewportBounds: e }, "MAP");
+	}
+	buildViewportFeature() {
+		if (!this.mapInstance) return null;
+		let e = [], t = this.mapInstance.getCanvas(), n = this.mapInstance.pixelRatio ?? window.devicePixelRatio ?? 1, r = (t?.width ?? 0) / n || t?.clientWidth || 0, i = (t?.height ?? 0) / n || t?.clientHeight || 0;
+		if (r > 0 && i > 0) {
+			let t = [
+				[0, i],
+				[r, i],
+				[r, 0],
+				[0, 0]
+			];
+			for (let n of t) {
+				let t = this.mapInstance.unproject(n);
+				e.push([t.lng, t.lat]);
+			}
+			e.push(e[0]);
+		}
+		if (e.length === 0) {
+			let t = this.mapInstance.getBounds();
+			if (!t) return null;
+			let n = t.getSouthWest(), r = t.getNorthEast();
+			e.push([n.lng, n.lat], [n.lng, r.lat], [r.lng, r.lat], [r.lng, n.lat], [n.lng, n.lat]);
+		}
+		return {
+			type: "Feature",
+			properties: { role: "mapViewport" },
+			geometry: {
+				type: "Polygon",
+				coordinates: [e]
+			}
+		};
+	}
+	resolveContainer(e) {
+		let t = document.getElementById(e);
+		if (!t) return console.warn(`[CORE SERVICE] Container #${e} not found. Falling back to ID.`), e;
+		if (t.tagName.toLowerCase() === "webmapx-map") {
+			let e = t.querySelector("[slot=\"map-view\"]");
+			if (e) return e;
+			console.warn("[CORE SERVICE] <webmapx-map> is missing a [slot=\"map-view\"] element. Using host as fallback.");
+		}
+		return t;
+	}
+	flushMapReadyCallbacks() {
+		if (this.mapInstance) for (let e of this.mapReadyCallbacks) try {
+			e(this.mapInstance);
+		} catch (e) {
+			console.error("[CORE SERVICE] mapReady callback failed.", e);
+		}
+	}
+	supportsRuntimeProjection() {
+		return typeof this.mapInstance?.setProjection == "function";
+	}
+	destroyAndReinitialize(e) {
+		if (!this.mapInstance || !this.lastContainerId) return;
+		let t = this.getViewportState();
+		this.mapInstance.remove(), this.mapInstance = null, this.initialize(this.lastContainerId, {
+			...this.lastInitOptions,
+			center: t.center,
+			zoom: t.zoom,
+			bearing: t.bearing,
+			pitch: t.pitch,
+			projection: e
+		});
+	}
+}, u = class {
+	constructor(e) {
+		this.mapLibreInstance = {}, this.mapLibreInstance = e;
+	}
+	setBufferRadius(e) {
+		console.log(`[SERVICE TEMPLATE] Set buffer radius to ${e}km on MapLibre.`);
+	}
+	toggleTool() {
+		console.log("[SERVICE TEMPLATE] Toggled buffer tool activation.");
+	}
+}, d = "https://demotiles.maplibre.org/style.json";
+function f(e) {
+	return e.includes("{s}") ? [
+		"a",
+		"b",
+		"c"
+	].map((t) => e.replace("{s}", t)) : [e];
+}
+var p = class {
+	constructor(e, t) {
+		this.id = e, this.map = t;
+	}
+	setData(e) {
+		let t = this.map.getSource(this.id);
+		t && t.setData(e);
+	}
+}, m = class {
+	constructor(e, t, n) {
+		this.id = e, this.sourceId = t, this.map = n;
+	}
+	getSource() {
+		return new p(this.sourceId, this.map);
+	}
+	remove() {
+		this.map.getLayer(this.id) && this.map.removeLayer(this.id);
+	}
+}, h = class {
+	constructor(e) {
+		this.map = e;
+	}
+	setViewport(e, t, n, r) {
+		this.map.jumpTo({
+			center: e,
+			zoom: t,
+			bearing: n ?? 0,
+			pitch: r ?? 0
+		});
+	}
+	createSource(e, t) {
+		return this.map.getSource(e) || this.map.addSource(e, {
+			type: "geojson",
+			data: t
+		}), new p(e, this.map);
+	}
+	getSource(e) {
+		return this.map.getSource(e) ? new p(e, this.map) : null;
+	}
+	createLayer(e) {
+		if (!this.map.getLayer(e.id)) {
+			let t = this.toMapLibreLayerSpec(e);
+			this.map.addLayer(t);
+		}
+		return new m(e.id, e.sourceId, this.map);
+	}
+	getLayer(e) {
+		let t = this.map.getLayer(e);
+		if (t) {
+			let n = t.source;
+			return new m(e, n, this.map);
+		}
+		return null;
+	}
+	onReady(e) {
+		this.map.isStyleLoaded() ? e() : this.map.once("load", e);
+	}
+	destroy() {
+		this.map.remove();
+	}
+	toMapLibreLayerSpec(e) {
+		switch (e.type) {
+			case "fill": return {
+				id: e.id,
+				type: "fill",
+				source: e.sourceId,
+				paint: e.paint
+			};
+			case "line": return {
+				id: e.id,
+				type: "line",
+				source: e.sourceId,
+				paint: e.paint
+			};
+			case "circle": return {
+				id: e.id,
+				type: "circle",
+				source: e.sourceId,
+				paint: e.paint
+			};
+			case "symbol": return {
+				id: e.id,
+				type: "symbol",
+				source: e.sourceId,
+				layout: {}
+			};
+			default: throw Error(`Unsupported layer type: ${e.type}`);
+		}
+	}
+}, g = class {
+	createMap(e, t) {
+		let n = Array.isArray(t?.tileUrls) && t.tileUrls.length > 0 ? t.tileUrls : typeof t?.tileUrl == "string" && t.tileUrl.length > 0 ? f(t.tileUrl) : void 0, r = t?.style ?? (n ? {
+			version: 8,
+			sources: { insetBackground: {
+				type: "raster",
+				tiles: n,
+				tileSize: t?.tileSize ?? 256,
+				...t?.tileAttribution ? { attribution: t.tileAttribution } : {}
+			} },
+			layers: [{
+				id: "inset-background",
+				type: "raster",
+				source: "insetBackground"
+			}]
+		} : void 0) ?? t?.styleUrl ?? d, i = new s.Map({
+			container: e,
+			style: r,
+			center: t?.center ?? [0, 0],
+			zoom: t?.zoom ?? 1,
+			attributionControl: !1,
+			interactive: t?.interactive ?? !0
+		});
+		return t?.interactive === !1 && (i.boxZoom?.disable(), i.scrollZoom?.disable(), i.dragPan?.disable(), i.dragRotate?.disable(), i.keyboard?.disable(), i.doubleClickZoom?.disable(), i.touchZoomRotate?.disable()), new h(i);
+	}
+}, _ = {
+	fill: ["fill-opacity"],
+	line: ["line-opacity"],
+	circle: ["circle-opacity"],
+	raster: ["raster-opacity"],
+	"fill-extrusion": ["fill-extrusion-opacity"],
+	heatmap: ["heatmap-opacity"],
+	background: ["background-opacity"],
+	symbol: ["icon-opacity", "text-opacity"],
+	hillshade: [
+		"hillshade-shadow-color",
+		"hillshade-highlight-color",
+		"hillshade-accent-color"
+	]
+}, v = class t {
+	constructor(e, t) {
+		this.logicalToNative = /* @__PURE__ */ new Map(), this.logicalSourceToNative = /* @__PURE__ */ new Map(), this.nativeLayerToSource = /* @__PURE__ */ new Map(), this.warpedMapLayers = /* @__PURE__ */ new Map(), this.nativeSourceToConfig = /* @__PURE__ */ new Map(), this.sourceIdCounter = 0, this.logicalLayerLegendRole = /* @__PURE__ */ new Map(), this._pendingHillshade = /* @__PURE__ */ new Map(), this.map = e, this.store = t;
+	}
+	resolveLegendRole(e) {
+		return (e?.metadata && typeof e.metadata == "object" ? e.metadata : null)?.legendRole === "background" ? "background" : "overlay";
+	}
+	findNextStyleLayerId(e) {
+		let t = this.map.getStyle()?.layers ?? [];
+		for (let n = 0; n < t.length; n += 1) if (t[n].id === e) return t[n + 1]?.id;
+	}
+	resolveInsertBeforeLayerIdFromOptions(e) {
+		if (e?.beforeLayerId) {
+			for (let t of this.logicalToNative.get(e.beforeLayerId) ?? []) if (this.map.getLayer(t)) return t;
+			if (this.map.getLayer(e.beforeLayerId)) return e.beforeLayerId;
+		}
+		if (e?.afterLayerId) {
+			let t = this.logicalToNative.get(e.afterLayerId) ?? [];
+			for (let e = t.length - 1; e >= 0; --e) if (this.map.getLayer(t[e])) return this.findNextStyleLayerId(t[e]);
+			if (this.map.getLayer(e.afterLayerId)) return this.findNextStyleLayerId(e.afterLayerId);
+		}
+	}
+	collectBackgroundNativeLayerIds() {
+		let e = /* @__PURE__ */ new Set();
+		for (let [t, n] of this.logicalToNative.entries()) if ((this.logicalLayerLegendRole.get(t) ?? "overlay") === "background") for (let t of n) e.add(t);
+		return e;
+	}
+	findBackgroundInsertionBeforeLayerId() {
+		let e = this.collectBackgroundNativeLayerIds();
+		for (let [t, n] of this.logicalToNative.entries()) if (this.logicalLayerLegendRole.get(t) !== "background") {
+			for (let t of n) if (!e.has(t)) return t;
+		}
+	}
+	getNativeSourceId(e) {
+		return this.logicalSourceToNative.get(e);
+	}
+	getOrCreateNativeSourceId(e) {
+		if (this.logicalSourceToNative.has(e)) return this.logicalSourceToNative.get(e);
+		let t = `src-${e.replace(/[^a-zA-Z0-9_-]/g, "-")}-${this.sourceIdCounter++}`;
+		return this.logicalSourceToNative.set(e, t), t;
+	}
+	ensureNativeSource(t, n) {
+		if (this.map.getSource(t)) {
+			this.nativeSourceToConfig.has(t) || this.nativeSourceToConfig.set(t, n);
+			return;
+		}
+		let r = { type: n.type };
+		if (n.type === "raster") {
+			if (n.service === "xyz" || n.service === void 0) r = {
+				type: "raster",
+				tiles: Array.isArray(n.url) ? n.url : [n.url]
+			}, "tileSize" in n && (r.tileSize = n.tileSize), "bounds" in n && (r.bounds = n.bounds), typeof n.minzoom == "number" && (r.minzoom = n.minzoom), typeof n.maxzoom == "number" && (r.maxzoom = n.maxzoom), "scheme" in n && (r.scheme = n.scheme), typeof n.attribution == "string" && (r.attribution = n.attribution), typeof n.volatile == "boolean" && (r.volatile = n.volatile);
+			else if (n.service === "wms") {
+				let t = n, i = n.tiles, a;
+				a = i?.length ? i : [e({
+					baseUrl: Array.isArray(t.url) ? t.url[0] : t.url,
+					layers: t.layers ?? "",
+					version: t.version,
+					styles: t.styles,
+					format: t.format,
+					transparent: t.transparent,
+					crs: t.crs,
+					tileSize: t.tileSize
+				}, "maplibre")], r = {
+					type: "raster",
+					tiles: a
+				}, "tileSize" in n && (r.tileSize = n.tileSize), "bounds" in n && (r.bounds = n.bounds), typeof n.minzoom == "number" && (r.minzoom = n.minzoom), typeof n.maxzoom == "number" && (r.maxzoom = n.maxzoom), "scheme" in n && (r.scheme = n.scheme), typeof n.attribution == "string" && (r.attribution = n.attribution), typeof n.volatile == "boolean" && (r.volatile = n.volatile);
+			}
+		} else if (n.type === "geojson") r = {
+			type: "geojson",
+			data: n.data
+		}, typeof n.attribution == "string" && (r.attribution = n.attribution);
+		else if (n.type === "raster-dem") {
+			let e = n;
+			r = {
+				type: "raster-dem",
+				tiles: e.tiles
+			}, typeof e.tileSize == "number" && (r.tileSize = e.tileSize), typeof e.encoding == "string" && (r.encoding = e.encoding), typeof e.maxzoom == "number" && (r.maxzoom = e.maxzoom), typeof e.attribution == "string" && (r.attribution = e.attribution);
+		} else if (n.type === "vector") {
+			let e = n;
+			r = e.tiles ? {
+				type: "vector",
+				tiles: e.tiles
+			} : {
+				type: "vector",
+				url: e.url
+			}, typeof n.attribution == "string" && (r.attribution = n.attribution);
+		}
+		this.map.addSource(t, r), this.nativeSourceToConfig.set(t, n);
+	}
+	buildNativeLayer(e, t, n, r) {
+		let i = {
+			id: e,
+			type: t.type,
+			source: n,
+			metadata: { mapLayerId: r }
+		};
+		return t["source-layer"] && (i["source-layer"] = t["source-layer"]), t.minzoom !== void 0 && (i.minzoom = t.minzoom), t.maxzoom !== void 0 && (i.maxzoom = t.maxzoom), t.paint && typeof t.paint == "object" && (i.paint = t.paint), t.layout && typeof t.layout == "object" && (i.layout = t.layout), Array.isArray(t.filter) && (i.filter = t.filter), i;
+	}
+	async addAllmapsLayer(e, t, n) {
+		let { WarpedMapLayer: r } = await import("./dist-kKlmcBXq.js"), i = `warpedmap-${e}`, a = new r({ layerId: i });
+		return this.map.addLayer(a, n), await a.addGeoreferenceAnnotationByUrl(t), this.warpedMapLayers.set(e, a), this.logicalToNative.set(e, [i]), !0;
+	}
+	async addCompositeLayer(e, t) {
+		let n = e.styleId, r = e.metadata?.legendRole === "background" ? "background" : "overlay", i = this.resolveInsertBeforeLayerIdFromOptions(t) ?? (r === "background" ? this.findBackgroundInsertionBeforeLayerId() : void 0), a = /* @__PURE__ */ new Map();
+		for (let t of e.sources) {
+			let e = this.getOrCreateNativeSourceId(t.globalId);
+			this.ensureNativeSource(e, t.config), a.set(t.key, e);
+		}
+		let o = [...this.logicalToNative.get(n) ?? []];
+		for (let t of e.subLayers) {
+			let e = `${n}-${t.id}`;
+			if (t.type === "background") {
+				if (!this.map.getLayer(e)) {
+					let n = {
+						id: e,
+						type: "background"
+					};
+					t.paint && (n.paint = t.paint), t.layout && (n.layout = t.layout), this.map.addLayer(n, i);
+				}
+				o.push(e);
+				continue;
+			}
+			let r = a.get(t.source ?? "");
+			!r || !this.map.getSource(r) || (this.map.getLayer(e) || this.map.addLayer(this.buildNativeLayer(e, t, r, n), i), o.push(e), this.nativeLayerToSource.set(e, r));
+		}
+		return this.logicalLayerLegendRole.set(n, r), this.logicalToNative.set(n, Array.from(new Set(o))), o.length > 0;
+	}
+	static {
+		this.LAYOUT_KEYS = new Set([
+			"text-size",
+			"icon-size",
+			"text-field",
+			"visibility"
+		]);
+	}
+	applyHillshadePaintThrottled(e, t, n) {
+		let r = this._pendingHillshade.get(e);
+		if (r) {
+			r.key = t, r.value = n;
+			return;
+		}
+		let i = requestAnimationFrame(() => {
+			let t = this._pendingHillshade.get(e);
+			t && (this._pendingHillshade.delete(e), this.map.setPaintProperty(e, t.key, t.value), this.map.triggerRepaint());
+		});
+		this._pendingHillshade.set(e, {
+			key: t,
+			value: n,
+			rafId: i
+		});
+	}
+	static layerTypeForKey(e) {
+		return e.startsWith("fill-extrusion") ? "fill-extrusion" : e.startsWith("text-") || e.startsWith("icon-") ? "symbol" : e.split("-")[0];
+	}
+	applyStyleProperty(e, n, r) {
+		t.LAYOUT_KEYS.has(n) ? (this.map.setLayoutProperty(e, n, r), this.map.triggerRepaint()) : n === "hillshade-exaggeration" ? this.applyHillshadePaintThrottled(e, n, r) : (this.map.setPaintProperty(e, n, r), this.map.triggerRepaint());
+	}
+	updateLayerStyle(e, n, r) {
+		let i = `${e}-${n}`;
+		if (this.map.getLayer(i)) {
+			for (let [e, t] of Object.entries(r)) this.applyStyleProperty(i, e, t);
+			return !0;
+		}
+		if (e !== n) return !1;
+		let a = !1, o = this.logicalToNative.get(e) ?? [];
+		for (let e of o) if (this.map.getLayer(e)) for (let [n, i] of Object.entries(r)) {
+			let r = t.layerTypeForKey(n);
+			e.endsWith(`-${r}`) && (this.applyStyleProperty(e, n, i), a = !0);
+		}
+		return a;
+	}
+	async addLayer(e, t) {
+		let i = e.id, a = this.resolveLegendRole(e), o = this.resolveInsertBeforeLayerIdFromOptions(t) ?? (a === "background" ? this.findBackgroundInsertionBeforeLayerId() : void 0);
+		if (e.type === "allmaps") {
+			let t = await this.addAllmapsLayer(i, e.annotation, o);
+			return t && this.logicalLayerLegendRole.set(i, a), t;
+		}
+		if (e.type === "style") {
+			let n = r(e);
+			return n ? this.addCompositeLayer(n, t) : !1;
+		}
+		let s = e;
+		if (s.type === "background") {
+			let e = `${i}-background`;
+			if (!this.map.getLayer(e)) {
+				let t = {
+					id: e,
+					type: "background"
+				};
+				s.paint && (t.paint = s.paint), s.layout && (t.layout = s.layout), this.map.addLayer(t, o);
+			}
+			return this.logicalLayerLegendRole.set(i, a), this.logicalToNative.set(i, [e]), !0;
+		}
+		if (!s.source) return !1;
+		let c = e.sources?.[s.source], l = c ? n(s.source, c) : null;
+		if (!l) return !1;
+		let u = this.getOrCreateNativeSourceId(l.id);
+		if (this.ensureNativeSource(u, l), !this.map.getSource(u)) return !1;
+		let d = `${i}-${l.id}-${s.type}`;
+		this.map.getLayer(d) || (this.map.addLayer(this.buildNativeLayer(d, s, u, i), o), s.type === "hillshade" && this.map.setPaintProperty(d, "hillshade-exaggeration-transition", {
+			duration: 0,
+			delay: 0
+		})), this.logicalLayerLegendRole.set(i, a);
+		let f = this.logicalToNative.get(i) ?? [];
+		return this.logicalToNative.set(i, Array.from(new Set([...f, d]))), this.nativeLayerToSource.set(d, u), !0;
+	}
+	moveLayer(e, t) {
+		let n = this.logicalToNative.get(e) ?? [], r = t ? this.resolveInsertBeforeLayerIdFromOptions({ beforeLayerId: t }) : void 0;
+		for (let e of n) if (this.map.getLayer(e)) try {
+			this.map.moveLayer(e, r);
+		} catch {}
+	}
+	removeLayer(e) {
+		if (this.warpedMapLayers.has(e)) {
+			for (let t of this.logicalToNative.get(e) ?? []) this.map.getLayer(t) && this.map.removeLayer(t);
+			this.warpedMapLayers.delete(e), this.logicalToNative.delete(e), this.logicalLayerLegendRole.delete(e);
+			return;
+		}
+		let t = this.logicalToNative.get(e) ?? [], n = /* @__PURE__ */ new Set();
+		for (let e of t) {
+			let t = this.nativeLayerToSource.get(e);
+			t && n.add(t), this.map.getLayer(e) && this.map.removeLayer(e), this.nativeLayerToSource.delete(e);
+		}
+		this.logicalToNative.delete(e), this.logicalLayerLegendRole.delete(e);
+		let r = this.map.getTerrain?.();
+		if (r && n.has(r.source)) {
+			this.map.setTerrain(null);
+			let e = r.source;
+			this.map.getSource(e) && !n.has(e) && this.map.removeSource(e);
+		}
+		for (let e of n) {
+			let t = !1;
+			for (let n of this.nativeLayerToSource.values()) if (n === e) {
+				t = !0;
+				break;
+			}
+			if (!t && this.map.getSource(e)) {
+				this.map.removeSource(e);
+				for (let [t, n] of this.logicalSourceToNative.entries()) if (n === e) {
+					this.logicalSourceToNative.delete(t);
+					break;
+				}
+			}
+		}
+	}
+	getVisibleLayers() {
+		return Array.from(this.logicalToNative.keys());
+	}
+	isLayerVisible(e) {
+		return this.logicalToNative.has(e);
+	}
+	setLayerVisibility(e, t) {
+		let n = this.logicalToNative.get(e) ?? [];
+		for (let e of n) try {
+			this.map.setLayoutProperty(e, "visibility", t ? "visible" : "none");
+		} catch {}
+	}
+	setLayerOpacity(e, t) {
+		let n = this.warpedMapLayers.get(e);
+		if (n) {
+			n.setOpacity(t);
+			return;
+		}
+		let r = this.logicalToNative.get(e) ?? [];
+		for (let e of r) try {
+			let n = this.map.getLayer(e), r = n ? _[n.type] : void 0;
+			if (!r) continue;
+			if (n.type === "hillshade") {
+				this.map.setPaintProperty(e, "hillshade-shadow-color", `rgba(0,0,0,${t})`), this.map.setPaintProperty(e, "hillshade-highlight-color", `rgba(255,255,255,${t})`), this.map.setPaintProperty(e, "hillshade-accent-color", `rgba(0,0,0,${t})`);
+				continue;
+			}
+			for (let n of r) this.map.setPaintProperty(e, n, t);
+		} catch {}
+	}
+	getSourceData(e) {
+		let t = this.logicalSourceToNative.get(e);
+		if (!t) return null;
+		let n = this.map.getSource(t);
+		if (!n || n.type !== "geojson") return null;
+		try {
+			let e = n.serialize?.()?.data;
+			if (typeof e == "string" || e && typeof e == "object") return e;
+		} catch {}
+		return null;
+	}
+	querySourceFeatures(e, t = {}) {
+		let n = this.logicalSourceToNative.get(e);
+		if (!n || !this.map.getSource(n)) return null;
+		try {
+			let e = t.sourceLayer ? { sourceLayer: t.sourceLayer } : void 0, r = this.map.querySourceFeatures(n, e);
+			return { features: this.dedupeSourceFeatures(r.map((e) => e.toJSON())) };
+		} catch {
+			return null;
+		}
+	}
+	dedupeSourceFeatures(e) {
+		let t = /* @__PURE__ */ new Set();
+		return e.filter((e) => {
+			let n = e.id === void 0 ? JSON.stringify([e.geometry, e.properties ?? {}]) : `id:${String(e.id)}`;
+			return t.has(n) ? !1 : (t.add(n), !0);
+		});
+	}
+	setSourceData(e, t) {
+		let n = this.logicalSourceToNative.get(e);
+		if (!n) return !1;
+		let r = this.map.getSource(n);
+		return !r || r.type !== "geojson" || typeof r.setData != "function" ? !1 : (r.setData(t), !0);
+	}
+	getVisibleWMSLayers() {
+		let e = [];
+		for (let t of this.logicalToNative.keys()) {
+			let n = this.logicalToNative.get(t) ?? [];
+			for (let r of n) {
+				let n = this.nativeLayerToSource.get(r);
+				if (!n) continue;
+				let i = this.nativeSourceToConfig.get(n);
+				if (i?.type === "raster" && i.service === "wms") {
+					let n = i, r = "gfiUrl" in n ? {
+						...n,
+						url: n.gfiUrl,
+						layers: n.gfiLayers,
+						version: n.gfiVersion
+					} : n;
+					e.push({
+						layerId: t,
+						sourceConfig: r
+					});
+				}
+				break;
+			}
+		}
+		return e;
+	}
+}, y = class {
+	constructor(e, t, n) {
+		this.map = e, this.layerService = t, this.store = n;
+	}
+	async queryFeatures(e, n = {}) {
+		let { pixel: r, lngLat: i } = e, a = n.tolerancePx ?? 5, o = [], s = [[r[0] - a, r[1] - a], [r[0] + a, r[1] + a]], c = n.layerIds?.length ? new Set(n.layerIds) : null, l = this.store.getState().mapLayers ?? {}, u = this.map.queryRenderedFeatures(s);
+		for (let e of u) {
+			let t = this.resolveRegisteredLayerId(e.layer, l);
+			if (!t || c && !c.has(t)) continue;
+			let n = this.resolveLayerTitle(t, l), r = typeof e.layer?.id == "string" ? e.layer.id : "", i = `${t}-style:`, a = r.startsWith(i) ? r.slice(i.length) : void 0, s = typeof e.layer?.type == "string" ? e.layer.type : void 0;
+			o.push({
+				layerId: t,
+				...n ? { layerTitle: n } : {},
+				properties: e.properties,
+				geometry: e.geometry,
+				source: "vector",
+				...a ? { subLayerId: a } : {},
+				...s ? { subLayerType: s } : {}
+			});
+		}
+		if (n.includeWMS) {
+			let e = this.map.getContainer(), n = e.clientWidth, i = e.clientHeight, a = this.map.getBounds(), s = {
+				west: a.getWest(),
+				south: a.getSouth(),
+				east: a.getEast(),
+				north: a.getNorth()
+			}, l = this.layerService.getVisibleWMSLayers(), u = await Promise.all(l.filter((e) => !c || c.has(e.layerId)).map((e) => t({
+				sourceConfig: e.sourceConfig,
+				layerId: e.layerId,
+				layerTitle: e.layerTitle,
+				bounds: s,
+				containerWidth: n,
+				containerHeight: i,
+				pixelX: r[0],
+				pixelY: r[1]
+			})));
+			for (let e of u) o.push(...e);
+		}
+		return o;
+	}
+	resolveRegisteredLayerId(e, t) {
+		let n = e.metadata && typeof e.metadata == "object" ? e.metadata : {}, r = typeof n.mapLayerId == "string" ? n.mapLayerId : typeof e.id == "string" ? e.id : null;
+		return r && t[r] ? r : null;
+	}
+	resolveLayerTitle(e, t) {
+		let n = t[e];
+		return typeof n?.label == "string" && n.label.length > 0 ? n.label : null;
+	}
+}, b = class {
+	constructor(e) {
+		this.map = e, this.markers = /* @__PURE__ */ new Map();
+	}
+	add(e, t, n = {}) {
+		this.remove(e);
+		let r = new s.Marker({
+			color: n.color ?? "#e63946",
+			draggable: n.draggable ?? !1
+		}).setLngLat([t[0], t[1]]).addTo(this.map);
+		this.markers.set(e, r);
+	}
+	move(e, t) {
+		this.markers.get(e)?.setLngLat([t[0], t[1]]);
+	}
+	remove(e) {
+		let t = this.markers.get(e);
+		t && (t.remove(), this.markers.delete(e));
+	}
+}, x = class extends a {
+	constructor() {
+		super(), this.engineId = "maplibre", this.engineVersion = typeof s.getVersion == "function" ? s.getVersion() : s.version ?? "", this.markerService = null, this.layerService = null, this.core = new l(this.store, this.events), this.toolService = new u({}), this.logicalLayerExecutor = new i(), this.queryExecutor = new o(), this.queryService = this.queryExecutor, this.mapFactory = new g(), this.core.onMapReady?.((e) => {
+			let t = () => {
+				let t = new v(e, this.store);
+				this.layerService = t, this.logicalLayerExecutor.bind(t), this.queryExecutor.bind(new y(e, t, this.store)), this.markerService = new b(e);
+			};
+			if (typeof e?.once == "function") {
+				e.once("load", t);
+				return;
+			}
+			t();
+		});
+	}
+	initialize(e, t) {
+		this.core.initialize(e, t);
+	}
+	getViewportState() {
+		return this.core.getViewportState();
+	}
+	setViewport(e, t) {
+		this.core.setViewport(e, t);
+	}
+	getZoom() {
+		return this.core.getZoom();
+	}
+	setZoom(e) {
+		this.core.setZoom(e);
+	}
+	getBearing() {
+		return this.core.getBearing();
+	}
+	setBearing(e) {
+		this.core.setBearing(e);
+	}
+	getPitch() {
+		return this.core.getPitch();
+	}
+	setPitch(e) {
+		this.core.setPitch(e);
+	}
+	setTerrainEnabled(e, t) {
+		let n = t?.id, r = n ? this.layerService?.getNativeSourceId(n) : void 0;
+		return this.core.setTerrainEnabled(e, t, r);
+	}
+	isTerrainEnabled() {
+		return this.core.isTerrainEnabled();
+	}
+	resetNorth() {
+		this.core.resetNorth();
+	}
+	resetNorthPitch() {
+		this.core.resetNorthPitch();
+	}
+	fitBounds(e) {
+		this.core.fitBounds(e);
+	}
+	setProjection(e) {
+		return this.core.setProjection(e);
+	}
+	getProjection() {
+		return this.core.getProjection();
+	}
+	setCursor(e) {
+		this.core.setCursor(e);
+	}
+	setPanEnabled(e) {
+		this.core.setPanEnabled(e);
+	}
+	setTouchCaptureEnabled(e) {}
+	setDoubleClickZoomEnabled(e) {
+		this.core.setDoubleClickZoomEnabled(e);
+	}
+	setLayerVisibility(e, t) {
+		this.logicalLayerExecutor.setLayerVisibility(e, t);
+	}
+	setLayerOpacity(e, t) {
+		this.logicalLayerExecutor.setLayerOpacity(e, t);
+	}
+	getSourceData(e) {
+		let t = this.core.getSourceData(e);
+		if (t !== null) return t;
+		let n = this.layerService?.getNativeSourceId(e);
+		if (n && n !== e) {
+			let e = this.core.getSourceData(n);
+			if (e !== null) return e;
+		}
+		return this.logicalLayerExecutor.getSourceData(e);
+	}
+	querySourceFeatures(e, t) {
+		return this.logicalLayerExecutor.querySourceFeatures(e, t);
+	}
+	project(e) {
+		return this.core.project(e);
+	}
+	unproject(e) {
+		return this.core.unproject(e);
+	}
+	getNavigationCapabilities() {
+		return this.core.getNavigationCapabilities();
+	}
+	async engineAddLayer(e, t) {
+		return await this.logicalLayerExecutor.addLayer(e, t) ? !0 : this.core.addLayer(e, t);
+	}
+	removeLogicalLayer(e) {
+		this.removeLayer(e);
+	}
+	engineAddSource(e, t) {
+		this.core.addSource(e, t);
+	}
+	engineRemoveLayer(e) {
+		this.logicalLayerExecutor.removeLayer(e), this.core.removeLayer(e);
+	}
+	engineRemoveSource(e) {
+		this.core.removeSource(e);
+	}
+	getCore() {
+		return this.core;
+	}
+	getLogicalLayerExecutor() {
+		return this.logicalLayerExecutor;
+	}
+	getMarkerService() {
+		return this.markerService;
+	}
+};
+//#endregion
+export { x as MapLibreAdapter };