@npm9912/v-map 0.1.0

package/dist/esm/cesium-provider-BJfAup3w.js

@@ -0,0 +1,2596 @@
+import { w as warn, l as log, e as error } from './messages-CMKJzsgL.js';
+import { C as CESIUM_VERSION } from './v-map.v-map-layer-osm.v-map-layergroup-B4pFHuSf.js';
+import { l as loadGeoTIFFSource, a as getGeoTIFFSource, b as getTileProcessorConfig, G as GeoTIFFTileProcessor, g as getColorStops } from './geotiff-source-esnDnC-u.js';
+import './index-jzneDarq.js';
+import './v-map-layer-helper-Dys44Cgo.js';
+
+/**
+ * Eine Gruppe verwaltet Sichtbarkeit & Basemap-Filter ihrer Cesium-Layer.
+ * - group.visible = false  => Alle Layer der Gruppe unsichtbar.
+ * - group.basemap = "X"    => Nur Layer mit elementId==="X" in der Gruppe sichtbar.
+ * - Der ursprüngliche Sichtbarkeitszustand jedes Layers wird gemerkt und bei
+ *   Re-Aktivierung wiederhergestellt.
+ */
+class CesiumLayerGroup {
+    id;
+    _visible = true;
+    _basemap = null;
+    _layers = new Map();
+    _originalVisible = new Map();
+    _dirty = true;
+    constructor(id, visible = true) {
+        this.id = id;
+        this._visible = visible;
+    }
+    get visible() {
+        return this._visible;
+    }
+    set visible(v) {
+        if (this._visible === v)
+            return;
+        this._visible = v;
+        this._dirty = true;
+    }
+    get basemap() {
+        return this._basemap;
+    }
+    set basemap(b) {
+        if (this._basemap === b)
+            return;
+        this._basemap = b;
+        this._dirty = true;
+    }
+    isDirty() {
+        return this._dirty;
+    }
+    addLayer(ref) {
+        if (this._layers.has(ref.id))
+            return;
+        this._layers.set(ref.id, ref);
+        this._originalVisible.set(ref.id, ref.layer.getVisible());
+        this._dirty = true;
+    }
+    /** optional zum Nachziehen von elementId (z. B. wenn erst später bekannt) */
+    setLayerElementId(layerId, elementId) {
+        const r = this._layers.get(layerId);
+        if (!r)
+            return;
+        if (r.elementId === elementId)
+            return;
+        r.elementId = elementId ?? null;
+        this._dirty = true;
+    }
+    removeLayer(layerId) {
+        const had = this._layers.delete(layerId);
+        this._originalVisible.delete(layerId);
+        if (had)
+            this._dirty = true;
+        return had;
+    }
+    clear() {
+        this._layers.clear();
+        this._originalVisible.clear();
+        this._dirty = true;
+    }
+    /** zentrale Logik: Basemap/Visibility anwenden */
+    apply() {
+        if (!this._dirty)
+            return;
+        for (const [id, ref] of this._layers) {
+            const original = this._originalVisible.get(id) ?? true;
+            // effektive Sichtbarkeit nach Gruppenregeln
+            let effective = this._visible && original;
+            if (effective && this._basemap) {
+                // innerhalb der Gruppe nur Layer mit passender elementId anzeigen
+                effective = ref.elementId === this._basemap;
+            }
+            // Nur dann setzen, wenn sich etwas ändert
+            if (ref.layer.getVisible() !== effective) {
+                ref.layer.setVisible(effective);
+            }
+        }
+        this._dirty = false;
+    }
+}
+/**
+ * Root-Store für mehrere Cesium-Gruppen.
+ * - Ordnung/Z-Index übernimmst du weiterhin im LayerManager pro Layer.
+ * - Diese Klasse kümmert sich um Gruppensichtbarkeit & Basemap-Filter.
+ */
+class CesiumLayerGroups {
+    _groups = [];
+    _dirty = true;
+    get groups() {
+        return [...this._groups];
+    }
+    getGroup(id) {
+        return this._groups.find(g => g.id === id);
+    }
+    hasGroup(id) {
+        return this._groups.some(g => g.id === id);
+    }
+    ensureGroup(id, visible = true) {
+        let g = this.getGroup(id);
+        if (g)
+            return g;
+        g = new CesiumLayerGroup(id, visible);
+        this._groups.push(g);
+        this._dirty = true;
+        return g;
+    }
+    addLayerToGroup(groupId, visible, ref) {
+        const g = this.ensureGroup(groupId, visible);
+        g.addLayer(ref);
+        this._dirty = true;
+    }
+    removeLayer(layerId, removeFromAll = true) {
+        let removed = false;
+        for (const g of this._groups) {
+            if (g.removeLayer(layerId)) {
+                removed = true;
+                if (!removeFromAll)
+                    break;
+            }
+        }
+        if (removed)
+            this._dirty = true;
+        return removed;
+    }
+    setGroupVisible(groupId, visible) {
+        const g = this.getGroup(groupId);
+        if (!g)
+            throw new Error(`CesiumLayerGroup "${groupId}" nicht gefunden`);
+        g.visible = visible;
+        this._dirty = true;
+    }
+    setBasemap(groupId, basemap) {
+        const g = this.getGroup(groupId);
+        if (!g)
+            throw new Error(`CesiumLayerGroup "${groupId}" nicht gefunden`);
+        g.basemap = basemap;
+        this._dirty = true;
+    }
+    /** Wendet alle Gruppenregeln an (sichtbar/basemap). */
+    apply() {
+        if (!this._dirty && !this._groups.some(g => g.isDirty()))
+            return;
+        for (const g of this._groups)
+            g.apply();
+        this._dirty = false;
+    }
+    clear() {
+        this._groups = [];
+        this._dirty = true;
+    }
+}
+
+class LayerManager {
+    Cesium;
+    layers = new Map();
+    viewer;
+    //private imageryZMutex = new AsyncMutex();
+    constructor(Cesium, viewer) {
+        this.viewer = viewer;
+        this.Cesium = Cesium;
+    }
+    replaceLayer(id, oldlayer, layer) {
+        if (!this.Cesium) {
+            throw new Error('Cesium must be initialized first. Call init() method.');
+        }
+        const zIndex = oldlayer.getZIndex();
+        const visible = oldlayer.getVisible();
+        const opacity = oldlayer.getOpacity();
+        this.removeLayer(id);
+        const wrappedLayer = this.addLayer(id, layer);
+        wrappedLayer.setZIndex(zIndex);
+        wrappedLayer.setVisible(visible);
+        wrappedLayer.setOpacity(opacity);
+        return wrappedLayer;
+    }
+    addLayer(id, layer) {
+        if (!this.Cesium) {
+            throw new Error('Cesium must be initialized first. Call init() method.');
+        }
+        //add layer
+        if (layer instanceof this.Cesium.GeoJsonDataSource) {
+            this.viewer.dataSources.add(layer);
+        }
+        else if (layer instanceof this.Cesium.DataSource) {
+            this.viewer.dataSources.add(layer);
+        }
+        else if (layer instanceof this.Cesium.Cesium3DTileset) {
+            this.viewer.scene.primitives.add(layer);
+            if (!layer.style) {
+                layer.style = new this.Cesium.Cesium3DTileStyle();
+            }
+        }
+        else if (layer instanceof this.Cesium.ImageryLayer) {
+            this.viewer.imageryLayers.add(layer);
+        }
+        layer.id = id;
+        const wrapped = this.wrapLayer(layer);
+        this.layers.set(id, wrapped);
+        return wrapped;
+    }
+    addCustomLayer(id, layer) {
+        this.layers.set(id, layer);
+        return layer;
+    }
+    getLayer(layerId) {
+        const layer = this.layers.get(layerId);
+        if (!layer)
+            throw new Error(`Layer mit ID "${layerId}" nicht gefunden.`);
+        return layer;
+    }
+    getLayerById(layerId) {
+        return this.getLayer(layerId);
+    }
+    removeLayer(layerId) {
+        const layer = this.getLayer(layerId);
+        layer.remove();
+        this.layers.delete(layerId);
+    }
+    setVisible(layerId, visible) {
+        const layer = this.getLayer(layerId);
+        layer.setVisible(visible);
+    }
+    setOpacity(layerId, opacity) {
+        const layer = this.getLayer(layerId);
+        layer.setOpacity(opacity);
+    }
+    async setZIndex(layerId, zindex) {
+        const layer = this.getLayer(layerId);
+        await layer.setZIndex(zindex);
+    }
+    wrapLayer(layer) {
+        if (layer instanceof this.Cesium.ImageryLayer) {
+            return this.wrapImageryLayer(layer);
+        }
+        else if (layer instanceof this.Cesium.Cesium3DTileset) {
+            return this.wrapTilesetLayer(layer);
+        }
+        else {
+            return this.wrapDataSourceLayer(layer);
+        }
+    }
+    async sortImageryLayers(collection, layer, targetZ) {
+        const tempCollection = this.sort(collection, layer, targetZ);
+        // Collection leeren und neu befüllen
+        collection.removeAll(false);
+        tempCollection.forEach(ds => collection.add(ds));
+    }
+    async sort3DTileSets(collection, tileset, targetZ) {
+        const tempCollection = this.sort(collection, tileset, targetZ);
+        // Collection leeren und neu befüllen
+        collection.removeAll();
+        tempCollection.forEach(ds => collection.add(ds));
+    }
+    async sortDataSources(collection, dataSource, zIndex) {
+        const tempCollection = this.sort(collection, dataSource, zIndex);
+        // Collection leeren und neu befüllen
+        collection.removeAll(false);
+        tempCollection.forEach(async (ds) => await collection.add(ds));
+    }
+    sort(collection, dataSource, zIndex) {
+        // 1. Layer entfernen
+        collection.remove(dataSource, false);
+        // 2. Layer an der richtigen Position wieder hinzufügen
+        // Cesium hat keine direkte "setZIndex"-Methode für DataSources,
+        // also müssen wir die Reihenfolge manuell steuern.
+        // Da DataSourceCollection keine Z-Index-Unterstützung hat,
+        // müssen wir alle Layer neu sortieren.
+        //    const dataSources: DataSource[] = [];
+        const tempDataSources = [];
+        // Alle Layer sammeln
+        for (let i = 0; i < collection.length; i++) {
+            tempDataSources.push(collection.get(i));
+        }
+        // Sortieren nach zIndex (falls vorhanden) oder Reihenfolge
+        tempDataSources.sort((a, b) => {
+            const aZIndex = a.zIndex || 0;
+            const bZIndex = b.zIndex || 0;
+            return aZIndex - bZIndex;
+        });
+        // Den Layer mit dem neuen zIndex einfügen
+        dataSource.zIndex = zIndex;
+        tempDataSources.push(dataSource);
+        // Neu sortieren
+        tempDataSources.sort((a, b) => {
+            const aZIndex = a.zIndex || 0;
+            const bZIndex = b.zIndex || 0;
+            return aZIndex - bZIndex;
+        });
+        return tempDataSources;
+    }
+    // /**
+    //  * Verschiebt ein bereits vorhandenes ImageryLayer innerhalb seiner Collection
+    //  * zu einem gewünschten zIndex und hält die Collection nach zIndex sortiert.
+    //  *
+    //  * @param collection  Die Sammlung, in der sich das Layer befindet.
+    //  * @param layer       Das zu verschiebende Layer (ist bereits Teil der Collection).
+    //  * @param targetZ     Der gewünschte neue zIndex.
+    //  */
+    // private moveImageryLayerToZIndex(
+    //   collection: ImageryLayerCollection,
+    //   layer: ImageryLayer,
+    //   targetZ: number,
+    // ): void {
+    //   // fire-and-forget; Thread-Sicherheit via Mutex
+    //   void this.imageryZMutex.runExclusive(async () => {
+    //     // -------------------------------------------------
+    //     // 1️⃣  Neues zIndex setzen (überschreibt das alte)
+    //     // -------------------------------------------------
+    //     (layer as any).zIndex = targetZ;
+    //     // -------------------------------------------------
+    //     // 2️⃣  Aktuelle Position bestimmen
+    //     // -------------------------------------------------
+    //     const curIdx = collection.indexOf(layer);
+    //     if (curIdx === -1) {
+    //       throw new Error('Der übergebene Layer ist nicht Teil der Collection.');
+    //     }
+    //     // -------------------------------------------------
+    //     // 3️⃣  Nach oben schieben, solange Vorgänger einen
+    //     //     größeren zIndex hat (stabile Sortierung)
+    //     // -------------------------------------------------
+    //     let idx = curIdx;
+    //     while (
+    //       idx > 0 && // nicht am Anfang
+    //       collection[idx - 1].zIndex > targetZ // Vorgänger hat höheren zIndex
+    //     ) {
+    //       // `raise` vertauscht das aktuelle Element mit seinem Vorgänger
+    //       collection.raise(collection[idx]);
+    //       idx--;
+    //     }
+    //     // -------------------------------------------------
+    //     // 4️⃣  Nach unten schieben, falls das neue zIndex
+    //     //     größer ist als das der nachfolgenden Elemente
+    //     // -------------------------------------------------
+    //     while (
+    //       idx < collection.length - 1 && // nicht am Ende
+    //       collection[idx + 1].zIndex < targetZ // Nachfolger hat kleineren zIndex
+    //     ) {
+    //       // `lower` vertauscht das aktuelle Element mit seinem Nachfolger
+    //       collection.lower(collection[idx]);
+    //       idx++;
+    //     }
+    //   });
+    //   // -------------------------------------------------
+    //   // 5️⃣  Optional: Guard‑Clause für extreme Werte
+    //   // -------------------------------------------------
+    //   // (Falls du Min/Max‑Grenzen definieren willst)
+    //   // if (targetZ < MIN_Z) (layer as any).zIndex = MIN_Z;
+    //   // if (targetZ > MAX_Z) (layer as any).zIndex = MAX_Z;
+    // }
+    // private moveTilesetToIndex(tileset: Cesium3DTileset, index: number): void {
+    //   const primitives = this.viewer.scene.primitives;
+    //   primitives.remove(tileset);
+    //   if (index >= primitives.length) {
+    //     primitives.add(tileset);
+    //   } else {
+    //     const tilesets = [];
+    //     for (let i = 0; i < primitives.length; i++) {
+    //       const current = primitives.get(i);
+    //       if (i === index) tilesets.push(tileset);
+    //       if (current !== tileset) tilesets.push(current);
+    //     }
+    //     primitives.removeAll();
+    //     tilesets.forEach(t => primitives.add(t));
+    //   }
+    // }
+    // private moveDataSourceToIndex(
+    //   collection: DataSourceCollection,
+    //   dataSource: DataSource,
+    //   zIndex: number,
+    // ): void {
+    //   // 1. Layer entfernen
+    //   collection.remove(dataSource);
+    //   // 2. Layer an der richtigen Position wieder hinzufügen
+    //   // Cesium hat keine direkte "setZIndex"-Methode für DataSources,
+    //   // also müssen wir die Reihenfolge manuell steuern.
+    //   // Da DataSourceCollection keine Z-Index-Unterstützung hat,
+    //   // müssen wir alle Layer neu sortieren.
+    //   //    const dataSources: DataSource[] = [];
+    //   const tempDataSources: DataSource[] = [];
+    //   // Alle Layer sammeln
+    //   for (let i = 0; i < collection.length; i++) {
+    //     tempDataSources.push(collection.get(i));
+    //   }
+    //   // Sortieren nach zIndex (falls vorhanden) oder Reihenfolge
+    //   tempDataSources.sort((a, b) => {
+    //     const aZIndex = (a as any).zIndex || 0;
+    //     const bZIndex = (b as any).zIndex || 0;
+    //     return aZIndex - bZIndex;
+    //   });
+    //   // Den Layer mit dem neuen zIndex einfügen
+    //   (dataSource as any).zIndex = zIndex;
+    //   tempDataSources.push(dataSource);
+    //   // Neu sortieren
+    //   tempDataSources.sort((a, b) => {
+    //     const aZIndex = (a as any).zIndex || 0;
+    //     const bZIndex = (b as any).zIndex || 0;
+    //     return aZIndex - bZIndex;
+    //   });
+    //   // Collection leeren und neu befüllen
+    //   collection.removeAll();
+    //   tempDataSources.forEach(ds => collection.add(ds));
+    // }
+    wrapImageryLayer(layer) {
+        const collection = this.viewer.imageryLayers;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+        let iLOptions = {};
+        return {
+            getOptions: () => {
+                return iLOptions;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+            setOptions(options) {
+                iLOptions = options;
+            },
+            getVisible: () => {
+                return layer.show;
+            },
+            setVisible: (value) => {
+                layer.show = value;
+            },
+            getOpacity: () => layer.alpha,
+            setOpacity: (value) => {
+                layer.alpha = value;
+            },
+            getZIndex: () => {
+                for (let i = 0; i < collection.length; i++) {
+                    if (collection.get(i) === layer)
+                        return i;
+                }
+                return -1;
+            },
+            setZIndex: async (zIndex) => {
+                if (zIndex !== undefined) {
+                    await this.sortImageryLayers(collection, layer, zIndex);
+                }
+            },
+            remove: () => collection.remove(layer),
+        };
+    }
+    wrapTilesetLayer(layer) {
+        const collection = this.viewer.scene.primitives;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+        let c3dTSOptions = {};
+        return {
+            getOptions: () => {
+                return c3dTSOptions;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+            setOptions(options) {
+                c3dTSOptions = options;
+            },
+            getVisible: () => {
+                return layer.show;
+            },
+            setVisible: (value) => {
+                layer.show = value;
+            },
+            getOpacity: () => {
+                const style = layer.style;
+                if (style.color && typeof style.color === 'string') {
+                    const colorStr = style.color;
+                    const match = colorStr.match(/color\(.*?,([\d.]+)\)/);
+                    return match ? parseFloat(match[1]) : 1.0;
+                }
+                return 1.0;
+            },
+            setOpacity: (value) => {
+                const currentColor = layer.style.color;
+                let colorExpr;
+                if (typeof currentColor === 'string') {
+                    const colorStr = currentColor;
+                    const colorPart = colorStr.replace(/color\((.*?),[\d.]+\)/, `color($1, ${value})`);
+                    colorExpr = colorPart.includes('color')
+                        ? colorPart
+                        : `color('white', ${value})`;
+                }
+                else {
+                    colorExpr = `color('white', ${value})`;
+                }
+                layer.style = new this.Cesium.Cesium3DTileStyle({
+                    color: colorExpr,
+                    colorBlendMode: this.Cesium.ColorBlendMode.MIX,
+                });
+            },
+            getZIndex: () => {
+                const primitives = this.viewer.scene.primitives;
+                for (let i = 0; i < primitives.length; i++) {
+                    if (primitives.get(i) === layer)
+                        return i;
+                }
+                return -1;
+            },
+            setZIndex: async (zIndex) => {
+                if (zIndex !== undefined) {
+                    this.sort3DTileSets(collection, layer, zIndex);
+                    //this.moveTilesetToIndex(layer, zIndex);
+                }
+            },
+            setColor: (color, opacity = 1.0) => {
+                const cssColor = color instanceof this.Cesium.Color
+                    ? color.toCssHexString()
+                    : color.replace(/[#\s]/g, '');
+                layer.style = new this.Cesium.Cesium3DTileStyle({
+                    color: `color('${cssColor}', ${opacity})`,
+                    colorBlendMode: this.Cesium.ColorBlendMode.MIX,
+                });
+            },
+            setStyle: (style) => {
+                layer.style =
+                    style instanceof this.Cesium.Cesium3DTileStyle
+                        ? style
+                        : new this.Cesium.Cesium3DTileStyle(style);
+            },
+            remove: () => this.viewer.scene.primitives.remove(layer),
+        };
+    }
+    wrapDataSourceLayer(layer) {
+        const collection = this.viewer.dataSources;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+        let dsOptions = {};
+        return {
+            getOptions: () => {
+                return dsOptions;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+            setOptions(options) {
+                dsOptions = options;
+            },
+            getVisible: () => {
+                return layer.show;
+            },
+            setVisible: (value) => {
+                layer.show = value;
+            },
+            getOpacity: () => 1.0, //todo
+            setOpacity: (value) => {
+                if (layer.__vmapLockOpacity)
+                    return;
+                layer.entities.values.forEach((entity) => {
+                    // Helper-Funktion zum Setzen der Opacity
+                    const setColorOpacity = (colorProperty, defaultColor) => {
+                        const { Color: CesiumColor, JulianDate } = this.Cesium;
+                        const applyAlpha = (color) => CesiumColor.fromAlpha(color ?? defaultColor, value, new CesiumColor());
+                        if (!colorProperty) {
+                            return new this.Cesium.ConstantProperty(applyAlpha(defaultColor));
+                        }
+                        const maybeProperty = colorProperty;
+                        if (maybeProperty && typeof maybeProperty.getValue === 'function') {
+                            const currentColor = maybeProperty.getValue(this.viewer?.clock?.currentTime ?? new JulianDate(), new CesiumColor());
+                            const nextColor = applyAlpha(currentColor);
+                            if (typeof maybeProperty.setValue === 'function') {
+                                maybeProperty.setValue(nextColor);
+                                return maybeProperty;
+                            }
+                            return new this.Cesium.ConstantProperty(nextColor);
+                        }
+                        if (colorProperty instanceof this.Cesium.Color) {
+                            return new this.Cesium.ConstantProperty(applyAlpha(colorProperty));
+                        }
+                        return new this.Cesium.ConstantProperty(applyAlpha(defaultColor));
+                    };
+                    // Polygone
+                    if (entity.polygon) {
+                        const material = entity.polygon.material;
+                        if (material instanceof Cesium.ColorMaterialProperty) {
+                            const color = material.color;
+                            material.color = setColorOpacity(color, Cesium.Color.WHITE);
+                        }
+                        else if (material instanceof Cesium.ImageMaterialProperty) {
+                            material.color = setColorOpacity(material.color, Cesium.Color.WHITE);
+                        }
+                    }
+                    // Polylinien
+                    if (entity.polyline) {
+                        const material = entity.polyline.material;
+                        if (material instanceof Cesium.ColorMaterialProperty) {
+                            material.color = setColorOpacity(material.color, Cesium.Color.WHITE);
+                        }
+                        else if (material instanceof Cesium.PolylineOutlineMaterialProperty) {
+                            material.color = setColorOpacity(material.color, Cesium.Color.WHITE);
+                        }
+                    }
+                    // Punkte
+                    if (entity.point) {
+                        entity.point.color = setColorOpacity(entity.point.color, Cesium.Color.WHITE);
+                    }
+                    // Billboards
+                    if (entity.billboard) {
+                        entity.billboard.color = setColorOpacity(entity.billboard.color, Cesium.Color.WHITE);
+                    }
+                    // Labels
+                    if (entity.label) {
+                        entity.label.fillColor = setColorOpacity(entity.label.fillColor, Cesium.Color.BLACK);
+                        if (entity.label.outlineColor) {
+                            entity.label.outlineColor = setColorOpacity(entity.label.outlineColor, Cesium.Color.BLACK);
+                        }
+                    }
+                    // 3D-Modelle (falls vorhanden)
+                    if (entity.model) {
+                        entity.model.color = setColorOpacity(entity.model.color, Cesium.Color.WHITE);
+                    }
+                });
+            },
+            getZIndex: () => {
+                for (let i = 0; i < collection.length; i++) {
+                    if (collection.get(i) === layer)
+                        return i;
+                }
+                return -1;
+            },
+            setZIndex: async (zIndex) => {
+                if (zIndex !== undefined) {
+                    await this.sortDataSources(collection, layer, zIndex);
+                }
+            },
+            remove: () => collection.remove(layer),
+        };
+    }
+}
+
+// utils/async-mutex.ts
+class AsyncMutex {
+    locked = false;
+    queue = [];
+    async runExclusive(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return Promise.resolve();
+        }
+        return new Promise(resolve => this.queue.push(resolve));
+    }
+    release() {
+        const next = this.queue.shift();
+        if (next)
+            next();
+        else
+            this.locked = false;
+    }
+}
+
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(msg);
+}
+const sameMM = (exp, act) => exp.match(/^\d+\.\d+/)?.[0] === act.match(/^\d+\.\d+/)?.[0];
+const loadCesiumMutex = new AsyncMutex();
+async function loadCesium(version = CESIUM_VERSION) {
+    const v = version.replace(/^[^\d]*/, '');
+    const base = `https://cdn.jsdelivr.net/npm/cesium@${v}/Build/Cesium`;
+    const url = `${base}/Cesium.js`;
+    await loadCesiumMutex.runExclusive(async () => {
+        if (!globalThis.Cesium) {
+            await new Promise((resolve, reject) => {
+                const id = 'cesium-cdn-script';
+                if (document.getElementById(id))
+                    return resolve();
+                const s = document.createElement('script');
+                s.id = id;
+                s.async = true;
+                s.src = url;
+                s.addEventListener('load', () => resolve(), { once: true });
+                s.addEventListener('error', () => reject(new Error(`Laden fehlgeschlagen: ${url}`)), { once: true });
+                document.head.appendChild(s);
+            });
+        }
+    });
+    const Cesium = globalThis.Cesium;
+    assert(Cesium, 'globalThis.Cesium nicht verfügbar.');
+    const actual = Cesium.VERSION; // z.B. "1.133"
+    assert(sameMM(String(version), actual), // Major.Minor muss passen
+    `Cesium-Version abweichend: erwartet ~${version}, geladen ${actual}`);
+    globalThis.CESIUM_BASE_URL = base;
+    return Cesium;
+}
+async function injectWidgetsCss(shadowRoot) {
+    const v = CESIUM_VERSION.replace(/^[^\d]*/, '');
+    const base = `https://cdn.jsdelivr.net/npm/cesium@${v}/Build/Cesium`;
+    const cssUrl = `${base}/Widgets/widgets.css`;
+    const cssText = await (await fetch(cssUrl)).text();
+    const absolutized = cssText.replace(/url\((?!['"]?data:)(['"]?)([^'")]+)\1\)/g, (_m, _q, rel) => `url(${base}/Widgets/${rel.replace(/^\.?\//, '')})`);
+    if (!shadowRoot)
+        return;
+    if ('adoptedStyleSheets' in Document.prototype) {
+        const sheet = new CSSStyleSheet();
+        await sheet.replace(absolutized);
+        shadowRoot.adoptedStyleSheets = [
+            ...(shadowRoot.adoptedStyleSheets ?? []),
+            sheet,
+        ];
+    }
+    else {
+        const style = document.createElement('style');
+        style.textContent = absolutized;
+        shadowRoot.appendChild(style);
+    }
+}
+
+/**
+ * Custom ImageryProvider that renders GeoTIFF tiles on demand using
+ * the shared GeoTIFFTileProcessor (triangulation-based reprojection).
+ */
+class GeoTIFFImageryProvider {
+    tileWidth;
+    tileHeight;
+    tilingScheme;
+    rectangle;
+    errorEvent;
+    credit = undefined;
+    tileDiscardPolicy = undefined;
+    proxy = undefined;
+    hasAlphaChannel = true;
+    minimumLevel;
+    maximumLevel;
+    Cesium;
+    tileProcessor;
+    resolution;
+    resampleMethod;
+    colorStops;
+    readyPromiseInternal;
+    ready = false;
+    constructor(options) {
+        const { Cesium, rectangleDegrees, tileProcessor, tileSize, resolution, resampleMethod, colorStops, minimumLevel, maximumLevel, } = options;
+        this.Cesium = Cesium;
+        this.tileProcessor = tileProcessor;
+        this.tileWidth = tileSize;
+        this.tileHeight = tileSize;
+        this.resolution = resolution;
+        this.resampleMethod = resampleMethod;
+        this.colorStops = colorStops;
+        this.minimumLevel = minimumLevel ?? 0;
+        this.maximumLevel = maximumLevel;
+        this.rectangle = Cesium.Rectangle.fromDegrees(rectangleDegrees[0], rectangleDegrees[1], rectangleDegrees[2], rectangleDegrees[3]);
+        // Always use WebMercatorTilingScheme because the GeoTIFFTileProcessor
+        // interprets (x,y,z) as Web Mercator tile coordinates.
+        this.tilingScheme = new Cesium.WebMercatorTilingScheme();
+        this.errorEvent = new Cesium.Event();
+        this.ready = true;
+        this.readyPromiseInternal = Promise.resolve(true);
+    }
+    get tilingSchemeName() {
+        // Expose helper for debugging if needed.
+        return this.tilingScheme instanceof this.Cesium.WebMercatorTilingScheme
+            ? 'WebMercator'
+            : undefined;
+    }
+    get readyPromise() {
+        return this.readyPromiseInternal;
+    }
+    get tileCredits() {
+        return undefined;
+    }
+    getTileCredits(_x, _y, _level) {
+        return undefined;
+    }
+    get url() {
+        return undefined;
+    }
+    /**
+     * Flips a canvas vertically (Y-axis inversion) for Cesium.
+     * Creates a new canvas with the flipped content.
+     *
+     * @param sourceCanvas - The canvas to flip
+     * @param width - Width of the canvas
+     * @param height - Height of the canvas
+     * @returns A new canvas with vertically flipped content, or the source canvas if flipping fails
+     */
+    flipCanvasVertically(sourceCanvas, width, height) {
+        const flippedCanvas = document.createElement('canvas');
+        flippedCanvas.width = width;
+        flippedCanvas.height = height;
+        const flippedCtx = flippedCanvas.getContext('2d');
+        if (!flippedCtx) {
+            warn('v-map - cesium - failed to get 2d context for flip');
+            return sourceCanvas; // Fallback to source canvas
+        }
+        flippedCtx.translate(0, height);
+        flippedCtx.scale(1, -1);
+        flippedCtx.drawImage(sourceCanvas, 0, 0);
+        return flippedCanvas;
+    }
+    /**
+     * Creates a flipped ImageBitmap from RGBA data.
+     * Uses ImageBitmap for better performance when available.
+     *
+     * @param rgbaData - The RGBA pixel data
+     * @param sampleSize - Size of the tile (width and height)
+     * @returns A flipped ImageBitmap, or undefined if creation fails
+     */
+    async createFlippedImageBitmap(rgbaData, sampleSize) {
+        if (typeof createImageBitmap !== 'function') {
+            return undefined;
+        }
+        try {
+            // Create temporary canvas for Y-axis flip
+            const tempCanvas = document.createElement('canvas');
+            tempCanvas.width = sampleSize;
+            tempCanvas.height = sampleSize;
+            const tempCtx = tempCanvas.getContext('2d');
+            if (!tempCtx) {
+                throw new Error('Failed to get 2d context');
+            }
+            const imageData = tempCtx.createImageData(sampleSize, sampleSize);
+            imageData.data.set(rgbaData);
+            tempCtx.putImageData(imageData, 0, 0);
+            // Flip vertically for Cesium
+            const flippedCanvas = this.flipCanvasVertically(tempCanvas, sampleSize, sampleSize);
+            return await createImageBitmap(flippedCanvas);
+        }
+        catch (err) {
+            warn('v-map - cesium - createImageBitmap failed, falling back', err);
+            return undefined;
+        }
+    }
+    /**
+     * Creates a flipped image (ImageBitmap or Canvas) from RGBA data.
+     * Prefers ImageBitmap for better performance, falls back to Canvas.
+     *
+     * @param rgbaData - The RGBA pixel data
+     * @returns A flipped ImageBitmap or Canvas, or undefined if creation fails
+     */
+    async createFlippedImageFromRGBA(rgbaData) {
+        // Calculate actual sample size (may differ from tileWidth due to resolution)
+        const sampleSize = Math.ceil(this.tileWidth * this.resolution);
+        // Prefer ImageBitmap when available for better performance
+        const imageBitmap = await this.createFlippedImageBitmap(rgbaData, sampleSize);
+        if (imageBitmap) {
+            return imageBitmap;
+        }
+        // Fallback to Canvas
+        const canvas = document.createElement('canvas');
+        canvas.width = sampleSize;
+        canvas.height = sampleSize;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            warn('v-map - cesium - unable to acquire canvas 2d context');
+            return undefined;
+        }
+        const imageData = ctx.createImageData(sampleSize, sampleSize);
+        imageData.data.set(rgbaData);
+        ctx.putImageData(imageData, 0, 0);
+        // Flip the canvas vertically for Cesium (Y-axis inversion)
+        return this.flipCanvasVertically(canvas, sampleSize, sampleSize);
+    }
+    async requestImage(x, y, level) {
+        if (!this.ready)
+            return undefined;
+        if (level < this.minimumLevel ||
+            (this.maximumLevel !== undefined && level > this.maximumLevel)) {
+            return undefined;
+        }
+        const params = {
+            x,
+            y,
+            z: level,
+            tileSize: this.tileWidth,
+            resolution: this.resolution,
+            resampleMethod: this.resampleMethod,
+            colorStops: this.colorStops,
+        };
+        let rgbaData = null;
+        try {
+            rgbaData = await this.tileProcessor.getTileData(params);
+            if (!rgbaData) {
+                log(`v-map - cesium - geotiff - requestImage(${x},${y},${level}): no data returned`);
+                return undefined;
+            }
+            log(`v-map - cesium - geotiff - requestImage(${x},${y},${level}): rgba ${rgbaData.length} bytes, sampleSize=${Math.ceil(this.tileWidth * this.resolution)}`);
+        }
+        catch (err) {
+            this.errorEvent.raiseEvent(err);
+            warn('v-map - cesium - getTileData - GeoTIFF tile request failed', err);
+            return undefined;
+        }
+        try {
+            const result = await this.createFlippedImageFromRGBA(rgbaData);
+            log(`v-map - cesium - geotiff - requestImage(${x},${y},${level}): result=${result?.constructor?.name ?? 'undefined'}, size=${result instanceof HTMLCanvasElement ? `${result.width}x${result.height}` : result instanceof ImageBitmap ? `${result.width}x${result.height}` : 'n/a'}`);
+            return result;
+        }
+        catch (err) {
+            this.errorEvent.raiseEvent(err);
+            warn('v-map - cesium - createFlippedImageFromRGBA - GeoTIFF tile request failed', err);
+            return undefined;
+        }
+    }
+    pickFeatures() {
+        return undefined;
+    }
+}
+
+const LOG_PREFIX = 'v-map - cesium - terrain-geotiff - ';
+/**
+ * Custom Cesium Terrain Provider for GeoTIFF elevation data
+ *
+ * This provider loads a GeoTIFF file containing elevation data and provides
+ * it to Cesium's terrain system as a heightmap.
+ */
+class CesiumGeoTIFFTerrainProvider {
+    Cesium;
+    image;
+    fromProjection = 'EPSG:4326';
+    sourceBounds = [0, 0, 0, 0];
+    wgs84Bounds = [0, 0, 0, 0];
+    width = 0;
+    height = 0;
+    noDataValue = 0;
+    ready = false;
+    _readyPromise;
+    heightmapWidth = 65;
+    heightmapHeight = 65;
+    proj4;
+    tilingScheme;
+    constructor(options) {
+        this.Cesium = options.Cesium;
+        // Initialize with GeographicTilingScheme (WGS84)
+        this.tilingScheme = new this.Cesium.GeographicTilingScheme();
+        // Start loading the GeoTIFF
+        this._readyPromise = this.initialize(options);
+    }
+    async initialize(options) {
+        try {
+            log(`${LOG_PREFIX}loadGeoTIFF: url=${options.url}`);
+            const [geotiffModule, { default: proj4 }, geokeysModule] = await Promise.all([
+                import('./geotiff-BEWxTIfH.js').then(function (n) { return n.g; }),
+                import('./index-RpJarvr_.js'),
+                import('./main-dist-CwnA7_Xn.js').then(function (n) { return n.m; }),
+            ]);
+            const source = await loadGeoTIFFSource(options.url, {
+                projection: options.projection,
+                forceProjection: options.forceProjection ?? false,
+                nodata: options.nodata,
+            }, {
+                geotiff: geotiffModule,
+                proj4,
+                geokeysToProj4: geokeysModule,
+            });
+            this.image = source.baseImage;
+            this.fromProjection = source.fromProjection;
+            this.sourceBounds = source.sourceBounds;
+            this.wgs84Bounds = source.wgs84Bounds;
+            this.width = source.width;
+            this.height = source.height;
+            this.noDataValue = source.noDataValue ?? 0;
+            this.proj4 = source.proj4; // Store proj4 instance with registered projections
+            log(`${LOG_PREFIX}loaded: projection=${this.fromProjection}, bounds=[${this.sourceBounds.map(v => v.toFixed(0)).join(',')}], wgs84=[${this.wgs84Bounds.map(v => v.toFixed(4)).join(',')}], size=${this.width}x${this.height}`);
+            this.ready = true;
+            return true;
+        }
+        catch (err) {
+            error(`${LOG_PREFIX}failed to load GeoTIFF:`, err);
+            this.ready = false;
+            return false;
+        }
+    }
+    /**
+     * Get the coverage rectangle in WGS84 coordinates
+     */
+    get rectangle() {
+        if (!this.ready || !this.wgs84Bounds) {
+            return this.Cesium.Rectangle.MAX_VALUE;
+        }
+        const [west, south, east, north] = this.wgs84Bounds;
+        return this.Cesium.Rectangle.fromDegrees(west, south, east, north);
+    }
+    /**
+     * Request tile geometry for a specific tile
+     */
+    async requestTileGeometry(x, y, level) {
+        if (!this.ready || !this.image) {
+            return undefined;
+        }
+        try {
+            // Get tile bounds in WGS84
+            const rectangle = this.tilingScheme.tileXYToRectangle(x, y, level);
+            let west = this.Cesium.Math.toDegrees(rectangle.west);
+            let south = this.Cesium.Math.toDegrees(rectangle.south);
+            let east = this.Cesium.Math.toDegrees(rectangle.east);
+            let north = this.Cesium.Math.toDegrees(rectangle.north);
+            // Get GeoTIFF bounds in WGS84
+            const [geoWest, geoSouth, geoEast, geoNorth] = this.wgs84Bounds;
+            // Check if tile intersects with GeoTIFF bounds
+            if (east < geoWest ||
+                west > geoEast ||
+                north < geoSouth ||
+                south > geoNorth) {
+                // Tile is completely outside GeoTIFF bounds, return flat heightmap
+                return this.createFlatHeightmap();
+            }
+            // Clamp tile bounds to GeoTIFF coverage area
+            // This prevents transformation errors when the GeoTIFF projection
+            // doesn't support the full WGS84 range (e.g., Mercator and poles)
+            west = Math.max(geoWest, Math.min(geoEast, west));
+            east = Math.max(geoWest, Math.min(geoEast, east));
+            south = Math.max(geoSouth, Math.min(geoNorth, south));
+            north = Math.max(geoSouth, Math.min(geoNorth, north));
+            // Transform tile bounds to source projection
+            // Use the stored proj4 instance that has the projection definitions
+            const transformToSource = (coord) => {
+                try {
+                    return this.proj4('EPSG:4326', this.fromProjection, coord);
+                }
+                catch (err) {
+                    warn(`${LOG_PREFIX}transform failed:`, err);
+                    return coord;
+                }
+            };
+            const swSource = transformToSource([west, south]);
+            const neSource = transformToSource([east, north]);
+            // Calculate pixel coordinates in GeoTIFF
+            const [srcWest, srcSouth, srcEast, srcNorth] = this.sourceBounds;
+            const srcWidth = this.width;
+            const srcHeight = this.height;
+            const pixelWidth = srcEast - srcWest;
+            const pixelHeight = srcNorth - srcSouth;
+            const x0 = Math.floor(((swSource[0] - srcWest) / pixelWidth) * srcWidth);
+            const y0 = Math.floor(((srcNorth - neSource[1]) / pixelHeight) * srcHeight);
+            const x1 = Math.ceil(((neSource[0] - srcWest) / pixelWidth) * srcWidth);
+            const y1 = Math.ceil(((srcNorth - swSource[1]) / pixelHeight) * srcHeight);
+            // Clamp to image bounds
+            const windowX = Math.max(0, Math.min(x0, srcWidth));
+            const windowY = Math.max(0, Math.min(y0, srcHeight));
+            const windowWidth = Math.max(1, Math.min(x1 - x0, srcWidth - windowX));
+            const windowHeight = Math.max(1, Math.min(y1 - y0, srcHeight - windowY));
+            // Read elevation data from GeoTIFF
+            const rasterData = await this.image.readRasters({
+                window: [
+                    windowX,
+                    windowY,
+                    windowX + windowWidth,
+                    windowY + windowHeight,
+                ],
+                width: this.heightmapWidth,
+                height: this.heightmapHeight,
+                resampleMethod: 'bilinear',
+            });
+            // Convert to heightmap array (first band contains elevation)
+            const elevationData = rasterData[0];
+            const buffer = new Float32Array(this.heightmapWidth * this.heightmapHeight);
+            for (let i = 0; i < buffer.length; i++) {
+                let value = elevationData[i];
+                // Replace nodata values with 0
+                if (value === this.noDataValue || !isFinite(value)) {
+                    value = 0;
+                }
+                buffer[i] = value;
+            }
+            // Create Cesium HeightmapTerrainData
+            return new this.Cesium.HeightmapTerrainData({
+                buffer,
+                width: this.heightmapWidth,
+                height: this.heightmapHeight,
+                childTileMask: 0,
+                structure: {
+                    heightScale: 1.0,
+                    heightOffset: 0.0,
+                    elementsPerHeight: 1,
+                    stride: 1,
+                    elementMultiplier: 1.0,
+                },
+            });
+        }
+        catch (err) {
+            warn(`${LOG_PREFIX}failed to load tile geometry:`, err);
+            return this.createFlatHeightmap();
+        }
+    }
+    /**
+     * Create a flat heightmap for tiles outside the GeoTIFF bounds
+     */
+    createFlatHeightmap() {
+        const buffer = new Float32Array(this.heightmapWidth * this.heightmapHeight);
+        buffer.fill(0);
+        return new this.Cesium.HeightmapTerrainData({
+            buffer,
+            width: this.heightmapWidth,
+            height: this.heightmapHeight,
+            childTileMask: 0,
+        });
+    }
+    /**
+     * Get the availability of tiles
+     */
+    get availability() {
+        // For now, we say all tiles are available
+        // In a more sophisticated implementation, we'd track which tiles
+        // intersect with the GeoTIFF bounds
+        return undefined;
+    }
+    /**
+     * Get the tiling scheme
+     */
+    getTilingScheme() {
+        return this.tilingScheme;
+    }
+    /**
+     * Get the maximum geometric error allowed at a specific level
+     * Required by Cesium's TerrainProvider interface
+     *
+     * The geometric error is the difference (in meters) between the actual terrain
+     * and the terrain approximation at this level. Higher levels have lower error.
+     */
+    getLevelMaximumGeometricError(level) {
+        // Standard geometric error calculation for terrain providers
+        // Based on Cesium's approach: error decreases exponentially with level
+        // Formula: maximumRadius / (tileWidth * (2^level))
+        const ellipsoid = this.tilingScheme.ellipsoid;
+        const maximumRadius = ellipsoid.maximumRadius;
+        const tileWidth = 65; // Standard heightmap width
+        return maximumRadius / (tileWidth * Math.pow(2, level));
+    }
+    loadTileDataAvailability(_x, _y, _level) {
+        return undefined;
+    }
+    /**
+     * Check if tile data is available for a specific tile
+     * Required by Cesium's TerrainProvider interface
+     */
+    getTileDataAvailable(x, y, level) {
+        if (!this.ready) {
+            return false;
+        }
+        // Check if tile intersects with GeoTIFF bounds
+        const rectangle = this.tilingScheme.tileXYToRectangle(x, y, level);
+        const west = this.Cesium.Math.toDegrees(rectangle.west);
+        const south = this.Cesium.Math.toDegrees(rectangle.south);
+        const east = this.Cesium.Math.toDegrees(rectangle.east);
+        const north = this.Cesium.Math.toDegrees(rectangle.north);
+        const [geoWest, geoSouth, geoEast, geoNorth] = this.wgs84Bounds;
+        // Return true if tile intersects with GeoTIFF bounds
+        return !(east < geoWest ||
+            west > geoEast ||
+            north < geoSouth ||
+            south > geoNorth);
+    }
+    /**
+     * Check if the provider is ready
+     */
+    get readyPromise() {
+        return this._readyPromise;
+    }
+    /**
+     * Get the credit to display
+     */
+    get credit() {
+        return new this.Cesium.Credit('GeoTIFF Terrain');
+    }
+    /**
+     * Check if the provider has water mask
+     */
+    get hasWaterMask() {
+        return false;
+    }
+    /**
+     * Check if the provider has vertex normals
+     */
+    get hasVertexNormals() {
+        return false;
+    }
+    /**
+     * Get the error event
+     */
+    get errorEvent() {
+        return new this.Cesium.Event();
+    }
+}
+/**
+ * Factory function to create a CesiumGeoTIFFTerrainProvider
+ */
+async function createCesiumGeoTIFFTerrainProvider(options) {
+    const provider = new CesiumGeoTIFFTerrainProvider(options);
+    await provider.readyPromise;
+    return provider;
+}
+
+// CesiumProvider.ts – relevante Ergänzungen
+const TERRAIN_GEOTIFF_LOG_PREFIX = 'v-map - cesium - terrain-geotiff - ';
+/**
+ * Entfernt das von Cesium injectWidgetsCss() eingefügte CSS.
+ * Funktioniert sowohl, wenn das Element eine ID hat,
+ * als auch wenn es keine ID besitzt (neue Cesium‑Versionen).
+ */
+function removeCesiumWidgetsCss(shadowRoot) {
+    if (!shadowRoot)
+        return;
+    // NodeList → echtes Array konvertieren
+    const styles = Array.from(shadowRoot.querySelectorAll('style'));
+    for (const style of styles) {
+        if (style.textContent?.includes('.cesium-credit-lightbox-overlay')) {
+            style.remove(); // modernes DOM‑API
+            // oder für sehr alte Browser:
+            // style.parentNode?.removeChild(style);
+            log('v-map - provider - cesium - Cesium‑Widget‑CSS entfernt');
+            break; // wir haben das gesuchte Style‑Tag gefunden
+        }
+    }
+}
+class CesiumTerrainLayer {
+    Cesium;
+    viewer;
+    provider;
+    options;
+    opacity = 1;
+    previousProvider;
+    constructor(Cesium, viewer, provider, options) {
+        this.Cesium = Cesium;
+        this.viewer = viewer;
+        this.provider = provider;
+        this.options = options ?? {};
+        this.previousProvider = viewer.terrainProvider;
+        this.viewer.terrainProvider = this.provider;
+    }
+    getOptions() {
+        return this.options;
+    }
+    setOptions(options) {
+        this.options = options;
+    }
+    getVisible() {
+        return this.viewer.scene.globe.show;
+    }
+    setVisible(value) {
+        this.viewer.scene.globe.show = value;
+    }
+    getOpacity() {
+        return this.opacity;
+    }
+    setOpacity(value) {
+        this.opacity = value;
+        const globe = this.viewer.scene.globe;
+        if (!globe.translucency) {
+            try {
+                globe.translucency = new this.Cesium.GlobeTranslucency();
+                globe.translucency.enabled = true;
+            }
+            catch (e) {
+                warn('Cesium terrain opacity not supported', e);
+                return;
+            }
+        }
+        globe.translucency.enabled = value < 1;
+        globe.translucency.frontFaceAlpha = value;
+    }
+    getZIndex() {
+        return 0;
+    }
+    async setZIndex(_zIndex) {
+        return;
+    }
+    remove() {
+        try {
+            this.viewer.terrainProvider = this.previousProvider
+                ? this.previousProvider
+                : new this.Cesium.EllipsoidTerrainProvider();
+            this.viewer.scene.globe.show = true;
+        }
+        catch (error) {
+            warn('Cesium terrain reset failed', error);
+        }
+    }
+}
+class CesiumProvider {
+    viewer;
+    Cesium;
+    layerManager;
+    shadowRoot;
+    layerGroups = new CesiumLayerGroups();
+    layerManagerMutex = new AsyncMutex();
+    layerErrorCallbacks = new Map();
+    layerErrorCleanups = new Map();
+    async init(options) {
+        this.shadowRoot = options.shadowRoot;
+        const sr = options.target.getRootNode() instanceof ShadowRoot
+            ? options.target.getRootNode()
+            : undefined;
+        await injectWidgetsCss(sr);
+        this.Cesium = await loadCesium();
+        /*
+        this.viewer = new this.Cesium.Viewer(container, {
+          terrainProvider: await this.Cesium.createWorldTerrainAsync(),
+          ...options,
+        });
+    */
+        Cesium.Ion.defaultAccessToken = null;
+        this.viewer = new this.Cesium.Viewer(options.target, {
+            baseLayer: false,
+            baseLayerPicker: false, // Remove the base layer picker if you don’t need to switch layers
+            terrainProvider: new Cesium.EllipsoidTerrainProvider(), // Use a simple ellipsoid terrain
+        });
+        //this.viewer.scene.terrainProvider..removeAll();
+        this.viewer.scene.primitives.removeAll();
+        this.viewer.scene.backgroundColor = this.Cesium.Color.WHITE;
+        this.viewer.scene.globe.baseColor = this.Cesium.Color.WHITE;
+        this.viewer.scene.globe.depthTestAgainstTerrain = false;
+        // this.viewer.terrainProvider = null;
+        /*
+        if (options.center) {
+          await this.viewer.camera.flyTo({
+            destination: this.Cesium.Cartesian3.fromDegrees(
+              options.center.longitude,
+              options.center.latitude,
+              1000,
+            ),
+          });
+        }
+          */
+        this.layerManager = new LayerManager(this.Cesium, this.viewer);
+    }
+    async destroy() {
+        removeCesiumWidgetsCss(this.shadowRoot);
+        this.viewer?.destroy();
+        this.viewer = undefined;
+    }
+    async createLayer(layerConfig, layerId) {
+        let wrapper = null;
+        switch (layerConfig.type) {
+            case 'geojson': {
+                const options = {
+                // clampToGround: true,
+                //fill: Cesium.Color.RED,
+                };
+                const geojsonConfig = layerConfig;
+                const ds = await this.createGeoJSONLayer(geojsonConfig, options);
+                wrapper = this.layerManager.addLayer(layerId, ds);
+                wrapper.setOptions(options);
+                break;
+            }
+            case 'osm': {
+                const iLayer = await this.createOSMLayer(layerConfig);
+                wrapper = this.layerManager.addLayer(layerId, iLayer);
+                break;
+            }
+            case 'google': {
+                const iLayer = await this.createGoogleLayer(layerConfig);
+                wrapper = this.layerManager.addLayer(layerId, iLayer);
+                break;
+            }
+            case 'terrain': {
+                const terrainLayer = await this.createTerrainLayer(layerConfig);
+                wrapper = this.layerManager.addCustomLayer(layerId, terrainLayer);
+                break;
+            }
+            case 'xyz': {
+                const iLayer = await this.createXYZLayer(layerConfig);
+                wrapper = this.layerManager.addLayer(layerId, iLayer);
+                break;
+            }
+            case 'wms': {
+                const iLayer = await this.addWMSLayer(layerConfig);
+                wrapper = this.layerManager.addLayer(layerId, iLayer);
+                break;
+            }
+            case 'wcs': {
+                const iLayer = await this.createWCSLayer(layerConfig);
+                wrapper = this.layerManager.addLayer(layerId, iLayer);
+                break;
+            }
+            case 'arcgis': {
+                await this.addArcGISLayer(layerConfig);
+                //todo  wrapper = this.layerManager.addLayer(layerId, iLayer);
+                break;
+            }
+            case 'wfs': {
+                const options = { clampToGround: true };
+                const wfsConfig = layerConfig;
+                const ds = await this.createWFSLayer(wfsConfig, options);
+                wrapper = this.layerManager.addLayer(layerId, ds);
+                wrapper.setOptions(options);
+                break;
+            }
+            case 'wkt': {
+                const options = { clampToGround: true };
+                const wktConfig = layerConfig;
+                const ds = await this.createWKTLayer(wktConfig, options);
+                wrapper = this.layerManager.addLayer(layerId, ds);
+                wrapper.setOptions(options);
+                break;
+            }
+            case 'geotiff': {
+                const iLayer = await this.createGeoTIFFLayer(layerConfig);
+                wrapper = this.layerManager.addLayer(layerId, iLayer);
+                break;
+            }
+            case 'tile3d': {
+                const tileset = await this.createTile3DLayer(layerConfig);
+                wrapper = this.layerManager.addLayer(layerId, tileset);
+                const tile3dConfig = layerConfig;
+                wrapper.setOptions(tile3dConfig.tilesetOptions ?? {});
+                if (tile3dConfig.cesiumStyle && 'setStyle' in wrapper) {
+                    wrapper.setStyle(tile3dConfig.cesiumStyle);
+                }
+                break;
+            }
+            case 'terrain-geotiff': {
+                const terrainLayer = await this.createGeoTIFFTerrainLayer(layerConfig);
+                wrapper = this.layerManager.addCustomLayer(layerId, terrainLayer);
+                break;
+            }
+            default:
+                throw new Error(`Unsupported layer type: ${layerConfig.type}`);
+        }
+        if (!wrapper)
+            return null;
+        // zIndex/Opacity/Visible zuerst auf dem Layer anwenden (bleiben „Originalzustand“ der Gruppe)
+        const commonProps = layerConfig;
+        if (commonProps.zIndex !== undefined)
+            await wrapper.setZIndex(commonProps.zIndex);
+        if (commonProps.opacity !== undefined)
+            wrapper.setOpacity(commonProps.opacity);
+        if (commonProps.visible !== undefined)
+            wrapper.setVisible(commonProps.visible);
+        return wrapper;
+    }
+    // ---------- Layer anlegen (mit Group & Basemap-Key) ----------
+    async addLayerToGroup(layerConfig) {
+        return await this.layerManagerMutex.runExclusive(async () => {
+            const layerId = crypto.randomUUID();
+            const wrapper = await this.createLayer(layerConfig, layerId);
+            // >>> In Gruppenverwaltung registrieren (inkl. Basemap-Key)
+            const elementId = layerConfig.layerElementId ??
+                layerConfig.elementId ??
+                null;
+            this.layerGroups.addLayerToGroup(layerConfig.groupId, typeof layerConfig.groupVisible !== undefined
+                ? layerConfig.groupVisible
+                : true, {
+                id: layerId,
+                elementId,
+                layer: wrapper,
+            });
+            // Regeln anwenden (sichtbar/basemap)
+            this.layerGroups.apply();
+            return layerId;
+        });
+    }
+    // ---------- Basemap-API analog deck ----------
+    async setBaseLayer(groupId, layerElementId) {
+        await this.layerManagerMutex.runExclusive(async () => {
+            this.layerGroups.setBasemap(groupId, layerElementId ?? null);
+            this.layerGroups.apply();
+        });
+    }
+    // Optional: Helper wie in deck.addBaseLayer(...)
+    async addBaseLayer(layerConfig, basemapid, layerElementId) {
+        if (!layerElementId || !basemapid)
+            return null;
+        return await this.layerManagerMutex.runExclusive(async () => {
+            const layerId = crypto.randomUUID();
+            const wrapper = await this.createLayer(layerConfig, layerId);
+            this.layerGroups.addLayerToGroup(layerConfig.groupId, typeof layerConfig.groupVisible !== undefined
+                ? layerConfig.groupVisible
+                : true, {
+                id: layerId,
+                elementId: layerElementId,
+                layer: wrapper,
+            });
+            this.layerGroups.setBasemap(layerConfig.groupId ?? 'basemap', basemapid);
+            this.layerGroups.apply();
+            return layerId;
+        });
+    }
+    async ensureGroup(groupId, visible, _opts) {
+        this.layerGroups.ensureGroup(groupId, visible);
+    }
+    // ---------- Sichtbarkeit/Z-Index/Opacity bleiben wie gehabt ----------
+    async setGroupVisible(groupId, visible) {
+        this.layerGroups.setGroupVisible(groupId, visible);
+        this.layerGroups.apply();
+    }
+    // ── Runtime error listeners ──────────────────────────────────────
+    onLayerError(layerId, callback) {
+        this.layerErrorCallbacks.set(layerId, callback);
+        this.attachCesiumErrorListeners(layerId);
+    }
+    offLayerError(layerId) {
+        this.layerErrorCleanups.get(layerId)?.();
+        this.layerErrorCleanups.delete(layerId);
+        this.layerErrorCallbacks.delete(layerId);
+    }
+    attachCesiumErrorListeners(layerId) {
+        this.layerErrorCleanups.get(layerId)?.();
+        const cb = this.layerErrorCallbacks.get(layerId);
+        if (!cb)
+            return;
+        const iLayer = this.layerManager.getLayer(layerId);
+        if (!iLayer)
+            return;
+        const cleanups = [];
+        const handler = () => { cb({ type: 'network', message: 'Tile load error' }); };
+        // ImageryLayer: access provider.errorEvent
+        const nativeLayer = iLayer._imageryLayer;
+        if (nativeLayer?.imageryProvider?.errorEvent) {
+            const unsub = nativeLayer.imageryProvider.errorEvent.addEventListener(handler);
+            cleanups.push(unsub);
+        }
+        // Cesium3DTileset: tileFailed event
+        const tileset = iLayer._tileset;
+        if (tileset?.tileFailed) {
+            const unsub = tileset.tileFailed.addEventListener(handler);
+            cleanups.push(unsub);
+        }
+        if (cleanups.length > 0) {
+            this.layerErrorCleanups.set(layerId, () => cleanups.forEach(fn => fn()));
+        }
+    }
+    async removeLayer(layerId) {
+        if (!layerId)
+            return;
+        this.offLayerError(layerId);
+        await this.layerManagerMutex.runExclusive(async () => {
+            this.layerManager.removeLayer(layerId);
+            this.layerGroups.removeLayer(layerId, true);
+            this.layerGroups.apply();
+        });
+    }
+    // updateLayer, setOpacity, setZIndex, setVisible bleiben – du änderst damit den
+    // „Originalzustand“ der Layer. Danach LayerGroups.apply() aufrufen, damit
+    // Gruppen-/Basemap-Regeln sofort wieder durchgesetzt werden:
+    async setOpacity(layerId, opacity) {
+        this.layerManager.setOpacity(layerId, opacity);
+        this.layerGroups.apply();
+    }
+    async setVisible(layerId, visible) {
+        this.layerManager.setVisible(layerId, visible);
+        this.layerGroups.apply();
+    }
+    async setZIndex(layerId, zIndex) {
+        // Note: layerManager.setZIndex calls layer.setZIndex which is async (returns Promise<void>)
+        // even though the manager method itself is not marked as async. The await is kept here
+        // for future compatibility when the manager method becomes properly async.
+        await this.layerManager.setZIndex(layerId, zIndex);
+        // Z-Order ist unabhängig von Basemap/Group-Visible, aber apply() schadet nicht
+        this.layerGroups.apply();
+    }
+    // ========== Enhanced Styling Helper Methods ==========
+    /**
+     * Apply Geostyler styling to a GeoJsonDataSource
+     */
+    applyGeostylerStyling(dataSource, geostylerStyle) {
+        dataSource.__vmapLockOpacity = true;
+        // Helper to extract static value from GeoStyler property
+        const getValue = (prop, defaultValue) => {
+            if (prop === undefined || prop === null)
+                return defaultValue;
+            // If it's a GeoStyler function object, we can't evaluate it here - return default
+            if (typeof prop === 'object' && prop !== null && 'name' in prop)
+                return defaultValue;
+            return prop;
+        };
+        const toNumber = (value, fallback) => {
+            if (value == null)
+                return fallback;
+            if (typeof value === 'number')
+                return value;
+            const n = Number(value);
+            return Number.isFinite(n) ? n : fallback;
+        };
+        const entities = dataSource.entities.values;
+        if (geostylerStyle.rules) {
+            for (const rule of geostylerStyle.rules) {
+                if (rule.symbolizers) {
+                    for (const symbolizer of rule.symbolizers) {
+                        for (let i = 0; i < entities.length; i++) {
+                            const entity = entities[i];
+                            switch (symbolizer.kind) {
+                                case 'Fill':
+                                    if (entity.polygon) {
+                                        const fillColor = getValue(symbolizer.color, 'rgba(0,100,255,0.3)');
+                                        const fillOpacity = toNumber(getValue(symbolizer.opacity, 0.3), 0.3);
+                                        const outlineColor = getValue(symbolizer.outlineColor, 'rgba(0,100,255,1)');
+                                        const outlineWidth = getValue(symbolizer.outlineWidth, 1);
+                                        let polygonColor = this.parseCesiumColor(fillColor, this.Cesium.Color.BLUE.withAlpha(0.3));
+                                        if (fillOpacity !== undefined && fillOpacity !== null) {
+                                            polygonColor = this.applyCesiumOpacity(polygonColor, fillOpacity);
+                                        }
+                                        //outline color
+                                        const outlineCesiumColor = this.parseCesiumColor(outlineColor, this.Cesium.Color.BLUE);
+                                        log('v-map - provider - cesium - applyGeostylerStyling: Fill', {
+                                            fillColor,
+                                            fillOpacity,
+                                            computedFill: polygonColor?.toString?.(),
+                                            outlineColor,
+                                            outlineWidth,
+                                        });
+                                        //fill
+                                        entity.polygon.fill = new this.Cesium.ConstantProperty(true);
+                                        //fill color
+                                        entity.polygon.material =
+                                            new this.Cesium.ColorMaterialProperty(polygonColor);
+                                        //outline
+                                        entity.polygon.outline = new this.Cesium.ConstantProperty(true);
+                                        entity.polygon.outlineColor =
+                                            new this.Cesium.ConstantProperty(outlineCesiumColor);
+                                        entity.polygon.outlineWidth =
+                                            new this.Cesium.ConstantProperty(outlineWidth);
+                                        //entity.polygon.height = new this.Cesium.ConstantProperty(0);
+                                        //
+                                        entity.polygon.extrudedHeight = undefined;
+                                        entity.polygon.heightReference =
+                                            new this.Cesium.ConstantProperty(this.Cesium.HeightReference.CLAMP_TO_GROUND);
+                                        entity.polygon.perPositionHeight =
+                                            new this.Cesium.ConstantProperty(false);
+                                        entity.polygon.classificationType =
+                                            new this.Cesium.ConstantProperty(this.Cesium.ClassificationType.BOTH);
+                                    }
+                                    break;
+                                case 'Line':
+                                    if (entity.polyline) {
+                                        const lineColor = getValue(symbolizer.color, 'rgba(0,100,255,1)');
+                                        const lineWidth = toNumber(getValue(symbolizer.width, 2), 2);
+                                        const lineOpacity = toNumber(getValue(symbolizer.opacity, 1), 1);
+                                        let materialColor = this.parseCesiumColor(lineColor, this.Cesium.Color.BLUE);
+                                        if (lineOpacity !== undefined && lineOpacity !== null) {
+                                            materialColor = this.applyCesiumOpacity(materialColor, lineOpacity);
+                                        }
+                                        log('v-map - provider - cesium - applyGeostylerStyling: Line', {
+                                            lineColor,
+                                            lineOpacity,
+                                            computedColor: materialColor?.toString?.(),
+                                            lineWidth,
+                                        });
+                                        entity.polyline.material =
+                                            new this.Cesium.ColorMaterialProperty(materialColor);
+                                        entity.polyline.width = new this.Cesium.ConstantProperty(lineWidth);
+                                    }
+                                    break;
+                                case 'Mark':
+                                    if (entity.point) {
+                                        const pointColor = getValue(symbolizer.color, 'rgba(0,100,255,1)');
+                                        const pointRadius = toNumber(getValue(symbolizer.radius, 6), 6);
+                                        const pointOpacity = toNumber(getValue(symbolizer.opacity, 1), 1);
+                                        let materialColor = this.parseCesiumColor(pointColor, this.Cesium.Color.BLUE);
+                                        if (pointOpacity !== undefined && pointOpacity !== null) {
+                                            materialColor = this.applyCesiumOpacity(materialColor, pointOpacity);
+                                        }
+                                        log('v-map - provider - cesium - applyGeostylerStyling: Mark', {
+                                            pointColor,
+                                            pointOpacity,
+                                            computedColor: materialColor?.toString?.(),
+                                            pointRadius,
+                                        });
+                                        entity.point.color = new this.Cesium.ConstantProperty(materialColor);
+                                        entity.point.pixelSize = new this.Cesium.ConstantProperty(pointRadius);
+                                    }
+                                    break;
+                                case 'Icon':
+                                    if (entity.point) {
+                                        const iconSrc = getValue(symbolizer.image);
+                                        const iconSize = toNumber(getValue(symbolizer.size, 32), 32);
+                                        const iconOpacity = toNumber(getValue(symbolizer.opacity, 1), 1);
+                                        if (iconSrc && typeof iconSrc === 'string') {
+                                            entity.billboard = new this.Cesium.BillboardGraphics({
+                                                image: new this.Cesium.ConstantProperty(iconSrc),
+                                                width: new this.Cesium.ConstantProperty(iconSize),
+                                                height: new this.Cesium.ConstantProperty(iconSize),
+                                                verticalOrigin: new this.Cesium.ConstantProperty(this.Cesium.VerticalOrigin.BOTTOM),
+                                                color: iconOpacity !== undefined && iconOpacity !== null
+                                                    ? new this.Cesium.ConstantProperty(this.Cesium.Color.WHITE.withAlpha(iconOpacity))
+                                                    : undefined,
+                                            });
+                                            entity.point.show = new this.Cesium.ConstantProperty(false);
+                                            log('v-map - provider - cesium - applyGeostylerStyling: Icon', {
+                                                iconSrc,
+                                                iconSize,
+                                                iconOpacity,
+                                            });
+                                        }
+                                    }
+                                    break;
+                                case 'Text':
+                                    const labelExpr = symbolizer.label;
+                                    const labelProp = typeof labelExpr === 'string' ? labelExpr : undefined;
+                                    if (labelProp &&
+                                        entity.properties &&
+                                        entity.properties[labelProp]) {
+                                        const textColor = getValue(symbolizer.color, '#000000');
+                                        const textSize = toNumber(getValue(symbolizer.size, 12), 12);
+                                        const textOpacity = toNumber(getValue(symbolizer.opacity, 1), 1);
+                                        let labelColor = this.parseCesiumColor(textColor, this.Cesium.Color.WHITE);
+                                        if (textOpacity !== undefined && textOpacity !== null) {
+                                            labelColor = this.applyCesiumOpacity(labelColor, textOpacity);
+                                        }
+                                        log('v-map - provider - cesium - applyGeostylerStyling: Text', {
+                                            labelProp,
+                                            textColor,
+                                            textOpacity,
+                                            computedColor: labelColor?.toString?.(),
+                                            textSize,
+                                        });
+                                        const textValue = entity.properties[labelProp]?.getValue?.(this.viewer.clock.currentTime) ??
+                                            entity.properties[labelProp]?._value ??
+                                            '';
+                                        entity.label = new this.Cesium.LabelGraphics({
+                                            text: new this.Cesium.ConstantProperty(String(textValue)),
+                                            font: new this.Cesium.ConstantProperty(`${textSize}px Arial`),
+                                            fillColor: new this.Cesium.ConstantProperty(labelColor),
+                                            verticalOrigin: new this.Cesium.ConstantProperty(this.Cesium.VerticalOrigin.BOTTOM),
+                                        });
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Convert CSS color to Cesium Color
+     */
+    parseCesiumColor(color, defaultColor) {
+        if (!color)
+            return defaultColor;
+        // Handle hex colors
+        if (color.startsWith('#')) {
+            return this.Cesium.Color.fromCssColorString(color);
+        }
+        // Handle rgba/rgb colors
+        if (color.includes('rgb')) {
+            return this.Cesium.Color.fromCssColorString(color);
+        }
+        // Try to parse as CSS color string
+        try {
+            return this.Cesium.Color.fromCssColorString(color);
+        }
+        catch {
+            return defaultColor;
+        }
+    }
+    /**
+     * Apply opacity to Cesium color
+     */
+    applyCesiumOpacity(color, opacity) {
+        if (!color)
+            return color;
+        return color.withAlpha(opacity);
+    }
+    /**
+     * Create Cesium styling options from StyleConfig
+     */
+    createCesiumStyle(style = {}) {
+        // Default colors
+        const defaultFillColor = this.Cesium.Color.BLUE.withAlpha(0.3);
+        const defaultStrokeColor = this.Cesium.Color.BLUE;
+        const defaultPointColor = this.Cesium.Color.BLUE;
+        // Parse colors
+        const fillColor = this.parseCesiumColor(style.fillColor, defaultFillColor);
+        const strokeColor = this.parseCesiumColor(style.strokeColor, defaultStrokeColor);
+        const pointColor = this.parseCesiumColor(style.pointColor, defaultPointColor);
+        // Apply opacity
+        const finalFillColor = style.fillOpacity !== undefined
+            ? this.applyCesiumOpacity(fillColor, style.fillOpacity)
+            : fillColor;
+        const finalStrokeColor = style.strokeOpacity !== undefined
+            ? this.applyCesiumOpacity(strokeColor, style.strokeOpacity)
+            : strokeColor;
+        const finalPointColor = style.pointOpacity !== undefined
+            ? this.applyCesiumOpacity(pointColor, style.pointOpacity)
+            : pointColor;
+        return {
+            // Polygon styling
+            fill: true,
+            fillColor: finalFillColor,
+            outline: true,
+            outlineColor: finalStrokeColor,
+            outlineWidth: style.strokeWidth ?? 2,
+            extrudedHeight: style.extrudeHeight,
+            heightReference: style.zOffset
+                ? this.Cesium.HeightReference.RELATIVE_TO_GROUND
+                : this.Cesium.HeightReference.CLAMP_TO_GROUND,
+            // Point styling
+            pixelSize: style.pointRadius ?? 8,
+            color: finalPointColor,
+            scaleByDistance: style.pointRadius
+                ? new this.Cesium.NearFarScalar(1.5e2, 2.0, 1.5e7, 0.5)
+                : undefined,
+            // Line styling
+            width: style.strokeWidth ?? 2,
+            clampToGround: !style.zOffset,
+            // Text/Label styling
+            labelText: style.textProperty,
+            labelFont: style.textSize
+                ? `${style.textSize}pt monospace`
+                : '12pt monospace',
+            labelFillColor: style.textColor
+                ? this.parseCesiumColor(style.textColor, this.Cesium.Color.WHITE)
+                : this.Cesium.Color.WHITE,
+            labelOutlineColor: style.textHaloColor
+                ? this.parseCesiumColor(style.textHaloColor, this.Cesium.Color.BLACK)
+                : this.Cesium.Color.BLACK,
+            labelOutlineWidth: style.textHaloWidth ?? 1,
+            labelPixelOffset: style.textOffset
+                ? new this.Cesium.Cartesian2(style.textOffset[0], style.textOffset[1])
+                : this.Cesium.Cartesian2.ZERO,
+            // 3D specific
+            height: style.zOffset ?? 0,
+        };
+    }
+    /**
+     * Apply enhanced styling to a GeoJsonDataSource
+     */
+    applyEnhancedStyling(dataSource, style = {}) {
+        const cesiumStyle = this.createCesiumStyle(style);
+        const entities = dataSource.entities.values;
+        for (let i = 0; i < entities.length; i++) {
+            const entity = entities[i];
+            let finalStyle = cesiumStyle;
+            if (style.styleFunction && entity.properties) {
+                const feature = {
+                    properties: entity.properties._propertyNames.reduce((props, name) => {
+                        props[name] = entity.properties[name]?._value;
+                        return props;
+                    }, {}),
+                    geometry: entity,
+                };
+                const conditionalStyle = style.styleFunction(feature);
+                if (conditionalStyle) {
+                    finalStyle = {
+                        ...cesiumStyle,
+                        ...this.createCesiumStyle(conditionalStyle),
+                    };
+                }
+            }
+            if (entity.polygon) {
+                entity.polygon.fill = new this.Cesium.ConstantProperty(finalStyle.fill);
+                entity.polygon.material = new this.Cesium.ColorMaterialProperty(finalStyle.fillColor);
+                entity.polygon.outline = new this.Cesium.ConstantProperty(finalStyle.outline);
+                entity.polygon.outlineColor = new this.Cesium.ConstantProperty(finalStyle.outlineColor);
+                entity.polygon.outlineWidth = new this.Cesium.ConstantProperty(finalStyle.outlineWidth);
+                entity.polygon.height =
+                    finalStyle.height !== undefined
+                        ? new this.Cesium.ConstantProperty(finalStyle.height)
+                        : undefined;
+                entity.polygon.extrudedHeight =
+                    finalStyle.extrudedHeight !== undefined
+                        ? new this.Cesium.ConstantProperty(finalStyle.extrudedHeight)
+                        : undefined;
+                entity.polygon.heightReference =
+                    finalStyle.heightReference !== undefined
+                        ? new this.Cesium.ConstantProperty(finalStyle.heightReference)
+                        : undefined;
+            }
+            if (entity.polyline) {
+                entity.polyline.material = new this.Cesium.ColorMaterialProperty(finalStyle.outlineColor);
+                entity.polyline.width = new this.Cesium.ConstantProperty(finalStyle.width);
+                entity.polyline.clampToGround = new this.Cesium.ConstantProperty(finalStyle.clampToGround);
+            }
+            if (entity.point) {
+                entity.point.pixelSize = new this.Cesium.ConstantProperty(finalStyle.pixelSize);
+                entity.point.color = new this.Cesium.ConstantProperty(finalStyle.color);
+                const scaleByDistance = finalStyle.scaleByDistance;
+                entity.point.scaleByDistance = scaleByDistance
+                    ? new this.Cesium.ConstantProperty(scaleByDistance)
+                    : undefined;
+                if (style.iconUrl) {
+                    entity.billboard = new this.Cesium.BillboardGraphics({
+                        image: new this.Cesium.ConstantProperty(style.iconUrl),
+                        width: new this.Cesium.ConstantProperty(style.iconSize ? style.iconSize[0] : 32),
+                        height: new this.Cesium.ConstantProperty(style.iconSize ? style.iconSize[1] : 32),
+                        verticalOrigin: new this.Cesium.ConstantProperty(this.Cesium.VerticalOrigin.BOTTOM),
+                        scaleByDistance: scaleByDistance
+                            ? new this.Cesium.ConstantProperty(scaleByDistance)
+                            : undefined,
+                    });
+                    entity.point.show = new this.Cesium.ConstantProperty(false);
+                }
+            }
+            if (style.textProperty &&
+                entity.properties &&
+                entity.properties[style.textProperty]) {
+                const textValue = entity.properties[style.textProperty]?.getValue?.(this.viewer.clock.currentTime) ??
+                    entity.properties[style.textProperty]?._value ??
+                    '';
+                entity.label = new this.Cesium.LabelGraphics({
+                    text: new this.Cesium.ConstantProperty(String(textValue)),
+                    font: new this.Cesium.ConstantProperty(finalStyle.labelFont),
+                    fillColor: new this.Cesium.ConstantProperty(finalStyle.labelFillColor),
+                    outlineColor: new this.Cesium.ConstantProperty(finalStyle.labelOutlineColor),
+                    outlineWidth: new this.Cesium.ConstantProperty(finalStyle.labelOutlineWidth),
+                    pixelOffset: new this.Cesium.ConstantProperty(finalStyle.labelPixelOffset),
+                    verticalOrigin: new this.Cesium.ConstantProperty(this.Cesium.VerticalOrigin.BOTTOM),
+                });
+            }
+        }
+    }
+    async createWKTLayer(config, options) {
+        const geoJsonData = await this.wktToGeoJSON(config);
+        const dataSource = await this.Cesium.GeoJsonDataSource.load(geoJsonData, options);
+        // Apply geostyler style if provided, otherwise use enhanced styling
+        if (config.geostylerStyle) {
+            this.applyGeostylerStyling(dataSource, config.geostylerStyle);
+        }
+        else if (config.style) {
+            this.applyEnhancedStyling(dataSource, config.style);
+        }
+        return dataSource;
+    }
+    async wktToGeoJSON(config) {
+        const wktText = await this.resolveWktText(config);
+        const wellknownModule = await import('./index-BUHa4Jj0.js').then(function (n) { return n.i; });
+        const parseFn = typeof wellknownModule.default === 'function'
+            ? wellknownModule.default
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- wellknown has inconsistent module exports across bundlers
+            : wellknownModule.parse;
+        if (typeof parseFn !== 'function') {
+            throw new Error('wellknown parser not available');
+        }
+        const geometry = parseFn(wktText);
+        if (!geometry) {
+            throw new Error('Failed to parse WKT');
+        }
+        return {
+            type: 'FeatureCollection',
+            features: [
+                {
+                    type: 'Feature',
+                    properties: {},
+                    geometry,
+                },
+            ],
+        };
+    }
+    async resolveWktText(config) {
+        if (config.wkt)
+            return config.wkt;
+        if (config.url) {
+            const response = await fetch(config.url);
+            if (!response.ok)
+                throw new Error(`Failed to fetch WKT: ${response.status}`);
+            return await response.text();
+        }
+        throw new Error('Either wkt or url must be provided');
+    }
+    async createGeoJSONLayer(config, options) {
+        let geojson_or_url = null;
+        if (config.geojson) {
+            geojson_or_url = JSON.parse(config.geojson);
+        }
+        else {
+            geojson_or_url = config.url;
+        }
+        //https://cesium.com/learn/ion-sdk/ref-doc/GeoJsonDataSource.html
+        const dataSource = await this.Cesium.GeoJsonDataSource.load(geojson_or_url, options);
+        // Apply geostyler style if provided, otherwise use enhanced styling
+        if (config.geostylerStyle) {
+            this.applyGeostylerStyling(dataSource, config.geostylerStyle);
+        }
+        else if (config.style) {
+            this.applyEnhancedStyling(dataSource, config.style);
+        }
+        return dataSource;
+    }
+    async createWFSLayer(config, options) {
+        // Fetch GeoJSON from WFS server
+        const geojson = await this.fetchWFSFromUrl(config);
+        // Load GeoJSON into Cesium DataSource
+        const dataSource = await this.Cesium.GeoJsonDataSource.load(geojson, options);
+        // Apply geostyler style if provided, otherwise use enhanced styling
+        if (config.geostylerStyle) {
+            this.applyGeostylerStyling(dataSource, config.geostylerStyle);
+        }
+        else if (config.style) {
+            this.applyEnhancedStyling(dataSource, config.style);
+        }
+        return dataSource;
+    }
+    async createOSMLayer(cfg) {
+        return new this.Cesium.ImageryLayer(new this.Cesium.OpenStreetMapImageryProvider({
+            url: cfg.url || 'https://a.tile.openstreetmap.org',
+        }));
+    }
+    async createGoogleLayer(config) {
+        if (!config.apiKey) {
+            throw new Error("Google-Layer benötigt 'apiKey' (Google Maps Platform).");
+        }
+        // Load Google Maps JavaScript API
+        await this.loadGoogleMapsApi(config.apiKey, {
+            language: config.language,
+            region: config.region,
+            libraries: config.libraries,
+        });
+        const mapType = config.mapType || 'roadmap';
+        const googleMapTypeId = this.getGoogleMapTypeId(mapType);
+        // Use a simpler approach with UrlTemplateImageryProvider and custom URL generator
+        const Cesium = this.Cesium;
+        // Create a custom URL template that we'll handle in the urlSchemeZeroPadding function
+        const customUrlTemplate = 'https://maps.googleapis.com/maps/api/staticmap?template';
+        const googleImageryProvider = new Cesium.UrlTemplateImageryProvider({
+            url: customUrlTemplate,
+            maximumLevel: config.maxZoom || 19,
+            minimumLevel: 0,
+            tilingScheme: new Cesium.WebMercatorTilingScheme(),
+            credit: 'Google Maps',
+            // Override URL generation using urlSchemeZeroPadding as a custom URL builder
+            urlSchemeZeroPadding: {
+                '{x}': '',
+                '{y}': '',
+                '{z}': '',
+            },
+        });
+        // Override the buildImageResource method to use Google Static Maps API
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- monkey-patching internal Cesium method not exposed in typings
+        googleImageryProvider.buildImageResource = function (x, y, level) {
+            const tilingScheme = new Cesium.WebMercatorTilingScheme();
+            const rectangle = tilingScheme.tileXYToRectangle(x, y, level);
+            const west = Cesium.Math.toDegrees(rectangle.west);
+            const south = Cesium.Math.toDegrees(rectangle.south);
+            const east = Cesium.Math.toDegrees(rectangle.east);
+            const north = Cesium.Math.toDegrees(rectangle.north);
+            // Center point of the tile
+            const centerLat = (south + north) / 2;
+            const centerLng = (west + east) / 2;
+            // Build Google Static Maps API URL
+            const params = new URLSearchParams({
+                center: `${centerLat},${centerLng}`,
+                zoom: level.toString(),
+                size: '256x256',
+                scale: config.scale === 'scaleFactor1x' ? '1' : '2',
+                maptype: googleMapTypeId,
+                key: config.apiKey,
+                format: 'png',
+            });
+            if (config.language) {
+                params.set('language', config.language);
+            }
+            if (config.region) {
+                params.set('region', config.region);
+            }
+            const url = `https://maps.googleapis.com/maps/api/staticmap?${params.toString()}`;
+            return new Cesium.Resource({ url });
+        };
+        // Add Google logo for compliance
+        this.ensureGoogleLogo();
+        return new this.Cesium.ImageryLayer(googleImageryProvider, {
+            alpha: config.opacity ?? 1,
+            show: config.visible ?? true,
+        });
+    }
+    getGoogleMapTypeId(mapType) {
+        switch (mapType) {
+            case 'roadmap':
+                return 'roadmap';
+            case 'satellite':
+                return 'satellite';
+            case 'terrain':
+                return 'terrain';
+            case 'hybrid':
+                return 'hybrid';
+            default:
+                return 'roadmap';
+        }
+    }
+    /**
+     * Load Google Maps JavaScript API
+     */
+    async loadGoogleMapsApi(apiKey, opts) {
+        const w = window;
+        const mockLoader = w.__mockGoogleMapsApi;
+        if (typeof mockLoader === 'function') {
+            await mockLoader(apiKey, opts);
+            return;
+        }
+        if (w.google?.maps)
+            return;
+        await new Promise((resolve, reject) => {
+            const cbName = '___cesiumGoogleInit___' + Math.random().toString(36).slice(2);
+            w[cbName] = () => resolve();
+            const script = document.createElement('script');
+            const params = new URLSearchParams({
+                key: apiKey,
+                callback: cbName,
+                v: 'weekly',
+            });
+            if (opts?.language)
+                params.set('language', opts.language);
+            if (opts?.region)
+                params.set('region', opts.region);
+            if (opts?.libraries?.length)
+                params.set('libraries', opts.libraries.join(','));
+            script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+            script.async = true;
+            script.onerror = () => reject(new Error('Google Maps JS API failed to load'));
+            document.head.appendChild(script);
+        });
+    }
+    /**
+     * Add Google logo for compliance
+     */
+    ensureGoogleLogo() {
+        if (!this.viewer?.container ||
+            this.viewer.container._googleLogoAdded)
+            return;
+        const logo = document.createElement('img');
+        logo.src =
+            'https://developers.google.com/static/maps/documentation/images/google_on_white.png';
+        logo.alt = 'Google';
+        logo.style.position = 'absolute';
+        logo.style.bottom = '6px';
+        logo.style.left = '6px';
+        logo.style.height = '18px';
+        logo.style.pointerEvents = 'none';
+        logo.style.zIndex = '1000';
+        this.viewer.container.appendChild(logo);
+        this.viewer.container._googleLogoAdded = true;
+    }
+    async createXYZLayer(config) {
+        if (!config.url) {
+            throw new Error('XYZ layer requires a url');
+        }
+        const credit = Array.isArray(config.attributions)
+            ? config.attributions.join(', ')
+            : config.attributions;
+        const providerOptions = {
+            url: config.url,
+            credit,
+            maximumLevel: config.maxZoom,
+            ...(config.options || {}),
+        };
+        const provider = new this.Cesium.UrlTemplateImageryProvider(providerOptions);
+        const layerOptions = {
+            alpha: config.opacity ?? 1,
+            show: config.visible ?? true,
+        };
+        return new this.Cesium.ImageryLayer(provider, layerOptions);
+    }
+    async createTerrainLayer(config) {
+        let provider;
+        if (config.elevationData) {
+            provider = await this.Cesium.CesiumTerrainProvider.fromUrl(config.elevationData);
+        }
+        else {
+            provider = await this.Cesium.createWorldTerrainAsync();
+        }
+        const layer = new CesiumTerrainLayer(this.Cesium, this.viewer, provider, config);
+        if (config.visible !== undefined) {
+            layer.setVisible(config.visible);
+        }
+        if (config.opacity !== undefined) {
+            layer.setOpacity(config.opacity);
+        }
+        return layer;
+    }
+    /**
+     * Create GeoTIFF Terrain Layer
+     * Loads GeoTIFF elevation data and provides it as terrain
+     */
+    async createGeoTIFFTerrainLayer(config) {
+        // If no URL is set, return a fallback layer with EllipsoidTerrainProvider
+        if (!config.url) {
+            log(`${TERRAIN_GEOTIFF_LOG_PREFIX}layer created without URL, waiting for URL to load`);
+            const fallbackProvider = new this.Cesium.EllipsoidTerrainProvider();
+            const layer = new CesiumTerrainLayer(this.Cesium, this.viewer, fallbackProvider, config);
+            // Set to invisible since there's no terrain data
+            layer.setVisible(false);
+            return layer;
+        }
+        try {
+            log(`${TERRAIN_GEOTIFF_LOG_PREFIX}create layer: url=${config.url}`);
+            // Create the custom GeoTIFF terrain provider
+            const provider = await createCesiumGeoTIFFTerrainProvider({
+                url: config.url,
+                projection: config.projection,
+                forceProjection: config.forceProjection,
+                nodata: config.nodata,
+                Cesium: this.Cesium,
+            });
+            // Wrap it in a CesiumTerrainLayer
+            // Cast config to terrain type since CesiumTerrainLayer expects it
+            const layer = new CesiumTerrainLayer(this.Cesium, this.viewer, provider, config);
+            if (config.visible !== undefined) {
+                layer.setVisible(config.visible);
+            }
+            if (config.opacity !== undefined) {
+                layer.setOpacity(config.opacity);
+            }
+            log(`${TERRAIN_GEOTIFF_LOG_PREFIX}layer created successfully`);
+            return layer;
+        }
+        catch (err) {
+            error(`${TERRAIN_GEOTIFF_LOG_PREFIX}failed to create terrain layer:`, err);
+            // Return a fallback with EllipsoidTerrainProvider
+            const fallbackProvider = new this.Cesium.EllipsoidTerrainProvider();
+            return new CesiumTerrainLayer(this.Cesium, this.viewer, fallbackProvider, config);
+        }
+    }
+    async addWMSLayer(config) {
+        return new this.Cesium.ImageryLayer(new this.Cesium.WebMapServiceImageryProvider({
+            url: config.url,
+            layers: config.layers,
+            parameters: config.extraParams,
+        }));
+    }
+    /**
+     * Create WCS (Web Coverage Service) ImageryLayer
+     * Supports WCS 2.0.1 (subset) and 1.x.x (BBOX) versions
+     */
+    async createWCSLayer(config) {
+        if (!config.url || !config.coverageName) {
+            throw new Error('WCS layer requires url and coverageName');
+        }
+        const version = config.version ?? '2.0.1';
+        const format = config.format ?? 'image/tiff';
+        const projection = config.projection ?? 'EPSG:4326';
+        const tileSize = config.tileSize ?? 256;
+        const Cesium = this.Cesium;
+        // Create a custom URL template - will be overridden by buildImageResource
+        const customUrlTemplate = `${config.url}?wcs_placeholder`;
+        const wcsImageryProvider = new Cesium.UrlTemplateImageryProvider({
+            url: customUrlTemplate,
+            maximumLevel: config.maxZoom ?? 18,
+            minimumLevel: config.minZoom ?? 0,
+            tileWidth: tileSize,
+            tileHeight: tileSize,
+            tilingScheme: new Cesium.GeographicTilingScheme(),
+            credit: 'WCS',
+        });
+        // Override the buildImageResource method to generate WCS GetCoverage URLs
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- monkey-patching internal Cesium method not exposed in typings
+        wcsImageryProvider.buildImageResource = function (x, y, level) {
+            const tilingScheme = new Cesium.GeographicTilingScheme();
+            const rectangle = tilingScheme.tileXYToRectangle(x, y, level);
+            // Convert to degrees
+            const west = Cesium.Math.toDegrees(rectangle.west);
+            const south = Cesium.Math.toDegrees(rectangle.south);
+            const east = Cesium.Math.toDegrees(rectangle.east);
+            const north = Cesium.Math.toDegrees(rectangle.north);
+            const baseParams = {
+                SERVICE: 'WCS',
+                REQUEST: 'GetCoverage',
+                VERSION: version,
+                FORMAT: format,
+            };
+            let url;
+            // WCS 2.0.1 uses subset parameters
+            if (version.startsWith('2.0')) {
+                const params = {
+                    ...baseParams,
+                    coverageId: config.coverageName,
+                    ...(config.params || {}),
+                };
+                // Add GeoTIFF compression if format is tiff
+                if (format.includes('tiff') || format.includes('geotiff')) {
+                    params['geotiff:compression'] = 'LZW';
+                }
+                // Build query string
+                const query = new URLSearchParams();
+                Object.entries(params).forEach(([key, value]) => {
+                    if (value !== undefined && value !== null) {
+                        query.set(key, String(value));
+                    }
+                });
+                const queryString = query.toString();
+                const subsetX = `subset=X(${west},${east})`;
+                const subsetY = `subset=Y(${south},${north})`;
+                url = `${config.url}${config.url.includes('?') ? '&' : '?'}${queryString}&${subsetX}&${subsetY}`;
+            }
+            // WCS 1.x.x uses BBOX parameter
+            else {
+                const params = {
+                    ...baseParams,
+                    COVERAGE: config.coverageName,
+                    BBOX: `${west},${south},${east},${north}`,
+                    CRS: projection,
+                    WIDTH: String(tileSize),
+                    HEIGHT: String(tileSize),
+                    ...(config.params || {}),
+                };
+                const query = new URLSearchParams();
+                Object.entries(params).forEach(([key, value]) => {
+                    if (value !== undefined && value !== null) {
+                        query.set(key, String(value));
+                    }
+                });
+                url = `${config.url}${config.url.includes('?') ? '&' : '?'}${query.toString()}`;
+            }
+            return new Cesium.Resource({ url });
+        };
+        return new this.Cesium.ImageryLayer(wcsImageryProvider, {
+            alpha: config.opacity ?? 1,
+            show: config.visible ?? true,
+        });
+    }
+    async addArcGISLayer(config) {
+        //"https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer"
+        const provider = await this.Cesium.ArcGisMapServerImageryProvider.fromUrl(config.url);
+        this.viewer.imageryLayers.addImageryProvider(provider);
+    }
+    async createGeoTIFFLayer(config) {
+        if (!config.url) {
+            throw new Error('GeoTIFF layer requires a URL');
+        }
+        // The GeoTIFFImageryProvider always uses WebMercatorTilingScheme,
+        // so the tile processor must reproject into EPSG:3857 to match
+        // the tile coordinate math (x,y,z → bounds).
+        const viewProjection = 'EPSG:3857';
+        try {
+            const geotiffExtra = config;
+            const source = await getGeoTIFFSource(config.url, geotiffExtra.projection, geotiffExtra.forceProjection, config.nodata);
+            const tileProcessorConfig = await getTileProcessorConfig(source, viewProjection);
+            const tileProcessor = new GeoTIFFTileProcessor(tileProcessorConfig);
+            tileProcessor.createGlobalTriangulation();
+            let colorStops;
+            if (config.colorMap) {
+                const { stops } = getColorStops(config.colorMap, config.valueRange);
+                colorStops = stops;
+            }
+            const geotiffRenderExtra = config;
+            const tileSize = geotiffRenderExtra.tileSize ?? 256;
+            const resolution = geotiffRenderExtra.resolution ?? 1.0;
+            const resampleMethod = geotiffRenderExtra.resampleMethod ?? 'bilinear';
+            const imageryProvider = new GeoTIFFImageryProvider({
+                Cesium: this.Cesium,
+                rectangleDegrees: source.wgs84Bounds,
+                tileProcessor,
+                tileSize,
+                resolution,
+                resampleMethod,
+                colorStops,
+            });
+            const layer = new this.Cesium.ImageryLayer(imageryProvider, {
+                alpha: config.opacity ?? 1.0,
+                show: config.visible ?? true,
+            });
+            layer.__vmapGeoTIFFMeta = {
+                url: config.url,
+                width: source.width,
+                height: source.height,
+                samplesPerPixel: source.samplesPerPixel,
+                noData: source.noDataValue,
+            };
+            return layer;
+        }
+        catch (err) {
+            error('v-map - provider - cesium - Failed to create GeoTIFF layer', err);
+            // Return a placeholder layer in case of error
+            const provider = new this.Cesium.SingleTileImageryProvider({
+                url: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
+                rectangle: this.Cesium.Rectangle.fromDegrees(-180, -90, 180, 90),
+            });
+            return new this.Cesium.ImageryLayer(provider, {
+                alpha: 0,
+                show: false,
+            });
+        }
+    }
+    async createTile3DLayer(config) {
+        if (!config.url) {
+            throw new Error('Tile3D layer requires a URL');
+        }
+        const tileset = await this.Cesium.Cesium3DTileset.fromUrl(config.url, config.tilesetOptions ?? {});
+        if (config.cesiumStyle) {
+            tileset.style = new this.Cesium.Cesium3DTileStyle(config.cesiumStyle);
+        }
+        return tileset;
+    }
+    async updateLayer(layerId, update) {
+        return await this.layerManagerMutex.runExclusive(async () => {
+            const hadErrorListener = this.layerErrorCallbacks.has(layerId);
+            if (hadErrorListener)
+                this.offLayerError(layerId);
+            const oldLayer = this.layerManager.getLayer(layerId);
+            switch (update.type) {
+                case 'geojson':
+                    {
+                        const data = update.data;
+                        const options = oldLayer.getOptions();
+                        const dataSource = await this.createGeoJSONLayer({
+                            geojson: data.geojson,
+                            url: data.url,
+                            style: data.style,
+                            geostylerStyle: data.geostylerStyle,
+                        }, options);
+                        const layer = this.layerManager.replaceLayer(layerId, oldLayer, dataSource);
+                        layer.setOptions(options);
+                    }
+                    break;
+                case 'wfs':
+                    {
+                        const data = update.data;
+                        const options = oldLayer.getOptions();
+                        const dataSource = await this.createWFSLayer(data, options);
+                        const layer = this.layerManager.replaceLayer(layerId, oldLayer, dataSource);
+                        layer.setOptions(options);
+                    }
+                    break;
+                case 'osm':
+                    {
+                        const osmOptions = oldLayer.getOptions();
+                        const osmLayer = new this.Cesium.ImageryLayer(new this.Cesium.OpenStreetMapImageryProvider({
+                            url: update.data.url || 'https://a.tile.openstreetmap.org',
+                        }));
+                        const updatedOsmlayer = this.layerManager.replaceLayer(layerId, oldLayer, osmLayer);
+                        updatedOsmlayer.setOptions(osmOptions);
+                    }
+                    break;
+                case 'google':
+                    {
+                        const googleOptions = oldLayer.getOptions();
+                        const googleLayer = await this.createGoogleLayer(update.data);
+                        const updatedGoogleLayer = this.layerManager.replaceLayer(layerId, oldLayer, googleLayer);
+                        updatedGoogleLayer.setOptions(googleOptions);
+                    }
+                    break;
+                case 'xyz':
+                    {
+                        const xyzOptions = oldLayer.getOptions();
+                        const xyzLayer = await this.createXYZLayer(update.data);
+                        const updatedXyzLayer = this.layerManager.replaceLayer(layerId, oldLayer, xyzLayer);
+                        updatedXyzLayer.setOptions(xyzOptions);
+                    }
+                    break;
+                case 'wcs':
+                    {
+                        const wcsOptions = oldLayer.getOptions();
+                        const wcsLayer = await this.createWCSLayer(update.data);
+                        const updatedWcsLayer = this.layerManager.replaceLayer(layerId, oldLayer, wcsLayer);
+                        updatedWcsLayer.setOptions(wcsOptions);
+                    }
+                    break;
+                case 'wkt':
+                    {
+                        const data = update.data;
+                        const options = oldLayer.getOptions();
+                        const dataSource = await this.createWKTLayer({
+                            wkt: data.wkt,
+                            url: data.url,
+                            style: data.style,
+                            geostylerStyle: data.geostylerStyle,
+                        }, options);
+                        const layer = this.layerManager.replaceLayer(layerId, oldLayer, dataSource);
+                        layer.setOptions(options);
+                    }
+                    break;
+                case 'geotiff':
+                    {
+                        const data = update.data;
+                        const iLayer = await this.createGeoTIFFLayer({
+                            url: data.url,
+                        });
+                        this.layerManager.replaceLayer(layerId, oldLayer, iLayer);
+                    }
+                    break;
+                case 'tile3d':
+                    {
+                        const data = update.data ?? {};
+                        if (!data.url) {
+                            throw new Error('tile3d update requires a url');
+                        }
+                        const layer = await this.createTile3DLayer({
+                            type: 'tile3d',
+                            url: data.url,
+                            tilesetOptions: data.tilesetOptions,
+                            cesiumStyle: data.cesiumStyle,
+                        });
+                        const updatedLayer = this.layerManager.replaceLayer(layerId, oldLayer, layer);
+                        updatedLayer.setOptions(data.tilesetOptions ?? {});
+                        if (data.cesiumStyle && 'setStyle' in updatedLayer) {
+                            updatedLayer.setStyle(data.cesiumStyle);
+                        }
+                    }
+                    break;
+                case 'tile3d-style':
+                    {
+                        const data = update.data ?? {};
+                        if ('setStyle' in oldLayer) {
+                            const stylePayload = data.style ?? {};
+                            oldLayer.setStyle(stylePayload);
+                        }
+                    }
+                    break;
+                case 'terrain':
+                    {
+                        const previousOptions = oldLayer.getOptions();
+                        const visible = oldLayer.getVisible();
+                        const opacity = oldLayer.getOpacity();
+                        oldLayer.remove();
+                        const terrainLayer = await this.createTerrainLayer({
+                            type: 'terrain',
+                            ...previousOptions,
+                            ...(update.data ?? {}),
+                        });
+                        const wrapped = this.layerManager.addCustomLayer(layerId, terrainLayer);
+                        wrapped.setVisible(visible);
+                        wrapped.setOpacity(opacity);
+                    }
+                    break;
+                case 'terrain-geotiff':
+                    {
+                        //const previousOptions = oldLayer.getOptions();
+                        //const visible = oldLayer.getVisible();
+                        //const opacity = oldLayer.getOpacity();
+                        oldLayer.remove();
+                        const terrainLayer = await this.createGeoTIFFTerrainLayer({
+                            type: 'terrain-geotiff',
+                            ...(update.data ?? {}),
+                        });
+                        this.layerManager.addCustomLayer(layerId, terrainLayer);
+                        //wrapped.setVisible(visible);
+                        //wrapped.setOpacity(opacity);
+                    }
+                    break;
+            }
+            // Re-attach error listeners after layer replacement
+            if (hadErrorListener)
+                this.attachCesiumErrorListeners(layerId);
+        });
+    }
+    async setView(center, zoom) {
+        if (!this.viewer)
+            return;
+        const [lon, lat] = center;
+        this.viewer.camera.flyTo({
+            destination: this.Cesium.Cartesian3.fromDegrees(lon, lat, 1000000 / zoom),
+            duration: 2.0, // Sekunden, anpassbar
+            orientation: {
+                heading: this.Cesium.Math.toRadians(0.0), // Blickrichtung nach Norden
+                pitch: this.Cesium.Math.toRadians(-30), // leicht nach unten schauen
+                roll: 0.0,
+            },
+            // optional: onComplete / onCancel callbacks
+            complete: () => log('v-map - provider - cesium - Fly‑to finished'),
+            cancel: () => warn('v-map - provider - cesium - Fly‑to cancelled'),
+        });
+    }
+    async fetchWFSFromUrl(config) {
+        const baseParams = {
+            service: 'WFS',
+            request: 'GetFeature',
+            version: config.version ?? '1.1.0',
+            typeName: config.typeName,
+            outputFormat: config.outputFormat ?? 'application/json',
+            srsName: config.srsName ?? 'EPSG:4326',
+        };
+        const params = { ...baseParams, ...(config.params ?? {}) };
+        const requestUrl = this.appendParams(config.url, params);
+        const response = await fetch(requestUrl);
+        if (!response.ok) {
+            throw new Error(`WFS request failed (${response.status} ${response.statusText})`);
+        }
+        const outputFormat = (config.outputFormat ?? 'application/json').toLowerCase();
+        // Handle JSON formats
+        if (outputFormat.includes('json') ||
+            outputFormat.includes('geojson') ||
+            outputFormat === 'application/json') {
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                return await response.json();
+            }
+            // Try to parse as JSON anyway
+            const text = await response.text();
+            return JSON.parse(text);
+        }
+        // Handle GML formats - parse XML to GeoJSON using @npm9912/s-gml
+        if (outputFormat.includes('gml') || outputFormat.includes('xml')) {
+            const xml = await response.text();
+            const { GmlParser } = await import('./index.browser-DhQAXuA7.js');
+            const parser = new GmlParser();
+            return await parser.parse(xml);
+        }
+        // Default: try to parse as JSON
+        return await response.json();
+    }
+    appendParams(baseUrl, params) {
+        const query = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                query.set(key, String(value));
+            }
+        });
+        if (!query.toString())
+            return baseUrl;
+        return `${baseUrl}${baseUrl.includes('?') ? '&' : '?'}${query.toString()}`;
+    }
+}
+
+export { CesiumProvider };