@mapbox/mapbox-gl-style-spec 14.11.0 → 14.12.0

package/dist/index.es.js

@@ -788,6 +788,16 @@ var source_vector = {
 		],
 		doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`. When this property is included in a source, no tiles outside of the given bounds are requested by Mapbox GL."
 	},
+	extra_bounds: {
+		type: "array",
+		value: {
+			type: "array",
+			value: "number",
+			length: 4,
+			doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`."
+		},
+		doc: "An array of additional discrete geographic regions where tiles are available. When used alongside the `bounds` property, these regions act as an additional filter - Mapbox GL will only request tiles that are both within the `bounds` and any of the regions defined in `extra_bounds`. When used independently (without `bounds`), Mapbox GL will request tiles that fall within any of the regions in `extra_bounds`. This allows for more fine-grained control over tile requests, particularly when dealing with sparse data coverage."
+	},
 	scheme: {
 		type: "enum",
 		values: {
@@ -867,6 +877,16 @@ var source_raster = {
 		],
 		doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`. When this property is included in a source, no tiles outside of the given bounds are requested by Mapbox GL."
 	},
+	extra_bounds: {
+		type: "array",
+		value: {
+			type: "array",
+			value: "number",
+			length: 4,
+			doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`."
+		},
+		doc: "An array of additional discrete geographic regions where tiles are available. When used alongside the `bounds` property, these regions act as an additional filter - Mapbox GL will only request tiles that are both within the `bounds` and any of the regions defined in `extra_bounds`. When used independently (without `bounds`), Mapbox GL will request tiles that fall within any of the regions in `extra_bounds`. This allows for more fine-grained control over tile requests, particularly when dealing with sparse data coverage."
+	},
 	minzoom: {
 		type: "number",
 		"default": 0,
@@ -948,6 +968,16 @@ var source_raster_dem = {
 		],
 		doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`. When this property is included in a source, no tiles outside of the given bounds are requested by Mapbox GL."
 	},
+	extra_bounds: {
+		type: "array",
+		value: {
+			type: "array",
+			value: "number",
+			length: 4,
+			doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`."
+		},
+		doc: "An array of additional discrete geographic regions where tiles are available. When used alongside the `bounds` property, these regions act as an additional filter - Mapbox GL will only request tiles that are both within the `bounds` and any of the regions defined in `extra_bounds`. When used independently (without `bounds`), Mapbox GL will request tiles that fall within any of the regions in `extra_bounds`. This allows for more fine-grained control over tile requests, particularly when dealing with sparse data coverage."
+	},
 	minzoom: {
 		type: "number",
 		"default": 0,
@@ -1030,6 +1060,16 @@ var source_raster_array = {
 		],
 		doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`. When this property is included in a source, no tiles outside of the given bounds are requested by Mapbox GL."
 	},
+	extra_bounds: {
+		type: "array",
+		value: {
+			type: "array",
+			value: "number",
+			length: 4,
+			doc: "An array containing the longitude and latitude of the southwest and northeast corners of the source's bounding box in the following order: `[sw.lng, sw.lat, ne.lng, ne.lat]`."
+		},
+		doc: "An array of additional discrete geographic regions where tiles are available. When used alongside the `bounds` property, these regions act as an additional filter - Mapbox GL will only request tiles that are both within the `bounds` and any of the regions defined in `extra_bounds`. When used independently (without `bounds`), Mapbox GL will request tiles that fall within any of the regions in `extra_bounds`. This allows for more fine-grained control over tile requests, particularly when dealing with sparse data coverage."
+	},
 	minzoom: {
 		type: "number",
 		"default": 0,
@@ -1321,6 +1361,13 @@ var layer = {
 					}
 				}
 			},
+			building: {
+				doc: "A procedural 3D building.",
+				"sdk-support": {
+				},
+				experimental: true,
+				"private": true
+			},
 			raster: {
 				doc: "Raster map textures such as satellite imagery.",
 				"sdk-support": {
@@ -1462,6 +1509,7 @@ var layout = [
 	"layout_circle",
 	"layout_heatmap",
 	"layout_fill-extrusion",
+	"layout_building",
 	"layout_symbol",
 	"layout_raster",
 	"layout_raster-particle",
@@ -1859,6 +1907,115 @@ var layout_heatmap = {
 		"property-type": "constant"
 	}
 };
+var layout_building = {
+	visibility: {
+		type: "enum",
+		values: {
+			visible: {
+				doc: "The layer is shown."
+			},
+			none: {
+				doc: "The layer is not shown."
+			}
+		},
+		"default": "visible",
+		doc: "Whether this layer is displayed.",
+		"sdk-support": {
+			"basic functionality": {
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "constant"
+	},
+	"building-roof-shape": {
+		type: "enum",
+		values: {
+			flat: {
+				doc: "Use regular extruded buildings with flat roofs."
+			},
+			hipped: {
+				doc: "Use hipped roof for the procedurally generated buildings."
+			},
+			gabled: {
+				doc: "Use gabled roof for the procedurally generated buildings."
+			},
+			parapet: {
+				doc: "Use parapet roof for the procedurally generated buildings."
+			},
+			mansard: {
+				doc: "Use mansard roof for the procedurally generated buildings."
+			},
+			skillion: {
+				doc: "Use skillion roof for the procedurally generated buildings."
+			},
+			pyramidal: {
+				doc: "Use pyramidal roof for the procedurally generated buildings."
+			}
+		},
+		"default": "flat",
+		doc: "Roof type to use for the procedural buildings.",
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: false,
+			parameters: [
+				"feature"
+			]
+		},
+		"property-type": "data-driven"
+	},
+	"building-height": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		units: "meters",
+		doc: "The height of the procedural buildings.",
+		transition: true,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "data-driven"
+	},
+	"building-base": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		units: "meters",
+		doc: "The height with which to extrude the base of this layer. Must be less than or equal to `building-height`.",
+		transition: true,
+		requires: [
+			"building-height"
+		],
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "data-driven"
+	}
+};
 var layout_line = {
 	"line-cap": {
 		type: "enum",
@@ -3800,6 +3957,20 @@ var filter_circle = {
 		]
 	}
 };
+var filter_building = {
+	type: "boolean",
+	doc: "Expression which determines whether or not to display a Polygon. Building layer does NOT support dynamic filtering, meaning this expression can NOT use the `[\"pitch\"]` and `[\"distance-from-center\"]` expressions to reference the current state of the view.",
+	"default": false,
+	transition: false,
+	"property-type": "data-driven",
+	expression: {
+		interpolated: false,
+		parameters: [
+			"zoom",
+			"feature"
+		]
+	}
+};
 var filter_heatmap = {
 	type: "boolean",
 	doc: "Expression used to determine whether a point is being displayed or not. Heatmap layer does NOT support dynamic filtering, meaning this expression can NOT use the `[\"pitch\"]` and `[\"distance-from-center\"]` expressions to reference the current state of the view.",
@@ -6105,6 +6276,7 @@ var paint = [
 	"paint_circle",
 	"paint_heatmap",
 	"paint_fill-extrusion",
+	"paint_building",
 	"paint_symbol",
 	"paint_raster",
 	"paint_raster-particle",
@@ -6312,6 +6484,30 @@ var paint_fill = {
 		},
 		"property-type": "data-driven"
 	},
+	"fill-pattern-cross-fade": {
+		type: "number",
+		"property-type": "data-constant",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			]
+		},
+		requires: [
+			"line-pattern"
+		],
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.12.0"
+			}
+		},
+		doc: "Controls the transition progress between the image variants of fill-pattern. Zero means the first variant is used, one is the second, and in between they are blended together.",
+		transition: true
+	},
 	"fill-emissive-strength": {
 		type: "number",
 		"default": 0,
@@ -6417,6 +6613,189 @@ var paint_fill = {
 		"property-type": "data-driven"
 	}
 };
