maplibre-gl-basemap-control 0.1.0

package/dist/BasemapControl-C40PophU.js

@@ -0,0 +1,1343 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const DEFAULT_BASEMAP_PROVIDERS = [
+  { id: "openstreetmap", name: "OpenStreetMap", category: "Community" },
+  { id: "google", name: "Google", category: "General" },
+  { id: "carto", name: "Carto", category: "General" },
+  { id: "cyclosm", name: "CyclOSM", category: "Cycling" },
+  { id: "esri", name: "ESRI", category: "Imagery" },
+  { id: "nasa-gibs", name: "NASA GIBS", category: "Imagery" },
+  { id: "openrailwaymap", name: "OpenRailwayMap", category: "Transport" },
+  { id: "opentopomap", name: "OpenTopoMap", category: "Terrain" },
+  { id: "openfreemap", name: "OpenFreeMap", category: "Vector Styles" },
+  { id: "swisstopo", name: "Swiss Federal Geoportal", category: "Regional" },
+  { id: "topplusopen", name: "TopPlusOpen", category: "Regional" },
+  { id: "usgs", name: "USGS", category: "United States" },
+  { id: "waymarkedtrails", name: "Waymarked Trails", category: "Outdoor" },
+  { id: "nlmaps", name: "nlmaps", category: "Regional" }
+];
+function rasterBasemap({
+  id,
+  name,
+  provider,
+  category,
+  description,
+  attribution,
+  tiles,
+  maxzoom = 19,
+  tags = []
+}) {
+  return {
+    id,
+    name,
+    provider,
+    type: "raster",
+    category,
+    description,
+    attribution,
+    source: {
+      type: "raster",
+      tiles,
+      tileSize: 256,
+      maxzoom
+    },
+    tags
+  };
+}
+const CARTO_ATTRIBUTION = "© OpenStreetMap contributors © CARTO";
+const ESRI_ATTRIBUTION = "Tiles © Esri and the GIS User Community";
+const OSM_ATTRIBUTION = "© OpenStreetMap contributors";
+const OPENFREEMAP_ATTRIBUTION = "OpenFreeMap © OpenMapTiles Data from OpenStreetMap";
+const DEFAULT_BASEMAPS = [
+  rasterBasemap({
+    id: "osm-standard",
+    name: "OpenStreetMap Standard",
+    provider: "openstreetmap",
+    category: "Street",
+    description: "Community-maintained street map.",
+    attribution: OSM_ATTRIBUTION,
+    tiles: [
+      "https://a.tile.openstreetmap.org/{z}/{x}/{y}.png",
+      "https://b.tile.openstreetmap.org/{z}/{x}/{y}.png",
+      "https://c.tile.openstreetmap.org/{z}/{x}/{y}.png"
+    ],
+    tags: ["osm", "street", "standard"]
+  }),
+  rasterBasemap({
+    id: "osm-hot",
+    name: "OpenStreetMap HOT",
+    provider: "openstreetmap",
+    category: "Street",
+    description: "Humanitarian OpenStreetMap Team style.",
+    attribution: `${OSM_ATTRIBUTION}, Tiles style by Humanitarian OpenStreetMap Team`,
+    tiles: ["https://a.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png"],
+    tags: ["osm", "hot", "humanitarian"]
+  }),
+  rasterBasemap({
+    id: "osm-de",
+    name: "OpenStreetMap DE",
+    provider: "openstreetmap",
+    category: "Regional",
+    description: "German OpenStreetMap tile style.",
+    attribution: OSM_ATTRIBUTION,
+    tiles: ["https://tile.openstreetmap.de/{z}/{x}/{y}.png"],
+    tags: ["osm", "germany", "regional"]
+  }),
+  rasterBasemap({
+    id: "osm-ch",
+    name: "OpenStreetMap CH",
+    provider: "openstreetmap",
+    category: "Regional",
+    description: "Swiss OpenStreetMap tile style.",
+    attribution: OSM_ATTRIBUTION,
+    tiles: ["https://tile.osm.ch/switzerland/{z}/{x}/{y}.png"],
+    tags: ["osm", "switzerland", "regional"]
+  }),
+  rasterBasemap({
+    id: "google-maps",
+    name: "Google Maps",
+    provider: "google",
+    category: "Street",
+    description: "Google road map tiles from the QGIS basemaps source.",
+    attribution: "© Google",
+    tiles: ["https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}"],
+    maxzoom: 20,
+    tags: ["google", "street"]
+  }),
+  rasterBasemap({
+    id: "google-satellite",
+    name: "Google Satellite",
+    provider: "google",
+    category: "Imagery",
+    description: "Google satellite tiles from the QGIS basemaps source.",
+    attribution: "© Google",
+    tiles: ["https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}"],
+    maxzoom: 20,
+    tags: ["google", "satellite", "imagery"]
+  }),
+  rasterBasemap({
+    id: "google-terrain",
+    name: "Google Terrain",
+    provider: "google",
+    category: "Terrain",
+    description: "Google terrain tiles from the QGIS basemaps source.",
+    attribution: "© Google",
+    tiles: ["https://mt1.google.com/vt/lyrs=p&x={x}&y={y}&z={z}"],
+    maxzoom: 20,
+    tags: ["google", "terrain"]
+  }),
+  rasterBasemap({
+    id: "google-hybrid",
+    name: "Google Hybrid",
+    provider: "google",
+    category: "Imagery",
+    description: "Google hybrid imagery tiles from the QGIS basemaps source.",
+    attribution: "© Google",
+    tiles: ["https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}"],
+    maxzoom: 20,
+    tags: ["google", "hybrid", "imagery"]
+  }),
+  rasterBasemap({
+    id: "carto-positron",
+    name: "Carto Positron",
+    provider: "carto",
+    category: "Light",
+    description: "Light basemap for data overlays.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: [
+      "https://a.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png",
+      "https://b.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png",
+      "https://c.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png",
+      "https://d.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png"
+    ],
+    maxzoom: 20,
+    tags: ["carto", "light", "positron"]
+  }),
+  rasterBasemap({
+    id: "carto-positron-no-labels",
+    name: "Carto Positron No Labels",
+    provider: "carto",
+    category: "Light",
+    description: "Light basemap without labels.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: ["https://a.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}.png"],
+    maxzoom: 20,
+    tags: ["carto", "light", "no labels"]
+  }),
+  rasterBasemap({
+    id: "carto-positron-only-labels",
+    name: "Carto Positron Only Labels",
+    provider: "carto",
+    category: "Labels",
+    description: "Carto Positron labels layer.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: ["https://a.basemaps.cartocdn.com/light_only_labels/{z}/{x}/{y}.png"],
+    maxzoom: 20,
+    tags: ["carto", "labels"]
+  }),
+  rasterBasemap({
+    id: "carto-dark-matter",
+    name: "Carto Dark Matter",
+    provider: "carto",
+    category: "Dark",
+    description: "Dark basemap for high-contrast overlays.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: [
+      "https://a.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png",
+      "https://b.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png",
+      "https://c.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png",
+      "https://d.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png"
+    ],
+    maxzoom: 20,
+    tags: ["carto", "dark", "matter"]
+  }),
+  rasterBasemap({
+    id: "carto-dark-matter-no-labels",
+    name: "Carto Dark Matter No Labels",
+    provider: "carto",
+    category: "Dark",
+    description: "Dark basemap without labels.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: ["https://a.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}.png"],
+    maxzoom: 20,
+    tags: ["carto", "dark", "no labels"]
+  }),
+  rasterBasemap({
+    id: "carto-dark-matter-only-labels",
+    name: "Carto Dark Matter Only Labels",
+    provider: "carto",
+    category: "Labels",
+    description: "Carto Dark Matter labels layer.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: ["https://a.basemaps.cartocdn.com/dark_only_labels/{z}/{x}/{y}.png"],
+    maxzoom: 20,
+    tags: ["carto", "dark", "labels"]
+  }),
+  rasterBasemap({
+    id: "carto-voyager",
+    name: "Carto Voyager",
+    provider: "carto",
+    category: "Street",
+    description: "Detailed street basemap with subtle styling.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: [
+      "https://a.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}.png",
+      "https://b.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}.png",
+      "https://c.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}.png",
+      "https://d.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}.png"
+    ],
+    maxzoom: 20,
+    tags: ["carto", "street", "voyager"]
+  }),
+  rasterBasemap({
+    id: "carto-voyager-no-labels",
+    name: "Carto Voyager No Labels",
+    provider: "carto",
+    category: "Street",
+    description: "Carto Voyager without labels.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: ["https://a.basemaps.cartocdn.com/rastertiles/voyager_nolabels/{z}/{x}/{y}.png"],
+    maxzoom: 20,
+    tags: ["carto", "voyager", "no labels"]
+  }),
+  rasterBasemap({
+    id: "carto-voyager-only-labels",
+    name: "Carto Voyager Only Labels",
+    provider: "carto",
+    category: "Labels",
+    description: "Carto Voyager labels layer.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: ["https://a.basemaps.cartocdn.com/rastertiles/voyager_only_labels/{z}/{x}/{y}.png"],
+    maxzoom: 20,
+    tags: ["carto", "voyager", "labels"]
+  }),
+  rasterBasemap({
+    id: "carto-voyager-labels-under",
+    name: "Carto Voyager Labels Under",
+    provider: "carto",
+    category: "Street",
+    description: "Carto Voyager labels-under variant.",
+    attribution: CARTO_ATTRIBUTION,
+    tiles: ["https://a.basemaps.cartocdn.com/rastertiles/voyager_labels_under/{z}/{x}/{y}.png"],
+    maxzoom: 20,
+    tags: ["carto", "voyager", "labels"]
+  }),
+  rasterBasemap({
+    id: "cyclosm",
+    name: "CyclOSM",
+    provider: "cyclosm",
+    category: "Cycling",
+    description: "Cycling-focused OpenStreetMap style.",
+    attribution: "CyclOSM | Map data: © OpenStreetMap contributors",
+    tiles: ["https://a.tile-cyclosm.openstreetmap.fr/cyclosm/{z}/{x}/{y}.png"],
+    tags: ["cycling", "osm"]
+  }),
+  rasterBasemap({
+    id: "esri-world-imagery",
+    name: "World Imagery",
+    provider: "esri",
+    category: "Imagery",
+    description: "Satellite and aerial imagery.",
+    attribution: "Tiles © Esri, Maxar, Earthstar Geographics, and the GIS User Community",
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "satellite", "imagery"]
+  }),
+  rasterBasemap({
+    id: "esri-world-topo",
+    name: "World Topographic",
+    provider: "esri",
+    category: "Terrain",
+    description: "Reference topographic map.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "topographic", "terrain"]
+  }),
+  rasterBasemap({
+    id: "esri-world-street-map",
+    name: "World Street Map",
+    provider: "esri",
+    category: "Street",
+    description: "ESRI street reference basemap.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "street"]
+  }),
+  rasterBasemap({
+    id: "esri-world-gray-canvas",
+    name: "World Gray Canvas",
+    provider: "esri",
+    category: "Light",
+    description: "Light gray canvas basemap.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "gray", "canvas"]
+  }),
+  rasterBasemap({
+    id: "esri-natgeo-world-map",
+    name: "NatGeo World Map",
+    provider: "esri",
+    category: "Street",
+    description: "National Geographic style world map.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "natgeo"]
+  }),
+  rasterBasemap({
+    id: "esri-ocean-basemap",
+    name: "Ocean Basemap",
+    provider: "esri",
+    category: "Marine",
+    description: "Ocean reference basemap.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "ocean", "marine"]
+  }),
+  rasterBasemap({
+    id: "esri-world-physical",
+    name: "World Physical",
+    provider: "esri",
+    category: "Terrain",
+    description: "Physical world map.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/World_Physical_Map/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "physical", "terrain"]
+  }),
+  rasterBasemap({
+    id: "esri-world-shaded-relief",
+    name: "World Shaded Relief",
+    provider: "esri",
+    category: "Terrain",
+    description: "Shaded relief world map.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "relief", "terrain"]
+  }),
+  rasterBasemap({
+    id: "esri-world-terrain",
+    name: "World Terrain",
+    provider: "esri",
+    category: "Terrain",
+    description: "ESRI terrain base.",
+    attribution: ESRI_ATTRIBUTION,
+    tiles: [
+      "https://server.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["esri", "terrain"]
+  }),
+  rasterBasemap({
+    id: "nasa-gibs-blue-marble",
+    name: "Blue Marble",
+    provider: "nasa-gibs",
+    category: "Imagery",
+    description: "NASA Blue Marble Next Generation imagery.",
+    attribution: "Imagery provided by NASA Global Imagery Browse Services",
+    tiles: [
+      "https://gibs.earthdata.nasa.gov/wmts/epsg3857/best/BlueMarble_NextGeneration/default/GoogleMapsCompatible_Level8/{z}/{y}/{x}.jpeg"
+    ],
+    maxzoom: 8,
+    tags: ["nasa", "gibs", "blue marble"]
+  }),
+  rasterBasemap({
+    id: "nasa-gibs-aster-gdem-shaded-relief",
+    name: "ASTER GDEM Shaded Relief",
+    provider: "nasa-gibs",
+    category: "Terrain",
+    description: "NASA ASTER GDEM greyscale shaded relief.",
+    attribution: "Imagery provided by NASA Global Imagery Browse Services",
+    tiles: [
+      "https://gibs.earthdata.nasa.gov/wmts/epsg3857/best/ASTER_GDEM_Greyscale_Shaded_Relief/default/GoogleMapsCompatible_Level12/{z}/{y}/{x}.jpg"
+    ],
+    maxzoom: 12,
+    tags: ["nasa", "gibs", "relief", "terrain"]
+  }),
+  rasterBasemap({
+    id: "nasa-gibs-modis-terra-true-color",
+    name: "MODIS Terra True Color",
+    provider: "nasa-gibs",
+    category: "Imagery",
+    description: "NASA MODIS Terra corrected reflectance true color.",
+    attribution: "Imagery provided by NASA Global Imagery Browse Services",
+    tiles: [
+      "https://map1.vis.earthdata.nasa.gov/wmts-webmerc/MODIS_Terra_CorrectedReflectance_TrueColor/default//GoogleMapsCompatible_Level9/{z}/{y}/{x}.jpg"
+    ],
+    maxzoom: 9,
+    tags: ["nasa", "gibs", "modis", "true color"]
+  }),
+  rasterBasemap({
+    id: "nasa-gibs-viirs-earth-at-night",
+    name: "VIIRS Earth At Night 2012",
+    provider: "nasa-gibs",
+    category: "Imagery",
+    description: "NASA VIIRS city lights imagery.",
+    attribution: "Imagery provided by NASA Global Imagery Browse Services",
+    tiles: [
+      "https://map1.vis.earthdata.nasa.gov/wmts-webmerc/VIIRS_CityLights_2012/default//GoogleMapsCompatible_Level8/{z}/{y}/{x}.jpg"
+    ],
+    maxzoom: 8,
+    tags: ["nasa", "gibs", "night", "viirs"]
+  }),
+  rasterBasemap({
+    id: "openrailwaymap",
+    name: "OpenRailwayMap",
+    provider: "openrailwaymap",
+    category: "Transport",
+    description: "Railway infrastructure map.",
+    attribution: "Map data: © OpenStreetMap contributors | Map style: OpenRailwayMap",
+    tiles: ["https://a.tiles.openrailwaymap.org/standard/{z}/{x}/{y}.png"],
+    tags: ["rail", "transport", "osm"]
+  }),
+  rasterBasemap({
+    id: "opentopomap",
+    name: "OpenTopoMap",
+    provider: "opentopomap",
+    category: "Terrain",
+    description: "Topographic map with relief and contour styling.",
+    attribution: "Map data © OpenStreetMap contributors, SRTM | Map style © OpenTopoMap",
+    tiles: ["https://a.tile.opentopomap.org/{z}/{x}/{y}.png"],
+    maxzoom: 17,
+    tags: ["terrain", "topo", "relief"]
+  }),
+  rasterBasemap({
+    id: "swisstopo-national-map-color",
+    name: "Swiss National Map Color",
+    provider: "swisstopo",
+    category: "Regional",
+    description: "Swiss federal color national map.",
+    attribution: "© swisstopo",
+    tiles: [
+      "https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.pixelkarte-farbe/default/current/3857/{z}/{x}/{y}.jpeg"
+    ],
+    maxzoom: 18,
+    tags: ["switzerland", "regional"]
+  }),
+  rasterBasemap({
+    id: "swisstopo-national-map-grey",
+    name: "Swiss National Map Grey",
+    provider: "swisstopo",
+    category: "Regional",
+    description: "Swiss federal grey national map.",
+    attribution: "© swisstopo",
+    tiles: [
+      "https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.pixelkarte-grau/default/current/3857/{z}/{x}/{y}.jpeg"
+    ],
+    maxzoom: 18,
+    tags: ["switzerland", "regional", "grey"]
+  }),
+  rasterBasemap({
+    id: "swisstopo-swissimage",
+    name: "SWISSIMAGE",
+    provider: "swisstopo",
+    category: "Imagery",
+    description: "Swiss federal aerial imagery.",
+    attribution: "© swisstopo",
+    tiles: [
+      "https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.swissimage/default/current/3857/{z}/{x}/{y}.jpeg"
+    ],
+    maxzoom: 18,
+    tags: ["switzerland", "imagery"]
+  }),
+  rasterBasemap({
+    id: "topplusopen-color",
+    name: "TopPlusOpen Color",
+    provider: "topplusopen",
+    category: "Regional",
+    description: "German TopPlusOpen color basemap.",
+    attribution: "Map data: © dl-de/by-2-0",
+    tiles: [
+      "https://sgx.geodatenzentrum.de/wmts_topplus_open/tile/1.0.0/web/default/WEBMERCATOR/{z}/{y}/{x}.png"
+    ],
+    maxzoom: 18,
+    tags: ["germany", "regional"]
+  }),
+  rasterBasemap({
+    id: "topplusopen-grey",
+    name: "TopPlusOpen Grey",
+    provider: "topplusopen",
+    category: "Regional",
+    description: "German TopPlusOpen grey basemap.",
+    attribution: "Map data: © dl-de/by-2-0",
+    tiles: [
+      "https://sgx.geodatenzentrum.de/wmts_topplus_open/tile/1.0.0/web_grau/default/WEBMERCATOR/{z}/{y}/{x}.png"
+    ],
+    maxzoom: 18,
+    tags: ["germany", "regional", "grey"]
+  }),
+  rasterBasemap({
+    id: "usgs-us-imagery",
+    name: "USGS US Imagery",
+    provider: "usgs",
+    category: "Imagery",
+    description: "USGS imagery-only basemap.",
+    attribution: "Tiles courtesy of the U.S. Geological Survey",
+    tiles: [
+      "https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["usgs", "imagery", "united states"]
+  }),
+  rasterBasemap({
+    id: "usgs-us-imagery-topo",
+    name: "USGS US Imagery Topo",
+    provider: "usgs",
+    category: "Imagery",
+    description: "USGS imagery with topographic reference.",
+    attribution: "Tiles courtesy of the U.S. Geological Survey",
+    tiles: [
+      "https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryTopo/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["usgs", "imagery", "topo", "united states"]
+  }),
+  rasterBasemap({
+    id: "usgs-us-topo",
+    name: "USGS US Topo",
+    provider: "usgs",
+    category: "Terrain",
+    description: "USGS topographic basemap.",
+    attribution: "Tiles courtesy of the U.S. Geological Survey",
+    tiles: [
+      "https://basemap.nationalmap.gov/arcgis/rest/services/USGSTopo/MapServer/tile/{z}/{y}/{x}"
+    ],
+    tags: ["usgs", "topo", "united states"]
+  }),
+  rasterBasemap({
+    id: "waymarkedtrails-hiking",
+    name: "Waymarked Trails Hiking",
+    provider: "waymarkedtrails",
+    category: "Outdoor",
+    description: "Hiking routes from Waymarked Trails.",
+    attribution: "Map data: © OpenStreetMap contributors | Map style: Waymarked Trails",
+    tiles: ["https://tile.waymarkedtrails.org/hiking/{z}/{x}/{y}.png"],
+    tags: ["hiking", "outdoor", "trails"]
+  }),
+  rasterBasemap({
+    id: "waymarkedtrails-cycling",
+    name: "Waymarked Trails Cycling",
+    provider: "waymarkedtrails",
+    category: "Cycling",
+    description: "Cycling routes from Waymarked Trails.",
+    attribution: "Map data: © OpenStreetMap contributors | Map style: Waymarked Trails",
+    tiles: ["https://tile.waymarkedtrails.org/cycling/{z}/{x}/{y}.png"],
+    tags: ["cycling", "outdoor", "trails"]
+  }),
+  rasterBasemap({
+    id: "waymarkedtrails-mtb",
+    name: "Waymarked Trails MTB",
+    provider: "waymarkedtrails",
+    category: "Cycling",
+    description: "Mountain biking routes from Waymarked Trails.",
+    attribution: "Map data: © OpenStreetMap contributors | Map style: Waymarked Trails",
+    tiles: ["https://tile.waymarkedtrails.org/mtb/{z}/{x}/{y}.png"],
+    tags: ["mtb", "outdoor", "trails"]
+  }),
+  rasterBasemap({
+    id: "waymarkedtrails-slopes",
+    name: "Waymarked Trails Slopes",
+    provider: "waymarkedtrails",
+    category: "Outdoor",
+    description: "Slope routes from Waymarked Trails.",
+    attribution: "Map data: © OpenStreetMap contributors | Map style: Waymarked Trails",
+    tiles: ["https://tile.waymarkedtrails.org/slopes/{z}/{x}/{y}.png"],
+    tags: ["slopes", "outdoor", "trails"]
+  }),
+  rasterBasemap({
+    id: "nlmaps-standaard",
+    name: "nlmaps Standaard",
+    provider: "nlmaps",
+    category: "Regional",
+    description: "Netherlands standard background map.",
+    attribution: "Kaartgegevens © Kadaster",
+    tiles: [
+      "https://service.pdok.nl/brt/achtergrondkaart/wmts/v2_0/standaard/EPSG:3857/{z}/{x}/{y}.png"
+    ],
+    tags: ["netherlands", "regional"]
+  }),
+  rasterBasemap({
+    id: "nlmaps-grijs",
+    name: "nlmaps Grijs",
+    provider: "nlmaps",
+    category: "Regional",
+    description: "Netherlands grey background map.",
+    attribution: "Kaartgegevens © Kadaster",
+    tiles: [
+      "https://service.pdok.nl/brt/achtergrondkaart/wmts/v2_0/grijs/EPSG:3857/{z}/{x}/{y}.png"
+    ],
+    tags: ["netherlands", "regional", "grey"]
+  }),
+  rasterBasemap({
+    id: "nlmaps-pastel",
+    name: "nlmaps Pastel",
+    provider: "nlmaps",
+    category: "Regional",
+    description: "Netherlands pastel background map.",
+    attribution: "Kaartgegevens © Kadaster",
+    tiles: [
+      "https://service.pdok.nl/brt/achtergrondkaart/wmts/v2_0/pastel/EPSG:3857/{z}/{x}/{y}.png"
+    ],
+    tags: ["netherlands", "regional", "pastel"]
+  }),
+  rasterBasemap({
+    id: "nlmaps-water",
+    name: "nlmaps Water",
+    provider: "nlmaps",
+    category: "Regional",
+    description: "Netherlands water-focused background map.",
+    attribution: "Kaartgegevens © Kadaster",
+    tiles: [
+      "https://service.pdok.nl/brt/achtergrondkaart/wmts/v2_0/water/EPSG:3857/{z}/{x}/{y}.png"
+    ],
+    tags: ["netherlands", "regional", "water"]
+  }),
+  rasterBasemap({
+    id: "nlmaps-luchtfoto",
+    name: "nlmaps Luchtfoto",
+    provider: "nlmaps",
+    category: "Imagery",
+    description: "Netherlands aerial photography.",
+    attribution: "Kaartgegevens © Kadaster",
+    tiles: [
+      "https://service.pdok.nl/hwh/luchtfotorgb/wmts/v1_0/Actueel_ortho25/EPSG:3857/{z}/{x}/{y}.jpeg"
+    ],
+    tags: ["netherlands", "imagery", "aerial"]
+  }),
+  {
+    id: "openfreemap-positron",
+    name: "OpenFreeMap Positron",
+    provider: "openfreemap",
+    type: "style",
+    category: "Light",
+    description: "Light, minimal OpenFreeMap vector style for data overlays.",
+    attribution: OPENFREEMAP_ATTRIBUTION,
+    source: {
+      type: "style",
+      url: "https://tiles.openfreemap.org/styles/positron"
+    },
+    tags: ["openfreemap", "vector", "style", "positron", "light"]
+  },
+  {
+    id: "openfreemap-bright",
+    name: "OpenFreeMap Bright",
+    provider: "openfreemap",
+    type: "style",
+    category: "Street",
+    description: "Colorful OpenFreeMap vector street style.",
+    attribution: OPENFREEMAP_ATTRIBUTION,
+    source: {
+      type: "style",
+      url: "https://tiles.openfreemap.org/styles/bright"
+    },
+    tags: ["openfreemap", "vector", "style", "bright", "street"]
+  },
+  {
+    id: "openfreemap-liberty",
+    name: "OpenFreeMap Liberty",
+    provider: "openfreemap",
+    type: "style",
+    category: "Vector",
+    description: "Open vector style loaded as a full MapLibre style.",
+    attribution: OPENFREEMAP_ATTRIBUTION,
+    source: {
+      type: "style",
+      url: "https://tiles.openfreemap.org/styles/liberty"
+    },
+    tags: ["openfreemap", "vector", "style"]
+  },
+  {
+    id: "openfreemap-dark",
+    name: "OpenFreeMap Dark",
+    provider: "openfreemap",
+    type: "style",
+    category: "Dark",
+    description: "Dark OpenFreeMap vector style.",
+    attribution: OPENFREEMAP_ATTRIBUTION,
+    source: {
+      type: "style",
+      url: "https://tiles.openfreemap.org/styles/dark"
+    },
+    tags: ["openfreemap", "vector", "style", "dark"]
+  },
+  {
+    id: "openfreemap-fiord",
+    name: "OpenFreeMap Fiord",
+    provider: "openfreemap",
+    type: "style",
+    category: "Dark",
+    description: "Blue-toned dark OpenFreeMap vector style.",
+    attribution: OPENFREEMAP_ATTRIBUTION,
+    source: {
+      type: "style",
+      url: "https://tiles.openfreemap.org/styles/fiord"
+    },
+    tags: ["openfreemap", "vector", "style", "fiord", "dark"]
+  },
+  {
+    id: "openfreemap-3d",
+    name: "OpenFreeMap 3D",
+    provider: "openfreemap",
+    type: "style",
+    category: "3D",
+    description: "OpenFreeMap Liberty style with a pitched 3D camera view.",
+    attribution: OPENFREEMAP_ATTRIBUTION,
+    source: {
+      type: "style",
+      url: "https://tiles.openfreemap.org/styles/liberty"
+    },
+    view: {
+      center: [-0.114, 51.506],
+      zoom: 14.2,
+      bearing: 55.2,
+      pitch: 60
+    },
+    tags: ["openfreemap", "vector", "style", "3d", "liberty"]
+  }
+];
+function combineProviders(defaults, custom = []) {
+  const byId = /* @__PURE__ */ new Map();
+  defaults.forEach((provider) => byId.set(provider.id, provider));
+  custom.forEach((provider) => byId.set(provider.id, provider));
+  return [...byId.values()];
+}
+function resolveBasemapProviders(basemaps, customProviders = [], includeDefaultProviders = true) {
+  const byId = /* @__PURE__ */ new Map();
+  if (includeDefaultProviders) {
+    DEFAULT_BASEMAP_PROVIDERS.forEach((provider) => byId.set(provider.id, provider));
+  }
+  customProviders.forEach((provider) => byId.set(provider.id, provider));
+  basemaps.forEach((basemap) => {
+    if (basemap.provider && !byId.has(basemap.provider)) {
+      byId.set(basemap.provider, { id: basemap.provider, name: basemap.provider });
+    }
+  });
+  return [...byId.values()];
+}
+function createBasemapCatalog(customBasemaps = [], includeDefaultBasemaps = true) {
+  const basemaps = includeDefaultBasemaps ? [...DEFAULT_BASEMAPS, ...customBasemaps] : [...customBasemaps];
+  const byId = /* @__PURE__ */ new Map();
+  basemaps.forEach((basemap) => byId.set(basemap.id, basemap));
+  return [...byId.values()];
+}
+function filterBasemaps(basemaps, filter) {
+  var _a;
+  const query = ((_a = filter.query) == null ? void 0 : _a.trim().toLowerCase()) ?? "";
+  return basemaps.filter((basemap) => {
+    if (filter.provider && basemap.provider !== filter.provider) return false;
+    if (filter.category && basemap.category !== filter.category) return false;
+    if (!query) return true;
+    const haystack = [
+      basemap.name,
+      basemap.provider,
+      basemap.category,
+      basemap.description,
+      ...basemap.tags ?? []
+    ].filter(Boolean).join(" ").toLowerCase();
+    return haystack.includes(query);
+  });
+}
+function getBasemapCategories(basemaps) {
+  return [...new Set(basemaps.map((basemap) => basemap.category).filter(Boolean))].sort();
+}
+const DEFAULT_OPTIONS = {
+  collapsed: true,
+  position: "top-right",
+  title: "Basemaps",
+  panelWidth: 340,
+  className: "",
+  includeDefaultBasemaps: true
+};
+const CONTROL_SOURCE_PREFIX = "maplibre-basemap-control-source";
+const CONTROL_LAYER_PREFIX = "maplibre-basemap-control-layer";
+class BasemapControl {
+  constructor(options) {
+    __publicField(this, "_map");
+    __publicField(this, "_mapContainer");
+    __publicField(this, "_container");
+    __publicField(this, "_panel");
+    __publicField(this, "_content");
+    __publicField(this, "_options");
+    __publicField(this, "_state");
+    __publicField(this, "_basemaps");
+    __publicField(this, "_providers");
+    __publicField(this, "_eventHandlers", new globalThis.Map());
+    __publicField(this, "_managedSourceIds", []);
+    __publicField(this, "_managedLayerIds", []);
+    __publicField(this, "_resizeHandler", null);
+    __publicField(this, "_mapResizeHandler", null);
+    __publicField(this, "_clickOutsideHandler", null);
+    this._options = { ...DEFAULT_OPTIONS, ...options };
+    this._basemaps = createBasemapCatalog(
+      options == null ? void 0 : options.basemaps,
+      this._options.includeDefaultBasemaps
+    );
+    this._providers = resolveBasemapProviders(
+      this._basemaps,
+      options == null ? void 0 : options.providers,
+      this._options.includeDefaultBasemaps
+    );
+    this._state = {
+      collapsed: this._options.collapsed,
+      panelWidth: this._options.panelWidth,
+      activeBasemapId: this._options.defaultBasemapId,
+      query: "",
+      providerFilter: "",
+      categoryFilter: "",
+      loading: false
+    };
+  }
+  onAdd(map) {
+    this._map = map;
+    this._mapContainer = map.getContainer();
+    this._container = this._createContainer();
+    this._panel = this._createPanel();
+    this._mapContainer.appendChild(this._panel);
+    this._setupEventListeners();
+    if (!this._state.collapsed) {
+      this._panel.classList.add("expanded");
+      requestAnimationFrame(() => this._updatePanelPosition());
+    }
+    this._renderContent();
+    if (this._state.activeBasemapId) {
+      this._selectBasemap(this._state.activeBasemapId);
+    }
+    return this._container;
+  }
+  onRemove() {
+    var _a, _b, _c, _d;
+    if (this._resizeHandler) {
+      window.removeEventListener("resize", this._resizeHandler);
+      this._resizeHandler = null;
+    }
+    if (this._mapResizeHandler && this._map) {
+      this._map.off("resize", this._mapResizeHandler);
+      this._mapResizeHandler = null;
+    }
+    if (this._clickOutsideHandler) {
+      document.removeEventListener("click", this._clickOutsideHandler);
+      this._clickOutsideHandler = null;
+    }
+    this._removeManagedBasemap();
+    (_b = (_a = this._panel) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.removeChild(this._panel);
+    (_d = (_c = this._container) == null ? void 0 : _c.parentNode) == null ? void 0 : _d.removeChild(this._container);
+    this._map = void 0;
+    this._mapContainer = void 0;
+    this._container = void 0;
+    this._panel = void 0;
+    this._content = void 0;
+    this._eventHandlers.clear();
+  }
+  getState() {
+    return { ...this._state };
+  }
+  setState(newState) {
+    this._state = { ...this._state, ...newState };
+    this._renderContent();
+    this._emit({ type: "statechange", state: this.getState() });
+  }
+  getBasemaps() {
+    return [...this._basemaps];
+  }
+  setBasemaps(basemaps) {
+    this._basemaps = [...basemaps];
+    this._providers = resolveBasemapProviders(
+      this._basemaps,
+      this._options.providers,
+      this._options.includeDefaultBasemaps
+    );
+    if (this._state.activeBasemapId && !this._basemaps.some((basemap) => basemap.id === this._state.activeBasemapId)) {
+      this._state = { ...this._state, activeBasemapId: void 0 };
+    }
+    this._renderContent();
+    this._emit({ type: "statechange", state: this.getState() });
+  }
+  getActiveBasemap() {
+    return this._basemaps.find((basemap) => basemap.id === this._state.activeBasemapId);
+  }
+  async setBasemap(id) {
+    const basemap = this._basemaps.find((candidate) => candidate.id === id);
+    if (!basemap) {
+      const error = new Error(`Basemap "${id}" was not found.`);
+      this._handleError(error);
+      throw error;
+    }
+    if (!this._map) {
+      const error = new Error("BasemapControl must be added to a map before setting a basemap.");
+      this._handleError(error, basemap);
+      throw error;
+    }
+    this._state = { ...this._state, loading: true, error: void 0 };
+    this._renderContent();
+    this._emit({ type: "statechange", state: this.getState() });
+    try {
+      if (basemap.source.type === "raster") {
+        await this._waitForStyleReady();
+        this._removeManagedBasemap();
+        this._addRasterBasemap(basemap);
+      } else {
+        this._removeManagedBasemap();
+        this._map.setStyle(basemap.source.url);
+      }
+      this._applyBasemapView(basemap);
+      this._state = {
+        ...this._state,
+        activeBasemapId: basemap.id,
+        loading: false,
+        error: void 0
+      };
+      this._renderContent();
+      this._emit({ type: "basemapchange", state: this.getState(), basemap });
+      this._emit({ type: "statechange", state: this.getState() });
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      this._state = { ...this._state, loading: false, error: error.message };
+      this._renderContent();
+      this._handleError(error, basemap);
+      throw error;
+    }
+  }
+  // setBasemap rethrows after emitting the error event so callers that await
+  // it can react. Internal fire-and-forget callers use this instead to avoid
+  // unhandled promise rejections; the failure is still reported via `error`.
+  _selectBasemap(id) {
+    this.setBasemap(id).catch(() => {
+    });
+  }
+  toggle() {
+    this._state = { ...this._state, collapsed: !this._state.collapsed };
+    if (this._panel) {
+      if (this._state.collapsed) {
+        this._panel.classList.remove("expanded");
+        this._emit({ type: "collapse", state: this.getState() });
+      } else {
+        this._panel.classList.add("expanded");
+        this._updatePanelPosition();
+        this._emit({ type: "expand", state: this.getState() });
+      }
+    }
+    this._emit({ type: "statechange", state: this.getState() });
+  }
+  expand() {
+    if (this._state.collapsed) this.toggle();
+  }
+  collapse() {
+    if (!this._state.collapsed) this.toggle();
+  }
+  on(event, handler) {
+    if (!this._eventHandlers.has(event)) {
+      this._eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this._eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    var _a;
+    (_a = this._eventHandlers.get(event)) == null ? void 0 : _a.delete(handler);
+  }
+  getMap() {
+    return this._map;
+  }
+  getContainer() {
+    return this._container;
+  }
+  _emit(event) {
+    var _a;
+    (_a = this._eventHandlers.get(event.type)) == null ? void 0 : _a.forEach((handler) => handler(event));
+  }
+  _handleError(error, basemap) {
+    this._emit({ type: "error", state: this.getState(), error, basemap });
+    this._emit({ type: "statechange", state: this.getState() });
+  }
+  _createContainer() {
+    const container = document.createElement("div");
+    container.className = `maplibregl-ctrl maplibregl-ctrl-group basemap-control${this._options.className ? ` ${this._options.className}` : ""}`;
+    const toggleBtn = document.createElement("button");
+    toggleBtn.className = "basemap-control-toggle";
+    toggleBtn.type = "button";
+    toggleBtn.title = this._options.title;
+    toggleBtn.setAttribute("aria-label", this._options.title);
+    toggleBtn.innerHTML = `
+      <span class="basemap-control-icon" aria-hidden="true">
+        <svg viewBox="0 0 24 24" width="22" height="22" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <path d="m3 6 6-3 6 3 6-3v15l-6 3-6-3-6 3V6Z"/>
+          <path d="M9 3v15"/>
+          <path d="M15 6v15"/>
+        </svg>
+      </span>
+    `;
+    toggleBtn.addEventListener("click", () => this.toggle());
+    container.appendChild(toggleBtn);
+    return container;
+  }
+  _createPanel() {
+    const panel = document.createElement("div");
+    panel.className = "basemap-control-panel";
+    panel.style.width = `${this._options.panelWidth}px`;
+    const header = document.createElement("div");
+    header.className = "basemap-control-header";
+    const title = document.createElement("span");
+    title.className = "basemap-control-title";
+    title.textContent = this._options.title;
+    const closeBtn = document.createElement("button");
+    closeBtn.className = "basemap-control-close";
+    closeBtn.type = "button";
+    closeBtn.setAttribute("aria-label", "Close basemap panel");
+    closeBtn.innerHTML = "&times;";
+    closeBtn.addEventListener("click", () => this.collapse());
+    header.appendChild(title);
+    header.appendChild(closeBtn);
+    this._content = document.createElement("div");
+    this._content.className = "basemap-control-content";
+    panel.appendChild(header);
+    panel.appendChild(this._content);
+    return panel;
+  }
+  _renderContent() {
+    if (!this._content) return;
+    const categories = getBasemapCategories(this._basemaps);
+    const results = filterBasemaps(this._basemaps, {
+      query: this._state.query,
+      provider: this._state.providerFilter,
+      category: this._state.categoryFilter
+    });
+    this._content.replaceChildren(
+      this._createSearchInput(),
+      this._createFilterRow(this._providers, categories),
+      this._createStatus(results.length),
+      this._createResults(results)
+    );
+  }
+  _createSearchInput() {
+    const wrapper = document.createElement("div");
+    wrapper.className = "basemap-control-search";
+    const input = document.createElement("input");
+    input.className = "basemap-control-input";
+    input.type = "search";
+    input.placeholder = "Search basemaps";
+    input.value = this._state.query;
+    input.setAttribute("aria-label", "Search basemaps");
+    input.addEventListener("input", () => {
+      this._state = { ...this._state, query: input.value };
+      this._renderContent();
+      this._emit({ type: "statechange", state: this.getState() });
+    });
+    wrapper.appendChild(input);
+    return wrapper;
+  }
+  _createFilterRow(providers, categories) {
+    const row = document.createElement("div");
+    row.className = "basemap-control-filters";
+    row.appendChild(
+      this._createSelect(
+        "Provider",
+        this._state.providerFilter,
+        providers.map((provider) => ({ value: provider.id, label: provider.name })),
+        (value) => {
+          this._state = { ...this._state, providerFilter: value };
+          this._renderContent();
+          this._emit({ type: "statechange", state: this.getState() });
+        }
+      )
+    );
+    row.appendChild(
+      this._createSelect(
+        "Category",
+        this._state.categoryFilter,
+        categories.map((category) => ({ value: category, label: category })),
+        (value) => {
+          this._state = { ...this._state, categoryFilter: value };
+          this._renderContent();
+          this._emit({ type: "statechange", state: this.getState() });
+        }
+      )
+    );
+    return row;
+  }
+  _createSelect(label, value, options, onChange) {
+    const select = document.createElement("select");
+    select.className = "basemap-control-select";
+    select.setAttribute("aria-label", label);
+    const all = document.createElement("option");
+    all.value = "";
+    all.textContent = `All ${label.toLowerCase()}s`;
+    select.appendChild(all);
+    options.forEach((option) => {
+      const element = document.createElement("option");
+      element.value = option.value;
+      element.textContent = option.label;
+      select.appendChild(element);
+    });
+    select.value = value;
+    select.addEventListener("change", () => onChange(select.value));
+    return select;
+  }
+  _createStatus(resultCount) {
+    const status = document.createElement("div");
+    status.className = "basemap-control-status";
+    if (this._state.loading) {
+      status.textContent = "Applying basemap...";
+    } else if (this._state.error) {
+      status.textContent = this._state.error;
+      status.classList.add("is-error");
+    } else {
+      status.textContent = `${resultCount} basemap${resultCount === 1 ? "" : "s"}`;
+    }
+    return status;
+  }
+  _createResults(results) {
+    const list = document.createElement("div");
+    list.className = "basemap-control-results";
+    if (results.length === 0) {
+      const empty = document.createElement("div");
+      empty.className = "basemap-control-empty";
+      empty.textContent = "No basemaps match your search.";
+      list.appendChild(empty);
+      return list;
+    }
+    results.forEach((basemap) => {
+      const row = document.createElement("button");
+      row.type = "button";
+      row.className = "basemap-control-result";
+      row.dataset.basemapId = basemap.id;
+      if (basemap.id === this._state.activeBasemapId) {
+        row.classList.add("is-active");
+        row.setAttribute("aria-current", "true");
+      }
+      row.disabled = this._state.loading;
+      row.addEventListener("click", () => {
+        this._selectBasemap(basemap.id);
+      });
+      const main = document.createElement("span");
+      main.className = "basemap-control-result-main";
+      const name = document.createElement("span");
+      name.className = "basemap-control-result-name";
+      name.textContent = basemap.name;
+      const meta = document.createElement("span");
+      meta.className = "basemap-control-result-meta";
+      meta.textContent = this._formatBasemapMeta(basemap);
+      main.appendChild(name);
+      main.appendChild(meta);
+      const type = document.createElement("span");
+      type.className = "basemap-control-result-type";
+      type.textContent = basemap.type === "raster" ? "Raster" : "Style";
+      row.appendChild(main);
+      row.appendChild(type);
+      if (basemap.attribution) {
+        const attribution = document.createElement("span");
+        attribution.className = "basemap-control-result-attribution";
+        attribution.textContent = this._stripHtml(basemap.attribution);
+        row.appendChild(attribution);
+      }
+      list.appendChild(row);
+    });
+    return list;
+  }
+  _formatBasemapMeta(basemap) {
+    const provider = this._providers.find((candidate) => candidate.id === basemap.provider);
+    return [(provider == null ? void 0 : provider.name) ?? basemap.provider, basemap.category].filter(Boolean).join(" / ");
+  }
+  _stripHtml(value) {
+    const template = document.createElement("template");
+    template.innerHTML = value;
+    return template.content.textContent ?? value;
+  }
+  _addRasterBasemap(basemap) {
+    if (!this._map || basemap.source.type !== "raster") return;
+    const sourceId = `${CONTROL_SOURCE_PREFIX}-${basemap.id}`;
+    const layerId = `${CONTROL_LAYER_PREFIX}-${basemap.id}`;
+    const source = {
+      type: "raster",
+      tiles: basemap.source.tiles,
+      tileSize: basemap.source.tileSize ?? 256,
+      minzoom: basemap.source.minzoom,
+      maxzoom: basemap.source.maxzoom,
+      scheme: basemap.source.scheme,
+      attribution: basemap.attribution
+    };
+    const layer = {
+      id: layerId,
+      type: "raster",
+      source: sourceId
+    };
+    this._map.addSource(sourceId, source);
+    this._map.addLayer(layer, this._findBasemapInsertBeforeId());
+    this._managedSourceIds = [sourceId];
+    this._managedLayerIds = [layerId];
+  }
+  _waitForStyleReady() {
+    if (!this._map) return Promise.resolve();
+    if (typeof this._map.isStyleLoaded !== "function" || this._map.isStyleLoaded()) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      var _a, _b;
+      const done = () => {
+        var _a2, _b2;
+        (_a2 = this._map) == null ? void 0 : _a2.off("load", done);
+        (_b2 = this._map) == null ? void 0 : _b2.off("style.load", done);
+        resolve();
+      };
+      (_a = this._map) == null ? void 0 : _a.once("load", done);
+      (_b = this._map) == null ? void 0 : _b.once("style.load", done);
+    });
+  }
+  _removeManagedBasemap() {
+    if (!this._map) return;
+    [...this._managedLayerIds].reverse().forEach((layerId) => {
+      var _a;
+      if ((_a = this._map) == null ? void 0 : _a.getLayer(layerId)) {
+        this._map.removeLayer(layerId);
+      }
+    });
+    [...this._managedSourceIds].reverse().forEach((sourceId) => {
+      var _a;
+      if ((_a = this._map) == null ? void 0 : _a.getSource(sourceId)) {
+        this._map.removeSource(sourceId);
+      }
+    });
+    this._managedLayerIds = [];
+    this._managedSourceIds = [];
+  }
+  _applyBasemapView(basemap) {
+    if (!this._map || !basemap.view) return;
+    this._map.jumpTo({
+      center: basemap.view.center,
+      zoom: basemap.view.zoom,
+      bearing: basemap.view.bearing,
+      pitch: basemap.view.pitch
+    });
+  }
+  _findBasemapInsertBeforeId() {
+    var _a;
+    const layers = ((_a = this._map) == null ? void 0 : _a.getStyle().layers) ?? [];
+    const firstOverlay = layers.find(
+      (layer) => layer.type !== "background" && !layer.id.startsWith(CONTROL_LAYER_PREFIX)
+    );
+    return firstOverlay == null ? void 0 : firstOverlay.id;
+  }
+  _setupEventListeners() {
+    var _a;
+    this._clickOutsideHandler = (e) => {
+      const target = e.target;
+      if (this._container && this._panel && !this._container.contains(target) && !this._panel.contains(target)) {
+        this.collapse();
+      }
+    };
+    document.addEventListener("click", this._clickOutsideHandler);
+    this._resizeHandler = () => {
+      if (!this._state.collapsed) this._updatePanelPosition();
+    };
+    window.addEventListener("resize", this._resizeHandler);
+    this._mapResizeHandler = () => {
+      if (!this._state.collapsed) this._updatePanelPosition();
+    };
+    (_a = this._map) == null ? void 0 : _a.on("resize", this._mapResizeHandler);
+  }
+  _getControlPosition() {
+    var _a;
+    const parent = (_a = this._container) == null ? void 0 : _a.parentElement;
+    if (!parent) return this._options.position;
+    if (parent.classList.contains("maplibregl-ctrl-top-left")) return "top-left";
+    if (parent.classList.contains("maplibregl-ctrl-top-right")) return "top-right";
+    if (parent.classList.contains("maplibregl-ctrl-bottom-left")) return "bottom-left";
+    if (parent.classList.contains("maplibregl-ctrl-bottom-right")) return "bottom-right";
+    return this._options.position;
+  }
+  _updatePanelPosition() {
+    if (!this._container || !this._panel || !this._mapContainer) return;
+    const button = this._container.querySelector(".basemap-control-toggle");
+    if (!button) return;
+    const buttonRect = button.getBoundingClientRect();
+    const mapRect = this._mapContainer.getBoundingClientRect();
+    const position = this._getControlPosition();
+    const buttonTop = buttonRect.top - mapRect.top;
+    const buttonBottom = mapRect.bottom - buttonRect.bottom;
+    const buttonLeft = buttonRect.left - mapRect.left;
+    const buttonRight = mapRect.right - buttonRect.right;
+    const panelGap = 5;
+    this._panel.style.top = "";
+    this._panel.style.bottom = "";
+    this._panel.style.left = "";
+    this._panel.style.right = "";
+    switch (position) {
+      case "top-left":
+        this._panel.style.top = `${buttonTop + buttonRect.height + panelGap}px`;
+        this._panel.style.left = `${buttonLeft}px`;
+        break;
+      case "top-right":
+        this._panel.style.top = `${buttonTop + buttonRect.height + panelGap}px`;
+        this._panel.style.right = `${buttonRight}px`;
+        break;
+      case "bottom-left":
+        this._panel.style.bottom = `${buttonBottom + buttonRect.height + panelGap}px`;
+        this._panel.style.left = `${buttonLeft}px`;
+        break;
+      case "bottom-right":
+        this._panel.style.bottom = `${buttonBottom + buttonRect.height + panelGap}px`;
+        this._panel.style.right = `${buttonRight}px`;
+        break;
+    }
+  }
+}
+export {
+  BasemapControl as B,
+  DEFAULT_BASEMAPS as D,
+  DEFAULT_BASEMAP_PROVIDERS as a,
+  createBasemapCatalog as b,
+  combineProviders as c,
+  filterBasemaps as f,
+  getBasemapCategories as g,
+  resolveBasemapProviders as r
+};
+//# sourceMappingURL=BasemapControl-C40PophU.js.map