@geoql/v-maplibre 1.2.4 → 1.4.0

package/dist/index.js

@@ -1,58 +1,4278 @@
-import { aR as r, aQ as l, ac as s, ad as V, ae as y, af as c, ag as L, aN as g, ai as k, ar as o, aq as D, ax as i, aI as t, aj as n, aG as p, aw as C, as as M, aB as u, aA as b, au as d, av as G, ao as m, al as S, aC as P, ak as h, at as H, am as T, aJ as v, aH as x, ah as f, aM as j, ay as A, aL as I, an as K, aF as O, ap as B, aD as F, aE as N, az as Q, aK as R, a4 as q, a6 as w, a5 as z, a7 as E, ab as J, a8 as W, a9 as U, aa as X, a1 as Y, a2 as Z, a3 as _, a1 as $, aP as aa, aO as ea } from "./index-kNnO8_Zs.js";
+import { inject as w, ref as M, shallowRef as H, watch as v, provide as O, onUnmounted as J, defineComponent as b, useSlots as X, onMounted as L, renderSlot as C, onBeforeUnmount as P, createBlock as K, openBlock as $, computed as z, toRaw as E, markRaw as R, createElementBlock as A, createCommentVNode as Q, withCtx as ee } from "vue";
+import te, { AttributionControl as oe, FullscreenControl as ae, GeolocateControl as ie, NavigationControl as re, ScaleControl as le, Map as ne, Popup as se, Marker as de } from "maplibre-gl";
+import { PMTiles as ce, Protocol as ue } from "pmtiles";
+import { ScatterplotLayer as ge, ArcLayer as ye, GeoJsonLayer as pe, PathLayer as fe, LineLayer as he, PolygonLayer as me, SolidPolygonLayer as ve, IconLayer as be, TextLayer as Le, ColumnLayer as Se, BitmapLayer as Ce, GridCellLayer as ke, PointCloudLayer as Pe } from "@deck.gl/layers";
+import { HeatmapLayer as xe, HexagonLayer as Ie, GridLayer as _e, ContourLayer as Me, ScreenGridLayer as Ee } from "@deck.gl/aggregation-layers";
+import { TripsLayer as Be, H3HexagonLayer as We, H3ClusterLayer as we, MVTLayer as Te, TileLayer as ze, Tile3DLayer as He, TerrainLayer as $e, GreatCircleLayer as Re, S2Layer as Oe, GeohashLayer as Ve, QuadkeyLayer as De, _WMSLayer as Ae } from "@deck.gl/geo-layers";
+import { SimpleMeshLayer as Ue, ScenegraphLayer as Fe } from "@deck.gl/mesh-layers";
+function k(g, a) {
+  const e = w(g, a);
+  if (!e)
+    throw new Error(`Could not resolve ${g.description}`);
+  return e;
+}
+const V = /* @__PURE__ */ Symbol("DeckOverlay"), D = /* @__PURE__ */ Symbol("DeckLayers");
+function I(g, a = {}) {
+  const { interleaved: e = !1 } = a, r = w(V, null), i = w(D, null);
+  if (r && i)
+    return {
+      overlay: r,
+      isInitialized: M(!0),
+      layers: M([]),
+      initOverlay: () => Promise.resolve(),
+      getLayers: () => [],
+      ...i
+    };
+  const u = H(null), l = M([]), n = M(!1);
+  let s = null;
+  const t = () => {
+    const d = g.value;
+    return !d || u.value ? Promise.resolve() : s || (s = import("@deck.gl/mapbox").then(({ MapboxOverlay: h }) => {
+      u.value || (u.value = new h({
+        interleaved: e,
+        layers: []
+      }), d.addControl(u.value), n.value = !0);
+    }).catch((h) => {
+      console.error("[deck.gl] Error initializing overlay:", h), s = null;
+    }), s);
+  }, o = (d) => d.id, y = () => {
+    u.value && u.value.setProps({ layers: l.value });
+  }, f = (d) => {
+    const h = o(d), B = l.value.findIndex(
+      (x) => o(x) === h
+    );
+    B >= 0 ? l.value = [
+      ...l.value.slice(0, B),
+      d,
+      ...l.value.slice(B + 1)
+    ] : l.value = [...l.value, d], u.value ? y() : t().then(y);
+  }, c = (d) => {
+    l.value = l.value.filter((h) => o(h) !== d), y();
+  }, m = (d, h) => {
+    const B = l.value.findIndex((x) => o(x) === d);
+    B >= 0 ? (l.value = [
+      ...l.value.slice(0, B),
+      h,
+      ...l.value.slice(B + 1)
+    ], y()) : f(h);
+  }, p = () => [...l.value];
+  return v(
+    g,
+    (d) => {
+      d && !u.value && (d.isStyleLoaded() ? t() : d.once("style.load", () => {
+        t();
+      }));
+    },
+    { immediate: !0 }
+  ), O(V, u), O(D, {
+    addLayer: f,
+    removeLayer: c,
+    updateLayer: m
+  }), J(() => {
+    if (u.value && g.value)
+      try {
+        g.value.removeControl(u.value), u.value.finalize();
+      } catch (d) {
+        console.error("[deck.gl] Error cleaning up overlay:", d);
+      }
+    u.value = null, l.value = [], n.value = !1, s = null;
+  }), {
+    overlay: u,
+    layers: l,
+    isInitialized: n,
+    initOverlay: t,
+    addLayer: f,
+    removeLayer: c,
+    updateLayer: m,
+    getLayers: p
+  };
+}
+function it() {
+  const g = w(D, null), a = w(V, null);
+  if (!g)
+    throw new Error(
+      "[deck.gl] useDeckLayers must be used within a component that has initialized useDeckOverlay"
+    );
+  return {
+    ...g,
+    overlay: a
+  };
+}
+const S = /* @__PURE__ */ Symbol("Map"), Y = /* @__PURE__ */ Symbol("Protocol"), rt = /* @__PURE__ */ b({
+  __name: "VControlAttribution",
+  props: {
+    options: { default: void 0 },
+    position: { default: "bottom-right" }
+  },
+  setup(g) {
+    const a = {
+      compact: !1,
+      customAttribution: void 0
+    }, e = g, r = X(), i = k(S);
+    L(() => {
+      u();
+    });
+    const u = () => {
+      let l = a;
+      e.options && (l = {
+        ...e.options
+      }), r && r.default?.() && (l.customAttribution = r.default()[0].children);
+      const n = new oe(l);
+      i.value.addControl(n, e.position);
+    };
+    return (l, n) => C(l.$slots, "default");
+  }
+}), lt = /* @__PURE__ */ b({
+  __name: "VControlFullscreen",
+  props: {
+    options: { default: void 0 },
+    position: { default: "top-left" }
+  },
+  setup(g) {
+    const a = {
+      container: void 0
+    }, e = g, r = k(S);
+    L(() => {
+      i();
+    });
+    const i = () => {
+      const u = new ae(e.options || a);
+      r.value.addControl(u, e.position);
+    };
+    return () => {
+    };
+  }
+}), U = [
+  "geolocate",
+  "error",
+  "outofmaxbounds",
+  "trackuserlocationstart",
+  "trackuserlocationend"
+], nt = /* @__PURE__ */ b({
+  __name: "VControlGeolocate",
+  props: {
+    options: { default: void 0 },
+    position: { default: "top-left" }
+  },
+  emits: U,
+  setup(g, { emit: a }) {
+    const e = {
+      fitBoundsOptions: {
+        linear: !1,
+        offset: [0, 0],
+        maxZoom: 22
+      },
+      positionOptions: {
+        enableHighAccuracy: !0,
+        maximumAge: 0,
+        timeout: 6e3
+      },
+      trackUserLocation: !0,
+      showAccuracyCircle: !0,
+      showUserLocation: !0
+    }, r = g, i = a, u = k(S);
+    L(() => {
+      l();
+    });
+    const l = () => {
+      const n = new ie(r.options || e);
+      u.value.addControl(n, r.position), U.forEach((s) => {
+        n.on(s, () => {
+          i(s);
+        });
+      });
+    };
+    return () => {
+    };
+  }
+}), st = /* @__PURE__ */ b({
+  __name: "VControlNavigation",
+  props: {
+    options: { default: void 0 },
+    position: { default: "top-left" }
+  },
+  setup(g) {
+    const a = {
+      showCompass: !0,
+      showZoom: !0,
+      visualizePitch: !0
+    }, e = g, r = w(S);
+    L(() => {
+      i();
+    });
+    const i = () => {
+      const u = new re(e.options || a);
+      r.value.addControl(u, e.position);
+    };
+    return () => {
+    };
+  }
+}), dt = /* @__PURE__ */ b({
+  __name: "VControlScale",
+  props: {
+    options: { default: void 0 },
+    position: { default: "bottom-left" }
+  },
+  setup(g) {
+    const a = {
+      maxWidth: 100,
+      unit: "metric"
+    }, e = g, r = w(S);
+    L(() => {
+      i();
+    });
+    const i = () => {
+      const u = new le(e.options || a);
+      r?.value.addControl(u, e.position);
+    };
+    return (u, l) => C(u.$slots, "default");
+  }
+}), F = [
+  "load",
+  "loadstart",
+  "loaderror",
+  "unload",
+  "statechange",
+  "stylechange",
+  "collapse",
+  "expand",
+  "streamingstart",
+  "streamingstop",
+  "streamingprogress",
+  "budgetreached"
+], ct = /* @__PURE__ */ b({
+  __name: "VControlLidar",
+  props: {
+    options: { default: void 0 },
+    position: { default: "top-right" },
+    defaultUrl: { default: void 0 }
+  },
+  emits: F,
+  setup(g, { expose: a, emit: e }) {
+    const r = {
+      collapsed: !0,
+      pointSize: 2,
+      colorScheme: "elevation",
+      pickable: !1,
+      autoZoom: !0
+    }, i = g, u = e, l = k(S), n = M(null);
+    L(async () => {
+      await s();
+    }), J(() => {
+      n.value && l.value && (l.value.removeControl(n.value), n.value = null);
+    });
+    const s = async () => {
+      const { LidarControl: t } = await import("maplibre-gl-lidar");
+      n.value = new t(
+        i.options || r
+      ), l.value.addControl(
+        n.value,
+        i.position
+      ), F.forEach((o) => {
+        n.value.on(o, (y) => {
+          u(o, y);
+        });
+      }), i.defaultUrl && n.value.loadPointCloud(i.defaultUrl);
+    };
+    return a({
+      loadPointCloud: (t) => n.value?.loadPointCloud(t),
+      unloadPointCloud: (t) => n.value?.unloadPointCloud(t),
+      flyToPointCloud: (t) => n.value?.flyToPointCloud(t),
+      setPointSize: (t) => n.value?.setPointSize(t),
+      setColorScheme: (t) => n.value?.setColorScheme(t),
+      setOpacity: (t) => n.value?.setOpacity(t),
+      setPickable: (t) => n.value?.setPickable(t),
+      setUsePercentile: (t) => n.value?.setUsePercentile(t),
+      setElevationRange: (t, o) => n.value?.setElevationRange(t, o),
+      clearElevationRange: () => n.value?.clearElevationRange(),
+      setZOffset: (t) => n.value?.setZOffset(t),
+      setZOffsetEnabled: (t) => n.value?.setZOffsetEnabled(t),
+      toggle: () => n.value?.toggle(),
+      expand: () => n.value?.expand(),
+      collapse: () => n.value?.collapse(),
+      getState: () => n.value?.getState(),
+      getPointClouds: () => n.value?.getPointClouds(),
+      stopStreaming: (t) => n.value?.stopStreaming(t),
+      isStreaming: (t) => n.value?.isStreaming(t),
+      getControl: () => n.value
+    }), () => {
+    };
+  }
+}), ut = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreCanvas",
+  props: {
+    source: {},
+    layer: {},
+    sourceId: { default: "maplibre.gl-canvas-source" },
+    layerId: { default: "maplibre.gl-canvas-layer" },
+    before: { default: "" }
+  },
+  setup(g) {
+    const a = g, e = k(S), r = M(!1), i = () => e.value || null, u = (t) => {
+      t && t.on("style.load", () => {
+        const o = () => {
+          t.isStyleLoaded() ? r.value = !0 : (r.value = !1, setTimeout(o, 200));
+        };
+        o();
+      });
+    }, l = () => {
+      const t = i();
+      if (t)
+        try {
+          if (t.getSource(a.sourceId) || t.addSource(a.sourceId, a.source), !t.getLayer(a.layerId)) {
+            const o = {
+              ...a.layer,
+              id: a.layerId,
+              source: a.sourceId
+            };
+            t.addLayer(o, a.before);
+          }
+        } catch (o) {
+          console.error("Error adding Canvas layer:", o);
+        }
+    }, n = () => {
+      const t = i();
+      if (t)
+        try {
+          t.getLayer(a.layerId) && t.removeLayer(a.layerId), t.getSource(a.sourceId) && t.removeSource(a.sourceId), t.addSource(a.sourceId, a.source);
+          const o = {
+            ...a.layer,
+            id: a.layerId,
+            source: a.sourceId
+          };
+          t.addLayer(o, a.before);
+        } catch (o) {
+          console.error("Error updating Canvas source:", o);
+        }
+    }, s = () => {
+      const t = i();
+      if (t)
+        try {
+          t.getLayer(a.layerId) && (Object.entries(a.layer.paint || {}).forEach(([o, y]) => {
+            t.setPaintProperty(a.layerId, o, y);
+          }), Object.entries(a.layer.layout || {}).forEach(([o, y]) => {
+            t.setLayoutProperty(a.layerId, o, y);
+          }));
+        } catch (o) {
+          console.error("Error updating Canvas layer:", o);
+        }
+    };
+    return v(() => a.source, n, { deep: !0 }), v(() => a.layer, s, { deep: !0 }), v(
+      e,
+      (t) => {
+        t && u(t);
+      },
+      { immediate: !0 }
+    ), v(r, (t) => {
+      t && l();
+    }), L(() => {
+      i()?.isStyleLoaded() && l();
+    }), P(() => {
+      const t = i();
+      if (t)
+        try {
+          t.getLayer(a.layerId) && t.removeLayer(a.layerId), t.getSource(a.sourceId) && t.removeSource(a.sourceId);
+        } catch (o) {
+          console.error("Error cleaning up Canvas layer:", o);
+        }
+    }), (t, o) => C(t.$slots, "default");
+  }
+}), gt = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreGeojson",
+  props: {
+    sourceId: { default: "maplibre-gl-geojson-source" },
+    layerId: { default: "maplibre-gl-geojson-layer" },
+    source: {},
+    layer: {},
+    before: { default: "" }
+  },
+  emits: ["on-click"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), u = M(!1), l = (c) => !c || typeof c == "string" ? !1 : c && typeof c == "object" && "type" in c ? c.type === "FeatureCollection" && "features" in c ? c.features.length > 0 : c.type === "Feature" || c.type === "Point" || c.type === "LineString" || c.type === "Polygon" || c.type === "MultiPoint" || c.type === "MultiLineString" || c.type === "MultiPolygon" : !1, n = () => i.value || null, s = (c) => {
+      c && c.on("style.load", () => {
+        const m = () => {
+          c.isStyleLoaded() ? u.value = !0 : (u.value = !1, setTimeout(m, 200));
+        };
+        m();
+      });
+    }, t = () => {
+      const c = n();
+      if (!(!c || !c.isStyleLoaded())) {
+        if (!l(e.source.data)) {
+          console.log(
+            `[${e.layerId}] Waiting for valid data before adding layer`
+          );
+          return;
+        }
+        try {
+          if (c.getSource(e.sourceId) || c.addSource(e.sourceId, e.source), !c.getLayer(e.layerId)) {
+            const m = {
+              ...e.layer,
+              id: e.layerId,
+              source: e.sourceId
+            };
+            c.addLayer(m, e.before);
+          }
+        } catch (m) {
+          console.error("Error adding GeoJSON layer:", m);
+        }
+      }
+    }, o = () => {
+      const c = n();
+      if (c)
+        try {
+          const m = c.getSource(e.sourceId);
+          if (m && "setData" in m) {
+            const p = c.getStyle().layers.filter(
+              (d) => d.type !== "background" && "source" in d && d.source === e.sourceId
+            );
+            (p.length === 0 || p[0]?.id === e.layerId) && m.setData(e.source.data);
+          } else m || t();
+        } catch (m) {
+          console.error("Error updating GeoJSON source:", m);
+        }
+    }, y = () => {
+      const c = n();
+      if (c)
+        try {
+          c.getLayer(e.layerId) ? (Object.entries(e.layer.paint || {}).forEach(([m, p]) => {
+            c.setPaintProperty(e.layerId, m, p);
+          }), Object.entries(e.layer.layout || {}).forEach(([m, p]) => {
+            c.setLayoutProperty(e.layerId, m, p);
+          })) : t();
+        } catch (m) {
+          console.error("Error updating GeoJSON layer:", m);
+        }
+    }, f = (c) => {
+      if (c)
+        try {
+          c.on("click", e.layerId, (m) => {
+            m.features && m.features.length > 0 && r("on-click", {
+              features: m.features,
+              coordinates: m.lngLat
+            });
+          }), c.on("mouseenter", e.layerId, () => {
+            c.getCanvas().style.cursor = "pointer";
+          }), c.on("mouseleave", e.layerId, () => {
+            c.getCanvas().style.cursor = "";
+          });
+        } catch (m) {
+          console.error("Error in setupLayerEvents:", m);
+        }
+    };
+    return v(
+      () => e.source,
+      (c, m) => {
+        if (l(c?.data) && JSON.stringify(c.data) !== JSON.stringify(m?.data)) {
+          const p = n();
+          p?.isStyleLoaded() && (p.getSource(e.sourceId) ? o() : t());
+        }
+      },
+      { deep: !0 }
+    ), v(() => e.layer, y, { deep: !0 }), v(
+      i,
+      (c) => {
+        c && (s(c), c.isStyleLoaded() && (u.value = !0));
+      },
+      { immediate: !0 }
+    ), v(u, (c) => {
+      if (c && l(e.source.data)) {
+        const m = n();
+        m && (t(), f(m));
+      }
+    }), v(
+      () => e.layer.layout?.visibility,
+      (c) => {
+        const m = n();
+        if (!m || !m.isStyleLoaded()) return;
+        const p = m.getLayer(e.layerId);
+        if (!p && c === "visible")
+          l(e.source.data) && t();
+        else if (p)
+          try {
+            m.setLayoutProperty(
+              e.layerId,
+              "visibility",
+              c
+            );
+          } catch (d) {
+            console.error(
+              `Error updating visibility for ${e.layerId}:`,
+              d
+            );
+          }
+      },
+      { immediate: !0 }
+    ), L(() => {
+      try {
+        n()?.isStyleLoaded() && l(e.source.data) && t();
+      } catch (c) {
+        console.error("Error adding layer:", c);
+      }
+    }), P(() => {
+      const c = n();
+      if (c)
+        try {
+          c.getLayer(e.layerId) && c.removeLayer(e.layerId), c.getStyle().layers.filter(
+            (p) => p.type !== "background" && "source" in p && p.source === e.sourceId
+          ).length === 0 && c.getSource(e.sourceId) && c.removeSource(e.sourceId);
+        } catch (m) {
+          console.error("Error cleaning up GeoJSON layer:", m);
+        }
+    }), (c, m) => C(c.$slots, "default");
+  }
+}), yt = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreImage",
+  props: {
+    sourceId: {
+      type: String,
+      default: "maplibre.gl-image-source",
+      required: !0
+    },
+    layerId: {
+      type: String,
+      default: "maplibre.gl-image-layer",
+      required: !0
+    },
+    source: {
+      type: Object,
+      required: !0
+    },
+    layer: {
+      type: Object,
+      default: () => ({}),
+      required: !0
+    },
+    before: {
+      type: String,
+      default: "",
+      required: !1
+    }
+  },
+  setup(g) {
+    const a = g, e = k(S), r = M(!1), i = () => e.value || null, u = (t) => {
+      t && t.on("style.load", () => {
+        const o = () => {
+          t.isStyleLoaded() ? r.value = !0 : (r.value = !1, setTimeout(o, 200));
+        };
+        o();
+      });
+    }, l = () => {
+      const t = i();
+      if (t)
+        try {
+          if (t.getSource(a.sourceId) || t.addSource(a.sourceId, a.source), !t.getLayer(a.layerId)) {
+            const o = {
+              ...a.layer,
+              id: a.layerId,
+              source: a.sourceId
+            };
+            t.addLayer(o, a.before);
+          }
+        } catch (o) {
+          console.error("Error adding Image layer:", o);
+        }
+    }, n = () => {
+      const t = i();
+      if (t)
+        try {
+          const o = t.getSource(a.sourceId);
+          if (o)
+            if (o.updateImage)
+              o.updateImage({
+                url: a.source.url,
+                coordinates: a.source.coordinates
+              });
+            else {
+              t.getLayer(a.layerId) && t.removeLayer(a.layerId), t.getSource(a.sourceId) && t.removeSource(a.sourceId), t.addSource(a.sourceId, a.source);
+              const y = {
+                ...a.layer,
+                id: a.layerId,
+                source: a.sourceId
+              };
+              t.addLayer(y, a.before);
+            }
+        } catch (o) {
+          console.error("Error updating Image source:", o);
+        }
+    }, s = () => {
+      const t = i();
+      if (t)
+        try {
+          t.getLayer(a.layerId) && (Object.entries(a.layer.paint || {}).forEach(([o, y]) => {
+            t.setPaintProperty(a.layerId, o, y);
+          }), Object.entries(a.layer.layout || {}).forEach(([o, y]) => {
+            t.setLayoutProperty(a.layerId, o, y);
+          }));
+        } catch (o) {
+          console.error("Error updating Image layer:", o);
+        }
+    };
+    return v(() => a.source, n, { deep: !0 }), v(() => a.layer, s, { deep: !0 }), v(
+      e,
+      (t) => {
+        t && u(t);
+      },
+      { immediate: !0 }
+    ), v(r, (t) => {
+      t && l();
+    }), L(() => {
+      i()?.isStyleLoaded() && l();
+    }), P(() => {
+      const t = i();
+      if (t)
+        try {
+          t.getLayer(a.layerId) && t.removeLayer(a.layerId), t.getSource(a.sourceId) && t.removeSource(a.sourceId);
+        } catch (o) {
+          console.error("Error cleaning up Image layer:", o);
+        }
+    }), (t, o) => C(t.$slots, "default");
+  }
+}), je = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreRaster",
+  props: {
+    sourceId: {},
+    source: {},
+    layerId: {},
+    layer: {},
+    before: {}
+  },
+  setup(g) {
+    const a = g, e = k(S), r = M(!1), i = () => e.value || null, u = (t) => {
+      t && t.on("style.load", () => {
+        const o = () => {
+          t.isStyleLoaded() ? r.value = !0 : (r.value = !1, setTimeout(o, 200));
+        };
+        o();
+      });
+    }, l = () => {
+      const t = i();
+      if (t)
+        try {
+          t.getSource(a.sourceId) || t.addSource(a.sourceId, a.source), t.getLayer(a.layerId) || (t.addLayer(a.layer, a.before), a.layer.layout?.visibility && t.setLayoutProperty(
+            a.layerId,
+            "visibility",
+            a.layer.layout.visibility
+          ));
+        } catch (o) {
+          console.error(`[${a.layerId}] Error setting up layer:`, o);
+        }
+    }, n = () => {
+      const t = i();
+      if (t)
+        try {
+          const o = a.before;
+          t.getLayer(a.layerId) && t.removeLayer(a.layerId), t.removeSource(a.sourceId), t.addSource(a.sourceId, a.source);
+          const y = {
+            ...a.layer,
+            id: a.layerId,
+            type: "raster",
+            source: a.sourceId
+          };
+          o && t.getLayer(o) ? t.addLayer(y, o) : t.addLayer(y);
+        } catch (o) {
+          console.error("Error updating Raster source:", o);
+        }
+    }, s = () => {
+      const t = i();
+      if (t)
+        try {
+          if (t.getLayer(a.layerId)) {
+            const o = a.layer.paint || {};
+            Object.entries(o).forEach(([f, c]) => {
+              t.setPaintProperty(a.layerId, f, c);
+            });
+            const y = a.layer.layout || {};
+            Object.entries(y).forEach(([f, c]) => {
+              t.setLayoutProperty(a.layerId, f, c);
+            });
+          }
+        } catch (o) {
+          console.error("Error updating Raster layer:", o);
+        }
+    };
+    return v(
+      () => a.source.tiles?.[0],
+      // Usually raster sources have a single tile URL
+      (t, o) => {
+        t !== o && n();
+      }
+    ), v(() => a.layer, s, { deep: !0 }), v(
+      e,
+      (t) => {
+        t && u(t);
+      },
+      { immediate: !0 }
+    ), v(r, (t) => {
+      t && l();
+    }), v(
+      () => a.layer.layout?.visibility,
+      (t) => {
+        const o = i();
+        if (!o) return;
+        if (o.getLayer(a.layerId))
+          try {
+            o.setLayoutProperty(
+              a.layerId,
+              "visibility",
+              t
+            ), t === "visible" && a.before && o.moveLayer(a.layerId, a.before);
+          } catch (f) {
+            console.error(`[${a.layerId}] Error updating visibility:`, f);
+          }
+        else
+          try {
+            o.addLayer(a.layer, a.before);
+          } catch (f) {
+            console.error(`[${a.layerId}] Error adding layer:`, f);
+          }
+      },
+      { immediate: !0 }
+    ), v(
+      () => a.before,
+      (t) => {
+        const o = i();
+        if (!(!o || !o.getLayer(a.layerId)) && a.layer.layout?.visibility === "visible")
+          try {
+            console.log(`[${a.layerId}] Moving layer before:`, t), o.moveLayer(a.layerId, t);
+          } catch (y) {
+            console.error(`[${a.layerId}] Error moving layer:`, y);
+          }
+      }
+    ), L(() => {
+      if (i())
+        try {
+          l();
+        } catch (o) {
+          console.error(`[${a.layerId}] Error setting up layer:`, o);
+        }
+    }), (t, o) => C(t.$slots, "default");
+  }
+}), j = [
+  "click",
+  "dblclick",
+  "mousedown",
+  "mouseup",
+  "mousemove",
+  "mouseenter",
+  "mouseleave",
+  "mouseover",
+  "mouseout",
+  "contextmenu",
+  "touchstart",
+  "touchend",
+  "touchcancel"
+], N = [
+  "error",
+  "load",
+  "idle",
+  "remove",
+  "render",
+  "resize",
+  "webglcontextlost",
+  "webglcontextrestored",
+  "dataloading",
+  "data",
+  "tiledataloading",
+  "sourcedataloading",
+  "styledataloading",
+  "sourcedata",
+  "styledata",
+  "boxzoomcancel",
+  "boxzoomstart",
+  "boxzoomend",
+  "touchcancel",
+  "touchmove",
+  "touchend",
+  "touchstart",
+  "click",
+  "contextmenu",
+  "dblclick",
+  "mousemove",
+  "mouseup",
+  "mousedown",
+  "mouseout",
+  "mouseover",
+  "movestart",
+  "move",
+  "moveend",
+  "zoomstart",
+  "zoom",
+  "zoomend",
+  "rotatestart",
+  "rotate",
+  "rotateend",
+  "dragstart",
+  "drag",
+  "dragend",
+  "pitchstart",
+  "pitch",
+  "pitchend",
+  "wheel"
+], G = ["dragstart", "drag", "dragend"], Z = ["click", "mouseenter", "mouseleave"], q = ["open", "close"], pt = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreVector",
+  props: {
+    sourceId: {},
+    source: {},
+    layerId: {},
+    layer: {},
+    before: {}
+  },
+  emits: [...j],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), u = M(!1), l = () => i.value || null, n = (f) => {
+      f && f.on("style.load", () => {
+        const c = () => {
+          f.isStyleLoaded() ? u.value = !0 : (u.value = !1, setTimeout(c, 200));
+        };
+        c();
+      });
+    }, s = () => {
+      const f = l();
+      if (f)
+        try {
+          f.getSource(e.sourceId) || f.addSource(e.sourceId, e.source), f.getLayer(e.layerId) || (e.layer.layout?.visibility === "visible" ? f.addLayer(e.layer, e.before) : f.addLayer(e.layer));
+        } catch (c) {
+          console.error(`[${e.layerId}] Error setting up layer:`, c);
+        }
+    }, t = () => {
+      const f = l();
+      if (f)
+        try {
+          const c = f.getSource(e.sourceId);
+          if (c && JSON.stringify(c.serialize()) !== JSON.stringify(e.source)) {
+            f.getLayer(e.layerId) && f.removeLayer(e.layerId), f.removeSource(e.sourceId), f.addSource(e.sourceId, e.source);
+            const m = {
+              ...e.layer,
+              id: e.layerId,
+              source: e.sourceId
+            };
+            f.addLayer(m, e.before);
+          }
+        } catch (c) {
+          console.error("Error updating vector source:", c);
+        }
+    }, o = () => {
+      const f = l();
+      if (f)
+        try {
+          if (f.getLayer(e.layerId)) {
+            const c = f.getLayer(e.layerId), m = c?.paint || {}, p = c?.layout || {};
+            Object.entries(e.layer.paint || {}).forEach(([d, h]) => {
+              JSON.stringify(m[d]) !== JSON.stringify(h) && f.setPaintProperty(e.layerId, d, h);
+            }), Object.entries(e.layer.layout || {}).forEach(([d, h]) => {
+              JSON.stringify(p[d]) !== JSON.stringify(h) && f.setLayoutProperty(e.layerId, d, h);
+            });
+          }
+        } catch (c) {
+          console.error("Error updating vector layer:", c);
+        }
+    }, y = (f) => {
+      if (f)
+        try {
+          j.forEach((c) => {
+            f.on(c, e.layerId, (m) => {
+              c === "mousemove" && (f.getCanvas().style.cursor = "pointer"), c === "mouseleave" && (f.getCanvas().style.cursor = ""), r(c, m);
+            });
+          });
+        } catch (c) {
+          console.error("Error setting up layer events:", c);
+        }
+    };
+    return v(
+      i,
+      (f, c) => {
+        f && f !== c && n(f);
+      },
+      { immediate: !0 }
+    ), v(u, (f) => {
+      if (f) {
+        const c = l();
+        if (!c) return;
+        s(), y(c);
+      }
+    }), v(
+      () => JSON.stringify(e.source.tiles),
+      (f, c) => {
+        f !== c && t();
+      }
+    ), v(
+      () => ({
+        paint: e.layer.paint,
+        // Watch layout changes but exclude visibility since it's handled separately
+        layout: e.layer.layout ? { ...e.layer.layout, visibility: void 0 } : void 0
+      }),
+      (f, c) => {
+        JSON.stringify(f) !== JSON.stringify(c) && o();
+      },
+      { deep: !0 }
+    ), v(
+      () => e.layer.layout?.visibility,
+      (f) => {
+        const c = l();
+        if (!c) return;
+        if (c.getLayer(e.layerId))
+          try {
+            c.setLayoutProperty(
+              e.layerId,
+              "visibility",
+              f
+            ), f === "visible" && e.before && setTimeout(() => {
+              c.moveLayer(e.layerId, e.before);
+            }, 0);
+          } catch (p) {
+            console.error(`[${e.layerId}] Error updating visibility:`, p);
+          }
+        else
+          try {
+            c.getSource(e.sourceId) || c.addSource(e.sourceId, e.source), c.addLayer(e.layer, e.before);
+          } catch (p) {
+            console.error(`[${e.layerId}] Error adding layer:`, p);
+          }
+      },
+      { immediate: !0 }
+    ), v(
+      () => e.before,
+      (f) => {
+        const c = l();
+        if (!(!c || !c.getLayer(e.layerId)) && e.layer.layout?.visibility === "visible")
+          try {
+            c.moveLayer(e.layerId, f);
+          } catch (m) {
+            console.error(
+              `Error reordering vector layer ${e.layerId}:`,
+              m
+            );
+          }
+      }
+    ), v(
+      () => e.layer.layout?.visibility,
+      (f) => {
+        const c = l();
+        if (!c) return;
+        if (c.getLayer(e.layerId))
+          try {
+            c.setLayoutProperty(
+              e.layerId,
+              "visibility",
+              f
+            );
+          } catch (p) {
+            console.error(`[${e.layerId}] Error updating visibility:`, p);
+          }
+        else
+          try {
+            c.getSource(e.sourceId) || c.addSource(e.sourceId, e.source), c.addLayer(e.layer, e.before);
+          } catch (p) {
+            console.error(`[${e.layerId}] Error adding layer:`, p);
+          }
+      },
+      { immediate: !0 }
+    ), L(() => {
+      if (l())
+        try {
+          s();
+        } catch (c) {
+          console.error(`[${e.layerId}] Error setting up layer:`, c);
+        }
+    }), (f, c) => C(f.$slots, "default");
+  }
+}), ft = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreVideo",
+  props: {
+    sourceId: {
+      type: String,
+      default: "maplibre.gl-video-source",
+      required: !0
+    },
+    layerId: {
+      type: String,
+      default: "maplibre.gl-video-layer",
+      required: !0
+    },
+    source: {
+      type: Object,
+      required: !0
+    },
+    layer: {
+      type: Object,
+      default: () => ({}),
+      required: !0
+    },
+    before: {
+      type: String,
+      default: "",
+      required: !1
+    }
+  },
+  setup(g) {
+    const a = g, e = k(S), r = M(!1), i = () => e.value || null, u = (t) => {
+      t && t.on("style.load", () => {
+        const o = () => {
+          t.isStyleLoaded() ? r.value = !0 : (r.value = !1, setTimeout(o, 200));
+        };
+        o();
+      });
+    }, l = () => {
+      const t = i();
+      if (t)
+        try {
+          if (t.getSource(a.sourceId) || t.addSource(a.sourceId, a.source), !t.getLayer(a.layerId)) {
+            const o = {
+              ...a.layer,
+              id: a.layerId,
+              source: a.sourceId
+            };
+            t.addLayer(o, a.before);
+          }
+        } catch (o) {
+          console.error("Error adding Video layer:", o);
+        }
+    }, n = () => {
+      const t = i();
+      if (t)
+        try {
+          const o = t.getSource(a.sourceId);
+          if (o) {
+            t.getLayer(a.layerId) && t.removeLayer(a.layerId), t.getSource(a.sourceId) && t.removeSource(a.sourceId), t.addSource(a.sourceId, a.source);
+            const y = {
+              ...a.layer,
+              id: a.layerId,
+              source: a.sourceId
+            };
+            if (t.addLayer(y, a.before), o.getVideo) {
+              const f = o.getVideo();
+              f && f.play().catch((c) => {
+                console.error("Error playing video:", c);
+              });
+            }
+          }
+        } catch (o) {
+          console.error("Error updating Video source:", o);
+        }
+    }, s = () => {
+      const t = i();
+      if (t)
+        try {
+          t.getLayer(a.layerId) && (Object.entries(a.layer.paint || {}).forEach(([o, y]) => {
+            t.setPaintProperty(a.layerId, o, y);
+          }), Object.entries(a.layer.layout || {}).forEach(([o, y]) => {
+            t.setLayoutProperty(a.layerId, o, y);
+          }));
+        } catch (o) {
+          console.error("Error updating Video layer:", o);
+        }
+    };
+    return v(() => a.source, n, { deep: !0 }), v(() => a.layer, s, { deep: !0 }), v(
+      e,
+      (t) => {
+        t && u(t);
+      },
+      { immediate: !0 }
+    ), v(r, (t) => {
+      t && l();
+    }), L(() => {
+      i()?.isStyleLoaded() && l();
+    }), P(() => {
+      const t = i();
+      if (t)
+        try {
+          const o = t.getSource(a.sourceId);
+          if (o?.getVideo) {
+            const y = o.getVideo();
+            y && (y.pause(), y.remove());
+          }
+          t.getLayer(a.layerId) && t.removeLayer(a.layerId), t.getSource(a.sourceId) && t.removeSource(a.sourceId);
+        } catch (o) {
+          console.error("Error cleaning up Video layer:", o);
+        }
+    }), (t, o) => C(t.$slots, "default");
+  }
+}), ht = /* @__PURE__ */ b({
+  __name: "VLayerMaplibrePmtile",
+  props: {
+    sourceId: {
+      type: String,
+      default: "maplibre.gl-pmtile-source",
+      required: !0
+    },
+    layerId: {
+      type: String,
+      default: "maplibre.gl-pmtile-layer",
+      required: !0
+    },
+    url: {
+      type: String,
+      required: !0
+    },
+    layer: {
+      type: Object,
+      default: () => ({}),
+      required: !0
+    },
+    before: {
+      type: String,
+      default: "",
+      required: !1
+    }
+  },
+  setup(g) {
+    const a = g, e = w(Y);
+    if (!e)
+      throw new Error("Protocol not provided");
+    const r = M({
+      type: "raster",
+      url: `pmtiles://${a.url}`,
+      tileSize: 512,
+      volatile: !0
+    });
+    return L(async () => {
+      const i = new ce(a.url);
+      e.add(i);
+    }), (i, u) => ($(), K(je, {
+      "source-id": g.sourceId,
+      "layer-id": g.layerId,
+      source: r.value,
+      layer: {
+        ...g.layer,
+        type: "raster"
+      },
+      before: g.before
+    }, null, 8, ["source-id", "layer-id", "source", "layer", "before"]));
+  }
+}), mt = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreCluster",
+  props: {
+    sourceId: { default: "cluster-source" },
+    baseLayerId: { default: "cluster" },
+    source: {},
+    visibility: { type: Boolean, default: !0 },
+    clusterPaint: { default: () => ({
+      colors: ["#51bbd6", "#f1f075", "#f28cb1"],
+      radii: [20, 30, 40]
+    }) },
+    unclusteredPaint: { default: () => ({
+      color: "#51bbd6",
+      radius: 6
+    }) },
+    textPaint: { default: () => ({
+      color: "#ffffff",
+      font: ["DIN Offc Pro Medium", "Arial Unicode MS Bold"],
+      size: 12
+    }) }
+  },
+  emits: ["cluster-click", "point-click"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), u = M(!1), l = z(() => `${e.baseLayerId}-clusters`), n = z(
+      () => `${e.baseLayerId}-cluster-count`
+    ), s = z(
+      () => `${e.baseLayerId}-unclustered-point`
+    ), t = () => i.value || null, o = (d) => typeof d == "string" ? !1 : d && typeof d == "object" && "type" in d && d.type === "FeatureCollection" && "features" in d ? d.features.length > 0 : !1, y = () => {
+      const d = t();
+      if (!(!d || !d.isStyleLoaded()))
+        try {
+          if (!d.getSource(e.sourceId))
+            console.log(`Adding clustered source: ${e.sourceId}`), d.addSource(e.sourceId, {
+              ...e.source,
+              cluster: !0,
+              clusterMaxZoom: 14,
+              clusterRadius: 50
+            });
+          else {
+            const h = d.getSource(e.sourceId);
+            h && "setData" in h && h.setData(e.source.data);
+          }
+          d.getLayer(l.value) || (console.log(`Adding clusters layer: ${l.value}`), d.addLayer({
+            id: l.value,
+            type: "circle",
+            source: e.sourceId,
+            filter: ["has", "point_count"],
+            paint: {
+              "circle-color": [
+                "step",
+                ["get", "point_count"],
+                e.clusterPaint.colors[0],
+                100,
+                e.clusterPaint.colors[1],
+                750,
+                e.clusterPaint.colors[2]
+              ],
+              "circle-radius": [
+                "step",
+                ["get", "point_count"],
+                e.clusterPaint.radii[0],
+                100,
+                e.clusterPaint.radii[1],
+                750,
+                e.clusterPaint.radii[2]
+              ],
+              "circle-stroke-width": 2,
+              "circle-stroke-color": "#ffffff",
+              "circle-opacity": 0.9
+            },
+            layout: {
+              visibility: e.visibility ? "visible" : "none"
+            }
+          })), d.getLayer(n.value) || (console.log(`Adding cluster count layer: ${n.value}`), d.addLayer({
+            id: n.value,
+            type: "symbol",
+            source: e.sourceId,
+            filter: ["has", "point_count"],
+            layout: {
+              "text-field": "{point_count_abbreviated}",
+              "text-font": e.textPaint.font,
+              "text-size": e.textPaint.size,
+              visibility: e.visibility ? "visible" : "none"
+            },
+            paint: {
+              "text-color": e.textPaint.color
+            }
+          })), d.getLayer(s.value) || (console.log(
+            `Adding unclustered points layer: ${s.value}`
+          ), d.addLayer({
+            id: s.value,
+            type: "circle",
+            source: e.sourceId,
+            filter: ["!", ["has", "point_count"]],
+            paint: {
+              "circle-color": e.unclusteredPaint.color,
+              "circle-radius": e.unclusteredPaint.radius,
+              "circle-stroke-width": 2,
+              "circle-stroke-color": "#ffffff",
+              "circle-opacity": 0.95
+            },
+            layout: {
+              visibility: e.visibility ? "visible" : "none"
+            }
+          })), console.log(`All cluster layers added for ${e.baseLayerId}`), m(d);
+        } catch (h) {
+          console.error("Error adding cluster layers:", h);
+        }
+    }, f = () => {
+      const d = t();
+      if (d)
+        try {
+          const h = d.getSource(e.sourceId);
+          h && "setData" in h ? (console.log(`Updating source ${e.sourceId} with data`), h.setData(e.source.data), setTimeout(() => {
+            y();
+          }, 100)) : h || y();
+        } catch (h) {
+          console.error("Error updating source:", h);
+        }
+    }, c = (d) => {
+      const h = t();
+      if (!h) return;
+      const B = d ? "visible" : "none";
+      [
+        l.value,
+        n.value,
+        s.value
+      ].forEach((x) => {
+        h.getLayer(x) && h.setLayoutProperty(x, "visibility", B);
+      });
+    }, m = (d) => {
+      if (d)
+        try {
+          d.on(
+            "click",
+            l.value,
+            (h) => {
+              h.features && h.features.length > 0 && r("cluster-click", {
+                features: h.features,
+                coordinates: h.lngLat
+              });
+            }
+          ), d.on(
+            "click",
+            s.value,
+            (h) => {
+              h.features && h.features.length > 0 && r("point-click", {
+                features: h.features,
+                coordinates: h.lngLat
+              });
+            }
+          ), [l.value, s.value].forEach((h) => {
+            d.on("mouseenter", h, () => {
+              d.getCanvas().style.cursor = "pointer";
+            }), d.on("mouseleave", h, () => {
+              d.getCanvas().style.cursor = "";
+            });
+          });
+        } catch (h) {
+          console.error("Error setting up layer events:", h);
+        }
+    }, p = (d) => {
+      d && (d.on("style.load", () => {
+        const h = () => {
+          d.isStyleLoaded() ? (u.value = !0, o(e.source.data) && y()) : (u.value = !1, setTimeout(h, 200));
+        };
+        h();
+      }), d.isStyleLoaded() && (u.value = !0, o(e.source.data) && y()));
+    };
+    return v(
+      () => e.source.data,
+      (d) => {
+        if (o(d)) {
+          const h = t();
+          h?.isStyleLoaded() && (h.getSource(e.sourceId) ? f() : y());
+        }
+      },
+      { deep: !0, immediate: !0 }
+    ), v(() => e.visibility, c), v(
+      i,
+      (d) => {
+        d && p(d);
+      },
+      { immediate: !0 }
+    ), L(() => {
+      t()?.isStyleLoaded() && o(e.source.data) && y();
+    }), P(() => {
+      const d = t();
+      if (d)
+        try {
+          [l.value, s.value].forEach((h) => {
+            d.off("click", h, () => {
+            }), d.off("mouseenter", h, () => {
+            }), d.off("mouseleave", h, () => {
+            });
+          }), [
+            l.value,
+            n.value,
+            s.value
+          ].forEach((h) => {
+            d.getLayer(h) && d.removeLayer(h);
+          }), d.getSource(e.sourceId) && d.removeSource(e.sourceId);
+        } catch (h) {
+          console.error("Error cleaning up cluster layers:", h);
+        }
+    }), (d, h) => C(d.$slots, "default");
+  }
+}), vt = /* @__PURE__ */ b({
+  __name: "VLayerMaplibreRoute",
+  props: {
+    id: { default: () => `route-${Math.random().toString(36).slice(2, 9)}` },
+    coordinates: {},
+    color: { default: "#4285F4" },
+    width: { default: 4 },
+    opacity: { default: 1 },
+    lineCap: { default: "round" },
+    lineJoin: { default: "round" },
+    visible: { type: Boolean, default: !0 },
+    interactive: { type: Boolean, default: !0 },
+    before: { default: "" },
+    dashArray: {},
+    blur: { default: 0 }
+  },
+  emits: ["click", "mouseenter", "mouseleave"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), u = M(!1), l = z(() => `${e.id}-source`), n = z(() => `${e.id}-layer`), s = z(
+      () => ({
+        type: "FeatureCollection",
+        features: e.coordinates.length >= 2 ? [
+          {
+            type: "Feature",
+            properties: {},
+            geometry: {
+              type: "LineString",
+              coordinates: e.coordinates
+            }
+          }
+        ] : []
+      })
+    ), t = () => i.value || null, o = (p) => {
+      p && p.on("style.load", () => {
+        const d = () => {
+          p.isStyleLoaded() ? u.value = !0 : (u.value = !1, setTimeout(d, 200));
+        };
+        d();
+      });
+    }, y = () => {
+      const p = t();
+      if (!(!p || !p.isStyleLoaded()) && !(e.coordinates.length < 2))
+        try {
+          if (p.getSource(l.value) || p.addSource(l.value, {
+            type: "geojson",
+            data: s.value
+          }), !p.getLayer(n.value)) {
+            const d = {
+              id: n.value,
+              type: "line",
+              source: l.value,
+              layout: {
+                "line-cap": e.lineCap,
+                "line-join": e.lineJoin,
+                visibility: e.visible ? "visible" : "none"
+              },
+              paint: {
+                "line-color": e.color,
+                "line-width": e.width,
+                "line-opacity": e.opacity,
+                ...e.blur > 0 && { "line-blur": e.blur },
+                ...e.dashArray && { "line-dasharray": e.dashArray }
+              }
+            };
+            p.addLayer(d, e.before || void 0);
+          }
+        } catch (d) {
+          console.error("Error adding route layer:", d);
+        }
+    }, f = () => {
+      const p = t();
+      if (p)
+        try {
+          const d = p.getSource(l.value);
+          d && "setData" in d ? d.setData(s.value) : !d && e.coordinates.length >= 2 && y();
+        } catch (d) {
+          console.error("Error updating route source:", d);
+        }
+    }, c = () => {
+      const p = t();
+      if (!(!p || !p.getLayer(n.value)))
+        try {
+          p.setPaintProperty(n.value, "line-color", e.color), p.setPaintProperty(n.value, "line-width", e.width), p.setPaintProperty(
+            n.value,
+            "line-opacity",
+            e.opacity
+          ), e.blur > 0 && p.setPaintProperty(n.value, "line-blur", e.blur), e.dashArray && p.setPaintProperty(
+            n.value,
+            "line-dasharray",
+            e.dashArray
+          ), p.setLayoutProperty(n.value, "line-cap", e.lineCap), p.setLayoutProperty(n.value, "line-join", e.lineJoin), p.setLayoutProperty(
+            n.value,
+            "visibility",
+            e.visible ? "visible" : "none"
+          );
+        } catch (d) {
+          console.error("Error updating route layer style:", d);
+        }
+    }, m = (p) => {
+      if (!(!p || !e.interactive))
+        try {
+          p.on("click", n.value, (d) => {
+            r("click", {
+              coordinates: d.lngLat
+            });
+          }), p.on("mouseenter", n.value, () => {
+            p.getCanvas().style.cursor = "pointer", r("mouseenter");
+          }), p.on("mouseleave", n.value, () => {
+            p.getCanvas().style.cursor = "", r("mouseleave");
+          });
+        } catch (d) {
+          console.error("Error setting up route layer events:", d);
+        }
+    };
+    return v(
+      () => e.coordinates,
+      () => {
+        const p = t();
+        p?.isStyleLoaded() && (p.getSource(l.value) ? f() : y());
+      },
+      { deep: !0 }
+    ), v(
+      () => [
+        e.color,
+        e.width,
+        e.opacity,
+        e.lineCap,
+        e.lineJoin,
+        e.visible,
+        e.blur,
+        e.dashArray
+      ],
+      () => c(),
+      { deep: !0 }
+    ), v(
+      i,
+      (p) => {
+        p && (o(p), p.isStyleLoaded() && (u.value = !0));
+      },
+      { immediate: !0 }
+    ), v(u, (p) => {
+      if (p && e.coordinates.length >= 2) {
+        const d = t();
+        d && (y(), m(d));
+      }
+    }), L(() => {
+      try {
+        const p = t();
+        p?.isStyleLoaded() && e.coordinates.length >= 2 && (y(), m(p));
+      } catch (p) {
+        console.error("Error mounting route layer:", p);
+      }
+    }), P(() => {
+      const p = t();
+      if (p)
+        try {
+          p.getLayer(n.value) && p.removeLayer(n.value), p.getSource(l.value) && p.removeSource(l.value);
+        } catch (d) {
+          console.error("Error cleaning up route layer:", d);
+        }
+    }), (p, d) => C(p.$slots, "default");
+  }
+}), bt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglScatterplot",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getRadius: {},
+    getFillColor: {},
+    getLineColor: {},
+    getLineWidth: {},
+    radiusUnits: { default: "meters" },
+    radiusScale: { default: 1 },
+    radiusMinPixels: { default: 0 },
+    radiusMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    stroked: { type: Boolean, default: !1 },
+    filled: { type: Boolean, default: !0 },
+    billboard: { type: Boolean, default: !1 },
+    antialiasing: { type: Boolean, default: !0 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new ge({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getRadius: e.getRadius ?? 1,
+      getFillColor: e.getFillColor ?? [255, 140, 0],
+      getLineColor: e.getLineColor ?? [0, 0, 0],
+      getLineWidth: e.getLineWidth ?? 1,
+      radiusUnits: e.radiusUnits,
+      radiusScale: e.radiusScale,
+      radiusMinPixels: e.radiusMinPixels,
+      radiusMaxPixels: e.radiusMaxPixels,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      stroked: e.stroked,
+      filled: e.filled,
+      billboard: e.billboard,
+      antialiasing: e.antialiasing,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.getRadius,
+        e.getFillColor,
+        e.getLineColor,
+        e.radiusScale,
+        e.opacity,
+        e.visible,
+        e.stroked,
+        e.filled
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Lt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglArc",
+  props: {
+    id: {},
+    data: {},
+    getSourcePosition: {},
+    getTargetPosition: {},
+    getSourceColor: {},
+    getTargetColor: {},
+    getWidth: {},
+    getHeight: {},
+    getTilt: {},
+    greatCircle: { type: Boolean, default: !1 },
+    numSegments: { default: 50 },
+    widthUnits: { default: "pixels" },
+    widthScale: { default: 1 },
+    widthMinPixels: { default: 0 },
+    widthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new ye({
+      id: e.id,
+      data: e.data,
+      getSourcePosition: e.getSourcePosition,
+      getTargetPosition: e.getTargetPosition,
+      getSourceColor: e.getSourceColor ?? [255, 140, 0],
+      getTargetColor: e.getTargetColor ?? [0, 200, 255],
+      getWidth: e.getWidth ?? 1,
+      getHeight: e.getHeight ?? 1,
+      getTilt: e.getTilt ?? 0,
+      greatCircle: e.greatCircle,
+      numSegments: e.numSegments,
+      widthUnits: e.widthUnits,
+      widthScale: e.widthScale,
+      widthMinPixels: e.widthMinPixels,
+      widthMaxPixels: e.widthMaxPixels,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getSourcePosition,
+        e.getTargetPosition,
+        e.getSourceColor,
+        e.getTargetColor,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), St = /* @__PURE__ */ b({
+  __name: "VLayerDeckglGeojson",
+  props: {
+    id: {},
+    data: {},
+    getFillColor: {},
+    getLineColor: {},
+    getLineWidth: {},
+    getPointRadius: {},
+    getElevation: {},
+    getText: {},
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    pointType: { default: "circle" },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    lineJointRounded: { type: Boolean, default: !1 },
+    lineCapRounded: { type: Boolean, default: !1 },
+    lineMiterLimit: { default: 4 },
+    pointRadiusUnits: { default: "meters" },
+    pointRadiusScale: { default: 1 },
+    pointRadiusMinPixels: { default: 0 },
+    pointRadiusMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    elevationScale: { default: 1 },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new pe({
+      id: e.id,
+      data: e.data,
+      getFillColor: e.getFillColor ?? [200, 200, 200, 200],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getLineWidth: e.getLineWidth ?? 1,
+      getPointRadius: e.getPointRadius ?? 1,
+      getElevation: e.getElevation ?? 1e3,
+      getText: e.getText,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      pointType: e.pointType,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      lineJointRounded: e.lineJointRounded,
+      lineCapRounded: e.lineCapRounded,
+      lineMiterLimit: e.lineMiterLimit,
+      pointRadiusUnits: e.pointRadiusUnits,
+      pointRadiusScale: e.pointRadiusScale,
+      pointRadiusMinPixels: e.pointRadiusMinPixels,
+      pointRadiusMaxPixels: e.pointRadiusMaxPixels,
+      elevationScale: e.elevationScale,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getFillColor,
+        e.getLineColor,
+        e.opacity,
+        e.visible,
+        e.extruded
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Ct = /* @__PURE__ */ b({
+  __name: "VLayerDeckglPath",
+  props: {
+    id: {},
+    data: {},
+    getPath: {},
+    getColor: {},
+    getWidth: {},
+    widthUnits: { default: "meters" },
+    widthScale: { default: 1 },
+    widthMinPixels: { default: 0 },
+    widthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    capRounded: { type: Boolean, default: !1 },
+    jointRounded: { type: Boolean, default: !1 },
+    billboard: { type: Boolean, default: !1 },
+    miterLimit: { default: 4 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new fe({
+      id: e.id,
+      data: e.data,
+      getPath: e.getPath,
+      getColor: e.getColor ?? [0, 0, 0, 255],
+      getWidth: e.getWidth ?? 1,
+      widthUnits: e.widthUnits,
+      widthScale: e.widthScale,
+      widthMinPixels: e.widthMinPixels,
+      widthMaxPixels: e.widthMaxPixels,
+      capRounded: e.capRounded,
+      jointRounded: e.jointRounded,
+      billboard: e.billboard,
+      miterLimit: e.miterLimit,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPath,
+        e.getColor,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), kt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglLine",
+  props: {
+    id: {},
+    data: {},
+    getSourcePosition: {},
+    getTargetPosition: {},
+    getColor: {},
+    getWidth: {},
+    widthUnits: { default: "pixels" },
+    widthScale: { default: 1 },
+    widthMinPixels: { default: 0 },
+    widthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new he({
+      id: e.id,
+      data: e.data,
+      getSourcePosition: e.getSourcePosition,
+      getTargetPosition: e.getTargetPosition,
+      getColor: e.getColor ?? [0, 0, 0, 255],
+      getWidth: e.getWidth ?? 1,
+      widthUnits: e.widthUnits,
+      widthScale: e.widthScale,
+      widthMinPixels: e.widthMinPixels,
+      widthMaxPixels: e.widthMaxPixels,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getSourcePosition,
+        e.getTargetPosition,
+        e.getColor,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Pt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglPolygon",
+  props: {
+    id: {},
+    data: {},
+    getPolygon: {},
+    getFillColor: {},
+    getLineColor: {},
+    getLineWidth: {},
+    getElevation: {},
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    elevationScale: { default: 1 },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    lineJointRounded: { type: Boolean, default: !1 },
+    lineMiterLimit: { default: 4 },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new me({
+      id: e.id,
+      data: e.data,
+      getPolygon: e.getPolygon,
+      getFillColor: e.getFillColor ?? [200, 200, 200, 200],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getLineWidth: e.getLineWidth ?? 1,
+      getElevation: e.getElevation ?? 1e3,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      elevationScale: e.elevationScale,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      lineJointRounded: e.lineJointRounded,
+      lineMiterLimit: e.lineMiterLimit,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPolygon,
+        e.getFillColor,
+        e.getLineColor,
+        e.opacity,
+        e.visible,
+        e.extruded
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), xt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglSolidPolygon",
+  props: {
+    id: {},
+    data: {},
+    getPolygon: {},
+    getFillColor: {},
+    getLineColor: {},
+    getElevation: {},
+    filled: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    elevationScale: { default: 1 },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new ve({
+      id: e.id,
+      data: e.data,
+      getPolygon: e.getPolygon,
+      getFillColor: e.getFillColor ?? [0, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      filled: e.filled,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      elevationScale: e.elevationScale,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPolygon,
+        e.getFillColor,
+        e.getElevation,
+        e.extruded,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), It = /* @__PURE__ */ b({
+  __name: "VLayerDeckglIcon",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getIcon: {},
+    getSize: {},
+    getColor: {},
+    getAngle: {},
+    iconAtlas: {},
+    iconMapping: {},
+    sizeScale: { default: 1 },
+    sizeUnits: { default: "pixels" },
+    sizeMinPixels: { default: 0 },
+    sizeMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    billboard: { type: Boolean, default: !0 },
+    alphaCutoff: { default: 0.05 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new be({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getIcon: e.getIcon ?? "marker",
+      getSize: e.getSize ?? 1,
+      getColor: e.getColor ?? [255, 255, 255, 255],
+      getAngle: e.getAngle ?? 0,
+      iconAtlas: e.iconAtlas,
+      iconMapping: e.iconMapping,
+      sizeScale: e.sizeScale,
+      sizeUnits: e.sizeUnits,
+      sizeMinPixels: e.sizeMinPixels,
+      sizeMaxPixels: e.sizeMaxPixels,
+      billboard: e.billboard,
+      alphaCutoff: e.alphaCutoff,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.getIcon,
+        e.getSize,
+        e.getColor,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), _t = /* @__PURE__ */ b({
+  __name: "VLayerDeckglText",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getText: {},
+    getSize: {},
+    getColor: {},
+    getAngle: {},
+    getTextAnchor: {},
+    getAlignmentBaseline: {},
+    getPixelOffset: {},
+    getBackgroundColor: {},
+    getBorderColor: {},
+    getBorderWidth: {},
+    background: { type: Boolean, default: !1 },
+    backgroundPadding: {},
+    billboard: { type: Boolean, default: !0 },
+    sizeScale: { default: 1 },
+    sizeUnits: { default: "pixels" },
+    sizeMinPixels: { default: 0 },
+    sizeMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    fontFamily: { default: "Monaco, monospace" },
+    fontWeight: { default: "normal" },
+    lineHeight: { default: 1 },
+    fontSettings: {},
+    wordBreak: { default: "break-word" },
+    maxWidth: { default: -1 },
+    outlineWidth: { default: 0 },
+    outlineColor: {},
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Le({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getText: e.getText,
+      getSize: e.getSize ?? 32,
+      getColor: e.getColor ?? [0, 0, 0, 255],
+      getAngle: e.getAngle ?? 0,
+      getTextAnchor: e.getTextAnchor ?? "middle",
+      getAlignmentBaseline: e.getAlignmentBaseline ?? "center",
+      getPixelOffset: e.getPixelOffset ?? [0, 0],
+      getBackgroundColor: e.getBackgroundColor,
+      getBorderColor: e.getBorderColor,
+      getBorderWidth: e.getBorderWidth,
+      background: e.background,
+      backgroundPadding: e.backgroundPadding,
+      billboard: e.billboard,
+      sizeScale: e.sizeScale,
+      sizeUnits: e.sizeUnits,
+      sizeMinPixels: e.sizeMinPixels,
+      sizeMaxPixels: e.sizeMaxPixels,
+      fontFamily: e.fontFamily,
+      fontWeight: e.fontWeight,
+      lineHeight: e.lineHeight,
+      fontSettings: e.fontSettings,
+      wordBreak: e.wordBreak,
+      maxWidth: e.maxWidth,
+      outlineWidth: e.outlineWidth,
+      outlineColor: e.outlineColor,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.getText,
+        e.getSize,
+        e.getColor,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Mt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglColumn",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getFillColor: {},
+    getLineColor: {},
+    getElevation: {},
+    diskResolution: { default: 20 },
+    radius: { default: 1e3 },
+    angle: { default: 0 },
+    vertices: {},
+    offset: {},
+    coverage: { default: 1 },
+    elevationScale: { default: 1 },
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !1 },
+    extruded: { type: Boolean, default: !0 },
+    wireframe: { type: Boolean, default: !1 },
+    flatShading: { type: Boolean, default: !1 },
+    radiusUnits: { default: "meters" },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Se({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      diskResolution: e.diskResolution,
+      radius: e.radius,
+      angle: e.angle,
+      vertices: e.vertices,
+      offset: e.offset,
+      coverage: e.coverage,
+      elevationScale: e.elevationScale,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      flatShading: e.flatShading,
+      radiusUnits: e.radiusUnits,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.getFillColor,
+        e.getElevation,
+        e.radius,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Et = /* @__PURE__ */ b({
+  __name: "VLayerDeckglBitmap",
+  props: {
+    id: {},
+    image: {},
+    bounds: {},
+    loadOptions: {},
+    textureParameters: {},
+    desaturate: { default: 0 },
+    transparentColor: {},
+    tintColor: {},
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Ce({
+      id: e.id,
+      image: e.image,
+      bounds: e.bounds,
+      loadOptions: e.loadOptions,
+      textureParameters: e.textureParameters,
+      desaturate: e.desaturate,
+      transparentColor: e.transparentColor ?? [0, 0, 0, 0],
+      tintColor: e.tintColor ?? [255, 255, 255],
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.image,
+        e.bounds,
+        e.desaturate,
+        e.tintColor,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Bt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglGridCell",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getFillColor: {},
+    getElevation: {},
+    cellSize: { default: 1e3 },
+    coverage: { default: 1 },
+    elevationScale: { default: 1 },
+    extruded: { type: Boolean, default: !0 },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new ke({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      cellSize: e.cellSize,
+      coverage: e.coverage,
+      elevationScale: e.elevationScale,
+      extruded: e.extruded,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.getFillColor,
+        e.getElevation,
+        e.cellSize,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Wt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglPointCloud",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getColor: {},
+    getNormal: {},
+    sizeUnits: { default: "pixels" },
+    pointSize: { default: 10 },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Pe({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getColor: e.getColor ?? [0, 0, 0, 255],
+      getNormal: e.getNormal ?? [0, 0, 1],
+      sizeUnits: e.sizeUnits,
+      pointSize: e.pointSize,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.getColor,
+        e.pointSize,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), wt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglHeatmap",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getWeight: {},
+    intensity: { default: 1 },
+    radiusPixels: { default: 30 },
+    colorRange: {},
+    threshold: { default: 0.05 },
+    colorDomain: {},
+    aggregation: { default: "SUM" },
+    weightsTextureSize: { default: 2048 },
+    debounceTimeout: { default: 500 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !1 },
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new xe({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getWeight: e.getWeight ?? 1,
+      intensity: e.intensity,
+      radiusPixels: e.radiusPixels,
+      colorRange: e.colorRange,
+      threshold: e.threshold,
+      colorDomain: e.colorDomain,
+      aggregation: e.aggregation,
+      weightsTextureSize: e.weightsTextureSize,
+      debounceTimeout: e.debounceTimeout,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.getWeight,
+        e.intensity,
+        e.radiusPixels,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Tt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglHexagon",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getColorWeight: {},
+    getElevationWeight: {},
+    gpuAggregation: { type: Boolean, default: !1 },
+    radius: { default: 1e3 },
+    elevationScale: { default: 1 },
+    elevationRange: {},
+    colorRange: {},
+    colorDomain: {},
+    coverage: { default: 1 },
+    extruded: { type: Boolean, default: !1 },
+    upperPercentile: { default: 100 },
+    lowerPercentile: { default: 0 },
+    elevationUpperPercentile: { default: 100 },
+    elevationLowerPercentile: { default: 0 },
+    colorScaleType: { default: "quantize" },
+    material: { type: [Boolean, Object] },
+    colorAggregation: { default: "SUM" },
+    elevationAggregation: { default: "SUM" },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Ie({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getColorWeight: e.getColorWeight,
+      getElevationWeight: e.getElevationWeight,
+      gpuAggregation: e.gpuAggregation,
+      radius: e.radius,
+      elevationScale: e.elevationScale,
+      elevationRange: e.elevationRange,
+      colorRange: e.colorRange,
+      colorDomain: e.colorDomain,
+      coverage: e.coverage,
+      extruded: e.extruded,
+      upperPercentile: e.upperPercentile,
+      lowerPercentile: e.lowerPercentile,
+      elevationUpperPercentile: e.elevationUpperPercentile,
+      elevationLowerPercentile: e.elevationLowerPercentile,
+      colorScaleType: e.colorScaleType,
+      material: e.material,
+      colorAggregation: e.colorAggregation,
+      elevationAggregation: e.elevationAggregation,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.radius,
+        e.elevationScale,
+        e.opacity,
+        e.visible,
+        e.extruded
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), zt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglGrid",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getColorWeight: {},
+    getElevationWeight: {},
+    cellSize: { default: 1e3 },
+    colorRange: {},
+    coverage: { default: 1 },
+    elevationDomain: {},
+    elevationRange: {},
+    elevationScale: { default: 1 },
+    extruded: { type: Boolean, default: !1 },
+    upperPercentile: { default: 100 },
+    lowerPercentile: { default: 0 },
+    elevationUpperPercentile: { default: 100 },
+    elevationLowerPercentile: { default: 0 },
+    colorScaleType: { default: "quantize" },
+    colorAggregation: { default: "SUM" },
+    elevationAggregation: { default: "SUM" },
+    gpuAggregation: { type: Boolean, default: !1 },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new _e({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getColorWeight: e.getColorWeight ?? 1,
+      getElevationWeight: e.getElevationWeight ?? 1,
+      cellSize: e.cellSize,
+      colorRange: e.colorRange,
+      coverage: e.coverage,
+      elevationDomain: e.elevationDomain,
+      elevationRange: e.elevationRange,
+      elevationScale: e.elevationScale,
+      extruded: e.extruded,
+      upperPercentile: e.upperPercentile,
+      lowerPercentile: e.lowerPercentile,
+      elevationUpperPercentile: e.elevationUpperPercentile,
+      elevationLowerPercentile: e.elevationLowerPercentile,
+      colorScaleType: e.colorScaleType,
+      colorAggregation: e.colorAggregation,
+      elevationAggregation: e.elevationAggregation,
+      gpuAggregation: e.gpuAggregation,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.cellSize,
+        e.colorRange,
+        e.elevationScale,
+        e.extruded,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Ht = /* @__PURE__ */ b({
+  __name: "VLayerDeckglContour",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getWeight: {},
+    cellSize: { default: 1e3 },
+    contours: {},
+    gpuAggregation: { type: Boolean, default: !1 },
+    aggregation: { default: "SUM" },
+    zOffset: { default: 5e-3 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Me({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getWeight: e.getWeight ?? 1,
+      cellSize: e.cellSize,
+      contours: e.contours,
+      gpuAggregation: e.gpuAggregation,
+      aggregation: e.aggregation,
+      zOffset: e.zOffset,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.cellSize,
+        e.contours,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), $t = /* @__PURE__ */ b({
+  __name: "VLayerDeckglScreenGrid",
+  props: {
+    id: {},
+    data: {},
+    getPosition: {},
+    getWeight: {},
+    cellSizePixels: { default: 100 },
+    cellMarginPixels: { default: 2 },
+    colorRange: {},
+    colorDomain: {},
+    gpuAggregation: { type: Boolean, default: !1 },
+    aggregation: { default: "SUM" },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Ee({
+      id: e.id,
+      data: e.data,
+      getPosition: e.getPosition,
+      getWeight: e.getWeight ?? 1,
+      cellSizePixels: e.cellSizePixels,
+      cellMarginPixels: e.cellMarginPixels,
+      colorRange: e.colorRange,
+      colorDomain: e.colorDomain,
+      gpuAggregation: e.gpuAggregation,
+      aggregation: e.aggregation,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPosition,
+        e.cellSizePixels,
+        e.colorRange,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Rt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglTrips",
+  props: {
+    id: {},
+    data: {},
+    getPath: {},
+    getTimestamps: {},
+    getColor: {},
+    getWidth: {},
+    currentTime: { default: 0 },
+    trailLength: { default: 120 },
+    fadeTrail: { type: Boolean, default: !0 },
+    widthUnits: { default: "pixels" },
+    widthScale: { default: 1 },
+    widthMinPixels: { default: 0 },
+    widthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    capRounded: { type: Boolean, default: !1 },
+    jointRounded: { type: Boolean, default: !1 },
+    billboard: { type: Boolean, default: !1 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Be({
+      id: e.id,
+      data: e.data,
+      getPath: e.getPath,
+      getTimestamps: e.getTimestamps,
+      getColor: e.getColor ?? [253, 128, 93],
+      getWidth: e.getWidth ?? 1,
+      currentTime: e.currentTime,
+      trailLength: e.trailLength,
+      fadeTrail: e.fadeTrail,
+      widthUnits: e.widthUnits,
+      widthScale: e.widthScale,
+      widthMinPixels: e.widthMinPixels,
+      widthMaxPixels: e.widthMaxPixels,
+      capRounded: e.capRounded,
+      jointRounded: e.jointRounded,
+      billboard: e.billboard,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getPath,
+        e.currentTime,
+        e.trailLength,
+        e.getColor,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Ot = /* @__PURE__ */ b({
+  __name: "VLayerDeckglH3Hexagon",
+  props: {
+    id: {},
+    data: {},
+    getHexagon: {},
+    getFillColor: {},
+    getLineColor: {},
+    getElevation: {},
+    highPrecision: { type: [Boolean, String], default: "auto" },
+    coverage: { default: 1 },
+    elevationScale: { default: 1 },
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new We({
+      id: e.id,
+      data: e.data,
+      getHexagon: e.getHexagon,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      highPrecision: e.highPrecision,
+      coverage: e.coverage,
+      elevationScale: e.elevationScale,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getHexagon,
+        e.getFillColor,
+        e.getElevation,
+        e.extruded,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Vt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglH3Cluster",
+  props: {
+    id: {},
+    data: {},
+    getHexagons: {},
+    getFillColor: {},
+    getLineColor: {},
+    getElevation: {},
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    elevationScale: { default: 1 },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new we({
+      id: e.id,
+      data: e.data,
+      getHexagons: e.getHexagons,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      elevationScale: e.elevationScale,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getHexagons,
+        e.getFillColor,
+        e.getElevation,
+        e.extruded,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Dt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglMVT",
+  props: {
+    id: {},
+    data: {},
+    minZoom: { default: 0 },
+    maxZoom: { default: 23 },
+    uniqueIdProperty: {},
+    highlightedFeatureId: {},
+    binary: { type: Boolean, default: !0 },
+    loadOptions: {},
+    getFillColor: {},
+    getLineColor: {},
+    getLineWidth: {},
+    getPointRadius: {},
+    getElevation: {},
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    pointRadiusUnits: { default: "meters" },
+    pointRadiusScale: { default: 1 },
+    pointRadiusMinPixels: { default: 0 },
+    pointRadiusMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    stroked: { type: Boolean, default: !0 },
+    filled: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    elevationScale: { default: 1 },
+    pointType: {},
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover", "tileLoad", "tileError"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Te({
+      id: e.id,
+      data: e.data,
+      minZoom: e.minZoom,
+      maxZoom: e.maxZoom,
+      uniqueIdProperty: e.uniqueIdProperty,
+      highlightedFeatureId: e.highlightedFeatureId,
+      binary: e.binary,
+      loadOptions: e.loadOptions,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getLineWidth: e.getLineWidth ?? 1,
+      getPointRadius: e.getPointRadius ?? 1,
+      getElevation: e.getElevation ?? 1e3,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      pointRadiusUnits: e.pointRadiusUnits,
+      pointRadiusScale: e.pointRadiusScale,
+      pointRadiusMinPixels: e.pointRadiusMinPixels,
+      pointRadiusMaxPixels: e.pointRadiusMaxPixels,
+      stroked: e.stroked,
+      filled: e.filled,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      elevationScale: e.elevationScale,
+      pointType: e.pointType,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o),
+      onTileLoad: (o) => r("tileLoad", o),
+      onTileError: (o, y) => r("tileError", o, y)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getFillColor,
+        e.getLineColor,
+        e.highlightedFeatureId,
+        e.extruded,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), At = /* @__PURE__ */ b({
+  __name: "VLayerDeckglTile",
+  props: {
+    id: {},
+    data: {},
+    getTileData: {},
+    renderSubLayers: {},
+    tileSize: { default: 512 },
+    maxZoom: {},
+    minZoom: { default: 0 },
+    maxCacheSize: {},
+    maxCacheByteSize: {},
+    refinementStrategy: { default: "best-available" },
+    zRange: {},
+    maxRequests: { default: 6 },
+    extent: {},
+    loadOptions: {},
+    zoomOffset: { default: 0 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !1 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover", "viewportLoad", "tileLoad", "tileUnload", "tileError"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new ze({
+      id: e.id,
+      data: e.data,
+      getTileData: e.getTileData,
+      renderSubLayers: e.renderSubLayers,
+      tileSize: e.tileSize,
+      maxZoom: e.maxZoom,
+      minZoom: e.minZoom,
+      maxCacheSize: e.maxCacheSize,
+      maxCacheByteSize: e.maxCacheByteSize,
+      refinementStrategy: e.refinementStrategy,
+      zRange: e.zRange,
+      maxRequests: e.maxRequests,
+      extent: e.extent,
+      loadOptions: e.loadOptions,
+      zoomOffset: e.zoomOffset,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o),
+      onViewportLoad: (o) => r("viewportLoad", o),
+      onTileLoad: (o) => r("tileLoad", o),
+      onTileUnload: (o) => r("tileUnload", o),
+      onTileError: (o, y) => r("tileError", o, y)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.tileSize,
+        e.maxZoom,
+        e.minZoom,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Ut = /* @__PURE__ */ b({
+  __name: "VLayerDeckglTile3D",
+  props: {
+    id: {},
+    data: {},
+    loader: {},
+    loadOptions: {},
+    pickable: { type: Boolean, default: !1 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pointSize: { default: 1 },
+    getPointColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover", "tilesetLoad", "tileLoad", "tileUnload", "tileError"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => {
+      const o = {
+        id: e.id,
+        data: e.data,
+        pointSize: e.pointSize,
+        opacity: e.opacity,
+        visible: e.visible,
+        pickable: e.pickable,
+        autoHighlight: e.autoHighlight,
+        beforeId: e.beforeId,
+        onClick: (y) => r("click", y),
+        onHover: (y) => r("hover", y),
+        onTilesetLoad: (y) => r("tilesetLoad", y),
+        onTileLoad: (y) => r("tileLoad", y),
+        onTileUnload: (y) => r("tileUnload", y),
+        onTileError: (y, f, c) => r("tileError", y, f, c),
+        // Only include optional props when defined to avoid deck.gl bugs
+        ...e.loader !== void 0 && { loader: e.loader },
+        ...e.loadOptions !== void 0 && {
+          loadOptions: e.loadOptions
+        },
+        ...e.highlightColor !== void 0 && {
+          highlightColor: e.highlightColor
+        },
+        ...e.getPointColor !== void 0 && {
+          getPointColor: e.getPointColor
+        }
+      };
+      return new He(
+        o
+      );
+    }, t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [e.data, e.pointSize, e.opacity, e.visible],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Ft = /* @__PURE__ */ b({
+  __name: "VLayerDeckglTerrain",
+  props: {
+    id: {},
+    elevationData: {},
+    texture: {},
+    meshMaxError: { default: 4 },
+    elevationDecoder: {},
+    bounds: {},
+    loadOptions: {},
+    workerUrl: {},
+    color: {},
+    wireframe: { type: Boolean, default: !1 },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !1 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new $e({
+      id: e.id,
+      elevationData: e.elevationData,
+      texture: e.texture,
+      meshMaxError: e.meshMaxError,
+      elevationDecoder: e.elevationDecoder,
+      bounds: e.bounds,
+      loadOptions: e.loadOptions,
+      workerUrl: e.workerUrl,
+      color: e.color ?? [255, 255, 255],
+      wireframe: e.wireframe,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.elevationData,
+        e.texture,
+        e.meshMaxError,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), jt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglGreatCircle",
+  props: {
+    id: {},
+    data: {},
+    getSourcePosition: {},
+    getTargetPosition: {},
+    getSourceColor: {},
+    getTargetColor: {},
+    getWidth: {},
+    getHeight: {},
+    getTilt: {},
+    numSegments: { default: 50 },
+    widthUnits: { default: "pixels" },
+    widthScale: { default: 1 },
+    widthMinPixels: { default: 0 },
+    widthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Re({
+      id: e.id,
+      data: e.data,
+      getSourcePosition: e.getSourcePosition,
+      getTargetPosition: e.getTargetPosition,
+      getSourceColor: e.getSourceColor ?? [0, 0, 255],
+      getTargetColor: e.getTargetColor ?? [0, 255, 0],
+      getWidth: e.getWidth ?? 1,
+      getHeight: e.getHeight ?? 1,
+      getTilt: e.getTilt ?? 0,
+      numSegments: e.numSegments,
+      widthUnits: e.widthUnits,
+      widthScale: e.widthScale,
+      widthMinPixels: e.widthMinPixels,
+      widthMaxPixels: e.widthMaxPixels,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getSourcePosition,
+        e.getTargetPosition,
+        e.getSourceColor,
+        e.getTargetColor,
+        e.getWidth,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Nt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglS2",
+  props: {
+    id: {},
+    data: {},
+    getS2Token: {},
+    getFillColor: {},
+    getLineColor: {},
+    getElevation: {},
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    elevationScale: { default: 1 },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Oe({
+      id: e.id,
+      data: e.data,
+      getS2Token: e.getS2Token,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      elevationScale: e.elevationScale,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getS2Token,
+        e.getFillColor,
+        e.getElevation,
+        e.extruded,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Gt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglGeohash",
+  props: {
+    id: {},
+    data: {},
+    getGeohash: {},
+    getFillColor: {},
+    getLineColor: {},
+    getElevation: {},
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    elevationScale: { default: 1 },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Ve({
+      id: e.id,
+      data: e.data,
+      getGeohash: e.getGeohash,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      elevationScale: e.elevationScale,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getGeohash,
+        e.getFillColor,
+        e.getElevation,
+        e.extruded,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Zt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglQuadkey",
+  props: {
+    id: {},
+    data: {},
+    getQuadkey: {},
+    getFillColor: {},
+    getLineColor: {},
+    getElevation: {},
+    filled: { type: Boolean, default: !0 },
+    stroked: { type: Boolean, default: !0 },
+    extruded: { type: Boolean, default: !1 },
+    wireframe: { type: Boolean, default: !1 },
+    elevationScale: { default: 1 },
+    lineWidthUnits: { default: "meters" },
+    lineWidthScale: { default: 1 },
+    lineWidthMinPixels: { default: 0 },
+    lineWidthMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    material: { type: [Boolean, Object] },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new De({
+      id: e.id,
+      data: e.data,
+      getQuadkey: e.getQuadkey,
+      getFillColor: e.getFillColor ?? [255, 0, 0, 255],
+      getLineColor: e.getLineColor ?? [0, 0, 0, 255],
+      getElevation: e.getElevation ?? 1e3,
+      filled: e.filled,
+      stroked: e.stroked,
+      extruded: e.extruded,
+      wireframe: e.wireframe,
+      elevationScale: e.elevationScale,
+      lineWidthUnits: e.lineWidthUnits,
+      lineWidthScale: e.lineWidthScale,
+      lineWidthMinPixels: e.lineWidthMinPixels,
+      lineWidthMaxPixels: e.lineWidthMaxPixels,
+      material: e.material,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.getQuadkey,
+        e.getFillColor,
+        e.getElevation,
+        e.extruded,
+        e.elevationScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), qt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglWMS",
+  props: {
+    id: {},
+    data: {},
+    serviceType: { default: "wms" },
+    layers: {},
+    srs: { default: "EPSG:4326" },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !1 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => new Ae({
+      id: e.id,
+      data: e.data,
+      serviceType: e.serviceType,
+      layers: e.layers,
+      srs: e.srs,
+      opacity: e.opacity,
+      visible: e.visible,
+      pickable: e.pickable,
+      autoHighlight: e.autoHighlight,
+      highlightColor: e.highlightColor,
+      beforeId: e.beforeId,
+      onClick: (o) => r("click", o),
+      onHover: (o) => r("hover", o)
+    }), t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [e.data, e.layers, e.srs, e.opacity, e.visible],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Jt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglSimpleMesh",
+  props: {
+    id: {},
+    data: {},
+    mesh: {},
+    getPosition: {},
+    getColor: {},
+    getOrientation: {},
+    getScale: {},
+    getTranslation: {},
+    getTransformMatrix: {},
+    texture: {},
+    sizeScale: { default: 1 },
+    wireframe: { type: Boolean, default: !1 },
+    material: { type: [Boolean, Object] },
+    loaders: {},
+    loadOptions: {},
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => {
+      const o = {
+        id: e.id,
+        data: e.data,
+        mesh: e.mesh,
+        getPosition: e.getPosition,
+        getColor: e.getColor ?? [255, 255, 255, 255],
+        getOrientation: e.getOrientation ?? [0, 0, 0],
+        getScale: e.getScale ?? [1, 1, 1],
+        getTranslation: e.getTranslation ?? [0, 0, 0],
+        sizeScale: e.sizeScale,
+        wireframe: e.wireframe,
+        opacity: e.opacity,
+        visible: e.visible,
+        pickable: e.pickable,
+        autoHighlight: e.autoHighlight,
+        onClick: (y) => r("click", y),
+        onHover: (y) => r("hover", y),
+        // Only include optional props if defined
+        ...e.getTransformMatrix !== void 0 && {
+          getTransformMatrix: e.getTransformMatrix
+        },
+        ...e.texture !== void 0 && { texture: e.texture },
+        ...e.material !== void 0 && { material: e.material },
+        ...e.loaders !== void 0 && { loaders: e.loaders },
+        ...e.loadOptions !== void 0 && {
+          loadOptions: e.loadOptions
+        },
+        ...e.highlightColor !== void 0 && {
+          highlightColor: e.highlightColor
+        },
+        ...e.beforeId !== void 0 && { beforeId: e.beforeId }
+      };
+      return new Ue(o);
+    }, t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.mesh,
+        e.getPosition,
+        e.getColor,
+        e.getOrientation,
+        e.getScale,
+        e.sizeScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Xt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglScenegraph",
+  props: {
+    id: {},
+    data: {},
+    scenegraph: {},
+    getPosition: {},
+    getColor: {},
+    getOrientation: {},
+    getScale: {},
+    getTranslation: {},
+    getTransformMatrix: {},
+    sizeScale: { default: 1 },
+    sizeMinPixels: { default: 0 },
+    sizeMaxPixels: { default: Number.MAX_SAFE_INTEGER },
+    animator: {},
+    loaders: {},
+    loadOptions: {},
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !0 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {},
+    _animations: {},
+    _lighting: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = () => {
+      const o = {
+        id: e.id,
+        data: e.data,
+        scenegraph: e.scenegraph,
+        getPosition: e.getPosition,
+        getColor: e.getColor ?? [255, 255, 255, 255],
+        getOrientation: e.getOrientation ?? [0, 0, 0],
+        getScale: e.getScale ?? [1, 1, 1],
+        getTranslation: e.getTranslation ?? [0, 0, 0],
+        sizeScale: e.sizeScale,
+        sizeMinPixels: e.sizeMinPixels,
+        sizeMaxPixels: e.sizeMaxPixels,
+        opacity: e.opacity,
+        visible: e.visible,
+        pickable: e.pickable,
+        autoHighlight: e.autoHighlight,
+        onClick: (y) => r("click", y),
+        onHover: (y) => r("hover", y),
+        // Only include optional props if defined
+        ...e.getTransformMatrix !== void 0 && {
+          getTransformMatrix: e.getTransformMatrix
+        },
+        ...e.animator !== void 0 && { animator: e.animator },
+        ...e.loaders !== void 0 && { loaders: e.loaders },
+        ...e.loadOptions !== void 0 && {
+          loadOptions: e.loadOptions
+        },
+        ...e.highlightColor !== void 0 && {
+          highlightColor: e.highlightColor
+        },
+        ...e.beforeId !== void 0 && { beforeId: e.beforeId },
+        ...e._animations !== void 0 && {
+          _animations: e._animations
+        },
+        ...e._lighting !== void 0 && { _lighting: e._lighting }
+      };
+      return new Fe(o);
+    }, t = () => {
+      u(s());
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? t() : i.value?.once("style.load", t);
+    }), v(
+      () => [
+        e.data,
+        e.scenegraph,
+        e.getPosition,
+        e.getColor,
+        e.getOrientation,
+        e.getScale,
+        e.sizeScale,
+        e.opacity,
+        e.visible
+      ],
+      () => n(e.id, s()),
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (o, y) => C(o.$slots, "default");
+  }
+}), Kt = /* @__PURE__ */ b({
+  __name: "VLayerDeckglCOG",
+  props: {
+    id: {},
+    geotiff: {},
+    tileSize: { default: 256 },
+    maxZoom: {},
+    minZoom: { default: 0 },
+    maxCacheSize: {},
+    refinementStrategy: { default: "best-available" },
+    maxRequests: { default: 6 },
+    opacity: { default: 1 },
+    visible: { type: Boolean, default: !0 },
+    pickable: { type: Boolean, default: !1 },
+    autoHighlight: { type: Boolean, default: !1 },
+    highlightColor: {},
+    beforeId: {},
+    debug: { type: Boolean, default: !1 },
+    debugOpacity: { default: 0.25 }
+  },
+  emits: ["click", "hover", "geotiffLoad"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), { addLayer: u, removeLayer: l, updateLayer: n } = I(i), s = H(null), t = H(null), o = H(null), y = () => {
+      if (!t.value || !o.value) return;
+      const m = t.value, p = o.value;
+      return async (d) => {
+        const h = p(d);
+        return {
+          def: h.proj4,
+          parsed: m.parseCrs(h.proj4),
+          coordinatesUnits: h.coordinatesUnits
+        };
+      };
+    }, f = () => {
+      if (!s.value) return null;
+      const m = y(), p = {
+        id: E(e.id),
+        geotiff: E(e.geotiff),
+        opacity: E(e.opacity),
+        visible: E(e.visible),
+        pickable: E(e.pickable),
+        autoHighlight: E(e.autoHighlight),
+        debug: E(e.debug),
+        debugOpacity: E(e.debugOpacity)
+      };
+      m && (p.geoKeysParser = m), p.onGeoTIFFLoad = (h, B) => {
+        r("geotiffLoad", h, B);
+      }, e.tileSize !== 256 && (p.tileSize = E(e.tileSize)), e.maxZoom !== void 0 && (p.maxZoom = E(e.maxZoom)), e.minZoom !== 0 && (p.minZoom = E(e.minZoom)), e.maxCacheSize !== void 0 && (p.maxCacheSize = E(e.maxCacheSize)), e.refinementStrategy !== "best-available" && (p.refinementStrategy = E(e.refinementStrategy)), e.maxRequests !== 6 && (p.maxRequests = E(e.maxRequests)), e.highlightColor !== void 0 && (p.highlightColor = E(e.highlightColor)), e.beforeId !== void 0 && (p.beforeId = E(e.beforeId));
+      const d = new s.value(p);
+      return R(d);
+    }, c = async () => {
+      try {
+        const [m, p] = await Promise.all([
+          import("@developmentseed/deck.gl-geotiff"),
+          import("geotiff-geokeys-to-proj4")
+        ]);
+        s.value = R(m.COGLayer), t.value = R(m.proj), o.value = R(p.toProj4);
+        const d = f();
+        d && u(d);
+      } catch (m) {
+        console.error("[deck.gl-raster] Error loading COGLayer:", m), console.error(
+          "Make sure @developmentseed/deck.gl-geotiff and geotiff-geokeys-to-proj4 are installed"
+        );
+      }
+    };
+    return L(() => {
+      i.value?.isStyleLoaded() ? c() : i.value?.once("style.load", c);
+    }), v(
+      () => [
+        e.geotiff,
+        e.tileSize,
+        e.maxZoom,
+        e.minZoom,
+        e.opacity,
+        e.visible,
+        e.debug,
+        e.debugOpacity
+      ],
+      () => {
+        const m = f();
+        m && n(e.id, m);
+      },
+      { deep: !0 }
+    ), P(() => {
+      l(e.id);
+    }), (m, p) => C(m.$slots, "default");
+  }
+}), Qt = /* @__PURE__ */ b({
+  __name: "VLayerDeckgl",
+  props: {
+    layer: {}
+  },
+  emits: ["click", "hover"],
+  setup(g, { emit: a }) {
+    const e = g, r = k(S), { addLayer: i, removeLayer: u, updateLayer: l } = I(r), n = (t) => t.id, s = () => {
+      i(e.layer);
+    };
+    return L(() => {
+      r.value?.isStyleLoaded() ? s() : r.value?.once("style.load", s);
+    }), v(
+      () => e.layer,
+      (t, o) => {
+        const y = o ? n(o) : null, f = n(t);
+        y && y !== f ? (u(y), i(t)) : l(f, t);
+      },
+      { deep: !0 }
+    ), P(() => {
+      u(n(e.layer));
+    }), (t, o) => C(t.$slots, "default");
+  }
+}), Ne = ["id"], Ge = /* @__PURE__ */ b({
+  __name: "VMap",
+  props: {
+    options: { default: () => ({ container: "map" }) },
+    supportPmtiles: { type: Boolean, default: !1 }
+  },
+  emits: ["loaded", ...N],
+  setup(g, { emit: a }) {
+    const e = g, r = a;
+    if (e.supportPmtiles) {
+      const s = new ue({ metadata: !0 });
+      te.addProtocol("pmtiles", s.tile), O(Y, s);
+    }
+    const i = H(null), u = M(!1), l = M(N);
+    O(S, i), L(() => {
+      i.value = new ne(e.options), u.value = !0, n();
+    });
+    const n = () => {
+      i.value && l.value.forEach((s) => {
+        i.value?.on(s, (t) => {
+          s === "load" ? r("loaded", i.value) : r(s, t);
+        });
+      });
+    };
+    return (s, t) => ($(), A("div", {
+      id: `${g.options?.container}`,
+      class: "v-map-container"
+    }, [
+      u.value ? C(s.$slots, "default", { key: 0 }, () => [
+        C(s.$slots, "default", {}, void 0, !0)
+      ], !0) : Q("", !0)
+    ], 8, Ne));
+  }
+}), Ze = (g, a) => {
+  const e = g.__vccOpts || g;
+  for (const [r, i] of a)
+    e[r] = i;
+  return e;
+}, Yt = /* @__PURE__ */ Ze(Ge, [["__scopeId", "data-v-e49c0b85"]]), qe = ["id"], Je = /* @__PURE__ */ b({
+  __name: "VPopup",
+  props: {
+    options: { default: () => ({}) },
+    coordinates: { default: () => ({}) },
+    marker: { default: () => ({}) }
+  },
+  emits: ["added", "removed", "open", "close"],
+  setup(g, { emit: a }) {
+    const e = g, r = a, i = k(S), u = new se(e.options), l = M(!0), n = M(null), s = () => i.value || null, t = (d) => {
+      d && d.on("style.load", () => {
+        const h = () => {
+          d.isStyleLoaded() ? l.value = !0 : (l.value = !1, setTimeout(h, 200));
+        };
+        h();
+      });
+    }, o = () => {
+      try {
+        n.value && u.setDOMContent(n.value);
+      } catch (d) {
+        console.error("Error setting popup content:", d);
+      }
+    }, y = () => {
+      try {
+        u.setLngLat(e.coordinates);
+      } catch (d) {
+        console.error("Error setting popup coordinates:", d);
+      }
+    }, f = () => {
+      const d = s();
+      if (d)
+        try {
+          "setPopup" in e.marker ? e.marker.setPopup(u) : u.addTo(d), r("added", { popup: u });
+        } catch (h) {
+          console.error("Error adding popup to marker:", h);
+        }
+    }, c = () => {
+      try {
+        u.remove(), r("removed");
+      } catch (d) {
+        console.error("Error removing popup:", d);
+      }
+    }, m = () => {
+      try {
+        q.forEach((d) => {
+          u.on(d, () => {
+            r(d);
+          });
+        });
+      } catch (d) {
+        console.error("Error setting up popup events:", d);
+      }
+    }, p = () => {
+      try {
+        q.forEach((d) => {
+          u.off(d, () => {
+            r(d);
+          });
+        });
+      } catch (d) {
+        console.error("Error removing popup events:", d);
+      }
+    };
+    return v(
+      i,
+      (d) => {
+        d && t(d);
+      },
+      { immediate: !0 }
+    ), v(
+      () => e.coordinates,
+      () => {
+        y();
+      },
+      { deep: !0 }
+    ), L(() => {
+      if (l.value)
+        try {
+          o(), y(), f(), m();
+        } catch (d) {
+          console.error("Error initializing popup:", d);
+        }
+      else
+        c(), p();
+    }), P(() => {
+      c(), p();
+    }), (d, h) => ($(), A("section", {
+      id: `popup-${Date.now()}`,
+      ref_key: "content",
+      ref: n
+    }, [
+      C(d.$slots, "default")
+    ], 8, qe));
+  }
+}), Xe = ["id"], eo = /* @__PURE__ */ b({
+  __name: "VMarker",
+  props: {
+    coordinates: { default: null },
+    options: { default: () => ({}) },
+    popupOptions: { default: () => ({}) },
+    cursor: { default: "pointer" }
+  },
+  emits: [
+    "added",
+    "update:coordinates",
+    "removed",
+    ...G,
+    ...Z
+  ],
+  setup(g, { emit: a }) {
+    const e = X(), r = g, i = a, u = k(S), l = M(null), n = M(!0), s = M(!1), t = M(null), o = () => u.value || null, y = (x) => {
+      x && x.on("style.load", () => {
+        const _ = () => {
+          x.isStyleLoaded() ? n.value = !0 : (n.value = !1, setTimeout(_, 200));
+        };
+        _();
+      });
+    }, f = (x) => {
+      x instanceof HTMLElement && (t.value = x);
+    }, c = (x) => {
+      if (r.coordinates !== null)
+        try {
+          x.setLngLat(r.coordinates);
+        } catch (_) {
+          console.error("Error setting marker coordinates:", _);
+        }
+    }, m = (x) => {
+      try {
+        x.getElement().style.cursor = r.cursor || "default";
+      } catch (_) {
+        console.error("Error setting cursor:", _);
+      }
+    }, p = (x) => {
+      const _ = o();
+      if (_)
+        try {
+          x.addTo(_), i("added", { marker: x });
+        } catch (W) {
+          console.error("Error adding marker to map:", W);
+        }
+    }, d = (x) => {
+      try {
+        x.remove(), i("removed");
+      } catch (_) {
+        console.error("Error removing marker from map:", _);
+      }
+    }, h = (x) => {
+      try {
+        let _;
+        G.forEach((W) => {
+          x.on(W, (T) => {
+            W === "dragend" && (Array.isArray(r.coordinates) ? _ = [
+              T.target.getLngLat().lng,
+              T.target.getLngLat().lat
+            ] : _ = T.target.getLngLat(), i("update:coordinates", _)), i(W, T);
+          });
+        }), Z.forEach((W) => {
+          x.getElement().addEventListener(W, (T) => {
+            i(W, T);
+          });
+        });
+      } catch (_) {
+        console.error("Error setting up marker events:", _);
+      }
+    };
+    v(l, (x) => {
+      s.value = x !== null && "_map" in x;
+    }), v(
+      u,
+      (x) => {
+        x && y(x);
+      },
+      { immediate: !0 }
+    );
+    const B = (x) => {
+      if (!(!n.value || l.value))
+        try {
+          const _ = {
+            ...r.options,
+            element: x || void 0
+          };
+          l.value = new de(_), c(l.value), p(l.value), m(l.value), h(l.value);
+        } catch (_) {
+          console.error("Error initializing marker:", _);
+        }
+    };
+    return v(t, (x) => {
+      x && !l.value && B(x);
+    }), L(() => {
+      e.markers || B();
+    }), P(() => {
+      l.value && d(l.value);
+    }), (x, _) => ($(), A("section", {
+      id: `marker-${Date.now()}`,
+      class: "absolute"
+    }, [
+      C(x.$slots, "markers", { setRef: f }),
+      s.value && x.$slots.default ? ($(), K(Je, {
+        key: 0,
+        marker: l.value,
+        options: g.popupOptions,
+        coordinates: g.coordinates
+      }, {
+        default: ee(() => [
+          C(x.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["marker", "options", "coordinates"])) : Q("", !0)
+    ], 8, Xe));
+  }
+});
 export {
-  r as DeckLayersKey,
-  l as DeckOverlayKey,
-  s as VControlAttribution,
-  V as VControlFullscreen,
-  y as VControlGeolocate,
-  c as VControlNavigation,
-  L as VControlScale,
-  g as VLayerDeckgl,
-  k as VLayerDeckglArc,
-  o as VLayerDeckglBitmap,
-  D as VLayerDeckglColumn,
-  i as VLayerDeckglContour,
-  t as VLayerDeckglGeohash,
-  n as VLayerDeckglGeojson,
-  p as VLayerDeckglGreatCircle,
-  C as VLayerDeckglGrid,
-  M as VLayerDeckglGridCell,
-  u as VLayerDeckglH3Cluster,
-  b as VLayerDeckglH3Hexagon,
-  d as VLayerDeckglHeatmap,
-  G as VLayerDeckglHexagon,
-  m as VLayerDeckglIcon,
-  S as VLayerDeckglLine,
-  P as VLayerDeckglMVT,
-  h as VLayerDeckglPath,
-  H as VLayerDeckglPointCloud,
-  T as VLayerDeckglPolygon,
-  v as VLayerDeckglQuadkey,
-  x as VLayerDeckglS2,
-  f as VLayerDeckglScatterplot,
-  j as VLayerDeckglScenegraph,
-  A as VLayerDeckglScreenGrid,
-  I as VLayerDeckglSimpleMesh,
-  K as VLayerDeckglSolidPolygon,
-  O as VLayerDeckglTerrain,
-  B as VLayerDeckglText,
-  F as VLayerDeckglTile,
-  N as VLayerDeckglTile3D,
-  Q as VLayerDeckglTrips,
-  R as VLayerDeckglWMS,
-  q as VLayerMaplibreCanvas,
-  w as VLayerMaplibreCluster,
-  z as VLayerMaplibreGeojson,
-  E as VLayerMaplibreImage,
-  J as VLayerMaplibrePmtile,
-  W as VLayerMaplibreRaster,
-  U as VLayerMaplibreVector,
-  X as VLayerMaplibreVideo,
-  Y as VMap,
-  Z as VMarker,
-  _ as VPopup,
-  $ as default,
-  aa as useDeckLayers,
-  ea as useDeckOverlay
+  D as DeckLayersKey,
+  V as DeckOverlayKey,
+  rt as VControlAttribution,
+  lt as VControlFullscreen,
+  nt as VControlGeolocate,
+  ct as VControlLidar,
+  st as VControlNavigation,
+  dt as VControlScale,
+  Qt as VLayerDeckgl,
+  Lt as VLayerDeckglArc,
+  Et as VLayerDeckglBitmap,
+  Kt as VLayerDeckglCOG,
+  Mt as VLayerDeckglColumn,
+  Ht as VLayerDeckglContour,
+  Gt as VLayerDeckglGeohash,
+  St as VLayerDeckglGeojson,
+  jt as VLayerDeckglGreatCircle,
+  zt as VLayerDeckglGrid,
+  Bt as VLayerDeckglGridCell,
+  Vt as VLayerDeckglH3Cluster,
+  Ot as VLayerDeckglH3Hexagon,
+  wt as VLayerDeckglHeatmap,
+  Tt as VLayerDeckglHexagon,
+  It as VLayerDeckglIcon,
+  kt as VLayerDeckglLine,
+  Dt as VLayerDeckglMVT,
+  Ct as VLayerDeckglPath,
+  Wt as VLayerDeckglPointCloud,
+  Pt as VLayerDeckglPolygon,
+  Zt as VLayerDeckglQuadkey,
+  Nt as VLayerDeckglS2,
+  bt as VLayerDeckglScatterplot,
+  Xt as VLayerDeckglScenegraph,
+  $t as VLayerDeckglScreenGrid,
+  Jt as VLayerDeckglSimpleMesh,
+  xt as VLayerDeckglSolidPolygon,
+  Ft as VLayerDeckglTerrain,
+  _t as VLayerDeckglText,
+  At as VLayerDeckglTile,
+  Ut as VLayerDeckglTile3D,
+  Rt as VLayerDeckglTrips,
+  qt as VLayerDeckglWMS,
+  ut as VLayerMaplibreCanvas,
+  mt as VLayerMaplibreCluster,
+  gt as VLayerMaplibreGeojson,
+  yt as VLayerMaplibreImage,
+  ht as VLayerMaplibrePmtile,
+  je as VLayerMaplibreRaster,
+  vt as VLayerMaplibreRoute,
+  pt as VLayerMaplibreVector,
+  ft as VLayerMaplibreVideo,
+  Yt as VMap,
+  eo as VMarker,
+  Je as VPopup,
+  Yt as default,
+  it as useDeckLayers,
+  I as useDeckOverlay
 };
 //# sourceMappingURL=index.js.map