maplibre-gl-raster 0.7.0 → 0.8.0

package/README.md

@@ -190,9 +190,10 @@ Per-layer visualization state, editable via the panel or `setRasterState`:
 
 ```typescript
 interface RasterLayerState {
-  mode: "rgb" | "single"; // RGB composite or single band + colormap
-  bands: number[]; // 1-indexed band selection
-  rescale: [number, number][] | null; // per-channel min/max; null = auto (2-98%)
+  mode: "rgb" | "single" | "index"; // RGB composite, single band + colormap, or normalized-difference index
+  bands: number[]; // 1-indexed band selection ([A, B] in index mode)
+  index?: string; // normalized-difference preset id (index mode), e.g. "ndvi"
+  rescale: [number, number][] | null; // per-channel min/max; null = auto (2-98%, or [-1, 1] for index)
   colormap: string; // colormap name; "palette" = embedded color table
   reversed: boolean; // sample the named colormap back-to-front
   nodata: number | "off" | "auto"; // nodata handling
@@ -213,6 +214,8 @@ interface RasterLayerState {
 
 When a raster loads, the mode and bands are picked automatically (3+ bands → RGB `[1, 2, 3]`; otherwise single-band), and the rescale range defaults to the 2-98% percentile of sampled statistics. Single-band rasters use the image's embedded color table when it carries one (`colormap: "palette"`) and grayscale otherwise. The first four bands are fetched as GPU textures, so band combinations among them re-render instantly without re-downloading tiles.
 
+**Index mode** computes a normalized-difference index `(A - B) / (A + B)` of two bands entirely on the GPU (no server or download), then colors the `[-1, 1]` result with a colormap. Presets (`NORMALIZED_DIFFERENCE_INDICES`) pre-fill the band roles and a default ramp for NDVI, NDWI, NDMI, NBR, NDBI, and NDSI, and a "Custom" option lets you pick any two bands; the settings panel seeds the operand bands from the file's band names when present. Index mode requires the default `maplibre-gl-raster` engine (the `cog-tiler-wasm` engine has no band-math endpoint and falls back to a colormapped view of the first operand).
+
 ### RasterControlReact
 
 React wrapper component for `RasterControl`.

package/dist/{RasterControl-CNxONQGm.js → RasterControl-BWZxkUQh.js}

@@ -1979,6 +1979,26 @@ var FilterNaN = {
   }
 ` }
 };
