@mapbox/mapbox-gl-style-spec 14.8.0-beta.1 → 14.9.0-beta.1

package/dist/index.es.js

@@ -107,6 +107,16 @@ var $root = {
 		type: "fog",
 		doc: "A global effect that fades layers and markers based on their distance to the camera. The fog can be used to approximate the effect of atmosphere on distant objects and enhance the depth perception of the map when used with terrain or 3D features. Note: fog is renamed to atmosphere in the Android and iOS SDKs and planned to be changed in GL-JS v.3.0.0."
 	},
+	snow: {
+		type: "snow",
+		doc: "Global precipitation particle-based snow. Having snow present in the style forces constant map repaint mode",
+		experimental: true
+	},
+	rain: {
+		type: "rain",
+		doc: "Global precipitation particle-based rain effect. Having rain present in the style forces constant map repaint mode.",
+		experimental: true
+	},
 	camera: {
 		type: "camera",
 		doc: "Global setting to control additional camera intrinsics parameters, e.g. projection type (perspective / orthographic)."
@@ -115,6 +125,11 @@ var $root = {
 		type: "colorTheme",
 		doc: "A global modifier for the colors of the style."
 	},
+	indoor: {
+		type: "indoor",
+		experimental: true,
+		doc: "Controls the behaviour of indoor features."
+	},
 	imports: {
 		type: "array",
 		value: "import",
@@ -212,7 +227,7 @@ var $root = {
 	featuresets: {
 		experimental: true,
 		type: "featuresets",
-		doc: "Defines sets of features for querying, interaction, and feature state manipulation.",
+		doc: "Defines sets of features for querying, interaction, and state management on the map, referencing individual layers or subsets of layers within the map's style.",
 		example: {
 			poi: {
 				selectors: [
@@ -455,6 +470,28 @@ var properties_light_directional = {
 			}
 		}
 	},
+	"shadow-quality": {
+		type: "number",
+		"property-type": "data-constant",
+		"default": 1,
+		minimum: 0,
+		maximum: 1,
+		expression: {
+			interpolated: false,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: false,
+		doc: "Determines the quality of the shadows on the map. A value of 1 ensures the highest quality and is the default value.",
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		},
+		experimental: true
+	},
 	"shadow-intensity": {
 		type: "number",
 		"property-type": "data-constant",
@@ -1579,6 +1616,35 @@ var layout_fill = {
 			interpolated: false
 		},
 		"property-type": "constant"
+	},
+	"fill-elevation-reference": {
+		type: "enum",
+		doc: "Selects the base of fill-elevation. Some modes might require precomputed elevation data in the tileset.",
+		values: {
+			none: {
+				doc: "Elevated rendering is disabled."
+			},
+			"hd-road-base": {
+				doc: "Elevate geometry relative to HD roads. Use this mode to describe base polygons of the road networks."
+			},
+			"hd-road-markup": {
+				doc: "Elevated rendering is enabled. Use this mode to describe additive and stackable features such as 'hatched areas' that should exist only on top of road polygons."
+			}
+		},
+		"default": "none",
+		experimental: true,
+		"private": true,
+		transition: false,
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "data-constant"
 	}
 };
 var layout_circle = {
@@ -1927,6 +1993,36 @@ var layout_line = {
 			interpolated: false
 		},
 		"property-type": "constant"
+	},
+	"line-width-unit": {
+		type: "enum",
+		doc: "Selects the unit of line-width. The same unit is automatically used for line-blur and line-offset. Note: This is an experimental property and might be removed in a future release.",
+		values: {
+			pixels: {
+				doc: "Width is rendered in pixels."
+			},
+			meters: {
+				doc: "Width is rendered in meters."
+			}
+		},
+		"default": "pixels",
+		experimental: true,
+		"private": true,
+		transition: false,
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.9.0",
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		},
+		expression: {
+			interpolated: false,
+			parameters: [
+				"zoom"
+			]
+		},
+		"property-type": "data-constant"
 	}
 };
 var layout_symbol = {
@@ -2041,7 +2137,7 @@ var layout_symbol = {
 				doc: "Sorts symbols by `symbol-sort-key` if set. Otherwise, sorts symbols by their y-position relative to the viewport if `icon-allow-overlap` or `text-allow-overlap` is set to `true` or `icon-ignore-placement` or `text-ignore-placement` is `false`."
 			},
 			"viewport-y": {
-				doc: "Sorts symbols by their y-position relative to the viewport if `icon-allow-overlap` or `text-allow-overlap` is set to `true` or `icon-ignore-placement` or `text-ignore-placement` is `false`."
+				doc: "Sorts symbols by their y-position relative to the viewport if any of the following is set to `true`: `icon-allow-overlap`, `text-allow-overlap`, `icon-ignore-placement`, `text-ignore-placement`."
 			},
 			source: {
 				doc: "Sorts symbols by `symbol-sort-key` if set. Otherwise, no sorting is applied; symbols are rendered in the same order as the source data."
@@ -2095,6 +2191,36 @@ var layout_symbol = {
 		},
 		"property-type": "data-constant"
 	},
+	"symbol-elevation-reference": {
+		type: "enum",
+		doc: "Selects the base of symbol-elevation.",
+		values: {
+			sea: {
+				doc: "Elevate symbols relative to the sea level."
+			},
+			ground: {
+				doc: "Elevate symbols relative to the ground's height below them."
+			},
+			"hd-road-markup": {
+				doc: "Use this mode to enable elevated behavior for features that are rendered on top of 3D road polygons. The feature is currently being developed."
+			}
+		},
+		"default": "ground",
+		experimental: true,
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		},
+		expression: {
+			interpolated: false,
+			parameters: [
+				"zoom"
+			]
+		},
+		"property-type": "data-constant"
+	},
 	"icon-allow-overlap": {
 		type: "boolean",
 		"default": false,
@@ -2248,9 +2374,7 @@ var layout_symbol = {
 		},
 		"sdk-support": {
 			"basic functionality": {
-				js: "3.8.0",
-				android: "11.8.0",
-				ios: "11.8.0"
+				js: "3.8.0"
 			}
 		},
 		"property-type": "data-constant"
@@ -2762,9 +2886,7 @@ var layout_symbol = {
 		},
 		"sdk-support": {
 			"basic functionality": {
-				js: "3.8.0",
-				android: "11.8.0",
-				ios: "11.8.0"
+				js: "3.8.0"
 			}
 		},
 		"property-type": "data-constant"
@@ -3468,6 +3590,62 @@ var filter_fill = {
 		]
 	}
 };
+var filter_hillshade = {
+	type: "boolean",
+	doc: "Expression which determines whether or not to enable the hillshade layer. Hillshade 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_raster = {
+	type: "boolean",
+	doc: "Expression which determines whether or not to enable the raster layer. Raster 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_clip = {
+	type: "boolean",
+	doc: "Expression which determines whether or not to enable the clip layer. Clip 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_model = {
+	type: "boolean",
+	doc: "Expression which determines whether or not to display a model. Model 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_line = {
 	type: "boolean",
 	doc: "Expression which determines whether or not to display a Polygon or LineString. Line 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.",
@@ -3959,6 +4137,17 @@ var expression_name = {
 				}
 			}
 		},