+var paint_building = {
+	"building-opacity": {
+		type: "number",
+		"default": 1,
+		minimum: 0,
+		maximum: 1,
+		doc: "The opacity of the entire procedural buildings layer. This is rendered on a per-layer, not per-feature, basis, and data-driven styling is not available.",
+		transition: true,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		"property-type": "data-constant"
+	},
+	"building-ambient-occlusion-wall-intensity": {
+		"property-type": "data-constant",
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		experimental: true,
+		"private": true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: true,
+		doc: "Controls the intensity of shading concave angles between walls and building elements, such as facades and rooftop.",
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-ambient-occlusion-ground-intensity": {
+		"property-type": "data-constant",
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		experimental: true,
+		"private": true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: true,
+		doc: "Controls the intensity of shading near ground",
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-ambient-occlusion-ground-radius": {
+		"property-type": "data-constant",
+		type: "number",
+		experimental: true,
+		"private": true,
+		"default": 3,
+		minimum: 0,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: true,
+		doc: "The extent of the ambient occlusion effect on the ground beneath the procedural buildings in meters.",
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-ambient-occlusion-ground-attenuation": {
+		"property-type": "data-constant",
+		type: "number",
+		experimental: true,
+		"private": true,
+		"default": 0.69,
+		minimum: 0,
+		maximum: 1,
+		doc: "Provides a control to further fine-tune the look of the ambient occlusion on the ground beneath the procedural buildings. Lower values give the effect a more solid look while higher values make it smoother.",
+		transition: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-vertical-scale": {
+		"property-type": "data-constant",
+		type: "number",
+		experimental: true,
+		"private": true,
+		"default": 1,
+		minimum: 0,
+		doc: "A global multiplier that can be used to scale base and height of the procedural buildings.",
+		transition: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-cast-shadows": {
+		type: "boolean",
+		"default": true,
+		doc: "Enable/Disable shadow casting for this layer",
+		transition: false,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			}
+		},
+		"property-type": "data-constant"
+	},
+	"building-color": {
+		type: "color",
+		"default": "rgba(193, 154, 127, 1)",
+		doc: "Color buildings. This can be styled using different building parts (e.g. windows, wall, roof, etc.). This won't be used if `building-roof-shape` has a value `flat`.",
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"feature",
+				"feature-state"
+			]
+		},
+		"property-type": "data-driven"
+	},
+	"building-emissive-strength": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		doc: "Controls the intensity of light emitted on the source features.",
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"feature",
+				"feature-state",
+				"measure-light"
+			]
+		},
+		"property-type": "data-driven"
+	}
+};
 var paint_line = {
 	"line-opacity": {
 		type: "number",
@@ -6713,6 +7092,30 @@ var paint_line = {
 		},
 		"property-type": "data-driven"
 	},
+	"line-pattern-cross-fade": {
+		type: "number",
+		"property-type": "data-constant",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			]
+		},
+		requires: [
+			"line-pattern"
+		],
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.12.0"
+			}
+		},
+		doc: "Controls the transition progress between the image variants of line-pattern. Zero means the first variant is used, one is the second, and in between they are blended together.",
+		transition: true
+	},
 	"line-gradient": {
 		type: "color",
 		doc: "A gradient used to color a line feature at various distances along its length. Defined using a `step` or `interpolate` expression which outputs a color for each corresponding `line-progress` input value. `line-progress` is a percentage of the line feature's total length as measured on the webmercator projected coordinate plane (a `number` between `0` and `1`). Can only be used with GeoJSON sources that specify `\"lineMetrics\": true`.",
@@ -7791,7 +8194,7 @@ var paint_symbol = {
 	},
 	"icon-image-cross-fade": {
 		type: "number",
-		"property-type": "data-driven",
+		"property-type": "data-constant",
 		"default": 0,
 		minimum: 0,
 		maximum: 1,
@@ -7799,8 +8202,6 @@ var paint_symbol = {
 			interpolated: true,
 			parameters: [
 				"zoom",
-				"feature",
-				"feature-state",
 				"measure-light"
 			]
 		},
@@ -7812,11 +8213,6 @@ var paint_symbol = {
 				js: "3.0.0",
 				android: "11.0.0",
 				ios: "11.0.0"
-			},
-			"data-driven styling": {
-				js: "3.0.0",
-				android: "11.0.0",
-				ios: "11.0.0"
 			}
 		},
 		doc: "Controls the transition progress between the image variants of icon-image. Zero means the first variant is used, one is the second, and in between they are blended together.",
@@ -9647,6 +10043,7 @@ var v8 = {
 		"property-type": "constant"
 	}
 },
