maplibre-gl 6.5.0 → 6.7.0

package/dist/maplibre-gl-dev.mjs

@@ -1,10 +1,10 @@
 /**
 * MapLibre GL JS
-* @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v6.5.0/LICENSE.txt
+* @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v6.7.0/LICENSE.txt
 */
-import { $ as tileCoordinatesToMercatorCoordinates, $n as deepEqual, $r as mul, $t as TRANSITION_SUFFIX, A as evaluateSizeForFeature, Ai as perspective, An as getVideo, Ar as remapSaturate, At as toEvaluationFeature, Bi as invert, Br as wrap, Bt as SegmentVector, C as isCustomStyleLayer, Ci as equals, Cn as Event, Cr as nextPowerOfTwo, Ct as HEATMAP_FULL_RENDER_FBO_KEY, D as SymbolBucket, Di as invert$1, Dn as getArrayBuffer, Dr as radiansToDegrees, Dt as RGBAImage, E as isSymbolStyleLayer, Ei as identity, En as GLOBAL_DISPATCHER_ID, Er as pointPlaneSignedDistance, Et as AlphaImage, F as ImagePosition, Fi as translate, Fn as removeProtocol, Fr as subscribe, Ft as Uniform4f, G as isFillExtrusionStyleLayer, Gn as bezier, Gr as length, Gt as PosArray, H as isLineStyleLayer, Hi as isOffscreenCanvasDistorted, Hn as angleToRotateBetweenVectors2D, Hr as pixelsToTileUnits, Ht as CollisionCircleLayoutArray, I as potpack, Ii as create$4, In as config, Ir as threePlaneIntersection, It as UniformColor, J as cameraDirectionFromPitchBearing, Jn as createIdentityMat4f32, Jr as zero, Jt as TriangleIndexArray, Kn as clamp, Kr as scale$1, Kt as QuadTriangleArray, L as isStyleImageWebGLData, Li as fromRotation, Ln as AbortError, Lr as translatePosition, Lt as UniformColorArray, Mi as rotateY$1, Mn as sameOrigin, Mr as rollPitchBearingToQuat, Mt as Uniform1i, N as getAnchorAlignment, Ni as rotateZ, Nn as addProtocol, Nr as scaleZoom, Nt as Uniform2f, O as addDynamicAttributes, Oi as multiply, On as getJSON, Or as rayPlaneIntersection, Ot as isCircleStyleLayer, Pi as scale, Pn as getProtocol, Pr as sphericalToCartesian, Pt as Uniform3f, Q as projectToWorldCoordinates, Qn as createVec4f64, Qr as slerp, Qt as Properties, R as renderStyleImage, Ri as create$2, Rn as isAbortError, Rr as uniqueId, Rt as UniformFloatArray, S as createStyleLayer, Si as create$1, Sn as ErrorEvent, Sr as mod, St as isHillshadeStyleLayer, T as isBackgroundStyleLayer, Ti as fromScaling, Tn as AJAXError, Tr as pick, Tt as renderColorRamp, Ui as offscreenCanvasSupported, Un as arrayBufferToImage, Ur as EXTENT, Ut as LineStripIndexArray, V as collisionCircleLayout, Vi as rotate, Vn as MAX_VALID_LATITUDE, Vr as zoomScale, Vt as CollisionBoxArray, Wi as Point, Wn as arrayBufferToImageBitmap, Wr as create$3, Wt as Pos3dArray, X as getMercatorHorizon, Xn as createMat4f64, Xr as fromValues, Xt as isRasterStyleLayer, Y as cameraMercatorCoordinateFromCenterAndRotation, Yn as createIdentityMat4f64, Yr as fromEuler, Yt as createLayout, Z as maxMercatorHorizonAngle, Zn as createVec3f64, Zr as multiply$1, Zt as DataConstantProperty, _ as UnwrappedTileID, _i as transformMat4$1, _n as emptyStyle, _r as isTouchableEvent, _t as SubdivisionGranularityExpression, a as clipLine, ai as dot, ar as evaluateZoomSnap, at as mercatorXfromLng, b as isInBoundsForZoomLngLat, bi as clone$1, bn as interpolateFactory, br as lerp, ci as negate, cn as validateAndEmit, cr as findLineIntersection, ct as LngLat, di as rotateY, dn as Color, dr as getEdgeTiles, dt as EXTENT_BOUNDS, ei as scale$3, en as Transitionable, er as defaultEasing, et as unprojectFromWorldCoordinates, f as GEOJSON_TILE_LAYER_NAME, fi as rotateZ$1, fn as ProjectionDefinition, ft as Bounds, g as OverscaledTileID, gi as transformMat3, gn as diff, gr as isSafari, gt as SOUTH_POLE_Y, h as CanonicalTileID, hi as sub, hn as derefLayers, hr as isPointableEvent, ht as NORTH_POLE_Y, ii as cross, in as ZoomHistory, ir as ensureError, it as lngFromMercatorX, j as evaluateSizeForZoom, ji as rotateX, jn as makeRequest, jr as rollPitchBearingEqual, jt as Uniform1f, k as getOverlapMode, ki as ortho, kn as getReferrer, kr as readImageUsingVideoFrame, kt as polygonIntersectsPolygon, li as normalize, ln as validateStyle, lr as getAABB, lt as earthRadius, mi as scaleAndAdd, mr as isImageBitmap, ni as add, nr as differenceOfAnglesDegrees, nt as altitudeFromMercatorZ, oi as len, on as SPEC_SOURCE_TYPES, or as extend, ot as mercatorYfromLat, pi as scale$2, pn as ValidationError, pr as getRollPitchBearing, pt as isFillStyleLayer, q as calculateTileMatrix, qn as clone$2, qr as sqrLen, qt as RasterBoundsArray, r as TextAnchorEnum, ri as clone, rn as codePointUsesLocalIdeographFontFamily, rr as distanceOfAnglesRadians, rt as latFromMercatorY, s as TileCache, si as length$1, sn as emitValidationErrors, sr as filterObject, st as mercatorZfromAltitude, t as getAnchorJustification, ti as transformMat4, tn as EvaluationParameters, tr as degreesToRadians, tt as MercatorCoordinate, u as GeoJSONFeature, ui as rotateX$1, un as validateStyleAndEmit, ur as getAngleDelta, v as calculateTileKey, vi as transformQuat, vn as featureFilter, vr as isTouchableOrPointableType, vt as SubdivisionGranularitySetting, w as validateCustomStyleLayer, wi as exactEquals, wn as Evented, wr as parseCacheControl, wt as isHeatmapStyleLayer, x as Actor, xi as copy, xn as latest, xr as mapObject, xt as Texture, y as compareTileId, yi as zero$1, yr as isWorker, yt as isColorReliefStyleLayer, z as parseGlyphPbf, zi as determinant, zn as throwIfAborted, zr as warnOnce, zt as UniformMatrix4f } from "./maplibre-gl-shared-dev.mjs";
+import { $ as maxMercatorHorizonAngle, $n as createVec3f64, $r as multiply$1, $t as DataConstantProperty, A as evaluateSizeForFeature, Ai as multiply, An as getJSON, Ar as rayPlaneIntersection, At as isCircleStyleLayer, Bi as create$2, Bn as isAbortError, Br as uniqueId, Bt as UniformFloatArray, C as isCustomStyleLayer, Ci as copy, Cn as latest, Cr as mapObject, Ct as Texture, D as SymbolBucket, Di as fromScaling, Dn as AJAXError, Dr as pick, Dt as renderColorRamp, E as isSymbolStyleLayer, Ei as exactEquals, En as Evented, Er as parseCacheControl, Et as isHeatmapStyleLayer, F as ImagePosition, Fi as rotateZ, Fn as addProtocol, Fr as scaleZoom, Ft as Uniform2f, Gi as offscreenCanvasSupported, Gn as arrayBufferToImage, Gr as EXTENT, Gt as LineStripIndexArray, H as collisionCircleLayout, Hi as invert, Hr as wrap, Ht as SegmentVector, I as potpack, Ii as scale, In as getProtocol, Ir as sphericalToCartesian, It as Uniform3f, J as calculateTileMatrix, Jn as clamp, Jr as scale$1, Jt as QuadTriangleArray, K as isFillExtrusionStyleLayer, Ki as Point, Kn as arrayBufferToImageBitmap, Kr as create$3, Kt as Pos3dArray, L as isStyleImageWebGLData, Li as translate, Ln as removeProtocol, Lr as subscribe, Lt as Uniform4f, Mi as perspective, Mn as getVideo, Mr as remapSaturate, Mt as toEvaluationFeature, N as getAnchorAlignment, Ni as rotateX, Nn as makeRequest, Nr as rollPitchBearingEqual, Nt as Uniform1f, O as addDynamicAttributes, Oi as identity, On as GLOBAL_DISPATCHER_ID, Or as pointPlaneSignedDistance, Ot as AlphaImage, Pi as rotateY$1, Pn as sameOrigin, Pr as rollPitchBearingToQuat, Pt as Uniform1i, Q as getMercatorHorizon, Qn as createMat4f64, Qr as fromValues, Qt as isRasterStyleLayer, R as renderStyleImage, Ri as create$4, Rn as config, Rr as threePlaneIntersection, Rt as UniformColor, S as createStyleLayer, Si as clone$1, Sn as derefLayers, Sr as lerp, T as isBackgroundStyleLayer, Ti as equals, Tn as Event, Tr as nextPowerOfTwo, Tt as HEATMAP_FULL_RENDER_FBO_KEY, U as isLineStyleLayer, Ui as rotate, Un as MAX_VALID_LATITUDE, Ur as zoomScale, Ut as CollisionBoxArray, V as isCluster, Vi as determinant, Vn as throwIfAborted, Vr as warnOnce, Vt as UniformMatrix4f, Wi as isOffscreenCanvasDistorted, Wn as angleToRotateBetweenVectors2D, Wr as pixelsToTileUnits, Wt as CollisionCircleLayoutArray, X as cameraMercatorCoordinate, Xn as createIdentityMat4f32, Xr as zero, Xt as TriangleIndexArray, Y as cameraDirectionFromPitchBearing, Yn as clone$2, Yr as sqrLen, Yt as RasterBoundsArray, Z as cameraMercatorCoordinateFromCenterAndRotation, Zn as createIdentityMat4f64, Zr as fromEuler, Zt as createLayout, _ as UnwrappedTileID, _i as sub, _n as interpolateFactory, _r as isPointableEvent, _t as NORTH_POLE_Y, a as clipLine, ai as clone, an as codePointUsesLocalIdeographFontFamily, ar as distanceOfAnglesRadians, at as latFromMercatorY, b as isInBoundsForZoomLngLat, bi as transformQuat, bn as ValidationError, br as isTouchableOrPointableType, bt as SubdivisionGranularitySetting, ci as len, cn as SPEC_SOURCE_TYPES, cr as extend, ct as mercatorYfromLat, di as normalize, dn as validateStyle, dr as getAABB, dt as earthRadius, ei as slerp, en as Properties, er as createVec4f64, et as projectToWorldCoordinates, f as GEOJSON_TILE_LAYER_NAME, fi as rotateX$1, fn as validateStyleAndEmit, fr as getAngleDelta, g as OverscaledTileID, gi as scaleAndAdd, gr as isImageBitmap, h as CanonicalTileID, hi as scale$2, hn as featureFilter, hr as getRollPitchBearing, ht as isFillStyleLayer, ii as add, ir as differenceOfAnglesDegrees, it as altitudeFromMercatorZ, j as evaluateSizeForZoom, ji as ortho, jn as getReferrer, jr as readImageUsingVideoFrame, jt as polygonIntersectsPolygon, k as getOverlapMode, ki as invert$1, kn as getArrayBuffer, kr as radiansToDegrees, kt as RGBAImage, li as length$1, ln as emitValidationErrors, lr as filterObject, lt as mercatorZfromAltitude, mi as rotateZ$1, mt as Bounds, ni as scale$3, nn as Transitionable, nr as defaultEasing, nt as unprojectFromWorldCoordinates, oi as cross, on as ZoomHistory, or as ensureError, ot as lngFromMercatorX, pi as rotateY, pn as emptyStyle, pr as getEdgeTiles, pt as EXTENT_BOUNDS, qn as bezier, qr as length, qt as PosArray, r as TextAnchorEnum, ri as transformMat4, rn as EvaluationParameters, rr as degreesToRadians, rt as MercatorCoordinate, s as TileCache, si as dot, sr as evaluateZoomSnap, st as mercatorXfromLng, t as getAnchorJustification, ti as mul, tn as TRANSITION_SUFFIX, tr as deepEqual, tt as tileCoordinatesToMercatorCoordinates, u as GeoJSONFeature, ui as negate, un as validateAndEmit, ur as findLineIntersection, ut as LngLat, v as calculateTileKey, vi as transformMat3, vn as ProjectionDefinition, vr as isSafari, vt as SOUTH_POLE_Y, w as validateCustomStyleLayer, wi as create$1, wn as ErrorEvent, wr as mod, wt as isHillshadeStyleLayer, x as Actor, xi as zero$1, xn as diff, xr as isWorker, xt as isColorReliefStyleLayer, y as compareTileId, yi as transformMat4$1, yn as Color, yr as isTouchableEvent, yt as SubdivisionGranularityExpression, z as parseGlyphPbf, zi as fromRotation, zn as AbortError, zr as translatePosition, zt as UniformColorArray } from "./maplibre-gl-shared-dev.mjs";
 //#region package.json
-var version$2 = "6.5.0";
+var version$2 = "6.7.0";
 //#endregion
 //#region src/util/browser.ts
 let linkEl;
@@ -1165,17 +1165,183 @@ var PatternAtlas = class {
 	}
 };
 //#endregion