+		"to-hsla": {
+			doc: "Returns a four-element array containing the input color's Hue, Saturation, Luminance and alpha components, in that order.",
+			group: "Color",
+			"sdk-support": {
+				"basic functionality": {
+					js: "3.9.0",
+					android: "11.9.0",
+					ios: "11.9.0"
+				}
+			}
+		},
 		"to-color": {
 			doc: "Converts the input value to a color. If multiple values are provided, each one is evaluated in order until the first successful conversion is obtained. If none of the inputs can be converted, the expression is an error.",
 			group: "Types",
@@ -4147,7 +4336,7 @@ var expression_name = {
 			}
 		},
 		"line-progress": {
-			doc: "Returns the progress along a gradient line. Can only be used in the `line-gradient` property.",
+			doc: "Returns the progress along a gradient line. Can only be used in the `line-gradient` and `line-z-offset` properties.",
 			group: "Feature data",
 			"sdk-support": {
 				"basic functionality": {
@@ -4892,11 +5081,11 @@ var snow = {
 			relaxZoomRestriction: true
 		},
 		transition: true,
-		doc: "Snow particles density.",
+		doc: "Snow particles density. Controls the overall particles number.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
@@ -4916,11 +5105,11 @@ var snow = {
 			relaxZoomRestriction: true
 		},
 		transition: true,
-		doc: "Snow particles movement factor.",
+		doc: "Snow particles movement factor. Controls the overall particles movement speed.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
@@ -4941,15 +5130,15 @@ var snow = {
 		doc: "Snow particles color.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
 	opacity: {
 		type: "number",
 		"property-type": "data-constant",
-		"default": 1,
+		"default": 0.9,
 		minimum: 0,
 		maximum: 1,
 		experimental: true,
@@ -4965,15 +5154,15 @@ var snow = {
 		doc: "Snow particles opacity.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
 	vignette: {
 		type: "number",
 		"property-type": "data-constant",
-		"default": 0,
+		"default": 0.3,
 		minimum: 0,
 		maximum: 1,
 		experimental: true,
@@ -4986,15 +5175,37 @@ var snow = {
 			relaxZoomRestriction: true
 		},
 		transition: true,
-		doc: "Snow vignette screen-space effect.",
+		doc: "Snow vignette screen-space effect. Adds snow tint to screen corners",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		}
+	},
+	"vignette-color": {
+		type: "color",
+		"property-type": "data-constant",
+		"default": "#ffffff",
+		experimental: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			],
+			relaxZoomRestriction: true
+		},
+		transition: true,
+		doc: "Snow vignette screen-space corners tint color.",
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
-	centerThinning: {
+	"center-thinning": {
 		type: "number",
 		"property-type": "data-constant",
 		"default": 1,
@@ -5013,8 +5224,8 @@ var snow = {
 		doc: "Thinning factor of snow particles from center. 0 - no thinning. 1 - maximal central area thinning.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
@@ -5039,15 +5250,39 @@ var snow = {
 			],
 			relaxZoomRestriction: true
 		},
-		doc: "Main snow particles direction. Heading & pitch",
+		doc: "Main snow particles direction. Azimuth and polar angles",
 		example: [
 			0,
 			45
 		],
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		}
+	},
+	"flake-size": {
+		type: "number",
+		"property-type": "data-constant",
+		"default": 1,
+		minimum: 0,
+		maximum: 5,
+		experimental: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			],
+			relaxZoomRestriction: true
+		},
+		transition: true,
+		doc: "Snow flake particle size. Correlates with individual particle screen size",
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	}
@@ -5069,11 +5304,11 @@ var rain = {
 			relaxZoomRestriction: true
 		},
 		transition: true,
-		doc: "Rain particles density.",
+		doc: "Rain particles density. Controls the overall screen density of the rain.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
@@ -5093,18 +5328,18 @@ var rain = {
 			relaxZoomRestriction: true
 		},
 		transition: true,
-		doc: "Rain particles movement factor.",
+		doc: "Rain particles movement factor. Controls the overall rain particles speed",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
 	color: {
 		type: "color",
 		"property-type": "data-constant",
-		"default": "#ffffff",
+		"default": "#919191",
 		experimental: true,
 		expression: {
 			interpolated: true,
@@ -5115,18 +5350,18 @@ var rain = {
 			relaxZoomRestriction: true
 		},
 		transition: true,
-		doc: "",
+		doc: "Individual rain particle dorplets color.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
 	opacity: {
 		type: "number",
 		"property-type": "data-constant",
-		"default": 1,
+		"default": 0.19,
 		minimum: 0,
 		maximum: 1,
 		experimental: true,
@@ -5142,15 +5377,15 @@ var rain = {
 		doc: "Rain particles opacity.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
 	vignette: {
 		type: "number",
 		"property-type": "data-constant",
-		"default": 0,
+		"default": 0.3,
 		minimum: 0,
 		maximum: 1,
 		experimental: true,
@@ -5163,15 +5398,37 @@ var rain = {
 			relaxZoomRestriction: true
 		},
 		transition: true,
-		doc: "Rain vignette screen-space effect.",
+		doc: "Screen-space vignette rain tinting effect intensity.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		}
+	},
+	"vignette-color": {
+		type: "color",
+		"property-type": "data-constant",
+		"default": "#ffffff",
+		experimental: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			],
+			relaxZoomRestriction: true
+		},
+		transition: true,
+		doc: "Rain vignette screen-space corners tint color.",
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
-	centerThinning: {
+	"center-thinning": {
 		type: "number",
 		"property-type": "data-constant",
 		"default": 1,
@@ -5190,8 +5447,8 @@ var rain = {
 		doc: "Thinning factor of rain particles from center. 0 - no thinning. 1 - maximal central area thinning.",
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	},
@@ -5216,15 +5473,72 @@ var rain = {
 			],
 			relaxZoomRestriction: true
 		},
-		doc: "Main rain particles direction. Heading & pitch",
+		doc: "Main rain particles direction. Azimuth and polar angles.",
 		example: [
 			0,
 			45
 		],
 		"sdk-support": {
 			"basic functionality": {
-				android: "11.8.0",
-				ios: "11.8.0"
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		}
+	},
+	"droplet-size": {
+		type: "array",
+		"default": [
+			1,
+			10
+		],
+		minimum: 0,
+		maximum: 20,
+		length: 2,
+		value: "number",
+		"property-type": "data-constant",
+		transition: true,
+		experimental: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			],
+			relaxZoomRestriction: true
+		},
+		doc: "Rain droplet size. x - normal to direction, y - along direction",
+		example: [
+			0,
+			45
+		],
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
+			}
+		}
+	},
+	"distortion-strength": {
+		type: "number",
+		"property-type": "data-constant",
+		"default": 0.5,
+		minimum: 0,
+		maximum: 1,
+		experimental: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			],
+			relaxZoomRestriction: true
+		},
+		transition: true,
+		doc: "Rain particles screen-space distortion strength.",
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		}
 	}