+/** Normalized-difference index: replaces the color with `(A - B) / (A + B)`
+* broadcast across RGB, where `A` is the red channel and `B` the green channel
+* populated by a preceding `CompositeBands` (r → band A, g → band B). The
+* result lies in [-1, 1] and is scale-invariant, so it can run on the raw
+* sampled band values regardless of the texture's sample scale — a downstream
+* `PerBandLinearRescale` maps the chosen window (default [-1, 1]) into [0, 1]
+* for the colormap. A zero denominator yields 0 rather than a NaN/Inf. Runs
+* before rescale / gamma / colormap. */
+var NormalizedDifference = {
+	name: "normalizedDifference",
+	inject: { "fs:DECKGL_FILTER_COLOR": `
+  {
+    float ndA = color.r;
+    float ndB = color.g;
+    float ndDenom = ndA + ndB;
+    float nd = abs(ndDenom) < 1e-12 ? 0.0 : (ndA - ndB) / ndDenom;
+    color.rgb = vec3(nd);
+  }
+` }
+};
 /** Per-channel `LinearRescale`. Same idea as the shipped `LinearRescale`,
 * but min/max are vec3 so each band gets its own range. */
 var PerBandLinearRescale = {
@@ -2176,6 +2196,29 @@ function pickMapping(data, requested, mode) {
 	if (b) mapping.b = b;
 	return mapping;
 }
+/** Push the nodata-discard modules for a tile, in the correct order. Filters
+* nodata BEFORE any rescale / gamma / colormap so the comparison happens
+* against the texture's native sample value. NaN nodata uses the custom
+* isnan() shader; everything else uses FilterNoDataVal with the value
+* normalized into the GPU's sample space (uint8 255 → 1.0 for r8unorm). Also
+* applies implicit NaN-as-nodata for float COGs — IEEE-754 NaN is invalid by
+* definition, and GDAL/QGIS treat it as transparent even when the file
+* declares no GDAL_NODATA tag (e.g. Sentinel-2 derivatives that mask
+* outside-swath pixels with NaN). Gated on float textures via sampleScale
+* (r8unorm uint8 textures can't carry NaN), and skipped when the user
+* explicitly set nodata to "off" or when FilterNaN is already in the pipeline
+* (state.nodata was numerically NaN). */
+function pushNodataFilters(state, data, pipeline) {
+	const nodata = effectiveNodata(state, data.nodata);
+	let explicitNodataModule = null;
+	if (nodata !== null) {
+		explicitNodataModule = nodataModule(nodata, data.sampleScale);
+		if (explicitNodataModule) pipeline.push(explicitNodataModule);
+	}
+	const isFloatTexture = data.sampleScale === 1;
+	const filterNaNAlreadyPushed = explicitNodataModule?.module === FilterNaN;
+	if (isFloatTexture && state.nodata !== "off" && !filterNaNAlreadyPushed) pipeline.push({ module: FilterNaN });
+}
 /** Shared renderTile builder. Handles both RGB and single-band paths
 * via a discriminated `mode`. The two paths differ only in: (a) which
 * bands feed CompositeBands, (b) whether a Colormap module is appended
@@ -2195,15 +2238,7 @@ function buildRenderTile(state, autoStats, mode) {
 			module: CompositeBands,
 			props: buildCompositeBandsProps(mapping, data.bands)
 		}];
-		const nodata = effectiveNodata(state, data.nodata);
-		let explicitNodataModule = null;
-		if (nodata !== null) {
-			explicitNodataModule = nodataModule(nodata, data.sampleScale);
-			if (explicitNodataModule) pipeline.push(explicitNodataModule);
-		}
-		const isFloatTexture = data.sampleScale === 1;
-		const filterNaNAlreadyPushed = explicitNodataModule?.module === FilterNaN;
-		if (isFloatTexture && state.nodata !== "off" && !filterNaNAlreadyPushed) pipeline.push({ module: FilterNaN });
+		pushNodataFilters(state, data, pipeline);
 		if (mode.kind === "palette") {
 			const max = 255 / data.sampleScale;
 			pipeline.push({
@@ -2284,6 +2319,61 @@ function buildPaletteCompositeRenderTile(state, paletteTexture) {
 		colormapTexture: paletteTexture
 	});
 }
+/** Default rescale window for a normalized-difference index: the full [-1, 1]
+* range the formula can produce. Used when `state.rescale` is unset. */
+var DEFAULT_INDEX_RANGE = [-1, 1];
+/** Index renderTile: computes a normalized difference `(A - B) / (A + B)` of
+* two bands on the GPU, then colormaps the [-1, 1] result. `CompositeBands`
+* loads band A into the red channel and band B into green; the
+* `NormalizedDifference` module collapses them to a single value broadcast
+* across RGB; `PerBandLinearRescale` maps the chosen window (default
+* {@link DEFAULT_INDEX_RANGE}) into [0, 1] for the colormap. The index is
+* scale-invariant, so — unlike the single/RGB paths — the rescale window is
+* NOT divided by `data.sampleScale`. Re-renders without a re-fetch when the
+* colormap / rescale change (within the cached band set). */
+function buildIndexCompositeRenderTile(state, colormapTexture) {
+	const colormapIndex = COLORMAP_INDEX[(state.colormap ?? "rdylgn").toLowerCase()] ?? COLORMAP_INDEX.rdylgn;
+	return function renderTile(data) {
+		if (data.bands.size === 0) return { renderPipeline: [] };
+		const bandA = pickBand(data, state.bands?.[0] ?? 1);
+		if (!bandA) return { renderPipeline: [] };
+		const pipeline = [{
+			module: CompositeBands,
+			props: buildCompositeBandsProps({
+				r: bandA,
+				g: pickBand(data, state.bands?.[1] ?? 2) ?? bandA
+			}, data.bands)
+		}];
+		pushNodataFilters(state, data, pipeline);
+		pipeline.push({ module: NormalizedDifference });
+		const [lo, hi] = safeRange(state.rescale?.[0] ?? DEFAULT_INDEX_RANGE);
+		pipeline.push({
+			module: PerBandLinearRescale,
+			props: {
+				rescaleMin: [
+					lo,
+					lo,
+					lo
+				],
+				rescaleMax: [
+					hi,
+					hi,
+					hi
+				]
+			}
+		});
+		pushAdjustments(state, pipeline);
+		pipeline.push({
+			module: Colormap,
+			props: {
+				colormapTexture,
+				colormapIndex,
+				reversed: state.reversed ?? false
+			}
+		});
+		return { renderPipeline: pipeline };
+	};
+}
 //#endregion
 //#region node_modules/@developmentseed/geotiff/dist/colormap.js
 /**
@@ -18010,13 +18100,14 @@ var CogTilerEngine = class {
 	* is intentionally excluded (applied as a paint property instead). */
 	_renderOptionsFor(layer) {
 		const s = layer.state;
-		const bidx = s.mode === "single" ? [s.bands[0] ?? 1] : s.bands.slice(0, 3).map((b) => b || 1);
+		const colormapped = s.mode === "single" || s.mode === "index";
+		const bidx = colormapped ? [s.bands[0] ?? 1] : s.bands.slice(0, 3).map((b) => b || 1);
 		const opts = {
 			bidx,
 			stretch: s.stretch,
 			gamma: s.gamma
 		};
-		if (s.mode === "single") {
+		if (colormapped) {
 			opts.reversed = s.reversed;
 			if (s.colormap && s.colormap !== "palette") opts.colormap = s.colormap;
 		}
@@ -18162,7 +18253,7 @@ function fetchBandsFor(layer) {
 		1,
 		2,
 		3
-	]).slice(0, 3) : [bands?.[0] ?? 1];
+	]).slice(0, 3) : layer.state.mode === "index" ? (bands && bands.length > 0 ? bands : [1, 2]).slice(0, 2) : [bands?.[0] ?? 1];
 	const unique = [...new Set(sampled.filter((b) => Number.isInteger(b) && b >= 1))].sort((a, b) => a - b);
 	if (unique.length === 0) unique.push(1);
 	return unique.slice(0, 4);