+	layout_building: layout_building,
 	layout_line: layout_line,
 	layout_symbol: layout_symbol,
 	layout_raster: layout_raster,
@@ -9719,6 +10116,7 @@ var v8 = {
 		]
 	}
 },
+	filter_building: filter_building,
 	filter_heatmap: filter_heatmap,
 	filter_operator: filter_operator,
 	geometry_type: geometry_type,
@@ -9935,6 +10333,30 @@ var v8 = {
 		},
 		"property-type": "data-driven"
 	},
+	"fill-extrusion-pattern-cross-fade": {
+		type: "number",
+		"property-type": "data-constant",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			]
+		},
+		requires: [
+			"line-pattern"
+		],
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.12.0"
+			}
+		},
+		doc: "Controls the transition progress between the image variants of fill-extrusion-pattern. Zero means the first variant is used, one is the second, and in between they are blended together.",
+		transition: true
+	},
 	"fill-extrusion-height": {
 		type: "number",
 		"default": 0,
@@ -10473,6 +10895,7 @@ var v8 = {
 		"property-type": "data-constant"
 	}
 },
+	paint_building: paint_building,
 	paint_line: paint_line,
 	paint_circle: paint_circle,
 	paint_heatmap: paint_heatmap,
@@ -12601,8 +13024,8 @@ class ImageVariant {
             ])
         });
     }
