maplibre-gl 6.0.0 → 6.2.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.0.0/LICENSE.txt
+* @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v6.2.0/LICENSE.txt
 */
-import { $n as findLineIntersection, $r as normalize, $t as validateStyle, A as earthRadius, Ai as rotate, Ar as warnOnce, At as SegmentVector, B as evaluateSizeForFeature, Bn as createMat4f64, Br as zero, Bt as isRasterStyleLayer, C as altitudeFromMercatorZ, Ci as rotateZ, Cn as addProtocol, Cr as rollPitchBearingToQuat, Ct as Uniform2f, D as mercatorYfromLat, Di as fromRotation, Dn as AbortError, Dr as threePlaneIntersection, Dt as UniformColorArray, E as mercatorXfromLng, Ei as create$4, En as config, Er as subscribe, Et as UniformColor, F as isBackgroundStyleLayer, Fn as bezier, Fr as create$3, Ft as PosArray, G as ImagePosition, Gn as degreesToRadians, Gr as transformMat4, Gt as EvaluationParameters, Hn as createVec4f64, Hr as slerp, Ht as Properties, I as isSymbolStyleLayer, In as clamp, Ir as length, It as QuadTriangleArray, J as parseGlyphPbf, Jn as easeCubicInOut, Jr as cross, Jt as ZoomHistory, K as potpack, Kn as differenceOfAnglesDegrees, Kr as add, L as SymbolBucket, Ln as clone$2, Lr as scale$1, Lt as RasterBoundsArray, M as createStyleLayer, Mi as offscreenCanvasSupported, Mn as angleToRotateBetweenVectors2D, Mr as zoomScale, Mt as CollisionCircleLayoutArray, N as isCustomStyleLayer, Ni as Point, Nn as arrayBufferToImage, Nr as pixelsToTileUnits, Nt as LineStripIndexArray, O as mercatorZfromAltitude, Oi as create$2, On as isAbortError, Or as translatePosition, Ot as UniformFloatArray, P as validateCustomStyleLayer, Pn as arrayBufferToImageBitmap, Pr as EXTENT, Pt as Pos3dArray, Qn as filterObject, Qr as negate, Qt as validateAndEmit, R as addDynamicAttributes, Rn as createIdentityMat4f32, Rr as sqrLen, Rt as TriangleIndexArray, S as MercatorCoordinate, Si as rotateY$1, Sn as sameOrigin, Sr as rollPitchBearingEqual, St as Uniform1i, T as lngFromMercatorX, Ti as translate, Tn as removeProtocol, Tr as sphericalToCartesian, Tt as Uniform4f, U as getAnchorAlignment, Un as deepEqual, Ur as mul, Ut as TRANSITION_SUFFIX, V as evaluateSizeForZoom, Vn as createVec3f64, Vr as fromEuler, Vt as DataConstantProperty, Wn as defaultEasing, Wr as scale$3, Wt as Transitionable, X as collisionCircleLayout, Xn as evaluateZoomSnap, Xr as len, Xt as SPEC_SOURCE_TYPES, Yn as ensureError, Yr as dot, Z as isLineStyleLayer, Zn as extend, Zr as length$1, Zt as emitValidationErrors, _ as OverscaledTileID, _i as invert$1, _n as getArrayBuffer, _r as pointPlaneSignedDistance, _t as RGBAImage, a as clipLine, ai as sub, an as derefLayers, ar as isImageBitmap, at as NORTH_POLE_Y, b as compareTileId, bi as perspective, bn as getVideo, br as readImageUsingVideoFrame, bt as toEvaluationFeature, ci as transformQuat, cn as featureFilter, cr as isTouchableEvent, ct as SubdivisionGranularitySetting, di as copy, dn as latest, dr as lerp, dt as Texture, ei as rotateX$1, en as validateStyleAndEmit, er as getAABB, et as isFillExtrusionStyleLayer, f as GEOJSON_TILE_LAYER_NAME, fi as create$1, fn as ErrorEvent, fr as mapObject, ft as isHillshadeStyleLayer, g as CanonicalTileID, gi as identity, gn as GLOBAL_DISPATCHER_ID, gr as pick, gt as AlphaImage, h as Bounds, hi as fromScaling, hn as AJAXError, hr as parseCacheControl, ht as renderColorRamp, ii as scaleAndAdd, ir as getRollPitchBearing, j as Actor, ji as isOffscreenCanvasDistorted, jn as MAX_VALID_LATITUDE, jr as wrap, jt as CollisionBoxArray, k as LngLat, ki as invert, kn as throwIfAborted, kr as uniqueId, kt as UniformMatrix4f, li as zero$1, lr as isTouchableOrPointableType, lt as isColorReliefStyleLayer, mi as exactEquals, mn as Evented, mr as nextPowerOfTwo, mt as isHeatmapStyleLayer, ni as rotateZ$1, nn as ProjectionDefinition, nr as getEdgeTiles, oi as transformMat3, on as diff, or as isPointableEvent, ot as SOUTH_POLE_Y, pi as equals, pn as Event, pr as mod, pt as HEATMAP_FULL_RENDER_FBO_KEY, q as renderStyleImage, qn as distanceOfAnglesRadians, qr as clone, qt as codePointUsesLocalIdeographFontFamily, r as TextAnchorEnum, ri as scale$2, rn as ValidationError, rt as isFillStyleLayer, s as TileCache, si as transformMat4$1, sn as emptyStyle, sr as isSafari, st as SubdivisionGranularityExpression, t as getAnchorJustification, ti as rotateY, tn as Color, tr as getAngleDelta, u as GeoJSONFeature, ui as clone$1, un as interpolateFactory, ur as isWorker, v as UnwrappedTileID, vi as multiply, vn as getJSON, vr as radiansToDegrees, vt as isCircleStyleLayer, w as latFromMercatorY, wi as scale, wn as getProtocol, wr as scaleZoom, wt as Uniform3f, x as isInBoundsForZoomLngLat, xi as rotateX, xn as makeRequest, xr as remapSaturate, xt as Uniform1f, y as calculateTileKey, yi as ortho, yn as getReferrer, yr as rayPlaneIntersection, yt as polygonIntersectsPolygon, z as getOverlapMode, zn as createIdentityMat4f64, zr as transformMat4$2, zt as createLayout } from "./maplibre-gl-shared-dev.mjs";
+import { $ as tileCoordinatesToMercatorCoordinates, $n as degreesToRadians, $r as clone, $t as EvaluationParameters, A as getOverlapMode, Ai as scale, An as sameOrigin, Ar as rollPitchBearingToQuat, At as Uniform1i, Bn as angleToRotateBetweenVectors2D, Br as pixelsToTileUnits, Bt as CollisionCircleLayoutArray, C as createStyleLayer, Ci as invert$1, Cn as AJAXError, Cr as pick, Ct as renderColorRamp, D as isSymbolStyleLayer, Di as rotateX, Dn as getReferrer, Dr as readImageUsingVideoFrame, Dt as polygonIntersectsPolygon, E as isBackgroundStyleLayer, Ei as perspective, En as getJSON, Er as rayPlaneIntersection, Et as isCircleStyleLayer, Fi as invert, Fn as AbortError, Fr as translatePosition, Ft as UniformColorArray, G as isFillExtrusionStyleLayer, Gn as clone$2, Gr as sqrLen, Gt as RasterBoundsArray, H as isLineStyleLayer, Hn as arrayBufferToImageBitmap, Hr as create$3, Ht as Pos3dArray, I as ImagePosition, Ii as rotate, In as isAbortError, Ir as uniqueId, It as UniformFloatArray, J as cameraDirectionFromPitchBearing, Jn as createMat4f64, Jr as slerp, Jt as isRasterStyleLayer, Kn as createIdentityMat4f32, Kr as zero, Kt as TriangleIndexArray, L as potpack, Li as isOffscreenCanvasDistorted, Ln as throwIfAborted, Lr as warnOnce, Lt as UniformMatrix4f, M as evaluateSizeForZoom, Mi as create$4, Mn as getProtocol, Mr as sphericalToCartesian, Mt as Uniform3f, Ni as fromRotation, Nn as removeProtocol, Nr as subscribe, Nt as Uniform4f, O as SymbolBucket, Oi as rotateY$1, On as getVideo, Or as remapSaturate, Ot as toEvaluationFeature, P as getAnchorAlignment, Pi as create$2, Pn as config, Pr as threePlaneIntersection, Pt as UniformColor, Q as projectToWorldCoordinates, Qn as defaultEasing, Qr as add, Qt as Transitionable, R as renderStyleImage, Ri as offscreenCanvasSupported, Rr as wrap, Rt as SegmentVector, S as Actor, Si as identity, Sn as Evented, Sr as parseCacheControl, St as isHeatmapStyleLayer, T as validateCustomStyleLayer, Ti as ortho, Tn as getArrayBuffer, Tr as radiansToDegrees, Tt as RGBAImage, Un as bezier, Ur as length, Ut as PosArray, V as collisionCircleLayout, Vn as arrayBufferToImage, Vr as EXTENT, Vt as LineStripIndexArray, Wn as clamp, Wr as scale$1, Wt as QuadTriangleArray, X as getMercatorHorizon, Xn as createVec4f64, Xr as scale$3, Xt as Properties, Y as cameraMercatorCoordinateFromCenterAndRotation, Yn as createVec3f64, Yr as mul, Yt as DataConstantProperty, Z as maxMercatorHorizonAngle, Zn as deepEqual, Zr as transformMat4, Zt as TRANSITION_SUFFIX, _ as OverscaledTileID, _i as copy, _r as isWorker, _t as isColorReliefStyleLayer, a as clipLine, ai as normalize, an as emitValidationErrors, ar as filterObject, at as mercatorXfromLng, b as compareTileId, bi as exactEquals, bn as ErrorEvent, br as mod, bt as isHillshadeStyleLayer, ci as rotateZ$1, cn as validateStyleAndEmit, cr as getAngleDelta, ct as LngLat, di as sub, dn as ValidationError, dr as getRollPitchBearing, dt as isFillStyleLayer, ei as cross, er as differenceOfAnglesDegrees, et as unprojectFromWorldCoordinates, f as GEOJSON_TILE_LAYER_NAME, fi as transformMat3, fr as isImageBitmap, g as CanonicalTileID, gi as clone$1, gn as featureFilter, gr as isTouchableOrPointableType, gt as SubdivisionGranularitySetting, h as Bounds, hi as zero$1, hn as emptyStyle, hr as isTouchableEvent, ht as SubdivisionGranularityExpression, ii as negate, in as SPEC_SOURCE_TYPES, ir as extend, it as lngFromMercatorX, j as evaluateSizeForFeature, ji as translate, jn as addProtocol, jr as scaleZoom, jt as Uniform2f, k as addDynamicAttributes, ki as rotateZ, kn as makeRequest, kr as rollPitchBearingEqual, kt as Uniform1f, li as scale$2, ln as Color, lr as getEdgeTiles, lt as earthRadius, mi as transformQuat, mn as diff, mr as isSafari, mt as SOUTH_POLE_Y, ni as len, nn as ZoomHistory, nr as ensureError, nt as altitudeFromMercatorZ, oi as rotateX$1, on as validateAndEmit, or as findLineIntersection, ot as mercatorYfromLat, pi as transformMat4$1, pn as derefLayers, pr as isPointableEvent, pt as NORTH_POLE_Y, q as calculateTileMatrix, qn as createIdentityMat4f64, qr as fromEuler, qt as createLayout, r as TextAnchorEnum, ri as length$1, rr as evaluateZoomSnap, rt as latFromMercatorY, s as TileCache, si as rotateY, sn as validateStyle, sr as getAABB, st as mercatorZfromAltitude, t as getAnchorJustification, ti as dot, tn as codePointUsesLocalIdeographFontFamily, tr as distanceOfAnglesRadians, tt as MercatorCoordinate, u as GeoJSONFeature, ui as scaleAndAdd, un as ProjectionDefinition, v as UnwrappedTileID, vi as create$1, vn as interpolateFactory, vr as lerp, w as isCustomStyleLayer, wi as multiply, wn as GLOBAL_DISPATCHER_ID, wr as pointPlaneSignedDistance, wt as AlphaImage, x as isInBoundsForZoomLngLat, xi as fromScaling, xn as Event, xr as nextPowerOfTwo, xt as HEATMAP_FULL_RENDER_FBO_KEY, y as calculateTileKey, yi as equals, yn as latest, yr as mapObject, yt as Texture, z as parseGlyphPbf, zi as Point, zn as MAX_VALID_LATITUDE, zr as zoomScale, zt as CollisionBoxArray } from "./maplibre-gl-shared-dev.mjs";
 //#region package.json
-var version$2 = "6.0.0";
+var version$2 = "6.2.0";
 //#endregion
 //#region src/util/browser.ts
 let linkEl;
