maplibre-gl-raster 0.12.0 → 0.14.0

package/README.md

@@ -164,7 +164,10 @@ layer:
   ([cog-tiler-wasm](https://github.com/opengeos/cog-tiler-wasm)) wired to a
   MapLibre custom protocol. Tiles are rendered on the CPU and served as native
   MapLibre raster layers. The panel's settings (bands, rescale, colormap,
-  curve, gamma, nodata, opacity) map directly onto its render parameters.
+  curve, gamma, nodata, opacity) map directly onto its render parameters. This
+  tiler ships a shorter colormap list than the deck.gl sprite, so while it is
+  active the panel's colormap picker narrows to the ramps it can actually draw
+  (a name it does not know renders black rather than falling back).
 - **`titiler`** - a server-side dynamic tiler
   ([TiTiler](https://developmentseed.org/titiler/)). Tiles are rendered by a
   remote TiTiler instance and drawn as native MapLibre raster layers, so

package/dist/{RasterControl-Cv3yZ90Z.js → RasterControl-hvApJoZQ.js}

@@ -2753,13 +2753,23 @@ var ColormapPicker = class {
 	constructor(options) {
 		this._palette = options.palette ?? null;
 		this._stats = options.stats ?? null;
-		const selectOptions = [...this._palette ? [{
-			value: PALETTE_COLORMAP,
-			label: "Image palette (default)"
-		}] : [], ...COLORMAP_OPTIONS.map((o) => ({
+		const allowed = options.allowed;
+		const named = COLORMAP_OPTIONS.filter((o) => !allowed || allowed.has(o.name)).map((o) => ({
 			value: o.name,
 			label: o.label
-		}))];
+		}));
+		const unsupported = allowed && options.value && options.value !== "palette" && !allowed.has(options.value) ? [{
+			value: options.value,
+			label: `${colormapDisplayName(options.value)} (not supported by this engine)`
+		}] : [];
+		const selectOptions = [
+			...this._palette ? [{
+				value: PALETTE_COLORMAP,
+				label: "Image palette (default)"
+			}] : [],
+			...unsupported,
+			...named
+		];
 		this._select = select(selectOptions, options.value, (next) => {
 			this._updatePreview(next);
 			options.onChange(next);
@@ -19055,7 +19065,180 @@ function classNames(classes) {
 	return Object.entries(classes).filter(([, value]) => value).map(([key]) => key).join(" ");
 }
 //#endregion
+//#region src/lib/state/RasterLayer.ts
+/** Default visualization state for a freshly added layer. Mode/bands are
+* re-picked automatically once the band count is known (unless the caller
+* supplied them explicitly); single-band rasters default to the image's
+* embedded color table when present ('palette') or grayscale otherwise. */
+var DEFAULT_LAYER_STATE = {
+	mode: "rgb",
+	bands: [
+		1,
+		2,
+		3
+	],
+	rescale: null,
+	colormap: "gray",
+	reversed: false,
+	nodata: "auto",
+	opacity: 1,
+	gamma: 1,
+	stretch: "linear",
+	visible: true,
+	minZoom: 0,
+	maxZoom: 24
+};
+/**
+* Creates a complete layer state from optional overrides.
+*
+* @param overrides - Partial state merged over the defaults
+* @returns A fully populated RasterLayerState
+*/
+function createLayerState(overrides) {
+	return {
+		...DEFAULT_LAYER_STATE,
+		...overrides
+	};
+}
+/**
+* Resolves a layer's min/max zoom bounds, filling in the full [0, 24] range for
+* any bound left unset. Shared by the render engines so the deck.gl overlay and
+* the native MapLibre raster layers apply an identical zoom range.
+*
+* @param state - The layer state (only its zoom bounds are read)
+* @returns The concrete `{ minZoom, maxZoom }` bounds
+*/
+function resolveZoomRange(state) {
+	return {
+		minZoom: state.minZoom ?? 0,
+		maxZoom: state.maxZoom ?? 24
+	};
+}
+/**
+* Derives the public snapshot for a layer.
+*
+* @param layer - Internal layer record
+* @returns A read-only info object safe to hand to consumers
+*/
+function toLayerInfo(layer) {
+	return {
+		id: layer.id,
+		name: layer.name,
+		source: layer.source,
+		memberUrls: layer.members ? layer.members.map((m) => m.url) : null,
+		bandCount: layer.bandCount,
+		bandNames: layer.bandNames ? new Map(layer.bandNames) : null,
+		beforeId: layer.beforeId,
+		attribution: layer.attribution,
+		bounds: layer.bounds ? { ...layer.bounds } : null,
+		loading: layer.loading,
+		error: layer.error,
+		state: { ...layer.state }
+	};
+}
+/** True when `lngLat` falls inside `bounds` (edges included). */
+function containsPoint(bounds, lngLat) {
+	const [lng, lat] = lngLat;
+	return lng >= bounds.west && lng <= bounds.east && lat >= bounds.south && lat <= bounds.north;
+}
+/**
+* The layer's images that could carry a sample at `lngLat`, topmost first.
+*
+* A plain layer has exactly one image. A mosaic VRT layer has one per member,
+* and only the members whose extent covers the point are worth reading — a
+* member whose bounds have not been reported yet stays a candidate rather than
+* being skipped, since bounds only arrive once a member renders.
+*
+* Members are returned in reverse document order because that is the order they
+* are drawn in: `LayerManager` builds one deck.gl layer per member in member
+* order, so later members paint over earlier ones — matching GDAL, where a
+* VRT's later sources overwrite earlier ones. Sources placed at their natural
+* position can still overlap (adjacent scenes commonly do), so where they do,
+* the last one is what the user sees and therefore what a reader should report.
+*
+* @param layer - The layer to read from
+* @param lngLat - The location, [lng, lat] in WGS84
+* @returns Candidate images, topmost first; empty when the layer has not loaded
+*   or the point falls outside every member
+*/
+function imagesAt(layer, lngLat) {
+	if (!layer.members) return layer.geotiff ? [layer.geotiff] : [];
+	return layer.members.filter((m) => !m.bounds || containsPoint(m.bounds, lngLat)).reverse().map((m) => m.geotiff);
+}
+/**
+* The mosaic assets whose extent covers `lngLat`, in manifest order.
+*
+* A mosaic manifest layer (MosaicJSON or STAC) has no opened image of its own —
+* the deck.gl {@link import('@developmentseed/deck.gl-geotiff').MosaicLayer}
+* opens each asset lazily while it is in view — so a reader works from the
+* manifest's bboxes and opens what it needs. This is the mosaic counterpart to
+* {@link imagesAt}, returning URLs because the COGs may not be open yet.
+*
+* Unlike a VRT's members these are *not* reversed. A VRT has a defined paint
+* order (later sources overwrite earlier ones), but a mosaic's assets are drawn
+* in whatever order its spatial index returns them, so no candidate is reliably
+* "topmost". Manifest order is used instead: it matches MosaicJSON's convention
+* that the first asset listed for a location is the preferred one. Where assets
+* genuinely overlap the drawn pixel is ambiguous, and the first covering asset
+* is as defensible a report as any.
+*
+* @param layer - The layer to read from
+* @param lngLat - The location, [lng, lat] in WGS84
+* @returns Covering asset URLs in manifest order; empty when the layer is not a
+*   mosaic manifest, has not parsed yet, or the point falls outside every asset
+*/
+function assetsAt(layer, lngLat) {
+	if (!layer.mosaicAssets) return [];
+	const [lng, lat] = lngLat;
+	return layer.mosaicAssets.filter((a) => lng >= a.bbox[0] && lng <= a.bbox[2] && lat >= a.bbox[1] && lat <= a.bbox[3]).map((a) => a.url);
+}
+/**
+* Derives a display name from a URL or file name: the last path segment
+* without query string.
+*
+* @param source - URL string or file name
+* @returns A short human-readable layer name
+*/
+function deriveLayerName(source) {
+	try {
+		const segment = (source.includes("://") ? new URL(source).pathname : source).split("/").filter(Boolean).pop();
+		return segment ? decodeURIComponent(segment) : source;
+	} catch {
+		return source;
+	}
+}
+//#endregion
 //#region src/lib/state/CogTilerEngine.ts
+/**
+* The colormaps assumed renderable before the wasm module has loaded.
+*
+* This is only a starting guess: once the module is in memory the engine
+* reports its real set from `colormaps()` (see
+* {@link CogTilerEngine.supportedColormaps}), so a package that ships more
+* ramps widens the picker on its own with no change here. The conservative
+* subset below is what every published version has always known, so the picker
+* never offers a ramp the tiler cannot draw during that first moment.
+*
+* Rendering an unknown name is a soft failure, not a hard one: the tiler falls
+* back to its `gray` ramp (asserted upstream by
+* `colormap::tests::unknown_name_falls_back_to_gray`), so a mismatch looks like
+* a greyscale image rather than a blank tile.
+*/
+var COG_TILER_COLORMAPS = [
+	"viridis",
+	"magma",
+	"plasma",
+	"inferno",
+	"cividis",
+	"turbo",
+	"terrain",
+	"blues",
+	"greens",
+	"reds",
+	"rdylgn",
+	"spectral",
+	"gray"
+];
 /** A blank tile: cog-tiler returns an empty buffer for tiles outside the COG. */
 var EMPTY_TILE = new Uint8Array(0);
 /** Upper bound on how many mosaic assets one tile will composite.
@@ -19169,6 +19352,23 @@ var CogTilerEngine = class {
 		this._map = map;
 		this._deps = deps;
 	}
+	/**
+	* The colormap names this build of `cog-tiler-wasm` can actually render.
+	*
+	* Read from the module's own `colormaps()` once it has loaded, so upgrading
+	* the package widens the picker without a change here; until then the
+	* conservative {@link COG_TILER_COLORMAPS} baseline stands in. A module too
+	* old to expose `colormaps()` also falls back to the baseline.
+	*/
+	get supportedColormaps() {
+		let names;
+		try {
+			names = this._module?.colormaps?.();
+		} catch {
+			names = void 0;
+		}
+		return new Set(names?.length ? names : COG_TILER_COLORMAPS);
+	}
 	/** Renders the given layers (in draw order, first = bottom), adding, updating,
 	* reordering, and removing native MapLibre raster layers to match. */
 	sync(layers) {
@@ -19240,7 +19440,9 @@ var CogTilerEngine = class {
 				throw err;
 			});
 			this._modulePromise.then(() => {
-				if (!this._destroyed) this._apply();
+				if (this._destroyed) return;
+				this._apply();
+				this._deps.onReady?.();
 			}, () => {});
 		}
 		return null;
@@ -19348,7 +19550,11 @@ var CogTilerEngine = class {
 			assets: layer.assets ?? null,
 			render
 		});
-		if (this._map.getLayer(lyrId)) this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+		if (this._map.getLayer(lyrId)) {
+			this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+			const { minZoom, maxZoom } = resolveZoomRange(layer.state);
+			this._map.setLayerZoomRange(lyrId, minZoom, maxZoom);
+		}
 	}
 	_addMapLayer(layer, renderKey) {
 		const srcId = this._srcId(layer.id);
@@ -19653,10 +19859,13 @@ var TiTilerEngine = class {
 				...tilejson.bounds ? { bounds: tilejson.bounds } : {},
 				...typeof tilejson.maxzoom === "number" ? { maxzoom: tilejson.maxzoom } : {}
 			});
+			const { minZoom, maxZoom } = resolveZoomRange(layer.state);
 			this._map.addLayer({
 				id: lyrId,
 				type: "raster",
 				source: srcId,
+				minzoom: minZoom,
+				maxzoom: maxZoom,
 				paint: { "raster-opacity": layer.state.opacity }
 			}, this._beforeMapId(layer));
 		} catch (err) {
@@ -19688,7 +19897,11 @@ var TiTilerEngine = class {
 	}
 	_setOpacity(layer) {
 		const lyrId = this._lyrId(layer.id);
-		if (this._map.getLayer(lyrId)) this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+		if (this._map.getLayer(lyrId)) {
+			this._map.setPaintProperty(lyrId, "raster-opacity", layer.state.opacity);
+			const { minZoom, maxZoom } = resolveZoomRange(layer.state);
+			this._map.setLayerZoomRange(lyrId, minZoom, maxZoom);
+		}
 	}
 	/** Enforces the draw order (first = bottom), honoring each layer's style
 	* beforeId when present. */
@@ -20020,133 +20233,6 @@ async function loadMosaic(url, signal) {
 	return parseMosaic(await resp.json());
 }
 //#endregion
-//#region src/lib/state/RasterLayer.ts
-/** Default visualization state for a freshly added layer. Mode/bands are
-* re-picked automatically once the band count is known (unless the caller
-* supplied them explicitly); single-band rasters default to the image's
-* embedded color table when present ('palette') or grayscale otherwise. */
-var DEFAULT_LAYER_STATE = {
-	mode: "rgb",
-	bands: [
-		1,
-		2,
-		3
-	],
-	rescale: null,
-	colormap: "gray",
-	reversed: false,
-	nodata: "auto",
-	opacity: 1,
-	gamma: 1,
-	stretch: "linear",
-	visible: true
-};
-/**
-* Creates a complete layer state from optional overrides.
-*
-* @param overrides - Partial state merged over the defaults
-* @returns A fully populated RasterLayerState
-*/
-function createLayerState(overrides) {
-	return {
-		...DEFAULT_LAYER_STATE,
-		...overrides
-	};
-}
-/**
-* Derives the public snapshot for a layer.
-*
-* @param layer - Internal layer record
-* @returns A read-only info object safe to hand to consumers
-*/
-function toLayerInfo(layer) {
-	return {
-		id: layer.id,
-		name: layer.name,
-		source: layer.source,
-		memberUrls: layer.members ? layer.members.map((m) => m.url) : null,
-		bandCount: layer.bandCount,
-		bandNames: layer.bandNames ? new Map(layer.bandNames) : null,
-		beforeId: layer.beforeId,
-		attribution: layer.attribution,
-		bounds: layer.bounds ? { ...layer.bounds } : null,
-		loading: layer.loading,
-		error: layer.error,
-		state: { ...layer.state }
-	};
-}
-/** True when `lngLat` falls inside `bounds` (edges included). */
-function containsPoint(bounds, lngLat) {
-	const [lng, lat] = lngLat;
-	return lng >= bounds.west && lng <= bounds.east && lat >= bounds.south && lat <= bounds.north;
-}
-/**
-* The layer's images that could carry a sample at `lngLat`, topmost first.
-*
-* A plain layer has exactly one image. A mosaic VRT layer has one per member,
-* and only the members whose extent covers the point are worth reading — a
-* member whose bounds have not been reported yet stays a candidate rather than
-* being skipped, since bounds only arrive once a member renders.
-*
-* Members are returned in reverse document order because that is the order they
-* are drawn in: `LayerManager` builds one deck.gl layer per member in member
-* order, so later members paint over earlier ones — matching GDAL, where a
-* VRT's later sources overwrite earlier ones. Sources placed at their natural
-* position can still overlap (adjacent scenes commonly do), so where they do,
-* the last one is what the user sees and therefore what a reader should report.
-*
-* @param layer - The layer to read from
-* @param lngLat - The location, [lng, lat] in WGS84
-* @returns Candidate images, topmost first; empty when the layer has not loaded
-*   or the point falls outside every member
-*/
-function imagesAt(layer, lngLat) {
-	if (!layer.members) return layer.geotiff ? [layer.geotiff] : [];
-	return layer.members.filter((m) => !m.bounds || containsPoint(m.bounds, lngLat)).reverse().map((m) => m.geotiff);
-}
-/**
-* The mosaic assets whose extent covers `lngLat`, in manifest order.
-*
-* A mosaic manifest layer (MosaicJSON or STAC) has no opened image of its own —
-* the deck.gl {@link import('@developmentseed/deck.gl-geotiff').MosaicLayer}
-* opens each asset lazily while it is in view — so a reader works from the
-* manifest's bboxes and opens what it needs. This is the mosaic counterpart to
-* {@link imagesAt}, returning URLs because the COGs may not be open yet.
-*
-* Unlike a VRT's members these are *not* reversed. A VRT has a defined paint
-* order (later sources overwrite earlier ones), but a mosaic's assets are drawn
-* in whatever order its spatial index returns them, so no candidate is reliably
-* "topmost". Manifest order is used instead: it matches MosaicJSON's convention
-* that the first asset listed for a location is the preferred one. Where assets
-* genuinely overlap the drawn pixel is ambiguous, and the first covering asset
-* is as defensible a report as any.
-*
-* @param layer - The layer to read from
-* @param lngLat - The location, [lng, lat] in WGS84
-* @returns Covering asset URLs in manifest order; empty when the layer is not a
-*   mosaic manifest, has not parsed yet, or the point falls outside every asset
-*/
-function assetsAt(layer, lngLat) {
-	if (!layer.mosaicAssets) return [];
-	const [lng, lat] = lngLat;
-	return layer.mosaicAssets.filter((a) => lng >= a.bbox[0] && lng <= a.bbox[2] && lat >= a.bbox[1] && lat <= a.bbox[3]).map((a) => a.url);
-}
-/**
-* Derives a display name from a URL or file name: the last path segment
-* without query string.
-*
-* @param source - URL string or file name
-* @returns A short human-readable layer name
-*/
-function deriveLayerName(source) {
-	try {
-		const segment = (source.includes("://") ? new URL(source).pathname : source).split("/").filter(Boolean).pop();
-		return segment ? decodeURIComponent(segment) : source;
-	} catch {
-		return source;
-	}
-}
-//#endregion
 //#region src/lib/state/LayerManager.ts
 /** Default engine when none is configured: the deck.gl GPU pipeline. */
 var DEFAULT_ENGINE = "maplibre-gl-raster";
@@ -20370,6 +20456,8 @@ var LayerManager = class {
 	_attribStyleReady = false;
 	_onAttribStyleLoad = null;
 	_destroyed = false;
+	_onZoom = null;
+	_zoomVisibleSig = "";
 	/**
 	* Creates a LayerManager bound to a map.
 	*
@@ -20386,6 +20474,8 @@ var LayerManager = class {
 			...DEFAULT_DEPS$1,
 			...deps
 		};
+		this._onZoom = () => this._syncZoomVisibility();
+		this._map.on("zoom", this._onZoom);
 	}
 	/** The id of the layer currently selected for editing, or null. */
 	get selectedId() {
@@ -20400,6 +20490,26 @@ var LayerManager = class {
 		return this._titilerEndpoint;
 	}
 	/**
+	* The colormap names the active engine can actually render, or null when it
+	* supports every colormap the panel offers.
+	*
+	* Only `cog-tiler-wasm` is limited: it knows a fixed set compiled into the
+	* wasm, and renders an unknown name with its `gray` ramp rather than the
+	* requested one — which reads as "the colormap was ignored". The panel
+	* narrows its picker to this set so a user cannot pick a ramp that will not
+	* draw as chosen. The deck.gl engine draws the full sprite, and TiTiler
+	* resolves names server-side.
+	*
+	* The set comes from the loaded engine, not a hard-coded list, so a
+	* `cog-tiler-wasm` release that adds ramps widens the picker with no change
+	* here. Before the engine exists (or its module has loaded) the conservative
+	* {@link COG_TILER_COLORMAPS} baseline applies.
+	*/
+	get supportedColormaps() {
+		if (this._engine !== "cog-tiler-wasm") return null;
+		return this._cogEngine?.supportedColormaps ?? new Set(COG_TILER_COLORMAPS);
+	}
+	/**
 	* Points the `titiler` engine at a different TiTiler instance. Empty input
 	* restores the default endpoint. When the `titiler` engine is active, tiles
 	* refetch from the new server immediately. A no-op when unchanged.
@@ -20855,6 +20965,10 @@ var LayerManager = class {
 			this._map.off("load", this._onAttribStyleLoad);
 			this._onAttribStyleLoad = null;
 		}
+		if (this._onZoom) {
+			this._map.off("zoom", this._onZoom);
+			this._onZoom = null;
+		}
 		if (this._overlay) {
 			this._deps.removeOverlay(this._map, this._overlay);
 			this._overlay = null;
@@ -20902,7 +21016,8 @@ var LayerManager = class {
 		if (!this._cogEngine) this._cogEngine = new CogTilerEngine(this._map, {
 			loadModule: this._deps.loadCogTiler,
 			onBounds: (id, bounds, zoomTo) => this._onCogBounds(id, bounds, zoomTo),
-			onError: (id, error) => this._onCogError(id, error)
+			onError: (id, error) => this._onCogError(id, error),
+			onReady: () => this._emit({ type: "rasterchange" })
 		});
 		return this._cogEngine;
 	}
@@ -21161,10 +21276,37 @@ var LayerManager = class {
 			return;
 		}
 		if (!this._overlay) return;
-		const layers = this._layers.filter((l) => (l.geotiff || l.mosaicAssets) && l.state.visible && !this._crsFailed.has(l.id)).flatMap((l) => this._buildCogLayers(l));
+		const renderable = this._layers.filter((l) => (l.geotiff || l.mosaicAssets) && l.state.visible && !this._crsFailed.has(l.id) && this._withinZoomRange(l.state));
+		this._zoomVisibleSig = renderable.map((l) => l.id).join("|");
+		const layers = renderable.flatMap((l) => this._buildCogLayers(l));
 		this._overlay.setProps({ layers });
 	}
 	/**
+	* Whether a layer draws at the map's current zoom, following MapLibre's
+	* per-layer zoom semantics: visible while `minZoom <= zoom < maxZoom`, hidden
+	* outside that. An unset bound falls back to the full [0, 24] range, so a
+	* layer with no constraint always passes.
+	*/
+	_withinZoomRange(state) {
+		const zoom = this._map.getZoom();
+		const min = state.minZoom ?? 0;
+		const max = state.maxZoom ?? 24;
+		return zoom >= min && zoom < max;
+	}
+	/**
+	* Re-renders the deck.gl overlay when the map zoom crosses a layer's min/max
+	* boundary. Runs on every 'zoom' event, so it stays cheap: it rebuilds only
+	* when the set of in-range layers actually changes, leaving pans and in-range
+	* zooms untouched (a needless rebuild would remount the COGLayers and refetch
+	* their tiles). The native engines carry their zoom range on the MapLibre
+	* layer itself, so this is a no-op for them.
+	*/
+	_syncZoomVisibility() {
+		if (this._engine !== "maplibre-gl-raster" || !this._overlay) return;
+		if (this._layers.filter((l) => (l.geotiff || l.mosaicAssets) && l.state.visible && !this._crsFailed.has(l.id) && this._withinZoomRange(l.state)).map((l) => l.id).join("|") === this._zoomVisibleSig) return;
+		this._rebuild();
+	}
+	/**
 	* The deck.gl layers that draw one managed layer: exactly one for a plain
 	* raster, and one per member for a mosaic VRT.
 	*
@@ -22472,15 +22614,22 @@ var SettingsSection = class {
 	/** Collapsed/expanded state of the Rescale section, preserved across the
 	* full re-renders this section performs on every structural change. */
 	_rescaleOpen = true;
+	/** Colormaps the active engine can draw, or null for all. Re-read on every
+	* render, so switching engines renarrows the picker. */
+	_getAllowedColormaps;
 	/**
 	* Creates the section.
 	*
 	* @param getLayer - Returns the currently selected layer (or null)
 	* @param setState - Applies a state patch to the selected layer
+	* @param inspect - Pixel-inspect hooks for the Inspect button
+	* @param getAllowedColormaps - Returns the colormaps the active engine can
+	*   render, or null when every colormap is drawable
 	*/
-	constructor(getLayer, setState, inspect) {
+	constructor(getLayer, setState, inspect, getAllowedColormaps) {
 		this._getLayer = getLayer;
 		this._inspect = inspect ?? null;
+		this._getAllowedColormaps = getAllowedColormaps ?? (() => null);
 		this._setState = (patch) => {
 			this._applying = true;
 			try {
@@ -22578,6 +22727,7 @@ var SettingsSection = class {
 				value: state.colormap,
 				palette: mode === "single" ? layer.palette : null,
 				stats: mode === "single" ? statsForBand(layer.autoStats, state.bands[0] ?? 1) : null,
+				allowed: this._getAllowedColormaps(),
 				onChange: (name) => {
 					this._setState({ colormap: name });
 					this.render();
@@ -23083,7 +23233,7 @@ var PanelUI = class {
 		}, (patch) => {
 			const id = this._manager.selectedId;
 			if (id) this._manager.setState(id, patch);
-		}, options?.inspect);
+		}, options?.inspect, () => this._manager.supportedColormaps);
 		this._root = el("div", { className: "mlr-panel" }, engine.el, addData.el, this._layerList.el, this._settings.el);
 		container.appendChild(this._root);
 		const onListChange = () => this._renderList();
@@ -24049,4 +24199,4 @@ var RasterControl = class {
 //#endregion
 export { DEFAULT_TITILER_ENDPOINT as A, COLORMAP_ROW_COUNT as B, throttle as C, loadVrt as D, isVrtUrl as E, loadColormapSprite as F, statsForBand as G, colormaps_default as H, sampleColormapStops as I, mergeAutoStats as J, MAX_SAMPLE_TILES as K, COLORMAP_DISPLAY_NAMES as L, isMosaicJsonUrl as M, PALETTE_COLORMAP as N, parseVrt as O, isKnownColormap as P, createResilientEpsgResolver as Q, COLORMAP_NAMES as R, generateId as S, isVrtFile as T, DEFAULT_INDEX_RANGE as U, colormapDisplayName as V, autoRangeFor as W, percentileFromHistogram as X, mergeBandStats as Y, readBandNames as Z, parseMosaic as _, NORMALIZED_DIFFERENCE_INDICES as a, debounce as b, readPixelValues as c, MAX_MOSAIC_ASSETS as d, MosaicUnsupportedError as f, mosaicMinZoom as g, mosaicInitialView as h, CUSTOM_NORMALIZED_DIFFERENCE as i, TITILER_TMS as j, loadGeoTIFF as k, DEFAULT_ENGINE as l, loadMosaic as m, Colorbar as n, guessBandForRole as o, assetUrlToHttps as p, computeAutoStats as q, CUSTOM_INDEX_ID as r, indexById as s, RasterControl as t, LayerManager as u, clamp as v, VrtUnsupportedError as w, formatNumericValue as x, classNames as y, COLORMAP_OPTIONS as z };
 
-//# sourceMappingURL=RasterControl-Cv3yZ90Z.js.map
+//# sourceMappingURL=RasterControl-hvApJoZQ.js.map