-    scaleSelf(factor) {
-        this.options.transform.scaleSelf(factor);
+    scaleSelf(factor, yFactor) {
+        this.options.transform.scaleSelf(factor, yFactor);
         return this;
     }
 }
@@ -12897,6 +13320,7 @@ class Assertion {
         }
         return new Assertion(type, parsed);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         for (let i = 0; i < this.args.length; i++) {
             const value = this.args[i].evaluate(ctx);
@@ -13316,6 +13740,7 @@ class Coercion {
         }
         return new Coercion(type, parsed);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         if (this.type.kind === 'boolean') {
             return Boolean(this.args[0].evaluate(ctx));
@@ -13617,6 +14042,306 @@ class CollatorExpression {
     }
 }
 
+var pointGeometry;
+var hasRequiredPointGeometry;
+
+function requirePointGeometry () {
+	if (hasRequiredPointGeometry) return pointGeometry;
+	hasRequiredPointGeometry = 1;
+	pointGeometry = Point;
+	/**
+	 * A standalone point geometry with useful accessor, comparison, and
+	 * modification methods.
+	 *
+	 * @class Point
+	 * @param {Number} x the x-coordinate. this could be longitude or screen
+	 * pixels, or any other sort of unit.
+	 * @param {Number} y the y-coordinate. this could be latitude or screen
+	 * pixels, or any other sort of unit.
+	 * @example
+	 * var point = new Point(-77, 38);
+	 */
+	function Point(x, y) {
+	    this.x = x;
+	    this.y = y;
+	}
+	Point.prototype = {
+	    /**
+	     * Clone this point, returning a new point that can be modified
+	     * without affecting the old one.
+	     * @return {Point} the clone
+	     */
+	    clone: function () {
+	        return new Point(this.x, this.y);
+	    },
+	    /**
+	     * Add this point's x & y coordinates to another point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    add: function (p) {
+	        return this.clone()._add(p);
+	    },
+	    /**
+	     * Subtract this point's x & y coordinates to from point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    sub: function (p) {
+	        return this.clone()._sub(p);
+	    },
+	    /**
+	     * Multiply this point's x & y coordinates by point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    multByPoint: function (p) {
+	        return this.clone()._multByPoint(p);
+	    },
+	    /**
+	     * Divide this point's x & y coordinates by point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    divByPoint: function (p) {
+	        return this.clone()._divByPoint(p);
+	    },
+	    /**
+	     * Multiply this point's x & y coordinates by a factor,
+	     * yielding a new point.
+	     * @param {Point} k factor
+	     * @return {Point} output point
+	     */
+	    mult: function (k) {
+	        return this.clone()._mult(k);
+	    },
+	    /**
+	     * Divide this point's x & y coordinates by a factor,
+	     * yielding a new point.
+	     * @param {Point} k factor
+	     * @return {Point} output point
+	     */
+	    div: function (k) {
+	        return this.clone()._div(k);
+	    },
+	    /**
+	     * Rotate this point around the 0, 0 origin by an angle a,
+	     * given in radians
+	     * @param {Number} a angle to rotate around, in radians
+	     * @return {Point} output point
+	     */
+	    rotate: function (a) {
+	        return this.clone()._rotate(a);
+	    },
+	    /**
+	     * Rotate this point around p point by an angle a,
+	     * given in radians
+	     * @param {Number} a angle to rotate around, in radians
+	     * @param {Point} p Point to rotate around
+	     * @return {Point} output point
+	     */
+	    rotateAround: function (a, p) {
+	        return this.clone()._rotateAround(a, p);
+	    },
+	    /**
+	     * Multiply this point by a 4x1 transformation matrix
+	     * @param {Array<Number>} m transformation matrix
+	     * @return {Point} output point
+	     */
+	    matMult: function (m) {
+	        return this.clone()._matMult(m);
+	    },
+	    /**
+	     * Calculate this point but as a unit vector from 0, 0, meaning
+	     * that the distance from the resulting point to the 0, 0
+	     * coordinate will be equal to 1 and the angle from the resulting
+	     * point to the 0, 0 coordinate will be the same as before.
+	     * @return {Point} unit vector point
+	     */
+	    unit: function () {
+	        return this.clone()._unit();
+	    },
+	    /**
+	     * Compute a perpendicular point, where the new y coordinate
+	     * is the old x coordinate and the new x coordinate is the old y
+	     * coordinate multiplied by -1
+	     * @return {Point} perpendicular point
+	     */
+	    perp: function () {
+	        return this.clone()._perp();
+	    },
+	    /**
+	     * Return a version of this point with the x & y coordinates
+	     * rounded to integers.
+	     * @return {Point} rounded point
+	     */
+	    round: function () {
+	        return this.clone()._round();
+	    },
+	    /**
+	     * Return the magitude of this point: this is the Euclidean
+	     * distance from the 0, 0 coordinate to this point's x and y
+	     * coordinates.
+	     * @return {Number} magnitude
+	     */
+	    mag: function () {
+	        return Math.sqrt(this.x * this.x + this.y * this.y);
+	    },
+	    /**
+	     * Judge whether this point is equal to another point, returning
+	     * true or false.
+	     * @param {Point} other the other point
+	     * @return {boolean} whether the points are equal
+	     */
+	    equals: function (other) {
+	        return this.x === other.x && this.y === other.y;
+	    },
+	    /**
+	     * Calculate the distance from this point to another point
+	     * @param {Point} p the other point
+	     * @return {Number} distance
+	     */
+	    dist: function (p) {
+	        return Math.sqrt(this.distSqr(p));
+	    },
+	    /**
+	     * Calculate the distance from this point to another point,
+	     * without the square root step. Useful if you're comparing
+	     * relative distances.
+	     * @param {Point} p the other point
+	     * @return {Number} distance
+	     */
+	    distSqr: function (p) {
+	        var dx = p.x - this.x, dy = p.y - this.y;
+	        return dx * dx + dy * dy;
+	    },
+	    /**
+	     * Get the angle from the 0, 0 coordinate to this point, in radians
+	     * coordinates.
+	     * @return {Number} angle
+	     */
+	    angle: function () {
+	        return Math.atan2(this.y, this.x);
+	    },
+	    /**
+	     * Get the angle from this point to another point, in radians
+	     * @param {Point} b the other point
+	     * @return {Number} angle
+	     */
+	    angleTo: function (b) {
+	        return Math.atan2(this.y - b.y, this.x - b.x);
+	    },
+	    /**
+	     * Get the angle between this point and another point, in radians
+	     * @param {Point} b the other point
+	     * @return {Number} angle
+	     */
+	    angleWith: function (b) {
+	        return this.angleWithSep(b.x, b.y);
+	    },
+	    /*
+	     * Find the angle of the two vectors, solving the formula for
+	     * the cross product a x b = |a||b|sin(θ) for θ.
+	     * @param {Number} x the x-coordinate
+	     * @param {Number} y the y-coordinate
+	     * @return {Number} the angle in radians
+	     */
+	    angleWithSep: function (x, y) {
+	        return Math.atan2(this.x * y - this.y * x, this.x * x + this.y * y);
+	    },
+	    _matMult: function (m) {
+	        var x = m[0] * this.x + m[1] * this.y, y = m[2] * this.x + m[3] * this.y;
+	        this.x = x;
+	        this.y = y;
+	        return this;
+	    },
+	    _add: function (p) {
+	        this.x += p.x;
+	        this.y += p.y;
+	        return this;
+	    },
+	    _sub: function (p) {
+	        this.x -= p.x;
+	        this.y -= p.y;
+	        return this;
+	    },
+	    _mult: function (k) {
+	        this.x *= k;
+	        this.y *= k;
+	        return this;
+	    },
+	    _div: function (k) {
+	        this.x /= k;
+	        this.y /= k;
+	        return this;
+	    },
+	    _multByPoint: function (p) {
+	        this.x *= p.x;
+	        this.y *= p.y;
+	        return this;
+	    },
+	    _divByPoint: function (p) {
+	        this.x /= p.x;
+	        this.y /= p.y;
+	        return this;
+	    },
+	    _unit: function () {
+	        this._div(this.mag());
+	        return this;
+	    },
+	    _perp: function () {
+	        var y = this.y;
+	        this.y = this.x;
+	        this.x = -y;
+	        return this;
+	    },
+	    _rotate: function (angle) {
+	        var cos = Math.cos(angle), sin = Math.sin(angle), x = cos * this.x - sin * this.y, y = sin * this.x + cos * this.y;
+	        this.x = x;
+	        this.y = y;
+	        return this;
+	    },
+	    _rotateAround: function (angle, p) {
+	        var cos = Math.cos(angle), sin = Math.sin(angle), x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y), y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
+	        this.x = x;
+	        this.y = y;
+	        return this;
+	    },
+	    _round: function () {
+	        this.x = Math.round(this.x);
+	        this.y = Math.round(this.y);
+	        return this;
+	    }
+	};
+	/**
+	 * Construct a point from an array if necessary, otherwise if the input
+	 * is already a Point, or an unknown type, return it unchanged
+	 * @param {Array<Number>|Point|*} a any kind of input value
+	 * @return {Point} constructed point, or passed-through value.
+	 * @example
+	 * // this
+	 * var point = Point.convert([0, 1]);
+	 * // is equivalent to
+	 * var point = new Point(0, 1);
+	 */
+	Point.convert = function (a) {
+	    if (a instanceof Point) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return new Point(a[0], a[1]);
+	    }
+	    return a;
+	};
+	return pointGeometry;
+}
+
+requirePointGeometry();
+
 function calculateSignedArea(ring) {
     let sum = 0;
     for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
@@ -15152,6 +15877,7 @@ class Config {
         }
         return new Config(type, toString(configKey.value));
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         const FQIDSeparator = '\x1F';
         const configKey = [
@@ -15296,6 +16022,7 @@ class Var {
         }
         return new Var(name, context.scope.get(name));
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         return this.boundExpression.evaluate(ctx);
     }
@@ -15561,6 +16288,7 @@ class Step {
         }
         return new Step(outputType, input, stops);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         const labels = this.labels;
         const outputs = this.outputs;
@@ -15963,6 +16691,7 @@ class Coalesce {
         const needsAnnotation = expectedType && parsedArgs.some(arg => checkSubtype(expectedType, arg.type));
         return needsAnnotation ? new Coalesce(ValueType, parsedArgs) : new Coalesce(outputType, parsedArgs);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         let result = null;
         let argCount = 0;
@@ -16005,6 +16734,7 @@ class Let {
         this.bindings = [].concat(bindings);
         this.result = result;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         return this.result.evaluate(ctx);
     }
@@ -16247,6 +16977,7 @@ class IndexOf {
             return new IndexOf(needle, haystack);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         const needle = this.needle.evaluate(ctx);
         const haystack = this.haystack.evaluate(ctx);
@@ -16363,6 +17094,7 @@ class Match {
         }
         return new Match(inputType, outputType, input, cases, outputs, otherwise);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         const input = this.input.evaluate(ctx);
         const output = typeOf(input) === this.inputType && this.outputs[this.cases[input]] || this.otherwise;
@@ -16444,6 +17176,7 @@ class Case {
             return null;
         return new Case(outputType, branches, otherwise);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         for (const [test, expression] of this.branches) {
             if (test.evaluate(ctx)) {
@@ -16502,6 +17235,7 @@ class Slice {
             return new Slice(input.type, input, beginIndex);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx) {
         const input = this.input.evaluate(ctx);
         const beginIndex = this.beginIndex.evaluate(ctx);
@@ -17022,6 +17756,7 @@ CompoundExpression.register(expressions, {
         overloads: [
             [
                 [StringType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [key]) => get(key.evaluate(ctx), ctx.properties())
             ],
             [
@@ -17029,6 +17764,7 @@ CompoundExpression.register(expressions, {
                     StringType,
                     ObjectType
                 ],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [key, obj]) => get(key.evaluate(ctx), obj.evaluate(ctx))
             ]
         ]
@@ -17036,6 +17772,7 @@ CompoundExpression.register(expressions, {
     'feature-state': [
         ValueType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [key]) => get(key.evaluate(ctx), ctx.featureState || {})
     ],
     'properties': [
@@ -17233,11 +17970,13 @@ CompoundExpression.register(expressions, {
     'min': [
         NumberType,
         varargs(NumberType),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, args) => Math.min(...args.map(arg => arg.evaluate(ctx)))
     ],
     'max': [
         NumberType,
         varargs(NumberType),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, args) => Math.max(...args.map(arg => arg.evaluate(ctx)))
     ],
     'abs': [
@@ -17411,6 +18150,7 @@ CompoundExpression.register(expressions, {
                     BooleanType,
                     BooleanType
                 ],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [a, b]) => a.evaluate(ctx) && b.evaluate(ctx)
             ],
             [
@@ -17433,6 +18173,7 @@ CompoundExpression.register(expressions, {
                     BooleanType,
                     BooleanType
                 ],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [a, b]) => a.evaluate(ctx) || b.evaluate(ctx)
             ],
             [
@@ -17467,11 +18208,13 @@ CompoundExpression.register(expressions, {
     'upcase': [
         StringType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [s]) => s.evaluate(ctx).toUpperCase()
     ],
     'downcase': [
         StringType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [s]) => s.evaluate(ctx).toLowerCase()
     ],
     'concat': [
@@ -17482,6 +18225,7 @@ CompoundExpression.register(expressions, {
     'resolved-locale': [
         StringType,
         [CollatorType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
     ],
     'random': [
@@ -17629,6 +18373,7 @@ function createFunction(parameters, propertySpec) {
             kind: 'composite',
             interpolationType,
             interpolationFactor: Interpolate.interpolationFactor.bind(void 0, interpolationType),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             zoomStops: featureFunctionStops.map(s => s[0]),
             evaluate({zoom}, properties) {
                 return evaluateExponentialFunction({
@@ -17646,7 +18391,9 @@ function createFunction(parameters, propertySpec) {
             kind: 'camera',
             interpolationType,
             interpolationFactor: Interpolate.interpolationFactor.bind(void 0, interpolationType),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             zoomStops: parameters.stops.map(s => s[0]),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             evaluate: ({zoom}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
         };
     } else {
@@ -18752,7 +19499,8 @@ function convertInOp(property, values, negate = false) {
             negate
         ];
     }
-    return [negate ? 'all' : 'any'].concat(values.map(v => [
+    return [negate ? 'all' : 'any'].concat(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+    values.map(v => [
         negate ? '!=' : '==',
         get,
         v
@@ -19037,7 +19785,15 @@ const operations = {
     /**
    * { command: 'updateImport', args: [importId, importSpecification | styleUrl] }
    */
-    updateImport: 'updateImport'
+    updateImport: 'updateImport',
+    /*
+   *  { command: 'addIconset', args: [iconsetId, IconsetSpecification] }
+   */
+    addIconset: 'addIconset',
+    /*
+   *  { command: 'removeIconset', args: [iconsetId] }
+   */
+    removeIconset: 'removeIconset'
 };
 function addSource(sourceId, after, commands) {
     commands.push({
@@ -19344,6 +20100,47 @@ function diffImports(before = [], after = [], commands) {
         });
     }
 }
+function diffIconsets(before, after, commands) {
+    before = before || {};
+    after = after || {};
+    let iconsetId;
+    for (iconsetId in before) {
+        if (!before.hasOwnProperty(iconsetId))
+            continue;
+        if (!after.hasOwnProperty(iconsetId)) {
+            commands.push({
+                command: operations.removeIconset,
+                args: [iconsetId]
+            });
+        }
+    }
+    for (iconsetId in after) {
+        if (!after.hasOwnProperty(iconsetId))
+            continue;
+        const iconset = after[iconsetId];
+        if (!before.hasOwnProperty(iconsetId)) {
+            commands.push({
+                command: operations.addIconset,
+                args: [
+                    iconsetId,
+                    iconset
+                ]
+            });
+        } else if (!deepEqual(before[iconsetId], iconset)) {
+            commands.push({
+                command: operations.removeIconset,
+                args: [iconsetId]
+            });
+            commands.push({
+                command: operations.addIconset,
+                args: [
+                    iconsetId,
+                    iconset
+                ]
+            });
+        }
+    }
+}
 function diffStyles(before, after) {
     if (!before)
         return [{
@@ -19445,6 +20242,9 @@ function diffStyles(before, after) {
                 args: [after.camera]
             });
         }
+        if (!deepEqual(before.iconsets, after.iconsets)) {
+            diffIconsets(before.iconsets, after.iconsets, commands);
+        }
         if (!deepEqual(before['color-theme'], after['color-theme'])) {
             return [{
                     command: operations.setStyle,
@@ -20198,8 +20998,8 @@ function validateLayer(options) {
                     'raster-particle'
                 ].includes(type)) {
                 errors.push(new ValidationError(key, layer.source, `raster-array source can only be used with layer type 'raster'.`));
-            } else if (type === 'line' && layer.paint && (layer.paint['line-gradient'] || layer.paint['line-trim-offset']) && (sourceType !== 'geojson' || !source.lineMetrics)) {
-                errors.push(new ValidationError(key, layer, `layer "${ layer.id }" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`));
+            } else if (type === 'line' && layer.paint && (layer.paint['line-gradient'] || layer.paint['line-trim-offset']) && (sourceType === 'geojson' && !source.lineMetrics)) {
+                errors.push(new ValidationError(key, layer, `layer "${ layer.id }" specifies a line-gradient, which requires the GeoJSON source to have \`lineMetrics\` enabled.`));
             } else if (type === 'raster-particle' && sourceType !== 'raster-array') {
                 errors.push(new ValidationError(key, layer.source, `layer "${ layer.id }" requires a 'raster-array' source.`));
             }
@@ -21956,7 +22756,7 @@ function isValid(value, regex) {
     return !!value.match(regex);
 }
 function getSourceCount(source) {
-    if (source.url) {
+    if ('url' in source) {
         return source.url.split(',').length;
     } else {
         return 0;
@@ -21995,7 +22795,7 @@ function getSourceErrors(source, i) {
         errors.push(new ValidationError(`sources[${ i }].type`, source.type, `Expected one of [${ Array.from(acceptedSourceTypes).join(', ') }]`));
     }
     const sourceUrlPattern = /^mapbox:\/\/([^/]*)$/;
-    if (!source.url || !isValid(source.url, sourceUrlPattern)) {
+    if (!('url' in source) || !isValid(source.url, sourceUrlPattern)) {
         errors.push(new ValidationError(`sources[${ i }].url`, source.url, 'Expected a valid Mapbox tileset url'));
     }
     return errors;