@@ -709,7 +709,8 @@ async function loadSprite(originalSprite, requestManager, pixelRatio, abortContr
 	const jsonsMap = {};
 	const imagesMap = {};
 	for (const { id, url } of spriteArray) {
-		jsonsMap[id] = getJSON(await requestManager.transformRequest(normalizeSpriteURL(url, format, ".json"), "SpriteJSON"), abortController);
+		const jsonRequestParameters = await requestManager.transformRequest(normalizeSpriteURL(url, format, ".json"), "SpriteJSON");
+		jsonsMap[id] = getJSON(jsonRequestParameters, abortController);
 		const imageRequestParameters = await requestManager.transformRequest(normalizeSpriteURL(url, format, ".png"), "SpriteImage");
 		imagesMap[id] = ImageRequest.getImage(imageRequestParameters, abortController);
 	}
@@ -940,8 +941,8 @@ var ImageManager = class extends Evented {
 		if (pattern && pattern.position.version === image.version) return pattern.position;
 		if (!pattern) {
 			const bin = {
-				w: image.data.width + padding * 2,
-				h: image.data.height + padding * 2,
+				w: image.data.width + 2,
+				h: image.data.height + 2,
 				x: 0,
 				y: 0
 			};
@@ -1061,7 +1062,8 @@ var ImageManager = class extends Evented {
 async function loadGlyphRange(fontstack, range, urlTemplate, requestManager) {
 	const begin = range * 256;
 	const end = begin + 255;
-	const response = await getArrayBuffer(await requestManager.transformRequest(urlTemplate.replace("{fontstack}", fontstack).replace("{range}", `${begin}-${end}`), "Glyphs"), new AbortController());
+	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;
@@ -1280,7 +1282,9 @@ var GlyphManager = class GlyphManager {
 	}
 	_warnOnMissingGlyphRange(glyph, range, id, err) {
 		const begin = range * 256;
-		warnOnce(`Unable to load glyph range ${range}, ${begin}-${begin + 255}. Rendering codepoint U+${id.toString(16).padStart(4, "0").toUpperCase()} locally instead. ${err}`);
+		const end = begin + 255;
+		const codePoint = id.toString(16).padStart(4, "0").toUpperCase();
+		warnOnce(`Unable to load glyph range ${range}, ${begin}-${end}. Rendering codepoint U+${codePoint} locally instead. ${err}`);
 	}
 	/**
 	* Returns whether the given codepoint should be rendered locally.
@@ -1315,8 +1319,8 @@ var GlyphManager = class GlyphManager {
 		return {
 			id,
 			bitmap: new AlphaImage({
-				width: char.width || 30 * textureScale,
-				height: char.height || 30 * textureScale
+				width: char.width || 60,
+				height: char.height || 60
 			}, char.data),
 			metrics: {
 				width: isControl ? 0 : char.glyphWidth / textureScale || 24,
@@ -1332,7 +1336,7 @@ var GlyphManager = class GlyphManager {
 		const fontFamilies = stack ? stack.split(",") : [];
 		fontFamilies.push(defaultGenericFontFamily);
 		const fontFamily = fontFamilies.map((fontName) => /[-\w]+/.test(fontName) ? fontName : `'${CSS.escape(fontName)}'`).join(",");
-		const fontSize = 24 * textureScale;
+		const fontSize = 48;
 		const fontWeight = this._fontWeight(fontFamilies[0]);
 		const fontStyle = this._fontStyle(fontFamilies[0]);
 		if (typeof document !== "undefined" && document.fonts?.load) try {
@@ -1342,8 +1346,8 @@ var GlyphManager = class GlyphManager {
 		}
 		return new GlyphManager.TinySDF({
 			fontSize,
-			buffer: 3 * textureScale,
-			radius: 8 * textureScale,
+			buffer: 6,
+			radius: 16,
 			cutoff: .25,
 			fontFamily,
 			fontWeight,
@@ -1410,9 +1414,9 @@ const getProperties$2 = () => properties$2 = properties$2 || new Properties({
 //#endregion
 //#region src/style/light.ts
 var Light = class extends Evented {
-	constructor(lightOptions) {
+	constructor(lightOptions, globalState) {
 		super();
-		this._transitionable = new Transitionable(getProperties$2(), "light", void 0);
+		this._transitionable = new Transitionable(getProperties$2(), "light", globalState);
 		this.setLight(lightOptions);
 		this._transitioning = this._transitionable.untransitioned();
 	}
@@ -1461,9 +1465,9 @@ const getProperties$1 = () => properties$1 = properties$1 || new Properties({
 //#endregion
 //#region src/style/sky.ts
 var Sky = class extends Evented {
-	constructor(sky) {
+	constructor(sky, globalState) {
 		super();
-		this._transitionable = new Transitionable(getProperties$1(), "sky", void 0);
+		this._transitionable = new Transitionable(getProperties$1(), "sky", globalState);
 		this.setSky(sky);
 		this._transitioning = this._transitionable.untransitioned();
 		this.recalculate(new EvaluationParameters(0));
@@ -2777,9 +2781,10 @@ var RasterTileSource = class extends Evented {
 		const url = tile.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);
 		const premultiply = this._premultiplyAlpha;
 		const imageBitmapOptions = premultiply ? void 0 : { premultiplyAlpha: "none" };
+		const request = await this.map._requestManager.transformRequest(url, "Tile");
 		tile.abortController = new AbortController();
 		try {
-			const response = await ImageRequest.getImage(await this.map._requestManager.transformRequest(url, "Tile"), tile.abortController, this.map._refreshExpiredTiles, imageBitmapOptions);
+			const response = await ImageRequest.getImage(request, tile.abortController, this.map._refreshExpiredTiles, imageBitmapOptions);
 			delete tile.abortController;
 			if (tile.aborted) {
 				tile.state = "unloaded";
@@ -3184,9 +3189,7 @@ function getGeoJSONBounds(data) {
 		case "Feature":
 			coordinates = getCoordinatesFromGeometry(data.geometry);
 			break;
-		default:
-			coordinates = getCoordinatesFromGeometry(data);
-			break;
+		default: coordinates = getCoordinatesFromGeometry(data);
 	}
 	if (coordinates.length === 0) return bounds;
 	for (const coordinate of coordinates) {
@@ -3314,6 +3317,9 @@ var GeoJSONSource = class extends Evented {
 	_pixelsToTileUnits(pixelValue) {
 		return pixelValue * (EXTENT / this.tileSize);
 	}
+	_tileUnitsToPixels(tileUnitValue) {
+		return tileUnitValue / (EXTENT / this.tileSize);
+	}
 	_getClusterMaxZoom(clusterMaxZoom) {
 		const effectiveClusterMaxZoom = clusterMaxZoom ? Math.round(clusterMaxZoom) : this.maxzoom - 1;
 		if (!(Number.isInteger(clusterMaxZoom) || clusterMaxZoom === void 0)) warnOnce(`Integer expected for option 'clusterMaxZoom': provided value "${clusterMaxZoom}" rounded to "${effectiveClusterMaxZoom}"`);
@@ -3392,6 +3398,24 @@ var GeoJSONSource = class extends Evented {
 		return this._updateWorkerData();
 	}
 	/**
+	* Gets the cluster options currently configured on the source.
+	* The returned values mirror the options accepted by `setClusterOptions`.
+	*
+	* @returns the source's current cluster options
+	* @example
+	* ```ts
+	* const {cluster, clusterMaxZoom, clusterRadius} = map.getSource('some id').getClusterOptions();
+	* ```
+	*/
+	getClusterOptions() {
+		const { cluster, clusterOptions } = this.workerOptions.geojsonVtOptions;
+		return {
+			cluster,
+			clusterMaxZoom: clusterOptions.maxZoom,
+			clusterRadius: this._tileUnitsToPixels(clusterOptions.radius)
+		};
+	}
+	/**
 	* For clustered sources, fetches the zoom at which the given cluster expands.
 	*
 	* @param clusterId - The value of the cluster's `cluster_id` property.
@@ -3714,6 +3738,10 @@ var GeoJSONSource = class extends Evented {
 *    ]
 * })
 *
+* // update with an already-decoded image (no network request)
+* const bitmap = await createImageBitmap(myCanvas);
+* mySource.updateImage({image: bitmap});
+*
 * map.removeSource('some id');  // remove
 * ```
 */
@@ -3738,9 +3766,10 @@ var ImageSource = class extends Evented {
 		this._loaded = false;
 		this.fire(new MapSourceDataEvent("dataloading"));
 		this.url = this.options.url;
+		const request = await this.map._requestManager.transformRequest(this.url, "Image");
 		this._request = new AbortController();
 		try {
-			const image = await ImageRequest.getImage(await this.map._requestManager.transformRequest(this.url, "Image"), this._request);
+			const image = await ImageRequest.getImage(request, this._request);
 			this._request = null;
 			this._loaded = true;
 			if (image?.data) {
@@ -3758,17 +3787,29 @@ var ImageSource = class extends Evented {
 		return this._loaded;
 	}
 	/**
-	* Updates the image URL and, optionally, the coordinates. To avoid having the image flash after changing,
+	* Updates the image and, optionally, the coordinates. To avoid having the image flash after changing,
 	* set the `raster-fade-duration` paint property on the raster layer to 0.
 	*
+	* Provide exactly one of `url` (to fetch a new image over the network) or `image` (an
+	* already-decoded `HTMLImageElement`, `HTMLCanvasElement`, `ImageBitmap` or `ImageData` to
+	* display directly, without a network request).
+	*
 	* @param options - The options object.
 	*/
 	updateImage(options) {
-		if (!options.url) return this;
 		if (this._request) {
 			this._request.abort();
 			this._request = null;
 		}
+		if ("image" in options) {
+			this._loaded = true;
+			this.image = options.image;
+			if (options.coordinates) this.coordinates = options.coordinates;
+			this.texture = null;
+			this._finishLoading();
+			return this;
+		}
+		if (!options.url) return this;
 		this.options.url = options.url;
 		this.load(options.coordinates).finally(() => this.texture = null);
 		return this;
@@ -3863,9 +3904,11 @@ var ImageSource = class extends Evented {
 			const maxTileY = Math.floor(maxY * tilesAtZoom);
 			const minTileXWrapped = (minTileX % tilesAtZoom + tilesAtZoom) % tilesAtZoom;
 			const maxTileXWrapped = maxTileX % tilesAtZoom;
+			const minWrap = Math.floor(minTileX / tilesAtZoom);
+			const maxWrap = Math.floor(maxTileX / tilesAtZoom);
 			ranges[z] = {
-				minWrap: Math.floor(minTileX / tilesAtZoom),
-				maxWrap: Math.floor(maxTileX / tilesAtZoom),
+				minWrap,
+				maxWrap,
 				minTileXWrapped,
 				maxTileXWrapped,
 				minTileY,
@@ -4525,7 +4568,8 @@ var Tile = class {
 				const evaluationFeature = toEvaluationFeature(feature, true);
 				if (!filter.filter(new EvaluationParameters(this.tileID.overscaledZ), evaluationFeature, this.tileID.canonical)) continue;
 			} else if (!filter.filter(new EvaluationParameters(this.tileID.overscaledZ), feature)) continue;
-			const geojsonFeature = new GeoJSONFeature(feature, z, x, y, featureIndex.getId(feature, sourceLayer));
+			const id = featureIndex.getId(feature, sourceLayer);
+			const geojsonFeature = new GeoJSONFeature(feature, z, x, y, id);
 			geojsonFeature.tile = coord;
 			result.push(geojsonFeature);
 		}
@@ -4716,86 +4760,6 @@ var SourceFeatureState = class {
 	}
 };
 //#endregion
-//#region src/geo/projection/mercator_utils.ts
-const maxMercatorHorizonAngle = 89.25;
-/**
-* Returns mercator coordinates in range 0..1 for given coordinates inside a specified tile.
-* @param inTileX - X coordinate in tile units - range [0..EXTENT].
-* @param inTileY - Y coordinate in tile units - range [0..EXTENT].
-* @param canonicalTileID - Tile canonical ID - mercator X, Y and zoom.
-* @returns Mercator coordinates of the specified point in range [0..1].
-*/
-function tileCoordinatesToMercatorCoordinates(inTileX, inTileY, canonicalTileID) {
-	const scale = 1 / (1 << canonicalTileID.z);
-	return new MercatorCoordinate(inTileX / EXTENT * scale + canonicalTileID.x * scale, inTileY / EXTENT * scale + canonicalTileID.y * scale);
-}
-/**
-* Convert from LngLat to world coordinates (Mercator coordinates scaled by world size).
-* @param worldSize - Mercator world size computed from zoom level and tile size.
-* @param lnglat - The location to convert.
-* @returns Point
-*/
-function projectToWorldCoordinates(worldSize, lnglat) {
-	const lat = clamp(lnglat.lat, -MAX_VALID_LATITUDE, MAX_VALID_LATITUDE);
-	return new Point(mercatorXfromLng(lnglat.lng) * worldSize, mercatorYfromLat(lat) * worldSize);
-}
-/**
-* Convert from world coordinates (mercator coordinates scaled by world size) to LngLat.
-* @param worldSize - Mercator world size computed from zoom level and tile size.
-* @param point - World coordinate.
-* @returns LngLat
-*/
-function unprojectFromWorldCoordinates(worldSize, point) {
-	return new MercatorCoordinate(point.x / worldSize, point.y / worldSize).toLngLat();
-}
-/**
-* Calculate pixel height of the visible horizon in relation to map-center (e.g. height/2),
-* multiplied by a static factor to simulate the earth-radius.
-* The calculated value is the horizontal line from the camera-height to sea-level.
-* @returns Horizon above center in pixels.
-*/
-function getMercatorHorizon(transform) {
-	return transform.cameraToCenterDistance * Math.min(Math.tan(degreesToRadians(90 - transform.pitch)) * .85, Math.tan(degreesToRadians(maxMercatorHorizonAngle - transform.pitch)));
-}
-function calculateTileMatrix(unwrappedTileID, worldSize) {
-	const canonical = unwrappedTileID.canonical;
-	const scale$5 = worldSize / zoomScale(canonical.z);
-	const unwrappedX = canonical.x + Math.pow(2, canonical.z) * unwrappedTileID.wrap;
-	const worldMatrix = /* @__PURE__ */ new Float64Array(16);
-	identity(worldMatrix);
-	translate(worldMatrix, worldMatrix, [
-		unwrappedX * scale$5,
-		canonical.y * scale$5,
-		0
-	]);
-	scale(worldMatrix, worldMatrix, [
-		scale$5 / EXTENT,
-		scale$5 / EXTENT,
-		1
-	]);
-	return worldMatrix;
-}
-function cameraMercatorCoordinateFromCenterAndRotation(center, elevation, pitch, bearing, distance) {
-	const centerMercator = MercatorCoordinate.fromLngLat(center, elevation);
-	const dMercator = distance * mercatorZfromAltitude(1, center.lat);
-	const { x, y, z } = cameraDirectionFromPitchBearing(pitch, bearing);
-	const dxMercator = dMercator * -x;
-	const dyMercator = dMercator * -y;
-	const dzMercator = dMercator * -z;
-	return new MercatorCoordinate(centerMercator.x + dxMercator, centerMercator.y + dyMercator, centerMercator.z + dzMercator);
-}
-function cameraDirectionFromPitchBearing(pitch, bearing) {
-	const pitchRadians = degreesToRadians(pitch);
-	const bearingRadians = degreesToRadians(bearing);
-	const z = Math.cos(-pitchRadians);
-	const h = Math.sin(pitchRadians);
-	return {
-		x: h * Math.sin(bearingRadians),
-		y: -h * Math.cos(bearingRadians),
-		z
-	};
-}
-//#endregion
 //#region src/geo/projection/covering_tiles.ts
 /**
 * A simple/heuristic function that returns whether the tile is visible under the current transform.
@@ -4861,6 +4825,35 @@ function coveringZoomLevel(transform, options) {
 	return Math.max(0, z);
 }
 /**
+* Without terrain, `getTileBoundingVolume` has no knowledge of extruded features
+* (eg. 3D buildings): every tile's bounding box is flat at the camera's `elevation`.
+* That's a fine approximation of what's visible for most views, but it breaks down
+* as the frustum's bottom edge approaches horizontal (which depends on both `pitch`
+* and `fov`, not pitch alone) - a tall building can still be poking up into view
+* long after its tile's ground point has dropped out of the frustum.
+*
+* This is an assumed upper bound on real-world feature height (in metres), used to
+* grow the elevation used for tile culling as that bottom edge nears horizontal, so
+* such tiles are not dropped too early. It has no effect away from that edge case.
+*/
+const ASSUMED_MAX_FEATURE_HEIGHT_METERS = 500;
+/**
+* Angle between the frustum's bottom edge and the mercator horizon below which
+* the culling elevation starts to grow.
+*/
+const TILE_CULLING_HORIZON_ONSET_DEGREES = 15;
+/**
+* Returns the elevation to use when computing tile bounding volumes for culling:
+* `transform.elevation`, growing by up to `ASSUMED_MAX_FEATURE_HEIGHT_METERS` as
+* the frustum's bottom edge approaches the horizon, where a ground-level bounding
+* box would cull tiles whose extruded features are still visible.
+*/
+function getElevationForTileCulling(transform) {
+	const bottomEdgeDegreesAboveHorizontal = maxMercatorHorizonAngle - transform.pitch - transform.fov / 2;
+	const proximityToHorizon = clamp((TILE_CULLING_HORIZON_ONSET_DEGREES - bottomEdgeDegreesAboveHorizontal) / TILE_CULLING_HORIZON_ONSET_DEGREES, 0, 1);
+	return transform.elevation + proximityToHorizon * ASSUMED_MAX_FEATURE_HEIGHT_METERS;
+}
+/**
 * Returns a list of tiles that optimally covers the screen. Adapted for globe projection.
 * Correctly handles LOD when moving over the antimeridian.
 * @param transform - The transform instance.
@@ -4878,6 +4871,7 @@ function coveringTiles(transform, options) {
 	const cameraCoord = transform.screenPointToMercatorCoordinate(transform.getCameraPoint());
 	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);
 	const desiredZ = coveringZoomLevel(transform, options);
@@ -4924,7 +4918,7 @@ function coveringTiles(transform, options) {
 			y,
 			z: it.zoom
 		};
-		const boundingVolume = detailsProvider.getTileBoundingVolume(tileID, it.wrap, transform.elevation, options);
+		const boundingVolume = detailsProvider.getTileBoundingVolume(tileID, it.wrap, elevationForTileCulling, options);
 		if (!fullyVisible) {
 			const intersectResult = isTileVisible(frustum, boundingVolume, plane);
 			if (intersectResult === 0) continue;
@@ -5339,7 +5333,7 @@ var TileManager = class TileManager extends Evented {
 	}
 	/**
 	* Reload tiles based on the current state of the source.
-	* @param sourceDataChanged - If `true`, reload all tiles using a state of 'expired', otherwise reload only non-errored tiles using state of 'reloading'.
+	* @param sourceDataChanged - If `true`, reload all tiles using a state of 'expired' (errored tiles use 'loading' since they have nothing to show yet), otherwise reload only non-errored tiles using state of 'reloading'.
 	* @param shouldReloadTileOptions - Set of options associated with a `MapSourceDataChangedEvent` that can be passed back to the associated `Source` determine whether a tile should be reloaded.
 	*/
 	reload(sourceDataChanged, shouldReloadTileOptions = void 0) {
@@ -5351,7 +5345,7 @@ var TileManager = class TileManager extends Evented {
 		for (const id of this._inViewTiles.getAllIds()) {
 			const tile = this._inViewTiles.getTileById(id);
 			if (shouldReloadTileOptions && !this._source.shouldReloadTile(tile, shouldReloadTileOptions)) continue;
-			else if (sourceDataChanged) this._reloadTile(id, "expired");
+			else if (sourceDataChanged) this._reloadTile(id, tile.state === "errored" ? "loading" : "expired");
 			else if (tile.state !== "errored") this._reloadTile(id, "reloading");
 		}
 	}
@@ -6843,12 +6837,13 @@ var CollisionIndex = class {
 			const featureKey = feature.key;
 			if (seenFeatures[featureKey.bucketInstanceId] === void 0) seenFeatures[featureKey.bucketInstanceId] = {};
 			if (seenFeatures[featureKey.bucketInstanceId][featureKey.featureIndex]) continue;
-			if (!polygonIntersectsPolygon(query, [
+			const bbox = [
 				new Point(feature.x1, feature.y1),
 				new Point(feature.x2, feature.y1),
 				new Point(feature.x2, feature.y2),
 				new Point(feature.x1, feature.y2)
-			])) continue;
+			];
+			if (!polygonIntersectsPolygon(query, bbox)) continue;
 			seenFeatures[featureKey.bucketInstanceId][featureKey.featureIndex] = true;
 			if (result[featureKey.bucketInstanceId] === void 0) result[featureKey.bucketInstanceId] = [];
 			result[featureKey.bucketInstanceId].push(featureKey.featureIndex);
@@ -6971,7 +6966,8 @@ var CollisionIndex = class {
 			distanceMultiplier = Math.pow(2, -zoomFraction);
 			distanceMultiplier *= this.transform.getPitchedTextCorrection(translatedAnchorX, translatedAnchorY, unwrappedTileID);
 			if (!shift) {
-				const perspectiveRatio = clamp(.5 + .5 * (projectedPoint.signedDistanceFromCamera / this.transform.cameraToCenterDistance), 0, 4);
+				const distanceRatio = projectedPoint.signedDistanceFromCamera / this.transform.cameraToCenterDistance;
+				const perspectiveRatio = clamp(.5 + .5 * distanceRatio, 0, 4);
 				distanceMultiplier *= perspectiveRatio;
 			}
 		}
@@ -7829,7 +7825,7 @@ var KDBush = class KDBush {
 			this.coords = new ArrayType(data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
 			this._pos = 0;
 			this._finished = false;
-			new Uint8Array(data, 0, 2).set([219, (VERSION << 4) + arrayTypeIndex]);
+			new Uint8Array(data, 0, 2).set([219, 16 + arrayTypeIndex]);
 			new Uint16Array(data, 2, 1)[0] = nodeSize;
 			new Uint32Array(data, 4, 1)[0] = numItems;
 		}
@@ -8267,8 +8263,8 @@ var clipping_mask_fragment_glsl_g_default = "void main() {fragColor=vec4(1.0);}"
 //#region src/shaders/shaders.ts
 const shaders = {
 	prelude: prepare(_prelude_fragment_glsl_g_default, _prelude_vertex_glsl_g_default),
-	projectionMercator: prepare("", "float projectLineThickness(float tileY) {return 1.0;}float projectCircleRadius(float tileY) {return 1.0;}vec4 projectTile(vec2 p) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);return result;}vec4 projectTile(vec2 p,vec2 rawPos) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);if (rawPos.y <-32767.5 || rawPos.y > 32766.5) {result.z=-10000000.0;}return result;}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_projection_matrix*vec4(posInTile,elevation,1.0);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {return projectTileWithElevation(posInTile,elevation);}"),
-	projectionGlobe: prepare("", "#define GLOBE_RADIUS 6371008.8\nuniform highp vec4 u_projection_tile_mercator_coords;uniform highp vec4 u_projection_clipping_plane;uniform highp float u_projection_transition;uniform mat4 u_projection_fallback_matrix;vec3 globeRotateVector(vec3 vec,vec2 angles) {vec3 axisRight=vec3(vec.z,0.0,-vec.x);vec3 axisUp=cross(axisRight,vec);axisRight=normalize(axisRight);axisUp=normalize(axisUp);vec2 t=tan(angles);return normalize(vec+axisRight*t.x+axisUp*t.y);}mat3 globeGetRotationMatrix(vec3 spherePos) {vec3 axisRight=vec3(spherePos.z,0.0,-spherePos.x);vec3 axisDown=cross(axisRight,spherePos);axisRight=normalize(axisRight);axisDown=normalize(axisDown);return mat3(axisRight,axisDown,spherePos\n);}float circumferenceRatioAtTileY(float tileY) {float mercator_pos_y=u_projection_tile_mercator_coords.y+u_projection_tile_mercator_coords.w*tileY;float spherical_y=2.0*atan(exp(PI-(mercator_pos_y*PI*2.0)))-PI*0.5;return cos(spherical_y);}float projectLineThickness(float tileY) {float thickness=1.0/circumferenceRatioAtTileY(tileY); \nif (u_projection_transition < 0.999) {return mix(1.0,thickness,u_projection_transition);} else {return thickness;}}vec3 projectToSphere(vec2 translatedPos,vec2 rawPos) {vec2 mercator_pos=u_projection_tile_mercator_coords.xy+u_projection_tile_mercator_coords.zw*translatedPos;vec2 spherical;spherical.x=mercator_pos.x*PI*2.0+PI;spherical.y=2.0*atan(exp(PI-(mercator_pos.y*PI*2.0)))-PI*0.5;float len=cos(spherical.y);vec3 pos=vec3(sin(spherical.x)*len,sin(spherical.y),cos(spherical.x)*len\n);if (rawPos.y <-32767.5) {pos=vec3(0.0,1.0,0.0);}if (rawPos.y > 32766.5) {pos=vec3(0.0,-1.0,0.0);}return pos;}vec3 projectToSphere(vec2 posInTile) {return projectToSphere(posInTile,vec2(0.0,0.0));}float globeComputeClippingZ(vec3 spherePos) {return (1.0-(dot(spherePos,u_projection_clipping_plane.xyz)+u_projection_clipping_plane.w));}vec4 interpolateProjection(vec2 posInTile,vec3 spherePos,float elevation) {vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);globePosition.z=globeComputeClippingZ(elevatedPos)*globePosition.w;if (u_projection_transition > 0.999) {return globePosition;}vec4 flatPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);const float z_globeness_threshold=0.2;vec4 result=globePosition;result.z=mix(0.0,globePosition.z,clamp((u_projection_transition-z_globeness_threshold)/(1.0-z_globeness_threshold),0.0,1.0));result.xyw=mix(flatPosition.xyw,globePosition.xyw,u_projection_transition);if ((posInTile.y <-32767.5) || (posInTile.y > 32766.5)) {result=globePosition;const float poles_hidden_anim_percentage=0.02;result.z=mix(globePosition.z,100.0,pow(max((1.0-u_projection_transition)/poles_hidden_anim_percentage,0.0),8.0));}return result;}vec4 interpolateProjectionFor3D(vec2 posInTile,vec3 spherePos,float elevation) {vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);if (u_projection_transition > 0.999) {return globePosition;}vec4 fallbackPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);return mix(fallbackPosition,globePosition,u_projection_transition);}vec4 projectTile(vec2 posInTile) {return interpolateProjection(posInTile,projectToSphere(posInTile),0.0);}vec4 projectTile(vec2 posInTile,vec2 rawPos) {return interpolateProjection(posInTile,projectToSphere(posInTile,rawPos),0.0);}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return interpolateProjection(posInTile,projectToSphere(posInTile),elevation);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {vec3 spherePos=projectToSphere(posInTile,posInTile);return interpolateProjectionFor3D(posInTile,spherePos,elevation);}"),
+	projectionMercator: prepare("\nvoid clipAntimeridian() {}", "float projectLineThickness(float tileY) {return 1.0;}float projectCircleRadius(float tileY) {return 1.0;}vec4 projectTile(vec2 p) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);return result;}vec4 projectTile(vec2 p,vec2 rawPos) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);if (rawPos.y <-32767.5 || rawPos.y > 32766.5) {result.z=-10000000.0;}return result;}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_projection_matrix*vec4(posInTile,elevation,1.0);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {return projectTileWithElevation(posInTile,elevation);}"),
+	projectionGlobe: prepare("uniform bool u_projection_clip_antimeridian;in highp float v_projection_tile_x;void clipAntimeridian() {if (u_projection_clip_antimeridian && (v_projection_tile_x < 0.0 || v_projection_tile_x >=8192.0)) {discard;}}", "#define GLOBE_RADIUS 6371008.8\nuniform highp vec4 u_projection_tile_mercator_coords;uniform highp vec4 u_projection_clipping_plane;uniform highp float u_projection_transition;uniform mat4 u_projection_fallback_matrix;out highp float v_projection_tile_x;vec3 globeRotateVector(vec3 vec,vec2 angles) {vec3 axisRight=vec3(vec.z,0.0,-vec.x);vec3 axisUp=cross(axisRight,vec);axisRight=normalize(axisRight);axisUp=normalize(axisUp);vec2 t=tan(angles);return normalize(vec+axisRight*t.x+axisUp*t.y);}mat3 globeGetRotationMatrix(vec3 spherePos) {vec3 axisRight=vec3(spherePos.z,0.0,-spherePos.x);vec3 axisDown=cross(axisRight,spherePos);axisRight=normalize(axisRight);axisDown=normalize(axisDown);return mat3(axisRight,axisDown,spherePos\n);}float circumferenceRatioAtTileY(float tileY) {float mercator_pos_y=u_projection_tile_mercator_coords.y+u_projection_tile_mercator_coords.w*tileY;float t=exp(PI-(mercator_pos_y*PI*2.0));return (2.0*t)/(t*t+1.0);}float projectLineThickness(float tileY) {float thickness=1.0/circumferenceRatioAtTileY(tileY);if (u_projection_transition < 0.999) {return mix(1.0,thickness,u_projection_transition);} else {return thickness;}}vec3 projectToSphere(vec2 translatedPos,vec2 rawPos) {vec2 mercator_pos=u_projection_tile_mercator_coords.xy+u_projection_tile_mercator_coords.zw*translatedPos;float spherical_x=mercator_pos.x*PI*2.0+PI;float t=exp(PI-(mercator_pos.y*PI*2.0));float t2=t*t;float denom=t2+1.0;float sin_sy=(t2-1.0)/denom;float cos_sy=(2.0*t)/denom;vec3 pos=vec3(sin(spherical_x)*cos_sy,sin_sy,cos(spherical_x)*cos_sy\n);if (rawPos.y <-32767.5) {pos=vec3(0.0,1.0,0.0);}if (rawPos.y > 32766.5) {pos=vec3(0.0,-1.0,0.0);}return pos;}vec3 projectToSphere(vec2 posInTile) {return projectToSphere(posInTile,vec2(0.0,0.0));}float globeComputeClippingZ(vec3 spherePos) {return (1.0-(dot(spherePos,u_projection_clipping_plane.xyz)+u_projection_clipping_plane.w));}vec4 interpolateProjection(vec2 posInTile,vec3 spherePos,float elevation) {v_projection_tile_x=posInTile.x;vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);globePosition.z=globeComputeClippingZ(elevatedPos)*globePosition.w;if (u_projection_transition > 0.999) {return globePosition;}vec4 flatPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);const float z_globeness_threshold=0.2;vec4 result=globePosition;result.z=mix(0.0,globePosition.z,clamp((u_projection_transition-z_globeness_threshold)/(1.0-z_globeness_threshold),0.0,1.0));result.xyw=mix(flatPosition.xyw,globePosition.xyw,u_projection_transition);if ((posInTile.y <-32767.5) || (posInTile.y > 32766.5)) {result=globePosition;const float poles_hidden_anim_percentage=0.02;result.z=mix(globePosition.z,100.0,pow(max((1.0-u_projection_transition)/poles_hidden_anim_percentage,0.0),8.0));}return result;}vec4 interpolateProjectionFor3D(vec2 posInTile,vec3 spherePos,float elevation) {v_projection_tile_x=posInTile.x;vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);if (u_projection_transition > 0.999) {return globePosition;}vec4 fallbackPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);return mix(fallbackPosition,globePosition,u_projection_transition);}vec4 projectTile(vec2 posInTile) {return interpolateProjection(posInTile,projectToSphere(posInTile),0.0);}vec4 projectTile(vec2 posInTile,vec2 rawPos) {return interpolateProjection(posInTile,projectToSphere(posInTile,rawPos),0.0);}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return interpolateProjection(posInTile,projectToSphere(posInTile),elevation);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {vec3 spherePos=projectToSphere(posInTile,posInTile);return interpolateProjectionFor3D(posInTile,spherePos,elevation);}"),
 	background: prepare(background_fragment_glsl_g_default, background_vertex_glsl_g_default),
 	backgroundPattern: prepare(background_pattern_fragment_glsl_g_default, background_pattern_vertex_glsl_g_default),
 	circle: prepare(circle_fragment_glsl_g_default, circle_vertex_glsl_g_default),
@@ -8288,11 +8284,11 @@ const shaders = {
 	fillExtrusionPattern: prepare("uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;in vec2 v_pos_a;in vec2 v_pos_b;in vec4 v_lighting;\n#pragma maplibre: define lowp float base\n#pragma maplibre: define lowp float height\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float base\n#pragma maplibre: initialize lowp float height\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);fragColor=mixedColor*v_lighting;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec2 u_fill_translate;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp vec3 u_lightpos_globe;uniform lowp float u_lightintensity;layout(location=0) in vec2 a_pos;layout(location=1) in vec4 a_normal_ed;\n#ifdef TERRAIN3D\nlayout(location=2) in vec2 a_centroid;\n#endif\n#ifdef GLOBE\nout vec3 v_sphere_pos;\n#endif\nout vec2 v_pos_a;out vec2 v_pos_b;out vec4 v_lighting;\n#pragma maplibre: define lowp float base\n#pragma maplibre: define lowp float height\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float base\n#pragma maplibre: initialize lowp float height\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);float elevation=t > 0.0 ? height : base;vec2 posInTile=a_pos+u_fill_translate;\n#ifdef GLOBE\nvec3 spherePos=projectToSphere(posInTile,a_pos);vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);v_sphere_pos=elevatedPos;gl_Position=interpolateProjectionFor3D(posInTile,spherePos,elevation);\n#else\ngl_Position=u_projection_matrix*vec4(posInTile,elevation,1.0);\n#endif\nvec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0\n? a_pos\n: vec2(edgedistance,elevation*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}"),
 	hillshadePrepare: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack);}void main() {vec2 epsilon=1.0/u_dimension;float tileSize=u_dimension.x-2.0;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))*tileSize/pow(2.0,exaggeration+(28.2562-u_zoom));fragColor=clamp(vec4(deriv.x/8.0+0.5,deriv.y/8.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_dimension;layout(location=0) in vec2 a_pos;layout(location=1) in vec2 a_texture_pos;out vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}"),
 	hillshade: prepare("uniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_latrange;uniform float u_exaggeration;uniform vec4 u_accent;uniform int u_method;uniform float u_altitudes[NUM_ILLUMINATION_SOURCES];uniform float u_azimuths[NUM_ILLUMINATION_SOURCES];uniform vec4 u_shadows[NUM_ILLUMINATION_SOURCES];uniform vec4 u_highlights[NUM_ILLUMINATION_SOURCES];\n#define PI 3.141592653589793\n#define STANDARD 0\n#define COMBINED 1\n#define IGOR 2\n#define MULTIDIRECTIONAL 3\n#define BASIC 4\nfloat get_aspect(vec2 deriv){return deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);}void igor_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float aspect=get_aspect(deriv);float azimuth=u_azimuths[0]+PI;float slope_stength=atan(length(deriv))*2.0/PI;float aspect_strength=1.0-abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);float shadow_strength=slope_stength*aspect_strength;float highlight_strength=slope_stength*(1.0-aspect_strength);fragColor=u_shadows[0]*shadow_strength+u_highlights[0]*highlight_strength;}void standard_hillshade(vec2 deriv){float azimuth=u_azimuths[0]+PI;float slope=atan(0.625*length(deriv));float aspect=get_aspect(deriv);float intensity=u_exaggeration;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadows[0],u_highlights[0],shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);fragColor=accent_color*(1.0-shade_color.a)+shade_color;}void basic_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor=u_highlights[0]*(2.0*shade-1.0);}else\n{fragColor=u_shadows[0]*(1.0-2.0*shade);}}void multidirectional_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;fragColor=vec4(0,0,0,0);for(int i=0; i < NUM_ILLUMINATION_SOURCES; i++){float cos_alt=cos(u_altitudes[i]);float sin_alt=sin(u_altitudes[i]);float cos_az=-cos(u_azimuths[i]);float sin_az=-sin(u_azimuths[i]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor+=u_highlights[i]*(2.0*shade-1.0)/float(NUM_ILLUMINATION_SOURCES);}else\n{fragColor+=u_shadows[i]*(1.0-2.0*shade)/float(NUM_ILLUMINATION_SOURCES);}}}void combined_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=acos((sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv)));cang=clamp(cang,0.0,PI/2.0);float shade=cang*atan(length(deriv))*4.0/PI/PI;float highlight=(PI/2.0-cang)*atan(length(deriv))*4.0/PI/PI;fragColor=u_shadows[0]*shade+u_highlights[0]*highlight;}void main() {vec4 pixel=texture(u_image,v_pos);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));vec2 deriv=((pixel.rg*8.0)-4.0)/scaleFactor;if (u_method==BASIC) {basic_hillshade(deriv);} else if (u_method==COMBINED) {combined_hillshade(deriv);} else if (u_method==IGOR) {igor_hillshade(deriv);} else if (u_method==MULTIDIRECTIONAL) {multidirectional_hillshade(deriv);} else if (u_method==STANDARD) {standard_hillshade(deriv);} else {standard_hillshade(deriv);}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=projectTile(a_pos,a_pos);v_pos=a_pos/8192.0;if (a_pos.y <-32767.5) {v_pos.y=0.0;}if (a_pos.y > 32766.5) {v_pos.y=1.0;}}"),
-	line: prepare("uniform lowp float u_device_pixel_ratio;flat in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nfloat 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);fragColor=color*(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\nlayout(location=0) in vec2 a_pos_normal;layout(location=1) in vec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp float v_linesofar;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\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\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\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\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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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\nv_width2=vec2(outset,inset);}"),
-	lineGradient: prepare("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;flat in vec2 v_width2;in vec2 v_normal;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\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nfloat 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);fragColor=color*(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\nlayout(location=0) in vec2 a_pos_normal;layout(location=1) in vec4 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;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;\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\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\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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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\nv_width2=vec2(outset,inset);}"),
-	linePattern: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;in vec2 v_normal;flat in vec2 v_width2;in float v_linesofar;in float v_gamma_scale;flat in float v_width;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;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);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture(u_image,pos_a),texture(u_image,pos_b),u_fade);fragColor=color*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 vec2 a_pos_normal;layout(location=1) in vec4 a_data;uniform vec2 u_translation;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_linesofar;out float v_gamma_scale;flat out float v_width;\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 lowp float offset\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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\nv_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}"),
-	lineSDF: prepare("uniform lowp float u_device_pixel_ratio;uniform lowp float u_lineatlas_width;uniform sampler2D u_image;uniform float u_mix;in vec2 v_normal;flat in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\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 highp vec4 color\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\nfloat 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);float sdfdist_a=texture(u_image,v_tex_a).a;float sdfdist_b=texture(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0/u_device_pixel_ratio)/min(dasharray_from.w,dasharray_to.w);alpha*=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(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 vec2 a_pos_normal;layout(location=1) in vec4 a_data;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_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 vec2 v_tex_a;out vec2 v_tex_b;out float v_gamma_scale;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\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 highp vec4 color\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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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);}"),
-	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\nfloat 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 vec2 a_pos_normal;layout(location=1) in vec4 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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*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=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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);}"),
+	line: prepare("uniform lowp float u_device_pixel_ratio;flat in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\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);fragColor=color*(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\nlayout(location=0) in vec2 a_pos_normal;layout(location=1) in vec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp float v_linesofar;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\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\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\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\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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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\nv_width2=vec2(outset,inset);}"),
+	lineGradient: prepare("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;flat in vec2 v_width2;in vec2 v_normal;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\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\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);fragColor=color*(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\nlayout(location=0) in vec2 a_pos_normal;layout(location=1) in vec4 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;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;\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\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\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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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\nv_width2=vec2(outset,inset);}"),
+	linePattern: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;in vec2 v_normal;flat in vec2 v_width2;in float v_linesofar;in float v_gamma_scale;flat in float v_width;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nclipAntimeridian();vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;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);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture(u_image,pos_a),texture(u_image,pos_b),u_fade);fragColor=color*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 vec2 a_pos_normal;layout(location=1) in vec4 a_data;uniform vec2 u_translation;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_linesofar;out float v_gamma_scale;flat out float v_width;\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 lowp float offset\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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\nv_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}"),
+	lineSDF: prepare("uniform lowp float u_device_pixel_ratio;uniform lowp float u_lineatlas_width;uniform sampler2D u_image;uniform float u_mix;in vec2 v_normal;flat in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\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 highp vec4 color\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);float sdfdist_a=texture(u_image,v_tex_a).a;float sdfdist_b=texture(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0/u_device_pixel_ratio)/min(dasharray_from.w,dasharray_to.w);alpha*=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(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 vec2 a_pos_normal;layout(location=1) in vec4 a_data;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_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 vec2 v_tex_a;out vec2 v_tex_b;out float v_gamma_scale;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\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 highp vec4 color\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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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);}"),
+	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 vec2 a_pos_normal;layout(location=1) in vec4 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=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*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=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;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 vec2 v_pos0;in vec2 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);vec4 color1=texture(u_image1,v_pos1);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 vec4 u_coords_top;uniform vec4 u_coords_bottom;layout(location=0) in vec2 a_pos;out vec2 v_pos0;out vec2 v_pos1;void main() {vec2 fractionalPos=a_pos/8192.0;vec2 position=mix(mix(u_coords_top.xy,u_coords_top.zw,fractionalPos.x),mix(u_coords_bottom.xy,u_coords_bottom.zw,fractionalPos.x),fractionalPos.y);gl_Position=projectTile(position,position);v_pos0=((fractionalPos-0.5)/u_buffer_scale)+0.5;\n#ifdef GLOBE\nif (a_pos.y <-32767.5) {v_pos0.y=0.0;}if (a_pos.y > 32766.5) {v_pos0.y=1.0;}\n#endif\nv_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}"),
 	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 vec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in float 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=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);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;}"),
@@ -8301,7 +8297,6 @@ const shaders = {
 	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);}"),
-	projectionErrorMeasurement: prepare("flat in vec4 v_output_error_encoded;void main() {fragColor=v_output_error_encoded;}", "layout(location=0) in vec2 a_pos;uniform highp float u_input;uniform highp float u_output_expected;flat out vec4 v_output_error_encoded;void main() {float real_output=2.0*atan(exp(PI-(u_input*PI*2.0)))-PI*0.5;float error=real_output-u_output_expected;float abs_error=abs(error)*128.0;v_output_error_encoded.x=min(floor(abs_error*256.0),255.0)/255.0;abs_error-=v_output_error_encoded.x;v_output_error_encoded.y=min(floor(abs_error*65536.0),255.0)/255.0;abs_error-=v_output_error_encoded.x/255.0;v_output_error_encoded.z=min(floor(abs_error*16777216.0),255.0)/255.0;v_output_error_encoded.w=error >=0.0 ? 1.0 : 0.0;gl_Position=vec4(a_pos,0.0,1.0);}"),
 	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);}")
 };