@@ -5262,7 +5576,29 @@ var camera = {
 var colorTheme = {
 	data: {
 		type: "string",
-		doc: "Expects a base64 encoded PNG image which represents a cube strip LUT. The height of the image cannot exceed 32 pixels and the width must be equal to the height squared.",
+		doc: "Expects a base64 encoded PNG image which represents a cube strip LUT. The height of the image cannot exceed 32 pixels and the width must be equal to the height squared.",
+		transition: false,
+		"property-type": "data-constant",
+		expression: {
+			interpolated: false
+		}
+	}
+};
+var indoor = {
+	floorplanFeaturesetId: {
+		type: "string",
+		doc: "An ID of a featureset to be used to query indoor floorplans.",
+		experimental: true,
+		transition: false,
+		"property-type": "data-constant",
+		expression: {
+			interpolated: false
+		}
+	},
+	buildingFeaturesetId: {
+		type: "string",
+		doc: "An ID of a featureset to be used to add interactivity for building selection.",
+		experimental: true,
 		transition: false,
 		"property-type": "data-constant",
 		expression: {
@@ -5929,7 +6265,8 @@ var paint_line = {
 				"zoom",
 				"feature",
 				"feature-state",
-				"measure-light"
+				"measure-light",
+				"line-progress"
 			]
 		},
 		"property-type": "data-driven"
@@ -7546,34 +7883,6 @@ var paint_symbol = {
 			]
 		},
 		"property-type": "data-driven"
-	},
-	"symbol-elevation-reference": {
-		type: "enum",
-		doc: "Selects the base of symbol-elevation.",
-		values: {
-			sea: {
-				doc: "Elevate symbols relative to the sea level."
-			},
-			ground: {
-				doc: "Elevate symbols relative to the ground's height below them."
-			}
-		},
-		"default": "ground",
-		experimental: true,
-		"sdk-support": {
-			"basic functionality": {
-				js: "3.7.0",
-				android: "11.7.0",
-				ios: "11.7.0"
-			}
-		},
-		expression: {
-			interpolated: false,
-			parameters: [
-				"zoom"
-			]
-		},
-		"property-type": "data-constant"
 	}
 };
 var paint_raster = {
@@ -8083,7 +8392,7 @@ var paint_background = {
 				doc: "The background is aligned to the plane of the map."
 			},
 			viewport: {
-				doc: "The background is aligned to the plane of the viewport, covering the whole screen."
+				doc: "The background is aligned to the plane of the viewport, covering the whole screen. Note: This mode disables the automatic reordering of the layer when terrain or globe projection is used."
 			}
 		},
 		"default": "map",
@@ -8100,6 +8409,7 @@ var paint_background = {
 			parameters: [
 			]
 		},
