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

package/dist/index.cjs

@@ -794,6 +794,16 @@
   		],
   		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: {
@@ -873,6 +883,16 @@
   		],
   		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,
@@ -954,6 +974,16 @@
   		],
   		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,
@@ -1036,6 +1066,16 @@
   		],
   		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,
@@ -1327,6 +1367,13 @@
   					}
   				}
   			},
+  			building: {
+  				doc: "A procedural 3D building.",
+  				"sdk-support": {
+  				},
+  				experimental: true,
+  				"private": true
+  			},
   			raster: {
   				doc: "Raster map textures such as satellite imagery.",
   				"sdk-support": {
@@ -1468,6 +1515,7 @@
   	"layout_circle",
   	"layout_heatmap",
   	"layout_fill-extrusion",
+  	"layout_building",
   	"layout_symbol",
   	"layout_raster",
   	"layout_raster-particle",
@@ -1865,6 +1913,115 @@
   		"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",
@@ -3806,6 +3963,20 @@
   		]
   	}
   };
+  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.",
@@ -6111,6 +6282,7 @@
   	"paint_circle",
   	"paint_heatmap",
   	"paint_fill-extrusion",
+  	"paint_building",
   	"paint_symbol",
   	"paint_raster",
   	"paint_raster-particle",
@@ -6318,6 +6490,30 @@
   		},
   		"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,
@@ -6423,6 +6619,189 @@
   		"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",
@@ -6719,6 +7098,30 @@
   		},
   		"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`.",
@@ -7797,7 +8200,7 @@
   	},
   	"icon-image-cross-fade": {
   		type: "number",
-  		"property-type": "data-driven",
+  		"property-type": "data-constant",
   		"default": 0,
   		minimum: 0,
   		maximum: 1,
@@ -7805,8 +8208,6 @@
   			interpolated: true,
   			parameters: [
   				"zoom",
-  				"feature",
-  				"feature-state",
   				"measure-light"
   			]
   		},
@@ -7818,11 +8219,6 @@
   				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.",
@@ -9653,6 +10049,7 @@
   		"property-type": "constant"
   	}
   },
+  	layout_building: layout_building,
   	layout_line: layout_line,
   	layout_symbol: layout_symbol,
   	layout_raster: layout_raster,
@@ -9725,6 +10122,7 @@
   		]
   	}
   },
+  	filter_building: filter_building,
   	filter_heatmap: filter_heatmap,
   	filter_operator: filter_operator,
   	geometry_type: geometry_type,
@@ -9941,6 +10339,30 @@
   		},
   		"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,
@@ -10479,6 +10901,7 @@
   		"property-type": "data-constant"
   	}
   },
+  	paint_building: paint_building,
   	paint_line: paint_line,
   	paint_circle: paint_circle,
   	paint_heatmap: paint_heatmap,
@@ -12607,8 +13030,8 @@
               ])
           });
       }
-      scaleSelf(factor) {
-          this.options.transform.scaleSelf(factor);
+      scaleSelf(factor, yFactor) {
+          this.options.transform.scaleSelf(factor, yFactor);
           return this;
       }
   }
@@ -12903,6 +13326,7 @@
           }
           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);
@@ -13322,6 +13746,7 @@
           }
           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));
@@ -13623,6 +14048,306 @@
       }
   }
 
+  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++) {
@@ -15158,6 +15883,7 @@
           }
           return new Config(type, toString(configKey.value));
       }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       evaluate(ctx) {
           const FQIDSeparator = '\x1F';
           const configKey = [
@@ -15302,6 +16028,7 @@
           }
           return new Var(name, context.scope.get(name));
       }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       evaluate(ctx) {
           return this.boundExpression.evaluate(ctx);
       }
@@ -15567,6 +16294,7 @@
           }
           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;
@@ -15969,6 +16697,7 @@
           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;
@@ -16011,6 +16740,7 @@
           this.bindings = [].concat(bindings);
           this.result = result;
       }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       evaluate(ctx) {
           return this.result.evaluate(ctx);
       }
@@ -16253,6 +16983,7 @@
               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);
@@ -16369,6 +17100,7 @@
           }
           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;
@@ -16450,6 +17182,7 @@
               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)) {
@@ -16508,6 +17241,7 @@
               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);
@@ -17028,6 +17762,7 @@
           overloads: [
               [
                   [StringType],
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                   (ctx, [key]) => get(key.evaluate(ctx), ctx.properties())
               ],
               [
@@ -17035,6 +17770,7 @@
                       StringType,
                       ObjectType
                   ],
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                   (ctx, [key, obj]) => get(key.evaluate(ctx), obj.evaluate(ctx))
               ]
           ]
@@ -17042,6 +17778,7 @@
       'feature-state': [
           ValueType,
           [StringType],
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
           (ctx, [key]) => get(key.evaluate(ctx), ctx.featureState || {})
       ],
       'properties': [
@@ -17239,11 +17976,13 @@
       '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': [
@@ -17417,6 +18156,7 @@
                       BooleanType,
                       BooleanType
                   ],
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                   (ctx, [a, b]) => a.evaluate(ctx) && b.evaluate(ctx)
               ],
               [
@@ -17439,6 +18179,7 @@
                       BooleanType,
                       BooleanType
                   ],
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                   (ctx, [a, b]) => a.evaluate(ctx) || b.evaluate(ctx)
               ],
               [
@@ -17473,11 +18214,13 @@
       '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': [
@@ -17488,6 +18231,7 @@
       'resolved-locale': [
           StringType,
           [CollatorType],
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
           (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
       ],
       'random': [
@@ -17635,6 +18379,7 @@
               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({
@@ -17652,7 +18397,9 @@
               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 {
@@ -18758,7 +19505,8 @@ ${ JSON.stringify(filterExp, null, 2) }
               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
@@ -19043,7 +19791,15 @@ ${ JSON.stringify(filterExp, null, 2) }
       /**
      * { 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({
@@ -19350,6 +20106,47 @@ ${ JSON.stringify(filterExp, null, 2) }
           });
       }
   }
+  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 [{
@@ -19451,6 +20248,9 @@ ${ JSON.stringify(filterExp, null, 2) }
                   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,
@@ -20204,8 +21004,8 @@ Use an identity property function instead: ${ example }.`)];
                       '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.`));
               }
@@ -21962,7 +22762,7 @@ Use an identity property function instead: ${ example }.`)];
       return !!value.match(regex);
   }
   function getSourceCount(source) {
-      if (source.url) {
+      if ('url' in source) {
           return source.url.split(',').length;
       } else {
           return 0;
@@ -22001,7 +22801,7 @@ Use an identity property function instead: ${ example }.`)];
           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;