@@ -8444,11 +8439,7 @@ var MercatorProjection = class {
 	get transitionState() {
 		return 0;
 	}
-	get latitudeErrorCorrectionRadians() {
-		return 0;
-	}
 	destroy() {}
-	updateGPUdependent(_) {}
 	getMeshFromTileID(context, _tileID, _hasBorder, _allowPoles, _usage) {
 		if (this._cachedMesh) return this._cachedMesh;
 		const tileExtentArray = new PosArray();
@@ -8469,7 +8460,6 @@ var MercatorProjection = class {
 	hasTransition() {
 		return false;
 	}
-	setErrorQueryLatitudeDegrees(_value) {}
 };
 //#endregion
 //#region src/geo/edge_insets.ts
@@ -8512,7 +8502,9 @@ var EdgeInsets = class EdgeInsets {
 	* @returns the point
 	*/
 	getCenter(width, height) {
-		return new Point(clamp((this.left + width - this.right) / 2, 0, width), clamp((this.top + height - this.bottom) / 2, 0, height));
+		const x = clamp((this.left + width - this.right) / 2, 0, width);
+		const y = clamp((this.top + height - this.bottom) / 2, 0, height);
+		return new Point(x, y);
 	}
 	equals(other) {
 		return this.top === other.top && this.bottom === other.bottom && this.left === other.left && this.right === other.right;
@@ -9164,13 +9156,13 @@ var MercatorCoveringTilesDetailsProvider = class {
 	* @param tileID - Tile x, y and z for zoom.
 	*/
 	getTileBoundingVolume(tileID, wrap, elevation, options) {
-		let minElevation = 0;
-		let maxElevation = 0;
+		let minElevation = Math.min(0, elevation);
+		let maxElevation = Math.max(0, elevation);
 		if (options?.terrain) {
 			const overscaledTileID = new OverscaledTileID(tileID.z, wrap, tileID.z, tileID.x, tileID.y);
 			const minMax = options.terrain.getMinMaxElevation(overscaledTileID);
-			minElevation = minMax.minElevation ?? Math.min(0, elevation);
-			maxElevation = minMax.maxElevation ?? Math.max(0, elevation);
+			minElevation = minMax.minElevation ?? minElevation;
+			maxElevation = minMax.maxElevation ?? maxElevation;
 		}
 		const numTiles = 1 << tileID.z;
 		return new Aabb([
@@ -9184,7 +9176,8 @@ var MercatorCoveringTilesDetailsProvider = class {
 		]);
 	}
 	allowVariableZoom(transform, options) {
-		const maxConstantZoomPitch = clamp(78.5 - transform.fov * (Math.abs(Math.cos(transform.rollInRadians)) * transform.height + Math.abs(Math.sin(transform.rollInRadians)) * transform.width) / transform.height / 2, 0, 60);
+		const zfov = transform.fov * (Math.abs(Math.cos(transform.rollInRadians)) * transform.height + Math.abs(Math.sin(transform.rollInRadians)) * transform.width) / transform.height;
+		const maxConstantZoomPitch = clamp(78.5 - zfov / 2, 0, 60);
 		return !!options.terrain || transform.pitch > maxConstantZoomPitch;
 	}
 	allowWorldCopies() {
@@ -9318,7 +9311,9 @@ var Frustum = class Frustum {
 		const frustumCoords = clipSpaceCorners.map((v) => unprojectClipSpacePoint(v, invProj, worldSize, scale));
 		if (horizonPlane) adjustFarPlaneByHorizonPlane(frustumCoords, frustumPlanePointIndices[0], horizonPlane, flippedNearFar);
 		const frustumPlanes = frustumPlanePointIndices.map((p) => {
-			const n = normalize([], cross([], sub([], frustumCoords[p[0]], frustumCoords[p[1]]), sub([], frustumCoords[p[2]], frustumCoords[p[1]])));
+			const a = sub([], frustumCoords[p[0]], frustumCoords[p[1]]);
+			const b = sub([], frustumCoords[p[2]], frustumCoords[p[1]]);
+			const n = normalize([], cross([], a, b));
 			const d = -dot(n, frustumCoords[p[1]]);
 			return n.concat(d);
 		});
@@ -9412,12 +9407,15 @@ function getNormalizedNearPlane(frustumCoords, nearPlanePointsIndices) {
 * Returns the ideal distance between the frustum's near and far plane so that the far plane only lies as far as the horizon.
 */
 function getIdealNearFarPlaneDistance(horizonPlane, nearPlaneNormalized) {
-	const normalizedHorizonPlane = scale$3([], horizonPlane, 1 / len(horizonPlane));
+	const horizonPlaneLen = len(horizonPlane);
+	const normalizedHorizonPlane = scale$3([], horizonPlane, 1 / horizonPlaneLen);
 	const projectedViewDirection = sub([], nearPlaneNormalized, scale$2([], normalizedHorizonPlane, dot(nearPlaneNormalized, normalizedHorizonPlane)));
 	const projectedViewLength = len(projectedViewDirection);
 	if (projectedViewLength > 0) {
 		const horizonCircleRadius = Math.sqrt(1 - normalizedHorizonPlane[3] * normalizedHorizonPlane[3]);
-		return pointPlaneSignedDistance(nearPlaneNormalized, add([], scale$2([], normalizedHorizonPlane, -normalizedHorizonPlane[3]), scale$2([], projectedViewDirection, horizonCircleRadius / projectedViewLength)));
+		const horizonCircleCenter = scale$2([], normalizedHorizonPlane, -normalizedHorizonPlane[3]);
+		const pointFurthestOnHorizonCircle = add([], horizonCircleCenter, scale$2([], projectedViewDirection, horizonCircleRadius / projectedViewLength));
+		return pointPlaneSignedDistance(nearPlaneNormalized, pointFurthestOnHorizonCircle);
 	} else return null;
 }
 //#endregion
@@ -9612,7 +9610,7 @@ var MercatorTransform = class MercatorTransform {
 	get autoCalculateNearFarZ() {
 		return this._helper.autoCalculateNearFarZ;
 	}
-	setTransitionState(_value, _error) {}
+	setTransitionState(_value) {}
 	constructor(options) {
 		this._posMatrixCache = /* @__PURE__ */ new Map();
 		this._alignedPosMatrixCache = /* @__PURE__ */ new Map();
@@ -9624,7 +9622,7 @@ var MercatorTransform = class MercatorTransform {
 				zoom
 			};
 			let lngRange = this._helper._lngRange;
-			if (!this._helper._renderWorldCopies && lngRange === null) lngRange = [-179.9999999999, 179.9999999999];
+			if (!this._helper._renderWorldCopies && lngRange === null) lngRange = [-179.9999999999, 180 - 1e-10];
 			const worldSize = this.tileSize * zoomScale(result.zoom);
 			let minY = 0;
 			let maxY = worldSize;
@@ -9649,7 +9647,8 @@ var MercatorTransform = class MercatorTransform {
 			let modifiedX, modifiedY;
 			const scale = Math.max(scaleX || 0, scaleY || 0);
 			if (scale) {
-				result.center = unprojectFromWorldCoordinates(worldSize, new Point(scaleX ? (maxX + minX) / 2 : originalX, scaleY ? (maxY + minY) / 2 : originalY)).wrap();
+				const newPoint = new Point(scaleX ? (maxX + minX) / 2 : originalX, scaleY ? (maxY + minY) / 2 : originalY);
+				result.center = unprojectFromWorldCoordinates(worldSize, newPoint).wrap();
 				result.zoom += scaleZoom(scale);
 				return result;
 			}
@@ -9666,7 +9665,10 @@ var MercatorTransform = class MercatorTransform {
 				if (wrappedX - w2 < minX) modifiedX = minX + w2;
 				if (wrappedX + w2 > maxX) modifiedX = maxX - w2;
 			}
-			if (modifiedX !== void 0 || modifiedY !== void 0) result.center = unprojectFromWorldCoordinates(worldSize, new Point(modifiedX ?? originalX, modifiedY ?? originalY)).wrap();
+			if (modifiedX !== void 0 || modifiedY !== void 0) {
+				const newPoint = new Point(modifiedX ?? originalX, modifiedY ?? originalY);
+				result.center = unprojectFromWorldCoordinates(worldSize, newPoint).wrap();
+			}
 			return result;
 		};
 		this.applyConstrain = (lngLat, zoom) => {
@@ -10020,7 +10022,8 @@ var MercatorTransform = class MercatorTransform {
 				0
 			],
 			projectionTransition: 0,
-			fallbackMatrix: mainMatrix
+			fallbackMatrix: mainMatrix,
+			clipAntimeridian: false
 		};
 	}
 	isLocationOccluded(_) {
@@ -10159,7 +10162,9 @@ function cameraForBoxAndBearing(options, padding, bounds, bearing, tr) {
 	}
 	const zoom = Math.min(scaleZoom(tr.scale * Math.min(scaleX, scaleY)), options.maxZoom);
 	const offset = Point.convert(options.offset);
-	const rotatedPaddingOffset = new Point((padding.left - padding.right) / 2, (padding.top - padding.bottom) / 2).rotate(degreesToRadians(bearing));
+	const paddingOffsetX = (padding.left - padding.right) / 2;
+	const paddingOffsetY = (padding.top - padding.bottom) / 2;
+	const rotatedPaddingOffset = new Point(paddingOffsetX, paddingOffsetY).rotate(degreesToRadians(bearing));
 	const offsetAtFinalZoom = offset.add(rotatedPaddingOffset).mult(tr.scale / zoomScale(zoom));
 	return {
 		center: unprojectFromWorldCoordinates(tr.worldSize, nwWorld.add(seWorld).div(2).sub(offsetAtFinalZoom)),
@@ -10290,238 +10295,6 @@ var MercatorCameraHelper = class {
 let properties;
 const getProperties = () => properties = properties || new Properties({ "type": new DataConstantProperty(latest["projection"]["type"], "type") });
 //#endregion
-//#region src/webgl/color_mode.ts
-const ZERO = 0;
-const ONE = 1;
-const ONE_MINUS_SRC_ALPHA = 771;
-var ColorMode = class {
-	constructor(blendFunction, blendColor, mask) {
-		this.blendFunction = blendFunction;
-		this.blendColor = blendColor;
-		this.mask = mask;
-	}
-};
-ColorMode.Replace = [ONE, ZERO];
-ColorMode.disabled = new ColorMode(ColorMode.Replace, Color.transparent, [
-	false,
-	false,
-	false,
-	false
-]);
-ColorMode.unblended = new ColorMode(ColorMode.Replace, Color.transparent, [
-	true,
-	true,
-	true,
-	true
-]);
-ColorMode.alphaBlended = new ColorMode([ONE, ONE_MINUS_SRC_ALPHA], Color.transparent, [
-	true,
-	true,
-	true,
-	true
-]);
-//#endregion
-//#region src/webgl/cull_face_mode.ts
-const FRONT = 1028;
-const BACK = 1029;
-const CCW = 2305;
-var CullFaceMode = class {
-	constructor(enable, mode, frontFace) {
-		this.enable = enable;
-		this.mode = mode;
-		this.frontFace = frontFace;
-	}
-};
-CullFaceMode.disabled = new CullFaceMode(false, BACK, CCW);
-CullFaceMode.backCCW = new CullFaceMode(true, BACK, CCW);
-CullFaceMode.frontCCW = new CullFaceMode(true, FRONT, CCW);
-//#endregion
-//#region src/webgl/depth_mode.ts
-const ALWAYS$1 = 519;
-var DepthMode = class {
-	constructor(depthFunc, depthMask, depthRange) {
-		this.func = depthFunc;
-		this.mask = depthMask;
-		this.range = depthRange;
-	}
-};
-DepthMode.ReadOnly = false;
-DepthMode.ReadWrite = true;
-DepthMode.disabled = new DepthMode(ALWAYS$1, DepthMode.ReadOnly, [0, 1]);
-//#endregion
-//#region src/webgl/stencil_mode.ts
-const ALWAYS = 519;
-const KEEP = 7680;
-var StencilMode = class {
-	constructor(test, ref, mask, fail, depthFail, pass) {
-		this.test = test;
-		this.ref = ref;
-		this.mask = mask;
-		this.fail = fail;
-		this.depthFail = depthFail;
-		this.pass = pass;
-	}
-};
-StencilMode.disabled = new StencilMode({
-	func: ALWAYS,
-	mask: 0
-}, 0, 0, KEEP, KEEP, KEEP);
-//#endregion
-//#region src/webgl/program/projection_error_measurement_program.ts
-const projectionErrorMeasurementUniforms = (context, locations) => ({
-	"u_input": new Uniform1f(context, locations.u_input),
-	"u_output_expected": new Uniform1f(context, locations.u_output_expected)
-});
-const projectionErrorMeasurementUniformValues = (input, outputExpected) => ({
-	"u_input": input,
-	"u_output_expected": outputExpected
-});
-//#endregion
-//#region src/geo/projection/globe_projection_error_measurement.ts
-/**
-* For vector globe the vertex shader projects mercator coordinates to angular coordinates on a sphere.
-* This projection requires some inverse trigonometry `atan(exp(...))`, which is inaccurate on some GPUs (mainly on AMD and Nvidia).
-* The inaccuracy is severe enough to require a workaround. The uncorrected map is shifted north-south by up to several hundred meters in some latitudes.
-* Since the inaccuracy is hardware-dependant and may change in the future, we need to measure the error at runtime.
-*
-* Our approach relies on several assumptions:
-*
-* - the error is only present in the "latitude" component (longitude doesn't need any inverse trigonometry)
-* - the error is continuous and changes slowly with latitude
-* - at zoom levels where the error is noticeable, the error is more-or-less the same across the entire visible map area (and thus can be described with a single number)
-*
-* Solution:
-*
-* Every few frames, launch a GPU shader that measures the error for the current map center latitude, and writes it to a 1x1 texture.
-* Read back that texture, and offset the globe projection matrix according to the error (interpolating smoothly from old error to new error if needed).
-* The texture readback is done asynchronously using Pixel Pack Buffers (WebGL2) when possible, and has a few frames of latency, but that should not be a problem.
-*
-* General operation of this class each frame is:
-*
-* - render the error shader into a fbo, read that pixel into a PBO, place a fence
-* - wait a few frames to allow the GPU (and driver) to actually execute the shader
-* - wait for the fence to be signalled (guaranteeing the shader to actually be executed)
-* - read back the PBO's contents
-* - wait a few more frames
-* - repeat
-*/
-var ProjectionErrorMeasurement = class ProjectionErrorMeasurement {
-	get awaitingQuery() {
-		return !!this._readbackQueue;
-	}
-	constructor(renderContext) {
-		this._readbackWaitFrames = 4;
-		this._measureWaitFrames = 6;
-		this._texWidth = 1;
-		this._texHeight = 1;
-		this._measuredError = 0;
-		this._updateCount = 0;
-		this._lastReadbackFrame = -1e3;
-		this._readbackQueue = null;
-		this._cachedRenderContext = renderContext;
-		const context = renderContext.context;
-		const gl = context.gl;
-		this._texFormat = gl.RGBA;
-		this._texType = gl.UNSIGNED_BYTE;
-		const vertexArray = new PosArray();
-		vertexArray.emplaceBack(-1, -1);
-		vertexArray.emplaceBack(2, -1);
-		vertexArray.emplaceBack(-1, 2);
-		const indexArray = new TriangleIndexArray();
-		indexArray.emplaceBack(0, 1, 2);
-		this._fullscreenTriangle = new Mesh(context.createVertexBuffer(vertexArray, posAttributes.members), context.createIndexBuffer(indexArray), SegmentVector.simpleSegment(0, 0, vertexArray.length, indexArray.length));
-		this._resultBuffer = /* @__PURE__ */ new Uint8Array(4);
-		context.activeTexture.set(gl.TEXTURE1);
-		const texture = gl.createTexture();
-		gl.bindTexture(gl.TEXTURE_2D, texture);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-		gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, this._texWidth, this._texHeight);
-		this._fbo = context.createFramebuffer(this._texWidth, this._texHeight, false, false);
-		this._fbo.colorAttachment.set(texture);
-		this._pbo = gl.createBuffer();
-		gl.bindBuffer(gl.PIXEL_PACK_BUFFER, this._pbo);
-		gl.bufferData(gl.PIXEL_PACK_BUFFER, 4, gl.STREAM_READ);
-		gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-	}
-	destroy() {
-		const gl = this._cachedRenderContext.context.gl;
-		this._fullscreenTriangle.destroy();
-		this._fbo.destroy();
-		gl.deleteBuffer(this._pbo);
-		this._fullscreenTriangle = null;
-		this._fbo = null;
-		this._pbo = null;
-		this._resultBuffer = null;
-	}
-	updateErrorLoop(normalizedMercatorY, expectedAngleY) {
-		const currentFrame = this._updateCount;
-		if (this._readbackQueue) {
-			if (currentFrame >= this._readbackQueue.frameNumberIssued + this._readbackWaitFrames) this._tryReadback();
-		} else if (currentFrame >= this._lastReadbackFrame + this._measureWaitFrames) this._renderErrorTexture(normalizedMercatorY, expectedAngleY);
-		this._updateCount++;
-		return this._measuredError;
-	}
-	_bindFramebuffer() {
-		const context = this._cachedRenderContext.context;
-		const gl = context.gl;
-		context.activeTexture.set(gl.TEXTURE1);
-		gl.bindTexture(gl.TEXTURE_2D, this._fbo.colorAttachment.get());
-		context.bindFramebuffer.set(this._fbo.framebuffer);
-	}
-	_renderErrorTexture(input, outputExpected) {
-		const context = this._cachedRenderContext.context;
-		const gl = context.gl;
-		this._bindFramebuffer();
-		context.viewport.set([
-			0,
-			0,
-			this._texWidth,
-			this._texHeight
-		]);
-		context.clear({ color: Color.transparent });
-		this._cachedRenderContext.useProgram("projectionErrorMeasurement").draw(context, gl.TRIANGLES, DepthMode.disabled, StencilMode.disabled, ColorMode.unblended, CullFaceMode.disabled, projectionErrorMeasurementUniformValues(input, outputExpected), null, null, "$clipping", this._fullscreenTriangle.vertexBuffer, this._fullscreenTriangle.indexBuffer, this._fullscreenTriangle.segments);
-		gl.bindBuffer(gl.PIXEL_PACK_BUFFER, this._pbo);
-		gl.readBuffer(gl.COLOR_ATTACHMENT0);
-		gl.readPixels(0, 0, this._texWidth, this._texHeight, this._texFormat, this._texType, 0);
-		gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-		const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
-		gl.flush();
-		this._readbackQueue = {
-			frameNumberIssued: this._updateCount,
-			sync
-		};
-	}
-	_tryReadback() {
-		const gl = this._cachedRenderContext.context.gl;
-		if (!this._readbackQueue) return;
-		const waitResult = gl.clientWaitSync(this._readbackQueue.sync, 0, 0);
-		if (waitResult === gl.WAIT_FAILED) {
-			warnOnce("WebGL2 clientWaitSync failed.");
-			this._readbackQueue = null;
-			this._lastReadbackFrame = this._updateCount;
-			return;
-		}
-		if (waitResult === gl.TIMEOUT_EXPIRED) return;
-		gl.bindBuffer(gl.PIXEL_PACK_BUFFER, this._pbo);
-		gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, this._resultBuffer, 0, 4);
-		gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-		this._readbackQueue = null;
-		this._measuredError = ProjectionErrorMeasurement._parseRGBA8float(this._resultBuffer);
-		this._lastReadbackFrame = this._updateCount;
-	}
-	static _parseRGBA8float(buffer) {
-		let result = 0;
-		result += buffer[0] / 256;
-		result += buffer[1] / 65536;
-		result += buffer[2] / 16777216;
-		if (buffer[3] < 127) result = -result;
-		return result / 128;
-	}
-};
-//#endregion
 //#region src/util/create_tile_mesh.ts
 /**
 * The size of border region for stencil masks, in internal tile coordinates.
@@ -10622,7 +10395,6 @@ function createTileMesh(options, forceIndicesSize) {
 //#region src/geo/projection/vertical_perspective_projection.ts
 const VerticalPerspectiveShaderDefine = "#define GLOBE";
 const VerticalPerspectiveShaderVariantKey = "globe";
-const globeConstants = { errorTransitionTimeSeconds: .5 };
 const granularitySettingsGlobe = new SubdivisionGranularitySetting({
 	fill: new SubdivisionGranularityExpression(128, 2),
 	line: new SubdivisionGranularityExpression(512, 0),
@@ -10633,10 +10405,6 @@ const granularitySettingsGlobe = new SubdivisionGranularitySetting({
 var VerticalPerspectiveProjection = class {
 	constructor() {
 		this._tileMeshCache = {};
-		this._errorCorrectionUsable = 0;
-		this._errorMeasurementLastValue = 0;
-		this._errorCorrectionPreviousValue = 0;
-		this._errorMeasurementLastChangeTime = -1e3;
 	}
 	get name() {
 		return "vertical-perspective";
@@ -10665,35 +10433,7 @@ var VerticalPerspectiveProjection = class {
 	get useGlobeControls() {
 		return true;
 	}
-	/**
-	* @internal
-	* Globe projection periodically measures the error of the GPU's
-	* projection from mercator to globe and computes how much to correct
-	* the globe's latitude alignment.
-	* This stores the correction that should be applied to the projection matrix.
-	*/
-	get latitudeErrorCorrectionRadians() {
-		return this._errorCorrectionUsable;
-	}
-	destroy() {
-		if (this._errorMeasurement) this._errorMeasurement.destroy();
-	}
-	updateGPUdependent(renderContext) {
-		this._errorMeasurement ||= new ProjectionErrorMeasurement(renderContext);
-		const mercatorY = mercatorYfromLat(this._errorQueryLatitudeDegrees);
-		const expectedResult = 2 * Math.atan(Math.exp(Math.PI - mercatorY * Math.PI * 2)) - Math.PI * .5;
-		const newValue = this._errorMeasurement.updateErrorLoop(mercatorY, expectedResult);
-		const currentTime = now();
-		if (newValue !== this._errorMeasurementLastValue) {
-			this._errorCorrectionPreviousValue = this._errorCorrectionUsable;
-			this._errorMeasurementLastValue = newValue;
-			this._errorMeasurementLastChangeTime = currentTime;
-		}
-		const sinceUpdateSeconds = (currentTime - this._errorMeasurementLastChangeTime) / 1e3;
-		const mix = Math.min(Math.max(sinceUpdateSeconds / globeConstants.errorTransitionTimeSeconds, 0), 1);
-		const newCorrection = -this._errorMeasurementLastValue;
-		this._errorCorrectionUsable = lerp(this._errorCorrectionPreviousValue, newCorrection, easeCubicInOut(mix));
-	}
+	destroy() {}
 	_getMeshKey(options) {
 		return `${options.granularity.toString(36)}_${options.generateBorders ? "b" : ""}${options.extendToNorthPole ? "n" : ""}${options.extendToSouthPole ? "s" : ""}`;
 	}
@@ -10717,22 +10457,15 @@ var VerticalPerspectiveProjection = class {
 	}
 	recalculate(_params) {}
 	hasTransition() {
-		const currentTime = now();
-		let dirty = false;
-		dirty ||= (currentTime - this._errorMeasurementLastChangeTime) / 1e3 < globeConstants.errorTransitionTimeSeconds + .2;
-		dirty ||= this._errorMeasurement?.awaitingQuery;
-		return dirty;
-	}
-	setErrorQueryLatitudeDegrees(value) {
-		this._errorQueryLatitudeDegrees = value;
+		return false;
 	}
 };
 //#endregion
 //#region src/geo/projection/globe_projection.ts
 var GlobeProjection = class extends Evented {
-	constructor(projection) {
+	constructor(projection, globalState) {
 		super();
-		this._transitionable = new Transitionable(getProperties(), "projection", void 0);
+		this._transitionable = new Transitionable(getProperties(), "projection", globalState);
 		this.setProjection(projection);
 		this._transitioning = this._transitionable.untransitioned();
 		this.recalculate(new EvaluationParameters(0));
@@ -10744,6 +10477,7 @@ var GlobeProjection = class extends Evented {
 		if (typeof currentProjectionSpecValue === "string" && currentProjectionSpecValue === "mercator") return 0;
 		if (typeof currentProjectionSpecValue === "string" && currentProjectionSpecValue === "vertical-perspective") return 1;
 		if (currentProjectionSpecValue instanceof ProjectionDefinition) {
+			if (currentProjectionSpecValue.from === currentProjectionSpecValue.to) return currentProjectionSpecValue.from === "mercator" ? 0 : 1;
 			if (currentProjectionSpecValue.from === "vertical-perspective" && currentProjectionSpecValue.to === "mercator") return 1 - currentProjectionSpecValue.transition;
 			if (currentProjectionSpecValue.from === "mercator" && currentProjectionSpecValue.to === "vertical-perspective") return currentProjectionSpecValue.transition;
 		}
@@ -10752,9 +10486,6 @@ var GlobeProjection = class extends Evented {
 	get useGlobeRendering() {
 		return this.transitionState > 0;
 	}
-	get latitudeErrorCorrectionRadians() {
-		return this._verticalPerspectiveProjection.latitudeErrorCorrectionRadians;
-	}
 	get currentProjection() {
 		return this.useGlobeRendering ? this._verticalPerspectiveProjection : this._mercatorProjection;
 	}
@@ -10786,10 +10517,6 @@ var GlobeProjection = class extends Evented {
 		this._mercatorProjection.destroy();
 		this._verticalPerspectiveProjection.destroy();
 	}
-	updateGPUdependent(context) {
-		this._mercatorProjection.updateGPUdependent(context);
-		this._verticalPerspectiveProjection.updateGPUdependent(context);
-	}
 	getMeshFromTileID(context, _tileID, _hasBorder, _allowPoles, _usage) {
 		return this.currentProjection.getMeshFromTileID(context, _tileID, _hasBorder, _allowPoles, _usage);
 	}
@@ -10805,10 +10532,6 @@ var GlobeProjection = class extends Evented {
 	recalculate(parameters) {
 		this.properties = this._transitioning.possiblyEvaluate(parameters);
 	}
-	setErrorQueryLatitudeDegrees(value) {
-		this._verticalPerspectiveProjection.setErrorQueryLatitudeDegrees(value);
-		this._mercatorProjection.setErrorQueryLatitudeDegrees(value);
-	}
 };
 //#endregion
 //#region src/geo/projection/globe_utils.ts
@@ -10817,7 +10540,9 @@ function getGlobeCircumferencePixels(transform) {
 	return 2 * Math.PI * radius;
 }
 function globeDistanceOfLocationsPixels(transform, a, b) {
-	const dot$2 = dot(angularCoordinatesToSurfaceVector(a), angularCoordinatesToSurfaceVector(b));
+	const vecA = angularCoordinatesToSurfaceVector(a);
+	const vecB = angularCoordinatesToSurfaceVector(b);
+	const dot$2 = dot(vecA, vecB);
 	const radians = Math.acos(dot$2);
 	const circumference = getGlobeCircumferencePixels(transform);
 	return radians / (2 * Math.PI) * circumference;
@@ -10883,7 +10608,8 @@ function sphereSurfacePointToCoordinates(surface) {
 		const projX = surface[0] / lengthXZ;
 		const projZ = surface[2] / lengthXZ;
 		const acosZ = Math.acos(projZ);
-		return new LngLat(wrap((projX > 0 ? acosZ : -acosZ) / Math.PI * 180, -180, 180), latDegrees);
+		const lngDegrees = (projX > 0 ? acosZ : -acosZ) / Math.PI * 180;
+		return new LngLat(wrap(lngDegrees, -180, 180), latDegrees);
 	} else return new LngLat(0, latDegrees);
 }
 /**
@@ -10929,7 +10655,8 @@ function planetScaleAtLatitude(latitudeDegrees) {
 */
 function getZoomAdjustment(oldLat, newLat) {
 	const oldCircumference = planetScaleAtLatitude(oldLat);
-	return scaleZoom(planetScaleAtLatitude(newLat) / oldCircumference);
+	const newCircumference = planetScaleAtLatitude(newLat);
+	return scaleZoom(newCircumference / oldCircumference);
 }
 function getDegreesPerPixel(worldSize, lat) {
 	return 360 / getGlobeCircumferencePixels({
@@ -10977,8 +10704,12 @@ function interpolateLngLatForGlobe(start, deltaLng, deltaLat, t) {
 		const valueStart = integrateSecX(samplePointStart);
 		const valueEnd = integrateSecX(samplePointEnd);
 		const newT = (valueT - valueStart) / (valueEnd - valueStart);
-		return new LngLat(start.lng + deltaLng * newT, interpolatedLat);
-	} else return new LngLat(start.lng + deltaLng * t, interpolatedLat);
+		const interpolatedLng = start.lng + deltaLng * newT;
+		return new LngLat(interpolatedLng, interpolatedLat);
+	} else {
+		const interpolatedLng = start.lng + deltaLng * t;
+		return new LngLat(interpolatedLng, interpolatedLat);
+	}
 }
 //#endregion
 //#region src/util/primitives/bounding_volume_cache.ts
@@ -11006,7 +10737,7 @@ var BoundingVolumeCache = class {
 	* @param tileID - Tile x, y and z for zoom.
 	*/
 	getTileBoundingVolume(tileID, wrap, elevation, options) {
-		const key = `${tileID.z}_${tileID.x}_${tileID.y}_${options?.terrain ? "t" : ""}`;
+		const key = `${tileID.z}_${tileID.x}_${tileID.y}_${options?.terrain ? "t" : ""}_${Math.round(elevation)}`;
 		const cached = this._cache.get(key);
 		if (cached) return cached;
 		const cachedPrevious = this._cachePrevious.get(key);
@@ -11244,9 +10975,8 @@ var GlobeCoveringTilesDetailsProvider = class {
 		const tileMercatorSize = 1 / scale;
 		const tileCornerX = tileID.x / scale;
 		const tileCornerY = tileID.y / scale;
-		const worldSize = 1;
-		const halfWorld = .5 * worldSize;
-		let smallestDistance = 2 * worldSize;
+		const halfWorld = .5;
+		let smallestDistance = 2;
 		smallestDistance = Math.min(smallestDistance, distanceToTileWrapX(pointX, pointY, tileCornerX, tileCornerY, tileMercatorSize));
 		smallestDistance = Math.min(smallestDistance, distanceToTileWrapX(pointX, pointY, tileCornerX + halfWorld, -tileCornerY - tileMercatorSize, tileMercatorSize));
 		smallestDistance = Math.min(smallestDistance, distanceToTileWrapX(pointX, pointY, tileCornerX + halfWorld, 2 - tileCornerY - tileMercatorSize, tileMercatorSize));
@@ -11277,13 +11007,13 @@ var GlobeCoveringTilesDetailsProvider = class {
 		return this._boundingVolumeCache.getTileBoundingVolume(tileID, wrap, elevation, options);
 	}
 	_computeTileBoundingVolume(tileID, wrap, elevation, options) {
-		let minElevation = 0;
-		let maxElevation = 0;
+		let minElevation = Math.min(0, elevation);
+		let maxElevation = Math.max(0, elevation);
 		if (options?.terrain) {
 			const overscaledTileID = new OverscaledTileID(tileID.z, wrap, tileID.z, tileID.x, tileID.y);
 			const minMax = options.terrain.getMinMaxElevation(overscaledTileID);
-			minElevation = minMax.minElevation ?? Math.min(0, elevation);
-			maxElevation = minMax.maxElevation ?? Math.max(0, elevation);
+			minElevation = minMax.minElevation ?? minElevation;
+			maxElevation = minMax.maxElevation ?? maxElevation;
 		}
 		minElevation /= earthRadius;
 		maxElevation /= earthRadius;
@@ -11608,11 +11338,10 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		this._cachedClippingPlane = createVec4f64();
 		this._projectionMatrix = createIdentityMat4f64();
 		this._globeViewProjMatrix32f = createIdentityMat4f32();
-		this._globeViewProjMatrixNoCorrection = createIdentityMat4f64();
-		this._globeViewProjMatrixNoCorrectionInverted = createIdentityMat4f64();
+		this._globeViewProjMatrixF64 = createIdentityMat4f64();
+		this._globeViewProjMatrixF64Inverted = createIdentityMat4f64();
 		this._globeProjMatrixInverted = createIdentityMat4f64();
 		this._cameraPosition = createVec3f64();
-		this._globeLatitudeErrorCorrectionRadians = 0;
 		this.defaultConstrain = (lngLat, zoom) => {
 			const constrainedLat = clamp(lngLat.lat, -MAX_VALID_LATITUDE, MAX_VALID_LATITUDE);
 			const constrainedZoom = clamp(+zoom, this.minZoom + getZoomAdjustment(0, constrainedLat), this.maxZoom);
@@ -11637,15 +11366,14 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		clone.apply(this, false);
 		return clone;
 	}
-	apply(that, constrain, globeLatitudeErrorCorrectionRadians) {
-		this._globeLatitudeErrorCorrectionRadians = globeLatitudeErrorCorrectionRadians || 0;
+	apply(that, constrain) {
 		this._helper.apply(that, constrain);
 	}
 	get projectionMatrix() {
 		return this._projectionMatrix;
 	}
 	get modelViewProjectionMatrix() {
-		return this._globeViewProjMatrixNoCorrection;
+		return this._globeViewProjMatrixF64;
 	}
 	get inverseProjectionMatrix() {
 		return this._globeProjMatrixInverted;
@@ -11668,7 +11396,8 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 			tileMercatorCoords: mercatorTileCoordinates,
 			clippingPlane: this._cachedClippingPlane,
 			projectionTransition: applyGlobeMatrix ? 1 : 0,
-			fallbackMatrix: this._globeViewProjMatrix32f
+			fallbackMatrix: this._globeViewProjMatrix32f,
+			clipAntimeridian: overscaledTileID?.canonical.z === 0
 		};
 	}
 	_computeClippingPlane(globeRadiusPixels) {
@@ -11766,7 +11495,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 			spherePos[2] * vectorMultiplier,
 			1
 		];
-		transformMat4(pos, pos, this._globeViewProjMatrixNoCorrection);
+		transformMat4(pos, pos, this._globeViewProjMatrixF64);
 		const plane = this._cachedClippingPlane;
 		const isOccluded = plane[0] * spherePos[0] + plane[1] * spherePos[1] + plane[2] * spherePos[2] + plane[3] < 0;
 		return {
@@ -11779,7 +11508,6 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		if (!this._helper._width || !this._helper._height) return;
 		const globeRadiusPixels = getGlobeRadiusPixels(this.worldSize, this.center.lat);
 		const globeMatrix = createMat4f64();
-		const globeMatrixUncorrected = createMat4f64();
 		if (this._helper.autoCalculateNearFarZ) {
 			this._helper._nearZ = .5;
 			this._helper._farZ = this.cameraToCenterDistance + globeRadiusPixels * 2;
@@ -11808,16 +11536,13 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		scaleVec[0] = globeRadiusPixels;
 		scaleVec[1] = globeRadiusPixels;
 		scaleVec[2] = globeRadiusPixels;
-		rotateX(globeMatrixUncorrected, globeMatrix, this.center.lat * Math.PI / 180);
-		rotateY$1(globeMatrixUncorrected, globeMatrixUncorrected, -this.center.lng * Math.PI / 180);
-		scale(globeMatrixUncorrected, globeMatrixUncorrected, scaleVec);
-		this._globeViewProjMatrixNoCorrection = globeMatrixUncorrected;
-		rotateX(globeMatrix, globeMatrix, this.center.lat * Math.PI / 180 - this._globeLatitudeErrorCorrectionRadians);
+		rotateX(globeMatrix, globeMatrix, this.center.lat * Math.PI / 180);
 		rotateY$1(globeMatrix, globeMatrix, -this.center.lng * Math.PI / 180);
 		scale(globeMatrix, globeMatrix, scaleVec);
+		this._globeViewProjMatrixF64 = globeMatrix;
 		this._globeViewProjMatrix32f = new Float32Array(globeMatrix);
-		this._globeViewProjMatrixNoCorrectionInverted = createMat4f64();
-		invert$1(this._globeViewProjMatrixNoCorrectionInverted, globeMatrixUncorrected);
+		this._globeViewProjMatrixF64Inverted = createMat4f64();
+		invert$1(this._globeViewProjMatrixF64Inverted, globeMatrix);
 		const zero = createVec3f64();
 		this._cameraPosition = createVec3f64();
 		this._cameraPosition[2] = this.cameraToCenterDistance / globeRadiusPixels;
@@ -11832,7 +11557,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		rotateX$1(this._cameraPosition, this._cameraPosition, zero, -this.center.lat * Math.PI / 180);
 		rotateY(this._cameraPosition, this._cameraPosition, zero, this.center.lng * Math.PI / 180);
 		this._cachedClippingPlane = this._computeClippingPlane(globeRadiusPixels);
-		const matrix = clone$1(this._globeViewProjMatrixNoCorrectionInverted);
+		const matrix = clone$1(this._globeViewProjMatrixF64Inverted);
 		scale(matrix, matrix, [
 			1,
 			1,
@@ -11878,7 +11603,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		return this._helper.getCameraLngLat();
 	}
 	lngLatToCameraDepth(lngLat, elevation) {
-		if (!this._globeViewProjMatrixNoCorrection) return 1;
+		if (!this._globeViewProjMatrixF64) return 1;
 		const vec = angularCoordinatesToSurfaceVector(lngLat);
 		scale$2(vec, vec, 1 + elevation / earthRadius);
 		const result = createVec4f64();
@@ -11887,7 +11612,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 			vec[1],
 			vec[2],
 			1
-		], this._globeViewProjMatrixNoCorrection);
+		], this._globeViewProjMatrixF64);
 		return result[2] / result[3];
 	}
 	populateCache(_coords) {}
@@ -12004,7 +11729,10 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	}
 	locationToScreenPoint(lnglat, terrain) {
 		const pos = angularCoordinatesToSurfaceVector(lnglat);
-		if (terrain) scale$2(pos, pos, 1 + terrain.getElevationForLngLatZoom(lnglat, this._helper._tileZoom) / earthRadius);
+		if (terrain) {
+			const elevation = terrain.getElevationForLngLatZoom(lnglat, this._helper._tileZoom);
+			scale$2(pos, pos, 1 + elevation / earthRadius);
+		}
 		return this._projectSurfacePointToScreen(pos);
 	}
 	/**
@@ -12013,7 +11741,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	*/
 	_projectSurfacePointToScreen(pos) {
 		const projected = createVec4f64();
-		transformMat4(projected, [...pos, 1], this._globeViewProjMatrixNoCorrection);
+		transformMat4(projected, [...pos, 1], this._globeViewProjMatrixF64);
 		projected[0] /= projected[3];
 		projected[1] /= projected[3];
 		return new Point((projected[0] * .5 + .5) * this.width, (-projected[1] * .5 + .5) * this.height);
@@ -12042,7 +11770,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		pos[1] = (p.y / this.height * 2 - 1) * -1;
 		pos[2] = 1;
 		pos[3] = 1;
-		transformMat4(pos, pos, this._globeViewProjMatrixNoCorrectionInverted);
+		transformMat4(pos, pos, this._globeViewProjMatrixF64Inverted);
 		pos[0] /= pos[3];
 		pos[1] /= pos[3];
 		pos[2] /= pos[3];
@@ -12069,7 +11797,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	isSurfacePointOnScreen(vec) {
 		if (!this.isSurfacePointVisible(vec)) return false;
 		const projected = createVec4f64();
-		transformMat4(projected, [...vec, 1], this._globeViewProjMatrixNoCorrection);
+		transformMat4(projected, [...vec, 1], this._globeViewProjMatrixF64);
 		projected[0] /= projected[3];
 		projected[1] /= projected[3];
 		projected[2] /= projected[3];
@@ -12370,9 +12098,8 @@ var GlobeTransform = class GlobeTransform {
 	get isGlobeRendering() {
 		return this._globeness > 0;
 	}
-	setTransitionState(globeness, errorCorrectionValue) {
+	setTransitionState(globeness) {
 		this._globeness = globeness;
-		this._globeLatitudeErrorCorrectionRadians = errorCorrectionValue;
 		this._calcMatrices();
 		this._verticalPerspectiveTransform.getCoveringTilesDetailsProvider().prepareNextFrame();
 		this._mercatorTransform.getCoveringTilesDetailsProvider().prepareNextFrame();
@@ -12381,7 +12108,6 @@ var GlobeTransform = class GlobeTransform {
 		return this.isGlobeRendering ? this._verticalPerspectiveTransform : this._mercatorTransform;
 	}
 	constructor(options) {
-		this._globeLatitudeErrorCorrectionRadians = 0;
 		this._globeness = 1;
 		this.defaultConstrain = (lngLat, zoom) => {
 			return this.currentTransform.defaultConstrain(lngLat, zoom);
@@ -12402,14 +12128,13 @@ var GlobeTransform = class GlobeTransform {
 	clone() {
 		const clone = new GlobeTransform();
 		clone._globeness = this._globeness;
-		clone._globeLatitudeErrorCorrectionRadians = this._globeLatitudeErrorCorrectionRadians;
 		clone.apply(this, false);
 		return clone;
 	}
 	apply(that, constrain) {
 		this._helper.apply(that, constrain);
 		this._mercatorTransform.apply(this, false);
-		this._verticalPerspectiveTransform.apply(this, false, this._globeLatitudeErrorCorrectionRadians);
+		this._verticalPerspectiveTransform.apply(this, false);
 	}
 	get projectionMatrix() {
 		return this.currentTransform.projectionMatrix;
@@ -12431,7 +12156,8 @@ var GlobeTransform = class GlobeTransform {
 			clippingPlane: verticalPerspectiveProjectionData.clippingPlane,
 			tileMercatorCoords: verticalPerspectiveProjectionData.tileMercatorCoords,
 			projectionTransition: params.applyGlobeMatrix ? this._globeness : 0,
-			fallbackMatrix: mercatorProjectionData.fallbackMatrix
+			fallbackMatrix: mercatorProjectionData.fallbackMatrix,
+			clipAntimeridian: verticalPerspectiveProjectionData.clipAntimeridian
 		};
 	}
 	isLocationOccluded(location) {
@@ -12447,14 +12173,16 @@ var GlobeTransform = class GlobeTransform {
 		return lerp(this._mercatorTransform.getCircleRadiusCorrection(), this._verticalPerspectiveTransform.getCircleRadiusCorrection(), this._globeness);
 	}
 	getPitchedTextCorrection(textAnchorX, textAnchorY, tileID) {
-		return lerp(this._mercatorTransform.getPitchedTextCorrection(textAnchorX, textAnchorY, tileID), this._verticalPerspectiveTransform.getPitchedTextCorrection(textAnchorX, textAnchorY, tileID), this._globeness);
+		const mercatorCorrection = this._mercatorTransform.getPitchedTextCorrection(textAnchorX, textAnchorY, tileID);
+		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);
 	}
 	_calcMatrices() {
 		if (!this._helper._width || !this._helper._height) return;
-		this._verticalPerspectiveTransform.apply(this, false, this._globeLatitudeErrorCorrectionRadians);
+		this._verticalPerspectiveTransform.apply(this, false);
 		this._helper._nearZ = this._verticalPerspectiveTransform.nearZ;
 		this._helper._farZ = this._verticalPerspectiveTransform.farZ;
 		this._mercatorTransform.apply(this, true, this.isGlobeRendering);
@@ -12760,7 +12488,8 @@ var VerticalPerspectiveCameraHelper = class VerticalPerspectiveCameraHelper {
 		const requestedMinZoom = typeof options.minZoom === "number" ? +options.minZoom : tr.minZoom;
 		const normalizedEffectiveMinZoom = Math.max(requestedMinZoom, tr.minZoom) + getZoomAdjustment(targetCenter.lat, 0);
 		const minZoomPreConstrain = Math.min(normalizedEffectiveMinZoom, normalizedStartZoom, normalizedTargetZoom) + getZoomAdjustment(0, targetCenter.lat);
-		const scaleOfMinZoom = zoomScale(tr.applyConstrain(targetCenter, minZoomPreConstrain).zoom + getZoomAdjustment(targetCenter.lat, 0) - normalizedStartZoom);
+		const normalizedMinZoom = tr.applyConstrain(targetCenter, minZoomPreConstrain).zoom + getZoomAdjustment(targetCenter.lat, 0);
+		const scaleOfMinZoom = zoomScale(normalizedMinZoom - normalizedStartZoom);
 		const deltaLng = differenceOfAnglesDegrees(startCenter.lng, targetCenter.lng);
 		const deltaLat = differenceOfAnglesDegrees(startCenter.lat, targetCenter.lat);
 		const easeFunc = (k, scale, centerFactor, _pointAtOffset) => {
@@ -12875,10 +12604,10 @@ var GlobeCameraHelper = class {
 };
 //#endregion
 //#region src/geo/projection/projection_factory.ts
-function createProjectionFromName(name, transformConstrain) {
+function createProjectionFromName(name, transformConstrain, globalState) {
 	const transformOptions = { constrainOverride: transformConstrain };
 	if (Array.isArray(name)) {
-		const globeProjection = new GlobeProjection({ type: name });
+		const globeProjection = new GlobeProjection({ type: name }, globalState);
 		return {
 			projection: globeProjection,
 			transform: new GlobeTransform(transformOptions),
@@ -12900,7 +12629,7 @@ function createProjectionFromName(name, transformConstrain) {
 				"vertical-perspective",
 				12,
 				"mercator"
-			] });
+			] }, {});
 			return {
 				projection: globeProjection,
 				transform: new GlobeTransform(transformOptions),
@@ -13090,9 +12819,9 @@ var Style = class extends Evented {
 		else this.imageManager.setLoaded(true);
 		this.glyphManager.setURL(nextState.glyphs);
 		this._createLayers();
-		this.light = new Light(this.stylesheet.light);
+		this.light = new Light(this.stylesheet.light ?? {}, this._globalState);
 		this._setProjectionInternal(this.stylesheet.projection?.type || "mercator");
-		this.sky = new Sky(this.stylesheet.sky);
+		this.sky = new Sky(this.stylesheet.sky, this._globalState);
 		this.map.setTerrain(this.stylesheet.terrain ?? null, { validate: false });
 		this.fire(new MapStyleDataEvent("data"));
 		this.fire(new MapStyleLoadEvent());
@@ -13384,9 +13113,7 @@ var Style = class extends Evented {
 			case "setTransition":
 				operations.push(() => {});
 				break;
-			default:
-				unimplemented.push(op.command);
-				break;
+			default: unimplemented.push(op.command);
 		}
 		return {
 			operations,
@@ -13938,7 +13665,7 @@ var Style = class extends Evented {
 		this.sky.updateTransitions(parameters);
 	}
 	_setProjectionInternal(name) {
-		const projectionObjects = createProjectionFromName(name, this.map._camera?.transform.constrainOverride);
+		const projectionObjects = createProjectionFromName(name, this.map._camera?.transform.constrainOverride, this._globalState);
 		this.projection = projectionObjects.projection;
 		this.map.migrateProjection(projectionObjects.transform, projectionObjects.cameraHelper);
 		for (const key in this.tileManagers) this.tileManagers[key].reload();
@@ -14309,18 +14036,20 @@ const projectionUniforms = (context, locations) => ({
 	"u_projection_tile_mercator_coords": new Uniform4f(context, locations.u_projection_tile_mercator_coords),
 	"u_projection_clipping_plane": new Uniform4f(context, locations.u_projection_clipping_plane),
 	"u_projection_transition": new Uniform1f(context, locations.u_projection_transition),
-	"u_projection_fallback_matrix": new UniformMatrix4f(context, locations.u_projection_fallback_matrix)
+	"u_projection_fallback_matrix": new UniformMatrix4f(context, locations.u_projection_fallback_matrix),
+	"u_projection_clip_antimeridian": new Uniform1i(context, locations.u_projection_clip_antimeridian)
 });
 /**
-* Maps a field name in {@link ProjectionData} to its corresponding uniform name in {@link ProjectionPreludeUniformsType}.
+* Converts a {@link ProjectionData} object into the values expected by the projection prelude's uniforms.
 */
-const projectionObjectToUniformMap = {
-	mainMatrix: "u_projection_matrix",
-	tileMercatorCoords: "u_projection_tile_mercator_coords",
-	clippingPlane: "u_projection_clipping_plane",
-	projectionTransition: "u_projection_transition",
-	fallbackMatrix: "u_projection_fallback_matrix"
-};
+const projectionUniformValues = (projectionData) => ({
+	"u_projection_matrix": projectionData.mainMatrix,
+	"u_projection_tile_mercator_coords": projectionData.tileMercatorCoords,
+	"u_projection_clipping_plane": projectionData.clippingPlane,
+	"u_projection_transition": projectionData.projectionTransition,
+	"u_projection_fallback_matrix": projectionData.fallbackMatrix,
+	"u_projection_clip_antimeridian": projectionData.clipAntimeridian ? 1 : 0
+});
 //#endregion
 //#region src/webgl/program.ts
 function getTokenizedAttributesAndUniforms(array) {
@@ -14384,6 +14113,7 @@ var Program = class {
 		for (const name in this.attributes) {
 			const actual = gl.getAttribLocation(this.program, name);
 			if (actual >= 0) this.attributes[name] = actual;
+			else delete this.attributes[name];
 		}
 		if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) throw new Error(`Program failed to link: ${gl.getProgramInfoLog(this.program)}`);
 		gl.deleteShader(vertexShader);
@@ -14412,9 +14142,9 @@ var Program = class {
 			gl.bindTexture(gl.TEXTURE_2D, terrain.texture);
 			for (const name in this.terrainUniforms) this.terrainUniforms[name].set(terrain[name]);
 		}
-		if (projectionData) for (const fieldName in projectionData) {
-			const uniformName = projectionObjectToUniformMap[fieldName];
-			this.projectionUniforms[uniformName].set(projectionData[fieldName]);
+		if (projectionData) {
+			const values = projectionUniformValues(projectionData);
+			for (const name in this.projectionUniforms) this.projectionUniforms[name].set(values[name]);
 		}
 		if (uniformValues) for (const name in this.fixedUniforms) this.fixedUniforms[name].set(uniformValues[name]);
 		if (configuration) configuration.setUniforms(context, this.binderUniforms, currentProperties, { zoom });
@@ -14426,9 +14156,7 @@ var Program = class {
 			case gl.TRIANGLES:
 				primitiveSize = 3;
 				break;
-			case gl.LINE_STRIP:
-				primitiveSize = 1;
-				break;
+			case gl.LINE_STRIP: primitiveSize = 1;
 		}
 		for (const segment of segments.get()) {
 			segment.vaos ||= {};
@@ -14695,9 +14423,7 @@ const hillshadeUniformValues = (painter, tile, layer) => {
 		case "multidirectional":
 			method = 3;
 			break;
-		default:
-			method = 0;
-			break;
+		default: method = 0;
 	}
 	const illumination = layer.getIlluminationProperties();
 	for (let i = 0; i < illumination.directionRadians.length; i++) if (layer.paint.get("hillshade-illumination-anchor") === "viewport") illumination.directionRadians[i] += painter.transform.bearingInRadians;
@@ -15173,7 +14899,6 @@ const programUniforms = {
 	terrain: terrainUniforms,
 	terrainDepth: terrainDepthUniforms,
 	terrainCoords: terrainCoordsUniforms,
-	projectionErrorMeasurement: projectionErrorMeasurementUniforms,
 	atmosphere: atmosphereUniforms,
 	sky: skyUniforms
 };
@@ -15762,6 +15487,37 @@ var Framebuffer = class {
 	}
 };
 //#endregion
+//#region src/webgl/color_mode.ts
+const ZERO = 0;
+const ONE = 1;
+const ONE_MINUS_SRC_ALPHA = 771;
+var ColorMode = class {
+	constructor(blendFunction, blendColor, mask) {
+		this.blendFunction = blendFunction;
+		this.blendColor = blendColor;
+		this.mask = mask;
+	}
+};
+ColorMode.Replace = [ONE, ZERO];
+ColorMode.disabled = new ColorMode(ColorMode.Replace, Color.transparent, [
+	false,
+	false,
+	false,
+	false
+]);
+ColorMode.unblended = new ColorMode(ColorMode.Replace, Color.transparent, [
+	true,
+	true,
+	true,
+	true
+]);
+ColorMode.alphaBlended = new ColorMode([ONE, ONE_MINUS_SRC_ALPHA], Color.transparent, [
+	true,
+	true,
+	true,
+	true
+]);
+//#endregion
 //#region src/webgl/context.ts
 /**
 * @internal
@@ -15965,6 +15721,52 @@ var Context = class {
 	}
 };
 //#endregion
+//#region src/webgl/depth_mode.ts
+const ALWAYS$1 = 519;
+var DepthMode = class {
+	constructor(depthFunc, depthMask, depthRange) {
+		this.func = depthFunc;
+		this.mask = depthMask;
+		this.range = depthRange;
+	}
+};
+DepthMode.ReadOnly = false;
+DepthMode.ReadWrite = true;
+DepthMode.disabled = new DepthMode(ALWAYS$1, DepthMode.ReadOnly, [0, 1]);
+//#endregion
+//#region src/webgl/stencil_mode.ts
+const ALWAYS = 519;
+const KEEP = 7680;
+var StencilMode = class {
+	constructor(test, ref, mask, fail, depthFail, pass) {
+		this.test = test;
+		this.ref = ref;
+		this.mask = mask;
+		this.fail = fail;
+		this.depthFail = depthFail;
+		this.pass = pass;
+	}
+};
+StencilMode.disabled = new StencilMode({
+	func: ALWAYS,
+	mask: 0
+}, 0, 0, KEEP, KEEP, KEEP);
+//#endregion
+//#region src/webgl/cull_face_mode.ts
+const FRONT = 1028;
+const BACK = 1029;
+const CCW = 2305;
+var CullFaceMode = class {
+	constructor(enable, mode, frontFace) {
+		this.enable = enable;
+		this.mode = mode;
+		this.frontFace = frontFace;
+	}
+};
+CullFaceMode.disabled = new CullFaceMode(false, BACK, CCW);
+CullFaceMode.backCCW = new CullFaceMode(true, BACK, CCW);
+CullFaceMode.frontCCW = new CullFaceMode(true, FRONT, CCW);
+//#endregion
 //#region src/webgl/draw/draw_collision_debug.ts
 let quadTriangles;
 function drawCollisionDebug(painter, tileManager, layer, coords, isText) {
@@ -16314,7 +16116,9 @@ function drawCircles(painter, tileManager, layer, coords, renderOptions) {
 		const tile = tileManager.getTile(coord);
 		const bucket = tile.getBucket(layer);
 		if (!bucket) continue;
-		const translateForUniforms = translatePosition(transform, tile, layer.paint.get("circle-translate"), layer.paint.get("circle-translate-anchor"));
+		const styleTranslate = layer.paint.get("circle-translate");
+		const styleTranslateAnchor = layer.paint.get("circle-translate-anchor");
+		const translateForUniforms = translatePosition(transform, tile, styleTranslate, styleTranslateAnchor);
 		const programConfiguration = bucket.programConfigurations.get(layer.id);
 		const program = painter.useProgram("circle", programConfiguration);
 		const layoutVertexBuffer = bucket.layoutVertexBuffer;
@@ -16594,7 +16398,8 @@ function updateGradientTexture(painter, tileManager, context, gl, layer, bucket,
 	if (layer.stepInterpolant) {
 		const sourceMaxZoom = tileManager.getSource().maxzoom;
 		const potentialOverzoom = coord.canonical.z === sourceMaxZoom ? Math.ceil(1 << painter.transform.maxZoom - coord.canonical.z) : 1;
-		textureResolution = clamp(nextPowerOfTwo(bucket.maxLineLength / EXTENT * 1024 * potentialOverzoom), 256, context.maxTextureSize);
+		const maxTextureCoverage = bucket.maxLineLength / EXTENT * 1024 * potentialOverzoom;
+		textureResolution = clamp(nextPowerOfTwo(maxTextureCoverage), 256, context.maxTextureSize);
 	}
 	layerGradient.gradient = renderColorRamp({
 		expression: layer.gradientExpression(),
@@ -17187,7 +16992,8 @@ function getCrossFadeValues(tile, parentTile, fadeDuration) {
 * Simple fade-in values for tile without a parent (i.e. edge tiles)
 */
 function getSelfFadeValues(tile, fadeDuration) {
-	const tileOpacity = clamp((now() - tile.timeAdded) / fadeDuration, 0, 1);
+	const timeSinceTile = (now() - tile.timeAdded) / fadeDuration;
+	const tileOpacity = clamp(timeSinceTile, 0, 1);
 	return {
 		tileOpacity,
 		fadeMix: {
@@ -17733,7 +17539,8 @@ var Painter = class Painter {
 				0
 			],
 			projectionTransition: 0,
-			fallbackMatrix: matrix
+			fallbackMatrix: matrix,
+			clipAntimeridian: false
 		};
 		this.useProgram("clippingMask", null, true).draw(context, gl.TRIANGLES, DepthMode.disabled, this.stencilClearMode, ColorMode.disabled, CullFaceMode.disabled, null, null, projectionData, "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);
 	}
@@ -17746,7 +17553,7 @@ var Painter = class Painter {
 		context.setDepthMode(DepthMode.disabled);
 		const stencilRefs = {};
 		for (const tileID of tileIDs) stencilRefs[tileID.key] = this.nextStencilID++;
-		this._renderTileMasks(stencilRefs, tileIDs, renderToTexture, true);
+		if (this.style.projection.useSubdivision) this._renderTileMasks(stencilRefs, tileIDs, renderToTexture, true);
 		this._renderTileMasks(stencilRefs, tileIDs, renderToTexture, false);
 		this._tileClippingMaskIDs = stencilRefs;
 	}
@@ -17942,10 +17749,6 @@ var Painter = class Painter {
 			if (layer.type !== "custom" && !coords.length) continue;
 			this.renderLayer(this, tileManagers[layer.source], layer, coords, renderOptions);
 		}
-		this.style.projection?.updateGPUdependent({
-			context: this.context,
-			useProgram: (name) => this.useProgram(name)
-		});
 		this.context.viewport.set([
 			0,
 			0,
@@ -18302,7 +18105,7 @@ var Hash = class {
 			location = location.replace("&&", "&");
 			window.history.replaceState(window.history.state, null, location);
 		};
-		this._updateHash = throttle(this._updateHashUnthrottled, 30 * 1e3 / 100);
+		this._updateHash = throttle(this._updateHashUnthrottled, 3e4 / 100);
 		this._hashName = hashName && encodeURIComponent(hashName);
 	}
 	/**
@@ -19037,13 +18840,13 @@ function generateMousePanHandler({ enable, clickTolerance }) {
 		assignEvents
 	});
 }
-function generateMouseRotationHandler({ enable, clickTolerance, aroundCenter = true, minPixelCenterThreshold = 100, rotateDegreesPerPixelMoved = .8 }, getCenter) {
+function generateMouseRotationHandler({ enable, clickTolerance, aroundCenter = true, minPixelCenterThreshold = 100, rotateSpeed = .8 }, getCenter) {
 	return new DragHandler({
 		clickTolerance,
 		move: (lastPoint, currentPoint) => {
 			const center = getCenter();
 			if (aroundCenter && Math.abs(center.y - lastPoint.y) > minPixelCenterThreshold) return { bearingDelta: getAngleDelta(new Point(lastPoint.x, currentPoint.y), currentPoint, center) };
-			let bearingDelta = (currentPoint.x - lastPoint.x) * rotateDegreesPerPixelMoved;
+			let bearingDelta = (currentPoint.x - lastPoint.x) * rotateSpeed;
 			if (aroundCenter && currentPoint.y < center.y) bearingDelta = -bearingDelta;
 			return { bearingDelta };
 		},
@@ -19052,10 +18855,10 @@ function generateMouseRotationHandler({ enable, clickTolerance, aroundCenter = t
 		assignEvents
 	});
 }
-function generateMousePitchHandler({ enable, clickTolerance, pitchDegreesPerPixelMoved = -.5 }) {
+function generateMousePitchHandler({ enable, clickTolerance, pitchSpeed = -.5 }) {
 	return new DragHandler({
 		clickTolerance,
-		move: (lastPoint, point) => ({ pitchDelta: (point.y - lastPoint.y) * pitchDegreesPerPixelMoved }),
+		move: (lastPoint, point) => ({ pitchDelta: (point.y - lastPoint.y) * pitchSpeed }),
 		moveStateManager: new MouseMoveStateManager({ checkCorrectEvent: (e) => e.button === LEFT_BUTTON && e.ctrlKey || e.button === RIGHT_BUTTON }),
 		enable,
 		assignEvents
@@ -19781,7 +19584,8 @@ var ScrollZoomHandler = class {
 			const t = (now() - currentEase.start) / currentEase.duration;
 			const speed = currentEase.easing(t + .01) - currentEase.easing(t);
 			const x = .27 / Math.sqrt(speed * speed + 1e-4) * .01;
-			easing = bezier(x, Math.sqrt(.27 * .27 - x * x), .25, 1);
+			const y = Math.sqrt(.0729 - x * x);
+			easing = bezier(x, y, .25, 1);
 		}
 		this._prevEase = {
 			start: now(),
@@ -21925,7 +21729,8 @@ var Terrain = class {
 		this._terrainSkirtLength = terrainSkirtLength;
 		this.qualityFactor = 2;
 		this.meshSize = 128;
-		this._demMatrixCache = {};
+		this._demMatrixCache = /* @__PURE__ */ new Map();
+		this._elevationSamplerCache = /* @__PURE__ */ new Map();
 		this.coordsIndex = [];
 		this._coordsTextureSize = 1024;
 	}
@@ -21971,12 +21776,8 @@ var Terrain = class {
 	getDEMElevation(tileID, x, y, extent = EXTENT) {
 		const normalized = tileID.normalizeCoordinates(x, y, extent);
 		if (!normalized) return 0;
-		const terrain = this.getTerrainData(normalized.tileID);
-		const dem = terrain.tile?.dem;
-		if (!dem) return 0;
-		const pos = transformMat4$2([], [normalized.x / extent * EXTENT, normalized.y / extent * EXTENT], terrain.u_terrain_matrix);
-		const coord = [pos[0] * dem.dim, pos[1] * dem.dim];
-		return dem.sampleBilinear(coord[0], coord[1]);
+		const sampler = this._getElevationSampler(normalized.tileID);
+		return sampler ? sampler(normalized.x, normalized.y, extent) : 0;
 	}
 	/**
 	* Get the elevation for given {@link LngLat} in respect of exaggeration.
@@ -22018,6 +21819,55 @@ var Terrain = class {
 		return this.getDEMElevation(tileID, x, y, extent) * this.exaggeration;
 	}
 	/**
+	* Clear CPU elevation samplers that may retain a previously selected DEM tile.
+	* @internal
+	*/
+	resetElevationCache() {
+		this._elevationSamplerCache.clear();
+	}
+	_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;
+	}
+	_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;
+	}
+	/**
 	* 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
@@ -22052,34 +21902,12 @@ var Terrain = class {
 			sourceTile.demTexture.bind(context.gl.NEAREST, context.gl.CLAMP_TO_EDGE);
 			sourceTile.needsTerrainPrepare = false;
 		}
-		const matrixKey = sourceTile && sourceTile.toString() + sourceTile.tileID.key + tileID.key;
-		if (matrixKey && !this._demMatrixCache[matrixKey]) {
-			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[matrixKey] = {
-				matrix: demMatrix,
-				coord: tileID
-			};
-		}
+		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": matrixKey ? this._demMatrixCache[matrixKey].matrix : this._emptyDemMatrix,
+			"u_terrain_matrix": terrainMatrix,
 			"u_terrain_unpack": sourceTile?.dem?.getUnpackVector() || this._emptyDemUnpack,
 			"u_terrain_exaggeration": this.exaggeration,
 			texture: (sourceTile?.demTexture || this._emptyDemTexture).texture,
@@ -22147,10 +21975,11 @@ var Terrain = class {
 			data[i + 2] = x >> 8 << 4 | y >> 8;
 			data[i + 3] = 0;
 		}
-		const texture = new Texture(context, new RGBAImage({
+		const image = new RGBAImage({
 			width: this._coordsTextureSize,
 			height: this._coordsTextureSize
-		}, new Uint8Array(data.buffer)), context.gl.RGBA, { premultiply: false });
+		}, 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;
@@ -22191,7 +22020,7 @@ var Terrain = class {
 		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] / (256 * 256 * 256) + rgba[1] / (256 * 256) + rgba[2] / 256 + rgba[3]) / 256;
+		return (rgba[0] / 16777216 + rgba[1] / 65536 + rgba[2] / 256 + rgba[3]) / 256;
 	}
 	/**
 	* create a regular mesh which will be used by all terrain-tiles
@@ -22258,8 +22087,9 @@ var Terrain = class {
 		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, Math.floor(mercatorX / EXTENT), Math.floor(mercatorY / EXTENT)),
+			tileID: new OverscaledTileID(zoom, 0, zoom, tileX, tileY),
 			mercatorX,
 			mercatorY
 		};
@@ -22508,6 +22338,8 @@ const defaultOptions$4 = {
 	localIdeographFontFamily: "sans-serif",
 	pitchWithRotate: true,
 	rollEnabled: false,
+	rotateSpeed: .8,
+	pitchSpeed: -.5,
 	reduceMotion: void 0,
 	validateStyle: true,
 	/**Because GL MAX_TEXTURE_SIZE is usually at least 4096px. */
@@ -24439,27 +24271,36 @@ var Map$1 = class extends Evented {
 				if (thisLayer.type === "hillshade" && thisLayer.source === options.source) warnOnce("You are using the same source for a hillshade layer and for 3D terrain. Please consider using two separate sources to improve rendering quality.");
 				if (thisLayer.type === "color-relief" && thisLayer.source === options.source) warnOnce("You are using the same source for a color-relief layer and for 3D terrain. Please consider using two separate sources to improve rendering quality.");
 			}
+			if (this.terrain) this.terrain.destroy();
 			this.terrain = new Terrain(this.painter, tileManager, options, this._terrainSkirtLength);
 			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._terrainDataCallback = (e) => {
-				if (e.dataType === "style") this.terrain.tileManager.releaseAllRTT();
-				else if (e.dataType === "source" && e.tile) {
-					if (e.sourceId === options.source && !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 (e.source?.type === "image") this.terrain.tileManager.releaseAllRTT();
-					else this.terrain.tileManager.releaseRTT(e.tile.tileID);
-				}
-			};
+			this._terrainDataCallback = (e) => this._handleTerrainDataEvent(e, options.source);
 			this.style.on("data", this._terrainDataCallback);
 		}
 		this.fire(new MapTerrainEvent({ terrain: options }));
 		return this;
 	}
+	_handleTerrainDataEvent(event, terrainSourceId) {
+		if (event.dataType === "style") {
+			this.terrain.tileManager.releaseAllRTT();
+			return;
+		}
+		const isTerrainSourceEvent = event.sourceId === terrainSourceId;
+		if (isTerrainSourceEvent) this.terrain.resetElevationCache();
+		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 (!event.tile) return;
+		if (event.source?.type === "image") {
+			this.terrain.tileManager.releaseAllRTT();
+			return;
+		}
+		this.terrain.tileManager.releaseRTT(event.tile.tileID);
+	}
 	/**
 	* Get the terrain-options if terrain is loaded
 	* @returns the TerrainSpecification passed to setTerrain
@@ -25546,14 +25387,14 @@ var Map$1 = class extends Evented {
 			this.style.update(parameters);
 		}
 		const globeRenderingChanged = this.style.projection?.transitionState > 0 !== isGlobeRendering;
-		this.style.projection?.setErrorQueryLatitudeDegrees(this._camera.transform.center.lat);
-		this._camera.transform.setTransitionState(this.style.projection?.transitionState, this.style.projection?.latitudeErrorCorrectionRadians);
+		this._camera.transform.setTransitionState(this.style.projection?.transitionState);
 		if (this.style && (this._sourcesDirty || globeRenderingChanged)) {
 			this._sourcesDirty = false;
 			this.style._updateSources(this._camera.transform);
 		}
 		if (this.terrain) {
 			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));
 		} else {
@@ -26203,6 +26044,7 @@ var Marker = class extends Evented {
 		this._clickTolerance = options?.clickTolerance || 0;
 		this._subpixelPositioning = options?.subpixelPositioning || false;
 		this._isDragging = false;
+		this._roleManaged = false;
 		this._state = "inactive";
 		this._rotation = options?.rotation || 0;
 		this._rotationAlignment = options?.rotationAlignment || "auto";
@@ -26337,8 +26179,8 @@ var Marker = class extends Evented {
 	addTo(map) {
 		this.remove();
 		this._map = map;
-		if (!this._element.hasAttribute("aria-label")) this._element.setAttribute("aria-label", map._getUIString("Marker.Title"));
-		if (!this._element.hasAttribute("role")) this._element.setAttribute("role", "button");
+		if (this._defaultMarker && !this._element.hasAttribute("aria-label")) this._element.setAttribute("aria-label", map._getUIString("Marker.Title"));
+		this._updateAccessibilityRole();
 		map.getCanvasContainer().appendChild(this._element);
 		map.on("move", this._update);
 		map.on("moveend", this._update);
@@ -26451,7 +26293,6 @@ var Marker = class extends Evented {
 		}
 		if (popup) {
 			if (!("offset" in popup.options)) {
-				const markerHeight = 41 - 5.8 / 2;
 				const markerRadius = 13.5;
 				const linearOffset = Math.abs(markerRadius) / Math.SQRT2;
 				popup.options.offset = this._defaultMarker ? {
@@ -26459,10 +26300,10 @@ var Marker = class extends Evented {
 					"top-left": [0, 0],
 					"top-right": [0, 0],
 					"bottom": [0, -38.1],
-					"bottom-left": [linearOffset, (markerHeight - markerRadius + linearOffset) * -1],
-					"bottom-right": [-linearOffset, (markerHeight - markerRadius + linearOffset) * -1],
-					"left": [markerRadius, (markerHeight - markerRadius) * -1],
-					"right": [-13.5, (markerHeight - markerRadius) * -1]
+					"bottom-left": [linearOffset, (24.6 + linearOffset) * -1],
+					"bottom-right": [-linearOffset, (24.6 + linearOffset) * -1],
+					"left": [markerRadius, -24.6],
+					"right": [-13.5, -24.6]
 				} : this._offset;
 			}
 			this._popup = popup;
@@ -26470,6 +26311,7 @@ var Marker = class extends Evented {
 			if (!this._originalTabIndex) this._element.setAttribute("tabindex", "0");
 			this._element.addEventListener("keypress", this._onKeyPress);
 		}
+		this._updateAccessibilityRole();
 		return this;
 	}
 	/**
@@ -26628,6 +26470,7 @@ var Marker = class extends Evented {
 	*/
 	setDraggable(shouldBeDraggable) {
 		this._draggable = !!shouldBeDraggable;
+		this._element.classList.toggle("maplibregl-marker-draggable", this._draggable);
 		if (this._map) if (shouldBeDraggable) {
 			this._map.on("mousedown", this._addDragHandler);
 			this._map.on("touchstart", this._addDragHandler);
@@ -26635,6 +26478,7 @@ var Marker = class extends Evented {
 			this._map.off("mousedown", this._addDragHandler);
 			this._map.off("touchstart", this._addDragHandler);
 		}
+		this._updateAccessibilityRole();
 		return this;
 	}
 	/**
@@ -26645,6 +26489,21 @@ var Marker = class extends Evented {
 		return this._draggable;
 	}
 	/**
+	* Keep the default marker role aligned with interactivity.
+	* Default markers need a role because `aria-label` is set in {@link Marker.addTo}.
+	* Non-interactive markers use `role=img`; interactive ones (draggable or with a popup) use `role=button`.
+	* Click listeners are application-owned and do not automatically change the role.
+	* Custom marker elements are left alone so applications own their a11y tree.
+	* Explicit roles set by the application are preserved.
+	*/
+	_updateAccessibilityRole() {
+		if (!this._defaultMarker) return;
+		if (this._element.hasAttribute("role") && !this._roleManaged) return;
+		const role = this._draggable || !!this._popup ? "button" : "img";
+		this._element.setAttribute("role", role);
+		this._roleManaged = true;
+	}
+	/**
 	* Sets the `rotation` property of the marker.
 	* @param rotation - The rotation angle of the marker (clockwise, in degrees), relative to its respective {@link Marker.setRotationAlignment} setting.
 	*/
@@ -26970,7 +26829,8 @@ var GeolocateControl = class extends Evented {
 		this._updateCamera = (position) => {
 			const center = new LngLat(position.coords.longitude, position.coords.latitude);
 			const radius = position.coords.accuracy;
-			const options = extend({ bearing: this._map.getBearing() }, this.options.fitBoundsOptions);
+			const bearing = this._map.getBearing();
+			const options = extend({ bearing }, this.options.fitBoundsOptions);
 			const newBounds = LngLatBounds.fromLngLat(center, radius);
 			this._map.fitBounds(newBounds, options, { geolocateSource: true });
 		};