+		experimental: true,
 		"property-type": "data-constant"
 	},
 	"background-color": {
@@ -8451,11 +8761,13 @@ var paint_model = {
 		"default": 1,
 		minimum: 0,
 		maximum: 1,
-		doc: "The opacity of the model layer.",
+		doc: "The opacity of the model layer. Except for zoom, expressions that are data-driven are not supported if using GeoJSON or vector tile as the model layer source.",
 		transition: true,
 		expression: {
 			interpolated: true,
 			parameters: [
+				"feature",
+				"feature-state",
 				"zoom"
 			]
 		},
@@ -8464,9 +8776,14 @@ var paint_model = {
 				js: "3.0.0",
 				android: "11.0.0",
 				ios: "11.0.0"
+			},
+			"data-driven styling": {
+				js: "3.9.0",
+				android: "11.9.0",
+				ios: "11.9.0"
 			}
 		},
-		"property-type": "data-constant"
+		"property-type": "data-driven"
 	},
 	"model-rotation": {
 		type: "array",
@@ -8893,6 +9210,11 @@ var v8 = {
 	data: {
 		type: "$root",
 		doc: "The inlined style that must correspond to the contents of the specified URL."
+	},
+	"color-theme": {
+		type: "colorTheme",
+		optional: true,
+		doc: "If specified, it overrides the color-theme of the imported style."
 	}
 },
 	config: config,
@@ -9062,6 +9384,24 @@ var v8 = {
 	filter: filter,
 	filter_symbol: filter_symbol,
 	filter_fill: filter_fill,
+	filter_hillshade: filter_hillshade,
+	filter_raster: filter_raster,
+	"filter_raster-particle": {
+	type: "boolean",
+	doc: "Expression which determines whether or not to enable the raster particle layer. Raster particle 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"
+		]
+	}
+},
+	filter_clip: filter_clip,
+	filter_model: filter_model,
 	filter_line: filter_line,
 	filter_circle: filter_circle,
 	"filter_fill-extrusion": {
@@ -9151,6 +9491,7 @@ var v8 = {
 	rain: rain,
 	camera: camera,
 	colorTheme: colorTheme,
+	indoor: indoor,
 	light: light,
 	projection: projection,
 	terrain: terrain,
@@ -11546,7 +11887,7 @@ class Color {
    * var translucentGreen = new Color.parse('rgba(26, 207, 26, .73)');
    * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
    */
-    toString() {
+    toStringPremultipliedAlpha() {
         const [r, g, b, a] = this.a === 0 ? [
             0,
             0,
@@ -11560,10 +11901,22 @@ class Color {
         ];
         return `rgba(${ Math.round(r) },${ Math.round(g) },${ Math.round(b) },${ a })`;
     }
+    toString() {
+        const [r, g, b, a] = [
+            this.r,
+            this.g,
+            this.b,
+            this.a
+        ];
+        return `rgba(${ Math.round(r * 255) },${ Math.round(g * 255) },${ Math.round(b * 255) },${ a })`;
+    }
     toRenderColor(lut) {
         const {r, g, b, a} = this;
         return new RenderColor(lut, r, g, b, a);
     }
+    clone() {
+        return new Color(this.r, this.g, this.b, this.a);
+    }
 }
 class RenderColor {
     constructor(lut, r, g, b, a) {
@@ -11625,6 +11978,53 @@ class RenderColor {
         ];
     }
     /**
+   * Returns an HSLA array of values representing the color, unpremultiplied by A.
+   *
+   * @returns An array of HSLA color values.
+   */
+    toHslaArray() {
+        if (this.a === 0) {
+            return [
+                0,
+                0,
+                0,
+                0
+            ];
+        }
+        const {r, g, b, a} = this;
+        const red = Math.min(Math.max(r / a, 0), 1);
+        const green = Math.min(Math.max(g / a, 0), 1);
+        const blue = Math.min(Math.max(b / a, 0), 1);
+        const min = Math.min(red, green, blue);
+        const max = Math.max(red, green, blue);
+        const l = (min + max) / 2;
+        if (min === max) {
+            return [
+                0,
+                0,
+                l * 100,
+                a
+            ];
+        }
+        const delta = max - min;
+        const s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+        let h = 0;
+        if (max === red) {
+            h = (green - blue) / delta + (green < blue ? 6 : 0);
+        } else if (max === green) {
+            h = (blue - red) / delta + 2;
+        } else if (max === blue) {
+            h = (red - green) / delta + 4;
+        }
+        h *= 60;
+        return [
+            Math.min(Math.max(h, 0), 360),
+            Math.min(Math.max(s * 100, 0), 100),
+            Math.min(Math.max(l * 100, 0), 100),
+            a
+        ];
+    }
+    /**
    * Returns a RGBA array of float values representing the color, unpremultiplied by A.
    *
    * @returns An array of RGBA color values in the range [0, 1].
@@ -11741,7 +12141,7 @@ class Formatted {
     isEmpty() {
         if (this.sections.length === 0)
             return true;
-        return !this.sections.some(section => section.text.length !== 0 || section.image && section.image.namePrimary.length !== 0);
+        return !this.sections.some(section => section.text.length !== 0 || section.image && section.image.namePrimary);
     }
     static factory(text) {
         if (text instanceof Formatted) {
@@ -11785,42 +12185,113 @@ class Formatted {
     }
 }
 
+class ImageIdWithOptions {
+    constructor(id, options) {
+        this.id = id;
+        this.options = options || { params: {} };
+        if (!this.options.transform) {
+            this.options.transform = new DOMMatrix([
+                1,
+                0,
+                0,
+                1,
+                0,
+                0
+            ]);
+        } else {
+            const {a, b, c, d, e, f} = this.options.transform;
+            this.options.transform = new DOMMatrix([
+                a,
+                b,
+                c,
+                d,
+                e,
+                f
+            ]);
+        }
+    }
+    static deserializeFromString(serialized) {
+        const deserializedObject = JSON.parse(serialized);
+        ({ params: deserializedObject.options.params });
+        const {a, b, c, d, e, f} = deserializedObject.options.transform;
+        new DOMMatrix([
+            a,
+            b,
+            c,
+            d,
+            e,
+            f
+        ]);
+        return new ImageIdWithOptions(deserializedObject.id, deserializedObject.options);
+    }
+    scaleSelf(factor) {
+        this.options.transform = this.options.transform.scale(factor);
+        return this;
+    }
+    serialize() {
+        const serialisedObject = { id: this.id };
+        if (this.options) {
+            serialisedObject.options = this.options;
+        }
+        const {a, b, c, d, e, f} = this.options.transform;
+        serialisedObject.options.transform = {
+            a,
+            b,
+            c,
+            d,
+            e,
+            f
+        };
+        return JSON.stringify(serialisedObject);
+    }
+}
+
 class ResolvedImage {
     constructor(options) {
         this.namePrimary = options.namePrimary;
         if (options.nameSecondary) {
             this.nameSecondary = options.nameSecondary;
         }
+        if (options.optionsPrimary) {
+            this.optionsPrimary = options.optionsPrimary;
+        }
+        if (options.optionsSecondary) {
+            this.optionsSecondary = options.optionsSecondary;
+        }
         this.available = options.available;
     }
     toString() {
-        if (this.nameSecondary) {
+        if (this.namePrimary && this.nameSecondary) {
             return `[${ this.namePrimary },${ this.nameSecondary }]`;
         }
         return this.namePrimary;
     }
-    static fromString(namePrimary, nameSecondary) {
+    getPrimary() {
+        return new ImageIdWithOptions(this.namePrimary, { params: this.optionsPrimary ? this.optionsPrimary.params || {} : {} });
+    }
+    getSerializedPrimary() {
+        return this.getPrimary().serialize();
+    }
+    getSecondary() {
+        if (this.nameSecondary) {
+            return new ImageIdWithOptions(this.nameSecondary, { params: this.optionsSecondary ? this.optionsSecondary.params || {} : {} });
+        }
+        return null;
+    }
+    static from(image) {
+        return typeof image === 'string' ? ResolvedImage.build(image) : image;
+    }
+    static build(namePrimary, nameSecondary, optionsPrimary, optionsSecondary) {
         if (!namePrimary)
             return null;
         return new ResolvedImage({
             namePrimary,
             nameSecondary,
+            optionsPrimary,
+            optionsSecondary,
             available: false
         });
     }
-    serialize() {
-        if (this.nameSecondary) {
-            return [
-                'image',
-                this.namePrimary,
-                this.nameSecondary
-            ];
-        }
-        return [
-            'image',
-            this.namePrimary
-        ];
-    }
 }
 
 function validateRGBA(r, g, b, a) {
@@ -11961,7 +12432,9 @@ function toString(value) {
         return '';
     } else if (type === 'string' || type === 'number' || type === 'boolean') {
         return String(value);
-    } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
+    } else if (value instanceof Color) {
+        return value.toStringPremultipliedAlpha();
+    } else if (value instanceof Formatted || value instanceof ResolvedImage) {
         return value.toString();
     } else {
         return JSON.stringify(value);
@@ -12210,29 +12683,114 @@ class FormatExpression {
     }
 }
 
+function isImageOptions(value) {
+    if (typeof value !== 'string' && !isExpression(value)) {
+        return true;
+    }
+    return false;
+}
 class ImageExpression {
-    constructor(inputPrimary, inputSecondary) {
+    constructor(inputPrimary, inputSecondary, inputPrimaryParams, inputSecondaryParams) {
+        this._imageWarnHistory = {};
         this.type = ResolvedImageType;
         this.inputPrimary = inputPrimary;
         this.inputSecondary = inputSecondary;
+        this.inputPrimaryParams = inputPrimaryParams;
+        this.inputSecondaryParams = inputSecondaryParams;
     }
     static parse(args, context) {
         if (args.length < 2) {
             return context.error(`Expected two or more arguments.`);
         }
-        const namePrimary = context.parse(args[1], 1, StringType);
-        if (!namePrimary)
-            return context.error(`No image name provided.`);
-        if (args.length === 2) {
-            return new ImageExpression(namePrimary);
+        let nextArgId = 1;
+        const imageExpression = [];
+        function tryParseImage() {
+            if (nextArgId < args.length) {
+                const imageName = context.parse(args[nextArgId], nextArgId++, StringType);
+                if (!imageName) {
+                    context.error(imageExpression.length ? `Secondary image variant is not a string.` : `No image name provided.`);
+                    return false;
+                }
+                imageExpression.push({
+                    image: imageName,
+                    options: void 0
+                });
+                return true;
+            }
+            return true;
+        }
+        function tryParseOptions() {
+            if (nextArgId < args.length) {
+                if (!isImageOptions(args[nextArgId])) {
+                    return true;
+                }
+                const params = args[nextArgId].params;
+                const optionsContext = context.concat(nextArgId);
+                if (!params) {
+                    nextArgId++;
+                    return true;
+                }
+                if (typeof params !== 'object' || params.constructor !== Object) {
+                    optionsContext.error(`Image options "params" should be an object`);
+                    return false;
+                }
+                const parsed = {};
+                const childContext = optionsContext.concat(void 0, 'params');
+                for (const key in params) {
+                    if (!key) {
+                        childContext.error(`Image parameter name should be non-empty`);
+                        return false;
+                    }
+                    const value = childContext.concat(void 0, key).parse(params[key], void 0, ColorType, void 0, { typeAnnotation: 'coerce' });
+                    if (!value) {
+                        return false;
+                    }
+                    parsed[key] = value;
+                }
+                imageExpression[imageExpression.length - 1].options = parsed;
+                nextArgId++;
+                return true;
+            }
+            return true;
+        }
+        for (let i = 0; i < 2; i++) {
+            if (!tryParseImage() || !tryParseOptions()) {
+                return;
+            }
+        }
+        return new ImageExpression(imageExpression[0].image, imageExpression[1] ? imageExpression[1].image : void 0, imageExpression[0].options, imageExpression[1] ? imageExpression[1].options : void 0);
+    }
+    evaluateParams(ctx, params) {
+        const result = {};
+        if (params) {
+            for (const key in params) {
+                if (params[key]) {
+                    try {
+                        const color = params[key].evaluate(ctx);
+                        const msg = `Ignoring image parameter "${ key }" with semi-transparent color ${ color.toString() }`;
+                        if (color.a !== 1) {
+                            if (!this._imageWarnHistory[msg]) {
+                                console.warn(msg);
+                                this._imageWarnHistory[msg] = true;
+                            }
+                            continue;
+                        }
+                        result[key] = color;
+                    } catch (err) {
+                        continue;
+                    }
+                }
+            }
+        } else {
+            return void 0;
+        }
+        if (Object.keys(result).length === 0) {
+            return void 0;
         }
-        const nameSecondary = context.parse(args[2], 1, StringType);
-        if (!nameSecondary)
-            return context.error(`Secondary image variant is not a string.`);
-        return new ImageExpression(namePrimary, nameSecondary);
+        return { params: result };
     }
     evaluate(ctx) {
-        const value = ResolvedImage.fromString(this.inputPrimary.evaluate(ctx), this.inputSecondary ? this.inputSecondary.evaluate(ctx) : void 0);
+        const value = ResolvedImage.build(this.inputPrimary.evaluate(ctx), this.inputSecondary ? this.inputSecondary.evaluate(ctx) : void 0, this.inputPrimaryParams ? this.evaluateParams(ctx, this.inputPrimaryParams) : void 0, this.inputSecondaryParams ? this.evaluateParams(ctx, this.inputSecondaryParams) : void 0);
         if (value && ctx.availableImages) {
             value.available = ctx.availableImages.indexOf(value.namePrimary) > -1;
             if (value.nameSecondary && value.available && ctx.availableImages) {
@@ -12243,25 +12801,55 @@ class ImageExpression {
     }
     eachChild(fn) {
         fn(this.inputPrimary);
+        if (this.inputPrimaryParams) {
+            for (const key in this.inputPrimaryParams) {
+                if (this.inputPrimaryParams[key]) {
+                    fn(this.inputPrimaryParams[key]);
+                }
+            }
+        }
         if (this.inputSecondary) {
             fn(this.inputSecondary);
+            if (this.inputSecondaryParams) {
+                for (const key in this.inputSecondaryParams) {
+                    if (this.inputSecondaryParams[key]) {
+                        fn(this.inputSecondaryParams[key]);
+                    }
+                }
+            }
         }
     }
     outputDefined() {
         return false;
     }
-    serialize() {
-        if (this.inputSecondary) {
-            return [
-                'image',
-                this.inputPrimary.serialize(),
-                this.inputSecondary.serialize()
-            ];
+    serializeParams(params) {
+        const result = {};
+        if (params) {
+            for (const key in params) {
+                if (params[key]) {
+                    result[key] = params[key].serialize();
+                }
+            }
+        } else {
+            return void 0;
         }
-        return [
+        return { params: result };
+    }
+    serialize() {
+        const serialized = [
             'image',
             this.inputPrimary.serialize()
         ];
+        if (this.inputPrimaryParams) {
+            serialized.push(this.serializeParams(this.inputPrimaryParams));
+        }
+        if (this.inputSecondary) {
+            serialized.push(this.inputSecondary.serialize());
+            if (this.inputSecondaryParams) {
+                serialized.push(this.serializeParams(this.inputSecondaryParams));
+            }
+        }
+        return serialized;
     }
 }
 
@@ -12389,7 +12977,7 @@ class Coercion {
         } else if (this.type.kind === 'formatted') {
             return Formatted.fromString(toString(this.args[0].evaluate(ctx)));
         } else if (this.type.kind === 'resolvedImage') {
-            return ResolvedImage.fromString(toString(this.args[0].evaluate(ctx)));
+            return ResolvedImage.build(toString(this.args[0].evaluate(ctx)));
         } else if (this.type.kind === 'array') {
             return this.args.map(arg => {
                 return arg.evaluate(ctx);
@@ -14143,7 +14731,7 @@ function coerceValue(type, value) {
             return Formatted.fromString(toString(value));
         }
     case 'resolvedImage': {
-            return ResolvedImage.fromString(toString(value));
+            return ResolvedImage.build(toString(value));
         }
     }
     return value;
@@ -14801,11 +15389,12 @@ var colorSpaces = /*#__PURE__*/Object.freeze({
 });
 
 class Interpolate {
-    constructor(type, operator, interpolation, input, stops) {
+    constructor(type, operator, interpolation, input, dynamicStops, stops) {
         this.type = type;
         this.operator = operator;
         this.interpolation = interpolation;
         this.input = input;
+        this.dynamicStops = dynamicStops;
         this.labels = [];
         this.outputs = [];
         for (const [label, expression] of stops) {
@@ -14853,10 +15442,10 @@ class Interpolate {
         } else {
             return context.error(`Unknown interpolation type ${ String(interpolation[0]) }`, 1, 0);
         }
-        if (args.length - 1 < 4) {
-            return context.error(`Expected at least 4 arguments, but found only ${ args.length - 1 }.`);
+        if (args.length - 1 < 3) {
+            return context.error(`Expected at least 3 arguments, but found only ${ args.length - 1 }.`);
         }
-        if ((args.length - 1) % 2 !== 0) {
+        if (args.length - 1 > 3 && (args.length - 1) % 2 !== 0) {
             return context.error(`Expected an even number of arguments.`);
         }
         input = context.parse(input, 2, NumberType);
@@ -14869,6 +15458,12 @@ class Interpolate {
         } else if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
+        if (args.length - 1 === 3) {
+            const dynamicStops = context.parse(rest[0], 3, ValueType);
+            if (!dynamicStops)
+                return null;
+            return new Interpolate(outputType, operator, interpolation, input, dynamicStops, stops);
+        }
         for (let i = 0; i < rest.length; i += 2) {
             const label = rest[i];
             const value = rest[i + 1];
@@ -14892,11 +15487,34 @@ class Interpolate {
         if (outputType.kind !== 'number' && outputType.kind !== 'color' && !(outputType.kind === 'array' && outputType.itemType.kind === 'number' && typeof outputType.N === 'number')) {
             return context.error(`Type ${ toString$1(outputType) } is not interpolatable.`);
         }
-        return new Interpolate(outputType, operator, interpolation, input, stops);
+        return new Interpolate(outputType, operator, interpolation, input, null, stops);
     }
     evaluate(ctx) {
-        const labels = this.labels;
-        const outputs = this.outputs;
+        let labels = this.labels;
+        let outputs = this.outputs;
+        if (this.dynamicStops) {
+            const dynamicStopsValue = this.dynamicStops.evaluate(ctx);
+            if (dynamicStopsValue.length % 2 !== 0) {
+                throw new RuntimeError('Expected an even number of arguments.');
+            }
+            labels = [];
+            outputs = [];
+            for (let i = 0; i < dynamicStopsValue.length; i += 2) {
+                const label = dynamicStopsValue[i];
+                const output = new Literal(NumberType, dynamicStopsValue[i + 1]);
+                if (typeof label !== 'number') {
+                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.');
+                }
+                if (labels.length && labels[labels.length - 1] >= label) {
+                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.');
+                }
+                labels.push(label);
+                outputs.push(output);
+            }
+            if (labels.length === 0) {
+                throw new RuntimeError('Expected at least one input/output pair.');
+            }
+        }
         if (labels.length === 1) {
             return outputs[0].evaluate(ctx);
         }
@@ -14952,8 +15570,12 @@ class Interpolate {
             interpolation,
             this.input.serialize()
         ];
-        for (let i = 0; i < this.labels.length; i++) {
-            serialized.push(this.labels[i], this.outputs[i].serialize());
+        if (this.dynamicStops) {
+            serialized.push(this.dynamicStops.serialize());
+        } else {
+            for (let i = 0; i < this.labels.length; i++) {
+                serialized.push(this.labels[i], this.outputs[i].serialize());
+            }
         }
         return serialized;
     }
@@ -15941,6 +16563,13 @@ CompoundExpression.register(expressions, {
             return v.evaluate(ctx).toRenderColor(null).toArray();
         }
     ],
+    'to-hsla': [
+        array$1(NumberType, 4),
+        [ColorType],
+        (ctx, [v]) => {
+            return v.evaluate(ctx).toRenderColor(null).toHslaArray();
+        }
+    ],
     'rgb': [
         ColorType,
         [
@@ -16516,6 +17145,9 @@ function supportsLightExpression(spec) {
 function supportsZoomExpression(spec) {
     return expressionHasParameter(spec.expression, 'zoom');
 }
+function supportsLineProgressExpression(spec) {
+    return expressionHasParameter(spec.expression, 'line-progress');
+}
 function supportsInterpolation(spec) {
     return !!spec.expression && spec.expression.interpolated;
 }
@@ -16702,7 +17334,7 @@ function evaluateIdentityFunction(parameters, propertySpec, input) {
     } else if (propertySpec.type === 'formatted') {
         input = Formatted.fromString(input.toString());
     } else if (propertySpec.type === 'resolvedImage') {
-        input = ResolvedImage.fromString(input.toString());
+        input = ResolvedImage.build(input.toString());
     } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
         input = void 0;
     }
@@ -16727,6 +17359,7 @@ class StyleExpression {
         this._evaluator = new EvaluationContext(scope, options);
         this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
+        this.configDependencies = getConfigDependencies(expression);
     }
     evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection, featureTileCoord, featureDistanceData) {
         this._evaluator.globals = globals;
@@ -16780,10 +17413,11 @@ function createExpression(expression, propertySpec, scope, options) {
     return success(new StyleExpression(parsed, propertySpec, scope, options));
 }
 class ZoomConstantExpression {
-    constructor(kind, expression, isLightConstant) {
+    constructor(kind, expression, isLightConstant, isLineProgressConstant) {
         this.kind = kind;
         this._styleExpression = expression;
         this.isLightConstant = isLightConstant;
+        this.isLineProgressConstant = isLineProgressConstant;
         this.isStateDependent = kind !== 'constant' && !isStateConstant(expression.expression);
         this.configDependencies = getConfigDependencies(expression.expression);
     }
@@ -16795,12 +17429,13 @@ class ZoomConstantExpression {
     }
 }
 class ZoomDependentExpression {
-    constructor(kind, expression, zoomStops, interpolationType, isLightConstant) {
+    constructor(kind, expression, zoomStops, interpolationType, isLightConstant, isLineProgressConstant) {
         this.kind = kind;
         this.zoomStops = zoomStops;
         this._styleExpression = expression;
         this.isStateDependent = kind !== 'camera' && !isStateConstant(expression.expression);
         this.isLightConstant = isLightConstant;
+        this.isLineProgressConstant = isLineProgressConstant;
         this.configDependencies = getConfigDependencies(expression.expression);
         this.interpolationType = interpolationType;
     }
@@ -16840,6 +17475,10 @@ function createPropertyExpression(expression, propertySpec, scope, options) {
     if (!isLightConstant && !supportsLightExpression(propertySpec)) {
         return error([new ParsingError$1('', 'measure-light expression not supported')]);
     }
+    const isLineProgressConstant = isGlobalPropertyConstant(parsed, ['line-progress']);
+    if (!isLineProgressConstant && !supportsLineProgressExpression(propertySpec)) {
+        return error([new ParsingError$1('', 'line-progress expression not supported')]);
+    }
     const canRelaxZoomRestriction = propertySpec.expression && propertySpec.expression.relaxZoomRestriction;
     const zoomCurve = findZoomCurve(parsed);
     if (!zoomCurve && !isZoomConstant && !canRelaxZoomRestriction) {
@@ -16850,14 +17489,14 @@ function createPropertyExpression(expression, propertySpec, scope, options) {
         return error([new ParsingError$1('', '"interpolate" expressions cannot be used with this property')]);
     }
     if (!zoomCurve) {
-        return success(isFeatureConstant$1 ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-        new ZoomConstantExpression('constant', expression.value, isLightConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-        new ZoomConstantExpression('source', expression.value, isLightConstant));
+        return success(isFeatureConstant$1 && isLineProgressConstant ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+        new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+        new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant));
     }
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : void 0;
-    return success(isFeatureConstant$1 ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-    new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-    new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant));
+    return success(isFeatureConstant$1 && isLineProgressConstant ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+    new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+    new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant));
 }
 class StylePropertyFunction {
     constructor(parameters, specification) {
@@ -17328,13 +17967,16 @@ Filter Expression:
 ${ JSON.stringify(filterExp, null, 2) }
         `);
     }
-    const filterSpec = v8[`filter_${ layerType }`];
-    const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
     let filterFunc = null;
-    if (compiledStaticFilter.result === 'error') {
-        throw new Error(compiledStaticFilter.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
-    } else {
-        filterFunc = (globalProperties, feature, canonical) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
+    let filterSpec = null;
+    if (layerType !== 'background' && layerType !== 'sky' && layerType !== 'slot') {
+        filterSpec = v8[`filter_${ layerType }`];
+        const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
+        if (compiledStaticFilter.result === 'error') {
+            throw new Error(compiledStaticFilter.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
+        } else {
+            filterFunc = (globalProperties, feature, canonical) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
+        }
     }
     let dynamicFilterFunc = null;
     let needFeature = null;
@@ -17976,6 +18618,14 @@ const operations = {
    */
     setFog: 'setFog',
     /*
+   *  { command: 'setSnow', args: [snowProperties] }
+   */
+    setSnow: 'setSnow',
+    /*
+   *  { command: 'setRain', args: [rainProperties] }
+   */
+    setRain: 'setRain',
+    /*
    *  { command: 'setCamera', args: [cameraProperties] }
    */
     setCamera: 'setCamera',
@@ -18376,6 +19026,18 @@ function diffStyles(before, after) {
                 args: [after.fog]
             });
         }
+        if (!deepEqual(before.snow, after.snow)) {
+            commands.push({
+                command: operations.setSnow,
+                args: [after.snow]
+            });
+        }
+        if (!deepEqual(before.rain, after.rain)) {
+            commands.push({
+                command: operations.setRain,
+                args: [after.rain]
+            });
+        }
         if (!deepEqual(before.projection, after.projection)) {
             commands.push({
                 command: operations.setProjection,
@@ -18987,6 +19649,16 @@ function validateProperty(options, propertyType) {
     const layerSpec = styleSpec[`${ propertyType }_${ options.layerType }`];
     if (!layerSpec)
         return [];
+    const useThemeMatch = propertyKey.match(/^(.*)-use-theme$/);
+    if (propertyType === 'paint' && useThemeMatch && layerSpec[useThemeMatch[1]]) {
+        return validate({
+            key,
+            value,
+            valueSpec: { type: 'string' },
+            style,
+            styleSpec
+        });
+    }
     const transitionMatch = propertyKey.match(/^(.*)-transition$/);
     if (propertyType === 'paint' && transitionMatch && layerSpec[transitionMatch[1]] && layerSpec[transitionMatch[1]].transition) {
         return validate({
@@ -19361,7 +20033,16 @@ function validateLight(options) {
     }
     for (const key in light) {
         const transitionMatch = key.match(/^(.*)-transition$/);
-        if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
+        const useThemeMatch = key.match(/^(.*)-use-theme$/);
+        if (useThemeMatch && lightSpec[useThemeMatch[1]]) {
+            errors = errors.concat(validate({
+                key,
+                value: light[key],
+                valueSpec: { type: 'string' },
+                style,
+                styleSpec
+            }));
+        } else if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
             errors = errors.concat(validate({
                 key,
                 value: light[key],
@@ -19447,7 +20128,16 @@ function validateLights(options) {
             }
         } else {
             const transitionMatch = key2.match(/^(.*)-transition$/);
-            if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
+            const useThemeMatch = key2.match(/^(.*)-use-theme$/);
+            if (useThemeMatch && lightSpec[useThemeMatch[1]]) {
+                errors = errors.concat(validate({
+                    key: key2,
+                    value: light[key2],
+                    valueSpec: { type: 'string' },
+                    style,
+                    styleSpec
+                }));
+            } else if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
                 errors = errors.concat(validate({
                     key: key2,
                     value: light[key2],
@@ -19489,7 +20179,16 @@ function validateTerrain(options) {
     }
     for (const key2 in terrain) {
         const transitionMatch = key2.match(/^(.*)-transition$/);
-        if (transitionMatch && terrainSpec[transitionMatch[1]] && terrainSpec[transitionMatch[1]].transition) {
+        const useThemeMatch = key2.match(/^(.*)-use-theme$/);
+        if (useThemeMatch && terrainSpec[useThemeMatch[1]]) {
+            errors = errors.concat(validate({
+                key: key2,
+                value: terrain[key2],
+                valueSpec: { type: 'string' },
+                style,
+                styleSpec
+            }));
+        } else if (transitionMatch && terrainSpec[transitionMatch[1]] && terrainSpec[transitionMatch[1]].transition) {
             errors = errors.concat(validate({
                 key: key2,
                 value: terrain[key2],
@@ -19538,7 +20237,16 @@ function validateFog(options) {
     }
     for (const key in fog) {
         const transitionMatch = key.match(/^(.*)-transition$/);
-        if (transitionMatch && fogSpec[transitionMatch[1]] && fogSpec[transitionMatch[1]].transition) {
+        const useThemeMatch = key.match(/^(.*)-use-theme$/);
+        if (useThemeMatch && fogSpec[useThemeMatch[1]]) {
+            errors = errors.concat(validate({
+                key,
+                value: fog[key],
+                valueSpec: { type: 'string' },
+                style,
+                styleSpec
+            }));
+        } else if (transitionMatch && fogSpec[transitionMatch[1]] && fogSpec[transitionMatch[1]].transition) {
             errors = errors.concat(validate({
                 key,
                 value: fog[key],