@@ -18795,6 +18886,7 @@ var LayerManager = class {
 				if (layer.paletteTexture) return buildPaletteCompositeRenderTile(layer.state, layer.paletteTexture);
 			} else if (this._colormapTexture) return buildSingleCompositeRenderTile(layer.state, this._colormapTexture, layer.autoStats);
 		}
+		if (layer.state.mode === "index" && this._colormapTexture) return buildIndexCompositeRenderTile(layer.state, this._colormapTexture);
 		return buildRgbCompositeRenderTile(layer.state, layer.autoStats);
 	}
 };
@@ -19337,6 +19429,135 @@ var LayerList = class {
 	}
 };
 //#endregion
+//#region src/lib/raster/indices.ts
+/** The `id` used for a free-form normalized difference (generic Band A / Band
+* B, no role hints). */
+var CUSTOM_INDEX_ID = "custom";
+/**
+* Built-in normalized-difference index presets, in menu order. Each maps two
+* band roles onto the shared `(A - B) / (A + B)` formula.
+*/
+var NORMALIZED_DIFFERENCE_INDICES = [
+	{
+		id: "ndvi",
+		label: "NDVI",
+		name: "Normalized Difference Vegetation Index — (NIR - Red) / (NIR + Red)",
+		roleA: "NIR",
+		roleB: "Red",
+		colormap: "rdylgn"
+	},
+	{
+		id: "ndwi",
+		label: "NDWI",
+		name: "Normalized Difference Water Index — (Green - NIR) / (Green + NIR)",
+		roleA: "Green",
+		roleB: "NIR",
+		colormap: "blues"
+	},
+	{
+		id: "ndmi",
+		label: "NDMI",
+		name: "Normalized Difference Moisture Index — (NIR - SWIR1) / (NIR + SWIR1)",
+		roleA: "NIR",
+		roleB: "SWIR1",
+		colormap: "brbg"
+	},
+	{
+		id: "nbr",
+		label: "NBR",
+		name: "Normalized Burn Ratio — (NIR - SWIR2) / (NIR + SWIR2)",
+		roleA: "NIR",
+		roleB: "SWIR2",
+		colormap: "rdylgn"
+	},
+	{
+		id: "ndbi",
+		label: "NDBI",
+		name: "Normalized Difference Built-up Index — (SWIR1 - NIR) / (SWIR1 + NIR)",
+		roleA: "SWIR1",
+		roleB: "NIR",
+		colormap: "inferno"
+	},
+	{
+		id: "ndsi",
+		label: "NDSI",
+		name: "Normalized Difference Snow Index — (Green - SWIR1) / (Green + SWIR1)",
+		roleA: "Green",
+		roleB: "SWIR1",
+		colormap: "blues"
+	}
+];
+/** The generic "custom" preset: two unlabeled bands and a neutral diverging
+* ramp. Kept separate from the named presets so callers can list it last. */
+var CUSTOM_NORMALIZED_DIFFERENCE = {
+	id: CUSTOM_INDEX_ID,
+	label: "Custom",
+	name: "Custom normalized difference — (Band A - Band B) / (Band A + Band B)",
+	roleA: "Band A",
+	roleB: "Band B",
+	colormap: "rdylgn"
+};
+/** Look up a preset by id (including the custom preset), or null. */
+function indexById(id) {
+	if (!id) return null;
+	if (id === "custom") return CUSTOM_NORMALIZED_DIFFERENCE;
+	return NORMALIZED_DIFFERENCE_INDICES.find((i) => i.id === id) ?? null;
+}
+/**
+* Guess the 1-based band number that plays a spectral role (e.g. "NIR") for a
+* raster, matching the role against GDAL band names. Common Sentinel-2 /
+* Landsat aliases are recognized. Returns null when no band name matches.
+*
+* @param role - The role label from a preset (e.g. "Red", "NIR", "SWIR1").
+* @param bandNames - 1-indexed band-number → name map, when the COG carries one.
+*/
+function guessBandForRole(role, bandNames) {
+	if (!bandNames || bandNames.size === 0) return null;
+	const aliases = ROLE_ALIASES[role.toLowerCase()] ?? [role.toLowerCase()];
+	for (const [band, rawName] of bandNames) {
+		const name = rawName.toLowerCase();
+		if (aliases.some((alias) => name.includes(alias))) return band;
+	}
+	return null;
+}
+/** Substrings that identify a spectral role inside a GDAL band name. */
+var ROLE_ALIASES = {
+	red: [
+		"red",
+		"b04",
+		"b4"
+	],
+	green: [
+		"green",
+		"b03",
+		"b3"
+	],
+	blue: [
+		"blue",
+		"b02",
+		"b2"
+	],
+	nir: [
+		"nir",
+		"near infrared",
+		"b08",
+		"b8",
+		"b8a"
+	],
+	swir1: [
+		"swir1",
+		"swir 1",
+		"swir_1",
+		"b11"
+	],
+	swir2: [
+		"swir2",
+		"swir 2",
+		"swir_2",
+		"b12"
+	]
+};
+//#endregion
 //#region src/lib/ui/BandHistogram.ts
 var HANDLE_SIZE = 12;
 /**
@@ -19558,9 +19779,11 @@ var RGB_CHANNELS = [
 	}
 ];
 var HELP = {
-	mode: "RGB / composite picks one band per output channel for true- or false-color images. Single band sends one band through a colormap.",
+	mode: "RGB / composite picks one band per output channel for true- or false-color images. Single band sends one band through a colormap. Index computes a normalized-difference index of two bands.",
 	bandsRgb: "Pick which band feeds each output channel. Native order is usually 1=red, 2=green, 3=blue; reorder to make false-color composites.",
 	bandSingle: "Which band's pixel values feed the colormap.",
+	index: "Compute a normalized-difference index (A - B) / (A + B) of two bands, then color the [-1, 1] result. Pick a preset (e.g. NDVI) or Custom.",
+	indexBands: "Assign each operand of the index to a band. Presets name a role (e.g. NIR, Red); the initial guess uses the file's band names when present.",
 	rescale: "Maps a window of source values to the colormap input. Drag the histogram handles, type values, or pick a preset.",
 	colormap: "Color lookup applied to the rescaled value (after the curve, before nodata).",
 	reversed: "Sample the colormap from end to start, equivalent to a reversed variant of the ramp.",
@@ -19758,13 +19981,14 @@ var SettingsSection = class {
 		const bandOptions = Array.from({ length: Math.max(1, layer.bandCount ?? 1) }, (_, i) => i + 1);
 		const paletteActive = mode === "single" && state.colormap === "palette" && layer.palette !== null;
 		this._body.appendChild(this._buildModeField(state, mode, bandOptions));
-		this._body.appendChild(this._buildBandsField(layer, state, mode, bandOptions));
+		if (mode === "index") this._body.appendChild(this._buildIndexField(layer, state, bandOptions));
+		else this._body.appendChild(this._buildBandsField(layer, state, mode, bandOptions));
 		if (!paletteActive) this._body.appendChild(this._buildRescaleField(layer, state, mode));
-		if (mode === "single") {
+		if (mode === "single" || mode === "index") {
 			const picker = new ColormapPicker({
 				value: state.colormap,
-				palette: layer.palette,
-				stats: statsForBand(layer.autoStats, state.bands[0] ?? 1),
+				palette: mode === "single" ? layer.palette : null,
+				stats: mode === "single" ? statsForBand(layer.autoStats, state.bands[0] ?? 1) : null,
 				onChange: (name) => {
 					this._setState({ colormap: name });
 					this.render();
@@ -19791,14 +20015,22 @@ var SettingsSection = class {
 			2,
 			3
 		].map((b) => Math.min(b, maxBand));
-		return field("Mode", select([{
-			value: "rgb",
-			label: "RGB / composite"
-		}, {
-			value: "single",
-			label: "Single band + colormap"
-		}], mode, (next) => {
-			this._setState({
+		return field("Mode", select([
+			{
+				value: "rgb",
+				label: "RGB / composite"
+			},
+			{
+				value: "single",
+				label: "Single band + colormap"
+			},
+			{
+				value: "index",
+				label: "Index (normalized difference)"
+			}
+		], mode, (next) => {
+			if (next === "index") this._setState(this._indexPatchFor(indexById(state.index)));
+			else this._setState({
 				mode: next,
 				bands: next === "single" ? [state.bands[0] ?? 1] : rgbDefault,
 				rescale: null
@@ -19806,6 +20038,26 @@ var SettingsSection = class {
 			this.render();
 		}, "mode"), HELP.mode);
 	}
+	/** Builds the state patch for entering / switching an index preset: assigns
+	* each operand a band (guessed from band names, else 1 and 2), applies the
+	* preset's default colormap, and resets rescale to the [-1, 1] auto range. */
+	_indexPatchFor(preset) {
+		const index = preset ?? NORMALIZED_DIFFERENCE_INDICES[0];
+		const layer = this._getLayer();
+		const bandCount = Math.max(1, layer?.bandCount ?? 1);
+		const names = layer?.bandNames ?? null;
+		const clamp = (b) => Math.min(Math.max(1, b), bandCount);
+		const a = clamp(guessBandForRole(index.roleA, names) ?? 1);
+		const b = clamp(guessBandForRole(index.roleB, names) ?? (a === 2 ? 1 : 2));
+		return {
+			mode: "index",
+			index: index.id,
+			bands: [a, b],
+			colormap: index.colormap,
+			reversed: false,
+			rescale: null
+		};
+	}
 	_buildBandsField(layer, state, mode, bandOptions) {
 		const options = bandOptions.map((n) => ({
 			value: String(n),
@@ -19826,14 +20078,46 @@ var SettingsSection = class {
 		});
 		return field("Bands (R, G, B)", row, HELP.bandsRgb);
 	}
+	/** Index mode UI: a preset selector plus a band picker for each operand of
+	* `(A - B) / (A + B)`, labelled with the preset's roles (e.g. NIR / Red). */
+	_buildIndexField(layer, state, bandOptions) {
+		const preset = indexById(state.index) ?? NORMALIZED_DIFFERENCE_INDICES[0];
+		const wrap = el("div");
+		const presetSelect = select([...NORMALIZED_DIFFERENCE_INDICES.map((i) => ({
+			value: i.id,
+			label: i.label
+		})), {
+			value: CUSTOM_NORMALIZED_DIFFERENCE.id,
+			label: CUSTOM_NORMALIZED_DIFFERENCE.label
+		}], preset.id, (next) => {
+			this._setState(this._indexPatchFor(indexById(next)));
+			this.render();
+		}, "index-preset");
+		wrap.appendChild(field("Index", presetSelect, preset.name));
+		const bandChoices = bandOptions.map((n) => ({
+			value: String(n),
+			label: bandLabel(n, layer.bandNames)
+		}));
+		const operandSelect = (slot, ariaLabel) => select(bandChoices, String(state.bands[slot] ?? (slot === 0 ? 1 : 2)), (next) => {
+			const bands = [state.bands[0] ?? 1, state.bands[1] ?? 2];
+			bands[slot] = Number(next);
+			this._setState({ bands });
+			this.render();
+		}, ariaLabel);
+		const grid = el("div", { className: "mlr-band-grid" }, operandSelect(0, "index-band-a"), operandSelect(1, "index-band-b"));
+		wrap.appendChild(field(`Bands (${preset.roleA}, ${preset.roleB})`, grid, HELP.indexBands));
+		return wrap;
+	}
 	_buildRescaleField(layer, state, mode) {
 		const autoStats = layer.autoStats;
-		const channelCount = mode === "single" ? 1 : 3;
+		const channelCount = mode === "rgb" ? 3 : 1;
 		const bands = state.bands;
-		const perBandStats = Array.from({ length: channelCount }, (_, i) => statsForBand(autoStats, bands[i] ?? bands[0] ?? 1));
+		const isIndex = mode === "index";
+		const perBandStats = Array.from({ length: channelCount }, (_, i) => isIndex ? null : statsForBand(autoStats, bands[i] ?? bands[0] ?? 1));
 		const perBandPercentile = perBandStats.map((s) => s ? autoRangeFor(s) : null);
 		const perBandMinMax = perBandStats.map((s) => s ? [s.min, s.max] : null);
-		const values = Array.from({ length: channelCount }, (_, i) => state.rescale?.[i] ?? perBandPercentile[i] ?? [0, 1]);
+		const defaultRange = isIndex ? [DEFAULT_INDEX_RANGE[0], DEFAULT_INDEX_RANGE[1]] : [0, 1];
+		const values = Array.from({ length: channelCount }, (_, i) => state.rescale?.[i] ?? perBandPercentile[i] ?? defaultRange);
 		const setChannel = (i, next) => {
 			const out = values.map((v) => [...v]);
 			out[i] = next;
@@ -19845,11 +20129,11 @@ var SettingsSection = class {
 		const wrap = el("div", { className: "mlr-rescale" });
 		const rows = [];
 		for (let i = 0; i < channelCount; i++) {
-			const channel = mode === "single" ? null : RGB_CHANNELS[i];
+			const channel = mode === "rgb" ? RGB_CHANNELS[i] : null;
 			const row = new RescaleRow({
 				color: channel?.color ?? "var(--mlr-histogram-neutral)",
 				label: channel?.label,
-				ariaPrefix: mode === "single" ? "rescale" : `rescale-${channel.label.toLowerCase()}`,
+				ariaPrefix: channel ? `rescale-${channel.label.toLowerCase()}` : "rescale",
 				onChange: (next) => setChannel(i, next),
 				onDragStart: () => {
 					this._dragCount++;
@@ -20839,7 +21123,7 @@ var RasterControl = class {
 		if (!map || !manager) return;
 		const seen = /* @__PURE__ */ new Set();
 		for (const layer of manager.getLayers()) {
-			if (!layer.state.colorbar?.visible || !layer.state.visible || layer.state.mode !== "single" || layer.state.colormap === "palette") continue;
+			if (!layer.state.colorbar?.visible || !layer.state.visible || layer.state.mode !== "single" && layer.state.mode !== "index" || layer.state.mode === "single" && layer.state.colormap === "palette") continue;
 			seen.add(layer.id);
 			const options = this._colorbarOptionsFor(layer);
 			const existing = this._colorbars.get(layer.id);
@@ -20864,7 +21148,8 @@ var RasterControl = class {
 	_colorbarOptionsFor(layer) {
 		const band = layer.state.bands[0] ?? 1;
 		const stats = statsForBand(layer.autoStats, band);
-		const range = layer.state.rescale?.[0] ?? (stats ? autoRangeFor(stats) : [0, 1]);
+		const autoRange = layer.state.mode === "index" ? [-1, 1] : stats ? autoRangeFor(stats) : [0, 1];
+		const range = layer.state.rescale?.[0] ?? autoRange;
 		const cb = layer.state.colorbar;
 		return {
 			colormap: layer.state.colormap,
@@ -21137,6 +21422,6 @@ var RasterControl = class {
 	}
 };
 //#endregion
-export { autoRangeFor as C, percentileFromHistogram as D, computeAutoStats as E, readBandNames as O, colormaps_default as S, MAX_SAMPLE_TILES as T, COLORMAP_DISPLAY_NAMES as _, LayerManager as a, COLORMAP_ROW_COUNT as b, loadColormapSprite as c, classNames as d, debounce as f, loadGeoTIFF as g, throttle as h, DEFAULT_ENGINE as i, createResilientEpsgResolver as k, sampleColormapStops as l, generateId as m, Colorbar as n, PALETTE_COLORMAP as o, formatNumericValue as p, readPixelValues as r, isKnownColormap as s, RasterControl as t, clamp as u, COLORMAP_NAMES as v, statsForBand as w, colormapDisplayName as x, COLORMAP_OPTIONS as y };
+export { statsForBand as A, COLORMAP_NAMES as C, colormaps_default as D, colormapDisplayName as E, createResilientEpsgResolver as F, computeAutoStats as M, percentileFromHistogram as N, DEFAULT_INDEX_RANGE as O, readBandNames as P, COLORMAP_DISPLAY_NAMES as S, COLORMAP_ROW_COUNT as T, debounce as _, NORMALIZED_DIFFERENCE_INDICES as a, throttle as b, readPixelValues as c, PALETTE_COLORMAP as d, isKnownColormap as f, classNames as g, clamp as h, CUSTOM_NORMALIZED_DIFFERENCE as i, MAX_SAMPLE_TILES as j, autoRangeFor as k, DEFAULT_ENGINE as l, sampleColormapStops as m, Colorbar as n, guessBandForRole as o, loadColormapSprite as p, CUSTOM_INDEX_ID as r, indexById as s, RasterControl as t, LayerManager as u, formatNumericValue as v, COLORMAP_OPTIONS as w, loadGeoTIFF as x, generateId as y };
 
-//# sourceMappingURL=RasterControl-CNxONQGm.js.map
+//# sourceMappingURL=RasterControl-BWZxkUQh.js.map