-//#region src/style/load_glyph_range.ts
-async function loadGlyphRange(fontstack, range, urlTemplate, requestManager) {
-	const begin = range * 256;
-	const end = begin + 255;
-	const request = await requestManager.transformRequest(urlTemplate.replace("{fontstack}", fontstack).replace("{range}", `${begin}-${end}`), "Glyphs");
-	const response = await getArrayBuffer(request, new AbortController());
-	if (!response?.data) throw new Error(`Could not load glyph range. range: ${range}, ${begin}-${end}`);
-	const glyphs = {};
-	for (const glyph of parseGlyphPbf(response.data)) glyphs[glyph.id] = glyph;
-	return glyphs;
+//#region src/render/font_face_manager.ts
+const MAX_CODE_POINT = 1114111;
+/**
+* What a font file covers when the style does not narrow it down with `unicode-range`.
+*/
+const DEFAULT_UNICODE_RANGE = {
+	start: 0,
+	end: MAX_CODE_POINT
+};
+/**
+* Makes the family names unique across every map on the page, since `document.fonts` is shared.
+*/
+let nextFamilyId = 0;
+/**
+* Parses one `unicode-range` entry, in the CSS grammar the style specification borrows: `U+A5`,
+* `U+0-10FFFF` or `U+4??`.
+* @param value - a single `unicode-range` entry
+* @returns the codepoints it covers, or `null` if it is not a range this can make sense of
+*/
+function parseUnicodeRange(value) {
+	const wildcard = /^u\+([0-9a-f]*)(\?+)$/i.exec(value);
+	if (wildcard) {
+		const [, prefix, questionMarks] = wildcard;
+		if (prefix.length + questionMarks.length > 6) return null;
+		return clampRange(parseInt(`${prefix}${"0".repeat(questionMarks.length)}`, 16), parseInt(`${prefix}${"f".repeat(questionMarks.length)}`, 16));
+	}
+	const explicit = /^u\+([0-9a-f]{1,6})(?:-([0-9a-f]{1,6}))?$/i.exec(value);
+	if (!explicit) return null;
+	const start = parseInt(explicit[1], 16);
+	return clampRange(start, explicit[2] === void 0 ? start : parseInt(explicit[2], 16));
+}
+function clampRange(start, end) {
+	if (start > end || start > MAX_CODE_POINT) return null;
+	return {
+		start,
+		end: Math.min(end, MAX_CODE_POINT)
+	};
+}
+/**
+* Whether the style lets this file cover the given codepoint.
+*/
+function covers(face, codePoint) {
+	return face.ranges.some(({ start, end }) => codePoint >= start && codePoint <= end);
 }
+/**
+* Keeps the font files a style declares in its
+* [`font-faces`](https://maplibre.org/maplibre-style-spec/root/#font-faces) property, and hands the
+* {@link GlyphManager} the CSS family to draw a given codepoint with.
+*
+* The files go to the browser's CSS Font Loading API, so any format it can render text with works.
+* Each is registered under a family name of our own making, so that a style cannot restyle the
+* surrounding page and a codepoint can be pinned to one file rather than to whatever font matching
+* picks.
+*
+* Rasterizing happens a grapheme cluster at a time, so a letter reaches the browser's text engine
+* with its marks. Shaping across cluster boundaries still needs the RTL text plugin.
+*/
+var FontFaceManager = class {
+	constructor(requestManager) {
+		this.requestManager = requestManager;
+		this._faces = {};
+		this._registered = /* @__PURE__ */ new Set();
+	}
+	/**
+	* Replaces the declared font faces. Nothing is downloaded here: each file waits until a
+	* codepoint it covers is actually drawn.
+	*/
+	setFontFaces(fontFaces) {
+		this._unregisterAll();
+		this._faces = {};
+		for (const [fontName, declaration] of Object.entries(fontFaces ?? {})) {
+			const declarations = Array.isArray(declaration) ? declaration : [declaration];
+			this._faces[fontName] = declarations.map((entry) => this._declareFontFace(fontName, entry)).filter((face) => face !== null);
+		}
+	}
+	/**
+	* Whether the style declared any font face at all, so that the common case of a style without
+	* `font-faces` costs nothing.
+	*/
+	hasFontFaces() {
+		return Object.keys(this._faces).length > 0;
+	}
+	/**
+	* Finds the font file to draw a codepoint with: each name of the `text-font` stack in turn, and
+	* within a name each declared file, until one covers it. A file that fails to load is skipped,
+	* the specification asking for unsupported fonts to be ignored.
+	*
+	* @returns the CSS family to draw with, or `null` to leave the codepoint to the `glyphs` URL
+	*/
+	async getFontFamily(fontStack, codePoint) {
+		for (const fontName of fontStack.split(",")) for (const face of this._faces[fontName.trim()] ?? []) {
+			if (!covers(face, codePoint)) continue;
+			face.loaded ??= this._loadFontFace(face);
+			if (await face.loaded) return face.family;
+		}
+		return null;
+	}
+	/**
+	* Turns one declaration into a face to draw with, or `null` if there is nothing usable in it.
+	*
+	* A bare URL is the same as a face that names no `unicode-range`: it covers every codepoint.
+	*/
+	_declareFontFace(fontName, declaration) {
+		const face = typeof declaration === "string" ? { url: declaration } : declaration;
+		if (typeof face?.url !== "string") {
+			warnOnce(`Ignoring the font face declared for "${fontName}": it has no URL.`);
+			return null;
+		}
+		const family = `maplibre-gl-font-face-${nextFamilyId++}`;
+		const unicodeRange = face["unicode-range"];
+		if (!unicodeRange?.length) return {
+			url: face.url,
+			ranges: [DEFAULT_UNICODE_RANGE],
+			family
+		};
+		const ranges = [];
+		for (const entry of unicodeRange) {
+			const range = parseUnicodeRange(entry);
+			if (!range) {
+				warnOnce(`Ignoring the unicode range "${entry}" of the font face at ${face.url}: it is not a valid range.`);
+				continue;
+			}
+			ranges.push(range);
+		}
+		if (!ranges.length) return null;
+		return {
+			url: face.url,
+			ranges,
+			family
+		};
+	}
+	/**
+	* Downloads a declared file and hands it to the browser, reporting whether it can be drawn with.
+	* A failure is not an error: its codepoints fall through to the next file, then to `glyphs`.
+	*/
+	async _loadFontFace(face) {
+		if (typeof FontFace === "undefined" || typeof document === "undefined" || !document.fonts) {
+			warnOnce(`Ignoring the font face at ${face.url}: this environment has no CSS Font Loading API.`);
+			return false;
+		}
+		let fontFace;
+		try {
+			fontFace = new FontFace(face.family, await this._downloadFontFile(face.url));
+			if (!Object.values(this._faces).some((faces) => faces.includes(face))) return false;
+			document.fonts.add(fontFace);
+			this._registered.add(fontFace);
+			await fontFace.load();
+			return true;
+		} catch (e) {
+			if (fontFace) this._unregister(fontFace);
+			warnOnce(`Ignoring the font face at ${face.url}: ${ensureError(e).message}`);
+			return false;
+		}
+	}
+	/**
+	* Downloads a font file, giving the map's `transformRequest` a chance to rewrite the request the
+	* same way it gets one for a glyph range.
+	*/
+	async _downloadFontFile(url) {
+		const request = await this.requestManager.transformRequest(url, "Glyphs");
+		const response = await getArrayBuffer(request, new AbortController());
+		if (!response?.data) throw new Error(`the response was empty for the font file at ${url}`);
+		return response.data;
+	}
+	_unregister(fontFace) {
+		document.fonts?.delete(fontFace);
+		this._registered.delete(fontFace);
+	}
+	_unregisterAll() {
+		for (const fontFace of this._registered) document.fonts?.delete(fontFace);
+		this._registered.clear();
+	}
+	destroy() {
+		this._unregisterAll();
+		this._faces = {};
+	}
+};
 //#endregion
 //#region node_modules/@mapbox/tiny-sdf/index.js
 const INF = 0x56bc75e2d63100000;
@@ -1305,22 +1471,38 @@ const defaultGenericFontFamily = "sans-serif";
 * Client-generated glyphs are rendered at 2× because CJK glyphs are more detailed than others.
 */
 const textureScale = 2;
-var GlyphManager = class GlyphManager {
-	static {
-		this.loadGlyphRange = loadGlyphRange;
-	}
-	static {
-		this.TinySDF = TinySDF;
-	}
-	constructor(requestManager, localIdeographFontFamily, lang) {
+const defaultCreateRasterizer = (options, padding) => {
+	const tinySDF = new TinySDF(options);
+	tinySDF.buffer = padding;
+	return tinySDF;
+};
+/**
+* How wide a grapheme cluster may be drawn, in multiples of the font size.
+*
+* TinySDF sizes its canvas for a single character and cuts off the rest, but a cluster is a whole
+* syllable: Burmese `လား` is nearly twice the font size. Three ems fits the ones that occur.
+*/
+const clusterEmsWide = 3;
+var GlyphManager = class {
+	constructor(requestManager, localIdeographFontFamily, lang, createRasterizer = defaultCreateRasterizer) {
 		this.requestManager = requestManager;
 		this.localIdeographFontFamily = localIdeographFontFamily;
 		this.entries = {};
 		this.lang = lang;
+		this.fontFaceManager = new FontFaceManager(requestManager);
+		this.createRasterizer = createRasterizer;
 	}
 	setURL(url) {
 		this.url = url;
 	}
+	/**
+	* Replaces the font files the style declares in its `font-faces` property, dropping every glyph
+	* drawn with the previous ones.
+	*/
+	setFontFaces(fontFaces) {
+		this.fontFaceManager.setFontFaces(fontFaces);
+		this.entries = {};
+	}
 	async getGlyphs(glyphs) {
 		const glyphsPromises = [];
 		for (const stack in glyphs) for (const id of glyphs[stack]) glyphsPromises.push(this._getAndCacheGlyphsPromise(stack, id));
@@ -1336,6 +1518,14 @@ var GlyphManager = class GlyphManager {
 		}
 		return result;
 	}
+	/**
+	* Gets one glyph, asked for by grapheme cluster so that a letter and its marks are drawn as the
+	* one shape they are written as.
+	*
+	* Only a file the style pinned with `font-faces` can draw a cluster -- a glyphs URL serves
+	* codepoints -- so where none covers it this returns nothing and layout falls back to codepoints.
+	* For a single codepoint a declared file still wins over the glyphs URL and the local fallbacks.
+	*/
 	async _getAndCacheGlyphsPromise(stack, id) {
 		this.entries[stack] ??= {
 			glyphs: {},
@@ -1349,7 +1539,25 @@ var GlyphManager = class GlyphManager {
 			id,
 			glyph
 		};
-		if (!this.url || this._charUsesLocalIdeographFontFamily(id)) {
+		const codePoint = id.codePointAt(0);
+		const fontFaceFamily = this.fontFaceManager.hasFontFaces() ? await this.fontFaceManager.getFontFamily(stack, codePoint) : null;
+		if (fontFaceFamily) {
+			glyph = entry.glyphs[id] = await this._drawGlyph(entry, stack, id, fontFaceFamily);
+			return {
+				stack,
+				id,
+				glyph
+			};
+		}
+		if (isCluster(id)) {
+			glyph = entry.glyphs[id] = null;
+			return {
+				stack,
+				id,
+				glyph
+			};
+		}
+		if (!this.url || this._charUsesLocalIdeographFontFamily(codePoint)) {
 			glyph = entry.glyphs[id] = await this._drawGlyph(entry, stack, id);
 			return {
 				stack,
@@ -1359,27 +1567,34 @@ var GlyphManager = class GlyphManager {
 		}
 		return await this._downloadAndCacheRangePromise(stack, id);
 	}
+	/**
+	* Gets a glyph from the server-side cache, downloading the PBF range it falls in if need be.
+	*
+	* Only reached for a single codepoint. What comes back is keyed by codepoint, as the file is,
+	* and is cached by cluster -- which for one codepoint is the character itself.
+	*/
 	async _downloadAndCacheRangePromise(stack, id) {
+		const codePoint = id.codePointAt(0);
 		const entry = this.entries[stack];
-		const range = Math.floor(id / 256);
+		const range = Math.floor(codePoint / 256);
 		if (entry.ranges[range]) return {
 			stack,
 			id,
 			glyph: null
 		};
-		entry.requests[range] ||= GlyphManager.loadGlyphRange(stack, range, this.url, this.requestManager);
+		entry.requests[range] ||= this._loadGlyphRange(stack, range);
 		try {
 			const response = await entry.requests[range];
-			for (const id in response) entry.glyphs[+id] = response[+id];
+			for (const responseId in response) entry.glyphs[String.fromCodePoint(+responseId)] = response[+responseId];
 			entry.ranges[range] = true;
 			return {
 				stack,
 				id,
-				glyph: response[id] || null
+				glyph: response[codePoint] || null
 			};
 		} catch (e) {
 			const glyph = entry.glyphs[id] = await this._drawGlyph(entry, stack, id);
-			this._warnOnMissingGlyphRange(glyph, range, id, ensureError(e));
+			this._warnOnMissingGlyphRange(glyph, range, codePoint, ensureError(e));
 			return {
 				stack,
 				id,
@@ -1387,6 +1602,19 @@ var GlyphManager = class GlyphManager {
 			};
 		}
 	}
+	/**
+	* Downloads one range of 256 codepoints from the glyphs URL and parses the glyphs out of it.
+	*/
+	async _loadGlyphRange(fontstack, range) {
+		const begin = range * 256;
+		const end = begin + 255;
+		const request = await this.requestManager.transformRequest(this.url.replace("{fontstack}", fontstack).replace("{range}", `${begin}-${end}`), "Glyphs");
+		const response = await getArrayBuffer(request, new AbortController());
+		if (!response?.data) throw new Error(`Could not load glyph range. range: ${range}, ${begin}-${end}`);
+		const glyphs = {};
+		for (const glyph of parseGlyphPbf(response.data)) glyphs[glyph.id] = glyph;
+		return glyphs;
+	}
 	_warnOnMissingGlyphRange(glyph, range, id, err) {
 		const begin = range * 256;
 		const end = begin + 255;
@@ -1400,13 +1628,13 @@ var GlyphManager = class GlyphManager {
 		return !!this.localIdeographFontFamily && codePointUsesLocalIdeographFontFamily(id);
 	}
 	/**
-	* Draws a glyph offscreen using TinySDF, creating a TinySDF instance lazily.
+	* Draws a glyph offscreen using TinySDF, created lazily. The whole cluster goes to TinySDF, which
+	* is what lets the browser's text engine place a letter's marks on it.
+	*
+	* @param fontFaceFamily - the CSS family of the `font-faces` file covering this codepoint, if any
 	*/
-	async _drawGlyph(entry, stack, id) {
-		const usesLocalIdeographFontFamily = stack === defaultStack && this.localIdeographFontFamily !== "" && this._charUsesLocalIdeographFontFamily(id);
-		const tinySDFKey = usesLocalIdeographFontFamily ? "ideographTinySDF" : "tinySDF";
-		entry[tinySDFKey] ||= this._createTinySDF(usesLocalIdeographFontFamily ? this.localIdeographFontFamily : stack);
-		const char = (await entry[tinySDFKey]).draw(String.fromCodePoint(id));
+	async _drawGlyph(entry, stack, id, fontFaceFamily) {
+		const char = (await this._getTinySDF(entry, stack, id, fontFaceFamily)).draw(id);
 		/**
 		* TinySDF's "top" is the distance from the alphabetic baseline to the top of the glyph.
 		* Server-generated fonts specify "top" relative to an origin above the em box (the origin
@@ -1422,9 +1650,9 @@ var GlyphManager = class GlyphManager {
 		*/
 		const topAdjustment = 27.5;
 		const leftAdjustment = .5;
-		const isControl = /^\p{gc=Cf}+$/u.test(String.fromCodePoint(id));
+		const isControl = /^\p{gc=Cf}+$/u.test(id);
 		return {
-			id,
+			id: id.codePointAt(0),
 			bitmap: new AlphaImage({
 				width: char.width || 60,
 				height: char.height || 60
@@ -1439,28 +1667,59 @@ var GlyphManager = class GlyphManager {
 			}
 		};
 	}
-	async _createTinySDF(stack) {
+	/**
+	* Returns the TinySDF that draws this grapheme, created lazily. A stack keeps one per font
+	* selection, so a fallback cannot bleed into the rest of the text, and one more per font file
+	* for the clusters drawn from it, which need a wider canvas.
+	*
+	* A font file carries its own weight and style, so neither is sniffed out of the family name.
+	* Where no file covers the grapheme, `localIdeographFontFamily` beats the last resort fontstack.
+	*/
+	_getTinySDF(entry, stack, id, fontFaceFamily) {
+		if (fontFaceFamily) {
+			const cluster = isCluster(id);
+			const cache = cluster ? "clusterTinySDFs" : "fontFaceTinySDFs";
+			entry[cache] ??= {};
+			entry[cache][fontFaceFamily] ||= this._createTinySDF(fontFaceFamily, false, cluster ? clusterEmsWide : 1);
+			return entry[cache][fontFaceFamily];
+		}
+		const usesLocalIdeographFontFamily = stack === defaultStack && this.localIdeographFontFamily !== "" && this._charUsesLocalIdeographFontFamily(id.codePointAt(0));
+		const cache = usesLocalIdeographFontFamily ? "ideographTinySDF" : "tinySDF";
+		entry[cache] ||= this._createTinySDF(usesLocalIdeographFontFamily ? this.localIdeographFontFamily : stack);
+		return entry[cache];
+	}
+	/**
+	* Builds the TinySDF that draws with a given font selection.
+	*
+	* TinySDF derives its canvas from `fontSize + buffer * 4`, so the buffer is the only way in to a
+	* wider one. It also stands for the padding the atlas expects to be `GLYPH_PBF_BORDER`, so the
+	* two are passed separately.
+	*
+	* @param emsWide - how wide the glyphs may be, in font sizes, before TinySDF cuts them off
+	*/
+	async _createTinySDF(stack, sniffFontStyles = true, emsWide = 1) {
 		const fontFamilies = stack ? stack.split(",") : [];
 		fontFamilies.push(defaultGenericFontFamily);
 		const fontFamily = fontFamilies.map((fontName) => /[-\w]+/.test(fontName) ? fontName : `'${CSS.escape(fontName)}'`).join(",");
 		const fontSize = 48;
-		const fontWeight = this._fontWeight(fontFamilies[0]);
-		const fontStyle = this._fontStyle(fontFamilies[0]);
+		const fontWeight = sniffFontStyles ? this._fontWeight(fontFamilies[0]) : void 0;
+		const fontStyle = sniffFontStyles ? this._fontStyle(fontFamilies[0]) : "normal";
 		if (typeof document !== "undefined" && document.fonts?.load) try {
 			await document.fonts.load(`${fontStyle} ${fontWeight || "normal"} ${fontSize}px ${fontFamily}`);
 		} catch (e) {
 			warnOnce(`Failed to load font "${fontFamily}": ${ensureError(e).message}`);
 		}
-		return new GlyphManager.TinySDF({
+		const padding = 6;
+		return this.createRasterizer({
 			fontSize,
-			buffer: 6,
+			buffer: Math.max(padding, Math.ceil(fontSize * (emsWide - 1) / 4)),
 			radius: 16,
 			cutoff: .25,
 			fontFamily,
 			fontWeight,
 			fontStyle,
 			lang: this.lang
-		});
+		}, padding);
 	}
 	/**
 	* Sniffs the font style out of a font family name.
@@ -1502,11 +1761,13 @@ var GlyphManager = class GlyphManager {
 			const entry = this.entries[stack];
 			entry.tinySDF = null;
 			entry.ideographTinySDF = null;
+			entry.fontFaceTinySDFs = {};
 			entry.glyphs = {};
 			entry.requests = {};
 			entry.ranges = {};
 		}
 		this.entries = {};
+		this.fontFaceManager.destroy();
 	}
 };
 //#endregion
@@ -3013,6 +3274,7 @@ var RasterDEMTileSource = class extends RasterTileSource {
 				});
 				tile.needsHillshadePrepare = true;
 				tile.needsTerrainPrepare = true;
+				tile.needsColorReliefPrepare = true;
 				tile.state = "loaded";
 			}
 		} catch (err) {
@@ -4062,6 +4324,18 @@ const BILINEAR_FORESHORTENING = 512;
 * const bitmap = await createImageBitmap(myCanvas);
 * mySource.updateImage({image: bitmap});
 *
+* // create an empty source (no url), then feed it entirely via updateImage
+* map.addSource('empty id', {
+*    type: 'image',
+*    coordinates: [
+*        [-76.54, 39.18],
+*        [-76.52, 39.18],
+*        [-76.52, 39.17],
+*        [-76.54, 39.17]
+*    ]
+* });
+* (map.getSource('empty id') as ImageSource).updateImage({image: bitmap});
+*
 * map.removeSource('some id');  // remove
 * ```
 */
@@ -4088,6 +4362,11 @@ var ImageSource = class extends Evented {
 		this.options = options;
 	}
 	async load(newCoordinates) {
+		if (this.options.url === void 0) {
+			this._loaded = true;
+			this._finishLoading();
+			return;
+		}
 		this._loaded = false;
 		this.fire(new MapSourceDataEvent("dataloading"));
 		this.url = this.options.url;
@@ -4270,11 +4549,12 @@ var ImageSource = class extends Evented {
 		} else tile.state = "errored";
 	}
 	serialize() {
-		return {
+		const spec = {
 			type: "image",
-			url: this.options.url,
 			coordinates: this.coordinates
 		};
+		if (this.options.url !== void 0) spec.url = this.options.url;
+		return spec;
 	}
 	hasTransition() {
 		return false;
@@ -5322,9 +5602,8 @@ function getElevationForTileCulling(transform) {
 function coveringTiles(transform, options) {
 	const frustum = transform.getCameraFrustum();
 	const plane = transform.getClippingPlane();
-	const cameraCoord = transform.screenPointToMercatorCoordinate(transform.getCameraPoint());
+	const cameraCoord = cameraMercatorCoordinate(transform);
 	const centerCoord = MercatorCoordinate.fromLngLat(transform.center, transform.elevation);
-	cameraCoord.z = centerCoord.z + Math.cos(transform.pitchInRadians) * transform.cameraToCenterDistance / transform.worldSize;
 	const elevationForTileCulling = getElevationForTileCulling(transform);
 	const detailsProvider = transform.getCoveringTilesDetailsProvider();
 	const allowVariableZoom = detailsProvider.allowVariableZoom(transform, options);
@@ -5565,6 +5844,7 @@ function backfillDEM(tile, inViewTiles) {
 function fillBorder(tile, borderTile) {
 	tile.needsHillshadePrepare = true;
 	tile.needsTerrainPrepare = true;
+	tile.needsColorReliefPrepare = true;
 	let dx = borderTile.tileID.canonical.x - tile.tileID.canonical.x;
 	const dy = borderTile.tileID.canonical.y - tile.tileID.canonical.y;
 	const dim = Math.pow(2, tile.tileID.canonical.z);
@@ -6285,6 +6565,30 @@ var PathInterpolator = class {
 	}
 };
 //#endregion
+//#region src/symbol/symbol_elevation.ts
+/**
+* Resolves the elevation of a symbol at a tile coordinate, combining the terrain elevation with the
+* symbol's `symbol-height-offset`. `symbol-height-anchor` selects the datum the offset is measured
+* from: the terrain surface below the symbol (`ground`) or the zero elevation datum (`absolute`),
+* in which case the terrain below the symbol is ignored.
+*
+* Call this where the elevation is needed, so that `getElevation` keeps returning the plain terrain
+* elevation and never has to be substituted with a wrapper.
+*
+* @param getElevation - the terrain elevation function, absent when the map has no terrain
+* @param x - the tile x coordinate to evaluate the elevation at
+* @param y - the tile y coordinate to evaluate the elevation at
+* @param heightOffset - the evaluated `symbol-height-offset` of the symbol, in meters
+* @param heightAnchorGround - whether `symbol-height-anchor` is `ground`
+* @returns the elevation in meters, or undefined when the symbol sits at the zero elevation datum,
+* which lets the projection take its fast path that ignores the z coordinate
+*/
+function getSymbolElevation(getElevation, x, y, heightOffset, heightAnchorGround) {
+	if (!heightAnchorGround) return heightOffset;
+	if (!getElevation) return heightOffset !== 0 ? heightOffset : void 0;
+	return getElevation(x, y) + heightOffset;
+}
+//#endregion
 //#region src/symbol/grid_index.ts
 function overlapAllowed(overlapA, overlapB) {
 	let allowed = true;
@@ -6678,16 +6982,22 @@ function getTileSkewVectors(transform) {
 	};
 }
 /**
+* Resolves the elevation of the symbol described by `projectionContext` at a tile coordinate.
+*/
+function elevationAt(projectionContext, x, y) {
+	return getSymbolElevation(projectionContext.getElevation, x, y, projectionContext.heightOffset ?? 0, projectionContext.heightAnchorGround ?? true);
+}
+/**
 * Projects a point using a specified matrix, including the perspective divide.
-* Uses a fast path if `getElevation` is undefined.
+* Uses a fast path if `elevation` is undefined.
 */
-function projectWithMatrix(x, y, matrix, getElevation) {
+function projectWithMatrix(x, y, matrix, elevation) {
 	let pos;
-	if (getElevation) {
+	if (elevation != null) {
 		pos = [
 			x,
 			y,
-			getElevation(x, y),
+			elevation,
 			1
 		];
 		transformMat4(pos, pos, matrix);
@@ -6901,10 +7211,10 @@ function projectTileCoordinatesToLabelPlane(x, y, projectionContext) {
 	const translatedY = y + projectionContext.translation[1];
 	let projection;
 	if (projectionContext.pitchWithMap) {
-		projection = projectWithMatrix(translatedX, translatedY, projectionContext.pitchedLabelPlaneMatrix, projectionContext.getElevation);
+		projection = projectWithMatrix(translatedX, translatedY, projectionContext.pitchedLabelPlaneMatrix, elevationAt(projectionContext, translatedX, translatedY));
 		projection.isOccluded = false;
 	} else {
-		projection = projectionContext.transform.projectTileCoordinates(translatedX, translatedY, projectionContext.unwrappedTileID, projectionContext.getElevation);
+		projection = projectionContext.transform.projectTileCoordinates(translatedX, translatedY, projectionContext.unwrappedTileID, elevationAt(projectionContext, translatedX, translatedY));
 		projection.point.x = (projection.point.x * .5 + .5) * projectionContext.width;
 		projection.point.y = (-projection.point.y * .5 + .5) * projectionContext.height;
 	}
@@ -6919,7 +7229,9 @@ function projectFromLabelPlaneToClipSpace(x, y, projectionContext, pitchedLabelP
 			1
 		];
 		transformMat4(pos, pos, pitchedLabelPlaneMatrixInverse);
-		return projectionContext.transform.projectTileCoordinates(pos[0] / pos[3], pos[1] / pos[3], projectionContext.unwrappedTileID, projectionContext.getElevation).point;
+		const tileX = pos[0] / pos[3];
+		const tileY = pos[1] / pos[3];
+		return projectionContext.transform.projectTileCoordinates(tileX, tileY, projectionContext.unwrappedTileID, elevationAt(projectionContext, tileX, tileY)).point;
 	} else return {
 		x: x / projectionContext.width * 2 - 1,
 		y: 1 - y / projectionContext.height * 2
@@ -6929,7 +7241,7 @@ function projectFromLabelPlaneToClipSpace(x, y, projectionContext, pitchedLabelP
 * Projects the given point in tile coordinates to the GL clip space (-1..1).
 */
 function projectTileCoordinatesToClipSpace(x, y, projectionContext) {
-	return projectionContext.transform.projectTileCoordinates(x, y, projectionContext.unwrappedTileID, projectionContext.getElevation);
+	return projectionContext.transform.projectTileCoordinates(x, y, projectionContext.unwrappedTileID, elevationAt(projectionContext, x, y));
 }
 /**
 * Calculate the normal vector for a line segment
@@ -7070,8 +7382,8 @@ function projectPathSpecialProjection(projectedPath, projectionContext) {
 	const inverseLabelPlaneMatrix = tmpMat4;
 	fastInvertSkewMat4(inverseLabelPlaneMatrix, projectionContext.pitchedLabelPlaneMatrix);
 	return projectedPath.map((p) => {
-		const backProjected = projectWithMatrix(p.x, p.y, inverseLabelPlaneMatrix, projectionContext.getElevation);
-		const projected = projectionContext.transform.projectTileCoordinates(backProjected.point.x, backProjected.point.y, projectionContext.unwrappedTileID, projectionContext.getElevation);
+		const backProjected = projectWithMatrix(p.x, p.y, inverseLabelPlaneMatrix, elevationAt(projectionContext, p.x, p.y));
+		const projected = projectionContext.transform.projectTileCoordinates(backProjected.point.x, backProjected.point.y, projectionContext.unwrappedTileID, elevationAt(projectionContext, backProjected.point.x, backProjected.point.y));
 		projected.point.x = (projected.point.x * .5 + .5) * projectionContext.width;
 		projected.point.y = (-projected.point.y * .5 + .5) * projectionContext.height;
 		return projected;
@@ -7122,10 +7434,10 @@ var CollisionIndex = class {
 		this.gridBottomBoundary = transform.height + 200;
 		this.perspectiveRatioCutoff = .6;
 	}
-	placeCollisionBox(collisionBox, overlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translation, collisionGroupPredicate, getElevation, shift, simpleProjectionMatrix) {
+	placeCollisionBox(collisionBox, overlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translation, collisionGroupPredicate, getElevation, shift, simpleProjectionMatrix, heightOffset = 0, heightAnchorGround = true) {
 		const x = collisionBox.anchorPointX + translation[0];
 		const y = collisionBox.anchorPointY + translation[1];
-		const projectedPoint = this.projectAndGetPerspectiveRatio(x, y, unwrappedTileID, getElevation, simpleProjectionMatrix);
+		const projectedPoint = this.projectAndGetPerspectiveRatio(x, y, unwrappedTileID, getSymbolElevation(getElevation, x, y, heightOffset, heightAnchorGround), simpleProjectionMatrix);
 		const tileToViewport = textPixelRatio * projectedPoint.perspectiveRatio;
 		let projectedBox;
 		if (!pitchWithMap && !rotateWithMap) {
@@ -7140,7 +7452,7 @@ var CollisionIndex = class {
 					pointY + collisionBox.y2 * tileToViewport
 				]
 			};
-		} else projectedBox = this._projectCollisionBox(collisionBox, tileToViewport, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translation, projectedPoint, getElevation, shift, simpleProjectionMatrix);
+		} else projectedBox = this._projectCollisionBox(collisionBox, tileToViewport, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translation, projectedPoint, getElevation, shift, simpleProjectionMatrix, heightOffset, heightAnchorGround);
 		const [tlX, tlY, brX, brY] = projectedBox.box;
 		const occluded = pitchWithMap ? projectedBox.allPointsOccluded : projectedPoint.isOccluded;
 		let unplaceable = occluded;
@@ -7172,7 +7484,7 @@ var CollisionIndex = class {
 	placeCollisionCircles(overlapMode, symbol, lineVertexArray, glyphOffsetArray, fontSize, unwrappedTileID, pitchedLabelPlaneMatrix, showCollisionCircles, pitchWithMap, collisionGroupPredicate, circlePixelDiameter, textPixelPadding, translation, getElevation) {
 		const placedCollisionCircles = [];
 		const tileUnitAnchorPoint = new Point(symbol.anchorX, symbol.anchorY);
-		const perspectiveRatio = this.getPerspectiveRatio(tileUnitAnchorPoint.x, tileUnitAnchorPoint.y, unwrappedTileID, getElevation);
+		const perspectiveRatio = this.getPerspectiveRatio(tileUnitAnchorPoint.x, tileUnitAnchorPoint.y, unwrappedTileID, getElevation?.(tileUnitAnchorPoint.x, tileUnitAnchorPoint.y));
 		const labelPlaneFontScale = (pitchWithMap ? fontSize * this.transform.getPitchedTextCorrection(symbol.anchorX, symbol.anchorY, unwrappedTileID) / perspectiveRatio : fontSize * perspectiveRatio) / 24;
 		const projectionCache = {
 			projections: {},
@@ -7321,14 +7633,14 @@ var CollisionIndex = class {
 		};
 		for (let k = 0; k < collisionCircles.length; k += 4) grid.insertCircle(key, collisionCircles[k], collisionCircles[k + 1], collisionCircles[k + 2]);
 	}
-	projectAndGetPerspectiveRatio(x, y, unwrappedTileID, getElevation, simpleProjectionMatrix) {
+	projectAndGetPerspectiveRatio(x, y, unwrappedTileID, elevation, simpleProjectionMatrix) {
 		if (simpleProjectionMatrix) {
 			let pos;
-			if (getElevation) {
+			if (elevation != null) {
 				pos = [
 					x,
 					y,
-					getElevation(x, y),
+					elevation,
 					1
 				];
 				transformMat4(pos, pos, simpleProjectionMatrix);
@@ -7350,7 +7662,7 @@ var CollisionIndex = class {
 				signedDistanceFromCamera: w
 			};
 		} else {
-			const projected = this.transform.projectTileCoordinates(x, y, unwrappedTileID, getElevation);
+			const projected = this.transform.projectTileCoordinates(x, y, unwrappedTileID, elevation);
 			return {
 				x: (projected.point.x + 1) / 2 * this.transform.width + 100,
 				y: (-projected.point.y + 1) / 2 * this.transform.height + 100,
@@ -7360,8 +7672,8 @@ var CollisionIndex = class {
 			};
 		}
 	}
-	getPerspectiveRatio(x, y, unwrappedTileID, getElevation) {
-		const projected = this.transform.projectTileCoordinates(x, y, unwrappedTileID, getElevation);
+	getPerspectiveRatio(x, y, unwrappedTileID, elevation) {
+		const projected = this.transform.projectTileCoordinates(x, y, unwrappedTileID, elevation);
 		return .5 + .5 * (this.transform.cameraToCenterDistance / projected.signedDistanceFromCamera);
 	}
 	isOffscreen(x1, y1, x2, y2) {
@@ -7382,7 +7694,7 @@ var CollisionIndex = class {
 	/**
 	* Applies all layout+paint properties of the given box in order to find as good approximation of its screen-space bounding box as possible.
 	*/
-	_projectCollisionBox(collisionBox, tileToViewport, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translation, projectedPoint, getElevation, shift, simpleProjectionMatrix) {
+	_projectCollisionBox(collisionBox, tileToViewport, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translation, projectedPoint, getElevation, shift, simpleProjectionMatrix, heightOffset = 0, heightAnchorGround = true) {
 		let vecEastX = 1;
 		let vecEastY = 0;
 		let vecSouthX = 0;
@@ -7390,7 +7702,7 @@ var CollisionIndex = class {
 		const translatedAnchorX = collisionBox.anchorPointX + translation[0];
 		const translatedAnchorY = collisionBox.anchorPointY + translation[1];
 		if (rotateWithMap && !pitchWithMap) {
-			const projectedEast = this.projectAndGetPerspectiveRatio(translatedAnchorX + 1, translatedAnchorY, unwrappedTileID, getElevation, simpleProjectionMatrix);
+			const projectedEast = this.projectAndGetPerspectiveRatio(translatedAnchorX + 1, translatedAnchorY, unwrappedTileID, getSymbolElevation(getElevation, translatedAnchorX + 1, translatedAnchorY, heightOffset, heightAnchorGround), simpleProjectionMatrix);
 			const toEastX = projectedEast.x - projectedPoint.x;
 			const toEastY = projectedEast.y - projectedPoint.y;
 			const angle = Math.atan(toEastY / toEastX) + (toEastX < 0 ? Math.PI : 0);
@@ -7470,7 +7782,7 @@ var CollisionIndex = class {
 		for (const { offsetX, offsetY } of offsetsArray) points.push(new Point(basePointX + vecEastX * offsetX + vecSouthX * offsetY, basePointY + vecEastY * offsetX + vecSouthY * offsetY));
 		let anyPointVisible = false;
 		if (pitchWithMap) {
-			const projected = points.map((p) => this.projectAndGetPerspectiveRatio(p.x, p.y, unwrappedTileID, getElevation, simpleProjectionMatrix));
+			const projected = points.map((p) => this.projectAndGetPerspectiveRatio(p.x, p.y, unwrappedTileID, getSymbolElevation(getElevation, p.x, p.y, heightOffset, heightAnchorGround), simpleProjectionMatrix));
 			anyPointVisible = projected.some((p) => !p.isOccluded);
 			points = projected.map((p) => new Point(p.x, p.y));
 		} else anyPointVisible = true;
@@ -7568,7 +7880,7 @@ var Placement = class {
 	}
 	_getTerrainElevationFunc(tileID) {
 		const terrain = this.terrain;
-		if (!terrain) return null;
+		if (!terrain) return void 0;
 		return (x, y) => terrain.getElevation(tileID, x, y);
 	}
 	getBucketParts(results, styleLayer, tile, sortAcrossTiles) {
@@ -7616,13 +7928,13 @@ var Placement = class {
 			parameters
 		});
 	}
-	attemptAnchorPlacement(textAnchorOffset, textBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, tileID, unwrappedTileID, collisionGroup, textOverlapMode, symbolInstance, bucket, orientation, translationText, translationIcon, iconBox, getElevation, simpleProjectionMatrix) {
+	attemptAnchorPlacement(textAnchorOffset, textBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, tileID, unwrappedTileID, collisionGroup, textOverlapMode, symbolInstance, bucket, orientation, translationText, translationIcon, iconBox, getElevation, simpleProjectionMatrix, heightOffset, heightAnchorGround) {
 		const anchor = TextAnchorEnum[textAnchorOffset.textAnchor];
 		const textOffset = [textAnchorOffset.textOffset0, textAnchorOffset.textOffset1];
 		const shift = calculateVariableLayoutShift(anchor, width, height, textOffset, textBoxScale);
-		const placedGlyphBoxes = this.collisionIndex.placeCollisionBox(textBox, textOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationText, collisionGroup.predicate, getElevation, shift, simpleProjectionMatrix);
+		const placedGlyphBoxes = this.collisionIndex.placeCollisionBox(textBox, textOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationText, collisionGroup.predicate, getElevation, shift, simpleProjectionMatrix, heightOffset, heightAnchorGround);
 		if (iconBox) {
-			if (!this.collisionIndex.placeCollisionBox(iconBox, textOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationIcon, collisionGroup.predicate, getElevation, shift, simpleProjectionMatrix).placeable) return;
+			if (!this.collisionIndex.placeCollisionBox(iconBox, textOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationIcon, collisionGroup.predicate, getElevation, shift, simpleProjectionMatrix, heightOffset, heightAnchorGround).placeable) return;
 		}
 		if (placedGlyphBoxes.placeable) {
 			let prevAnchor;
@@ -7659,6 +7971,7 @@ var Placement = class {
 		const pitchWithMap = layout.get("text-pitch-alignment") === "map";
 		const hasIconTextFit = layout.get("icon-text-fit") !== "none";
 		const zOrderByViewportY = layout.get("symbol-z-order") === "viewport-y";
+		const heightAnchorGround = layout.get("symbol-height-anchor") === "ground";
 		const alwaysShowText = textAlwaysOverlap && (iconAlwaysOverlap || !bucket.hasIconData() || iconOptional);
 		const alwaysShowIcon = iconAlwaysOverlap && (textAlwaysOverlap || !bucket.hasTextData() || textOptional);
 		if (!bucket.collisionArrays && collisionBoxArray) bucket.deserializeCollisionBoxes(collisionBoxArray);
@@ -7671,6 +7984,7 @@ var Placement = class {
 				this.placements[symbolInstance.crossTileID] = new JointPlacement(false, false, false);
 				return;
 			}
+			const symbolHeightOffset = symbolInstance.heightOffset;
 			let placeText = false;
 			let placeIcon = false;
 			let offscreen = true;
@@ -7723,7 +8037,7 @@ var Placement = class {
 				const textAnchorOffsetEnd = symbolInstance.textAnchorOffsetEndIndex;
 				if (textAnchorOffsetEnd === textAnchorOffsetStart) {
 					const placeBox = (collisionTextBox, orientation) => {
-						const placedFeature = this.collisionIndex.placeCollisionBox(collisionTextBox, textOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationText, collisionGroup.predicate, getElevation, void 0, simpleProjectionMatrix);
+						const placedFeature = this.collisionIndex.placeCollisionBox(collisionTextBox, textOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationText, collisionGroup.predicate, getElevation, void 0, simpleProjectionMatrix, symbolHeightOffset, heightAnchorGround);
 						if (placedFeature?.placeable) {
 							this.markUsedOrientation(bucket, orientation, symbolInstance);
 							this.placedOrientations[symbolInstance.crossTileID] = orientation;
@@ -7758,7 +8072,7 @@ var Placement = class {
 							for (let i = textAnchorOffsetStart; i < textAnchorOffsetEnd; i++) {
 								const textAnchorOffset = bucket.textAnchorOffsets.get(i);
 								if (prevAnchor && textAnchorOffset.textAnchor !== prevAnchor) continue;
-								const result = this.attemptAnchorPlacement(textAnchorOffset, collisionTextBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, tileID, unwrappedTileID, collisionGroup, overlapMode, symbolInstance, bucket, orientation, translationText, translationIcon, variableIconBox, getElevation);
+								const result = this.attemptAnchorPlacement(textAnchorOffset, collisionTextBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, tileID, unwrappedTileID, collisionGroup, overlapMode, symbolInstance, bucket, orientation, translationText, translationIcon, variableIconBox, getElevation, simpleProjectionMatrix, symbolHeightOffset, heightAnchorGround);
 								if (result) {
 									placedBox = result.placedGlyphBoxes;
 									if (placedBox?.placeable) {
@@ -7772,7 +8086,7 @@ var Placement = class {
 							else overlapMode = textOverlapMode;
 						}
 						if (showCollisionBoxes && !placedBox) placedBox = {
-							box: this.collisionIndex.placeCollisionBox(textBox, "always", textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationText, collisionGroup.predicate, getElevation, void 0, simpleProjectionMatrix).box,
+							box: this.collisionIndex.placeCollisionBox(textBox, "always", textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationText, collisionGroup.predicate, getElevation, void 0, simpleProjectionMatrix, symbolHeightOffset, heightAnchorGround).box,
 							offscreen: false,
 							placeable: false,
 							occluded: false
@@ -7823,7 +8137,7 @@ var Placement = class {
 			if (collisionArrays.iconFeatureIndex) iconFeatureIndex = collisionArrays.iconFeatureIndex;
 			if (collisionArrays.iconBox) {
 				const placeIconFeature = (iconBox) => {
-					return this.collisionIndex.placeCollisionBox(iconBox, iconOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationIcon, collisionGroup.predicate, getElevation, hasIconTextFit && shift ? shift : void 0, simpleProjectionMatrix);
+					return this.collisionIndex.placeCollisionBox(iconBox, iconOverlapMode, textPixelRatio, tileID, unwrappedTileID, pitchWithMap, rotateWithMap, translationIcon, collisionGroup.predicate, getElevation, hasIconTextFit && shift ? shift : void 0, simpleProjectionMatrix, symbolHeightOffset, heightAnchorGround);
 				};
 				if (placedVerticalText && placedVerticalText.placeable && collisionArrays.verticalIconBox) {
 					placedIconBoxes = placeIconFeature(collisionArrays.verticalIconBox);
@@ -8778,12 +9092,11 @@ const shaders = {
 	lineGradientSDF: prepare("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform sampler2D u_image_dash;uniform float u_mix;uniform lowp float u_lineatlas_width;in vec2 v_normal;flat in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;in highp vec2 v_uv;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture(u_image,v_uv);float sdfdist_a=texture(u_image_dash,v_tex_a).a;float sdfdist_b=texture(u_image_dash,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0)/min(dasharray_from.w,dasharray_to.w);float dash_alpha=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(alpha*dash_alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;layout(location=2) in float a_uv_x;layout(location=3) in float a_split_index;uniform vec2 u_translation;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;uniform float u_tileratio;uniform float u_crossfade_from;uniform float u_crossfade_to;uniform float u_lineatlas_height;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;out vec2 v_tex_a;out vec2 v_tex_b;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);float a_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*LINE_DISTANCE_SCALE;float texel_height=1.0/u_image_height;float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nfloat u_patternscale_a_x=u_tileratio/dasharray_from.w/u_crossfade_from;float u_patternscale_a_y=-dasharray_from.z/2.0/u_lineatlas_height;float u_patternscale_b_x=u_tileratio/dasharray_to.w/u_crossfade_to;float u_patternscale_b_y=-dasharray_to.z/2.0/u_lineatlas_height;v_tex_a=vec2(a_linesofar*u_patternscale_a_x/floorwidth,normal.y*u_patternscale_a_y+(float(dasharray_from.y)+0.5)/u_lineatlas_height);v_tex_b=vec2(a_linesofar*u_patternscale_b_x/floorwidth,normal.y*u_patternscale_b_y+(float(dasharray_to.y)+0.5)/u_lineatlas_height);v_width2=vec2(outset,inset);}"),
 	layerOpacity: prepare("uniform sampler2D u_image;uniform float u_opacity;in vec2 v_pos;void main() {fragColor=texture(u_image,v_pos)*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(0.0);\n#endif\n}", "layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=vec4(a_pos.x*2.0-1.0,1.0-a_pos.y*2.0,0.0,1.0);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"),
 	raster: prepare("uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;in vec3 v_pos0;in vec3 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture(u_image0,v_pos0.xy/v_pos0.z);vec4 color1=texture(u_image1,v_pos1.xy/v_pos1.z);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);fragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;uniform vec3 u_image_warp;uniform vec4 u_coords_top;uniform vec4 u_coords_bottom;layout(location=0) in vec2 a_pos;out vec3 v_pos0;out vec3 v_pos1;void main() {vec2 fractionalPos=a_pos/8192.0;vec2 topLeft=u_coords_top.xy;vec2 topRight=u_coords_top.zw;vec2 bottomLeft=u_coords_bottom.xy;vec2 bottomRight=u_coords_bottom.zw;vec2 bilinearPos=mix(mix(topLeft,topRight,fractionalPos.x),mix(bottomLeft,bottomRight,fractionalPos.x),fractionalPos.y);float denominator=dot(u_image_warp.xy,fractionalPos)+1.0;vec2 acrossTop=topRight-topLeft+u_image_warp.x*topRight;vec2 downLeft=bottomLeft-topLeft+u_image_warp.y*bottomLeft;vec2 projectivePos=(acrossTop*fractionalPos.x+downLeft*fractionalPos.y+topLeft)/denominator;vec2 position=mix(projectivePos,bilinearPos,u_image_warp.z);gl_Position=projectTile(position,position);vec2 texturePos=((fractionalPos-0.5)/u_buffer_scale)+0.5;\n#ifdef GLOBE\nif (a_pos.y <-32767.5) {texturePos.y=0.0;}if (a_pos.y > 32766.5) {texturePos.y=1.0;}\n#endif\nfloat perspectiveRatio=mix(1.0/denominator,1.0,u_image_warp.z);v_pos0=vec3(texturePos*perspectiveRatio,perspectiveRatio);vec2 parentPos=(texturePos*u_scale_parent)+u_tl_parent;v_pos1=vec3(parentPos*perspectiveRatio,perspectiveRatio);}"),
-	symbolIcon: prepare("uniform sampler2D u_texture;in vec2 v_tex;flat in float v_total_opacity;void main() {fragColor=texture(u_texture,v_tex)*v_total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;out vec2 v_tex;flat out float v_total_opacity;\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_total_opacity=opacity*max(0.0,min(visibility,fade_opacity[0]+fade_change));if (v_total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;}"),
-	symbolSDF: prepare("#define SDF_PX 8.0\nuniform bool u_is_halo;uniform bool u_is_plain;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;in vec2 v_data0;in vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float total_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out_text,color_alpha_out_halo;if (u_is_plain){highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);color_alpha_out_text=total_opacity*alpha*fill_color;}if (u_is_halo) {float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);float inner_edge_halo=inner_edge+gamma_halo*gamma_scale;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(inner_edge_halo-gamma_scaled_halo,inner_edge_halo+gamma_scaled_halo,dist);highp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha_halo= min(smoothstep(halo_edge-gamma_scaled_halo,halo_edge+gamma_scaled_halo,dist),1.0-alpha_halo);color_alpha_out_halo=total_opacity*alpha_halo*halo_color;}if (u_is_plain && u_is_halo) {fragColor=color_alpha_out_text+(1.-color_alpha_out_text.a)*color_alpha_out_halo;} else if (u_is_halo){fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out_text;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;out vec2 v_data0;out vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy/16.0;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,total_opacity);}"),
-	symbolTextAndIcon: prepare("#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform bool u_is_text;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;in vec4 v_data0;in vec3 v_data1;flat in float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat total_opacity=v_data1[2];if (v_is_sdf==ICON) {vec2 tex_icon=v_data0.zw;fragColor=texture(u_texture_icon,tex_icon)*total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out,color_alpha_out_halo;if (u_is_text) {highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);color_alpha_out=fill_color*(alpha*total_opacity);}if (u_is_halo) {highp float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);lowp float buff_halo=(6.0-halo_width/fontScale)/SDF_PX;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(buff_halo-gamma_scaled_halo,buff_halo+gamma_scaled_halo,dist);color_alpha_out_halo=halo_color*(alpha_halo*total_opacity);}if (u_is_text && u_is_halo) {fragColor=color_alpha_out+(1.-color_alpha_out.a)*color_alpha_out_halo;} else if (u_is_halo) {fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec3 a_projected_pos;layout(location=3) in uint a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;out vec4 v_data0;out vec3 v_data1;flat out float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);float is_sdf=float(a_data.z & 1u);float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map && !u_is_along_line) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec3(gamma_scale,size,total_opacity);v_is_sdf=is_sdf;}"),
+	symbolIcon: prepare("uniform sampler2D u_texture;in vec2 v_tex;flat in float v_total_opacity;void main() {fragColor=texture(u_texture,v_tex)*v_total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;layout(location=5) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec2 v_tex;flat out float v_total_opacity;\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_total_opacity=opacity*max(0.0,min(visibility,fade_opacity[0]+fade_change));if (v_total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;}"),
+	symbolSDF: prepare("#define SDF_PX 8.0\nuniform bool u_is_halo;uniform bool u_is_plain;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;in vec2 v_data0;in vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float total_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out_text,color_alpha_out_halo;if (u_is_plain){highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);color_alpha_out_text=total_opacity*alpha*fill_color;}if (u_is_halo) {float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);float inner_edge_halo=inner_edge+gamma_halo*gamma_scale;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(inner_edge_halo-gamma_scaled_halo,inner_edge_halo+gamma_scaled_halo,dist);highp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha_halo= min(smoothstep(halo_edge-gamma_scaled_halo,halo_edge+gamma_scaled_halo,dist),1.0-alpha_halo);color_alpha_out_halo=total_opacity*alpha_halo*halo_color;}if (u_is_plain && u_is_halo) {fragColor=color_alpha_out_text+(1.-color_alpha_out_text.a)*color_alpha_out_halo;} else if (u_is_halo){fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out_text;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;layout(location=5) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec2 v_data0;out vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy/16.0;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,total_opacity);}"),
+	symbolTextAndIcon: prepare("#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform bool u_is_text;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;in vec4 v_data0;in vec3 v_data1;flat in float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat total_opacity=v_data1[2];if (v_is_sdf==ICON) {vec2 tex_icon=v_data0.zw;fragColor=texture(u_texture_icon,tex_icon)*total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out,color_alpha_out_halo;if (u_is_text) {highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);color_alpha_out=fill_color*(alpha*total_opacity);}if (u_is_halo) {highp float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);lowp float buff_halo=(6.0-halo_width/fontScale)/SDF_PX;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(buff_halo-gamma_scaled_halo,buff_halo+gamma_scaled_halo,dist);color_alpha_out_halo=halo_color*(alpha_halo*total_opacity);}if (u_is_text && u_is_halo) {fragColor=color_alpha_out+(1.-color_alpha_out.a)*color_alpha_out_halo;} else if (u_is_halo) {fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec3 a_projected_pos;layout(location=3) in uint a_fade_opacity;layout(location=4) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec4 v_data0;out vec3 v_data1;flat out float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);float is_sdf=float(a_data.z & 1u);float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map && !u_is_along_line) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec3(gamma_scale,size,total_opacity);v_is_sdf=is_sdf;}"),
 	terrain: prepare("uniform sampler2D u_texture;uniform vec4 u_fog_color;uniform vec4 u_horizon_color;uniform float u_fog_ground_blend;uniform float u_fog_ground_blend_opacity;uniform float u_horizon_fog_blend;uniform bool u_is_globe_mode;in vec2 v_texture_pos;in float v_fog_depth;const float gamma=2.2;vec4 gammaToLinear(vec4 color) {return pow(color,vec4(gamma));}vec4 linearToGamma(vec4 color) {return pow(color,vec4(1.0/gamma));}void main() {vec4 surface_color=texture(u_texture,vec2(v_texture_pos.x,1.0-v_texture_pos.y));if (!u_is_globe_mode && u_fog_ground_blend_opacity > 0.0 && v_fog_depth > u_fog_ground_blend) {vec4 surface_color_linear=gammaToLinear(surface_color);float blend_color=smoothstep(0.0,1.0,max((v_fog_depth-u_horizon_fog_blend)/(1.0-u_horizon_fog_blend),0.0));vec4 fog_horizon_color_linear=mix(gammaToLinear(u_fog_color),gammaToLinear(u_horizon_color),blend_color);float factor_fog=max(v_fog_depth-u_fog_ground_blend,0.0)/(1.0-u_fog_ground_blend);fragColor=linearToGamma(mix(surface_color_linear,fog_horizon_color_linear,pow(factor_fog,2.0)*u_fog_ground_blend_opacity));} else {fragColor=surface_color;}}", "layout(location=0) in vec3 a_pos3d;uniform mat4 u_fog_matrix;uniform float u_ele_delta;out vec2 v_texture_pos;out float v_fog_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=projectTileFor3D(a_pos3d.xy,ele-ele_delta);vec4 pos=u_fog_matrix*vec4(a_pos3d.xy,ele,1.0);v_fog_depth=pos.z/pos.w*0.5+0.5;}"),
 	terrainDepth: prepare("in float v_depth;const highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitMsk=vec4(0.,vec3(1./256.0));highp vec4 pack(highp float value) {highp vec4 comp=fract(value*bitSh);comp-=comp.xxyz*bitMsk;return comp;}void main() {fragColor=pack(v_depth);}", "layout(location=0) in vec3 a_pos3d;uniform float u_ele_delta;out float v_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;gl_Position=projectTileFor3D(a_pos3d.xy,ele-ele_delta);v_depth=gl_Position.z/gl_Position.w;}"),
-	terrainCoords: prepare("precision mediump float;uniform sampler2D u_texture;uniform float u_terrain_coords_id;in vec2 v_texture_pos;void main() {vec4 rgba=texture(u_texture,v_texture_pos);fragColor=vec4(rgba.r,rgba.g,rgba.b,u_terrain_coords_id);}", "layout(location=0) in vec3 a_pos3d;uniform float u_ele_delta;out vec2 v_texture_pos;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=projectTileFor3D(a_pos3d.xy,ele-ele_delta);}"),
 	atmosphere: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nin vec3 view_direction;uniform vec3 u_sun_pos;uniform vec3 u_globe_position;uniform float u_globe_radius;uniform float u_atmosphere_blend;/**Shader use from https:*Made some change to adapt to MapLibre Globe geometry*/const float PI=3.141592653589793;const int iSteps=5;const int jSteps=3;/*radius of the planet*/const float EARTH_RADIUS=6371e3;/*radius of the atmosphere*/const float ATMOS_RADIUS=6471e3;vec2 rsi(vec3 r0,vec3 rd,float sr) {float a=dot(rd,rd);float b=2.0*dot(rd,r0);float c=dot(r0,r0)-(sr*sr);float d=(b*b)-4.0*a*c;if (d < 0.0) return vec2(1e5,-1e5);return vec2((-b-sqrt(d))/(2.0*a),(-b+sqrt(d))/(2.0*a));}vec4 atmosphere(vec3 r,vec3 r0,vec3 pSun,float iSun,float rPlanet,float rAtmos,vec3 kRlh,float kMie,float shRlh,float shMie,float g) {pSun=normalize(pSun);r=normalize(r);vec2 p=rsi(r0,r,rAtmos);if (p.x > p.y) {return vec4(0.0,0.0,0.0,1.0);}if (p.x < 0.0) {p.x=0.0;}vec3 pos=r0+r*p.x;vec2 p2=rsi(r0,r,rPlanet);if (p2.x <=p2.y && p2.x > 0.0) {p.y=min(p.y,p2.x);}float iStepSize=(p.y-p.x)/float(iSteps);float iTime=p.x+iStepSize*0.5;vec3 totalRlh=vec3(0,0,0);vec3 totalMie=vec3(0,0,0);float iOdRlh=0.0;float iOdMie=0.0;float mu=dot(r,pSun);float mumu=mu*mu;float gg=g*g;float pRlh=3.0/(16.0*PI)*(1.0+mumu);float pMie=3.0/(8.0*PI)*((1.0-gg)*(mumu+1.0))/(pow(1.0+gg-2.0*mu*g,1.5)*(2.0+gg));for (int i=0; i < iSteps; i++) {vec3 iPos=r0+r*iTime;float iHeight=length(iPos)-rPlanet;float odStepRlh=exp(-iHeight/shRlh)*iStepSize;float odStepMie=exp(-iHeight/shMie)*iStepSize;iOdRlh+=odStepRlh;iOdMie+=odStepMie;float jStepSize=rsi(iPos,pSun,rAtmos).y/float(jSteps);float jTime=jStepSize*0.5;float jOdRlh=0.0;float jOdMie=0.0;for (int j=0; j < jSteps; j++) {vec3 jPos=iPos+pSun*jTime;float jHeight=length(jPos)-rPlanet;jOdRlh+=exp(-jHeight/shRlh)*jStepSize;jOdMie+=exp(-jHeight/shMie)*jStepSize;jTime+=jStepSize;}vec3 attn=exp(-(kMie*(iOdMie+jOdMie)+kRlh*(iOdRlh+jOdRlh)));totalRlh+=odStepRlh*attn;totalMie+=odStepMie*attn;iTime+=iStepSize;}float opacity=exp(-(length(kRlh)*length(totalRlh)+kMie*length(totalMie)));vec3 color=iSun*(pRlh*kRlh*totalRlh+pMie*kMie*totalMie);return vec4(color,opacity);}void main() {vec3 scale_camera_pos=-u_globe_position*EARTH_RADIUS/u_globe_radius;vec4 color=atmosphere(normalize(view_direction),scale_camera_pos,u_sun_pos,22.0,EARTH_RADIUS,ATMOS_RADIUS,vec3(5.5e-6,13.0e-6,22.4e-6),21e-6,8e3,1.2e3,0.758\n);color.rgb=1.0-exp(-1.0*color.rgb);color=pow(color,vec4(1.0/2.2));fragColor=vec4(color.rgb,1.0-color.a)*u_atmosphere_blend;}", "layout(location=0) in vec2 a_pos;uniform mat4 u_inv_proj_matrix;out vec3 view_direction;void main() {view_direction=(u_inv_proj_matrix*vec4(a_pos,0.0,1.0)).xyz;gl_Position=vec4(a_pos,0.0,1.0);}"),
 	sky: prepare("uniform vec4 u_sky_color;uniform vec4 u_horizon_color;uniform vec2 u_horizon;uniform vec2 u_horizon_normal;uniform float u_sky_horizon_blend;uniform float u_sky_blend;void main() {float x=gl_FragCoord.x;float y=gl_FragCoord.y;float blend=(y-u_horizon.y)*u_horizon_normal.y+(x-u_horizon.x)*u_horizon_normal.x;if (blend > 0.0) {if (blend < u_sky_horizon_blend) {fragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {fragColor=u_sky_color;}}fragColor=mix(fragColor,vec4(vec3(0.0),0.0),u_sky_blend);}", "layout(location=0) in vec2 a_pos;void main() {gl_Position=vec4(a_pos,1.0,1.0);}")
 };
@@ -9127,7 +9440,9 @@ var TransformHelper = class {
 	setMinZoom(zoom) {
 		if (this._minZoom === zoom) return;
 		this._minZoom = zoom;
+		const unmodified = this._unmodified;
 		this.setZoom(this.applyConstrain(this._center, this.zoom).zoom);
+		this._unmodified = unmodified;
 	}
 	get maxZoom() {
 		return this._maxZoom;
@@ -9135,7 +9450,9 @@ var TransformHelper = class {
 	setMaxZoom(zoom) {
 		if (this._maxZoom === zoom) return;
 		this._maxZoom = zoom;
+		const unmodified = this._unmodified;
 		this.setZoom(this.applyConstrain(this._center, this.zoom).zoom);
+		this._unmodified = unmodified;
 	}
 	get minPitch() {
 		return this._minPitch;
@@ -9143,7 +9460,9 @@ var TransformHelper = class {
 	setMinPitch(pitch) {
 		if (this._minPitch === pitch) return;
 		this._minPitch = pitch;
+		const unmodified = this._unmodified;
 		this.setPitch(Math.max(this.pitch, pitch));
+		this._unmodified = unmodified;
 	}
 	get maxPitch() {
 		return this._maxPitch;
@@ -9151,7 +9470,9 @@ var TransformHelper = class {
 	setMaxPitch(pitch) {
 		if (this._maxPitch === pitch) return;
 		this._maxPitch = pitch;
+		const unmodified = this._unmodified;
 		this.setPitch(Math.min(this.pitch, pitch));
+		this._unmodified = unmodified;
 	}
 	get renderWorldCopies() {
 		return this._renderWorldCopies;
@@ -9523,9 +9844,7 @@ var TransformHelper = class {
 		return Math.cos(this.pitchInRadians) * this._cameraToCenterDistance / this._pixelPerMeter + this.elevation;
 	}
 	getCameraLngLat() {
-		const pixelPerMeter = mercatorZfromAltitude(1, this.center.lat) * this.worldSize;
-		const cameraToCenterDistanceMeters = this.cameraToCenterDistance / pixelPerMeter;
-		return cameraMercatorCoordinateFromCenterAndRotation(this.center, this.elevation, this.pitch, this.bearing, cameraToCenterDistanceMeters).toLngLat();
+		return cameraMercatorCoordinate(this).toLngLat();
 	}
 	getMercatorTileCoordinates(overscaledTileID) {
 		if (!overscaledTileID) return [
@@ -9883,118 +10202,857 @@ function getIdealNearFarPlaneDistance(horizonPlane, nearPlaneNormalized) {
 	} else return null;
 }
 //#endregion
-//#region src/geo/projection/mercator_transform.ts
-var MercatorTransform = class MercatorTransform {
-	get pixelsToClipSpaceMatrix() {
-		return this._helper.pixelsToClipSpaceMatrix;
-	}
-	get clipSpaceToPixelsMatrix() {
-		return this._helper.clipSpaceToPixelsMatrix;
-	}
-	get pixelsToGLUnits() {
-		return this._helper.pixelsToGLUnits;
+//#region src/data/pos3d_attributes.ts
+const pos3dAttributes = createLayout([{
+	name: "a_pos3d",
+	type: "Int16",
+	components: 3
+}]);
+//#endregion
+//#region src/tile/terrain_tile_manager.ts
+/**
+* @internal
+* This class is a helper for the Terrain-class, it:
+*
+* - loads raster-dem tiles
+* - manages all renderToTexture tiles.
+* - caches previous rendered tiles.
+* - finds all necessary renderToTexture tiles for a OverscaledTileID area
+* - finds the corresponding raster-dem tile for OverscaledTileID
+*/
+var TerrainTileManager = class extends Evented {
+	constructor(tileManager) {
+		super();
+		this._lastTilesetChange = now();
+		this.tileManager = tileManager;
+		this._tiles = {};
+		this._renderableTilesKeys = [];
+		this._sourceTileCache = {};
+		this.minzoom = 0;
+		this.maxzoom = 22;
+		this.deltaZoom = 1;
+		this.tileSize = tileManager._source.tileSize * 2 ** this.deltaZoom;
+		tileManager.usedForTerrain = true;
+		tileManager.tileSize = this.tileSize;
 	}
-	get centerOffset() {
-		return this._helper.centerOffset;
+	destruct() {
+		this.tileManager.usedForTerrain = false;
+		this.tileManager.tileSize = null;
+		this.releaseAllRTT();
 	}
-	get size() {
-		return this._helper.size;
+	getSource() {
+		return this.tileManager._source;
 	}
-	get rotationMatrix() {
-		return this._helper.rotationMatrix;
+	/**
+	* Load Terrain Tiles, create internal render-to-texture tiles, free GPU memory.
+	* @param transform - the operation to do
+	* @param terrain - the terrain
+	* @returns true when the set of renderable tiles changed
+	*/
+	update(transform, terrain) {
+		this.tileManager.update(transform, terrain);
+		this._renderableTilesKeys = [];
+		const keys = {};
+		let changed = false;
+		for (const tileID of coveringTiles(transform, {
+			tileSize: this.tileSize,
+			minzoom: this.minzoom,
+			maxzoom: this.maxzoom,
+			reparseOverscaled: false,
+			terrain,
+			calculateTileZoom: this.tileManager._source.calculateTileZoom
+		})) {
+			keys[tileID.key] = true;
+			this._renderableTilesKeys.push(tileID.key);
+			if (!this._tiles[tileID.key]) {
+				tileID.terrainRttPosMatrix32f = /* @__PURE__ */ new Float32Array(16);
+				ortho(tileID.terrainRttPosMatrix32f, 0, EXTENT, EXTENT, 0, 0, 1);
+				this._tiles[tileID.key] = new Tile(tileID, this.tileSize);
+				this._lastTilesetChange = now();
+				changed = true;
+			}
+		}
+		for (const key in this._tiles) if (!keys[key]) {
+			this._tiles[key].releaseRTT(this.tileManager.map.painter);
+			delete this._tiles[key];
+			changed = true;
+		}
+		return changed;
 	}
-	get centerPoint() {
-		return this._helper.centerPoint;
+	/**
+	* Release the RTT objects for `tileID` (and its ancestors/descendants),
+	*/
+	releaseRTT(tileID) {
+		for (const key in this._tiles) {
+			const tile = this._tiles[key];
+			if (tile.tileID.equals(tileID) || tile.tileID.isChildOf(tileID) || tileID.isChildOf(tile.tileID)) tile.releaseRTT(this.tileManager.map.painter);
+		}
 	}
-	get pixelsPerMeter() {
-		return this._helper.pixelsPerMeter;
+	/**
+	* Release the A RTT objects for all tiles.
+	*/
+	releaseAllRTT() {
+		for (const key in this._tiles) this._tiles[key].releaseRTT(this.tileManager.map.painter);
 	}
-	setMinZoom(zoom) {
-		this._helper.setMinZoom(zoom);
+	/**
+	* get a list of tiles, which are loaded and should be rendered in the current scene
+	* @returns the renderable tiles
+	*/
+	getRenderableTiles() {
+		return this._renderableTilesKeys.map((key) => this.getTileByID(key));
 	}
-	setMaxZoom(zoom) {
-		this._helper.setMaxZoom(zoom);
-	}
-	setMinPitch(pitch) {
-		this._helper.setMinPitch(pitch);
-	}
-	setMaxPitch(pitch) {
-		this._helper.setMaxPitch(pitch);
-	}
-	setRenderWorldCopies(renderWorldCopies) {
-		this._helper.setRenderWorldCopies(renderWorldCopies);
+	/**
+	* get terrain tile by the TileID key
+	* @param id - the tile id
+	* @returns the tile
+	*/
+	getTileByID(id) {
+		return this._tiles[id];
 	}
-	setBearing(bearing) {
-		this._helper.setBearing(bearing);
+	/**
+	* Searches for the corresponding current renderable terrain-tiles
+	* @param tileID - the tile to look for
+	* @returns the tiles that were found
+	*/
+	getTerrainCoords(tileID, terrainTileRanges) {
+		if (terrainTileRanges) return this._getTerrainCoordsForTileRanges(tileID, terrainTileRanges);
+		else return this._getTerrainCoordsForRegularTile(tileID);
 	}
-	setPitch(pitch) {
-		this._helper.setPitch(pitch);
+	/**
+	* Searches for the corresponding current renderable terrain-tiles.
+	* Includes terrain tiles that are either:
+	* - the same as the tileID
+	* - a parent of the tileID
+	* - a child of the tileID
+	* @param tileID - the tile to look for
+	* @returns the tiles that were found
+	*/
+	_getTerrainCoordsForRegularTile(tileID) {
+		const coords = {};
+		for (const key of this._renderableTilesKeys) {
+			const terrainTileID = this._tiles[key].tileID;
+			const coord = tileID.clone();
+			const mat = createMat4f64();
+			if (terrainTileID.canonical.equals(tileID.canonical)) ortho(mat, 0, EXTENT, EXTENT, 0, 0, 1);
+			else if (terrainTileID.canonical.isChildOf(tileID.canonical)) {
+				const dz = terrainTileID.canonical.z - tileID.canonical.z;
+				const dx = terrainTileID.canonical.x - (terrainTileID.canonical.x >> dz << dz);
+				const dy = terrainTileID.canonical.y - (terrainTileID.canonical.y >> dz << dz);
+				const size = EXTENT >> dz;
+				ortho(mat, 0, size, size, 0, 0, 1);
+				translate(mat, mat, [
+					-dx * size,
+					-dy * size,
+					0
+				]);
+			} else if (tileID.canonical.isChildOf(terrainTileID.canonical)) {
+				const dz = tileID.canonical.z - terrainTileID.canonical.z;
+				const dx = tileID.canonical.x - (tileID.canonical.x >> dz << dz);
+				const dy = tileID.canonical.y - (tileID.canonical.y >> dz << dz);
+				const size = EXTENT >> dz;
+				ortho(mat, 0, EXTENT, EXTENT, 0, 0, 1);
+				translate(mat, mat, [
+					dx * size,
+					dy * size,
+					0
+				]);
+				scale(mat, mat, [
+					1 / 2 ** dz,
+					1 / 2 ** dz,
+					0
+				]);
+			} else continue;
+			coord.terrainRttPosMatrix32f = new Float32Array(mat);
+			coords[key] = coord;
+		}
+		return coords;
 	}
-	setRoll(roll) {
-		this._helper.setRoll(roll);
+	/**
+	* Searches for the corresponding current renderable terrain-tiles.
+	* Includes terrain tiles that are within terrain tile ranges.
+	* @param tileID - the tile to look for
+	* @returns the tiles that were found
+	*/
+	_getTerrainCoordsForTileRanges(tileID, terrainTileRanges) {
+		const coords = {};
+		for (const key of this._renderableTilesKeys) {
+			const terrainTileID = this._tiles[key].tileID;
+			if (!this._isWithinTileRanges(terrainTileID, terrainTileRanges)) continue;
+			const coord = tileID.clone();
+			const mat = createMat4f64();
+			if (terrainTileID.canonical.z === tileID.canonical.z) {
+				const dx = tileID.canonical.x - terrainTileID.canonical.x + tileID.wrap * (1 << tileID.canonical.z);
+				const dy = tileID.canonical.y - terrainTileID.canonical.y;
+				ortho(mat, 0, EXTENT, EXTENT, 0, 0, 1);
+				translate(mat, mat, [
+					dx * EXTENT,
+					dy * EXTENT,
+					0
+				]);
+			} else if (terrainTileID.canonical.z > tileID.canonical.z) {
+				const dz = terrainTileID.canonical.z - tileID.canonical.z;
+				const dx = terrainTileID.canonical.x - (terrainTileID.canonical.x >> dz << dz) + tileID.wrap * (1 << terrainTileID.canonical.z);
+				const dy = terrainTileID.canonical.y - (terrainTileID.canonical.y >> dz << dz);
+				const dx2 = tileID.canonical.x - (terrainTileID.canonical.x >> dz);
+				const dy2 = tileID.canonical.y - (terrainTileID.canonical.y >> dz);
+				const size = EXTENT >> dz;
+				ortho(mat, 0, size, size, 0, 0, 1);
+				translate(mat, mat, [
+					-dx * size + dx2 * EXTENT,
+					-dy * size + dy2 * EXTENT,
+					0
+				]);
+			} else {
+				const dz = tileID.canonical.z - terrainTileID.canonical.z;
+				const dx = tileID.canonical.x - (tileID.canonical.x >> dz << dz) + tileID.wrap * (1 << tileID.canonical.z);
+				const dy = tileID.canonical.y - (tileID.canonical.y >> dz << dz);
+				const dx2 = (tileID.canonical.x >> dz) - terrainTileID.canonical.x;
+				const dy2 = (tileID.canonical.y >> dz) - terrainTileID.canonical.y;
+				const size = EXTENT << dz;
+				ortho(mat, 0, size, size, 0, 0, 1);
+				translate(mat, mat, [
+					dx * EXTENT + dx2 * size,
+					dy * EXTENT + dy2 * size,
+					0
+				]);
+			}
+			coord.terrainRttPosMatrix32f = new Float32Array(mat);
+			coords[key] = coord;
+		}
+		return coords;
 	}
-	setFov(fov) {
-		this._helper.setFov(fov);
+	/**
+	* find the covering raster-dem tile
+	* @param tileID - the tile to look for
+	* @param searchForDEM - Optional parameter to search for (parent) source tiles with loaded dem.
+	* @returns the tile
+	*/
+	getSourceTile(tileID, searchForDEM) {
+		const source = this.tileManager._source;
+		let z = tileID.overscaledZ - this.deltaZoom;
+		if (z > source.maxzoom) z = source.maxzoom;
+		if (z < source.minzoom) return void 0;
+		this._sourceTileCache[tileID.key] ||= tileID.scaledTo(z).key;
+		let tile = this.findTileInCaches(this._sourceTileCache[tileID.key]);
+		if (!tile?.dem && searchForDEM) while (z >= source.minzoom && !tile?.dem) tile = this.findTileInCaches(tileID.scaledTo(z--).key);
+		return tile;
 	}
-	setZoom(zoom) {
-		this._helper.setZoom(zoom);
+	findTileInCaches(key) {
+		let tile = this.tileManager.getTileByID(key);
+		if (tile) return tile;
+		tile = this.tileManager._outOfViewCache.getByKey(key);
+		return tile;
 	}
-	setCenter(center) {
-		this._helper.setCenter(center);
+	/**
+	* gets whether any tiles were loaded after a specific time. This is used to update the depth framebuffer.
+	* @param time - the time
+	* @returns true if any tiles came into view at or after the specified time
+	*/
+	anyTilesAfterTime(time = now()) {
+		return this._lastTilesetChange >= time;
 	}
-	setElevation(elevation) {
-		this._helper.setElevation(elevation);
+	/**
+	* Checks whether a tile is within the canonical tile ranges.
+	* @param tileID - Tile to check
+	* @param canonicalTileRanges - Canonical tile ranges
+	* @returns
+	*/
+	_isWithinTileRanges(tileID, canonicalTileRanges) {
+		const range = canonicalTileRanges[tileID.canonical.z];
+		return !!range && (tileID.wrap > range.minWrap || tileID.wrap < range.maxWrap || tileID.canonical.x >= range.minTileXWrapped && tileID.canonical.x <= range.maxTileXWrapped && tileID.canonical.y >= range.minTileY && tileID.canonical.y <= range.maxTileY);
 	}
-	setMinElevationForCurrentTile(elevation) {
-		this._helper.setMinElevationForCurrentTile(elevation);
+};
+//#endregion
+//#region src/render/terrain.ts
+const MAX_BISECTIONS = 40;
+const HIT_EPSILON_M = 1e-6;
+/** Keeps the elevation bracket non-degenerate when the terrain is entirely flat, such as unloaded DEMs. */
+const BRACKET_PADDING_M = 10;
+/** `DEMData.sampleBilinear` throws on the far tile edge, so samples stop just short of it. */
+const MAX_TILE_COORD = EXTENT * (1 - 1e-12);
+/**
+* @internal
+* This is the main class which handles most of the 3D Terrain logic. It has the following topics:
+*
+* 1. loads raster-dem tiles via the internal tileManager this.tileManager
+* 2. creates a depth-framebuffer, which is used to calculate the visibility of coordinates
+* 3. stores all render-to-texture tiles in the this.tileManager._tiles
+* 4. calculates the elevation for a specific tile-coordinate
+* 5. creates a terrain-mesh
+*
+* A note about the GPU resource-usage:
+*
+* Framebuffers:
+*
+* - one for the depth framebuffer with the size of the map-div.
+* - one for rendering a tile to texture with the size of tileSize (= 512x512).
+*
+* Textures:
+*
+* - one texture for an empty raster-dem tile with size 1x1
+* - one texture for an empty depth-buffer, when terrain is disabled with size 1x1
+* - one texture for an each loaded raster-dem with size of the source.tileSize
+* - one texture for the depth-framebuffer with the size of the map-div.
+* - finally for each render-to-texture tile (= this._tiles) a set of textures
+* for each render stack (The stack-concept is documented in painter.ts).
+*
+* Normally there exists 1-3 Textures per tile, depending on the stylesheet.
+* Each Textures has the size 2*tileSize (= 1024x1024). Also there exists a
+* cache of the last 150 newest rendered tiles.
+*
+*/
+var Terrain = class {
+	constructor(painter, tileManager, options, terrainSkirtLength = "auto") {
+		this._meshCache = {};
+		this.painter = painter;
+		this.tileManager = new TerrainTileManager(tileManager);
+		this.options = options;
+		this.exaggeration = typeof options.exaggeration === "number" ? options.exaggeration : 1;
+		this._terrainSkirtLength = terrainSkirtLength;
+		this.qualityFactor = 2;
+		this.meshSize = 128;
+		this._demMatrixCache = /* @__PURE__ */ new Map();
+		this._elevationSamplerCache = /* @__PURE__ */ new Map();
 	}
-	setPadding(padding) {
-		this._helper.setPadding(padding);
+	destroy() {
+		if (this._fbo) {
+			this._fbo.destroy();
+			this._fbo = null;
+		}
+		if (this._fboDepthTexture) {
+			this._fboDepthTexture.destroy();
+			this._fboDepthTexture = null;
+		}
+		if (this._emptyDemTexture) {
+			this._emptyDemTexture.destroy();
+			this._emptyDemTexture = null;
+		}
+		if (this._emptyDepthTexture) {
+			this._emptyDepthTexture.destroy();
+			this._emptyDepthTexture = null;
+		}
+		for (const key in this._meshCache) this._meshCache[key].destroy();
+		this._meshCache = {};
+		this.tileManager.destruct();
 	}
-	interpolatePadding(start, target, t) {
-		this._helper.interpolatePadding(start, target, t);
+	/**
+	* Get the elevation-value from original dem-data for a given tile-coordinate.
+	* Coordinates that fall outside `[0, extent)` are normalized to the
+	* appropriate neighbor tile before lookup.
+	* @param tileID - the tile to get the elevation for
+	* @param x - x coordinate relative to the tile, may be outside `[0, extent)`
+	* @param y - y coordinate relative to the tile, may be outside `[0, extent)`
+	* @param extent - optional, default 8192
+	* @returns the elevation
+	*/
+	getDEMElevation(tileID, x, y, extent = EXTENT) {
+		const normalized = tileID.normalizeCoordinates(x, y, extent);
+		if (!normalized) return 0;
+		const sampler = this.getElevationSampler(normalized.tileID);
+		return sampler ? sampler(normalized.x, normalized.y, extent) : 0;
 	}
-	isPaddingEqual(padding) {
-		return this._helper.isPaddingEqual(padding);
-	}
-	resize(width, height, constrain = true) {
-		this._helper.resize(width, height, constrain);
+	/**
+	* Get the elevation for given {@link LngLat} in respect of exaggeration.
+	* @param lnglat - the location
+	* @param zoom - the zoom, use {@link getElevationForLngLat} if you don't want a specific zoom level, but more accurate results.
+	* @returns the elevation
+	*/
+	getElevationForLngLatZoom(lnglat, zoom) {
+		if (!isInBoundsForZoomLngLat(zoom, lnglat.wrap())) return 0;
+		const { tileID, mercatorX, mercatorY } = this._getOverscaledTileIDFromLngLatZoom(lnglat, zoom);
+		return this.getElevation(tileID, mercatorX % EXTENT, mercatorY % EXTENT, EXTENT);
 	}
-	getMaxBounds() {
-		return this._helper.getMaxBounds();
+	/**
+	* Get the elevation for given {@link LngLat} in respect of exaggeration.
+	* Where the location is covered by a rendered tile with loaded DEM data this samples the
+	* rendered surface, so the result agrees with what is drawn; elsewhere it traverses up the
+	* zoom levels to find the first tile with data to return.
+	* @param lnglat - the location
+	* @returns the elevation
+	*/
+	getElevationForLngLat(lnglat, transform) {
+		const index = this.getCoverageIndex();
+		if (index) {
+			const mercator = MercatorCoordinate.fromLngLat(lnglat);
+			const sample = sampleAt(index, this.exaggeration, mercator.x, mercator.y);
+			if (sample.demLoaded) return sample.elevation;
+		}
+		const terrainCoveringTiles = coveringTiles(transform, {
+			maxzoom: this.tileManager.maxzoom,
+			minzoom: this.tileManager.minzoom,
+			tileSize: 512,
+			terrain: this
+		});
+		let zoom = 0;
+		for (const tile of terrainCoveringTiles) if (tile.canonical.z > zoom) zoom = Math.min(tile.canonical.z, this.tileManager.maxzoom);
+		return this.getElevationForLngLatZoom(lnglat, zoom);
 	}
-	setMaxBounds(bounds) {
-		this._helper.setMaxBounds(bounds);
+	/**
+	* Get the elevation for given coordinate in respect of exaggeration.
+	* @param tileID - the tile id
+	* @param x - x coordinate relative to the tile, may be outside `[0, extent)`
+	* @param y - y coordinate relative to the tile, may be outside `[0, extent)`
+	* @param extent - optional, default 8192
+	* @returns the elevation
+	*/
+	getElevation(tileID, x, y, extent = EXTENT) {
+		return this.getDEMElevation(tileID, x, y, extent) * this.exaggeration;
 	}
-	setConstrainOverride(constrain) {
-		this._helper.setConstrainOverride(constrain);
+	/**
+	* Clear CPU elevation samplers that may retain a previously selected DEM tile.
+	* @internal
+	*/
+	resetElevationCache() {
+		this._elevationSamplerCache.clear();
+		this._coverageIndex = void 0;
+	}
+	/**
+	* Index of the tiles the terrain currently renders, for sampling the terrain surface on the CPU.
+	* Built on first use and kept until {@link resetElevationCache}.
+	* @returns the index, or null when no terrain tile is renderable
+	*/
+	getCoverageIndex() {
+		if (this._coverageIndex === void 0) this._coverageIndex = this._buildCoverageIndex();
+		return this._coverageIndex;
+	}
+	_buildCoverageIndex() {
+		const zooms = [];
+		const samplerPerTile = /* @__PURE__ */ new Map();
+		let minElevation = 0;
+		let maxElevation = 0;
+		for (const tile of this.tileManager.getRenderableTiles()) {
+			if (!tile) continue;
+			const { canonical, wrap } = tile.tileID;
+			if (!zooms.includes(canonical.z)) zooms.push(canonical.z);
+			const sampler = this.getElevationSampler(tile.tileID);
+			samplerPerTile.set(`${wrap}/${canonical.z}/${canonical.x}/${canonical.y}`, sampler);
+			const { minElevation: tileMin, maxElevation: tileMax } = this.getMinMaxElevation(tile.tileID);
+			minElevation = Math.min(minElevation, tileMin ?? 0);
+			maxElevation = Math.max(maxElevation, tileMax ?? 0);
+		}
+		if (samplerPerTile.size === 0) return null;
+		zooms.sort((a, b) => b - a);
+		return {
+			zooms,
+			samplerPerTile,
+			minElevation: minElevation - BRACKET_PADDING_M,
+			maxElevation: maxElevation + BRACKET_PADDING_M
+		};
 	}
-	overrideNearFarZ(nearZ, farZ) {
-		this._helper.overrideNearFarZ(nearZ, farZ);
+	/**
+	* Get a function that samples the raw DEM elevation of a tile, without exaggeration.
+	* @param tileID - the tile id
+	* @returns the sampler, or null when the tile's DEM data is not loaded
+	*/
+	getElevationSampler(tileID) {
+		const key = tileID.key;
+		const cachedSampler = this._elevationSamplerCache.get(key);
+		if (cachedSampler) return cachedSampler;
+		const sourceTile = this.tileManager.getSourceTile(tileID, true);
+		const dem = sourceTile?.dem;
+		if (!sourceTile || !dem) return null;
+		const matrix = this._getDEMTileMatrix(tileID, sourceTile);
+		const demPixelScaleX = matrix[0] * dem.dim;
+		const demPixelScaleY = matrix[5] * dem.dim;
+		const demPixelOffsetX = matrix[12] * dem.dim;
+		const demPixelOffsetY = matrix[13] * dem.dim;
+		const sampler = (x, y, extent) => {
+			const extentScale = extent === 8192 ? 1 : EXTENT / extent;
+			return dem.sampleBilinear(x * extentScale * demPixelScaleX + demPixelOffsetX, y * extentScale * demPixelScaleY + demPixelOffsetY);
+		};
+		this._elevationSamplerCache.set(key, sampler);
+		return sampler;
 	}
-	clearNearFarZOverride() {
-		this._helper.clearNearFarZOverride();
+	_getDEMTileMatrix(tileID, sourceTile) {
+		const matrixKey = `${sourceTile.tileID.key}/${tileID.key}`;
+		const cachedMatrix = this._demMatrixCache.get(matrixKey);
+		if (cachedMatrix) return cachedMatrix;
+		const maxzoom = this.tileManager.getSource().maxzoom;
+		let dz = tileID.canonical.z - sourceTile.tileID.canonical.z;
+		if (tileID.overscaledZ > tileID.canonical.z) {
+			if (tileID.canonical.z >= maxzoom) dz = tileID.canonical.z - maxzoom;
+			else warnOnce("cannot calculate elevation if elevation maxzoom > source.maxzoom");
+		}
+		const dx = tileID.canonical.x - (tileID.canonical.x >> dz << dz);
+		const dy = tileID.canonical.y - (tileID.canonical.y >> dz << dz);
+		const demMatrix = fromScaling(/* @__PURE__ */ new Float64Array(16), [
+			1 / (EXTENT << dz),
+			1 / (EXTENT << dz),
+			0
+		]);
+		translate(demMatrix, demMatrix, [
+			dx * EXTENT,
+			dy * EXTENT,
+			0
+		]);
+		this._demMatrixCache.set(matrixKey, demMatrix);
+		return demMatrix;
 	}
-	getCameraQueryGeometry(queryGeometry) {
-		return this._helper.getCameraQueryGeometry(this.getCameraPoint(), queryGeometry);
+	/**
+	* returns a Terrain Object for a tile. Unless the tile corresponds to data (e.g. tile is loading), return a flat dem object
+	* @param tileID - the tile to get the terrain for
+	* @returns the terrain data to use in the program
+	*/
+	getTerrainData(tileID) {
+		if (!this._emptyDemTexture) {
+			const context = this.painter.context;
+			const image = new RGBAImage({
+				width: 1,
+				height: 1
+			}, /* @__PURE__ */ new Uint8Array(4));
+			this._emptyDepthTexture = new Texture(context, image, context.gl.RGBA, { premultiply: false });
+			this._emptyDemUnpack = [
+				0,
+				0,
+				0,
+				0
+			];
+			this._emptyDemTexture = new Texture(context, new RGBAImage({
+				width: 1,
+				height: 1
+			}), context.gl.RGBA, { premultiply: false });
+			this._emptyDemTexture.bind(context.gl.NEAREST, context.gl.CLAMP_TO_EDGE);
+			this._emptyDemMatrix = identity([]);
+		}
+		const sourceTile = this.tileManager.getSourceTile(tileID, true);
+		if (sourceTile?.dem && (!sourceTile.demTexture || sourceTile.needsTerrainPrepare)) {
+			const context = this.painter.context;
+			sourceTile.demTexture ||= this.painter.getTileTexture(sourceTile.dem.stride);
+			if (sourceTile.demTexture) sourceTile.demTexture.update(sourceTile.dem.getPixels(), { premultiply: false });
+			else sourceTile.demTexture = new Texture(context, sourceTile.dem.getPixels(), context.gl.RGBA, { premultiply: false });
+			sourceTile.demTexture.bind(context.gl.NEAREST, context.gl.CLAMP_TO_EDGE);
+			sourceTile.needsTerrainPrepare = false;
+		}
+		const terrainMatrix = sourceTile ? this._getDEMTileMatrix(tileID, sourceTile) : this._emptyDemMatrix;
+		return {
+			"u_depth": 2,
+			"u_terrain": 3,
+			"u_terrain_dim": sourceTile?.dem?.dim || 1,
+			"u_terrain_matrix": terrainMatrix,
+			"u_terrain_unpack": sourceTile?.dem?.getUnpackVector() || this._emptyDemUnpack,
+			"u_terrain_exaggeration": this.exaggeration,
+			texture: (sourceTile?.demTexture || this._emptyDemTexture).texture,
+			depthTexture: (this._fboDepthTexture || this._emptyDepthTexture).texture,
+			tile: sourceTile
+		};
 	}
-	get tileSize() {
-		return this._helper.tileSize;
+	/**
+	* get a framebuffer as big as the map-div, which will be used to render depth into a texture
+	* @returns the frame buffer
+	*/
+	getFramebuffer() {
+		const painter = this.painter;
+		const width = painter.width / devicePixelRatio;
+		const height = painter.height / devicePixelRatio;
+		if (this._fbo && (this._fbo.width !== width || this._fbo.height !== height)) {
+			this._fbo.destroy();
+			this._fboDepthTexture.destroy();
+			delete this._fbo;
+			delete this._fboDepthTexture;
+		}
+		if (!this._fboDepthTexture) {
+			this._fboDepthTexture = new Texture(painter.context, {
+				width,
+				height,
+				data: null
+			}, painter.context.gl.RGBA, { premultiply: false });
+			this._fboDepthTexture.bind(painter.context.gl.NEAREST, painter.context.gl.CLAMP_TO_EDGE);
+		}
+		if (!this._fbo) {
+			this._fbo = painter.context.createFramebuffer(width, height, true, false);
+			this._fbo.depthAttachment.set(painter.context.createRenderbuffer(painter.context.gl.DEPTH_COMPONENT16, width, height));
+		}
+		this._fbo.colorAttachment.set(this._fboDepthTexture.texture);
+		return this._fbo;
 	}
-	get tileZoom() {
-		return this._helper.tileZoom;
+	/**
+	* Reads the depth value from the depth-framebuffer at a given screen pixel
+	* @param p - Screen coordinate
+	* @returns depth value in clip space (between 0 and 1)
+	*/
+	depthAtPoint(p) {
+		const rgba = /* @__PURE__ */ new Uint8Array(4);
+		const context = this.painter.context, gl = context.gl;
+		context.bindFramebuffer.set(this.getFramebuffer().framebuffer);
+		gl.readPixels(p.x, this.painter.height / devicePixelRatio - p.y - 1, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, rgba);
+		context.bindFramebuffer.set(null);
+		return (rgba[0] / 16777216 + rgba[1] / 65536 + rgba[2] / 256 + rgba[3]) / 256;
 	}
-	get scale() {
-		return this._helper.scale;
+	/**
+	* create a regular mesh which will be used by all terrain-tiles
+	* @returns the created regular mesh
+	*/
+	getTerrainMesh(tileId) {
+		const globeEnabled = this.painter.style.projection?.transitionState > 0;
+		const northPole = globeEnabled && tileId.canonical.y === 0;
+		const southPole = globeEnabled && tileId.canonical.y === (1 << tileId.canonical.z) - 1;
+		const key = `m_${northPole ? "n" : ""}_${southPole ? "s" : ""}`;
+		if (this._meshCache[key]) return this._meshCache[key];
+		const context = this.painter.context;
+		const vertexArray = new Pos3dArray();
+		const indexArray = new TriangleIndexArray();
+		const meshSize = this.meshSize;
+		const delta = EXTENT / meshSize;
+		const meshSize2 = meshSize * meshSize;
+		for (let y = 0; y <= meshSize; y++) for (let x = 0; x <= meshSize; x++) vertexArray.emplaceBack(x * delta, y * delta, 0);
+		for (let y = 0; y < meshSize2; y += meshSize + 1) for (let x = 0; x < meshSize; x++) {
+			indexArray.emplaceBack(x + y, meshSize + x + y + 1, meshSize + x + y + 2);
+			indexArray.emplaceBack(x + y, meshSize + x + y + 2, x + y + 1);
+		}
+		if (this._terrainSkirtLength !== "none") this._buildSkirts(vertexArray, indexArray, meshSize, delta, northPole, southPole);
+		const mesh = new Mesh(context.createVertexBuffer(vertexArray, pos3dAttributes.members), context.createIndexBuffer(indexArray), SegmentVector.simpleSegment(0, 0, vertexArray.length, indexArray.length));
+		this._meshCache[key] = mesh;
+		return mesh;
 	}
-	get worldSize() {
-		return this._helper.worldSize;
+	/**
+	* Calculates the height of the tile skirts for the "auto" strategy.
+	* @see {@link MapOptions.terrainSkirtLength}
+	* @param zoom - current zoomlevel
+	* @returns the elevation delta in meters
+	*/
+	getSkirtLength(zoom) {
+		return 2 * Math.PI * earthRadius / Math.pow(2, Math.max(zoom, 0)) / 5;
 	}
-	get width() {
-		return this._helper.width;
+	getMinTileElevationForLngLatZoom(lnglat, zoom) {
+		if (!isInBoundsForZoomLngLat(zoom, lnglat.wrap())) return 0;
+		const { tileID } = this._getOverscaledTileIDFromLngLatZoom(lnglat, zoom);
+		return this.getMinMaxElevation(tileID).minElevation ?? 0;
 	}
-	get height() {
-		return this._helper.height;
+	/**
+	* Get the minimum and maximum elevation contained in a tile. This includes any
+	* exaggeration included in the terrain.
+	*
+	* @param tileID - ID of the tile to be used as a source for the min/max elevation
+	* @returns the minimum and maximum elevation found in the tile, including the terrain's
+	* exaggeration
+	*/
+	getMinMaxElevation(tileID) {
+		const tile = this.tileManager.getSourceTile(tileID, true);
+		const minMax = {
+			minElevation: null,
+			maxElevation: null
+		};
+		if (tile?.dem) {
+			minMax.minElevation = tile.dem.min * this.exaggeration;
+			minMax.maxElevation = tile.dem.max * this.exaggeration;
+		}
+		return minMax;
+	}
+	_getOverscaledTileIDFromLngLatZoom(lnglat, zoom) {
+		const mercatorCoordinate = MercatorCoordinate.fromLngLat(lnglat.wrap());
+		const worldSize = (1 << zoom) * EXTENT;
+		const mercatorX = mercatorCoordinate.x * worldSize;
+		const mercatorY = mercatorCoordinate.y * worldSize;
+		const tileX = Math.floor(mercatorX / EXTENT), tileY = Math.floor(mercatorY / EXTENT);
+		return {
+			tileID: new OverscaledTileID(zoom, 0, zoom, tileX, tileY),
+			mercatorX,
+			mercatorY
+		};
+	}
+	/** Add an extra frame around the mesh to avoid hairline gaps (stitching) on tile boundaries with different zoomlevels.
+	* @see {@link MapOptions.terrainSkirtLength}
+	*/
+	_buildSkirts(vertexArray, indexArray, meshSize, delta, northPole, southPole) {
+		const offsetTop = vertexArray.length;
+		const offsetTopEdge = 0;
+		const offsetBottom = offsetTop + (meshSize + 1);
+		const offsetBottomEdge = (meshSize + 1) * meshSize;
+		const northY = northPole ? NORTH_POLE_Y : 0;
+		const northZ = northPole ? 0 : 1;
+		const southY = southPole ? SOUTH_POLE_Y : EXTENT;
+		const southZ = southPole ? 0 : 1;
+		for (let x = 0; x <= meshSize; x++) vertexArray.emplaceBack(x * delta, northY, northZ);
+		for (let x = 0; x <= meshSize; x++) vertexArray.emplaceBack(x * delta, southY, southZ);
+		for (let x = 0; x < meshSize; x++) {
+			indexArray.emplaceBack(offsetBottomEdge + x, offsetBottom + x, offsetBottom + x + 1);
+			indexArray.emplaceBack(offsetBottomEdge + x, offsetBottom + x + 1, offsetBottomEdge + x + 1);
+			indexArray.emplaceBack(offsetTopEdge + x, offsetTop + x + 1, offsetTop + x);
+			indexArray.emplaceBack(offsetTopEdge + x, offsetTopEdge + x + 1, offsetTop + x + 1);
+		}
+		const offsetLeft = vertexArray.length;
+		const offsetRight = offsetLeft + (meshSize + 1) * 2;
+		for (const x of [0, 1]) for (let y = 0; y <= meshSize; y++) for (const z of [0, 1]) vertexArray.emplaceBack(x * EXTENT, y * delta, z);
+		for (let y = 0; y < meshSize * 2; y += 2) {
+			indexArray.emplaceBack(offsetLeft + y, offsetLeft + y + 1, offsetLeft + y + 3);
+			indexArray.emplaceBack(offsetLeft + y, offsetLeft + y + 3, offsetLeft + y + 2);
+			indexArray.emplaceBack(offsetRight + y, offsetRight + y + 3, offsetRight + y + 1);
+			indexArray.emplaceBack(offsetRight + y, offsetRight + y + 2, offsetRight + y + 3);
+		}
+	}
+};
+const NOT_COVERED = {
+	covered: false,
+	demLoaded: false,
+	elevation: 0
+};
+/**
+* Elevation of the rendered terrain surface at a mercator position, and whether it is covered at all.
+* A covered tile whose DEM has not loaded yet is flat at zero, which is what the terrain mesh renders.
+*/
+function sampleAt(index, exaggeration, mercatorX, mercatorY) {
+	if (mercatorY < 0 || mercatorY >= 1) return NOT_COVERED;
+	const wrap = Math.floor(mercatorX);
+	const wrappedX = mercatorX - wrap;
+	for (const z of index.zooms) {
+		const scale = 1 << z;
+		const scaledX = wrappedX * scale;
+		const scaledY = mercatorY * scale;
+		const tileX = Math.floor(scaledX);
+		const tileY = Math.floor(scaledY);
+		const key = `${wrap}/${z}/${tileX}/${tileY}`;
+		if (!index.samplerPerTile.has(key)) continue;
+		const sampler = index.samplerPerTile.get(key);
+		if (!sampler) return {
+			covered: true,
+			demLoaded: false,
+			elevation: 0
+		};
+		return {
+			covered: true,
+			demLoaded: true,
+			elevation: sampler(Math.min((scaledX - tileX) * EXTENT, MAX_TILE_COORD), Math.min((scaledY - tileY) * EXTENT, MAX_TILE_COORD), EXTENT) * exaggeration
+		};
+	}
+	return NOT_COVERED;
+}
+/**
+* Whether a height in meters is at or below the sampled terrain surface.
+* The epsilon absorbs rounding when a bracket endpoint lands exactly on the surface.
+*/
+function isBelowTerrainSample(sample, height) {
+	return sample.covered && height <= sample.elevation + HIT_EPSILON_M;
+}
+/**
+* Narrows the bracket `[lo, hi]` around the surface crossing until it is shorter than `tolerance` in ray parameter units.
+*/
+function bisect(ray, isBelowTerrain, lo, hi, tolerance) {
+	for (let j = 0; j < MAX_BISECTIONS && hi - lo > tolerance; j++) {
+		const mid = (lo + hi) / 2;
+		if (isBelowTerrain(ray, mid)) hi = mid;
+		else lo = mid;
+	}
+	return {
+		lo,
+		hi
+	};
+}
+//#endregion
+//#region src/geo/projection/mercator_transform.ts
+const TARGET_WORLD_STEP_PX = 4;
+const MAX_SAMPLES = 512;
+const MERCATOR_BISECT_EPSILON_WORLD_PX = .001;
+var MercatorTransform = class MercatorTransform {
+	get pixelsToClipSpaceMatrix() {
+		return this._helper.pixelsToClipSpaceMatrix;
+	}
+	get clipSpaceToPixelsMatrix() {
+		return this._helper.clipSpaceToPixelsMatrix;
+	}
+	get pixelsToGLUnits() {
+		return this._helper.pixelsToGLUnits;
+	}
+	get centerOffset() {
+		return this._helper.centerOffset;
+	}
+	get size() {
+		return this._helper.size;
+	}
+	get rotationMatrix() {
+		return this._helper.rotationMatrix;
+	}
+	get centerPoint() {
+		return this._helper.centerPoint;
+	}
+	get pixelsPerMeter() {
+		return this._helper.pixelsPerMeter;
+	}
+	setMinZoom(zoom) {
+		this._helper.setMinZoom(zoom);
+	}
+	setMaxZoom(zoom) {
+		this._helper.setMaxZoom(zoom);
+	}
+	setMinPitch(pitch) {
+		this._helper.setMinPitch(pitch);
+	}
+	setMaxPitch(pitch) {
+		this._helper.setMaxPitch(pitch);
+	}
+	setRenderWorldCopies(renderWorldCopies) {
+		this._helper.setRenderWorldCopies(renderWorldCopies);
+	}
+	setBearing(bearing) {
+		this._helper.setBearing(bearing);
+	}
+	setPitch(pitch) {
+		this._helper.setPitch(pitch);
+	}
+	setRoll(roll) {
+		this._helper.setRoll(roll);
+	}
+	setFov(fov) {
+		this._helper.setFov(fov);
+	}
+	setZoom(zoom) {
+		this._helper.setZoom(zoom);
+	}
+	setCenter(center) {
+		this._helper.setCenter(center);
+	}
+	setElevation(elevation) {
+		this._helper.setElevation(elevation);
+	}
+	setMinElevationForCurrentTile(elevation) {
+		this._helper.setMinElevationForCurrentTile(elevation);
+	}
+	setPadding(padding) {
+		this._helper.setPadding(padding);
+	}
+	interpolatePadding(start, target, t) {
+		this._helper.interpolatePadding(start, target, t);
+	}
+	isPaddingEqual(padding) {
+		return this._helper.isPaddingEqual(padding);
+	}
+	resize(width, height, constrain = true) {
+		this._helper.resize(width, height, constrain);
+	}
+	getMaxBounds() {
+		return this._helper.getMaxBounds();
+	}
+	setMaxBounds(bounds) {
+		this._helper.setMaxBounds(bounds);
+	}
+	setConstrainOverride(constrain) {
+		this._helper.setConstrainOverride(constrain);
+	}
+	overrideNearFarZ(nearZ, farZ) {
+		this._helper.overrideNearFarZ(nearZ, farZ);
+	}
+	clearNearFarZOverride() {
+		this._helper.clearNearFarZOverride();
+	}
+	getCameraQueryGeometry(queryGeometry) {
+		return this._helper.getCameraQueryGeometry(this.getCameraPoint(), queryGeometry);
+	}
+	get tileSize() {
+		return this._helper.tileSize;
+	}
+	get tileZoom() {
+		return this._helper.tileZoom;
+	}
+	get scale() {
+		return this._helper.scale;
+	}
+	get worldSize() {
+		return this._helper.worldSize;
+	}
+	get width() {
+		return this._helper.width;
+	}
+	get height() {
+		return this._helper.height;
 	}
 	get lngRange() {
 		return this._helper.lngRange;
@@ -10197,7 +11255,7 @@ var MercatorTransform = class MercatorTransform {
 	}
 	recalculateZoomAndCenter(terrain) {
 		const center = this.screenPointToLocation(this.centerPoint, terrain);
-		const elevation = terrain ? terrain.getElevationForLngLatZoom(center, this._helper._tileZoom) : 0;
+		const elevation = terrain ? terrain.getElevationForLngLat(center, this) : 0;
 		this._helper.recalculateZoomAndCenter(elevation);
 	}
 	/**
@@ -10228,17 +11286,64 @@ var MercatorTransform = class MercatorTransform {
 	}
 	screenPointToMercatorCoordinate(p, terrain) {
 		if (terrain) {
-			const coordinate = terrain.pointCoordinate(p);
+			const coordinate = this.screenTerrainPointToMercatorCoordinate(p, terrain);
 			if (coordinate != null) return coordinate;
 		}
 		return this.screenPointToMercatorCoordinateAtZ(p);
 	}
+	/** {@inheritDoc ITransform.screenTerrainPointToMercatorCoordinate} */
+	screenTerrainPointToMercatorCoordinate(p, terrain) {
+		const index = terrain.getCoverageIndex();
+		if (!index) return null;
+		const { near, far } = this.getRaySegmentFromPixel(p);
+		const worldSize = this.worldSize;
+		const dx = far[0] - near[0];
+		const dy = far[1] - near[1];
+		const dz = far[2] - near[2];
+		const ray = {
+			index,
+			exaggeration: terrain.exaggeration,
+			near,
+			dx,
+			dy,
+			dz,
+			worldSize
+		};
+		let tStart = 0;
+		let tEnd = 1;
+		if (dz === 0) {
+			if (near[2] > index.maxElevation || near[2] < index.minElevation) return null;
+		} else {
+			const tHigh = (index.maxElevation - near[2]) / dz;
+			const tLow = (index.minElevation - near[2]) / dz;
+			tStart = Math.max(tStart, Math.min(tHigh, tLow));
+			tEnd = Math.min(tEnd, Math.max(tHigh, tLow));
+			if (tStart > tEnd) return null;
+		}
+		const horizontalLength = Math.hypot(dx, dy);
+		const samples = clamp(Math.ceil(horizontalLength * (tEnd - tStart) / TARGET_WORLD_STEP_PX), 1, MAX_SAMPLES);
+		let previousT = 0;
+		let aboveTerrain = !mercatorIsBelowTerrain(ray, 0);
+		for (let i = 0; i <= samples; i++) {
+			const t = tStart + (tEnd - tStart) * i / samples;
+			if (!aboveTerrain) aboveTerrain = !mercatorIsBelowTerrain(ray, t);
+			else if (mercatorIsBelowTerrain(ray, t)) {
+				const { lo, hi } = bisect(ray, mercatorIsBelowTerrain, previousT, t, MERCATOR_BISECT_EPSILON_WORLD_PX / horizontalLength);
+				const sampleLo = mercatorSampleAt(ray, lo);
+				const sampleHi = mercatorSampleAt(ray, hi);
+				const fLo = near[2] + lo * dz - sampleLo.elevation;
+				const fHi = near[2] + hi * dz - sampleHi.elevation;
+				const hit = sampleLo.covered && fLo > fHi ? clamp(lo + fLo * (hi - lo) / (fLo - fHi), lo, hi) : hi;
+				return new MercatorCoordinate((near[0] + hit * dx) / worldSize, (near[1] + hit * dy) / worldSize, mercatorSampleAt(ray, hit).elevation);
+			}
+			previousT = t;
+		}
+		return null;
+	}
 	/**
-	* Intersects the ray through a screen point with the horizontal plane at `z`,
-	* given in meters relative to the plane at the center's elevation (not mercator units).
+	* Returns the segment of the ray through the given screen pixel that lies inside the view frustum.
 	*/
-	screenPointToMercatorCoordinateAtZ(p, z) {
-		const targetZ = z ? z : 0;
+	getRaySegmentFromPixel(p) {
 		const coord0 = [
 			p.x,
 			p.y,
@@ -10255,14 +11360,29 @@ var MercatorTransform = class MercatorTransform {
 		transformMat4(coord1, coord1, this._pixelMatrixInverse);
 		const w0 = coord0[3];
 		const w1 = coord1[3];
-		const x0 = coord0[0] / w0;
-		const x1 = coord1[0] / w1;
-		const y0 = coord0[1] / w0;
-		const y1 = coord1[1] / w1;
-		const z0 = coord0[2] / w0;
-		const z1 = coord1[2] / w1;
-		const t = z0 === z1 ? 0 : (targetZ - z0) / (z1 - z0);
-		return new MercatorCoordinate(interpolateFactory.number(x0, x1, t) / this.worldSize, interpolateFactory.number(y0, y1, t) / this.worldSize, targetZ);
+		const elevation = this.elevation;
+		return {
+			near: [
+				coord0[0] / w0,
+				coord0[1] / w0,
+				coord0[2] / w0 + elevation
+			],
+			far: [
+				coord1[0] / w1,
+				coord1[1] / w1,
+				coord1[2] / w1 + elevation
+			]
+		};
+	}
+	/**
+	* Intersects the ray through a screen point with the horizontal plane at `z`,
+	* given in meters relative to the plane at the center's elevation (not mercator units).
+	*/
+	screenPointToMercatorCoordinateAtZ(p, z) {
+		const targetZ = z ? z : 0;
+		const { near, far } = this.getRaySegmentFromPixel(p);
+		const t = near[2] === far[2] ? 0 : (targetZ + this.elevation - near[2]) / (far[2] - near[2]);
+		return new MercatorCoordinate(interpolateFactory.number(near[0], far[0], t) / this.worldSize, interpolateFactory.number(near[1], far[1], t) / this.worldSize, targetZ);
 	}
 	/**
 	* Given a coordinate, return the screen point that corresponds to it
@@ -10286,7 +11406,7 @@ var MercatorTransform = class MercatorTransform {
 		return new LngLatBounds().extend(this.screenPointToLocation(new Point(0, top))).extend(this.screenPointToLocation(new Point(this._helper._width, top))).extend(this.screenPointToLocation(new Point(this._helper._width, this._helper._height))).extend(this.screenPointToLocation(new Point(0, this._helper._height)));
 	}
 	isPointOnMapSurface(p, terrain) {
-		if (terrain) return terrain.pointCoordinate(p) != null;
+		if (terrain) return this.screenTerrainPointToMercatorCoordinate(p, terrain) != null;
 		return p.y > this.height / 2 - getMercatorHorizon(this);
 	}
 	calculatePosMatrix(tileID, aligned = false, useFloat32 = false) {
@@ -10523,14 +11643,14 @@ var MercatorTransform = class MercatorTransform {
 	getRayDirectionFromPixel(_p) {
 		throw new Error("Not implemented.");
 	}
-	projectTileCoordinates(x, y, unwrappedTileID, getElevation) {
+	projectTileCoordinates(x, y, unwrappedTileID, elevation) {
 		const matrix = this.calculatePosMatrix(unwrappedTileID);
 		let pos;
-		if (getElevation) {
+		if (elevation != null) {
 			pos = [
 				x,
 				y,
-				getElevation(x, y),
+				elevation,
 				1
 			];
 			transformMat4(pos, pos, matrix);
@@ -10584,6 +11704,12 @@ var MercatorTransform = class MercatorTransform {
 		return this.calculatePosMatrix(tileID);
 	}
 };
+function mercatorSampleAt(ray, t) {
+	return sampleAt(ray.index, ray.exaggeration, (ray.near[0] + t * ray.dx) / ray.worldSize, (ray.near[1] + t * ray.dy) / ray.worldSize);
+}
+function mercatorIsBelowTerrain(ray, t) {
+	return isBelowTerrainSample(mercatorSampleAt(ray, t), ray.near[2] + t * ray.dz);
+}
 //#endregion
 //#region src/geo/projection/camera_helper.ts
 /**
@@ -11234,6 +12360,36 @@ function interpolateLngLatForGlobe(start, deltaLng, deltaLat, t) {
 		return new LngLat(interpolatedLng, interpolatedLat);
 	}
 }
+/**
+* Returns the two intersection points of the ray and a sphere centered at the origin,
+* or null if no intersection occurs.
+* The intersections are encoded as the parameter for parametric ray equation,
+* with `tMin` being the first intersection and `tMax` being the second.
+* The quadratic is solved as suggested in Ray Tracing Gems, chapter 7, since the
+* schoolbook approach leads to floating point precision issues:
+* https://www.realtimerendering.com/raytracinggems/rtg/index.html
+* @param origin - The ray origin.
+* @param direction - The normalized ray direction.
+* @param radius - The sphere radius, defaults to the unit sphere of the planet.
+*/
+function raySphereIntersection(origin, direction, radius = 1) {
+	const originDotDirection = dot(origin, direction);
+	const radiusSquared = radius * radius;
+	const inner = createVec3f64();
+	const scaledDir = createVec3f64();
+	scale$2(scaledDir, direction, originDotDirection);
+	sub(inner, origin, scaledDir);
+	const discriminant = radiusSquared - dot(inner, inner);
+	if (discriminant < 0) return null;
+	const c = dot(origin, origin) - radiusSquared;
+	const q = -originDotDirection + (originDotDirection < 0 ? 1 : -1) * Math.sqrt(discriminant);
+	const t0 = c / q;
+	const t1 = q;
+	return {
+		tMin: Math.min(t0, t1),
+		tMax: Math.max(t0, t1)
+	};
+}
 //#endregion
 //#region src/util/primitives/bounding_volume_cache.ts
 var BoundingVolumeCache = class {
@@ -11669,6 +12825,10 @@ function findAxisMinMax(axis, points) {
 }
 //#endregion
 //#region src/geo/projection/vertical_perspective_transform.ts
+const GLOBE_SAMPLES = 256;
+const GLOBE_BISECT_EPSILON_T = 1e-12;
+/** Latitudes outside the mercator range project past the world edge; the globe mesh still covers them. */
+const MAX_MERCATOR_Y = 1 - 1e-9;
 var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	get pixelsToClipSpaceMatrix() {
 		return this._helper.pixelsToClipSpaceMatrix;
@@ -12008,10 +13168,10 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		const angular = mercatorCoordinatesToAngularCoordinatesRadians(mercator.x, mercator.y);
 		return this.getCircleRadiusCorrection() / Math.cos(angular[1]);
 	}
-	projectTileCoordinates(x, y, unwrappedTileID, getElevation) {
+	projectTileCoordinates(x, y, unwrappedTileID, elevation) {
 		const canonical = unwrappedTileID.canonical;
 		const spherePos = projectTileCoordinatesToSphere(x, y, canonical.x, canonical.y, canonical.z);
-		const vectorMultiplier = 1 + (getElevation ? getElevation(x, y) : 0) / earthRadius;
+		const vectorMultiplier = 1 + (elevation ?? 0) / earthRadius;
 		const pos = [
 			spherePos[0] * vectorMultiplier,
 			spherePos[1] * vectorMultiplier,
@@ -12271,11 +13431,41 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	}
 	screenPointToMercatorCoordinate(p, terrain) {
 		if (terrain) {
-			const coordinate = terrain.pointCoordinate(p);
+			const coordinate = this.screenTerrainPointToMercatorCoordinate(p, terrain);
 			if (coordinate) return coordinate;
 		}
 		return MercatorCoordinate.fromLngLat(this.unprojectScreenPoint(p));
 	}
+	/** {@inheritDoc ITransform.screenTerrainPointToMercatorCoordinate} */
+	screenTerrainPointToMercatorCoordinate(p, terrain) {
+		const index = terrain.getCoverageIndex();
+		if (!index) return null;
+		const origin = this.cameraPosition;
+		const direction = this.getRayDirectionFromPixel(p);
+		const outer = raySphereIntersection(origin, direction, 1 + index.maxElevation / earthRadius);
+		if (!outer) return null;
+		const inner = raySphereIntersection(origin, direction, 1 + index.minElevation / earthRadius);
+		const tStart = Math.max(outer.tMin, 0);
+		const tEnd = inner ? inner.tMin : outer.tMax;
+		if (tEnd <= tStart) return null;
+		const ray = {
+			index,
+			exaggeration: terrain.exaggeration,
+			origin,
+			direction
+		};
+		let previousT = 0;
+		for (let i = 0; i <= GLOBE_SAMPLES; i++) {
+			const t = tStart + (tEnd - tStart) * i / GLOBE_SAMPLES;
+			if (globeIsBelowTerrain(ray, t)) {
+				const { hi } = bisect(ray, globeIsBelowTerrain, previousT, t, GLOBE_BISECT_EPSILON_T);
+				const { sample, mercator } = globeSampleAt(ray, hi);
+				return new MercatorCoordinate(mercator.x, mercator.y, sample.elevation);
+			}
+			previousT = t;
+		}
+		return null;
+	}
 	screenPointToLocation(p, terrain) {
 		return this.screenPointToMercatorCoordinate(p, terrain)?.toLngLat();
 	}
@@ -12284,8 +13474,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	}
 	isPointOnMapSurface(p, _terrain) {
 		const rayOrigin = this._cameraPosition;
-		const rayDirection = this.getRayDirectionFromPixel(p);
-		return !!this.rayPlanetIntersection(rayOrigin, rayDirection);
+		return !!raySphereIntersection(rayOrigin, this.getRayDirectionFromPixel(p));
 	}
 	/**
 	* Computes normalized direction of a ray from the camera to the given screen pixel.
@@ -12330,33 +13519,6 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		return projected[0] > -1 && projected[0] < 1 && projected[1] > -1 && projected[1] < 1 && projected[2] > -1 && projected[2] < 1;
 	}
 	/**
-	* Returns the two intersection points of the ray and the planet's sphere,
-	* or null if no intersection occurs.
-	* The intersections are encoded as the parameter for parametric ray equation,
-	* with `tMin` being the first intersection and `tMax` being the second.
-	* Eg. the nearer intersection point can then be computed as `origin + direction * tMin`.
-	* @param origin - The ray origin.
-	* @param direction - The normalized ray direction.
-	*/
-	rayPlanetIntersection(origin, direction) {
-		const originDotDirection = dot(origin, direction);
-		const planetRadiusSquared = 1;
-		const inner = createVec3f64();
-		const scaledDir = createVec3f64();
-		scale$2(scaledDir, direction, originDotDirection);
-		sub(inner, origin, scaledDir);
-		const discriminant = planetRadiusSquared - dot(inner, inner);
-		if (discriminant < 0) return null;
-		const c = dot(origin, origin) - planetRadiusSquared;
-		const q = -originDotDirection + (originDotDirection < 0 ? 1 : -1) * Math.sqrt(discriminant);
-		const t0 = c / q;
-		const t1 = q;
-		return {
-			tMin: Math.min(t0, t1),
-			tMax: Math.max(t0, t1)
-		};
-	}
-	/**
 	* @internal
 	* Returns a {@link LngLat} representing geographical coordinates that correspond to the specified pixel coordinates.
 	* Note: if the point does not lie on the globe, returns a location on the visible globe horizon (edge) that is
@@ -12367,7 +13529,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	unprojectScreenPoint(p) {
 		const rayOrigin = this._cameraPosition;
 		const rayDirection = this.getRayDirectionFromPixel(p);
-		const intersection = this.rayPlanetIntersection(rayOrigin, rayDirection);
+		const intersection = raySphereIntersection(rayOrigin, rayDirection);
 		if (intersection) {
 			const intersectionPoint = createVec3f64();
 			add(intersectionPoint, rayOrigin, [
@@ -12421,6 +13583,30 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	}
 	getFastPathSimpleProjectionMatrix(_tileID) {}
 };
+function globeSampleAt(ray, t) {
+	const position = createVec3f64();
+	scaleAndAdd(position, ray.origin, ray.direction, t);
+	const radius = length$1(position);
+	const surface = createVec3f64();
+	scale$2(surface, position, 1 / radius);
+	const lngLat = sphereSurfacePointToCoordinates(surface);
+	const projected = MercatorCoordinate.fromLngLat(lngLat);
+	const mercator = new MercatorCoordinate(projected.x, clamp(projected.y, 0, MAX_MERCATOR_Y));
+	const sample = sampleAt(ray.index, ray.exaggeration, mercator.x, mercator.y);
+	const elevation = Math.abs(lngLat.lat) > 85.051129 ? 0 : sample.elevation;
+	return {
+		sample: {
+			...sample,
+			elevation
+		},
+		radius,
+		mercator
+	};
+}
+function globeIsBelowTerrain(ray, t) {
+	const { sample, radius } = globeSampleAt(ray, t);
+	return isBelowTerrainSample(sample, (radius - 1) * earthRadius);
+}
 //#endregion
 //#region src/geo/projection/globe_transform.ts
 /**
@@ -12703,8 +13889,8 @@ var GlobeTransform = class GlobeTransform {
 		const verticalCorrection = this._verticalPerspectiveTransform.getPitchedTextCorrection(textAnchorX, textAnchorY, tileID);
 		return lerp(mercatorCorrection, verticalCorrection, this._globeness);
 	}
-	projectTileCoordinates(x, y, unwrappedTileID, getElevation) {
-		return this.currentTransform.projectTileCoordinates(x, y, unwrappedTileID, getElevation);
+	projectTileCoordinates(x, y, unwrappedTileID, elevation) {
+		return this.currentTransform.projectTileCoordinates(x, y, unwrappedTileID, elevation);
 	}
 	_calcMatrices() {
 		if (!this._helper._width || !this._helper._height) return;
@@ -12777,6 +13963,10 @@ var GlobeTransform = class GlobeTransform {
 	screenPointToMercatorCoordinate(p, terrain) {
 		return this.currentTransform.screenPointToMercatorCoordinate(p, terrain);
 	}
+	/** {@inheritDoc ITransform.screenTerrainPointToMercatorCoordinate} */
+	screenTerrainPointToMercatorCoordinate(p, terrain) {
+		return this.currentTransform.screenTerrainPointToMercatorCoordinate(p, terrain);
+	}
 	screenPointToLocation(p, terrain) {
 		return this.currentTransform.screenPointToLocation(p, terrain);
 	}
@@ -13286,6 +14476,8 @@ var Style = class extends Evented {
 		this._glyphsDidChange = false;
 		this._updatedPaintProps = {};
 		this._layerOrderChanged = false;
+		this._symbolPlacementTriggered = false;
+		this._placedProjectionTransition = void 0;
 		this.crossTileSymbolIndex = new ((this.crossTileSymbolIndex?.constructor) || Object)();
 		this.pauseablePlacement = void 0;
 		this.placement = void 0;
@@ -13380,6 +14572,7 @@ var Style = class extends Evented {
 		if (nextState.sprite) this._loadSprite(nextState.sprite);
 		else this.imageManager.setLoaded(true);
 		this.glyphManager.setURL(nextState.glyphs);
+		this.glyphManager.setFontFaces(nextState["font-faces"]);
 		this._createLayers();
 		this.light = new Light(this.stylesheet.light ?? {}, this._globalState);
 		this._setProjectionInternal(this.stylesheet.projection?.type || "mercator");
@@ -13643,6 +14836,9 @@ var Style = class extends Evented {
 			case "setGlyphs":
 				operations.push(() => this.setGlyphs.apply(this, op.args));
 				break;
+			case "setFontFaces":
+				operations.push(() => this.setFontFaces.apply(this, op.args));
+				break;
 			case "setSprite":
 				operations.push(() => this.setSprite.apply(this, op.args));
 				break;
@@ -13968,6 +15164,7 @@ var Style = class extends Evented {
 		if (isRasterStyleLayer(layer) && name === "raster-fade-duration") this.tileManagers[layer.source].setRasterFadeDuration(value);
 		this._changed = true;
 		this._updatedPaintProps[layer.id] = true;
+		if (layer.type === "symbol") this.triggerSymbolPlacement();
 		this._serializedLayers = null;
 	}
 	getPaintProperty(layer, name) {
@@ -14066,8 +15263,10 @@ var Style = class extends Evented {
 			pitch: myStyleSheet.pitch,
 			sprite: myStyleSheet.sprite,
 			glyphs: myStyleSheet.glyphs,
+			"font-faces": myStyleSheet["font-faces"],
 			transition: myStyleSheet.transition,
 			projection: myStyleSheet.projection,
+			state: myStyleSheet.state,
 			sources,
 			layers,
 			terrain
@@ -14225,6 +15424,7 @@ var Style = class extends Evented {
 		for (const key in this.tileManagers) this.tileManagers[key].reload();
 	}
 	_validate(validate, key, value, props, options = {}) {
+		if (options.validate === false) return false;
 		return validateAndEmit(this, validate, {
 			key,
 			style: this.serialize(),
@@ -14270,6 +15470,26 @@ var Style = class extends Evented {
 	_generateCollisionBoxes() {
 		for (const id in this.tileManagers) this._reloadSource(id);
 	}
+	/**
+	* Re-places symbols on the next frame.
+	* Placement is skipped while its inputs look unchanged, so call this when something
+	* the map cannot see for itself has moved symbols.
+	*/
+	triggerSymbolPlacement() {
+		this._symbolPlacementTriggered = true;
+	}
+	/**
+	* Whether re-running symbol placement could produce a different result than the last run.
+	* Every camera and viewport parameter placement can observe perturbs the model-view-projection
+	* matrix, so comparing the matrix covers them all. Inputs the matrix cannot see arrive as
+	* {@link triggerSymbolPlacement} calls.
+	*
+	* @internal
+	*/
+	_placementInputsChanged(transform, showCollisionBoxes, crossSourceCollisions) {
+		const lastPlacement = this.pauseablePlacement;
+		return !lastPlacement || this._symbolPlacementTriggered || this._placedProjectionTransition !== this.projection?.transitionState || lastPlacement._showCollisionBoxes !== showCollisionBoxes || lastPlacement.placement.collisionGroups.crossSourceCollisions !== crossSourceCollisions || lastPlacement.placement.transform.renderWorldCopies !== transform.renderWorldCopies || !exactEquals(lastPlacement.placement.transform.modelViewProjectionMatrix, transform.modelViewProjectionMatrix);
+	}
 	_updatePlacement(transform, showCollisionBoxes, fadeDuration, crossSourceCollisions, forceFullPlacement = false) {
 		let symbolBucketsChanged = false;
 		let placementCommitted = false;
@@ -14286,12 +15506,17 @@ var Style = class extends Evented {
 		}
 		this.crossTileSymbolIndex.pruneUnusedLayers(this._order);
 		forceFullPlacement ||= this._layerOrderChanged || fadeDuration === 0;
-		if (forceFullPlacement || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(now(), transform.zoom)) {
+		const placementInputsChanged = symbolBucketsChanged || this._placementInputsChanged(transform, showCollisionBoxes, crossSourceCollisions);
+		const placementSettled = this.pauseablePlacement?.isDone() && !this.placement.stillRecent(now(), transform.zoom);
+		if (forceFullPlacement || !this.pauseablePlacement || placementSettled && (placementInputsChanged || this.placement.stale)) {
+			this._symbolPlacementTriggered = false;
+			this._placedProjectionTransition = this.projection?.transitionState;
 			this.pauseablePlacement = new PauseablePlacement(transform, this.map.terrain, this._order, forceFullPlacement, showCollisionBoxes, fadeDuration, crossSourceCollisions, this.placement);
 			this._layerOrderChanged = false;
 		}
-		if (this.pauseablePlacement.isDone()) this.placement.setStale();
-		else {
+		if (this.pauseablePlacement.isDone()) {
+			if (placementInputsChanged) this.placement.setStale();
+		} else {
 			this.pauseablePlacement.continuePlacement(this._order, this._layers, layerTiles);
 			if (this.pauseablePlacement.isDone()) {
 				this.placement = this.pauseablePlacement.commit(now());
@@ -14328,11 +15553,22 @@ var Style = class extends Evented {
 	setGlyphs(glyphsUrl, options = {}) {
 		this._checkLoaded();
 		if (glyphsUrl && this._validate(validateStyle.glyphs, "glyphs", glyphsUrl, null, options)) return;
+		this._changed = true;
 		this._glyphsDidChange = true;
 		this.stylesheet.glyphs = glyphsUrl;
 		this.glyphManager.entries = {};
 		this.glyphManager.setURL(glyphsUrl);
 	}
+	getFontFaces() {
+		return this.stylesheet["font-faces"] || null;
+	}
+	setFontFaces(fontFaces) {
+		this._checkLoaded();
+		this._changed = true;
+		this._glyphsDidChange = true;
+		this.stylesheet["font-faces"] = fontFaces;
+		this.glyphManager.setFontFaces(fontFaces);
+	}
 	async getDashes(mapId, params) {
 		const result = {};
 		for (const [key, dash] of Object.entries(params.dashes)) result[key] = this.lineAtlas.getDash(dash.dasharray, dash.round);
@@ -14556,11 +15792,6 @@ const terrainUniforms = (context, locations) => ({
 	"u_is_globe_mode": new Uniform1f(context, locations.u_is_globe_mode)
 });
 const terrainDepthUniforms = (context, locations) => ({ "u_ele_delta": new Uniform1f(context, locations.u_ele_delta) });
-const terrainCoordsUniforms = (context, locations) => ({
-	"u_texture": new Uniform1i(context, locations.u_texture),
-	"u_terrain_coords_id": new Uniform1f(context, locations.u_terrain_coords_id),
-	"u_ele_delta": new Uniform1f(context, locations.u_ele_delta)
-});
 const terrainUniformValues = (eleDelta, fogMatrix, sky, pitch, isGlobeMode) => ({
 	"u_texture": 0,
 	"u_ele_delta": eleDelta,
@@ -14573,11 +15804,6 @@ const terrainUniformValues = (eleDelta, fogMatrix, sky, pitch, isGlobeMode) => (
 	"u_is_globe_mode": isGlobeMode ? 1 : 0
 });
 const terrainDepthUniformValues = (eleDelta) => ({ "u_ele_delta": eleDelta });
-const terrainCoordsUniformValues = (coordsId, eleDelta) => ({
-	"u_terrain_coords_id": coordsId / 255,
-	"u_texture": 0,
-	"u_ele_delta": eleDelta
-});
 //#endregion
 //#region src/webgl/program/projection_program.ts
 const projectionUniforms = (context, locations) => ({
@@ -15207,7 +16433,8 @@ const symbolIconUniforms = (context, locations) => ({
 	"u_texture": new Uniform1i(context, locations.u_texture),
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_pitched_scale": new Uniform1f(context, locations.u_pitched_scale),
-	"u_is_offset": new Uniform1i(context, locations.u_is_offset)
+	"u_is_offset": new Uniform1i(context, locations.u_is_offset),
+	"u_height_anchor_ground": new Uniform1i(context, locations.u_height_anchor_ground)
 });
 const symbolSDFUniforms = (context, locations) => ({
 	"u_is_size_zoom_constant": new Uniform1i(context, locations.u_is_size_zoom_constant),
@@ -15233,7 +16460,8 @@ const symbolSDFUniforms = (context, locations) => ({
 	"u_is_plain": new Uniform1i(context, locations.u_is_plain),
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_pitched_scale": new Uniform1f(context, locations.u_pitched_scale),
-	"u_is_offset": new Uniform1i(context, locations.u_is_offset)
+	"u_is_offset": new Uniform1i(context, locations.u_is_offset),
+	"u_height_anchor_ground": new Uniform1i(context, locations.u_height_anchor_ground)
 });
 const symbolTextAndIconUniforms = (context, locations) => ({
 	"u_is_size_zoom_constant": new Uniform1i(context, locations.u_is_size_zoom_constant),
@@ -15260,9 +16488,10 @@ const symbolTextAndIconUniforms = (context, locations) => ({
 	"u_is_halo": new Uniform1i(context, locations.u_is_halo),
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_pitched_scale": new Uniform1f(context, locations.u_pitched_scale),
-	"u_is_offset": new Uniform1i(context, locations.u_is_offset)
+	"u_is_offset": new Uniform1i(context, locations.u_is_offset),
+	"u_height_anchor_ground": new Uniform1i(context, locations.u_height_anchor_ground)
 });
-const symbolIconUniformValues = (functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, pitchedScale, isOffset) => {
+const symbolIconUniformValues = (functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, pitchedScale, isOffset, heightAnchorGround) => {
 	const transform = painter.transform;
 	return {
 		"u_is_size_zoom_constant": +(functionType === "constant" || functionType === "source"),
@@ -15284,20 +16513,21 @@ const symbolIconUniformValues = (functionType, size, rotateInShader, pitchWithMa
 		"u_texture": 0,
 		"u_translation": translation,
 		"u_pitched_scale": pitchedScale,
-		"u_is_offset": isOffset
+		"u_is_offset": isOffset,
+		"u_height_anchor_ground": +heightAnchorGround
 	};
 };
-const symbolSDFUniformValues = (functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, isHalo, pitchedScale, isOffset) => {
+const symbolSDFUniformValues = (functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, isHalo, pitchedScale, isOffset, heightAnchorGround) => {
 	const transform = painter.transform;
-	return extend(symbolIconUniformValues(functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, pitchedScale, isOffset), {
+	return extend(symbolIconUniformValues(functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, pitchedScale, isOffset, heightAnchorGround), {
 		"u_gamma_scale": pitchWithMap ? Math.cos(transform.pitch * Math.PI / 180) * transform.cameraToCenterDistance : 1,
 		"u_device_pixel_ratio": painter.pixelRatio,
 		"u_is_halo": isHalo ? 1 : 0,
 		"u_is_plain": 1
 	});
 };
-const symbolTextAndIconUniformValues = (functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, texSizeSDF, texSizeIcon, pitchedScale, isOffset) => {
-	return extend(symbolSDFUniformValues(functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, true, texSizeSDF, true, pitchedScale, isOffset), {
+const symbolTextAndIconUniformValues = (functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, texSizeSDF, texSizeIcon, pitchedScale, isOffset, heightAnchorGround) => {
+	return extend(symbolSDFUniformValues(functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, true, texSizeSDF, true, pitchedScale, isOffset, heightAnchorGround), {
 		"u_texsize_icon": texSizeIcon,
 		"u_texture_icon": 1
 	});
@@ -15409,7 +16639,6 @@ const programUniforms = {
 	backgroundPattern: backgroundPatternUniforms,
 	terrain: terrainUniforms,
 	terrainDepth: terrainDepthUniforms,
-	terrainCoords: terrainCoordsUniforms,
 	atmosphere: atmosphereUniforms,
 	sky: skyUniforms
 };
@@ -16383,7 +17612,7 @@ function drawSymbols(painter, tileManager, layer, coords, variableOffsets, rende
 	const stencilMode = StencilMode.disabled;
 	const colorMode = painter.colorModeForRenderPass();
 	if (layer._unevaluatedLayout.hasValue("text-variable-anchor") || layer._unevaluatedLayout.hasValue("text-variable-anchor-offset")) updateVariableAnchors(coords, painter, layer, tileManager, layer.layout.get("text-rotation-alignment"), layer.layout.get("text-pitch-alignment"), layer.paint.get("text-translate"), layer.paint.get("text-translate-anchor"), variableOffsets);
-	if (layer.paint.get("icon-opacity").constantOr(1) !== 0) drawLayerSymbols(painter, tileManager, layer, coords, false, layer.paint.get("icon-translate"), layer.paint.get("icon-translate-anchor"), layer.layout.get("icon-rotation-alignment"), layer.layout.get("icon-pitch-alignment"), layer.layout.get("icon-keep-upright"), stencilMode, colorMode, isRenderingToTexture);
+	if (layer.paint.get("icon-opacity").constantOr(1) !== 0) drawLayerSymbols(painter, tileManager, layer, coords, false, layer.paint.get("icon-translate"), layer.paint.get("icon-translate-anchor"), layer.layout.get("icon-rotation-alignment").constantOr("viewport"), layer.layout.get("icon-pitch-alignment"), layer.layout.get("icon-keep-upright"), stencilMode, colorMode, isRenderingToTexture);
 	if (layer.paint.get("text-opacity").constantOr(1) !== 0) drawLayerSymbols(painter, tileManager, layer, coords, true, layer.paint.get("text-translate"), layer.paint.get("text-translate-anchor"), layer.layout.get("text-rotation-alignment"), layer.layout.get("text-pitch-alignment"), layer.layout.get("text-keep-upright"), stencilMode, colorMode, isRenderingToTexture);
 	if (tileManager.map.showCollisionBoxes) {
 		drawCollisionDebug(painter, tileManager, layer, coords, true);
@@ -16412,8 +17641,8 @@ function updateVariableAnchors(coords, painter, layer, tileManager, rotationAlig
 		const updateTextFitIcon = layer.layout.get("icon-text-fit") !== "none" && bucket.hasIconData();
 		if (size) {
 			const tileScale = Math.pow(2, transform.zoom - tile.tileID.overscaledZ);
-			const getElevation = terrain ? (x, y) => terrain.getElevation(coord, x, y) : null;
-			updateVariableAnchorsForBucket(bucket, rotateWithMap, pitchWithMap, variableOffsets, transform, pitchedLabelPlaneMatrix, tileScale, size, updateTextFitIcon, translatePosition(transform, tile, translate, translateAnchor), coord.toUnwrapped(), getElevation);
+			const getElevation = terrain ? (x, y) => terrain.getElevation(coord, x, y) : void 0;
+			updateVariableAnchorsForBucket(bucket, rotateWithMap, pitchWithMap, variableOffsets, transform, pitchedLabelPlaneMatrix, tileScale, size, updateTextFitIcon, translatePosition(transform, tile, translate, translateAnchor), coord.toUnwrapped(), getElevation, layer.layout.get("symbol-height-anchor") === "ground");
 		}
 	}
 }
@@ -16423,14 +17652,14 @@ function getShiftedAnchor(projectedAnchorPoint, projectionContext, rotateWithMap
 		let adjustedShift = shift.mult(pitchedTextShiftCorrection);
 		if (!rotateWithMap) adjustedShift = adjustedShift.rotate(-transformAngle);
 		const tileAnchorShifted = translatedAnchor.add(adjustedShift);
-		return projectWithMatrix(tileAnchorShifted.x, tileAnchorShifted.y, projectionContext.pitchedLabelPlaneMatrix, projectionContext.getElevation).point;
+		return projectWithMatrix(tileAnchorShifted.x, tileAnchorShifted.y, projectionContext.pitchedLabelPlaneMatrix, elevationAt(projectionContext, tileAnchorShifted.x, tileAnchorShifted.y)).point;
 	} else if (rotateWithMap) {
 		const east = projectTileCoordinatesToLabelPlane(projectionContext.tileAnchorPoint.x + 1, projectionContext.tileAnchorPoint.y, projectionContext).point.sub(projectedAnchorPoint);
 		const angle = Math.atan(east.y / east.x) + (east.x < 0 ? Math.PI : 0);
 		return projectedAnchorPoint.add(shift.rotate(angle));
 	} else return projectedAnchorPoint.add(shift);
 }
-function updateVariableAnchorsForBucket(bucket, rotateWithMap, pitchWithMap, variableOffsets, transform, pitchedLabelPlaneMatrix, tileScale, size, updateTextFitIcon, translation, unwrappedTileID, getElevation) {
+function updateVariableAnchorsForBucket(bucket, rotateWithMap, pitchWithMap, variableOffsets, transform, pitchedLabelPlaneMatrix, tileScale, size, updateTextFitIcon, translation, unwrappedTileID, getElevation, heightAnchorGround) {
 	const placedSymbols = bucket.text.placedSymbolArray;
 	const dynamicTextLayoutVertexArray = bucket.text.dynamicLayoutVertexArray;
 	const dynamicIconLayoutVertexArray = bucket.icon.dynamicLayoutVertexArray;
@@ -16445,6 +17674,8 @@ function updateVariableAnchorsForBucket(bucket, rotateWithMap, pitchWithMap, var
 			const tileAnchor = new Point(symbol.anchorX, symbol.anchorY);
 			const projectionContext = {
 				getElevation,
+				heightOffset: symbol.heightOffset,
+				heightAnchorGround,
 				width: transform.width,
 				height: transform.height,
 				pitchedLabelPlaneMatrix,
@@ -16554,10 +17785,11 @@ function drawLayerSymbols(painter, tileManager, layer, coords, isText, translate
 		const hasVariableAnchors = hasVariablePlacement && bucket.hasTextData();
 		const updateTextFitIcon = layer.layout.get("icon-text-fit") !== "none" && hasVariableAnchors && bucket.hasIconData();
 		const isOffset = layer._unevaluatedLayout.hasValue("icon-offset");
+		const heightAnchorGround = layer.layout.get("symbol-height-anchor") === "ground";
 		if (alongLine) {
 			const pitchedLabelPlaneMatrixInverse = create$1();
 			fastInvertTransformMat4(pitchedLabelPlaneMatrixInverse, pitchedLabelPlaneMatrix);
-			const getElevation = painter.style.map.terrain ? (x, y) => painter.style.map.terrain.getElevation(coord, x, y) : null;
+			const getElevation = painter.style.map.terrain ? (x, y) => painter.style.map.terrain.getElevation(coord, x, y) : void 0;
 			updateLineLabels(bucket, painter, isText, pitchedLabelPlaneMatrix, pitchedLabelPlaneMatrixInverse, pitchWithMap, keepUpright, layer.layout.get("text-rotation-alignment") === "map", coord.toUnwrapped(), transform.width, transform.height, translation, getElevation);
 		}
 		const shaderVariableAnchor = isText && hasVariablePlacement || updateTextFitIcon;
@@ -16566,9 +17798,9 @@ function drawLayerSymbols(painter, tileManager, layer, coords, isText, translate
 		const hasHalo = isSDF && layer.paint.get(isText ? "text-halo-width" : "icon-halo-width").constantOr(1) !== 0;
 		let uniformValues;
 		if (isSDF) {
-			if (!bucket.iconsInText) uniformValues = symbolSDFUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, alongLine, shaderVariableAnchor, painter, uLabelPlaneMatrix, glCoordMatrixForShader, translation, isText, texSize, hasHalo, pitchedTextRescaling, isOffset);
-			else uniformValues = symbolTextAndIconUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, alongLine, shaderVariableAnchor, painter, uLabelPlaneMatrix, glCoordMatrixForShader, translation, texSize, texSizeIcon, pitchedTextRescaling, isOffset);
-		} else uniformValues = symbolIconUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, alongLine, shaderVariableAnchor, painter, uLabelPlaneMatrix, glCoordMatrixForShader, translation, isText, texSize, pitchedTextRescaling, isOffset);
+			if (!bucket.iconsInText) uniformValues = symbolSDFUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, alongLine, shaderVariableAnchor, painter, uLabelPlaneMatrix, glCoordMatrixForShader, translation, isText, texSize, hasHalo, pitchedTextRescaling, isOffset, heightAnchorGround);
+			else uniformValues = symbolTextAndIconUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, alongLine, shaderVariableAnchor, painter, uLabelPlaneMatrix, glCoordMatrixForShader, translation, texSize, texSizeIcon, pitchedTextRescaling, isOffset, heightAnchorGround);
+		} else uniformValues = symbolIconUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, alongLine, shaderVariableAnchor, painter, uLabelPlaneMatrix, glCoordMatrixForShader, translation, isText, texSize, pitchedTextRescaling, isOffset, heightAnchorGround);
 		const state = {
 			program,
 			buffers,
@@ -17380,18 +18612,18 @@ function renderColorRelief(painter, tileManager, layer, coords, stencilModes, de
 		}
 		if (!dem?.data) continue;
 		const textureStride = dem.stride;
-		const pixelData = dem.getPixels();
 		context.activeTexture.set(gl.TEXTURE0);
-		context.pixelStoreUnpackPremultiplyAlpha.set(false);
-		tile.demTexture ||= painter.getTileTexture(textureStride);
-		if (tile.demTexture) {
-			const demTexture = tile.demTexture;
-			demTexture.update(pixelData, { premultiply: false });
-			demTexture.bind(textureFilter, gl.CLAMP_TO_EDGE);
-		} else {
-			tile.demTexture = new Texture(context, pixelData, gl.RGBA, { premultiply: false });
-			tile.demTexture.bind(textureFilter, gl.CLAMP_TO_EDGE);
+		if (!tile.demTexture || tile.needsColorReliefPrepare) {
+			context.pixelStoreUnpackPremultiplyAlpha.set(false);
+			tile.demTexture ||= painter.getTileTexture(textureStride) ?? new Texture(context, {
+				width: textureStride,
+				height: textureStride,
+				data: null
+			}, gl.RGBA);
+			tile.demTexture.update(dem.getPixels(), { premultiply: false });
+			tile.needsColorReliefPrepare = false;
 		}
+		tile.demTexture.bind(textureFilter, gl.CLAMP_TO_EDGE);
 		const mesh = projection.getMeshFromTileID(context, coord.canonical, useBorder, true, "raster");
 		const terrainData = painter.getTerrainDataForTile(coord, isRenderingToTexture);
 		const projectionData = transform.getProjectionData({
@@ -17746,7 +18978,7 @@ function drawDepth(painter, terrain) {
 	const depthMode = new DepthMode(gl.LEQUAL, DepthMode.ReadWrite, [0, 1]);
 	const tiles = terrain.tileManager.getRenderableTiles();
 	const program = painter.useProgram("terrainDepth");
-	context.bindFramebuffer.set(terrain.getFramebuffer("depth").framebuffer);
+	context.bindFramebuffer.set(terrain.getFramebuffer().framebuffer);
 	context.viewport.set([
 		0,
 		0,
@@ -17754,7 +18986,7 @@ function drawDepth(painter, terrain) {
 		painter.height / devicePixelRatio
 	]);
 	context.clear({
-		color: Color.transparent,
+		color: Color.white,
 		depth: 1
 	});
 	for (const tile of tiles) {
@@ -17776,54 +19008,6 @@ function drawDepth(painter, terrain) {
 		painter.height
 	]);
 }
-/**
-* Redraw the Coords Framebuffers
-* @param painter - the painter
-* @param terrain - the terrain
-*/
-function drawCoords(painter, terrain) {
-	const context = painter.context;
-	const gl = context.gl;
-	const tr = painter.transform;
-	const colorMode = ColorMode.unblended;
-	const depthMode = new DepthMode(gl.LEQUAL, DepthMode.ReadWrite, [0, 1]);
-	const coords = terrain.getCoordsTexture();
-	const tiles = terrain.tileManager.getRenderableTiles();
-	const program = painter.useProgram("terrainCoords");
-	context.bindFramebuffer.set(terrain.getFramebuffer("coords").framebuffer);
-	context.viewport.set([
-		0,
-		0,
-		painter.width / devicePixelRatio,
-		painter.height / devicePixelRatio
-	]);
-	context.clear({
-		color: Color.transparent,
-		depth: 1
-	});
-	terrain.coordsIndex = [];
-	for (const tile of tiles) {
-		const mesh = terrain.getTerrainMesh(tile.tileID);
-		const terrainData = terrain.getTerrainData(tile.tileID);
-		context.activeTexture.set(gl.TEXTURE0);
-		gl.bindTexture(gl.TEXTURE_2D, coords.texture);
-		const uniformValues = terrainCoordsUniformValues(255 - terrain.coordsIndex.length, terrain.getSkirtLength(tr.zoom));
-		const projectionData = tr.getProjectionData({
-			overscaledTileID: tile.tileID,
-			applyTerrainMatrix: false,
-			applyGlobeMatrix: true
-		});
-		program.draw(context, gl.TRIANGLES, depthMode, StencilMode.disabled, colorMode, CullFaceMode.backCCW, uniformValues, terrainData, projectionData, "terrain", mesh.vertexBuffer, mesh.indexBuffer, mesh.segments);
-		terrain.coordsIndex.push(tile.tileID.key);
-	}
-	context.bindFramebuffer.set(null);
-	context.viewport.set([
-		0,
-		0,
-		painter.width,
-		painter.height
-	]);
-}
 function drawTerrain(painter, terrain, tiles, renderOptions) {
 	const { isRenderingGlobe } = renderOptions;
 	const context = painter.context;
@@ -17952,8 +19136,7 @@ const webglDrawFunctions = {
 	custom: drawCustom,
 	debug: drawDebug,
 	debugPadding: drawDebugPadding,
-	terrainDepth: drawDepth,
-	terrainCoords: drawCoords
+	terrainDepth: drawDepth
 };
 //#endregion
 //#region src/render/painter.ts
@@ -17972,7 +19155,6 @@ var Painter = class Painter {
 		this._rttSharedFbo = null;
 		this.terrainFacilitator = {
 			depthDirty: true,
-			coordsDirty: false,
 			matrix: identity(/* @__PURE__ */ new Float64Array(16)),
 			renderTime: 0
 		};
@@ -18273,7 +19455,7 @@ var Painter = class Painter {
 				break;
 			}
 		}
-		this.maybeDrawDepth(false);
+		this.maybeDrawDepth();
 		if (this.renderToTexture) {
 			this.renderToTexture.prepareForRender(this.style, this.transform.zoom);
 			this.opaquePassCutoff = 0;
@@ -18335,30 +19517,20 @@ var Painter = class Painter {
 	}
 	/**
 	* Update the depth framebuffer if the camera has moved or tiles have reloaded.
-	* Marks coords as depthDirty so they are re-rendered on next demand.
 	*/
-	maybeDrawDepth(requireExact) {
+	maybeDrawDepth() {
 		if (!this.style?.map?.terrain) return;
 		const prevMatrix = this.terrainFacilitator.matrix;
 		const currMatrix = this.transform.modelViewProjectionMatrix;
 		let doUpdate = this.terrainFacilitator.depthDirty;
-		doUpdate ||= requireExact ? !exactEquals(prevMatrix, currMatrix) : !equals(prevMatrix, currMatrix);
+		doUpdate ||= !equals(prevMatrix, currMatrix);
 		doUpdate ||= this.style.map.terrain.tileManager.anyTilesAfterTime(this.terrainFacilitator.renderTime);
 		if (!doUpdate) return;
 		copy(prevMatrix, currMatrix);
 		this.terrainFacilitator.renderTime = now();
 		this.terrainFacilitator.depthDirty = false;
-		this.terrainFacilitator.coordsDirty = true;
 		this.drawFunctions.terrainDepth(this, this.style.map.terrain);
 	}
-	/**
-	* Render the coords framebuffer if it is coordsDirty
-	*/
-	maybeDrawCoords() {
-		if (!this.style?.map?.terrain || !this.terrainFacilitator.coordsDirty) return;
-		this.terrainFacilitator.coordsDirty = false;
-		this.drawFunctions.terrainCoords(this, this.style.map.terrain);
-	}
 	renderLayer(painter, tileManager, layer, coords, renderOptions) {
 		if (layer.isHidden(this.transform.zoom)) return;
 		if (layer.type !== "background" && layer.type !== "custom" && !(coords || []).length) return;
@@ -18551,7 +19723,8 @@ var Painter = class Painter {
 //#endregion
 //#region src/util/gpu_initialization_error.ts
 /**
-* Thrown (via the map's `error` event) when a GPU rendering context cannot be created.
+* Thrown by the `Map` constructor when a GPU rendering context cannot be created,
+* or fired via the map's `error` event when recreating the context after a `webglcontextrestored` fails.
 *
 * Carries the canvas attributes that were requested and, when the browser provided one,
 * the originating `webglcontextcreationerror` `statusMessage`.
@@ -21094,7 +22267,7 @@ var HandlerManager = class {
 	_terrainGestureElevation(terrain, around, aroundOnSurface, tr, combinedEventsInProgress) {
 		if (!aroundOnSurface) return;
 		if (!this._terrainMovement && (combinedEventsInProgress.drag || combinedEventsInProgress.zoom)) {
-			const anchor = terrain.pointCoordinate(around);
+			const anchor = tr.screenTerrainPointToMercatorCoordinate(around, terrain);
 			this._terrainGestureAnchorElevation = anchor ? anchor.z : null;
 		}
 		if (this._terrainGestureAnchorElevation === null) return;
@@ -21430,7 +22603,7 @@ var Camera = class extends Evented {
 		let bearingChanged = false, pitchChanged = false;
 		let rollChanged = false;
 		const oldZoom = tr.zoom;
-		if (this.terrain) tr.setElevation(this.terrain.getElevationForLngLatZoom(options.center ? LngLat.convert(options.center) : tr.center, options.zoom || tr.tileZoom));
+		if (this.terrain) tr.setElevation(this.terrain.getElevationForLngLat(options.center ? LngLat.convert(options.center) : tr.center, tr));
 		this.cameraHelper.handleJumpToCenterZoom(tr, options);
 		const zoomChanged = tr.zoom !== oldZoom;
 		if ("elevation" in options && tr.elevation !== +options.elevation) tr.setElevation(+options.elevation);
@@ -21531,1232 +22704,532 @@ var Camera = class extends Evented {
 		this._easeId = options.easeId;
 		this._prepareEase(eventData, options.noMoveStart, currently);
 		if (this.terrain) this._prepareElevation(easeHandler.elevationCenter);
-		this._ease((k) => {
-			easeHandler.easeFunc(k);
-			if (this.terrain && !options.freezeElevation) this._updateElevation(k);
-			this.applyUpdatedTransform(tr);
-			this._fireMoveEvents(eventData);
-		}, (interruptingEaseId) => {
-			if (this.terrain && options.freezeElevation) this._finalizeElevation();
-			this._afterEase(eventData, interruptingEaseId);
-		}, options);
-		return this;
-	}
-	_prepareEase(eventData, noMoveStart, currently = {}) {
-		this._moving = true;
-		if (!noMoveStart && !currently.moving) this.fire(new MapMovementEvent("movestart", eventData));
-		if (this._zooming && !currently.zooming) this.fire(new MapMovementEvent("zoomstart", eventData));
-		if (this._rotating && !currently.rotating) this.fire(new MapMovementEvent("rotatestart", eventData));
-		if (this._pitching && !currently.pitching) this.fire(new MapMovementEvent("pitchstart", eventData));
-		if (this._rolling && !currently.rolling) this.fire(new MapMovementEvent("rollstart", eventData));
-	}
-	_prepareElevation(center) {
-		this._elevationCenter = center;
-		this._elevationStart = this.transform.elevation;
-		this._elevationTarget = this.terrain.getElevationForLngLatZoom(center, this.transform.tileZoom);
-		this.elevationFreeze = true;
-	}
-	_updateElevation(k) {
-		if (this._elevationStart === void 0 || this._elevationCenter === void 0) this._prepareElevation(this.transform.center);
-		this.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom));
-		const elevation = this.terrain.getElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);
-		if (k < 1 && elevation !== this._elevationTarget) {
-			const pitch1 = this._elevationTarget - this._elevationStart;
-			const pitch2 = (elevation - (pitch1 * k + this._elevationStart)) / (1 - k);
-			this._elevationStart += k * (pitch1 - pitch2);
-			this._elevationTarget = elevation;
-		}
-		this.transform.setElevation(interpolateFactory.number(this._elevationStart, this._elevationTarget, k));
-	}
-	_finalizeElevation() {
-		this.elevationFreeze = false;
-		if (this.getCenterClampedToGround()) this.transform.recalculateZoomAndCenter(this.terrain);
-	}
-	/**
-	* @internal
-	* Called when the camera is about to be manipulated.
-	* If `transformCameraUpdate` is specified or terrain is enabled, a copy of
-	* the current transform is created to track the accumulated changes.
-	* This underlying transform represents the "desired state" proposed by input handlers / animations / UI controls.
-	* It may differ from the state used for rendering (`this.transform`).
-	* @returns Transform to apply changes to
-	*/
-	getTransformForUpdate() {
-		if (!this.transformCameraUpdate && !this.terrain) return this.transform;
-		this._requestedCameraState ||= this.transform.clone();
-		return this._requestedCameraState;
-	}
-	/**
-	* @internal
-	* Checks the given transform for the camera being below terrain surface and
-	* returns new pitch and zoom to fix that.
-	*
-	* With the new pitch and zoom, the camera will be at the same ground
-	* position but at higher altitude. It will still point to the same spot on
-	* the map.
-	*
-	* @param tr - The transform to check.
-	*/
-	_elevateCameraIfInsideTerrain(tr) {
-		if (!this.terrain && tr.elevation >= 0 && tr.pitch <= 90) return {};
-		const cameraLngLat = tr.getCameraLngLat();
-		const cameraAltitude = tr.getCameraAltitude();
-		const minAltitude = this.terrain ? this.terrain.getElevationForLngLatZoom(cameraLngLat, tr.zoom) : 0;
-		if (cameraAltitude < minAltitude) {
-			const newCamera = this.calculateCameraOptionsFromTo(cameraLngLat, minAltitude, tr.center, tr.elevation);
-			return {
-				pitch: newCamera.pitch,
-				zoom: newCamera.zoom
-			};
-		}
-		return {};
-	}
-	/**
-	* @internal
-	* Called after the camera is done being manipulated.
-	* @param tr - the requested camera end state
-	* If the camera is inside terrain, it gets elevated.
-	* Call `transformCameraUpdate` if present, and then apply the "approved" changes.
-	*/
-	applyUpdatedTransform(tr) {
-		const modifiers = [];
-		modifiers.push((tr) => this._elevateCameraIfInsideTerrain(tr));
-		if (this.transformCameraUpdate) modifiers.push((tr) => this.transformCameraUpdate(tr));
-		if (!modifiers.length) return;
-		const finalTransform = tr.clone();
-		for (const modifier of modifiers) {
-			const nextTransform = finalTransform.clone();
-			const { center, zoom, roll, pitch, bearing, elevation } = modifier(nextTransform);
-			if (center) nextTransform.setCenter(center);
-			if (elevation !== void 0) nextTransform.setElevation(elevation);
-			if (zoom !== void 0) nextTransform.setZoom(zoom);
-			if (roll !== void 0) nextTransform.setRoll(roll);
-			if (pitch !== void 0) nextTransform.setPitch(pitch);
-			if (bearing !== void 0) nextTransform.setBearing(bearing);
-			finalTransform.apply(nextTransform, false);
-		}
-		this.transform.apply(finalTransform, false);
-	}
-	_fireMoveEvents(eventData) {
-		this.fire(new MapMovementEvent("move", eventData));
-		if (this._zooming) this.fire(new MapMovementEvent("zoom", eventData));
-		if (this._rotating) this.fire(new MapMovementEvent("rotate", eventData));
-		if (this._pitching) this.fire(new MapMovementEvent("pitch", eventData));
-		if (this._rolling) this.fire(new MapMovementEvent("roll", eventData));
-	}
-	_afterEase(eventData, easeId) {
-		if (this._easeId && easeId && this._easeId === easeId) return;
-		delete this._easeId;
-		const wasZooming = this._zooming;
-		const wasRotating = this._rotating;
-		const wasPitching = this._pitching;
-		const wasRolling = this._rolling;
-		this._moving = false;
-		this._zooming = false;
-		this._rotating = false;
-		this._pitching = false;
-		this._rolling = false;
-		this._padding = false;
-		if (wasZooming) this.fire(new MapMovementEvent("zoomend", eventData));
-		if (wasRotating) this.fire(new MapMovementEvent("rotateend", eventData));
-		if (wasPitching) this.fire(new MapMovementEvent("pitchend", eventData));
-		if (wasRolling) this.fire(new MapMovementEvent("rollend", eventData));
-		this.fire(new MapMovementEvent("moveend", eventData));
-	}
-	flyTo(options, eventData) {
-		if (!options.essential && browser.prefersReducedMotion) {
-			const coercedOptions = pick(options, [
-				"center",
-				"zoom",
-				"bearing",
-				"pitch",
-				"roll",
-				"elevation",
-				"padding"
-			]);
-			return this.jumpTo(coercedOptions, eventData);
-		}
-		this.stop();
-		options = extend({
-			offset: [0, 0],
-			speed: 1.2,
-			curve: 1.42,
-			easing: defaultEasing
-		}, options);
-		if ("zoom" in options && this._zoomSnap) options.zoom = evaluateZoomSnap(options.zoom, this._zoomSnap);
-		const tr = this.getTransformForUpdate(), startBearing = tr.bearing, startPitch = tr.pitch, startRoll = tr.roll, startPadding = tr.padding;
-		const bearing = "bearing" in options ? this._normalizeBearing(options.bearing, startBearing) : startBearing;
-		const pitch = "pitch" in options ? +options.pitch : startPitch;
-		const roll = "roll" in options ? this._normalizeBearing(options.roll, startRoll) : startRoll;
-		const padding = "padding" in options ? options.padding : tr.padding;
-		const offsetAsPoint = Point.convert(options.offset);
-		let pointAtOffset = tr.centerPoint.add(offsetAsPoint);
-		const locationAtOffset = tr.screenPointToLocation(pointAtOffset);
-		const flyToHandler = this.cameraHelper.handleFlyTo(tr, {
-			bearing,
-			pitch,
-			roll,
-			padding,
-			locationAtOffset,
-			offsetAsPoint,
-			center: options.center,
-			minZoom: options.minZoom,
-			zoom: options.zoom
-		});
-		let rho = options.curve;
-		const w0 = Math.max(tr.width, tr.height);
-		const w1 = w0 / flyToHandler.scaleOfZoom;
-		const u1 = flyToHandler.pixelPathLength;
-		const wMax = w0 / flyToHandler.scaleOfMinZoom;
-		rho = Math.min(rho, Math.sqrt(wMax / u1 * 2));
-		const rho2 = rho * rho;
-		/**
-		* rᵢ: Returns the zoom-out factor at one end of the animation.
-		*
-		* @param descent - `true` for the descent, `false` for the ascent
-		*/
-		function zoomOutFactor(descent) {
-			const b = (w1 * w1 - w0 * w0 + (descent ? -1 : 1) * rho2 * rho2 * u1 * u1) / (2 * (descent ? w1 : w0) * rho2 * u1);
-			return Math.log(Math.sqrt(b * b + 1) - b);
-		}
-		function sinh(n) {
-			return (Math.exp(n) - Math.exp(-n)) / 2;
-		}
-		function cosh(n) {
-			return (Math.exp(n) + Math.exp(-n)) / 2;
-		}
-		function tanh(n) {
-			return sinh(n) / cosh(n);
-		}
-		const r0 = zoomOutFactor(false);
-		let w = function(s) {
-			return cosh(r0) / cosh(r0 + rho * s);
-		};
-		let u = function(s) {
-			return w0 * ((cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2) / u1;
-		};
-		let S = (zoomOutFactor(true) - r0) / rho;
-		if (Math.abs(u1) < 2e-6 || !isFinite(S)) {
-			if (Math.abs(w0 - w1) < 1e-6) return this.easeTo(options, eventData);
-			const k = w1 < w0 ? -1 : 1;
-			S = Math.abs(Math.log(w1 / w0)) / rho;
-			u = () => 0;
-			w = (s) => Math.exp(k * rho * s);
-		}
-		if ("duration" in options) options.duration = +options.duration;
-		else {
-			const V = "screenSpeed" in options ? +options.screenSpeed / rho : +options.speed;
-			options.duration = 1e3 * S / V;
-		}
-		if (options.maxDuration && options.duration > options.maxDuration) options.duration = 0;
-		this._zooming = true;
-		this._rotating = startBearing !== bearing;
-		this._pitching = pitch !== startPitch;
-		this._rolling = roll !== startRoll;
-		this._padding = !tr.isPaddingEqual(padding);
-		this._prepareEase(eventData, false);
-		if (this.terrain) this._prepareElevation(flyToHandler.targetCenter);
-		this._ease((k) => {
-			const s = k * S;
-			const scale = 1 / w(s);
-			const centerFactor = u(s);
-			if (this._rotating) tr.setBearing(interpolateFactory.number(startBearing, bearing, k));
-			if (this._pitching) tr.setPitch(interpolateFactory.number(startPitch, pitch, k));
-			if (this._rolling) tr.setRoll(interpolateFactory.number(startRoll, roll, k));
-			if (this._padding) {
-				tr.interpolatePadding(startPadding, padding, k);
-				pointAtOffset = tr.centerPoint.add(offsetAsPoint);
-			}
-			flyToHandler.easeFunc(k, scale, centerFactor, pointAtOffset);
-			if (this.terrain && !options.freezeElevation) this._updateElevation(k);
-			this.applyUpdatedTransform(tr);
-			this._fireMoveEvents(eventData);
-		}, () => {
-			if (this.terrain && options.freezeElevation) this._finalizeElevation();
-			this._afterEase(eventData);
-		}, options);
-		return this;
-	}
-	isEasing() {
-		return !!this._easeFrameId;
-	}
-	stop(allowGestures) {
-		return this._stop(allowGestures);
-	}
-	_stop(allowGestures, easeId) {
-		if (this._easeFrameId) {
-			this._cancelRenderFrame(this._easeFrameId);
-			delete this._easeFrameId;
-			delete this._onEaseFrame;
-		}
-		if (this._onEaseEnd) {
-			const onEaseEnd = this._onEaseEnd;
-			delete this._onEaseEnd;
-			onEaseEnd.call(this, easeId);
-		}
-		if (!allowGestures) this._stopHandlers();
-		return this;
-	}
-	_ease(frame, finish, options) {
-		if (options.animate === false || options.duration === 0) {
-			frame(1);
-			finish();
-		} else {
-			this._easeStart = now();
-			this._easeOptions = options;
-			this._onEaseFrame = frame;
-			this._onEaseEnd = finish;
-			this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback);
-		}
-	}
-	_normalizeBearing(bearing, currentBearing) {
-		bearing = wrap(bearing, -180, 180);
-		const diff = Math.abs(bearing - currentBearing);
-		if (Math.abs(bearing - 360 - currentBearing) < diff) bearing -= 360;
-		if (Math.abs(bearing + 360 - currentBearing) < diff) bearing += 360;
-		return bearing;
-	}
-	isMoving() {
-		return this._moving;
-	}
-	isZooming() {
-		return this._zooming;
-	}
-	isRotating() {
-		return this._rotating;
-	}
-};
-//#endregion
-//#region src/ui/control/attribution_control.ts
-const defaultAttributionControlOptions = {
-	compact: true,
-	customAttribution: "<a href=\"https://maplibre.org/\" target=\"_blank\">MapLibre</a>"
-};
-/**
-* An `AttributionControl` control presents the map's attribution information. By default, the attribution control is expanded (regardless of map width).
-* @group Markers and Controls
-* @example
-* ```ts
-* let map = new Map({attributionControl: false})
-*     .addControl(new AttributionControl({
-*         compact: true
-*     }));
-* ```
-* @see [Change the default position for attribution](https://maplibre.org/maplibre-gl-js/docs/examples/change-the-default-position-for-attribution/)
-*/
-var AttributionControl = class {
-	/**
-	* @param options - the attribution options
-	*/
-	constructor(options = defaultAttributionControlOptions) {
-		this._toggleAttribution = () => {
-			if (this._container.classList.contains("maplibregl-compact")) {
-				if (this._container.classList.contains("maplibregl-compact-show")) {
-					this._container.setAttribute("open", "");
-					this._container.classList.remove("maplibregl-compact-show");
-				} else {
-					this._container.classList.add("maplibregl-compact-show");
-					this._container.removeAttribute("open");
-				}
-			}
-		};
-		this._updateData = (e) => {
-			if (e && (e.type === "terrain" || e.dataType === "style" || e.dataType === "source" && (e.sourceDataType === "metadata" || e.sourceDataType === "visibility"))) this._updateAttributions();
-		};
-		this._updateCompact = () => {
-			if (this._map.getCanvasContainer().offsetWidth <= 640 || this._compact) {
-				if (this._compact === false) this._container.setAttribute("open", "");
-				else if (!this._container.classList.contains("maplibregl-compact") && !this._container.classList.contains("maplibregl-attrib-empty")) {
-					this._container.setAttribute("open", "");
-					this._container.classList.add("maplibregl-compact", "maplibregl-compact-show");
-				}
-			} else {
-				this._container.setAttribute("open", "");
-				if (this._container.classList.contains("maplibregl-compact")) this._container.classList.remove("maplibregl-compact", "maplibregl-compact-show");
-			}
-		};
-		this._updateCompactMinimize = () => {
-			if (this._container.classList.contains("maplibregl-compact")) {
-				if (this._container.classList.contains("maplibregl-compact-show")) this._container.classList.remove("maplibregl-compact-show");
-			}
-		};
-		this.options = options;
-	}
-	getDefaultPosition() {
-		return "bottom-right";
-	}
-	/** {@inheritDoc IControl.onAdd} */
-	onAdd(map) {
-		this._map = map;
-		this._compact = this.options.compact;
-		this._container = DOM.create("details", "maplibregl-ctrl maplibregl-ctrl-attrib");
-		this._compactButton = DOM.create("summary", "maplibregl-ctrl-attrib-button", this._container);
-		this._compactButton.addEventListener("click", this._toggleAttribution);
-		this._setElementTitle(this._compactButton, "ToggleAttribution");
-		this._innerContainer = DOM.create("div", "maplibregl-ctrl-attrib-inner", this._container);
-		this._updateAttributions();
-		this._updateCompact();
-		this._map.on("styledata", this._updateData);
-		this._map.on("sourcedata", this._updateData);
-		this._map.on("terrain", this._updateData);
-		this._map.on("resize", this._updateCompact);
-		this._map.on("drag", this._updateCompactMinimize);
-		return this._container;
-	}
-	/** {@inheritDoc IControl.onRemove} */
-	onRemove() {
-		this._container.remove();
-		this._map.off("styledata", this._updateData);
-		this._map.off("sourcedata", this._updateData);
-		this._map.off("terrain", this._updateData);
-		this._map.off("resize", this._updateCompact);
-		this._map.off("drag", this._updateCompactMinimize);
-		this._map = void 0;
-		this._compact = void 0;
-		this._attribHTML = void 0;
-	}
-	_setElementTitle(element, title) {
-		const str = this._map._getUIString(`AttributionControl.${title}`);
-		element.title = str;
-		element.setAttribute("aria-label", str);
-	}
-	_updateAttributions() {
-		if (!this._map.style) return;
-		let attributions = [];
-		if (this.options.customAttribution) {
-			if (Array.isArray(this.options.customAttribution)) attributions = attributions.concat(this.options.customAttribution.map((attribution) => {
-				if (typeof attribution !== "string") return "";
-				return attribution;
-			}));
-			else if (typeof this.options.customAttribution === "string") attributions.push(this.options.customAttribution);
-		}
-		if (this._map.style.stylesheet) {
-			const stylesheet = this._map.style.stylesheet;
-			this.styleOwner = stylesheet.owner;
-			this.styleId = stylesheet.id;
-		}
-		const tileManagers = this._map.style.tileManagers;
-		for (const id in tileManagers) {
-			const tileManager = tileManagers[id];
-			if (tileManager.used || tileManager.usedForTerrain) {
-				const source = tileManager.getSource();
-				if (source.attribution && !attributions.includes(source.attribution)) attributions.push(source.attribution);
-			}
-		}
-		attributions = attributions.filter((e) => String(e).trim());
-		attributions.sort((a, b) => a.length - b.length);
-		attributions = attributions.filter((attrib, i) => {
-			for (let j = i + 1; j < attributions.length; j++) if (attributions[j].includes(attrib)) return false;
-			return true;
-		});
-		const attribHTML = attributions.join(" | ");
-		if (attribHTML === this._attribHTML) return;
-		this._attribHTML = attribHTML;
-		if (attributions.length) {
-			this._innerContainer.innerHTML = DOM.sanitize(attribHTML);
-			this._container.classList.remove("maplibregl-attrib-empty");
-		} else this._container.classList.add("maplibregl-attrib-empty");
-		this._updateCompact();
-		this._editLink = null;
-	}
-};
-//#endregion
-//#region src/ui/control/logo_control.ts
-/**
-* A `LogoControl` is a control that adds the watermark.
-*
-* @group Markers and Controls
-*
-* @example
-* ```ts
-* map.addControl(new LogoControl({compact: false}));
-* ```
-**/
-var LogoControl = class {
-	/**
-	* @param options - the control's options
-	*/
-	constructor(options = {}) {
-		this._updateCompact = () => {
-			const containerChildren = this._container.children;
-			if (containerChildren.length) {
-				const anchor = containerChildren[0];
-				if (this._map.getCanvasContainer().offsetWidth <= 640 || this._compact) {
-					if (this._compact !== false) anchor.classList.add("maplibregl-compact");
-				} else anchor.classList.remove("maplibregl-compact");
-			}
-		};
-		this.options = options;
-	}
-	getDefaultPosition() {
-		return "bottom-left";
-	}
-	/** {@inheritDoc IControl.onAdd} */
-	onAdd(map) {
-		this._map = map;
-		this._compact = this.options?.compact;
-		this._container = DOM.create("div", "maplibregl-ctrl");
-		const anchor = DOM.create("a", "maplibregl-ctrl-logo");
-		anchor.target = "_blank";
-		anchor.rel = "noopener nofollow";
-		anchor.href = "https://maplibre.org/";
-		anchor.setAttribute("aria-label", this._map._getUIString("LogoControl.Title"));
-		anchor.setAttribute("rel", "noopener nofollow");
-		this._container.appendChild(anchor);
-		this._container.style.display = "block";
-		this._map.on("resize", this._updateCompact);
-		this._updateCompact();
-		return this._container;
-	}
-	/** {@inheritDoc IControl.onRemove} */
-	onRemove() {
-		this._container.remove();
-		this._map.off("resize", this._updateCompact);
-		this._map = void 0;
-		this._compact = void 0;
-	}
-};
-//#endregion
-//#region src/util/task_queue.ts
-var TaskQueue = class {
-	constructor() {
-		this._queue = [];
-		this._id = 0;
-		this._cleared = false;
-		this._currentlyRunning = false;
-	}
-	add(callback) {
-		const id = ++this._id;
-		this._queue.push({
-			callback,
-			id,
-			cancelled: false
-		});
-		return id;
-	}
-	remove(id) {
-		const running = this._currentlyRunning;
-		const queue = running ? this._queue.concat(running) : this._queue;
-		for (const task of queue) if (task.id === id) {
-			task.cancelled = true;
-			return;
-		}
-	}
-	run(timeStamp = 0) {
-		if (this._currentlyRunning) throw new Error("Attempting to run(), but is already running.");
-		const queue = this._currentlyRunning = this._queue;
-		this._queue = [];
-		for (const task of queue) {
-			if (task.cancelled) continue;
-			task.callback(timeStamp);
-			if (this._cleared) break;
-		}
-		this._cleared = false;
-		this._currentlyRunning = false;
-	}
-	clear() {
-		if (this._currentlyRunning) this._cleared = true;
-		this._queue = [];
-	}
-};
-//#endregion
-//#region src/data/pos3d_attributes.ts
-const pos3dAttributes = createLayout([{
-	name: "a_pos3d",
-	type: "Int16",
-	components: 3
-}]);
-//#endregion
-//#region src/tile/terrain_tile_manager.ts
-/**
-* @internal
-* This class is a helper for the Terrain-class, it:
-*
-* - loads raster-dem tiles
-* - manages all renderToTexture tiles.
-* - caches previous rendered tiles.
-* - finds all necessary renderToTexture tiles for a OverscaledTileID area
-* - finds the corresponding raster-dem tile for OverscaledTileID
-*/
-var TerrainTileManager = class extends Evented {
-	constructor(tileManager) {
-		super();
-		this._lastTilesetChange = now();
-		this.tileManager = tileManager;
-		this._tiles = {};
-		this._renderableTilesKeys = [];
-		this._sourceTileCache = {};
-		this.minzoom = 0;
-		this.maxzoom = 22;
-		this.deltaZoom = 1;
-		this.tileSize = tileManager._source.tileSize * 2 ** this.deltaZoom;
-		tileManager.usedForTerrain = true;
-		tileManager.tileSize = this.tileSize;
-	}
-	destruct() {
-		this.tileManager.usedForTerrain = false;
-		this.tileManager.tileSize = null;
-		this.releaseAllRTT();
-	}
-	getSource() {
-		return this.tileManager._source;
-	}
-	/**
-	* Load Terrain Tiles, create internal render-to-texture tiles, free GPU memory.
-	* @param transform - the operation to do
-	* @param terrain - the terrain
-	*/
-	update(transform, terrain) {
-		this.tileManager.update(transform, terrain);
-		this._renderableTilesKeys = [];
-		const keys = {};
-		for (const tileID of coveringTiles(transform, {
-			tileSize: this.tileSize,
-			minzoom: this.minzoom,
-			maxzoom: this.maxzoom,
-			reparseOverscaled: false,
-			terrain,
-			calculateTileZoom: this.tileManager._source.calculateTileZoom
-		})) {
-			keys[tileID.key] = true;
-			this._renderableTilesKeys.push(tileID.key);
-			if (!this._tiles[tileID.key]) {
-				tileID.terrainRttPosMatrix32f = /* @__PURE__ */ new Float32Array(16);
-				ortho(tileID.terrainRttPosMatrix32f, 0, EXTENT, EXTENT, 0, 0, 1);
-				this._tiles[tileID.key] = new Tile(tileID, this.tileSize);
-				this._lastTilesetChange = now();
-			}
-		}
-		for (const key in this._tiles) if (!keys[key]) {
-			this._tiles[key].releaseRTT(this.tileManager.map.painter);
-			delete this._tiles[key];
-		}
+		this._ease((k) => {
+			easeHandler.easeFunc(k);
+			if (this.terrain && !options.freezeElevation) this._updateElevation(k);
+			this.applyUpdatedTransform(tr);
+			this._fireMoveEvents(eventData);
+		}, (interruptingEaseId) => {
+			if (this.terrain && options.freezeElevation) this._finalizeElevation();
+			this._afterEase(eventData, interruptingEaseId);
+		}, options);
+		return this;
 	}
-	/**
-	* Release the RTT objects for `tileID` (and its ancestors/descendants),
-	*/
-	releaseRTT(tileID) {
-		for (const key in this._tiles) {
-			const tile = this._tiles[key];
-			if (tile.tileID.equals(tileID) || tile.tileID.isChildOf(tileID) || tileID.isChildOf(tile.tileID)) tile.releaseRTT(this.tileManager.map.painter);
-		}
+	_prepareEase(eventData, noMoveStart, currently = {}) {
+		this._moving = true;
+		if (!noMoveStart && !currently.moving) this.fire(new MapMovementEvent("movestart", eventData));
+		if (this._zooming && !currently.zooming) this.fire(new MapMovementEvent("zoomstart", eventData));
+		if (this._rotating && !currently.rotating) this.fire(new MapMovementEvent("rotatestart", eventData));
+		if (this._pitching && !currently.pitching) this.fire(new MapMovementEvent("pitchstart", eventData));
+		if (this._rolling && !currently.rolling) this.fire(new MapMovementEvent("rollstart", eventData));
 	}
-	/**
-	* Release the A RTT objects for all tiles.
-	*/
-	releaseAllRTT() {
-		for (const key in this._tiles) this._tiles[key].releaseRTT(this.tileManager.map.painter);
+	_prepareElevation(center) {
+		this._elevationCenter = center;
+		this._elevationStart = this.transform.elevation;
+		this._elevationTarget = this.terrain.getElevationForLngLat(center, this.transform);
+		this.elevationFreeze = true;
 	}
-	/**
-	* get a list of tiles, which are loaded and should be rendered in the current scene
-	* @returns the renderable tiles
-	*/
-	getRenderableTiles() {
-		return this._renderableTilesKeys.map((key) => this.getTileByID(key));
+	_updateElevation(k) {
+		if (this._elevationStart === void 0 || this._elevationCenter === void 0) this._prepareElevation(this.transform.center);
+		this.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom));
+		const elevation = this.terrain.getElevationForLngLat(this._elevationCenter, this.transform);
+		if (k < 1 && elevation !== this._elevationTarget) {
+			const pitch1 = this._elevationTarget - this._elevationStart;
+			const pitch2 = (elevation - (pitch1 * k + this._elevationStart)) / (1 - k);
+			this._elevationStart += k * (pitch1 - pitch2);
+			this._elevationTarget = elevation;
+		}
+		this.transform.setElevation(interpolateFactory.number(this._elevationStart, this._elevationTarget, k));
 	}
-	/**
-	* get terrain tile by the TileID key
-	* @param id - the tile id
-	* @returns the tile
-	*/
-	getTileByID(id) {
-		return this._tiles[id];
+	_finalizeElevation() {
+		this.elevationFreeze = false;
+		if (this.getCenterClampedToGround()) this.transform.recalculateZoomAndCenter(this.terrain);
 	}
 	/**
-	* Searches for the corresponding current renderable terrain-tiles
-	* @param tileID - the tile to look for
-	* @returns the tiles that were found
+	* @internal
+	* Called when the camera is about to be manipulated.
+	* If `transformCameraUpdate` is specified or terrain is enabled, a copy of
+	* the current transform is created to track the accumulated changes.
+	* This underlying transform represents the "desired state" proposed by input handlers / animations / UI controls.
+	* It may differ from the state used for rendering (`this.transform`).
+	* @returns Transform to apply changes to
 	*/
-	getTerrainCoords(tileID, terrainTileRanges) {
-		if (terrainTileRanges) return this._getTerrainCoordsForTileRanges(tileID, terrainTileRanges);
-		else return this._getTerrainCoordsForRegularTile(tileID);
+	getTransformForUpdate() {
+		if (!this.transformCameraUpdate && !this.terrain) return this.transform;
+		this._requestedCameraState ||= this.transform.clone();
+		return this._requestedCameraState;
 	}
 	/**
-	* Searches for the corresponding current renderable terrain-tiles.
-	* Includes terrain tiles that are either:
-	* - the same as the tileID
-	* - a parent of the tileID
-	* - a child of the tileID
-	* @param tileID - the tile to look for
-	* @returns the tiles that were found
+	* @internal
+	* Checks the given transform for the camera being below terrain surface and
+	* returns new pitch and zoom to fix that.
+	*
+	* With the new pitch and zoom, the camera will be at the same ground
+	* position but at higher altitude. It will still point to the same spot on
+	* the map.
+	*
+	* @param tr - The transform to check.
 	*/
-	_getTerrainCoordsForRegularTile(tileID) {
-		const coords = {};
-		for (const key of this._renderableTilesKeys) {
-			const terrainTileID = this._tiles[key].tileID;
-			const coord = tileID.clone();
-			const mat = createMat4f64();
-			if (terrainTileID.canonical.equals(tileID.canonical)) ortho(mat, 0, EXTENT, EXTENT, 0, 0, 1);
-			else if (terrainTileID.canonical.isChildOf(tileID.canonical)) {
-				const dz = terrainTileID.canonical.z - tileID.canonical.z;
-				const dx = terrainTileID.canonical.x - (terrainTileID.canonical.x >> dz << dz);
-				const dy = terrainTileID.canonical.y - (terrainTileID.canonical.y >> dz << dz);
-				const size = EXTENT >> dz;
-				ortho(mat, 0, size, size, 0, 0, 1);
-				translate(mat, mat, [
-					-dx * size,
-					-dy * size,
-					0
-				]);
-			} else if (tileID.canonical.isChildOf(terrainTileID.canonical)) {
-				const dz = tileID.canonical.z - terrainTileID.canonical.z;
-				const dx = tileID.canonical.x - (tileID.canonical.x >> dz << dz);
-				const dy = tileID.canonical.y - (tileID.canonical.y >> dz << dz);
-				const size = EXTENT >> dz;
-				ortho(mat, 0, EXTENT, EXTENT, 0, 0, 1);
-				translate(mat, mat, [
-					dx * size,
-					dy * size,
-					0
-				]);
-				scale(mat, mat, [
-					1 / 2 ** dz,
-					1 / 2 ** dz,
-					0
-				]);
-			} else continue;
-			coord.terrainRttPosMatrix32f = new Float32Array(mat);
-			coords[key] = coord;
+	_elevateCameraIfInsideTerrain(tr) {
+		if (!this.terrain && tr.elevation >= 0 && tr.pitch <= 90) return {};
+		const cameraLngLat = tr.getCameraLngLat();
+		const cameraAltitude = tr.getCameraAltitude();
+		const minAltitude = this.terrain ? this.terrain.getElevationForLngLatZoom(cameraLngLat, tr.zoom) : 0;
+		if (cameraAltitude < minAltitude) {
+			const newCamera = this.calculateCameraOptionsFromTo(cameraLngLat, minAltitude, tr.center, tr.elevation);
+			return {
+				pitch: newCamera.pitch,
+				zoom: newCamera.zoom
+			};
 		}
-		return coords;
+		return {};
 	}
 	/**
-	* Searches for the corresponding current renderable terrain-tiles.
-	* Includes terrain tiles that are within terrain tile ranges.
-	* @param tileID - the tile to look for
-	* @returns the tiles that were found
+	* @internal
+	* Called after the camera is done being manipulated.
+	* @param tr - the requested camera end state
+	* If the camera is inside terrain, it gets elevated.
+	* Call `transformCameraUpdate` if present, and then apply the "approved" changes.
 	*/
-	_getTerrainCoordsForTileRanges(tileID, terrainTileRanges) {
-		const coords = {};
-		for (const key of this._renderableTilesKeys) {
-			const terrainTileID = this._tiles[key].tileID;
-			if (!this._isWithinTileRanges(terrainTileID, terrainTileRanges)) continue;
-			const coord = tileID.clone();
-			const mat = createMat4f64();
-			if (terrainTileID.canonical.z === tileID.canonical.z) {
-				const dx = tileID.canonical.x - terrainTileID.canonical.x + tileID.wrap * (1 << tileID.canonical.z);
-				const dy = tileID.canonical.y - terrainTileID.canonical.y;
-				ortho(mat, 0, EXTENT, EXTENT, 0, 0, 1);
-				translate(mat, mat, [
-					dx * EXTENT,
-					dy * EXTENT,
-					0
-				]);
-			} else if (terrainTileID.canonical.z > tileID.canonical.z) {
-				const dz = terrainTileID.canonical.z - tileID.canonical.z;
-				const dx = terrainTileID.canonical.x - (terrainTileID.canonical.x >> dz << dz) + tileID.wrap * (1 << terrainTileID.canonical.z);
-				const dy = terrainTileID.canonical.y - (terrainTileID.canonical.y >> dz << dz);
-				const dx2 = tileID.canonical.x - (terrainTileID.canonical.x >> dz);
-				const dy2 = tileID.canonical.y - (terrainTileID.canonical.y >> dz);
-				const size = EXTENT >> dz;
-				ortho(mat, 0, size, size, 0, 0, 1);
-				translate(mat, mat, [
-					-dx * size + dx2 * EXTENT,
-					-dy * size + dy2 * EXTENT,
-					0
-				]);
-			} else {
-				const dz = tileID.canonical.z - terrainTileID.canonical.z;
-				const dx = tileID.canonical.x - (tileID.canonical.x >> dz << dz) + tileID.wrap * (1 << tileID.canonical.z);
-				const dy = tileID.canonical.y - (tileID.canonical.y >> dz << dz);
-				const dx2 = (tileID.canonical.x >> dz) - terrainTileID.canonical.x;
-				const dy2 = (tileID.canonical.y >> dz) - terrainTileID.canonical.y;
-				const size = EXTENT << dz;
-				ortho(mat, 0, size, size, 0, 0, 1);
-				translate(mat, mat, [
-					dx * EXTENT + dx2 * size,
-					dy * EXTENT + dy2 * size,
-					0
-				]);
-			}
-			coord.terrainRttPosMatrix32f = new Float32Array(mat);
-			coords[key] = coord;
+	applyUpdatedTransform(tr) {
+		const modifiers = [];
+		modifiers.push((tr) => this._elevateCameraIfInsideTerrain(tr));
+		if (this.transformCameraUpdate) modifiers.push((tr) => this.transformCameraUpdate(tr));
+		if (!modifiers.length) return;
+		const finalTransform = tr.clone();
+		for (const modifier of modifiers) {
+			const nextTransform = finalTransform.clone();
+			const { center, zoom, roll, pitch, bearing, elevation } = modifier(nextTransform);
+			if (center) nextTransform.setCenter(center);
+			if (elevation !== void 0) nextTransform.setElevation(elevation);
+			if (zoom !== void 0) nextTransform.setZoom(zoom);
+			if (roll !== void 0) nextTransform.setRoll(roll);
+			if (pitch !== void 0) nextTransform.setPitch(pitch);
+			if (bearing !== void 0) nextTransform.setBearing(bearing);
+			finalTransform.apply(nextTransform, false);
 		}
-		return coords;
-	}
-	/**
-	* find the covering raster-dem tile
-	* @param tileID - the tile to look for
-	* @param searchForDEM - Optional parameter to search for (parent) source tiles with loaded dem.
-	* @returns the tile
-	*/
-	getSourceTile(tileID, searchForDEM) {
-		const source = this.tileManager._source;
-		let z = tileID.overscaledZ - this.deltaZoom;
-		if (z > source.maxzoom) z = source.maxzoom;
-		if (z < source.minzoom) return void 0;
-		this._sourceTileCache[tileID.key] ||= tileID.scaledTo(z).key;
-		let tile = this.findTileInCaches(this._sourceTileCache[tileID.key]);
-		if (!tile?.dem && searchForDEM) while (z >= source.minzoom && !tile?.dem) tile = this.findTileInCaches(tileID.scaledTo(z--).key);
-		return tile;
-	}
-	findTileInCaches(key) {
-		let tile = this.tileManager.getTileByID(key);
-		if (tile) return tile;
-		tile = this.tileManager._outOfViewCache.getByKey(key);
-		return tile;
-	}
-	/**
-	* gets whether any tiles were loaded after a specific time. This is used to update depth & coords framebuffers.
-	* @param time - the time
-	* @returns true if any tiles came into view at or after the specified time
-	*/
-	anyTilesAfterTime(time = now()) {
-		return this._lastTilesetChange >= time;
+		this.transform.apply(finalTransform, false);
 	}
-	/**
-	* Checks whether a tile is within the canonical tile ranges.
-	* @param tileID - Tile to check
-	* @param canonicalTileRanges - Canonical tile ranges
-	* @returns
-	*/
-	_isWithinTileRanges(tileID, canonicalTileRanges) {
-		const range = canonicalTileRanges[tileID.canonical.z];
-		return !!range && (tileID.wrap > range.minWrap || tileID.wrap < range.maxWrap || tileID.canonical.x >= range.minTileXWrapped && tileID.canonical.x <= range.maxTileXWrapped && tileID.canonical.y >= range.minTileY && tileID.canonical.y <= range.maxTileY);
+	_fireMoveEvents(eventData) {
+		this.fire(new MapMovementEvent("move", eventData));
+		if (this._zooming) this.fire(new MapMovementEvent("zoom", eventData));
+		if (this._rotating) this.fire(new MapMovementEvent("rotate", eventData));
+		if (this._pitching) this.fire(new MapMovementEvent("pitch", eventData));
+		if (this._rolling) this.fire(new MapMovementEvent("roll", eventData));
 	}
-};
-//#endregion
-//#region src/render/terrain.ts
-/**
-* @internal
-* This is the main class which handles most of the 3D Terrain logic. It has the following topics:
-*
-* 1. loads raster-dem tiles via the internal tileManager this.tileManager
-* 2. creates a depth-framebuffer, which is used to calculate the visibility of coordinates
-* 3. creates a coords-framebuffer, which is used the get to tile-coordinate for a screen-pixel
-* 4. stores all render-to-texture tiles in the this.tileManager._tiles
-* 5. calculates the elevation for a specific tile-coordinate
-* 6. creates a terrain-mesh
-*
-* A note about the GPU resource-usage:
-*
-* Framebuffers:
-*
-* - one for the depth & coords framebuffer with the size of the map-div.
-* - one for rendering a tile to texture with the size of tileSize (= 512x512).
-*
-* Textures:
-*
-* - one texture for an empty raster-dem tile with size 1x1
-* - one texture for an empty depth-buffer, when terrain is disabled with size 1x1
-* - one texture for an each loaded raster-dem with size of the source.tileSize
-* - one texture for the coords-framebuffer with the size of the map-div.
-* - one texture for the depth-framebuffer with the size of the map-div.
-* - one texture for the encoded tile-coords with the size 2*tileSize (=1024x1024)
-* - finally for each render-to-texture tile (= this._tiles) a set of textures
-* for each render stack (The stack-concept is documented in painter.ts).
-*
-* Normally there exists 1-3 Textures per tile, depending on the stylesheet.
-* Each Textures has the size 2*tileSize (= 1024x1024). Also there exists a
-* cache of the last 150 newest rendered tiles.
-*
-*/
-var Terrain = class {
-	constructor(painter, tileManager, options, terrainSkirtLength = "auto") {
-		this._meshCache = {};
-		this.painter = painter;
-		this.tileManager = new TerrainTileManager(tileManager);
-		this.options = options;
-		this.exaggeration = typeof options.exaggeration === "number" ? options.exaggeration : 1;
-		this._terrainSkirtLength = terrainSkirtLength;
-		this.qualityFactor = 2;
-		this.meshSize = 128;
-		this._demMatrixCache = /* @__PURE__ */ new Map();
-		this._elevationSamplerCache = /* @__PURE__ */ new Map();
-		this.coordsIndex = [];
-		this._coordsTextureSize = 1024;
+	_afterEase(eventData, easeId) {
+		if (this._easeId && easeId && this._easeId === easeId) return;
+		delete this._easeId;
+		const wasZooming = this._zooming;
+		const wasRotating = this._rotating;
+		const wasPitching = this._pitching;
+		const wasRolling = this._rolling;
+		this._moving = false;
+		this._zooming = false;
+		this._rotating = false;
+		this._pitching = false;
+		this._rolling = false;
+		this._padding = false;
+		if (wasZooming) this.fire(new MapMovementEvent("zoomend", eventData));
+		if (wasRotating) this.fire(new MapMovementEvent("rotateend", eventData));
+		if (wasPitching) this.fire(new MapMovementEvent("pitchend", eventData));
+		if (wasRolling) this.fire(new MapMovementEvent("rollend", eventData));
+		this.fire(new MapMovementEvent("moveend", eventData));
 	}
-	destroy() {
-		if (this._fbo) {
-			this._fbo.destroy();
-			this._fbo = null;
+	flyTo(options, eventData) {
+		if (!options.essential && browser.prefersReducedMotion) {
+			const coercedOptions = pick(options, [
+				"center",
+				"zoom",
+				"bearing",
+				"pitch",
+				"roll",
+				"elevation",
+				"padding"
+			]);
+			return this.jumpTo(coercedOptions, eventData);
 		}
-		if (this._fboCoordsTexture) {
-			this._fboCoordsTexture.destroy();
-			this._fboCoordsTexture = null;
+		this.stop();
+		options = extend({
+			offset: [0, 0],
+			speed: 1.2,
+			curve: 1.42,
+			easing: defaultEasing
+		}, options);
+		if ("zoom" in options && this._zoomSnap) options.zoom = evaluateZoomSnap(options.zoom, this._zoomSnap);
+		const tr = this.getTransformForUpdate(), startBearing = tr.bearing, startPitch = tr.pitch, startRoll = tr.roll, startPadding = tr.padding;
+		const bearing = "bearing" in options ? this._normalizeBearing(options.bearing, startBearing) : startBearing;
+		const pitch = "pitch" in options ? +options.pitch : startPitch;
+		const roll = "roll" in options ? this._normalizeBearing(options.roll, startRoll) : startRoll;
+		const padding = "padding" in options ? options.padding : tr.padding;
+		const offsetAsPoint = Point.convert(options.offset);
+		let pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+		const locationAtOffset = tr.screenPointToLocation(pointAtOffset);
+		const flyToHandler = this.cameraHelper.handleFlyTo(tr, {
+			bearing,
+			pitch,
+			roll,
+			padding,
+			locationAtOffset,
+			offsetAsPoint,
+			center: options.center,
+			minZoom: options.minZoom,
+			zoom: options.zoom
+		});
+		let rho = options.curve;
+		const w0 = Math.max(tr.width, tr.height);
+		const w1 = w0 / flyToHandler.scaleOfZoom;
+		const u1 = flyToHandler.pixelPathLength;
+		const wMax = w0 / flyToHandler.scaleOfMinZoom;
+		rho = Math.min(rho, Math.sqrt(wMax / u1 * 2));
+		const rho2 = rho * rho;
+		/**
+		* rᵢ: Returns the zoom-out factor at one end of the animation.
+		*
+		* @param descent - `true` for the descent, `false` for the ascent
+		*/
+		function zoomOutFactor(descent) {
+			const b = (w1 * w1 - w0 * w0 + (descent ? -1 : 1) * rho2 * rho2 * u1 * u1) / (2 * (descent ? w1 : w0) * rho2 * u1);
+			return Math.log(Math.sqrt(b * b + 1) - b);
 		}
-		if (this._fboDepthTexture) {
-			this._fboDepthTexture.destroy();
-			this._fboDepthTexture = null;
+		function sinh(n) {
+			return (Math.exp(n) - Math.exp(-n)) / 2;
 		}
-		if (this._emptyDemTexture) {
-			this._emptyDemTexture.destroy();
-			this._emptyDemTexture = null;
+		function cosh(n) {
+			return (Math.exp(n) + Math.exp(-n)) / 2;
 		}
-		if (this._emptyDepthTexture) {
-			this._emptyDepthTexture.destroy();
-			this._emptyDepthTexture = null;
+		function tanh(n) {
+			return sinh(n) / cosh(n);
+		}
+		const r0 = zoomOutFactor(false);
+		let w = function(s) {
+			return cosh(r0) / cosh(r0 + rho * s);
+		};
+		let u = function(s) {
+			return w0 * ((cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2) / u1;
+		};
+		let S = (zoomOutFactor(true) - r0) / rho;
+		if (Math.abs(u1) < 2e-6 || !isFinite(S)) {
+			if (Math.abs(w0 - w1) < 1e-6) return this.easeTo(options, eventData);
+			const k = w1 < w0 ? -1 : 1;
+			S = Math.abs(Math.log(w1 / w0)) / rho;
+			u = () => 0;
+			w = (s) => Math.exp(k * rho * s);
 		}
-		if (this._coordsTexture) {
-			this._coordsTexture.destroy();
-			this._coordsTexture = null;
+		if ("duration" in options) options.duration = +options.duration;
+		else {
+			const V = "screenSpeed" in options ? +options.screenSpeed / rho : +options.speed;
+			options.duration = 1e3 * S / V;
 		}
-		for (const key in this._meshCache) this._meshCache[key].destroy();
-		this._meshCache = {};
-		this.tileManager.destruct();
+		if (options.maxDuration && options.duration > options.maxDuration) options.duration = 0;
+		this._zooming = true;
+		this._rotating = startBearing !== bearing;
+		this._pitching = pitch !== startPitch;
+		this._rolling = roll !== startRoll;
+		this._padding = !tr.isPaddingEqual(padding);
+		this._prepareEase(eventData, false);
+		if (this.terrain) this._prepareElevation(flyToHandler.targetCenter);
+		this._ease((k) => {
+			const s = k * S;
+			const scale = 1 / w(s);
+			const centerFactor = u(s);
+			if (this._rotating) tr.setBearing(interpolateFactory.number(startBearing, bearing, k));
+			if (this._pitching) tr.setPitch(interpolateFactory.number(startPitch, pitch, k));
+			if (this._rolling) tr.setRoll(interpolateFactory.number(startRoll, roll, k));
+			if (this._padding) {
+				tr.interpolatePadding(startPadding, padding, k);
+				pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+			}
+			flyToHandler.easeFunc(k, scale, centerFactor, pointAtOffset);
+			if (this.terrain && !options.freezeElevation) this._updateElevation(k);
+			this.applyUpdatedTransform(tr);
+			this._fireMoveEvents(eventData);
+		}, () => {
+			if (this.terrain && options.freezeElevation) this._finalizeElevation();
+			this._afterEase(eventData);
+		}, options);
+		return this;
 	}
-	/**
-	* Get the elevation-value from original dem-data for a given tile-coordinate.
-	* Coordinates that fall outside `[0, extent)` are normalized to the
-	* appropriate neighbor tile before lookup.
-	* @param tileID - the tile to get the elevation for
-	* @param x - x coordinate relative to the tile, may be outside `[0, extent)`
-	* @param y - y coordinate relative to the tile, may be outside `[0, extent)`
-	* @param extent - optional, default 8192
-	* @returns the elevation
-	*/
-	getDEMElevation(tileID, x, y, extent = EXTENT) {
-		const normalized = tileID.normalizeCoordinates(x, y, extent);
-		if (!normalized) return 0;
-		const sampler = this._getElevationSampler(normalized.tileID);
-		return sampler ? sampler(normalized.x, normalized.y, extent) : 0;
+	isEasing() {
+		return !!this._easeFrameId;
 	}
-	/**
-	* Get the elevation for given {@link LngLat} in respect of exaggeration.
-	* @param lnglat - the location
-	* @param zoom - the zoom, use {@link getElevationForLngLat} if you don't want a specific zoom level, but more accurate results.
-	* @returns the elevation
-	*/
-	getElevationForLngLatZoom(lnglat, zoom) {
-		if (!isInBoundsForZoomLngLat(zoom, lnglat.wrap())) return 0;
-		const { tileID, mercatorX, mercatorY } = this._getOverscaledTileIDFromLngLatZoom(lnglat, zoom);
-		return this.getElevation(tileID, mercatorX % EXTENT, mercatorY % EXTENT, EXTENT);
+	stop(allowGestures) {
+		return this._stop(allowGestures);
 	}
-	/**
-	* Get the elevation for given {@link LngLat} in respect of exaggeration.
-	* This will traverse up the zoom levels to find the first tile with data to return.
-	* @param lnglat - the location
-	* @returns the elevation
-	*/
-	getElevationForLngLat(lnglat, transform) {
-		const terrainCoveringTiles = coveringTiles(transform, {
-			maxzoom: this.tileManager.maxzoom,
-			minzoom: this.tileManager.minzoom,
-			tileSize: 512,
-			terrain: this
-		});
-		let zoom = 0;
-		for (const tile of terrainCoveringTiles) if (tile.canonical.z > zoom) zoom = Math.min(tile.canonical.z, this.tileManager.maxzoom);
-		return this.getElevationForLngLatZoom(lnglat, zoom);
+	_stop(allowGestures, easeId) {
+		if (this._easeFrameId) {
+			this._cancelRenderFrame(this._easeFrameId);
+			delete this._easeFrameId;
+			delete this._onEaseFrame;
+		}
+		if (this._onEaseEnd) {
+			const onEaseEnd = this._onEaseEnd;
+			delete this._onEaseEnd;
+			onEaseEnd.call(this, easeId);
+		}
+		if (!allowGestures) this._stopHandlers();
+		return this;
 	}
-	/**
-	* Get the elevation for given coordinate in respect of exaggeration.
-	* @param tileID - the tile id
-	* @param x - x coordinate relative to the tile, may be outside `[0, extent)`
-	* @param y - y coordinate relative to the tile, may be outside `[0, extent)`
-	* @param extent - optional, default 8192
-	* @returns the elevation
-	*/
-	getElevation(tileID, x, y, extent = EXTENT) {
-		return this.getDEMElevation(tileID, x, y, extent) * this.exaggeration;
+	_ease(frame, finish, options) {
+		if (options.animate === false || options.duration === 0) {
+			frame(1);
+			finish();
+		} else {
+			this._easeStart = now();
+			this._easeOptions = options;
+			this._onEaseFrame = frame;
+			this._onEaseEnd = finish;
+			this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback);
+		}
 	}
-	/**
-	* Clear CPU elevation samplers that may retain a previously selected DEM tile.
-	* @internal
-	*/
-	resetElevationCache() {
-		this._elevationSamplerCache.clear();
+	_normalizeBearing(bearing, currentBearing) {
+		bearing = wrap(bearing, -180, 180);
+		const diff = Math.abs(bearing - currentBearing);
+		if (Math.abs(bearing - 360 - currentBearing) < diff) bearing -= 360;
+		if (Math.abs(bearing + 360 - currentBearing) < diff) bearing += 360;
+		return bearing;
 	}
-	_getElevationSampler(tileID) {
-		const key = tileID.key;
-		const cachedSampler = this._elevationSamplerCache.get(key);
-		if (cachedSampler) return cachedSampler;
-		const sourceTile = this.tileManager.getSourceTile(tileID, true);
-		const dem = sourceTile?.dem;
-		if (!sourceTile || !dem) return null;
-		const matrix = this._getDEMTileMatrix(tileID, sourceTile);
-		const demPixelScaleX = matrix[0] * dem.dim;
-		const demPixelScaleY = matrix[5] * dem.dim;
-		const demPixelOffsetX = matrix[12] * dem.dim;
-		const demPixelOffsetY = matrix[13] * dem.dim;
-		const sampler = (x, y, extent) => {
-			const extentScale = extent === 8192 ? 1 : EXTENT / extent;
-			return dem.sampleBilinear(x * extentScale * demPixelScaleX + demPixelOffsetX, y * extentScale * demPixelScaleY + demPixelOffsetY);
-		};
-		this._elevationSamplerCache.set(key, sampler);
-		return sampler;
+	isMoving() {
+		return this._moving;
 	}
-	_getDEMTileMatrix(tileID, sourceTile) {
-		const matrixKey = `${sourceTile.tileID.key}/${tileID.key}`;
-		const cachedMatrix = this._demMatrixCache.get(matrixKey);
-		if (cachedMatrix) return cachedMatrix;
-		const maxzoom = this.tileManager.getSource().maxzoom;
-		let dz = tileID.canonical.z - sourceTile.tileID.canonical.z;
-		if (tileID.overscaledZ > tileID.canonical.z) {
-			if (tileID.canonical.z >= maxzoom) dz = tileID.canonical.z - maxzoom;
-			else warnOnce("cannot calculate elevation if elevation maxzoom > source.maxzoom");
-		}
-		const dx = tileID.canonical.x - (tileID.canonical.x >> dz << dz);
-		const dy = tileID.canonical.y - (tileID.canonical.y >> dz << dz);
-		const demMatrix = fromScaling(/* @__PURE__ */ new Float64Array(16), [
-			1 / (EXTENT << dz),
-			1 / (EXTENT << dz),
-			0
-		]);
-		translate(demMatrix, demMatrix, [
-			dx * EXTENT,
-			dy * EXTENT,
-			0
-		]);
-		this._demMatrixCache.set(matrixKey, demMatrix);
-		return demMatrix;
+	isZooming() {
+		return this._zooming;
 	}
+	isRotating() {
+		return this._rotating;
+	}
+};
+//#endregion
+//#region src/ui/control/attribution_control.ts
+const defaultAttributionControlOptions = {
+	compact: true,
+	customAttribution: "<a href=\"https://maplibre.org/\" target=\"_blank\">MapLibre</a>"
+};
+/**
+* An `AttributionControl` control presents the map's attribution information. By default, the attribution control is expanded (regardless of map width).
+* @group Markers and Controls
+* @example
+* ```ts
+* let map = new Map({attributionControl: false})
+*     .addControl(new AttributionControl({
+*         compact: true
+*     }));
+* ```
+* @see [Change the default position for attribution](https://maplibre.org/maplibre-gl-js/docs/examples/change-the-default-position-for-attribution/)
+*/
+var AttributionControl = class {
 	/**
-	* returns a Terrain Object for a tile. Unless the tile corresponds to data (e.g. tile is loading), return a flat dem object
-	* @param tileID - the tile to get the terrain for
-	* @returns the terrain data to use in the program
+	* @param options - the attribution options
 	*/
-	getTerrainData(tileID) {
-		if (!this._emptyDemTexture) {
-			const context = this.painter.context;
-			const image = new RGBAImage({
-				width: 1,
-				height: 1
-			}, /* @__PURE__ */ new Uint8Array(4));
-			this._emptyDepthTexture = new Texture(context, image, context.gl.RGBA, { premultiply: false });
-			this._emptyDemUnpack = [
-				0,
-				0,
-				0,
-				0
-			];
-			this._emptyDemTexture = new Texture(context, new RGBAImage({
-				width: 1,
-				height: 1
-			}), context.gl.RGBA, { premultiply: false });
-			this._emptyDemTexture.bind(context.gl.NEAREST, context.gl.CLAMP_TO_EDGE);
-			this._emptyDemMatrix = identity([]);
-		}
-		const sourceTile = this.tileManager.getSourceTile(tileID, true);
-		if (sourceTile?.dem && (!sourceTile.demTexture || sourceTile.needsTerrainPrepare)) {
-			const context = this.painter.context;
-			sourceTile.demTexture ||= this.painter.getTileTexture(sourceTile.dem.stride);
-			if (sourceTile.demTexture) sourceTile.demTexture.update(sourceTile.dem.getPixels(), { premultiply: false });
-			else sourceTile.demTexture = new Texture(context, sourceTile.dem.getPixels(), context.gl.RGBA, { premultiply: false });
-			sourceTile.demTexture.bind(context.gl.NEAREST, context.gl.CLAMP_TO_EDGE);
-			sourceTile.needsTerrainPrepare = false;
-		}
-		const terrainMatrix = sourceTile ? this._getDEMTileMatrix(tileID, sourceTile) : this._emptyDemMatrix;
-		return {
-			"u_depth": 2,
-			"u_terrain": 3,
-			"u_terrain_dim": sourceTile?.dem?.dim || 1,
-			"u_terrain_matrix": terrainMatrix,
-			"u_terrain_unpack": sourceTile?.dem?.getUnpackVector() || this._emptyDemUnpack,
-			"u_terrain_exaggeration": this.exaggeration,
-			texture: (sourceTile?.demTexture || this._emptyDemTexture).texture,
-			depthTexture: (this._fboDepthTexture || this._emptyDepthTexture).texture,
-			tile: sourceTile
+	constructor(options = defaultAttributionControlOptions) {
+		this._toggleAttribution = () => {
+			if (this._container.classList.contains("maplibregl-compact")) {
+				if (this._container.classList.contains("maplibregl-compact-show")) {
+					this._container.setAttribute("open", "");
+					this._container.classList.remove("maplibregl-compact-show");
+				} else {
+					this._container.classList.add("maplibregl-compact-show");
+					this._container.removeAttribute("open");
+				}
+			}
+		};
+		this._updateData = (e) => {
+			if (e && (e.type === "terrain" || e.dataType === "style" || e.dataType === "source" && (e.sourceDataType === "metadata" || e.sourceDataType === "visibility"))) this._updateAttributions();
+		};
+		this._updateCompact = () => {
+			if (this._map.getCanvasContainer().offsetWidth <= 640 || this._compact) {
+				if (this._compact === false) this._container.setAttribute("open", "");
+				else if (!this._container.classList.contains("maplibregl-compact") && !this._container.classList.contains("maplibregl-attrib-empty")) {
+					this._container.setAttribute("open", "");
+					this._container.classList.add("maplibregl-compact", "maplibregl-compact-show");
+				}
+			} else {
+				this._container.setAttribute("open", "");
+				if (this._container.classList.contains("maplibregl-compact")) this._container.classList.remove("maplibregl-compact", "maplibregl-compact-show");
+			}
+		};
+		this._updateCompactMinimize = () => {
+			if (this._container.classList.contains("maplibregl-compact")) {
+				if (this._container.classList.contains("maplibregl-compact-show")) this._container.classList.remove("maplibregl-compact-show");
+			}
 		};
+		this.options = options;
 	}
-	/**
-	* get a framebuffer as big as the map-div, which will be used to render depth & coords into a texture
-	* @param texture - the texture
-	* @returns the frame buffer
-	*/
-	getFramebuffer(texture) {
-		const painter = this.painter;
-		const width = painter.width / devicePixelRatio;
-		const height = painter.height / devicePixelRatio;
-		if (this._fbo && (this._fbo.width !== width || this._fbo.height !== height)) {
-			this._fbo.destroy();
-			this._fboCoordsTexture.destroy();
-			this._fboDepthTexture.destroy();
-			delete this._fbo;
-			delete this._fboDepthTexture;
-			delete this._fboCoordsTexture;
-		}
-		if (!this._fboCoordsTexture) {
-			this._fboCoordsTexture = new Texture(painter.context, {
-				width,
-				height,
-				data: null
-			}, painter.context.gl.RGBA, { premultiply: false });
-			this._fboCoordsTexture.bind(painter.context.gl.NEAREST, painter.context.gl.CLAMP_TO_EDGE);
+	getDefaultPosition() {
+		return "bottom-right";
+	}
+	/** {@inheritDoc IControl.onAdd} */
+	onAdd(map) {
+		this._map = map;
+		this._compact = this.options.compact;
+		this._container = DOM.create("details", "maplibregl-ctrl maplibregl-ctrl-attrib");
+		this._compactButton = DOM.create("summary", "maplibregl-ctrl-attrib-button", this._container);
+		this._compactButton.addEventListener("click", this._toggleAttribution);
+		this._setElementTitle(this._compactButton, "ToggleAttribution");
+		this._innerContainer = DOM.create("div", "maplibregl-ctrl-attrib-inner", this._container);
+		this._updateAttributions();
+		this._updateCompact();
+		this._map.on("styledata", this._updateData);
+		this._map.on("sourcedata", this._updateData);
+		this._map.on("terrain", this._updateData);
+		this._map.on("resize", this._updateCompact);
+		this._map.on("drag", this._updateCompactMinimize);
+		return this._container;
+	}
+	/** {@inheritDoc IControl.onRemove} */
+	onRemove() {
+		this._container.remove();
+		this._map.off("styledata", this._updateData);
+		this._map.off("sourcedata", this._updateData);
+		this._map.off("terrain", this._updateData);
+		this._map.off("resize", this._updateCompact);
+		this._map.off("drag", this._updateCompactMinimize);
+		this._map = void 0;
+		this._compact = void 0;
+		this._attribHTML = void 0;
+	}
+	_setElementTitle(element, title) {
+		const str = this._map._getUIString(`AttributionControl.${title}`);
+		element.title = str;
+		element.setAttribute("aria-label", str);
+	}
+	_updateAttributions() {
+		if (!this._map.style) return;
+		let attributions = [];
+		if (this.options.customAttribution) {
+			if (Array.isArray(this.options.customAttribution)) attributions = attributions.concat(this.options.customAttribution.map((attribution) => {
+				if (typeof attribution !== "string") return "";
+				return attribution;
+			}));
+			else if (typeof this.options.customAttribution === "string") attributions.push(this.options.customAttribution);
 		}
-		if (!this._fboDepthTexture) {
-			this._fboDepthTexture = new Texture(painter.context, {
-				width,
-				height,
-				data: null
-			}, painter.context.gl.RGBA, { premultiply: false });
-			this._fboDepthTexture.bind(painter.context.gl.NEAREST, painter.context.gl.CLAMP_TO_EDGE);
+		if (this._map.style.stylesheet) {
+			const stylesheet = this._map.style.stylesheet;
+			this.styleOwner = stylesheet.owner;
+			this.styleId = stylesheet.id;
 		}
-		if (!this._fbo) {
-			this._fbo = painter.context.createFramebuffer(width, height, true, false);
-			this._fbo.depthAttachment.set(painter.context.createRenderbuffer(painter.context.gl.DEPTH_COMPONENT16, width, height));
+		const tileManagers = this._map.style.tileManagers;
+		for (const id in tileManagers) {
+			const tileManager = tileManagers[id];
+			if (tileManager.used || tileManager.usedForTerrain) {
+				const source = tileManager.getSource();
+				if (source.attribution && !attributions.includes(source.attribution)) attributions.push(source.attribution);
+			}
 		}
-		this._fbo.colorAttachment.set(texture === "coords" ? this._fboCoordsTexture.texture : this._fboDepthTexture.texture);
-		return this._fbo;
-	}
-	/**
-	* create coords texture, needed to grab coordinates from canvas
-	* encode coords coordinate into 4 bytes:
-	*   - 8 lower bits for x
-	*   - 8 lower bits for y
-	*   - 4 higher bits for x
-	*   - 4 higher bits for y
-	*   - 8 bits for coordsIndex (1 .. 255) (= number of terraintile), is later set in draw_terrain uniform value
-	* @returns the texture
-	*/
-	getCoordsTexture() {
-		const context = this.painter.context;
-		if (this._coordsTexture) return this._coordsTexture;
-		const data = new Uint8Array(this._coordsTextureSize * this._coordsTextureSize * 4);
-		for (let y = 0, i = 0; y < this._coordsTextureSize; y++) for (let x = 0; x < this._coordsTextureSize; x++, i += 4) {
-			data[i + 0] = x & 255;
-			data[i + 1] = y & 255;
-			data[i + 2] = x >> 8 << 4 | y >> 8;
-			data[i + 3] = 0;
-		}
-		const image = new RGBAImage({
-			width: this._coordsTextureSize,
-			height: this._coordsTextureSize
-		}, new Uint8Array(data.buffer));
-		const texture = new Texture(context, image, context.gl.RGBA, { premultiply: false });
-		texture.bind(context.gl.NEAREST, context.gl.CLAMP_TO_EDGE);
-		this._coordsTexture = texture;
-		return texture;
-	}
-	/**
-	* Reads a pixel from the coords-framebuffer and translate this to mercator, or null, if the pixel doesn't lie on the terrain's surface (but the sky instead).
-	* @param p - Screen-Coordinate
-	* @returns Mercator coordinate for a screen pixel, or null, if the pixel is not covered by terrain (is in the sky).
-	*/
-	pointCoordinate(p) {
-		this.painter.maybeDrawDepth(true);
-		this.painter.maybeDrawCoords();
-		const rgba = /* @__PURE__ */ new Uint8Array(4);
-		const context = this.painter.context, gl = context.gl;
-		const px = Math.round(p.x * this.painter.pixelRatio / devicePixelRatio);
-		const py = Math.round(p.y * this.painter.pixelRatio / devicePixelRatio);
-		const fbHeight = Math.round(this.painter.height / devicePixelRatio);
-		context.bindFramebuffer.set(this.getFramebuffer("coords").framebuffer);
-		gl.readPixels(px, fbHeight - py - 1, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, rgba);
-		context.bindFramebuffer.set(null);
-		const x = rgba[0] + (rgba[2] >> 4 << 8);
-		const y = rgba[1] + ((rgba[2] & 15) << 8);
-		const tileID = this.coordsIndex[255 - rgba[3]];
-		const tile = tileID && this.tileManager.getTileByID(tileID);
-		if (!tile) return null;
-		const coordsSize = this._coordsTextureSize;
-		const worldSize = (1 << tile.tileID.canonical.z) * coordsSize;
-		return new MercatorCoordinate((tile.tileID.canonical.x * coordsSize + x) / worldSize + tile.tileID.wrap, (tile.tileID.canonical.y * coordsSize + y) / worldSize, this.getElevation(tile.tileID, x, y, coordsSize));
+		attributions = attributions.filter((e) => String(e).trim());
+		attributions.sort((a, b) => a.length - b.length);
+		attributions = attributions.filter((attrib, i) => {
+			for (let j = i + 1; j < attributions.length; j++) if (attributions[j].includes(attrib)) return false;
+			return true;
+		});
+		const attribHTML = attributions.join(" | ");
+		if (attribHTML === this._attribHTML) return;
+		this._attribHTML = attribHTML;
+		if (attributions.length) {
+			this._innerContainer.innerHTML = DOM.sanitize(attribHTML);
+			this._container.classList.remove("maplibregl-attrib-empty");
+		} else this._container.classList.add("maplibregl-attrib-empty");
+		this._updateCompact();
+		this._editLink = null;
 	}
+};
+//#endregion
+//#region src/ui/control/logo_control.ts
+/**
+* A `LogoControl` is a control that adds the watermark.
+*
+* @group Markers and Controls
+*
+* @example
+* ```ts
+* map.addControl(new LogoControl({compact: false}));
+* ```
+**/
+var LogoControl = class {
 	/**
-	* Reads the depth value from the depth-framebuffer at a given screen pixel
-	* @param p - Screen coordinate
-	* @returns depth value in clip space (between 0 and 1)
+	* @param options - the control's options
 	*/
-	depthAtPoint(p) {
-		const rgba = /* @__PURE__ */ new Uint8Array(4);
-		const context = this.painter.context, gl = context.gl;
-		context.bindFramebuffer.set(this.getFramebuffer("depth").framebuffer);
-		gl.readPixels(p.x, this.painter.height / devicePixelRatio - p.y - 1, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, rgba);
-		context.bindFramebuffer.set(null);
-		return (rgba[0] / 16777216 + rgba[1] / 65536 + rgba[2] / 256 + rgba[3]) / 256;
+	constructor(options = {}) {
+		this._updateCompact = () => {
+			const containerChildren = this._container.children;
+			if (containerChildren.length) {
+				const anchor = containerChildren[0];
+				if (this._map.getCanvasContainer().offsetWidth <= 640 || this._compact) {
+					if (this._compact !== false) anchor.classList.add("maplibregl-compact");
+				} else anchor.classList.remove("maplibregl-compact");
+			}
+		};
+		this.options = options;
 	}
-	/**
-	* create a regular mesh which will be used by all terrain-tiles
-	* @returns the created regular mesh
-	*/
-	getTerrainMesh(tileId) {
-		const globeEnabled = this.painter.style.projection?.transitionState > 0;
-		const northPole = globeEnabled && tileId.canonical.y === 0;
-		const southPole = globeEnabled && tileId.canonical.y === (1 << tileId.canonical.z) - 1;
-		const key = `m_${northPole ? "n" : ""}_${southPole ? "s" : ""}`;
-		if (this._meshCache[key]) return this._meshCache[key];
-		const context = this.painter.context;
-		const vertexArray = new Pos3dArray();
-		const indexArray = new TriangleIndexArray();
-		const meshSize = this.meshSize;
-		const delta = EXTENT / meshSize;
-		const meshSize2 = meshSize * meshSize;
-		for (let y = 0; y <= meshSize; y++) for (let x = 0; x <= meshSize; x++) vertexArray.emplaceBack(x * delta, y * delta, 0);
-		for (let y = 0; y < meshSize2; y += meshSize + 1) for (let x = 0; x < meshSize; x++) {
-			indexArray.emplaceBack(x + y, meshSize + x + y + 1, meshSize + x + y + 2);
-			indexArray.emplaceBack(x + y, meshSize + x + y + 2, x + y + 1);
-		}
-		if (this._terrainSkirtLength !== "none") this._buildSkirts(vertexArray, indexArray, meshSize, delta, northPole, southPole);
-		const mesh = new Mesh(context.createVertexBuffer(vertexArray, pos3dAttributes.members), context.createIndexBuffer(indexArray), SegmentVector.simpleSegment(0, 0, vertexArray.length, indexArray.length));
-		this._meshCache[key] = mesh;
-		return mesh;
+	getDefaultPosition() {
+		return "bottom-left";
 	}
-	/**
-	* Calculates the height of the tile skirts for the "auto" strategy.
-	* @see {@link MapOptions.terrainSkirtLength}
-	* @param zoom - current zoomlevel
-	* @returns the elevation delta in meters
-	*/
-	getSkirtLength(zoom) {
-		return 2 * Math.PI * earthRadius / Math.pow(2, Math.max(zoom, 0)) / 5;
+	/** {@inheritDoc IControl.onAdd} */
+	onAdd(map) {
+		this._map = map;
+		this._compact = this.options?.compact;
+		this._container = DOM.create("div", "maplibregl-ctrl");
+		const anchor = DOM.create("a", "maplibregl-ctrl-logo");
+		anchor.target = "_blank";
+		anchor.rel = "noopener nofollow";
+		anchor.href = "https://maplibre.org/";
+		anchor.setAttribute("aria-label", this._map._getUIString("LogoControl.Title"));
+		anchor.setAttribute("rel", "noopener nofollow");
+		this._container.appendChild(anchor);
+		this._container.style.display = "block";
+		this._map.on("resize", this._updateCompact);
+		this._updateCompact();
+		return this._container;
 	}
-	getMinTileElevationForLngLatZoom(lnglat, zoom) {
-		if (!isInBoundsForZoomLngLat(zoom, lnglat.wrap())) return 0;
-		const { tileID } = this._getOverscaledTileIDFromLngLatZoom(lnglat, zoom);
-		return this.getMinMaxElevation(tileID).minElevation ?? 0;
+	/** {@inheritDoc IControl.onRemove} */
+	onRemove() {
+		this._container.remove();
+		this._map.off("resize", this._updateCompact);
+		this._map = void 0;
+		this._compact = void 0;
 	}
-	/**
-	* Get the minimum and maximum elevation contained in a tile. This includes any
-	* exaggeration included in the terrain.
-	*
-	* @param tileID - ID of the tile to be used as a source for the min/max elevation
-	* @returns the minimum and maximum elevation found in the tile, including the terrain's
-	* exaggeration
-	*/
-	getMinMaxElevation(tileID) {
-		const tile = this.tileManager.getSourceTile(tileID, true);
-		const minMax = {
-			minElevation: null,
-			maxElevation: null
-		};
-		if (tile?.dem) {
-			minMax.minElevation = tile.dem.min * this.exaggeration;
-			minMax.maxElevation = tile.dem.max * this.exaggeration;
-		}
-		return minMax;
+};
+//#endregion
+//#region src/util/task_queue.ts
+var TaskQueue = class {
+	constructor() {
+		this._queue = [];
+		this._id = 0;
+		this._cleared = false;
+		this._currentlyRunning = false;
 	}
-	_getOverscaledTileIDFromLngLatZoom(lnglat, zoom) {
-		const mercatorCoordinate = MercatorCoordinate.fromLngLat(lnglat.wrap());
-		const worldSize = (1 << zoom) * EXTENT;
-		const mercatorX = mercatorCoordinate.x * worldSize;
-		const mercatorY = mercatorCoordinate.y * worldSize;
-		const tileX = Math.floor(mercatorX / EXTENT), tileY = Math.floor(mercatorY / EXTENT);
-		return {
-			tileID: new OverscaledTileID(zoom, 0, zoom, tileX, tileY),
-			mercatorX,
-			mercatorY
-		};
+	add(callback) {
+		const id = ++this._id;
+		this._queue.push({
+			callback,
+			id,
+			cancelled: false
+		});
+		return id;
 	}
-	/** Add an extra frame around the mesh to avoid hairline gaps (stitching) on tile boundaries with different zoomlevels.
-	* @see {@link MapOptions.terrainSkirtLength}
-	*/
-	_buildSkirts(vertexArray, indexArray, meshSize, delta, northPole, southPole) {
-		const offsetTop = vertexArray.length;
-		const offsetTopEdge = 0;
-		const offsetBottom = offsetTop + (meshSize + 1);
-		const offsetBottomEdge = (meshSize + 1) * meshSize;
-		const northY = northPole ? NORTH_POLE_Y : 0;
-		const northZ = northPole ? 0 : 1;
-		const southY = southPole ? SOUTH_POLE_Y : EXTENT;
-		const southZ = southPole ? 0 : 1;
-		for (let x = 0; x <= meshSize; x++) vertexArray.emplaceBack(x * delta, northY, northZ);
-		for (let x = 0; x <= meshSize; x++) vertexArray.emplaceBack(x * delta, southY, southZ);
-		for (let x = 0; x < meshSize; x++) {
-			indexArray.emplaceBack(offsetBottomEdge + x, offsetBottom + x, offsetBottom + x + 1);
-			indexArray.emplaceBack(offsetBottomEdge + x, offsetBottom + x + 1, offsetBottomEdge + x + 1);
-			indexArray.emplaceBack(offsetTopEdge + x, offsetTop + x + 1, offsetTop + x);
-			indexArray.emplaceBack(offsetTopEdge + x, offsetTopEdge + x + 1, offsetTop + x + 1);
+	remove(id) {
+		const running = this._currentlyRunning;
+		const queue = running ? this._queue.concat(running) : this._queue;
+		for (const task of queue) if (task.id === id) {
+			task.cancelled = true;
+			return;
 		}
-		const offsetLeft = vertexArray.length;
-		const offsetRight = offsetLeft + (meshSize + 1) * 2;
-		for (const x of [0, 1]) for (let y = 0; y <= meshSize; y++) for (const z of [0, 1]) vertexArray.emplaceBack(x * EXTENT, y * delta, z);
-		for (let y = 0; y < meshSize * 2; y += 2) {
-			indexArray.emplaceBack(offsetLeft + y, offsetLeft + y + 1, offsetLeft + y + 3);
-			indexArray.emplaceBack(offsetLeft + y, offsetLeft + y + 3, offsetLeft + y + 2);
-			indexArray.emplaceBack(offsetRight + y, offsetRight + y + 3, offsetRight + y + 1);
-			indexArray.emplaceBack(offsetRight + y, offsetRight + y + 2, offsetRight + y + 3);
+	}
+	run(timeStamp = 0) {
+		if (this._currentlyRunning) throw new Error("Attempting to run(), but is already running.");
+		const queue = this._currentlyRunning = this._queue;
+		this._queue = [];
+		for (const task of queue) {
+			if (task.cancelled) continue;
+			task.callback(timeStamp);
+			if (this._cleared) break;
 		}
+		this._cleared = false;
+		this._currentlyRunning = false;
+	}
+	clear() {
+		if (this._currentlyRunning) this._cleared = true;
+		this._queue = [];
 	}
 };
 //#endregion
@@ -23069,8 +23542,12 @@ var Map$1 = class extends Evented {
 				style: null,
 				images: null
 			};
-			this._setupPainter();
-			if (!this.painter) return;
+			try {
+				this._setupPainter();
+			} catch (error) {
+				this.fire(new ErrorEvent(error));
+				return;
+			}
 			this.resize();
 			this._update();
 			this._resizeInternal();
@@ -23135,13 +23612,17 @@ var Map$1 = class extends Evented {
 		this.cancelPendingTileRequestsWhileZooming = resolvedOptions.cancelPendingTileRequestsWhileZooming === true;
 		this.setAnisotropicFilterPitch(resolvedOptions.anisotropicFilterPitch);
 		if (resolvedOptions.reduceMotion !== void 0) browser.prefersReducedMotion = resolvedOptions.reduceMotion;
-		this._imageQueueHandle = ImageRequest.addThrottleControl(() => this.isMoving());
 		this._requestManager = new RequestManager(resolvedOptions.transformRequest);
 		this._container = this._resolveContainer(resolvedOptions.container);
 		if (resolvedOptions.maxBounds) this.setMaxBounds(resolvedOptions.maxBounds);
 		this._setupContainer();
-		this._setupPainter();
-		if (!this.painter) return;
+		try {
+			this._setupPainter();
+		} catch (error) {
+			this._cleanupContainer();
+			throw error;
+		}
+		this._imageQueueHandle = ImageRequest.addThrottleControl(() => this.isMoving());
 		this.on("move", () => this._update(false));
 		this.on("moveend", () => this._update(false));
 		this.on("zoom", () => this._update(true));
@@ -24116,14 +24597,17 @@ var Map$1 = class extends Evented {
 	/**
 	* Returns the map's minimum allowable zoom level.
 	*
+	* @param constrained - If `true`, returns the effective minimum zoom after applying the map's viewport constraints.
+	* If `false` or omitted, returns the configured minimum zoom.
 	* @returns minZoom
 	* @example
 	* ```ts
 	* let minZoom = map.getMinZoom();
 	* ```
 	*/
-	getMinZoom() {
-		return this._camera.transform.minZoom;
+	getMinZoom(constrained = false) {
+		const transform = this._camera.transform;
+		return constrained ? transform.applyConstrain(transform.center, transform.minZoom).zoom : transform.minZoom;
 	}
 	/**
 	* Sets or clears the map's maximum zoom level.
@@ -24918,10 +25402,11 @@ var Map$1 = class extends Evented {
 			this.painter.renderToTexture = new RenderToTexture(this.painter, this.terrain);
 			this._camera.terrain = this.terrain;
 			this._camera.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this._camera.transform.center, this._camera.transform.tileZoom));
-			this._camera.transform.setElevation(this.terrain.getElevationForLngLatZoom(this._camera.transform.center, this._camera.transform.tileZoom));
+			this._camera.transform.setElevation(this.terrain.getElevationForLngLat(this._camera.transform.center, this._camera.transform));
 			this._terrainDataCallback = (e) => this._handleTerrainDataEvent(e, options.source);
 			this.style.on("data", this._terrainDataCallback);
 		}
+		this.style.triggerSymbolPlacement();
 		this.fire(new MapTerrainEvent({ terrain: options }));
 		return this;
 	}
@@ -24931,10 +25416,13 @@ var Map$1 = class extends Evented {
 			return;
 		}
 		const isTerrainSourceEvent = event.sourceId === terrainSourceId;
-		if (isTerrainSourceEvent) this.terrain.resetElevationCache();
+		if (isTerrainSourceEvent) {
+			this.terrain.resetElevationCache();
+			this.style.triggerSymbolPlacement();
+		}
 		if (isTerrainSourceEvent && event.tile && !this._camera.elevationFreeze) {
 			this._camera.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this._camera.transform.center, this._camera.transform.tileZoom));
-			if (this.getCenterClampedToGround()) this._camera.transform.setElevation(this.terrain.getElevationForLngLatZoom(this._camera.transform.center, this._camera.transform.tileZoom));
+			if (this.getCenterClampedToGround()) this._camera.transform.setElevation(this.terrain.getElevationForLngLat(this._camera.transform.center, this._camera.transform));
 		}
 		if (!event.tile) return;
 		if (event.source?.type === "image") {
@@ -25589,6 +26077,42 @@ var Map$1 = class extends Evented {
 		return this.style.getGlyphsUrl();
 	}
 	/**
+	* Sets the value of the style's `font-faces` property, which points at the font files used to
+	* draw text that the style's `glyphs` URL does not cover. Pass a falsy value (null or undefined)
+	* to unset it.
+	*
+	* The files are handed to the browser's CSS Font Loading API, so any format the browser can
+	* render text with may be used, and requests for them go through `transformRequest` as glyph
+	* requests do. Text is drawn a grapheme cluster at a time, so a letter and the marks written on
+	* it are handed to the browser's text engine together and come back as the one shape they are
+	* written as -- which is what a `glyphs` URL, serving one codepoint at a time, cannot do.
+	*
+	* @param fontFaces - The font faces to set. Must conform to the [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/root/#font-faces).
+	* A declaration this cannot make sense of is skipped with a warning, as is a font file that
+	* fails to load, so the text it would have drawn falls back to the `glyphs` URL.
+	* @example
+	* ```ts
+	* map.setFontFaces({
+	*     'Noto Sans Regular': [
+	*         {url: 'https://example.com/NotoSansKhmer-Regular.ttf', 'unicode-range': ['U+1780-17FF']}
+	*     ]
+	* });
+	* ```
+	*/
+	setFontFaces(fontFaces) {
+		this._lazyInitEmptyStyle();
+		this.style.setFontFaces(fontFaces);
+		return this._update(true);
+	}
+	/**
+	* Returns the value of the style's `font-faces` property.
+	*
+	* @returns The style's font faces, or `null` if it declares none.
+	*/
+	getFontFaces() {
+		return this.style.getFontFaces();
+	}
+	/**
 	* Adds a sprite to the map's style. Fires the `style` event.
 	*
 	* @param id - The ID of the sprite to add. Must not conflict with existing sprites.
@@ -25924,12 +26448,28 @@ var Map$1 = class extends Evented {
 		]) positions[positionName] = DOM.create("div", `maplibregl-ctrl-${positionName} `, controlContainer);
 		this._container.addEventListener("scroll", this._onMapScroll, false);
 	}
+	/**
+	* @internal
+	* Reverses the DOM mutations of {@link Map._setupContainer}, returning the container element to its pre-construction state.
+	*/
+	_cleanupContainer() {
+		this._canvas.removeEventListener("webglcontextrestored", this._contextRestored, false);
+		this._canvas.removeEventListener("webglcontextlost", this._contextLost, false);
+		this._canvasContainer.remove();
+		this._controlContainer.remove();
+		this._container.removeEventListener("scroll", this._onMapScroll, false);
+		this._container.classList.remove("maplibregl-map");
+	}
 	_resizeCanvas(width, height, pixelRatio) {
 		this._canvas.width = Math.floor(pixelRatio * width);
 		this._canvas.height = Math.floor(pixelRatio * height);
 		this._canvas.style.width = `${width}px`;
 		this._canvas.style.height = `${height}px`;
 	}
+	/**
+	* @internal
+	* Creates the WebGL2 context and the painter. Throws {@link GPUInitializationError} when the context cannot be created.
+	*/
 	_setupPainter() {
 		const attributes = {
 			...this._canvasContextAttributes,
@@ -25943,10 +26483,7 @@ var Map$1 = class extends Evented {
 			creationEvent = event;
 		}, { once: true });
 		const gl = this._canvas.getContext("webgl2", attributes);
-		if (!gl) {
-			this.fire(new ErrorEvent(new GPUInitializationError(attributes, creationEvent)));
-			return;
-		}
+		if (!gl) throw new GPUInitializationError(attributes, creationEvent);
 		this.painter = new Painter(gl, this._camera.transform);
 	}
 	/**
@@ -26044,10 +26581,9 @@ var Map$1 = class extends Evented {
 			this.style._updateSources(this._camera.transform);
 		}
 		if (this.terrain) {
-			this.terrain.tileManager.update(this._camera.transform, this.terrain);
-			this.terrain.resetElevationCache();
+			if (this.terrain.tileManager.update(this._camera.transform, this.terrain)) this.terrain.resetElevationCache();
 			this._camera.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this._camera.transform.center, this._camera.transform.tileZoom));
-			if (!this._camera.elevationFreeze && this.getCenterClampedToGround()) this._camera.transform.setElevation(this.terrain.getElevationForLngLatZoom(this._camera.transform.center, this._camera.transform.tileZoom));
+			if (!this._camera.elevationFreeze && this.getCenterClampedToGround()) this._camera.transform.setElevation(this.terrain.getElevationForLngLat(this._camera.transform.center, this._camera.transform));
 		} else {
 			this._camera.transform.setMinElevationForCurrentTile(0);
 			if (this.getCenterClampedToGround()) this._camera.transform.setElevation(0);
@@ -26120,12 +26656,7 @@ var Map$1 = class extends Evented {
 		this._resizeObserver?.disconnect();
 		const extension = this.painter.context.gl.getExtension("WEBGL_lose_context");
 		if (extension?.loseContext) extension.loseContext();
-		this._canvas.removeEventListener("webglcontextrestored", this._contextRestored, false);
-		this._canvas.removeEventListener("webglcontextlost", this._contextLost, false);
-		this._canvasContainer.remove();
-		this._controlContainer.remove();
-		this._container.removeEventListener("scroll", this._onMapScroll, false);
-		this._container.classList.remove("maplibregl-map");
+		this._cleanupContainer();
 		this._removed = true;
 		this.fire(new MapLibreEvent("remove"));
 	}
@@ -26302,7 +26833,7 @@ var NavigationControl = class {
 		this._updateZoomButtons = () => {
 			const zoom = this._map.getZoom();
 			const isMax = zoom === this._map.getMaxZoom();
-			const isMin = zoom === this._map.getMinZoom();
+			const isMin = zoom === this._map.getMinZoom(true);
 			this._zoomInButton.disabled = isMax;
 			this._zoomOutButton.disabled = isMin;
 			this._zoomInButton.setAttribute("aria-disabled", isMax.toString());
@@ -26356,7 +26887,7 @@ var NavigationControl = class {
 		if (this.options.showZoom) {
 			this._setButtonTitle(this._zoomInButton, "ZoomIn");
 			this._setButtonTitle(this._zoomOutButton, "ZoomOut");
-			this._map.on("zoom", this._updateZoomButtons);
+			this._map.on("move", this._updateZoomButtons);
 			this._updateZoomButtons();
 		}
 		if (this.options.showCompass) {
@@ -26372,7 +26903,7 @@ var NavigationControl = class {
 	/** {@inheritDoc IControl.onRemove} */
 	onRemove() {
 		this._container.remove();
-		if (this.options.showZoom) this._map.off("zoom", this._updateZoomButtons);
+		if (this.options.showZoom) this._map.off("move", this._updateZoomButtons);
 		if (this.options.showCompass) {
 			if (this.options.visualizePitch) this._map.off("pitch", this._rotateCompassArrow);
 			if (this.options.visualizeRoll) this._map.off("roll", this._rotateCompassArrow);