@edugis-org/webmapx 0.1.6 → 0.1.8

package/dist-lib/openlayers-adapter-B8WtV1tn.js

@@ -0,0 +1,1462 @@
+import { t as e } from "./wms-feature-info-C0RVMEQC.js";
+import { a as t, i as n, n as r, o as i, r as a, t as o } from "./deferred-query-service-BJDcngw6.js";
+import { n as s } from "./marker-utils-DztWXeop.js";
+import { fromLonLat as c, toLonLat as l } from "ol/proj";
+import { VERSION as u } from "ol/util.js";
+import d from "ol/Map";
+import f from "ol/View";
+import { apply as p, stylefunction as m } from "ol-mapbox-style";
+import "ol/ol.css";
+import h from "ol/layer/Vector";
+import g from "ol/source/Vector";
+import _ from "ol/format/GeoJSON";
+import v from "ol/layer/Tile";
+import y from "ol/source/OSM";
+import b from "ol/source/XYZ";
+import { Fill as x, Stroke as S, Style as C } from "ol/style";
+import w from "ol/layer/VectorTile";
+import T from "ol/source/VectorTile";
+import E from "ol/format/MVT";
+import D from "ol/source/ImageWMS";
+import O from "ol/layer/Image";
+import k from "ol/source/TileWMS";
+import { createXYZ as A } from "ol/tilegrid";
+import { createFromTemplate as j } from "ol/tileurlfunction";
+import M from "ol/Overlay";
+//#region src/map/openlayers-services/MapCoreService.ts
+var N = class e {
+	static {
+		this.ZOOM_OFFSET = 1;
+	}
+	constructor(e, t) {
+		this.store = e, this.eventBus = t, this.mapInstance = null, this.panDisabled = !1, this.mapReadyCallbacks = [], this.silentSourceIds = /* @__PURE__ */ new Set(), this.initialConfig = {
+			center: [10.45, 51.17],
+			zoom: 4
+		}, this.layerOrderRegistry = null, this.sources = /* @__PURE__ */ new Map(), this.pendingTileLoads = 0;
+	}
+	toLogicalBearing(e) {
+		return -(e.getRotation() || 0) * 180 / Math.PI;
+	}
+	toOLZoom(t) {
+		return t + e.ZOOM_OFFSET;
+	}
+	fromOLZoom(t) {
+		return t - e.ZOOM_OFFSET;
+	}
+	getViewportState() {
+		if (this.mapInstance) {
+			let e = this.mapInstance.getView();
+			return {
+				center: l(e.getCenter() || [0, 0]),
+				zoom: this.fromOLZoom(e.getZoom() || 1),
+				bearing: this.toLogicalBearing(e),
+				pitch: 0
+			};
+		}
+		return {
+			center: [0, 0],
+			zoom: 1,
+			bearing: 0,
+			pitch: 0
+		};
+	}
+	setViewport(e, t) {
+		if (this.mapInstance) {
+			let n = this.clampZoom(t);
+			this.mapInstance.getView().animate({
+				center: c(e),
+				zoom: this.toOLZoom(n),
+				duration: 500
+			}), n !== t && this.scheduleViewportSync();
+		}
+	}
+	initialize(e, t) {
+		let n = t?.center ?? this.initialConfig.center, r = t?.zoom ?? this.initialConfig.zoom, i = this.toOLZoom(r);
+		this.minZoom = t?.minZoom, this.maxZoom = t?.maxZoom;
+		let a = t?.minZoom, o = t?.maxZoom, s = this.resolveContainer(e), u = {
+			center: c(n),
+			zoom: i
+		};
+		a !== void 0 && (u.minZoom = this.toOLZoom(a)), o !== void 0 && (u.maxZoom = this.toOLZoom(o)), this.mapInstance = new d({
+			target: s,
+			layers: [],
+			view: new f({ ...u }),
+			controls: [],
+			keyboardEventTarget: document
+		});
+		let m = this.mapInstance.getViewport();
+		if (m && (m.tabIndex = -1), t?.styleUrl) p(this.mapInstance, t.styleUrl).catch((e) => {
+			console.error("[OL CORE] Failed to apply style from URL:", e);
+		});
+		else if (t?.style) {
+			let e = {
+				version: 8,
+				...t.style
+			};
+			Array.isArray(e.layers) && e.layers.length > 0 && p(this.mapInstance, e).catch((e) => {
+				console.error("[OL CORE] Failed to apply inline style:", e);
+			});
+		}
+		this.mapInstance.once("rendercomplete", () => {
+			let e = this.buildViewportFeature();
+			this.store.dispatch({
+				mapLoaded: !0,
+				zoomLevel: r,
+				mapCenter: n,
+				mapViewportBounds: e
+			}, "MAP"), this.flushMapReadyCallbacks();
+		}), this.attachLoadingEvents(this.mapInstance);
+		let h = this.mapInstance.getView();
+		h.on("change:resolution", () => {
+			let e = this.fromOLZoom(h.getZoom() || 0), t = this.buildViewportFeature();
+			this.store.dispatch({
+				zoomLevel: e,
+				mapViewportBounds: t
+			}, "MAP"), this.eventBus?.emit({
+				type: "zoom-end",
+				zoom: e
+			});
+		}), h.on("change:center", () => {
+			let e = l(h.getCenter() || [0, 0]), t = this.fromOLZoom(h.getZoom() || 0), n = this.buildViewportFeature();
+			this.store.dispatch({
+				mapCenter: e,
+				zoomLevel: t,
+				mapViewportBounds: n
+			}, "MAP");
+		}), h.on("change:rotation", () => {
+			let e = l(h.getCenter() || [0, 0]), t = this.fromOLZoom(h.getZoom() || 0), n = this.buildViewportFeature();
+			this.store.dispatch({
+				mapCenter: e,
+				zoomLevel: t,
+				mapViewportBounds: n
+			}, "MAP"), this.emitViewChange();
+		}), this.mapInstance.on("moveend", () => {
+			this.emitViewChangeEnd();
+		}), this.mapInstance.on("pointerdrag", () => {
+			this.dispatchViewportBoundsSnapshot(), this.emitViewChange();
+		}), this.attachPointerEvents(this.mapInstance);
+	}
+	attachPointerEvents(e) {
+		e.on("pointermove", (e) => {
+			if (e.dragging && !this.panDisabled) return;
+			let t = l(e.coordinate), n = [e.pixel[0], e.pixel[1]], r = this.computePointerResolution();
+			this.eventBus?.emit({
+				type: "pointer-move",
+				coords: t,
+				pixel: n,
+				resolution: r,
+				originalEvent: e.originalEvent
+			}), this.store.dispatch({
+				pointerCoordinates: t,
+				pointerResolution: r
+			}, "MAP");
+		}), e.getViewport().addEventListener("mouseout", (e) => {
+			this.eventBus?.emit({
+				type: "pointer-leave",
+				originalEvent: e
+			}), this.store.dispatch({
+				pointerCoordinates: null,
+				pointerResolution: null
+			}, "MAP");
+		}), e.on("click", (e) => {
+			let t = l(e.coordinate), n = [e.pixel[0], e.pixel[1]], r = this.computePointerResolution();
+			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 = l(e.coordinate), n = [e.pixel[0], e.pixel[1]];
+			this.eventBus?.emit({
+				type: "dblclick",
+				coords: t,
+				pixel: n,
+				originalEvent: e.originalEvent
+			});
+		}), e.getViewport().addEventListener("pointerdown", (t) => {
+			let n = e.getEventPixel(t), r = e.getCoordinateFromPixel(n);
+			if (!r) return;
+			let i = l(r);
+			this.eventBus?.emit({
+				type: "pointer-down",
+				coords: i,
+				pixel: n,
+				button: t.button,
+				originalEvent: t
+			});
+		}), e.getViewport().addEventListener("pointerup", (t) => {
+			let n = e.getEventPixel(t), r = e.getCoordinateFromPixel(n);
+			if (!r) return;
+			let i = l(r);
+			this.eventBus?.emit({
+				type: "pointer-up",
+				coords: i,
+				pixel: n,
+				button: t.button,
+				originalEvent: t
+			});
+		}), e.getViewport().addEventListener("pointercancel", () => {
+			this.eventBus?.emit({ type: "pointer-cancel" });
+		}), e.getViewport().addEventListener("contextmenu", (t) => {
+			t.preventDefault();
+			let n = e.getEventPixel(t), r = e.getCoordinateFromPixel(n);
+			if (r) {
+				let e = l(r);
+				this.eventBus?.emit({
+					type: "contextmenu",
+					coords: e,
+					pixel: [n[0], n[1]],
+					originalEvent: t
+				});
+			}
+		});
+	}
+	computePointerResolution() {
+		if (!this.mapInstance) return null;
+		let e = this.mapInstance.getView().getResolution();
+		if (!e) return null;
+		let t = e / 111320;
+		return {
+			lng: t,
+			lat: t
+		};
+	}
+	emitViewChange() {
+		if (!this.eventBus || !this.mapInstance) return;
+		let e = this.mapInstance.getView(), t = l(e.getCenter() || [0, 0]), n = e.calculateExtent(this.mapInstance.getSize()), r = l([n[0], n[1]]), i = l([n[2], n[3]]);
+		this.eventBus.emit({
+			type: "view-change",
+			center: t,
+			zoom: this.fromOLZoom(e.getZoom() || 0),
+			bearing: this.toLogicalBearing(e),
+			pitch: 0,
+			bounds: {
+				sw: r,
+				ne: i
+			}
+		});
+	}
+	emitViewChangeEnd() {
+		if (!this.eventBus || !this.mapInstance) return;
+		let e = this.mapInstance.getView(), t = l(e.getCenter() || [0, 0]), n = e.calculateExtent(this.mapInstance.getSize()), r = l([n[0], n[1]]), i = l([n[2], n[3]]);
+		this.eventBus.emit({
+			type: "view-change-end",
+			center: t,
+			zoom: this.fromOLZoom(e.getZoom() || 0),
+			bearing: this.toLogicalBearing(e),
+			pitch: 0,
+			bounds: {
+				sw: r,
+				ne: i
+			}
+		});
+	}
+	setZoom(e) {
+		if (this.mapInstance) {
+			let t = this.clampZoom(e), n = this.mapInstance.getView();
+			if (this.fromOLZoom(n.getZoom() || 0) === t && t !== e) {
+				this.scheduleViewportSync();
+				return;
+			}
+			n.setZoom(this.toOLZoom(t));
+		}
+	}
+	getZoom() {
+		return this.fromOLZoom(this.mapInstance?.getView().getZoom() || this.toOLZoom(this.initialConfig.zoom));
+	}
+	getNavigationCapabilities() {
+		return {
+			bearing: !0,
+			pitch: !1
+		};
+	}
+	getBearing() {
+		let e = this.mapInstance?.getView();
+		return e ? this.toLogicalBearing(e) : 0;
+	}
+	setBearing(e) {
+		let t = this.mapInstance?.getView();
+		t && t.setRotation(-e * Math.PI / 180);
+	}
+	getPitch() {
+		return 0;
+	}
+	setPitch(e) {}
+	setTerrainEnabled(e) {
+		return !1;
+	}
+	isTerrainEnabled() {
+		return null;
+	}
+	resetNorth() {
+		this.setBearing(0);
+	}
+	resetNorthPitch() {
+		this.resetNorth();
+	}
+	setProjection(e) {
+		return !1;
+	}
+	getProjection() {
+		return null;
+	}
+	scheduleViewportSync() {
+		this.mapInstance && requestAnimationFrame(() => {
+			if (!this.mapInstance) return;
+			let e = this.mapInstance.getView(), t = l(e.getCenter() || [0, 0]), n = this.fromOLZoom(e.getZoom() || 0), r = this.buildViewportFeature();
+			this.store.dispatch({
+				zoomLevel: n,
+				mapCenter: t,
+				mapViewportBounds: r
+			}, "MAP"), this.emitViewChangeEnd();
+		});
+	}
+	clampZoom(e) {
+		let t = e;
+		return this.minZoom !== void 0 && (t = Math.max(t, this.minZoom)), this.maxZoom !== void 0 && (t = Math.min(t, this.maxZoom)), t;
+	}
+	setLayerOrderRegistry(e) {
+		this.layerOrderRegistry = e;
+	}
+	addLayer(e, t) {
+		if (!this.mapInstance) return !1;
+		let n = e.source, r = this.sources.get(n);
+		if (!r) return console.error(`[OL CORE] Source "${n}" not found for layer "${e.id}".`), !1;
+		let i = e?.metadata && typeof e.metadata == "object" ? e.metadata : {};
+		r.olLayer.__mapLayerId = typeof i.mapLayerId == "string" ? i.mapLayerId : e.id, this.layerOrderRegistry?.registerInlineLayer(r.olLayer.__mapLayerId ?? e.id, r.olLayer, t);
+		let a = t?.beforeLayerId, o = t?.afterLayerId;
+		if (typeof a == "string") {
+			let t = r.layers.findIndex((e) => e?.id === a);
+			t >= 0 ? r.layers.splice(t, 0, e) : r.layers.push(e);
+		} else if (typeof o == "string") {
+			let t = r.layers.findIndex((e) => e?.id === o);
+			t >= 0 ? r.layers.splice(t + 1, 0, e) : r.layers.push(e);
+		} else r.layers.push(e);
+		return this.updateStyle(n), !0;
+	}
+	removeLayer(e) {
+		for (let [t, n] of this.sources.entries()) {
+			let r = n.layers.findIndex((t) => t.id === e);
+			if (r > -1) {
+				n.layers.splice(r, 1), n.layers.length === 0 ? (this.mapInstance?.removeLayer(n.olLayer), this.sources.delete(t), this.layerOrderRegistry?.unregisterInlineLayer(e)) : this.updateStyle(t);
+				return;
+			}
+		}
+	}
+	addSource(e, t) {
+		if (this.sources.has(e)) return;
+		let n = new g({ features: new _().readFeatures(t.data, {
+			dataProjection: "EPSG:4326",
+			featureProjection: "EPSG:3857"
+		}) });
+		n.set("_webmapx_source_id", e);
+		let r = new h({ source: n });
+		this.sources.set(e, {
+			source: n,
+			layers: [],
+			olLayer: r
+		}), this.mapInstance?.addLayer(r);
+	}
+	removeSource(e) {
+		let t = this.sources.get(e);
+		t && (this.mapInstance?.removeLayer(t.olLayer), this.sources.delete(e));
+	}
+	getSource(e) {
+		let t = this.sources.get(e);
+		if (t) return {
+			id: e,
+			setData: (e) => {
+				t.source.clear(), t.source.addFeatures(new _().readFeatures(e, {
+					dataProjection: "EPSG:4326",
+					featureProjection: "EPSG:3857"
+				}));
+			}
+		};
+	}
+	project(e) {
+		if (!this.mapInstance) return console.warn("[CORE SERVICE - OpenLayers] project called before map instance is ready."), [0, 0];
+		let t = c(e), n = this.mapInstance.getPixelFromCoordinate(t);
+		return n ? [n[0], n[1]] : [0, 0];
+	}
+	unproject(e) {
+		if (!this.mapInstance) return null;
+		let t = this.mapInstance.getCoordinateFromPixel([e[0], e[1]]);
+		return t ? l(t) : null;
+	}
+	fitBounds(e) {
+		if (!this.mapInstance) return;
+		let t = c([e[0], e[1]]), n = c([e[2], e[3]]), r = [
+			t[0],
+			t[1],
+			n[0],
+			n[1]
+		];
+		this.mapInstance.getView().fit(r, {
+			size: this.mapInstance.getSize(),
+			padding: [
+				40,
+				40,
+				40,
+				40
+			],
+			duration: 300
+		});
+	}
+	setCursor(e) {
+		if (!this.mapInstance) return;
+		let t = this.mapInstance.getViewport();
+		t.style.cursor = e;
+	}
+	setPanEnabled(e) {
+		this.mapInstance && (this.panDisabled = !e, this.mapInstance.getInteractions().forEach((t) => {
+			t.constructor?.name === "DragPan" && t.setActive(e);
+		}));
+	}
+	setTouchCaptureEnabled(e) {
+		if (!this.mapInstance) return;
+		let t = this.mapInstance.getViewport();
+		t.style.touchAction = e ? "" : "none";
+	}
+	setDoubleClickZoomEnabled(e) {}
+	setLayerVisibility(e, t) {
+		let n = this.sources.get(e);
+		n?.olLayer && n.olLayer.setVisible(t);
+	}
+	getSourceData(e) {
+		let t = this.sources.get(e);
+		if (!t) return null;
+		let n = new _();
+		return {
+			type: "FeatureCollection",
+			features: t.source.getFeatures().map((e) => JSON.parse(n.writeFeature(e, {
+				dataProjection: "EPSG:4326",
+				featureProjection: "EPSG:3857"
+			})))
+		};
+	}
+	updateStyle(e) {
+		let t = this.sources.get(e);
+		if (!t) return;
+		let n = {
+			version: 8,
+			sources: { [e]: { type: "geojson" } },
+			layers: t.layers
+		};
+		m(t.olLayer, n, e);
+	}
+	suppressBusySignalForSource(e) {
+		this.silentSourceIds.add(e);
+	}
+	unsuppressBusySignalForSource(e) {
+		this.silentSourceIds.delete(e);
+	}
+	onMapReady(e) {
+		if (this.mapInstance) {
+			e(this.mapInstance);
+			return;
+		}
+		this.mapReadyCallbacks.push(e);
+	}
+	flushMapReadyCallbacks() {
+		this.mapInstance && this.mapReadyCallbacks.splice(0).forEach((e) => {
+			try {
+				e(this.mapInstance);
+			} catch (e) {
+				console.error("[OL CORE SERVICE] mapReady callback failed.", e);
+			}
+		});
+	}
+	attachLoadingEvents(e) {
+		let t = (e) => {
+			let t = e.getSource?.();
+			if (!t) return;
+			let n = t.get?.("_webmapx_source_id");
+			t.on?.("tileloadstart", () => {
+				n && this.silentSourceIds.has(n) || (this.pendingTileLoads++, this.store.dispatch({ mapBusy: !0 }, "MAP"));
+			});
+			let r = () => {
+				this.pendingTileLoads = Math.max(0, this.pendingTileLoads - 1), this.pendingTileLoads === 0 && this.store.dispatch({ mapBusy: !1 }, "MAP");
+			};
+			t.on?.("tileloadend", r), t.on?.("tileloaderror", r);
+		};
+		e.getLayers().forEach(t), e.getLayers().on("add", (e) => {
+			t(e.element);
+		}), e.on("rendercomplete", () => {
+			this.pendingTileLoads === 0 && this.store.dispatch({ mapBusy: !1 }, "MAP");
+		}), e.on("loadstart", () => {
+			this.store.dispatch({ mapBusy: !0 }, "MAP");
+		});
+	}
+	dispatchViewportBoundsSnapshot() {
+		let e = this.buildViewportFeature();
+		this.store.dispatch({ mapViewportBounds: e }, "MAP");
+	}
+	buildViewportFeature() {
+		if (!this.mapInstance) return null;
+		let e = this.mapInstance.getView(), t = this.mapInstance.getSize();
+		if (!t) return null;
+		let n = [], r = e.getCenter(), i = e.getResolution();
+		if (r && typeof i == "number") {
+			let a = e.getRotation(), o = t[0] * i / 2, s = t[1] * i / 2, c = Math.cos(a), u = Math.sin(a), d = (e, t) => l([r[0] + e * c - t * u, r[1] + e * u + t * c]);
+			n.push(d(-o, -s), d(o, -s), d(o, s), d(-o, s));
+		}
+		if (n.length === 0) {
+			let r = e.calculateExtent(t), i = l([r[0], r[1]]), a = l([r[2], r[3]]);
+			n.push([i[0], i[1]], [i[0], a[1]], [a[0], a[1]], [a[0], i[1]]);
+		}
+		return n.length > 0 && n.push(n[0]), {
+			type: "Feature",
+			properties: { role: "mapViewport" },
+			geometry: {
+				type: "Polygon",
+				coordinates: [n]
+			}
+		};
+	}
+	resolveContainer(e) {
+		let t = document.getElementById(e);
+		if (!t) throw Error(`Container #${e} not found.`);
+		if (t.tagName.toLowerCase() === "webmapx-map") {
+			let e = t.querySelector("[slot=\"map-view\"]");
+			if (e) return e;
+		}
+		return t;
+	}
+}, P = class {
+	constructor() {}
+	setBufferRadius(e) {
+		console.log(`[OL SERVICE] Set buffer radius to ${e}km.`);
+	}
+	toggleTool() {
+		console.log("[OL SERVICE] Toggled tool activation.");
+	}
+}, F = class {
+	constructor(e, t) {
+		this.id = e, this.source = t;
+	}
+	setData(e) {
+		this.source.clear();
+		let t = new _().readFeatures(e, { featureProjection: "EPSG:3857" });
+		this.source.addFeatures(t);
+	}
+}, I = class {
+	constructor(e, t, n, r) {
+		this.id = e, this.layer = t, this.sourceId = n, this.map = r;
+	}
+	getSource() {
+		return new F(this.sourceId, this.layer.getSource());
+	}
+	remove() {
+		this.map.removeLayer(this.layer);
+	}
+}, L = 1, R = class {
+	constructor(e) {
+		this.map = e, this.sources = new globalThis.Map(), this.layers = new globalThis.Map();
+	}
+	setViewport(e, t, n, r) {
+		this.map.getView().animate({
+			center: c(e),
+			zoom: t + L,
+			rotation: n ? n * Math.PI / 180 : 0,
+			duration: 0
+		});
+	}
+	createSource(e, t) {
+		if (!this.sources.has(e)) {
+			let n = new g({ features: new _().readFeatures(t, { featureProjection: "EPSG:3857" }) });
+			this.sources.set(e, n);
+		}
+		return new F(e, this.sources.get(e));
+	}
+	getSource(e) {
+		let t = this.sources.get(e);
+		return t ? new F(e, t) : null;
+	}
+	createLayer(e) {
+		if (!this.layers.has(e.id)) {
+			let t = this.sources.get(e.sourceId);
+			if (!t) throw Error(`Source "${e.sourceId}" not found. Create source before layer.`);
+			let n = new h({
+				source: t,
+				style: this.createStyle(e)
+			});
+			n.__layerId = e.id, this.map.addLayer(n), this.layers.set(e.id, n);
+		}
+		return new I(e.id, this.layers.get(e.id), e.sourceId, this.map);
+	}
+	getLayer(e) {
+		let t = this.layers.get(e);
+		return t ? new I(e, t, Array.from(this.sources.entries()).find(([e, n]) => n === t.getSource())?.[0] ?? "", this.map) : null;
+	}
+	onReady(e) {
+		this.map.once("rendercomplete", e), setTimeout(() => {
+			this.map.getView() && e();
+		}, 0);
+	}
+	destroy() {
+		this.map.setTarget(void 0), this.sources.clear(), this.layers.clear();
+	}
+	createStyle(e) {
+		let t = e.paint || {};
+		switch (e.type) {
+			case "fill": return new C({
+				fill: new x({ color: this.toRgba(t["fill-color"] || "#000000", t["fill-opacity"] ?? 1) }),
+				stroke: new S({
+					color: this.toRgba(t["fill-color"] || "#000000", t["fill-opacity"] ?? 1),
+					width: 1
+				})
+			});
+			case "line": return new C({ stroke: new S({
+				color: this.toRgba(t["line-color"] || "#000000", t["line-opacity"] ?? 1),
+				width: t["line-width"] || 1
+			}) });
+			case "circle": return new C({
+				fill: new x({ color: "#3399CC" }),
+				stroke: new S({
+					color: "#fff",
+					width: 1
+				})
+			});
+			default: return new C();
+		}
+	}
+	toRgba(e, t) {
+		if (e.startsWith("#")) {
+			let n = e.slice(1);
+			return `rgba(${parseInt(n.slice(0, 2), 16)}, ${parseInt(n.slice(2, 4), 16)}, ${parseInt(n.slice(4, 6), 16)}, ${t})`;
+		}
+		return e;
+	}
+}, z = class {
+	createMap(e, t) {
+		let n = t?.center ?? [0, 0], r = (t?.zoom ?? 2) + L, i = new d({
+			target: e,
+			layers: [new v({ source: t?.tileUrl || Array.isArray(t?.tileUrls) && t.tileUrls.length > 0 ? new b({
+				...Array.isArray(t?.tileUrls) && t.tileUrls.length > 0 ? { urls: t.tileUrls } : { url: t?.tileUrl },
+				tileSize: t.tileSize ?? 256,
+				attributions: t.tileAttribution
+			}) : new y({ attributions: t?.tileAttribution }) })],
+			view: new f({
+				center: c(n),
+				zoom: r
+			}),
+			controls: []
+		});
+		return t?.interactive === !1 && i.getInteractions().forEach((e) => {
+			e.setActive(!1);
+		}), new R(i);
+	}
+}, B = "warpedmap://", V = class e {
+	static {
+		this.LAYOUT_KEYS = new Set([
+			"text-size",
+			"icon-size",
+			"text-field",
+			"visibility"
+		]);
+	}
+	constructor(e, t) {
+		this.logicalToNative = /* @__PURE__ */ new Map(), this.logicalSourceToNative = /* @__PURE__ */ new Map(), this.nativeLayerToSource = /* @__PURE__ */ new Map(), this.nativeLayerInstances = /* @__PURE__ */ new Map(), this.spriteResourceCache = /* @__PURE__ */ new Map(), this.warpedMapLayers = /* @__PURE__ */ new Map(), this.compositeSubLayerCache = /* @__PURE__ */ new Map(), this.styleBackedLayerCache = /* @__PURE__ */ new Map(), this.sourceIdCounter = 0, this.map = e, this.store = t;
+	}
+	findLayerIndexByInstance(e) {
+		return this.map.getLayers().getArray().findIndex((t) => t === e);
+	}
+	resolveInsertIndexFromOptions(e) {
+		if (e?.beforeLayerId) {
+			let t = this.logicalToNative.get(e.beforeLayerId) ?? [];
+			for (let e of t) {
+				let t = this.nativeLayerInstances.get(e);
+				if (!t) continue;
+				let n = this.findLayerIndexByInstance(t);
+				if (n >= 0) return n;
+			}
+			let n = this.map.getLayers().getArray().findIndex((t) => t.__mapLayerId === e.beforeLayerId);
+			if (n >= 0) return n;
+		}
+		if (e?.afterLayerId) {
+			let t = this.logicalToNative.get(e.afterLayerId) ?? [];
+			for (let e = t.length - 1; e >= 0; --e) {
+				let n = this.nativeLayerInstances.get(t[e]);
+				if (!n) continue;
+				let r = this.findLayerIndexByInstance(n);
+				if (r >= 0) return r + 1;
+			}
+			let n = this.map.getLayers().getArray().findIndex((t) => t.__mapLayerId === e.afterLayerId);
+			if (n >= 0) return n + 1;
+		}
+	}
+	resolveInsertIndex(e) {
+		let t = this.resolveInsertIndexFromOptions(e);
+		if (t !== void 0) return t;
+		let n = e?.beforeLayerId ?? e?.afterLayerId;
+		if (!n) return;
+		let r = e?.beforeLayerId !== void 0, i = 0;
+		for (let [e, t] of this.logicalToNative.entries()) {
+			if (e === n) return r ? i : i + t.length;
+			for (let e of t) this.nativeLayerInstances.has(e) && i++;
+		}
+	}
+	addMapLayerAtIndex(e, t) {
+		if (typeof t != "number" || !Number.isFinite(t)) {
+			this.map.addLayer(e);
+			return;
+		}
+		let n = this.map.getLayers(), r = Math.max(0, Math.min(t, n.getLength()));
+		return n.insertAt(r, e), r + 1;
+	}
+	getOrCreateNativeSourceId(e) {
+		if (this.logicalSourceToNative.has(e.id)) return this.logicalSourceToNative.get(e.id);
+		let t = `src-${e.id}-${this.sourceIdCounter++}`;
+		return this.logicalSourceToNative.set(e.id, t), t;
+	}
+	isWarpedMapSource(e) {
+		return e.type === "raster" && "url" in e ? (Array.isArray(e.url) ? e.url[0] : e.url).startsWith(B) : !1;
+	}
+	parseWarpedMapUrl(e) {
+		return e.startsWith(B) ? "https://" + e.slice(12) : e;
+	}
+	async addWarpedMapLayer(e, t, n) {
+		let { WarpedMapLayer: r } = await import("./dist-BIbq3o-p.js"), i = `warpedmap-${e}`, a = new r(), o = a;
+		return typeof o.getDeclutter != "function" && (o.getDeclutter = () => !1), typeof o.renderDeferred != "function" && (o.renderDeferred = () => {}), this.addMapLayerAtIndex(a, n), await a.addGeoreferenceAnnotationByUrl(t), this.warpedMapLayers.set(e, a), this.nativeLayerInstances.set(i, a), this.logicalToNative.set(e, [i]), !0;
+	}
+	async addLayer(e, r) {
+		let i = e.id, a = this.resolveInsertIndex(r);
+		if (e.type === "allmaps") return this.addWarpedMapLayer(i, e.annotation, a);
+		if (e.type === "style") {
+			let t = n(e);
+			return t ? this.addCompositeLayer(t, r) : !1;
+		}
+		let o = e;
+		if (!o.source) return !1;
+		let s = e.sources?.[o.source], c = s ? t(o.source, s) : null;
+		if (!c) return !1;
+		if (this.isWarpedMapSource(c)) {
+			let e = Array.isArray(c.url) ? c.url[0] : c.url, t = this.parseWarpedMapUrl(e);
+			return this.addWarpedMapLayer(i, t, a);
+		}
+		let l = this.getOrCreateNativeSourceId(c), u = [], d = `${i}-${c.id}-${o.type}`;
+		if (!this.nativeLayerInstances.has(d)) {
+			let e = await this.createLayer(d, o, c);
+			e && (e.__mapLayerId = i, a = this.addMapLayerAtIndex(e, a), this.nativeLayerInstances.set(d, e));
+		}
+		return u.push(d), this.nativeLayerToSource.set(d, l), this.logicalToNative.set(i, this.mergeNativeLayerIds(i, u)), u.length > 0;
+	}
+	async addCompositeLayer(e, t) {
+		let n = e.styleId, r = this.resolveInsertIndex(t), i = e.rawConfig, o = [], s = e.sources.filter((e) => e.config.type === "vector");
+		if (s.length > 0 && typeof e.metadata?.styleUrl == "string") for (let e of s) {
+			if (!this.isStyleBackedVectorSource(i, e.config)) continue;
+			let t = this.getOrCreateNativeSourceId(e.config), a = `${n}-${e.config.id}-vector-style`;
+			if (!this.nativeLayerInstances.has(a)) {
+				let t = await this.createStyleBackedVectorTileLayer(a, i, e.config);
+				if (!t) return !1;
+				let { layer: o, mapboxLayerIds: s, spriteResources: c } = t;
+				o.__mapLayerId = n, r = this.addMapLayerAtIndex(o, r), this.nativeLayerInstances.set(a, o), this.styleBackedLayerCache.set(a, {
+					layer: o,
+					layerConfig: i,
+					sourceConfig: e.config,
+					mapboxLayerIds: s,
+					spriteResources: c
+				});
+			}
+			o.push(a), this.nativeLayerToSource.set(a, t);
+		}
+		else for (let t of e.subLayers) {
+			let i = a(e, t.source);
+			if (!i) continue;
+			let s = this.getOrCreateNativeSourceId(i.config), c = `${n}-${t.id}`;
+			if (!this.nativeLayerInstances.has(c)) {
+				let e = await this.createLayer(c, t, i.config);
+				e && (e.__mapLayerId = n, r = this.addMapLayerAtIndex(e, r), this.nativeLayerInstances.set(c, e), this.compositeSubLayerCache.set(c, {
+					spec: t,
+					sourceConfig: i.config
+				}));
+			}
+			o.push(c), this.nativeLayerToSource.set(c, s);
+		}
+		return this.logicalToNative.set(n, this.mergeNativeLayerIds(n, o)), o.length > 0;
+	}
+	updateLayerStyle(e, t, n) {
+		let r = `${e}-${t}`, i = this.compositeSubLayerCache.get(r), a = this.nativeLayerInstances.get(r);
+		if (!i || !a) return this.updateStyleBackedSubLayer(e, t, n);
+		let o = {
+			...i.spec,
+			paint: {
+				...i.spec.paint ?? {},
+				...n
+			}
+		}, s = this.findLayerIndexByInstance(a);
+		return this.createLayer(r, o, i.sourceConfig).then((e) => {
+			if (!e) return;
+			e.__mapLayerId = a.__mapLayerId;
+			let t = this.map.getLayers(), n = this.findLayerIndexByInstance(a);
+			n >= 0 ? (t.removeAt(n), t.insertAt(n, e)) : s >= 0 ? t.insertAt(Math.min(s, t.getLength()), e) : this.map.addLayer(e), this.nativeLayerInstances.set(r, e), this.compositeSubLayerCache.set(r, {
+				spec: o,
+				sourceConfig: i.sourceConfig
+			});
+		}), !0;
+	}
+	updateStyleBackedSubLayer(t, n, r) {
+		for (let [i, a] of this.styleBackedLayerCache) {
+			if (!i.startsWith(`${t}-`)) continue;
+			let o = (a.layerConfig.layers ?? []).find((e) => e.id === n);
+			if (!o) continue;
+			for (let [t, n] of Object.entries(r)) e.LAYOUT_KEYS.has(t) ? o.layout = {
+				...o.layout ?? {},
+				[t]: n
+			} : o.paint = {
+				...o.paint ?? {},
+				[t]: n
+			};
+			let s = this.buildStyleBackedGlStyle(a.layerConfig, a.sourceConfig);
+			return m(a.layer, s, a.mapboxLayerIds, void 0, a.spriteResources?.spriteData, a.spriteResources?.spriteImageUrl), a.layer.changed(), !0;
+		}
+		return !1;
+	}
+	mergeNativeLayerIds(e, t) {
+		let n = this.logicalToNative.get(e) ?? [];
+		return Array.from(new Set([...n, ...t]));
+	}
+	isStyleBackedVectorSource(e, t) {
+		let n = e?.metadata;
+		return t.type === "vector" && typeof n?.styleUrl == "string" && e.type === "style" && Array.isArray(e.layers) && e.layers.length > 0;
+	}
+	async createStyleBackedVectorTileLayer(e, t, n) {
+		let r = await this.resolveVectorTileSourceInfo(n);
+		if (!r) return null;
+		let { urlTemplate: i, minZoom: a, maxZoom: o } = r, s = new w({
+			source: new T({
+				format: new E(),
+				attributions: n.attribution,
+				...a === void 0 ? {} : { minZoom: a },
+				...o === void 0 ? {} : { maxZoom: o },
+				...o === void 0 ? { url: i } : { tileUrlFunction: this.createClampedVectorTileUrlFunction(i, o) }
+			}),
+			declutter: !0
+		}), c = this.buildStyleBackedGlStyle(t, n), l = await this.resolveStyleSpriteResources(t?.metadata ?? {}), u = (t.type === "style" ? t.layers ?? [] : []).map((e) => typeof e.id == "string" ? e.id : null).filter((e) => typeof e == "string" && e.length > 0), d = u.length > 0 ? u : n.id;
+		return m(s, c, d, void 0, l?.spriteData, l?.spriteImageUrl), s.__layerId = e, {
+			layer: s,
+			mapboxLayerIds: d,
+			spriteResources: l ?? null
+		};
+	}
+	buildStyleBackedGlStyle(e, t) {
+		let n = e?.metadata ?? {}, r = e.type === "style" ? e.layers ?? [] : [], i = { type: "vector" };
+		typeof t.url == "string" && t.url.length > 0 && (i.url = t.url);
+		let a = Array.isArray(t.tiles) ? t.tiles.filter((e) => typeof e == "string" && e.length > 0) : [];
+		return a.length > 0 && (i.tiles = a), typeof t.minzoom == "number" && (i.minzoom = t.minzoom), typeof t.attribution == "string" && (i.attribution = t.attribution), {
+			version: 8,
+			...typeof n.styleSpriteUrl == "string" ? { sprite: n.styleSpriteUrl } : {},
+			...typeof n.styleGlyphsUrl == "string" ? { glyphs: n.styleGlyphsUrl } : {},
+			sources: { [t.id]: i },
+			layers: r.map((e) => ({
+				id: e.id,
+				type: e.type,
+				source: t.id,
+				...typeof e["source-layer"] == "string" ? { "source-layer": e["source-layer"] } : {},
+				...typeof e.minzoom == "number" ? { minzoom: e.minzoom } : {},
+				...typeof e.maxzoom == "number" ? { maxzoom: e.maxzoom } : {},
+				...e.filter ? { filter: e.filter } : {},
+				...e.layout ? { layout: e.layout } : {},
+				...e.paint ? { paint: e.paint } : {}
+			}))
+		};
+	}
+	async resolveStyleSpriteResources(e) {
+		let t = typeof e.styleSpriteUrl == "string" ? e.styleSpriteUrl : null;
+		return t ? (this.spriteResourceCache.has(t) || this.spriteResourceCache.set(t, (async () => {
+			try {
+				let e = this.buildSpriteAssetUrl(t, ".json"), n = await fetch(e);
+				if (!n.ok) return null;
+				let r = await n.json();
+				return typeof r != "object" || !r || Array.isArray(r) ? null : {
+					spriteData: r,
+					spriteImageUrl: this.buildSpriteAssetUrl(t, ".png")
+				};
+			} catch {
+				return null;
+			}
+		})()), this.spriteResourceCache.get(t) ?? null) : null;
+	}
+	buildSpriteAssetUrl(e, t) {
+		try {
+			let n = new URL(e);
+			return n.pathname.endsWith(t) || (n.pathname = `${n.pathname}${t}`), n.toString();
+		} catch {
+			return e.endsWith(t) ? e : `${e}${t}`;
+		}
+	}
+	async createLayer(e, t, n) {
+		if (t.type === "raster" && n.type === "raster") {
+			if (n.service === "xyz") return this.createXYZLayer(e, n, t);
+			if (n.service === "wms") return this.createWMSLayer(e, n, t);
+		} else if ([
+			"fill",
+			"line",
+			"circle"
+		].includes(t.type) && n.type === "geojson") return this.createGeoJSONLayer(e, n, t);
+		else if ([
+			"fill",
+			"line",
+			"circle",
+			"symbol"
+		].includes(t.type) && n.type === "vector") return this.createVectorTileLayer(e, n, t);
+		return null;
+	}
+	async resolveVectorTileUrl(e) {
+		return (await this.resolveVectorTileSourceInfo(e))?.urlTemplate ?? null;
+	}
+	async resolveVectorTileSourceInfo(e) {
+		let t = typeof e.minzoom == "number" ? e.minzoom : void 0, n = typeof e.maxzoom == "number" ? e.maxzoom : void 0, r = Array.isArray(e.tiles) ? e.tiles.filter((e) => typeof e == "string") : [];
+		if (r.length > 0) return {
+			urlTemplate: r[0],
+			...t === void 0 ? {} : { minZoom: t },
+			...n === void 0 ? {} : { maxZoom: n }
+		};
+		let i = e.url;
+		if (typeof i != "string" || i.length === 0) return null;
+		if (i.includes("{z}") && i.includes("{x}") && i.includes("{y}")) return {
+			urlTemplate: i,
+			...t === void 0 ? {} : { minZoom: t },
+			...n === void 0 ? {} : { maxZoom: n }
+		};
+		try {
+			let e = await fetch(i);
+			if (!e.ok) return null;
+			let r = await e.json();
+			if (Array.isArray(r?.tiles)) {
+				let e = r.tiles.find((e) => typeof e == "string");
+				if (typeof e == "string") return {
+					urlTemplate: e,
+					...t === void 0 ? typeof r?.minzoom == "number" ? { minZoom: r.minzoom } : {} : { minZoom: t },
+					...n === void 0 ? typeof r?.maxzoom == "number" ? { maxZoom: r.maxzoom } : {} : { maxZoom: n }
+				};
+			}
+		} catch {
+			return null;
+		}
+		return null;
+	}
+	createClampedVectorTileUrlFunction(e, t) {
+		let n = j(e, null);
+		return (e, r, i) => {
+			if (!e || e.length < 3) return;
+			let [a, o, s] = e;
+			if (!Number.isInteger(a) || !Number.isInteger(o) || !Number.isInteger(s) || a <= t) return n(e, r, i);
+			let c = 2 ** (a - t);
+			return n([
+				t,
+				Math.floor(o / c),
+				Math.floor(s / c)
+			], r, i);
+		};
+	}
+	createBboxTileUrlFunction(e) {
+		let t = A();
+		return (n) => {
+			if (!n || n.length < 3) return;
+			let [, r, i] = n, a = t.getTileCoordExtent(n).join(",");
+			return e[Math.abs(r + i) % e.length].replace("{bbox-epsg-3857}", a);
+		};
+	}
+	getLiteralNumberValue(e, t) {
+		return typeof e == "number" && Number.isFinite(e) ? e : t;
+	}
+	createVectorTileLayer(e, t, n) {
+		return this.resolveVectorTileSourceInfo(t).then((r) => {
+			if (!r) return null;
+			let { urlTemplate: i, minZoom: a, maxZoom: o } = r, s = new w({
+				source: new T({
+					format: new E(),
+					attributions: t.attribution,
+					...a === void 0 ? {} : { minZoom: a },
+					...o === void 0 ? {} : { maxZoom: o },
+					...o === void 0 ? { url: i } : { tileUrlFunction: this.createClampedVectorTileUrlFunction(i, o) }
+				}),
+				minZoom: n.minzoom,
+				maxZoom: n.maxzoom
+			}), c = e, l = n.id ?? e;
+			return m(s, {
+				version: 8,
+				sources: { [c]: {
+					type: "vector",
+					tiles: [i]
+				} },
+				layers: [{
+					...n,
+					id: l,
+					source: c
+				}]
+			}, [l]), s.__layerId = e, s;
+		});
+	}
+	createXYZLayer(e, t, n) {
+		let r = Array.isArray(t.url) ? t.url : [t.url], i = new v({
+			source: r.some((e) => e.includes("{bbox-epsg-3857}")) ? new b({
+				tileUrlFunction: this.createBboxTileUrlFunction(r),
+				tileSize: t.tileSize,
+				attributions: t.attribution,
+				minZoom: t.minzoom,
+				maxZoom: t.maxzoom
+			}) : new b({
+				urls: r,
+				tileSize: t.tileSize,
+				attributions: t.attribution,
+				minZoom: t.minzoom,
+				maxZoom: t.maxzoom
+			}),
+			minZoom: n.minzoom,
+			maxZoom: n.maxzoom,
+			opacity: this.getLiteralNumberValue(n.paint?.["raster-opacity"], 1)
+		});
+		return i.__layerId = e, i;
+	}
+	createWMSLayer(e, t, n) {
+		let r = Array.isArray(t.url) ? t.url[0] : t.url, { baseUrl: i, params: a } = this.parseUrlParams(r), o = new Set(Object.keys(a).map((e) => e.toLowerCase()));
+		o.has("format") || (a.FORMAT = t.format || "image/png"), o.has("transparent") || (a.TRANSPARENT = t.transparent === !1 ? "false" : "true"), t.layers && !o.has("layers") && (a.LAYERS = t.layers), t.styles && !o.has("styles") && (a.STYLES = t.styles), t.version && !o.has("version") && (a.VERSION = t.version);
+		let s;
+		if (t.tileSize) {
+			let e = A({
+				tileSize: t.tileSize,
+				minZoom: t.minzoom,
+				maxZoom: t.maxzoom
+			});
+			s = new v({
+				source: new k({
+					url: i,
+					params: a,
+					attributions: t.attribution,
+					tileGrid: e
+				}),
+				minZoom: n.minzoom,
+				maxZoom: n.maxzoom,
+				opacity: this.getLiteralNumberValue(n.paint?.["raster-opacity"], 1)
+			});
+		} else s = new O({
+			source: new D({
+				url: i,
+				params: a,
+				attributions: t.attribution,
+				ratio: 1
+			}),
+			minZoom: n.minzoom,
+			maxZoom: n.maxzoom,
+			opacity: this.getLiteralNumberValue(n.paint?.["raster-opacity"], 1)
+		});
+		return s.__layerId = e, s;
+	}
+	parseUrlParams(e) {
+		let t = e.indexOf("?");
+		if (t === -1) return {
+			baseUrl: e,
+			params: {}
+		};
+		let n = e.substring(0, t), r = e.substring(t + 1), i = {};
+		for (let e of r.split("&")) {
+			let t = e.indexOf("=");
+			if (t !== -1) {
+				let n = e.substring(0, t);
+				i[n] = decodeURIComponent(e.substring(t + 1));
+			} else e && (i[e] = "");
+		}
+		return {
+			baseUrl: n,
+			params: i
+		};
+	}
+	createGeoJSONLayer(e, t, n) {
+		let r = new h({
+			source: new g({
+				features: typeof t.data == "string" ? void 0 : new _().readFeatures(t.data, { featureProjection: "EPSG:3857" }),
+				url: typeof t.data == "string" ? t.data : void 0,
+				format: typeof t.data == "string" ? new _() : void 0,
+				attributions: t.attribution
+			}),
+			minZoom: n.minzoom,
+			maxZoom: n.maxzoom
+		}), i = e, a = n.id ?? e;
+		return m(r, {
+			version: 8,
+			sources: { [i]: {
+				type: "geojson",
+				data: t.data ?? {
+					type: "FeatureCollection",
+					features: []
+				}
+			} },
+			layers: [{
+				...n,
+				id: a,
+				source: i
+			}]
+		}, [a]), r.__layerId = e, r;
+	}
+	moveLayer(e, t) {
+		let n = (this.logicalToNative.get(e) ?? []).map((e) => this.nativeLayerInstances.get(e)).filter((e) => !!e);
+		if (n.length === 0) return;
+		let r = this.map.getLayers(), i = t ? this.resolveInsertIndex({ beforeLayerId: t }) : void 0;
+		i === void 0 && (i = r.getLength());
+		for (let e of n) {
+			let t = this.findLayerIndexByInstance(e);
+			t !== -1 && (r.removeAt(t), t < i && i--);
+		}
+		i = Math.max(0, Math.min(i, r.getLength())), n.forEach((e, t) => r.insertAt(i + t, e));
+	}
+	removeLayer(e) {
+		if (this.warpedMapLayers.has(e)) {
+			let t = this.warpedMapLayers.get(e);
+			this.map.removeLayer(t);
+			let n = this.logicalToNative.get(e) || [];
+			for (let e of n) this.nativeLayerInstances.delete(e);
+			this.warpedMapLayers.delete(e), this.logicalToNative.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);
+			let r = this.nativeLayerInstances.get(e);
+			r && (this.map.removeLayer(r), this.nativeLayerInstances.delete(e)), this.nativeLayerToSource.delete(e), this.compositeSubLayerCache.delete(e);
+		}
+		this.logicalToNative.delete(e);
+		for (let e of n) {
+			let t = !1;
+			for (let n of this.nativeLayerToSource.values()) if (n === e) {
+				t = !0;
+				break;
+			}
+			if (!t) {
+				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) this.nativeLayerInstances.get(e)?.setVisible(t);
+	}
+	setLayerOpacity(e, t) {
+		let n = this.logicalToNative.get(e) ?? [];
+		for (let e of n) this.nativeLayerInstances.get(e)?.setOpacity(t);
+	}
+	getSourceData(e) {
+		let t = this.logicalSourceToNative.get(e);
+		if (!t) return null;
+		let n = new _();
+		for (let [e, r] of this.nativeLayerToSource.entries()) {
+			if (r !== t) continue;
+			let i = this.nativeLayerInstances.get(e)?.getSource?.();
+			if (!i || typeof i.getFeatures != "function") continue;
+			let a = i.getFeatures().map((e) => JSON.parse(n.writeFeature(e, {
+				dataProjection: "EPSG:4326",
+				featureProjection: "EPSG:3857"
+			})));
+			if (a.length === 0 && typeof i.getUrl == "function") {
+				let e = i.getUrl();
+				if (typeof e == "string") return e;
+			}
+			return {
+				type: "FeatureCollection",
+				features: a
+			};
+		}
+		return null;
+	}
+	setSourceData(e, t) {
+		let n = this.logicalSourceToNative.get(e);
+		if (!n) return !1;
+		let r = !1;
+		for (let [e, i] of this.nativeLayerToSource.entries()) {
+			if (i !== n) continue;
+			let a = this.nativeLayerInstances.get(e)?.getSource?.();
+			!a || typeof a.clear != "function" || (a.clear(), a.addFeatures(new _().readFeatures(t, {
+				dataProjection: "EPSG:4326",
+				featureProjection: "EPSG:3857"
+			})), r = !0);
+		}
+		return r;
+	}
+	registerInlineLayer(e, t, n) {
+		let r = `${e}-inline`;
+		this.nativeLayerInstances.set(r, t), this.logicalToNative.set(e, [r]);
+	}
+	unregisterInlineLayer(e) {
+		let t = this.logicalToNative.get(e) ?? [];
+		for (let e of t) this.nativeLayerInstances.delete(e);
+		this.logicalToNative.delete(e);
+	}
+	getVisibleWMSLayers() {
+		return [];
+	}
+}, H = class {
+	constructor(e, t, n) {
+		this.map = e, this.layerService = t, this.store = n;
+	}
+	async queryFeatures(t, n = {}) {
+		let { pixel: r } = t, i = n.tolerancePx ?? 5, a = [], o = n.layerIds?.length ? new Set(n.layerIds) : null, s = this.store.getState().mapLayers ?? {};
+		this.map.forEachFeatureAtPixel(r, (e, t) => {
+			let n = t?.__layerId, r = this.resolveRegisteredLayerId(t, n, s);
+			if (!r || o && !o.has(r)) return;
+			let i = this.resolveLayerTitle(r, s), c = e.getProperties();
+			delete c.geometry;
+			let l, u, d = -1, f = e.get?.("layer");
+			if (f) {
+				let t = s[r], n = Array.isArray(t?.sublayers) ? t.sublayers : [], i = this.store.getState().zoomLevel ?? 0, a = e.getGeometry?.()?.getType?.(), o = a?.includes("Polygon") ? new Set(["fill", "fill-extrusion"]) : a?.includes("LineString") ? new Set(["line"]) : a?.includes("Point") ? new Set(["circle", "symbol"]) : null, p = o ? [!0, !1] : [!1];
+				outer: for (let e of p) for (let t = n.length - 1; t >= 0; t--) {
+					let r = n[t];
+					if (r?.["source-layer"] !== f && r?.sourceLayer !== f || e && o && !o.has(r?.type) || r?.layout?.visibility === "none") continue;
+					let a = typeof r?.minzoom == "number" ? r.minzoom : 0, s = typeof r?.maxzoom == "number" ? r.maxzoom + 1 : 24;
+					if (!(i < a || i >= s) && !(r?.filter && !this.matchesFilter(r.filter, c))) {
+						l = String(r.id ?? "").replace(/^style:/, ""), u = r.type, d = t;
+						break outer;
+					}
+				}
+			}
+			a.push({
+				layerId: r,
+				...i ? { layerTitle: i } : {},
+				properties: c,
+				source: "vector",
+				...l ? {
+					subLayerId: l,
+					subLayerType: u
+				} : {},
+				_subLayerIndex: d
+			});
+		}, { hitTolerance: i }), a.sort((e, t) => (t._subLayerIndex ?? -1) - (e._subLayerIndex ?? -1));
+		let c = /* @__PURE__ */ new Set(), u = [];
+		for (let e of a) {
+			let t = `${e.layerId}|${e.subLayerId ?? ""}`;
+			c.has(t) || (c.add(t), u.push(e));
+		}
+		if (a.length = 0, a.push(...u.map((e) => {
+			let t = { ...e };
+			return delete t._subLayerIndex, t;
+		})), n.includeWMS) {
+			let t = this.map.getView(), n = this.map.getSize() ?? [0, 0], i = t.calculateExtent(n), s = l([i[0], i[1]]), c = l([i[2], i[3]]), u = {
+				west: s[0],
+				south: s[1],
+				east: c[0],
+				north: c[1]
+			}, d = this.layerService.getVisibleWMSLayers(), f = await Promise.all(d.filter((e) => !o || o.has(e.layerId)).map((t) => e({
+				sourceConfig: t.sourceConfig,
+				layerId: t.layerId,
+				layerTitle: t.layerTitle,
+				bounds: u,
+				containerWidth: n[0],
+				containerHeight: n[1],
+				pixelX: r[0],
+				pixelY: r[1]
+			})));
+			for (let e of f) a.push(...e);
+		}
+		return a;
+	}
+	matchesFilter(e, t) {
+		if (!Array.isArray(e) || e.length === 0) return !0;
+		let n = e[0];
+		if (n === "all") return e.slice(1).every((e) => this.matchesFilter(e, t));
+		if (n === "any") return e.slice(1).some((e) => this.matchesFilter(e, t));
+		if (n === "none") return !e.slice(1).some((e) => this.matchesFilter(e, t));
+		let r = (e) => {
+			if (Array.isArray(e) && e[0] === "get") return t[e[1]];
+			if (!(Array.isArray(e) && e[0] === "geometry-type") && !(Array.isArray(e) && e[0] === "zoom")) return e;
+		}, i = r(e[1]), a = r(e[2]);
+		if (n === "==" || n === "===") return i === a;
+		if (n === "!=" || n === "!==") return i !== a;
+		if (n === "<") return Number(i) < Number(a);
+		if (n === "<=") return Number(i) <= Number(a);
+		if (n === ">") return Number(i) > Number(a);
+		if (n === ">=") return Number(i) >= Number(a);
+		if (n === "match") {
+			let t = r(e[1]);
+			for (let n = 2; n + 1 < e.length; n += 2) {
+				let r = e[n];
+				if (Array.isArray(r) ? r.includes(t) : r === t) return !!e[n + 1];
+			}
+			return !!e[e.length - 1];
+		}
+		if (n === "in") {
+			let t = r(e[1]);
+			return e.slice(2).includes(t);
+		}
+		return n === "has" ? t[e[1]] !== void 0 : n === "!has" ? t[e[1]] === void 0 : !0;
+	}
+	resolveRegisteredLayerId(e, t, n) {
+		let r = typeof e.__mapLayerId == "string" ? e.__mapLayerId : t ?? null;
+		return r && n[r] ? r : null;
+	}
+	resolveLayerTitle(e, t) {
+		let n = t[e];
+		return typeof n?.label == "string" && n.label.length > 0 ? n.label : null;
+	}
+}, U = class {
+	constructor(e) {
+		this.map = e, this.markers = /* @__PURE__ */ new Map();
+	}
+	add(e, t, n = {}) {
+		this.remove(e);
+		let r = n.color ?? "#e63946", i = n.draggable ?? !1, a = document.createElement("div");
+		a.style.cssText = "cursor:pointer;user-select:none;", a.innerHTML = s(r);
+		let o = new M({
+			element: a,
+			positioning: "bottom-center",
+			stopEvent: !1,
+			position: c([t[0], t[1]])
+		});
+		this.map.addOverlay(o);
+		let l = {
+			overlay: o,
+			element: a,
+			draggable: i
+		};
+		i && (l.dragCleanup = this.attachDrag(e, a, o)), this.markers.set(e, l);
+	}
+	move(e, t) {
+		let n = this.markers.get(e);
+		n && n.overlay.setPosition(c([t[0], t[1]]));
+	}
+	remove(e) {
+		let t = this.markers.get(e);
+		t && (t.dragCleanup?.(), this.map.removeOverlay(t.overlay), this.markers.delete(e));
+	}
+	attachDrag(e, t, n) {
+		let r = !1, i = (e) => {
+			e.preventDefault(), r = !0, t.setPointerCapture(e.pointerId);
+		}, a = (e) => {
+			if (!r) return;
+			let t = this.map.getTargetElement().getBoundingClientRect(), i = [e.clientX - t.left, e.clientY - t.top], a = this.map.getCoordinateFromPixel(i);
+			a && n.setPosition(a);
+		}, o = () => {
+			r = !1;
+		};
+		return t.addEventListener("pointerdown", i), t.addEventListener("pointermove", a), t.addEventListener("pointerup", o), () => {
+			t.removeEventListener("pointerdown", i), t.removeEventListener("pointermove", a), t.removeEventListener("pointerup", o);
+		};
+	}
+}, W = class extends i {
+	constructor() {
+		super(), this.engineId = "openlayers", this.engineVersion = u, this.markerService = null, this.core = new N(this.store, this.events), this.toolService = new P(), this.logicalLayerExecutor = new r(), this.queryExecutor = new o(), this.queryService = this.queryExecutor, this.mapFactory = new z(), this.core.onMapReady?.((e) => {
+			let t = new V(e, this.store);
+			this.core.setLayerOrderRegistry(t), this.logicalLayerExecutor.bind(t), this.queryExecutor.bind(new H(e, t, this.store)), this.markerService = new U(e);
+		});
+	}
+	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) {
+		return !1;
+	}
+	isTerrainEnabled() {
+		return null;
+	}
+	resetNorth() {
+		this.core.resetNorth();
+	}
+	resetNorthPitch() {
+		this.core.resetNorthPitch();
+	}
+	fitBounds(e) {
+		this.core.fitBounds(e);
+	}
+	setProjection(e) {
+		return !1;
+	}
+	getProjection() {
+		return null;
+	}
+	setCursor(e) {
+		this.core.setCursor(e);
+	}
+	setPanEnabled(e) {
+		this.core.setPanEnabled(e);
+	}
+	setTouchCaptureEnabled(e) {
+		this.core.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) {
+		return this.core.getSourceData(e) ?? this.logicalLayerExecutor.getSourceData(e);
+	}
+	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 { W as OpenLayersAdapter };