@mapbox/mapbox-gl-style-spec 14.4.0 → 14.5.0

package/dist/index.es.js

@@ -111,6 +111,10 @@ var $root = {
 		type: "camera",
 		doc: "Global setting to control additional camera intrinsics parameters, e.g. projection type (perspective / orthographic)."
 	},
+	"color-theme": {
+		type: "colorTheme",
+		doc: "A global modifier for the colors of the style."
+	},
 	imports: {
 		type: "array",
 		value: "import",
@@ -227,6 +231,10 @@ var option = {
 	"default": {
 		type: "*",
 		doc: "Default configuration value for this option.",
+		"property-type": "data-constant",
+		expression: {
+			interpolated: false
+		},
 		required: true
 	},
 	type: {
@@ -810,6 +818,7 @@ var source_raster_dem = {
 	}
 };
 var source_raster_array = {
+	experimental: true,
 	type: {
 		required: true,
 		type: "enum",
@@ -1143,6 +1152,7 @@ var layer = {
 				}
 			},
 			"raster-particle": {
+				experimental: true,
 				doc: "Particle animation driven by textures such as wind maps.",
 				"sdk-support": {
 					"basic functionality": {
@@ -1164,6 +1174,7 @@ var layer = {
 			},
 			model: {
 				doc: "A 3D model",
+				experimental: true,
 				"sdk-support": {
 					"basic functionality": {
 						js: "3.0.0",
@@ -1201,6 +1212,17 @@ var layer = {
 						ios: "11.0.0"
 					}
 				}
+			},
+			clip: {
+				doc: "Layer that removes 3D content from map.",
+				"sdk-support": {
+					"basic functionality": {
+						js: "3.5.0",
+						android: "11.5.0",
+						ios: "11.5.0"
+					},
+					experimental: true
+				}
 			}
 		},
 		doc: "Rendering type of this layer.",
@@ -1255,6 +1277,7 @@ var layer = {
 	}
 };
 var layout = [
+	"layout_clip",
 	"layout_fill",
 	"layout_line",
 	"layout_circle",
@@ -1390,6 +1413,35 @@ var layout_model = {
 		]
 	}
 };
+var layout_clip = {
+	"clip-layer-types": {
+		type: "array",
+		value: "enum",
+		values: {
+			model: {
+				doc: "If present the clip layer would remove all 3d model layers below it. Currently only instanced models (e.g. trees) are removed."
+			},
+			symbol: {
+				doc: "If present the clip layer would remove all symbol layers below it."
+			}
+		},
+		"default": [
+		],
+		doc: "Layer types that will also be removed if fallen below this clip layer.",
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.5.0"
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "data-constant",
+		experimental: true
+	}
+};
 var layout_fill = {
 	"fill-sort-key": {
 		type: "number",
@@ -1682,6 +1734,32 @@ var layout_line = {
 		},
 		"property-type": "data-driven"
 	},
+	"line-z-offset": {
+		type: "number",
+		experimental: true,
+		doc: "Vertical offset from ground, in meters. Defaults to 0. Not supported for globe projection at the moment.",
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.5.0"
+			},
+			"data-driven styling": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.5.0"
+			}
+		},
+		expression: {
+			interpolated: false,
+			parameters: [
+				"zoom",
+				"feature",
+				"line-progress"
+			]
+		},
+		"property-type": "data-driven"
+	},
 	visibility: {
 		type: "enum",
 		values: {
@@ -4638,6 +4716,17 @@ var camera = {
 		"property-type": "data-constant"
 	}
 };
+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.",
+		transition: false,
+		"property-type": "data-constant",
+		expression: {
+			interpolated: false
+		}
+	}
+};
 var light = {
 	anchor: {
 		type: "enum",
@@ -4896,6 +4985,7 @@ var paint = [
 	"paint_fill-extrusion",
 	"paint_symbol",
 	"paint_raster",
+	"paint_raster-particle",
 	"paint_hillshade",
 	"paint_background",
 	"paint_sky",
@@ -5478,7 +5568,7 @@ var paint_line = {
 	"line-trim-offset": {
 		type: "array",
 		value: "number",
-		doc: "The line part between [trim-start, trim-end] will be marked as transparent to make a route vanishing effect. The line trim-off offset is based on the whole line range [0.0, 1.0].",
+		doc: "The line part between [trim-start, trim-end] will be painted using `line-trim-color,` which is transparent by default to produce a route vanishing effect. The line trim-off offset is based on the whole line range [0.0, 1.0].",
 		length: 2,
 		"default": [
 			0,
@@ -5510,6 +5600,81 @@ var paint_line = {
 		},
 		"property-type": "constant"
 	},
+	"line-trim-fade-range": {
+		type: "array",
+		value: "number",
+		doc: "The fade range for the trim-start and trim-end points is defined by the `line-trim-offset` property. The first element of the array represents the fade range from the trim-start point toward the end of the line, while the second element defines the fade range from the trim-end point toward the beginning of the line. The fade result is achieved by interpolating between `line-trim-color` and the color specified by the `line-color` or the `line-gradient` property.",
+		experimental: true,
+		length: 2,
+		"default": [
+			0,
+			0
+		],
+		minimum: [
+			0,
+			0
+		],
+		maximum: [
+			1,
+			1
+		],
+		transition: false,
+		requires: [
+			"line-trim-offset",
+			{
+				source: "geojson",
+				has: {
+					lineMetrics: true
+				}
+			}
+		],
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			]
+		},
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.6.0",
+				android: "11.6.0",
+				ios: "11.6.0"
+			}
+		},
+		"property-type": "data-constant"
+	},
+	"line-trim-color": {
+		type: "color",
+		doc: "The color to be used for rendering the trimmed line section that is defined by the `line-trim-offset` property.",
+		experimental: true,
+		"default": "transparent",
+		transition: true,
+		requires: [
+			"line-trim-offset",
+			{
+				source: "geojson",
+				has: {
+					lineMetrics: true
+				}
+			}
+		],
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.6.0",
+				android: "11.6.0",
+				ios: "11.6.0"
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light"
+			]
+		},
+		"property-type": "data-constant"
+	},
 	"line-emissive-strength": {
 		type: "number",
 		"default": 0,
@@ -5592,6 +5757,29 @@ var paint_line = {
 			]
 		},
 		"property-type": "data-driven"
+	},
+	"line-occlusion-opacity": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		experimental: true,
+		doc: "Opacity multiplier (multiplies line-opacity value) of the line part that is occluded by 3D objects. Value 0 hides occluded part, value 1 means the same opacity as non-occluded part. The property is not supported when `line-opacity` has data-driven styling.",
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.5.0"
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: true,
+		"property-type": "data-constant"
 	}
 };
 var paint_circle = {
@@ -6116,6 +6304,39 @@ var paint_symbol = {
 		},
 		"property-type": "data-driven"
 	},
+	"icon-occlusion-opacity": {
+		doc: "The opacity at which the icon will be drawn in case of being depth occluded. Not supported on globe zoom levels.",
+		type: "number",
+		"default": 1,
+		minimum: 0,
+		maximum: 1,
+		transition: true,
+		requires: [
+			"icon-image"
+		],
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.6.0"
+			},
+			"data-driven styling": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.6.0"
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"feature",
+				"feature-state",
+				"measure-light"
+			]
+		},
+		"property-type": "data-driven"
+	},
 	"icon-emissive-strength": {
 		type: "number",
 		"default": 1,
@@ -6432,6 +6653,39 @@ var paint_symbol = {
 		},
 		"property-type": "data-driven"
 	},
+	"text-occlusion-opacity": {
+		type: "number",
+		doc: "The opacity at which the text will be drawn in case of being depth occluded. Not supported on globe zoom levels.",
+		"default": 1,
+		minimum: 0,
+		maximum: 1,
+		transition: true,
+		requires: [
+			"text-field"
+		],
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.6.0"
+			},
+			"data-driven styling": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.6.0"
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"feature",
+				"feature-state",
+				"measure-light"
+			]
+		},
+		"property-type": "data-driven"
+	},
 	"text-color": {
 		type: "color",
 		doc: "The color with which the text will be drawn.",
@@ -6994,6 +7248,7 @@ var paint_raster = {
 	"raster-array-band": {
 		type: "string",
 		required: false,
+		experimental: true,
 		"property-type": "data-constant",
 		transition: false,
 		requires: [
@@ -7017,6 +7272,7 @@ var paint_raster = {
 		"default": 0,
 		minimum: 0,
 		transition: true,
+		experimental: true,
 		"sdk-support": {
 			"basic functionality": {
 				js: "3.1.0",
@@ -8063,6 +8319,7 @@ var v8 = {
 	layout_background: layout_background,
 	layout_sky: layout_sky,
 	layout_model: layout_model,
+	layout_clip: layout_clip,
 	layout_fill: layout_fill,
 	layout_circle: layout_circle,
 	layout_heatmap: layout_heatmap,
@@ -8098,6 +8355,7 @@ var v8 = {
 	},
 	"fill-extrusion-edge-radius": {
 		type: "number",
+		experimental: true,
 		"private": true,
 		"default": 0,
 		minimum: 0,
@@ -8245,6 +8503,7 @@ var v8 = {
 	expression_name: expression_name,
 	fog: fog,
 	camera: camera,
+	colorTheme: colorTheme,
 	light: light,
 	projection: projection,
 	terrain: terrain,
@@ -8519,6 +8778,7 @@ var v8 = {
 	"fill-extrusion-ambient-occlusion-wall-radius": {
 		"property-type": "data-constant",
 		type: "number",
+		experimental: true,
 		"default": 3,
 		minimum: 0,
 		expression: {
@@ -8544,6 +8804,7 @@ var v8 = {
 	"fill-extrusion-ambient-occlusion-ground-radius": {
 		"property-type": "data-constant",
 		type: "number",
+		experimental: true,
 		"default": 3,
 		minimum: 0,
 		expression: {
@@ -8568,6 +8829,7 @@ var v8 = {
 	"fill-extrusion-ambient-occlusion-ground-attenuation": {
 		"property-type": "data-constant",
 		type: "number",
+		experimental: true,
 		"default": 0.69,
 		minimum: 0,
 		maximum: 1,
@@ -8593,6 +8855,7 @@ var v8 = {
 	"fill-extrusion-flood-light-color": {
 		"property-type": "data-constant",
 		type: "color",
+		experimental: true,
 		"default": "#ffffff",
 		doc: "The color of the flood light effect on the walls of the extruded buildings.",
 		requires: [
@@ -8617,6 +8880,7 @@ var v8 = {
 	"fill-extrusion-flood-light-intensity": {
 		"property-type": "data-constant",
 		type: "number",
+		experimental: true,
 		"default": 0,
 		minimum: 0,
 		maximum: 1,
@@ -8643,6 +8907,7 @@ var v8 = {
 	"fill-extrusion-flood-light-wall-radius": {
 		"property-type": "data-driven",
 		type: "number",
+		experimental: true,
 		units: "meters",
 		"default": 0,
 		minimum: 0,
@@ -8674,6 +8939,7 @@ var v8 = {
 	"fill-extrusion-flood-light-ground-radius": {
 		"property-type": "data-driven",
 		type: "number",
+		experimental: true,
 		units: "meters",
 		"default": 0,
 		doc: "The extent of the flood light effect on the ground beneath the extruded buildings in meters.",
@@ -8704,6 +8970,7 @@ var v8 = {
 	"fill-extrusion-flood-light-ground-attenuation": {
 		"property-type": "data-constant",
 		type: "number",
+		experimental: true,
 		"default": 0.69,
 		minimum: 0,
 		maximum: 1,
@@ -8729,6 +8996,7 @@ var v8 = {
 	"fill-extrusion-vertical-scale": {
 		"property-type": "data-constant",
 		type: "number",
+		experimental: true,
 		"default": 1,
 		minimum: 0,
 		doc: "A global multiplier that can be used to scale base, height, AO, and flood light of the fill extrusions.",
@@ -8751,6 +9019,7 @@ var v8 = {
 		"property-type": "data-constant",
 		type: "boolean",
 		"default": true,
+		experimental: true,
 		doc: "Indicates whether top edges should be rounded when fill-extrusion-edge-radius has a value greater than 0. If false, rounded edges are only applied to the sides. Default is true.",
 		requires: [
 			"fill-extrusion-edge-radius"
@@ -9044,42 +9313,20 @@ function stringify(passedObj, options = {}) {
     }(passedObj, '', 0);
 }
 
-//        
-function sortKeysBy(obj, reference) {
+function sortKeysBy(obj, reference2) {
     const result = {};
-    for (const key in reference) {
-        if (obj[key] !== undefined) {
+    for (const key in reference2) {
+        if (obj[key] !== void 0) {
             result[key] = obj[key];
         }
     }
     for (const key in obj) {
-        if (result[key] === undefined) {
+        if (result[key] === void 0) {
             result[key] = obj[key];
         }
     }
     return result;
 }
-/**
- * Format a Mapbox GL Style.  Returns a stringified style with its keys
- * sorted in the same order as the reference style.
- *
- * The optional `space` argument is passed to
- * [`JSON.stringify`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)
- * to generate formatted output.
- *
- * If `space` is unspecified, a default of `2` spaces will be used.
- *
- * @private
- * @param {Object} style a Mapbox GL Style
- * @param {number} [space] space argument to pass to `JSON.stringify`
- * @returns {string} stringified formatted JSON
- * @example
- * var fs = require('fs');
- * var format = require('mapbox-gl-style-spec').format;
- * var style = fs.readFileSync('./source.json', 'utf8');
- * fs.writeFileSync('./dest.json', format(style));
- * fs.writeFileSync('./dest.min.json', format(style, 0));
- */
 function format(style, space = 2) {
     style = sortKeysBy(style, v8.$root);
     if (style.layers) {
@@ -9088,7 +9335,6 @@ function format(style, space = 2) {
     return stringify(style, { indent: space });
 }
 
-//      
 function getPropertyReference(propertyName) {
     for (let i = 0; i < v8.layout.length; i++) {
         for (const key in v8[v8.layout[i]]) {
@@ -9116,7 +9362,7 @@ function eachLayer(style, callback) {
 }
 function eachProperty(style, options, callback) {
     function inner(layer, propertyType) {
-        if (layer.type === 'slot')
+        if (layer.type === 'slot' || layer.type === 'clip')
             return;
         const properties = layer[propertyType];
         if (!properties)
@@ -9147,7 +9393,6 @@ function eachProperty(style, options, callback) {
     });
 }
 
-//        
 function eachLayout(layer, callback) {
     for (const k in layer) {
         if (k.indexOf('layout') === 0) {
@@ -9178,9 +9423,8 @@ function renameProperty(obj, from, to) {
 }
 function migrateToV8 (style) {
     style.version = 8;
-    // Rename properties, reverse coordinates in source and layers
     eachSource(style, source => {
-        if (source.type === 'video' && source.url !== undefined) {
+        if (source.type === 'video' && source.url !== void 0) {
             renameProperty(source, 'url', 'urls');
         }
         if (source.type === 'video') {
@@ -9191,23 +9435,22 @@ function migrateToV8 (style) {
     });
     eachLayer(style, layer => {
         eachLayout(layer, layout => {
-            if (layout['symbol-min-distance'] !== undefined) {
+            if (layout['symbol-min-distance'] !== void 0) {
                 renameProperty(layout, 'symbol-min-distance', 'symbol-spacing');
             }
         });
         eachPaint(layer, paint => {
-            if (paint['background-image'] !== undefined) {
+            if (paint['background-image'] !== void 0) {
                 renameProperty(paint, 'background-image', 'background-pattern');
             }
-            if (paint['line-image'] !== undefined) {
+            if (paint['line-image'] !== void 0) {
                 renameProperty(paint, 'line-image', 'line-pattern');
             }
-            if (paint['fill-image'] !== undefined) {
+            if (paint['fill-image'] !== void 0) {
                 renameProperty(paint, 'fill-image', 'fill-pattern');
             }
         });
     });
-    // Inline Constants
     eachProperty(style, {
         paint: true,
         layout: true
@@ -9222,9 +9465,6 @@ function migrateToV8 (style) {
     });
     delete style.constants;
     eachLayer(style, layer => {
-        // get rid of text-max-size, icon-max-size
-        // turn text-size, icon-size into layout properties
-        // https://github.com/mapbox/mapbox-gl-style-spec/issues/255
         eachLayout(layer, layout => {
             delete layout['text-max-size'];
             delete layout['icon-max-size'];
@@ -9276,7 +9516,6 @@ function migrateToV8 (style) {
             });
         }
         if (Array.isArray(font)) {
-            // Assume it's a previously migrated font-array.
             return font;
         } else if (typeof font === 'string') {
             return splitAndTrim(font);
@@ -9296,18 +9535,6 @@ function migrateToV8 (style) {
             }
         });
     });
-    // Reverse order of symbol layers. This is an imperfect migration.
-    //
-    // The order of a symbol layer in the layers list affects two things:
-    // - how it is drawn relative to other layers (like oneway arrows below bridges)
-    // - the placement priority compared to other layers
-    //
-    // It's impossible to reverse the placement priority without breaking the draw order
-    // in some cases. This migration only reverses the order of symbol layers that
-    // are above all other types of layers.
-    //
-    // Symbol layers that are at the top of the map preserve their priority.
-    // Symbol layers that are below another type (line, fill) of layer preserve their draw order.
     let firstSymbolLayer = 0;
     for (let i = style.layers.length - 1; i >= 0; i--) {
         const layer = style.layers[i];
@@ -9322,7 +9549,6 @@ function migrateToV8 (style) {
     return style;
 }
 
-//      
 function extend (output, ...inputs) {
     for (const input of inputs) {
         for (const k in input) {
@@ -9332,7 +9558,6 @@ function extend (output, ...inputs) {
     return output;
 }
 
-//      
 let ParsingError$1 = class ParsingError extends Error {
     constructor(key, message) {
         super(message);
@@ -9341,11 +9566,6 @@ let ParsingError$1 = class ParsingError extends Error {
     }
 };
 
-//      
-/**
- * Tracks `let` bindings during expression parsing.
- * @private
- */
 class Scope {
     constructor(parent, bindings = []) {
         this.parent = parent;
@@ -9373,7 +9593,6 @@ class Scope {
     }
 }
 
-//      
 const NullType = { kind: 'null' };
 const NumberType = { kind: 'number' };
 const StringType = { kind: 'string' };
@@ -9411,14 +9630,8 @@ const valueMemberTypes = [
     array$1(ValueType),
     ResolvedImageType
 ];
-/**
- * Returns null if `t` is a subtype of `expected`; otherwise returns an
- * error message.
- * @private
- */
 function checkSubtype(expected, t) {
     if (t.kind === 'error') {
-        // Error is a subtype of every type
         return null;
     } else if (expected.kind === 'array') {
         if (t.kind === 'array' && (t.N === 0 && t.itemType.kind === 'value' || !checkSubtype(expected.itemType, t.itemType)) && (typeof expected.N !== 'number' || expected.N === t.N)) {
@@ -10502,18 +10715,25 @@ try {
 } catch (e) {
 }
 
-//      
-/**
- * An RGBA color value. Create instances from color strings using the static
- * method `Color.parse`. The constructor accepts RGB channel values in the range
- * `[0, 1]`, premultiplied by A.
- *
- * @param {number} r The red channel.
- * @param {number} g The green channel.
- * @param {number} b The blue channel.
- * @param {number} a The alpha channel.
- * @private
- */
+function number(a, b, t) {
+    return a * (1 - t) + b * t;
+}
+function color(from, to, t) {
+    return new Color(number(from.r, to.r, t), number(from.g, to.g, t), number(from.b, to.b, t), number(from.a, to.a, t));
+}
+function array(from, to, t) {
+    return from.map((d, i) => {
+        return number(d, to[i], t);
+    });
+}
+
+var interpolate$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  array: array,
+  color: color,
+  number: number
+});
+
 class Color {
     constructor(r, g, b, a = 1) {
         this.r = r;
@@ -10522,44 +10742,99 @@ class Color {
         this.a = a;
     }
     /**
-     * Parses valid CSS color strings and returns a `Color` instance.
-     * @returns A `Color` instance, or `undefined` if the input is not a valid color string.
-     */
+   * Parses valid CSS color strings and returns a `Color` instance.
+   * @returns A `Color` instance, or `undefined` if the input is not a valid color string.
+   */
     static parse(input) {
         if (!input) {
-            return undefined;
+            return void 0;
         }
         if (input instanceof Color) {
             return input;
         }
         if (typeof input !== 'string') {
-            return undefined;
+            return void 0;
         }
         const rgba = parseCSSColor_1(input);
         if (!rgba) {
-            return undefined;
+            return void 0;
         }
         return new Color(rgba[0] / 255 * rgba[3], rgba[1] / 255 * rgba[3], rgba[2] / 255 * rgba[3], rgba[3]);
     }
     /**
-     * Returns an RGBA string representing the color value.
-     *
-     * @returns An RGBA string.
-     * @example
-     * var purple = new Color.parse('purple');
-     * purple.toString; // = "rgba(128,0,128,1)"
-     * var translucentGreen = new Color.parse('rgba(26, 207, 26, .73)');
-     * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
-     */
+   * Returns an RGBA string representing the color value.
+   *
+   * @returns An RGBA string.
+   * @example
+   * var purple = new Color.parse('purple');
+   * purple.toString; // = "rgba(128,0,128,1)"
+   * var translucentGreen = new Color.parse('rgba(26, 207, 26, .73)');
+   * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
+   */
     toString() {
-        const [r, g, b, a] = this.toArray();
+        const [r, g, b, a] = this.a === 0 ? [
+            0,
+            0,
+            0,
+            0
+        ] : [
+            this.r * 255 / this.a,
+            this.g * 255 / this.a,
+            this.b * 255 / this.a,
+            this.a
+        ];
         return `rgba(${ Math.round(r) },${ Math.round(g) },${ Math.round(b) },${ a })`;
     }
+    toRenderColor(lut) {
+        const {r, g, b, a} = this;
+        return new RenderColor(lut, r, g, b, a);
+    }
+}
+class RenderColor {
+    constructor(lut, r, g, b, a) {
+        if (!lut) {
+            this.r = r;
+            this.g = g;
+            this.b = b;
+            this.a = a;
+        } else {
+            const N = lut.image.height;
+            const N2 = N * N;
+            r = a === 0 ? 0 : r / a * (N - 1);
+            g = a === 0 ? 0 : g / a * (N - 1);
+            b = a === 0 ? 0 : b / a * (N - 1);
+            const r0 = Math.floor(r);
+            const g0 = Math.floor(g);
+            const b0 = Math.floor(b);
+            const r1 = Math.ceil(r);
+            const g1 = Math.ceil(g);
+            const b1 = Math.ceil(b);
+            const rw = r - r0;
+            const gw = g - g0;
+            const bw = b - b0;
+            const data = lut.image.data;
+            const i0 = (r0 + g0 * N2 + b0 * N) * 4;
+            const i1 = (r0 + g0 * N2 + b1 * N) * 4;
+            const i2 = (r0 + g1 * N2 + b0 * N) * 4;
+            const i3 = (r0 + g1 * N2 + b1 * N) * 4;
+            const i4 = (r1 + g0 * N2 + b0 * N) * 4;
+            const i5 = (r1 + g0 * N2 + b1 * N) * 4;
+            const i6 = (r1 + g1 * N2 + b0 * N) * 4;
+            const i7 = (r1 + g1 * N2 + b1 * N) * 4;
+            if (i0 < 0 || i7 >= data.length) {
+                throw new Error('out of range');
+            }
+            this.r = number(number(number(data[i0], data[i1], bw), number(data[i2], data[i3], bw), gw), number(number(data[i4], data[i5], bw), number(data[i6], data[i7], bw), gw), rw) / 255 * a;
+            this.g = number(number(number(data[i0 + 1], data[i1 + 1], bw), number(data[i2 + 1], data[i3 + 1], bw), gw), number(number(data[i4 + 1], data[i5 + 1], bw), number(data[i6 + 1], data[i7 + 1], bw), gw), rw) / 255 * a;
+            this.b = number(number(number(data[i0 + 2], data[i1 + 2], bw), number(data[i2 + 2], data[i3 + 2], bw), gw), number(number(data[i4 + 2], data[i5 + 2], bw), number(data[i6 + 2], data[i7 + 2], bw), gw), rw) / 255 * a;
+            this.a = a;
+        }
+    }
     /**
-     * Returns an RGBA array of values representing the color, unpremultiplied by A.
-     *
-     * @returns An array of RGBA color values in the range [0, 255].
-     */
+   * Returns an RGBA array of values representing the color, unpremultiplied by A.
+   *
+   * @returns An array of RGBA color values in the range [0, 255].
+   */
     toArray() {
         const {r, g, b, a} = this;
         return a === 0 ? [
@@ -10575,10 +10850,10 @@ class Color {
         ];
     }
     /**
-     * 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].
-     */
+   * 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].
+   */
     toArray01() {
         const {r, g, b, a} = this;
         return a === 0 ? [
@@ -10594,11 +10869,11 @@ class Color {
         ];
     }
     /**
-     * Returns an RGB array of values representing the color, unpremultiplied by A and multiplied by a scalar.
-     *
-     * @param {number} scale A scale to apply to the unpremultiplied-alpha values.
-     * @returns An array of RGB color values in the range [0, 1].
-     */
+   * Returns an RGB array of values representing the color, unpremultiplied by A and multiplied by a scalar.
+   *
+   * @param {number} scale A scale to apply to the unpremultiplied-alpha values.
+   * @returns An array of RGB color values in the range [0, 1].
+   */
     toArray01Scaled(scale) {
         const {r, g, b, a} = this;
         return a === 0 ? [
@@ -10612,10 +10887,10 @@ class Color {
         ];
     }
     /**
-     * Returns an RGBA array of values representing the color, premultiplied by A.
-     *
-     * @returns An array of RGBA color values in the range [0, 1].
-     */
+   * Returns an RGBA array of values representing the color, premultiplied by A.
+   *
+   * @returns An array of RGBA color values in the range [0, 1].
+   */
     toArray01PremultipliedAlpha() {
         const {r, g, b, a} = this;
         return [
@@ -10626,11 +10901,11 @@ class Color {
         ];
     }
     /**
-     * Returns an RGBA array of values representing the color, unpremultiplied by A, and converted to linear color space.
-     * The color is defined by sRGB primaries, but the sRGB transfer function is reversed to obtain linear energy.
-     *
-     * @returns An array of RGBA color values in the range [0, 1].
-     */
+   * Returns an RGBA array of values representing the color, unpremultiplied by A, and converted to linear color space.
+   * The color is defined by sRGB primaries, but the sRGB transfer function is reversed to obtain linear energy.
+   *
+   * @returns An array of RGBA color values in the range [0, 1].
+   */
     toArray01Linear() {
         const {r, g, b, a} = this;
         return a === 0 ? [
@@ -10651,9 +10926,7 @@ Color.white = new Color(1, 1, 1, 1);
 Color.transparent = new Color(0, 0, 0, 0);
 Color.red = new Color(1, 0, 0, 1);
 Color.blue = new Color(0, 0, 1, 1);
-var Color$1 = Color;
 
-//      
 class Collator {
     constructor(caseSensitive, diacriticSensitive, locale) {
         if (caseSensitive)
@@ -10670,16 +10943,12 @@ class Collator {
         return this.collator.compare(lhs, rhs);
     }
     resolvedLocale() {
-        // We create a Collator without "usage: search" because we don't want
-        // the search options encoded in our result (e.g. "en-u-co-search")
         return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
     }
 }
 
-//      
 class FormattedSection {
     constructor(text, image, scale, fontStack, textColor) {
-        // combine characters so that diacritic marks are not separate code points
         this.text = text.normalize ? text.normalize() : text;
         this.image = image;
         this.scale = scale;
@@ -10733,7 +11002,7 @@ class Formatted {
                 options['font-scale'] = section.scale;
             }
             if (section.textColor) {
-                options['text-color'] = ['rgba'].concat(section.textColor.toArray());
+                options['text-color'] = ['rgba'].concat(section.textColor.toRenderColor(null).toArray());
             }
             serialized.push(options);
         }
@@ -10741,7 +11010,6 @@ class Formatted {
     }
 }
 
-//      
 class ResolvedImage {
     constructor(options) {
         this.namePrimary = options.namePrimary;
@@ -10759,7 +11027,6 @@ class ResolvedImage {
     static fromString(namePrimary, nameSecondary) {
         if (!namePrimary)
             return null;
-        // treat empty values as no image
         return new ResolvedImage({
             namePrimary,
             nameSecondary,
@@ -10851,7 +11118,7 @@ function isValue(mixed) {
         return true;
     } else if (typeof mixed === 'number') {
         return true;
-    } else if (mixed instanceof Color$1) {
+    } else if (mixed instanceof Color) {
         return true;
     } else if (mixed instanceof Collator) {
         return true;
@@ -10886,7 +11153,7 @@ function typeOf(value) {
         return BooleanType;
     } else if (typeof value === 'number') {
         return NumberType;
-    } else if (value instanceof Color$1) {
+    } else if (value instanceof Color) {
         return ColorType;
     } else if (value instanceof Collator) {
         return CollatorType;
@@ -10919,7 +11186,7 @@ function toString(value) {
         return '';
     } else if (type === 'string' || type === 'number' || type === 'boolean') {
         return String(value);
-    } else if (value instanceof Color$1 || value instanceof Formatted || value instanceof ResolvedImage) {
+    } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
         return value.toString();
     } else {
         return JSON.stringify(value);
@@ -10938,7 +11205,6 @@ class Literal {
             return context.error(`invalid value`);
         const value = args[1];
         let type = typeOf(value);
-        // special case: infer the item type if possible for zero-length arrays
         const expected = context.expectedType;
         if (type.kind === 'array' && type.N === 0 && expected && expected.kind === 'array' && (typeof expected.N !== 'number' || expected.N === 0)) {
             type = expected;
@@ -10959,13 +11225,9 @@ class Literal {
                 'literal',
                 this.value
             ];
-        } else if (this.value instanceof Color$1) {
-            // Constant-folding can generate Literal expressions that you
-            // couldn't actually generate with a "literal" expression,
-            // so we have to implement an equivalent serialization here
-            return ['rgba'].concat(this.value.toArray());
+        } else if (this.value instanceof Color) {
+            return ['rgba'].concat(this.value.toRenderColor(null).toArray());
         } else if (this.value instanceof Formatted) {
-            // Same as Color
             return this.value.serialize();
         } else {
             return this.value;
@@ -10973,7 +11235,6 @@ class Literal {
     }
 }
 
-//      
 class RuntimeError {
     constructor(message) {
         this.name = 'ExpressionEvaluationError';
@@ -11004,10 +11265,10 @@ class Assertion {
         if (name === 'array') {
             let itemType;
             if (args.length > 2) {
-                const type = args[1];
-                if (typeof type !== 'string' || !(type in types$1) || type === 'object')
+                const type2 = args[1];
+                if (typeof type2 !== 'string' || !(type2 in types$1) || type2 === 'object')
                     return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
-                itemType = types$1[type];
+                itemType = types$1[type2];
                 i++;
             } else {
                 itemType = ValueType;
@@ -11068,7 +11329,6 @@ class Assertion {
     }
 }
 
-//      
 class FormatExpression {
     constructor(sections) {
         this.type = FormattedType;
@@ -11153,8 +11413,6 @@ class FormatExpression {
         }
     }
     outputDefined() {
-        // Technically the combinatoric set of all children
-        // Usually, this.text will be undefined anyway
         return false;
     }
     serialize() {
@@ -11177,7 +11435,6 @@ class FormatExpression {
     }
 }
 
-//      
 class ImageExpression {
     constructor(inputPrimary, inputSecondary) {
         this.type = ResolvedImageType;
@@ -11200,10 +11457,9 @@ class ImageExpression {
         return new ImageExpression(namePrimary, nameSecondary);
     }
     evaluate(ctx) {
-        const value = ResolvedImage.fromString(this.inputPrimary.evaluate(ctx), this.inputSecondary ? this.inputSecondary.evaluate(ctx) : undefined);
+        const value = ResolvedImage.fromString(this.inputPrimary.evaluate(ctx), this.inputSecondary ? this.inputSecondary.evaluate(ctx) : void 0);
         if (value && ctx.availableImages) {
             value.available = ctx.availableImages.indexOf(value.namePrimary) > -1;
-            // If there's a secondary variant, only mark it available if both are present
             if (value.nameSecondary && value.available && ctx.availableImages) {
                 value.available = ctx.availableImages.indexOf(value.nameSecondary) > -1;
             }
@@ -11217,12 +11473,10 @@ class ImageExpression {
         }
     }
     outputDefined() {
-        // The output of image is determined by the list of available images in the evaluation context
         return false;
     }
     serialize() {
         if (this.inputSecondary) {
-            // $FlowIgnore
             return [
                 'image',
                 this.inputPrimary.serialize(),
@@ -11236,7 +11490,6 @@ class ImageExpression {
     }
 }
 
-//      
 function getType(val) {
     if (val instanceof Number) {
         return 'number';
@@ -11259,13 +11512,6 @@ const types = {
     'to-number': NumberType,
     'to-string': StringType
 };
-/**
- * Special form for error-coalescing coercion expressions "to-number",
- * "to-color".  Since these coercions can fail at runtime, they accept multiple
- * arguments, only evaluating one at a time until one succeeds.
- *
- * @private
- */
 class Coercion {
     constructor(type, args) {
         this.type = type;
@@ -11295,11 +11541,10 @@ class Coercion {
                 return null;
             }
             for (let i = 0; i < arrayLength; i++) {
-                // $FlowIgnore
                 const member = args[1][i];
                 let parsedMember;
                 if (getType(member) === 'array') {
-                    parsedMember = context.parse(member, undefined, type.itemType);
+                    parsedMember = context.parse(member, void 0, type.itemType);
                 } else {
                     const memberType = getType(member);
                     if (memberType !== type.itemType.kind) {
@@ -11307,7 +11552,7 @@ class Coercion {
                     }
                     parsedMember = context.registry['literal'].parse([
                         'literal',
-                        member === undefined ? null : member
+                        member === void 0 ? null : member
                     ], context);
                 }
                 if (!parsedMember)
@@ -11336,7 +11581,7 @@ class Coercion {
             for (const arg of this.args) {
                 input = arg.evaluate(ctx);
                 error = null;
-                if (input instanceof Color$1) {
+                if (input instanceof Color) {
                     return input;
                 } else if (typeof input === 'string') {
                     const c = ctx.parseColor(input);
@@ -11349,7 +11594,7 @@ class Coercion {
                         error = validateRGBA(input[0], input[1], input[2], input[3]);
                     }
                     if (!error) {
-                        return new Color$1(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
+                        return new Color(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
                     }
                 }
             }
@@ -11367,8 +11612,6 @@ class Coercion {
             }
             throw new RuntimeError(`Could not convert ${ JSON.stringify(value) } to number.`);
         } else if (this.type.kind === 'formatted') {
-            // There is no explicit 'to-formatted' but this coercion can be implicitly
-            // created by properties that expect the 'formatted' type.
             return Formatted.fromString(toString(this.args[0].evaluate(ctx)));
         } else if (this.type.kind === 'resolvedImage') {
             return ResolvedImage.fromString(toString(this.args[0].evaluate(ctx)));
@@ -11406,7 +11649,6 @@ class Coercion {
     }
 }
 
-//      
 const geometryTypes = [
     'Unknown',
     'Point',
@@ -11428,7 +11670,7 @@ class EvaluationContext {
         this.options = options;
     }
     id() {
-        return this.feature && this.feature.id !== undefined ? this.feature.id : null;
+        return this.feature && this.feature.id !== void 0 ? this.feature.id : null;
     }
     geometryType() {
         return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
@@ -11450,13 +11692,10 @@ class EvaluationContext {
             const c = this.featureDistanceData.center;
             const scale = this.featureDistanceData.scale;
             const {x, y} = this.featureTileCoord;
-            // Calculate the distance vector `d` (left handed)
             const dX = x * scale - c[0];
             const dY = y * scale - c[1];
-            // The bearing vector `b` (left handed)
             const bX = this.featureDistanceData.bearing[0];
             const bY = this.featureDistanceData.bearing[1];
-            // Distance is calculated as `dot(d, v)`
             const dist = bX * dX + bY * dY;
             return dist;
         }
@@ -11465,7 +11704,7 @@ class EvaluationContext {
     parseColor(input) {
         let cached = this._parseColorCache[input];
         if (!cached) {
-            cached = this._parseColorCache[input] = Color$1.parse(input);
+            cached = this._parseColorCache[input] = Color.parse(input);
         }
         return cached;
     }
@@ -11474,7 +11713,6 @@ class EvaluationContext {
     }
 }
 
-//      
 class CompoundExpression {
     constructor(name, type, evaluate, args, overloadIndex) {
         this.name = name;
@@ -11485,7 +11723,6 @@ class CompoundExpression {
     }
     evaluate(ctx) {
         if (!this._evaluate) {
-            // restore evaluate function after transfer between threads
             const definition = CompoundExpression.definitions[this.name];
             this._evaluate = Array.isArray(definition) ? definition[2] : definition.overloads[this._overloadIndex][1];
         }
@@ -11506,7 +11743,6 @@ class CompoundExpression {
         if (!definition) {
             return context.error(`Unknown expression "${ op }". If you wanted a literal array, use ["literal", [...]].`, 0);
         }
-        // Now check argument types against each signature
         const type = Array.isArray(definition) ? definition[0] : definition.type;
         const availableOverloads = Array.isArray(definition) ? [[
                 definition[1],
@@ -11518,19 +11754,15 @@ class CompoundExpression {
         for (const [params, evaluate] of availableOverloads) {
             if (Array.isArray(params) && params.length !== args.length - 1)
                 continue;
-            // param count doesn't match
             overloadParams.push(params);
             overloadIndex++;
-            // Use a fresh context for each attempted signature so that, if
-            // we eventually succeed, we haven't polluted `context.errors`.
-            signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, undefined, context._scope, context.options);
-            // First parse all the args, potentially coercing to the
-            // types expected by this overload.
+            signatureContext = new ParsingContext$1(context.registry, context.path, null, context.scope, void 0, context._scope, context.options);
             const parsedArgs = [];
             let argParseFailed = false;
             for (let i = 1; i < args.length; i++) {
                 const arg = args[i];
-                const expectedType = Array.isArray(params) ? params[i - 1] : params.type;
+                const expectedType = Array.isArray(params) ? params[i - 1] : // @ts-expect-error - TS2339 - Property 'type' does not exist on type 'Varargs | Evaluate'.
+                params.type;
                 const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
                 if (!parsed) {
                     argParseFailed = true;
@@ -11539,8 +11771,6 @@ class CompoundExpression {
                 parsedArgs.push(parsed);
             }
             if (argParseFailed) {
-                // Couldn't coerce args of this overload to expected type, move
-                // on to next one.
                 continue;
             }
             if (Array.isArray(params)) {
@@ -11564,8 +11794,6 @@ class CompoundExpression {
             const expected = overloadParams.length ? overloadParams : availableOverloads.map(([params]) => params);
             const signatures = expected.map(stringifySignature).join(' | ');
             const actualTypes = [];
-            // For error message, re-parse arguments without trying to
-            // apply any coercions
             for (let i = 1; i < args.length; i++) {
                 const parsed = context.parse(args[i], 1 + actualTypes.length);
                 if (!parsed)
@@ -11579,7 +11807,6 @@ class CompoundExpression {
     static register(registry, definitions) {
         CompoundExpression.definitions = definitions;
         for (const name in definitions) {
-            // $FlowFixMe[method-unbinding]
             registry[name] = CompoundExpression;
         }
     }
@@ -11592,7 +11819,6 @@ function stringifySignature(signature) {
     }
 }
 
-//      
 class CollatorExpression {
     constructor(caseSensitive, diacriticSensitive, locale) {
         this.type = CollatorType;
@@ -11606,10 +11832,10 @@ class CollatorExpression {
         const options = args[1];
         if (typeof options !== 'object' || Array.isArray(options))
             return context.error(`Collator options argument must be an object.`);
-        const caseSensitive = context.parse(options['case-sensitive'] === undefined ? false : options['case-sensitive'], 1, BooleanType);
+        const caseSensitive = context.parse(options['case-sensitive'] === void 0 ? false : options['case-sensitive'], 1, BooleanType);
         if (!caseSensitive)
             return null;
-        const diacriticSensitive = context.parse(options['diacritic-sensitive'] === undefined ? false : options['diacritic-sensitive'], 1, BooleanType);
+        const diacriticSensitive = context.parse(options['diacritic-sensitive'] === void 0 ? false : options['diacritic-sensitive'], 1, BooleanType);
         if (!diacriticSensitive)
             return null;
         let locale = null;
@@ -11631,10 +11857,6 @@ class CollatorExpression {
         }
     }
     outputDefined() {
-        // Technically the set of possible outputs is the combinatoric set of Collators produced
-        // by all possible outputs of locale/caseSensitive/diacriticSensitive
-        // But for the primary use of Collators in comparison operators, we ignore the Collator's
-        // possible outputs anyway, so we can get away with leaving this false for now.
         return false;
     }
     serialize() {
@@ -11651,13 +11873,6 @@ class CollatorExpression {
     }
 }
 
-//      
-// minX, minY, maxX, maxY
-/**
- * Returns the signed area for the polygon ring.  Postive areas are exterior rings and
- * have a clockwise winding.  Negative areas are interior rings and have a counter clockwise
- * ordering.
- */
 function calculateSignedArea(ring) {
     let sum = 0;
     for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
@@ -11667,7 +11882,6 @@ function calculateSignedArea(ring) {
     }
     return sum;
 }
-// classifies an array of rings into polygons with outer rings and holes
 function classifyRings(rings, maxRings) {
     const len = rings.length;
     if (len <= 1)
@@ -11679,7 +11893,7 @@ function classifyRings(rings, maxRings) {
         if (area === 0)
             continue;
         rings[i].area = Math.abs(area);
-        if (ccw === undefined)
+        if (ccw === void 0)
             ccw = area < 0;
         if (ccw === area < 0) {
             if (polygon)
@@ -11720,7 +11934,6 @@ function onBoundary(p, p1, p2) {
 function rayIntersect(p, p1, p2) {
     return p1[1] > p[1] !== p2[1] > p[1] && p[0] < (p2[0] - p1[0]) * (p[1] - p1[1]) / (p2[1] - p1[1]) + p1[0];
 }
-// ray casting algorithm for detecting if point is in polygon
 function pointWithinPolygon(point, rings, trueOnBoundary = false) {
     let inside = false;
     for (let i = 0, len = rings.length; i < len; i++) {
@@ -11739,9 +11952,7 @@ function pointWithinPolygon(point, rings, trueOnBoundary = false) {
 function perp(v1, v2) {
     return v1[0] * v2[1] - v1[1] * v2[0];
 }
-// check if p1 and p2 are in different sides of line segment q1->q2
 function twoSided(p1, p2, q1, q2) {
-    // q1->p1 (x1, y1), q1->p2 (x2, y2), q1->q2 (x3, y3)
     const x1 = p1[0] - q1[0];
     const y1 = p1[1] - q1[1];
     const x2 = p2[0] - q1[0];
@@ -11754,11 +11965,7 @@ function twoSided(p1, p2, q1, q2) {
         return true;
     return false;
 }
-// a, b are end points for line segment1, c and d are end points for line segment2
 function segmentIntersectSegment(a, b, c, d) {
-    // check if two segments are parallel or not
-    // precondition is end point a, b is inside polygon, if line a->b is
-    // parallel to polygon edge c->d, then a->b won't intersect with c->d
     const vectorP = [
         b[0] - a[0],
         b[1] - a[1]
@@ -11769,15 +11976,11 @@ function segmentIntersectSegment(a, b, c, d) {
     ];
     if (perp(vectorQ, vectorP) === 0)
         return false;
-    // If lines are intersecting with each other, the relative location should be:
-    // a and b lie in different sides of segment c->d
-    // c and d lie in different sides of segment a->b
     if (twoSided(a, b, c, d) && twoSided(c, d, a, b))
         return true;
     return false;
 }
 
-//      
 const EXTENT$1 = 8192;
 function mercatorXfromLng(lng) {
     return (180 + lng) / 360;
@@ -11803,7 +12006,6 @@ function pointWithinPolygons(point, polygons) {
 }
 function lineIntersectPolygon(p1, p2, polygon) {
     for (const ring of polygon) {
-        // loop through every edge of the ring
         for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
             const q1 = ring[k];
             const q2 = ring[j];
@@ -11815,13 +12017,11 @@ function lineIntersectPolygon(p1, p2, polygon) {
     return false;
 }
 function lineStringWithinPolygon(line, polygon) {
-    // First, check if geometry points of line segments are all inside polygon
     for (let i = 0; i < line.length; ++i) {
         if (!pointWithinPolygon(line[i], polygon)) {
             return false;
         }
     }
-    // Second, check if there is line segment intersecting polygon edge
     for (let i = 0; i < line.length - 1; ++i) {
         if (lineIntersectPolygon(line[i], line[i + 1], polygon)) {
             return false;
@@ -12054,7 +12254,6 @@ class Within {
     }
 }
 
-/*       */
 const factors = {
     kilometers: 1,
     miles: 1000 / 1609.344,
@@ -12074,13 +12273,6 @@ const E2 = FE * (2 - FE);
 const RAD = Math.PI / 180;
 /**
  * A collection of very fast approximations to common geodesic measurements. Useful for performance-sensitive code that measures things on a city scale.
- *
- * @param {number} lat latitude
- * @param {string} [units='kilometers']
- * @returns {CheapRuler}
- * @example
- * const ruler = cheapRuler(35.05, 'miles');
- * //=ruler
  */
 class CheapRuler {
     /**
@@ -12088,7 +12280,7 @@ class CheapRuler {
      *
      * @param {number} y
      * @param {number} z
-     * @param {string} [units='kilometers']
+     * @param {keyof typeof factors} [units='kilometers']
      * @returns {CheapRuler}
      * @example
      * const ruler = cheapRuler.fromTile(1567, 12);
@@ -12113,8 +12305,7 @@ class CheapRuler {
      * Creates a ruler instance for very fast approximations to common geodesic measurements around a certain latitude.
      *
      * @param {number} lat latitude
-     * @param {string} [units='kilometers']
-     * @returns {CheapRuler}
+     * @param {keyof typeof factors} [units='kilometers']
      * @example
      * const ruler = cheapRuler(35.05, 'miles');
      * //=ruler
@@ -12137,8 +12328,8 @@ class CheapRuler {
     /**
      * Given two points of the form [longitude, latitude], returns the distance.
      *
-     * @param {Array<number>} a point [longitude, latitude]
-     * @param {Array<number>} b point [longitude, latitude]
+     * @param {[number, number]} a point [longitude, latitude]
+     * @param {[number, number]} b point [longitude, latitude]
      * @returns {number} distance
      * @example
      * const distance = ruler.distance([30.5, 50.5], [30.51, 50.49]);
@@ -12152,8 +12343,8 @@ class CheapRuler {
     /**
      * Returns the bearing between two points in angles.
      *
-     * @param {Array<number>} a point [longitude, latitude]
-     * @param {Array<number>} b point [longitude, latitude]
+     * @param {[number, number]} a point [longitude, latitude]
+     * @param {[number, number]} b point [longitude, latitude]
      * @returns {number} bearing
      * @example
      * const bearing = ruler.bearing([30.5, 50.5], [30.51, 50.49]);
@@ -12167,10 +12358,10 @@ class CheapRuler {
     /**
      * Returns a new point given distance and bearing from the starting point.
      *
-     * @param {Array<number>} p point [longitude, latitude]
+     * @param {[number, number]} p point [longitude, latitude]
      * @param {number} dist distance
      * @param {number} bearing
-     * @returns {Array<number>} point [longitude, latitude]
+     * @returns {[number, number]} point [longitude, latitude]
      * @example
      * const point = ruler.destination([30.5, 50.5], 0.1, 90);
      * //=point
@@ -12182,10 +12373,10 @@ class CheapRuler {
     /**
      * Returns a new point given easting and northing offsets (in ruler units) from the starting point.
      *
-     * @param {Array<number>} p point [longitude, latitude]
+     * @param {[number, number]} p point [longitude, latitude]
      * @param {number} dx easting
      * @param {number} dy northing
-     * @returns {Array<number>} point [longitude, latitude]
+     * @returns {[number, number]} point [longitude, latitude]
      * @example
      * const point = ruler.offset([30.5, 50.5], 10, 10);
      * //=point
@@ -12199,7 +12390,7 @@ class CheapRuler {
     /**
      * Given a line (an array of points), returns the total line distance.
      *
-     * @param {Array<Array<number>>} points [longitude, latitude]
+     * @param {[number, number][]} points [longitude, latitude]
      * @returns {number} total line distance
      * @example
      * const length = ruler.lineDistance([
@@ -12218,7 +12409,7 @@ class CheapRuler {
     /**
      * Given a polygon (an array of rings, where each ring is an array of points), returns the area.
      *
-     * @param {Array<Array<Array<number>>>} polygon
+     * @param {[number, number][][]} polygon
      * @returns {number} area value in the specified units (square kilometers by default)
      * @example
      * const area = ruler.area([[
@@ -12240,9 +12431,9 @@ class CheapRuler {
     /**
      * Returns the point at a specified distance along the line.
      *
-     * @param {Array<Array<number>>} line
+     * @param {[number, number][]} line
      * @param {number} dist distance
-     * @returns {Array<number>} point [longitude, latitude]
+     * @returns {[number, number]} point [longitude, latitude]
      * @example
      * const point = ruler.along(line, 2.5);
      * //=point
@@ -12257,7 +12448,7 @@ class CheapRuler {
             const d = this.distance(p0, p1);
             sum += d;
             if (sum > dist)
-                return interpolate$1(p0, p1, (dist - (sum - d)) / d);
+                return interpolate(p0, p1, (dist - (sum - d)) / d);
         }
         return line[line.length - 1];
     }
@@ -12265,9 +12456,9 @@ class CheapRuler {
      * Returns the distance from a point `p` to a line segment `a` to `b`.
      *
      * @pointToSegmentDistance
-     * @param {Array<number>} p point [longitude, latitude]
-     * @param {Array<number>} p1 segment point 1 [longitude, latitude]
-     * @param {Array<number>} p2 segment point 2 [longitude, latitude]
+     * @param {[number, number]} p point [longitude, latitude]
+     * @param {[number, number]} a segment point 1 [longitude, latitude]
+     * @param {[number, number]} b segment point 2 [longitude, latitude]
      * @returns {number} distance
      * @example
      * const distance = ruler.pointToSegmentDistance([-67.04, 50.5], [-67.05, 50.57], [-67.03, 50.54]);
@@ -12277,9 +12468,8 @@ class CheapRuler {
         let [x, y] = a;
         let dx = wrap(b[0] - x) * this.kx;
         let dy = (b[1] - y) * this.ky;
-        let t = 0;
         if (dx !== 0 || dy !== 0) {
-            t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
+            const t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
             if (t > 1) {
                 x = b[0];
                 y = b[1];
@@ -12297,16 +12487,19 @@ class CheapRuler {
      * from the given point, index is the start index of the segment with the closest point,
      * and t is a parameter from 0 to 1 that indicates where the closest point is on that segment.
      *
-     * @param {Array<Array<number>>} line
-     * @param {Array<number>} p point [longitude, latitude]
-     * @returns {Object} {point, index, t}
+     * @param {[number, number][]} line
+     * @param {[number, number]} p point [longitude, latitude]
+     * @returns {{point: [number, number], index: number, t: number}} {point, index, t}
      * @example
      * const point = ruler.pointOnLine(line, [-67.04, 50.5]).point;
      * //=point
      */
     pointOnLine(line, p) {
         let minDist = Infinity;
-        let minX, minY, minI, minT;
+        let minX = line[0][0];
+        let minY = line[0][1];
+        let minI = 0;
+        let minT = 0;
         for (let i = 0; i < line.length - 1; i++) {
             let x = line[i][0];
             let y = line[i][1];
@@ -12346,10 +12539,10 @@ class CheapRuler {
     /**
      * Returns a part of the given line between the start and the stop points (or their closest points on the line).
      *
-     * @param {Array<number>} start point [longitude, latitude]
-     * @param {Array<number>} stop point [longitude, latitude]
-     * @param {Array<Array<number>>} line
-     * @returns {Array<Array<number>>} line part of a line
+     * @param {[number, number]} start point [longitude, latitude]
+     * @param {[number, number]} stop point [longitude, latitude]
+     * @param {[number, number][]} line
+     * @returns {[number, number][]} line part of a line
      * @example
      * const line2 = ruler.lineSlice([-67.04, 50.5], [-67.05, 50.56], line1);
      * //=line2
@@ -12377,10 +12570,10 @@ class CheapRuler {
     /**
      * Returns a part of the given line between the start and the stop points indicated by distance along the line.
      *
-     * @param {number} start distance
-     * @param {number} stop distance
-     * @param {Array<Array<number>>} line
-     * @returns {Array<Array<number>>} line part of a line
+     * @param {number} start start distance
+     * @param {number} stop stop distance
+     * @param {[number, number][]} line
+     * @returns {[number, number][]} part of a line
      * @example
      * const line2 = ruler.lineSliceAlong(10, 20, line1);
      * //=line2
@@ -12394,10 +12587,10 @@ class CheapRuler {
             const d = this.distance(p0, p1);
             sum += d;
             if (sum > start && slice.length === 0) {
-                slice.push(interpolate$1(p0, p1, (start - (sum - d)) / d));
+                slice.push(interpolate(p0, p1, (start - (sum - d)) / d));
             }
             if (sum >= stop) {
-                slice.push(interpolate$1(p0, p1, (stop - (sum - d)) / d));
+                slice.push(interpolate(p0, p1, (stop - (sum - d)) / d));
                 return slice;
             }
             if (sum > start)
@@ -12408,9 +12601,9 @@ class CheapRuler {
     /**
      * Given a point, returns a bounding box object ([w, s, e, n]) created from the given point buffered by a given distance.
      *
-     * @param {Array<number>} p point [longitude, latitude]
+     * @param {[number, number]} p point [longitude, latitude]
      * @param {number} buffer
-     * @returns {Array<number>} box object ([w, s, e, n])
+     * @returns {[number, number, number, number]} bbox ([w, s, e, n])
      * @example
      * const bbox = ruler.bufferPoint([30.5, 50.5], 0.01);
      * //=bbox
@@ -12428,9 +12621,9 @@ class CheapRuler {
     /**
      * Given a bounding box, returns the box buffered by a given distance.
      *
-     * @param {Array<number>} box object ([w, s, e, n])
+     * @param {[number, number, number, number]} bbox ([w, s, e, n])
      * @param {number} buffer
-     * @returns {Array<number>} box object ([w, s, e, n])
+     * @returns {[number, number, number, number]} bbox ([w, s, e, n])
      * @example
      * const bbox = ruler.bufferBBox([30.5, 50.5, 31, 51], 0.2);
      * //=bbox
@@ -12448,21 +12641,32 @@ class CheapRuler {
     /**
      * Returns true if the given point is inside in the given bounding box, otherwise false.
      *
-     * @param {Array<number>} p point [longitude, latitude]
-     * @param {Array<number>} box object ([w, s, e, n])
+     * @param {[number, number]} p point [longitude, latitude]
+     * @param {[number, number, number, number]} bbox ([w, s, e, n])
      * @returns {boolean}
      * @example
      * const inside = ruler.insideBBox([30.5, 50.5], [30, 50, 31, 51]);
      * //=inside
      */
     insideBBox(p, bbox) {
+        // eslint-disable-line
         return wrap(p[0] - bbox[0]) >= 0 && wrap(p[0] - bbox[2]) <= 0 && p[1] >= bbox[1] && p[1] <= bbox[3];
     }
 }
+/**
+ * @param {[number, number]} a
+ * @param {[number, number]} b
+ */
 function equals(a, b) {
     return a[0] === b[0] && a[1] === b[1];
 }
-function interpolate$1(a, b, t) {
+/**
+ * @param {[number, number]} a
+ * @param {[number, number]} b
+ * @param {number} t
+ * @returns {[number, number]}
+ */
+function interpolate(a, b, t) {
     const dx = wrap(b[0] - a[0]);
     const dy = b[1] - a[1];
     return [
@@ -12470,7 +12674,10 @@ function interpolate$1(a, b, t) {
         a[1] + dy * t
     ];
 }
-// normalize a degree value into [-180..180] range
+/**
+ * normalize a degree value into [-180..180] range
+ * @param {number} deg
+ */
 function wrap(deg) {
     while (deg < -180)
         deg += 360;
@@ -12835,26 +13042,8 @@ function defaultCompare(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
 
-//      
-/**
- * The maximum value of a coordinate in the internal tile coordinate system. Coordinates of
- * all source features normalized to this extent upon load.
- *
- * The value is a consequence of the following:
- *
- * * Vertex buffer store positions as signed 16 bit integers.
- * * One bit is lost for signedness to support tile buffers.
- * * One bit is lost because the line vertex buffer used to pack 1 bit of other data into the int.
- * * One bit is lost to support features extending past the extent on the right edge of the tile.
- * * This leaves us with 2^13 = 8192
- *
- * @private
- * @readonly
- */
 var EXTENT = 8192;
 
-//      
-// Inclusive index range for multipoint or linestring container
 function compareMax(a, b) {
     return b.dist - a.dist;
 }
@@ -12887,9 +13076,6 @@ function isRangeSafe(range, threshold) {
     }
     return ret;
 }
-// Split the point set(points or linestring) into two halves, using IndexRange to do in-place splitting.
-// If geometry is a line, the last point(here is the second index) of range1 needs to be included as the first point(here is the first index) of range2.
-// If geometry are points, just split the points equally(if possible) into two new point sets(here are two index ranges).
 function splitRange(range, isLine) {
     if (range[0] > range[1])
         return [
@@ -12967,28 +13153,21 @@ function getPolygonBBox(polygon) {
     }
     return bbox;
 }
-// Calculate the distance between two bounding boxes.
-// Calculate the delta in x and y direction, and use two fake points {0.0, 0.0} and {dx, dy} to calculate the distance.
-// Distance will be 0.0 if bounding box are overlapping.
 function bboxToBBoxDistance(bbox1, bbox2, ruler) {
     if (isDefaultBBOX(bbox1) || isDefaultBBOX(bbox2)) {
         return NaN;
     }
     let dx = 0;
     let dy = 0;
-    // bbox1 in left side
     if (bbox1[2] < bbox2[0]) {
         dx = bbox2[0] - bbox1[2];
     }
-    // bbox1 in right side
     if (bbox1[0] > bbox2[2]) {
         dx = bbox1[0] - bbox2[2];
     }
-    // bbox1 in above side
     if (bbox1[1] > bbox2[3]) {
         dy = bbox1[1] - bbox2[3];
     }
-    // bbox1 in down side
     if (bbox1[3] < bbox2[1]) {
         dy = bbox2[1] - bbox1[3];
     }
@@ -13036,10 +13215,13 @@ function pointsToLineDistance(points, rangeA, line, rangeB, ruler) {
     }
     return dist;
 }
-// precondition is two segments are not intersecting with each other
 function segmentToSegmentDistance(p1, p2, q1, q2, ruler) {
-    const dist1 = Math.min(ruler.pointToSegmentDistance(p1, q1, q2), ruler.pointToSegmentDistance(p2, q1, q2));
-    const dist2 = Math.min(ruler.pointToSegmentDistance(q1, p1, p2), ruler.pointToSegmentDistance(q2, p1, p2));
+    const dist1 = Math.min(// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
+    ruler.pointToSegmentDistance(p1, q1, q2), // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
+    ruler.pointToSegmentDistance(p2, q1, q2));
+    const dist2 = Math.min(// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
+    ruler.pointToSegmentDistance(q1, p1, p2), // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
+    ruler.pointToSegmentDistance(q2, p1, p2));
     return Math.min(dist1, dist2);
 }
 function lineToLineDistance(line1, range1, line2, range2, ruler) {
@@ -13147,7 +13329,6 @@ function updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, r1, r2) {
     if (r1 === null || r2 === null)
         return;
     const tempDist = bboxToBBoxDistance(getBBox(pointSet1, r1), getBBox(pointSet2, r2), ruler);
-    // Insert new pair to the queue if the bbox distance is less than miniDist, the pair with biggest distance will be at the top
     if (tempDist < miniDist)
         distQueue.push({
             dist: tempDist,
@@ -13155,8 +13336,6 @@ function updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, r1, r2) {
             range2: r2
         });
 }
-// Divide and conquer, the time complexity is O(n*lgn), faster than Brute force O(n*n)
-// Most of the time, use index for in-place processing.
 function pointSetToPolygonDistance(pointSets, isLine, polygon, ruler, currentMiniDist = Infinity) {
     let miniDist = Math.min(ruler.distance(pointSets[0], polygon[0][0]), currentMiniDist);
     if (miniDist === 0)
@@ -13180,7 +13359,6 @@ function pointSetToPolygonDistance(pointSets, isLine, polygon, ruler, currentMin
         if (distPair.dist >= miniDist)
             continue;
         const range = distPair.range1;
-        // In case the set size are relatively small, we could use brute-force directly
         if (getRangeSize(range) <= setThreshold) {
             if (!isRangeSafe(range, pointSets.length))
                 return NaN;
@@ -13249,7 +13427,6 @@ function pointSetsDistance(pointSet1, isLine1, pointSet2, isLine2, ruler, curren
             continue;
         const rangeA = distPair.range1;
         const rangeB = distPair.range2;
-        // In case the set size are relatively small, we could use brute-force directly
         if (getRangeSize(rangeA) <= set1Threshold && getRangeSize(rangeB) <= set2Threshold) {
             if (!isRangeSafe(rangeA, pointSet1.length) || !isRangeSafe(rangeB, pointSet2.length)) {
                 return NaN;
@@ -13288,7 +13465,7 @@ function pointSetToLinesDistance(pointSet, isLine, lines, ruler, currentMiniDist
                 line.length - 1
             ]), ruler) >= dist)
             continue;
-        dist = Math.min(dist, pointSetsDistance(pointSet, isLine, line, true    /*isLine*/, ruler, dist));
+        dist = Math.min(dist, pointSetsDistance(pointSet, isLine, line, true, ruler, dist));
         if (dist === 0)
             return dist;
     }
@@ -13333,13 +13510,13 @@ function pointsToGeometryDistance(originGeometry, canonical, geometry) {
     }
     const ruler = new CheapRuler(lngLatPoints[0][1], 'meters');
     if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
-        return pointSetsDistance(lngLatPoints, false    /*isLine*/, geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates, geometry.type === 'LineString'    /*isLine*/, ruler);
+        return pointSetsDistance(lngLatPoints, false, geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates, geometry.type === 'LineString', ruler);
     }
     if (geometry.type === 'MultiLineString') {
-        return pointSetToLinesDistance(lngLatPoints, false    /*isLine*/, geometry.coordinates, ruler);
+        return pointSetToLinesDistance(lngLatPoints, false, geometry.coordinates, ruler);
     }
     if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
-        return pointSetToPolygonsDistance(lngLatPoints, false    /*isLine*/, geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates, ruler);
+        return pointSetToPolygonsDistance(lngLatPoints, false, geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates, ruler);
     }
     return null;
 }
@@ -13354,12 +13531,12 @@ function linesToGeometryDistance(originGeometry, canonical, geometry) {
     }
     const ruler = new CheapRuler(lngLatLines[0][0][1], 'meters');
     if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
-        return pointSetToLinesDistance(geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates, geometry.type === 'LineString'    /*isLine*/, lngLatLines, ruler);
+        return pointSetToLinesDistance(geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates, geometry.type === 'LineString', lngLatLines, ruler);
     }
     if (geometry.type === 'MultiLineString') {
         let dist = Infinity;
         for (let i = 0; i < geometry.coordinates.length; i++) {
-            const tempDist = pointSetToLinesDistance(geometry.coordinates[i], true    /*isLine*/, lngLatLines, ruler, dist);
+            const tempDist = pointSetToLinesDistance(geometry.coordinates[i], true, lngLatLines, ruler, dist);
             if (isNaN(tempDist))
                 return tempDist;
             if ((dist = Math.min(dist, tempDist)) === 0)
@@ -13370,7 +13547,7 @@ function linesToGeometryDistance(originGeometry, canonical, geometry) {
     if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
         let dist = Infinity;
         for (let i = 0; i < lngLatLines.length; i++) {
-            const tempDist = pointSetToPolygonsDistance(lngLatLines[i], true    /*isLine*/, geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates, ruler, dist);
+            const tempDist = pointSetToPolygonsDistance(lngLatLines[i], true, geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates, ruler, dist);
             if (isNaN(tempDist))
                 return tempDist;
             if ((dist = Math.min(dist, tempDist)) === 0)
@@ -13391,12 +13568,12 @@ function polygonsToGeometryDistance(originGeometry, canonical, geometry) {
     }
     const ruler = new CheapRuler(lngLatPolygons[0][0][0][1], 'meters');
     if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
-        return pointSetToPolygonsDistance(geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates, geometry.type === 'LineString'    /*isLine*/, lngLatPolygons, ruler);
+        return pointSetToPolygonsDistance(geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates, geometry.type === 'LineString', lngLatPolygons, ruler);
     }
     if (geometry.type === 'MultiLineString') {
         let dist = Infinity;
         for (let i = 0; i < geometry.coordinates.length; i++) {
-            const tempDist = pointSetToPolygonsDistance(geometry.coordinates[i], true    /*isLine*/, lngLatPolygons, ruler, dist);
+            const tempDist = pointSetToPolygonsDistance(geometry.coordinates[i], true, lngLatPolygons, ruler, dist);
             if (isNaN(tempDist))
                 return tempDist;
             if ((dist = Math.min(dist, tempDist)) === 0)
@@ -13472,7 +13649,6 @@ class Distance {
     }
 }
 
-//      
 function coerceValue(type, value) {
     switch (type) {
     case 'string':
@@ -13482,7 +13658,7 @@ function coerceValue(type, value) {
     case 'boolean':
         return !!value;
     case 'color':
-        return Color$1.parse(value);
+        return Color.parse(value);
     case 'formatted': {
             return Formatted.fromString(toString(value));
         }
@@ -13493,13 +13669,13 @@ function coerceValue(type, value) {
     return value;
 }
 function clampToAllowedNumber(value, min, max, step) {
-    if (step !== undefined) {
+    if (step !== void 0) {
         value = step * Math.round(value / step);
     }
-    if (min !== undefined && value < min) {
+    if (min !== void 0 && value < min) {
         value = min;
     }
-    if (max !== undefined && value > max) {
+    if (max !== void 0 && value > max) {
         value = max;
     }
     return value;
@@ -13512,7 +13688,7 @@ class Config {
     }
     static parse(args, context) {
         let type = context.expectedType;
-        if (type === null || type === undefined) {
+        if (type === null || type === void 0) {
             type = ValueType;
         }
         if (args.length < 2 || args.length > 3) {
@@ -13545,7 +13721,6 @@ class Config {
         const defaultValue = config.default.evaluate(ctx);
         let result = defaultValue;
         if (value) {
-            // temporarily override scope to parent to evaluate config expressions passed from the parent
             const originalScope = ctx.scope;
             ctx.scope = (originalScope || '').split(FQIDSeparator).slice(1).join(FQIDSeparator);
             result = value.evaluate(ctx);
@@ -13554,21 +13729,20 @@ class Config {
         if (type) {
             result = coerceValue(type, result);
         }
-        if (result !== undefined && (minValue !== undefined || maxValue !== undefined || stepValue !== undefined)) {
+        if (result !== void 0 && (minValue !== void 0 || maxValue !== void 0 || stepValue !== void 0)) {
             if (typeof result === 'number') {
                 result = clampToAllowedNumber(result, minValue, maxValue, stepValue);
             } else if (Array.isArray(result)) {
                 result = result.map(item => typeof item === 'number' ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item);
             }
         }
-        if (value !== undefined && result !== undefined && values && !values.includes(result)) {
-            // The result is not among the allowed values. Instead, use the default value from the option.
+        if (value !== void 0 && result !== void 0 && values && !values.includes(result)) {
             result = defaultValue;
             if (type) {
                 result = coerceValue(type, result);
             }
         }
-        if (type && type !== this.type || result !== undefined && typeOf(result) !== this.type) {
+        if (type && type !== this.type || result !== void 0 && typeOf(result) !== this.type) {
             result = coerceValue(this.type.kind, result);
         }
         return result;
@@ -13590,7 +13764,6 @@ class Config {
     }
 }
 
-//      
 function isFeatureConstant(e) {
     if (e instanceof CompoundExpression) {
         if (e.name === 'get' && e.args.length === 1) {
@@ -13658,7 +13831,6 @@ function isGlobalPropertyConstant(e, properties) {
     return result;
 }
 
-//      
 class Var {
     constructor(name, boundExpression) {
         this.type = boundExpression.type;
@@ -13690,16 +13862,7 @@ class Var {
     }
 }
 
-//      
-/**
- * State associated parsing at a given point in an expression tree.
- * @private
- */
 class ParsingContext {
-    // The expected type of this expression. Provided only to allow Expression
-    // implementations to infer argument types: Expression#parse() need not
-    // check that the output type of the parsed expression matches
-    // `expectedType`.
     constructor(registry, path = [], expectedType, scope = new Scope(), errors = [], _scope, options) {
         this.registry = registry;
         this.path = path;
@@ -13711,12 +13874,12 @@ class ParsingContext {
         this.options = options;
     }
     /**
-     * @param expr the JSON expression to parse
-     * @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
-     * @param options
-     * @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
-     * @private
-     */
+   * @param expr the JSON expression to parse
+   * @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
+   * @param options
+   * @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
+   * @private
+   */
     parse(expr, index, expectedType, bindings, options = {}) {
         if (index || expectedType) {
             return this.concat(index, expectedType, bindings)._parse(expr, options);
@@ -13743,7 +13906,7 @@ class ParsingContext {
             if (expr.length === 0) {
                 return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
             }
-            const Expr = typeof expr[0] === 'string' ? this.registry[expr[0]] : undefined;
+            const Expr = typeof expr[0] === 'string' ? this.registry[expr[0]] : void 0;
             if (Expr) {
                 let parsed = Expr.parse(expr, this);
                 if (!parsed)
@@ -13751,14 +13914,6 @@ class ParsingContext {
                 if (this.expectedType) {
                     const expected = this.expectedType;
                     const actual = parsed.type;
-                    // When we expect a number, string, boolean, or array but have a value, wrap it in an assertion.
-                    // When we expect a color or formatted string, but have a string or value, wrap it in a coercion.
-                    // Otherwise, we do static type-checking.
-                    //
-                    // These behaviors are overridable for:
-                    //   * The "coalesce" operator, which needs to omit type annotations.
-                    //   * String-valued properties (e.g. `text-field`), where coercion is more convenient than assertion.
-                    //
                     if ((expected.kind === 'string' || expected.kind === 'number' || expected.kind === 'boolean' || expected.kind === 'object' || expected.kind === 'array') && actual.kind === 'value') {
                         parsed = annotate(parsed, expected, options.typeAnnotation || 'assert');
                     } else if ((expected.kind === 'color' || expected.kind === 'formatted' || expected.kind === 'resolvedImage') && (actual.kind === 'value' || actual.kind === 'string')) {
@@ -13767,10 +13922,6 @@ class ParsingContext {
                         return null;
                     }
                 }
-                // If an expression's arguments are all literals, we can evaluate
-                // it immediately and replace it with a literal value in the
-                // parsed/compiled result. Expressions that expect an image should
-                // not be resolved here so we can later get the available images.
                 if (!(parsed instanceof Literal) && parsed.type.kind !== 'resolvedImage' && isConstant(parsed)) {
                     const ec = new EvaluationContext(this._scope, this.options);
                     try {
@@ -13782,7 +13933,6 @@ class ParsingContext {
                 }
                 return parsed;
             }
-            // Try to parse as array
             return Coercion.parse([
                 'to-array',
                 expr
@@ -13796,33 +13946,33 @@ class ParsingContext {
         }
     }
     /**
-     * Returns a copy of this context suitable for parsing the subexpression at
-     * index `index`, optionally appending to 'let' binding map.
-     *
-     * Note that `errors` property, intended for collecting errors while
-     * parsing, is copied by reference rather than cloned.
-     * @private
-     */
+   * Returns a copy of this context suitable for parsing the subexpression at
+   * index `index`, optionally appending to 'let' binding map.
+   *
+   * Note that `errors` property, intended for collecting errors while
+   * parsing, is copied by reference rather than cloned.
+   * @private
+   */
     concat(index, expectedType, bindings) {
         const path = typeof index === 'number' ? this.path.concat(index) : this.path;
         const scope = bindings ? this.scope.concat(bindings) : this.scope;
         return new ParsingContext(this.registry, path, expectedType || null, scope, this.errors, this._scope, this.options);
     }
     /**
-     * Push a parsing (or type checking) error into the `this.errors`
-     * @param error The message
-     * @param keys Optionally specify the source of the error at a child
-     * of the current expression at `this.key`.
-     * @private
-     */
+   * Push a parsing (or type checking) error into the `this.errors`
+   * @param error The message
+   * @param keys Optionally specify the source of the error at a child
+   * of the current expression at `this.key`.
+   * @private
+   */
     error(error, ...keys) {
         const key = `${ this.key }${ keys.map(k => `[${ k }]`).join('') }`;
         this.errors.push(new ParsingError$1(key, error));
     }
     /**
-     * Returns null if `t` is a subtype of `expected`; otherwise returns an
-     * error message and also pushes it to `this.errors`.
-     */
+   * Returns null if `t` is a subtype of `expected`; otherwise returns an
+   * error message and also pushes it to `this.errors`.
+   */
     checkSubtype(expected, t) {
         const error = checkSubtype(expected, t);
         if (error)
@@ -13830,15 +13980,13 @@ class ParsingContext {
         return error;
     }
 }
+var ParsingContext$1 = ParsingContext;
 function isConstant(expression) {
     if (expression instanceof Var) {
         return isConstant(expression.boundExpression);
     } else if (expression instanceof CompoundExpression && expression.name === 'error') {
         return false;
     } else if (expression instanceof CollatorExpression) {
-        // Although the results of a Collator expression with fixed arguments
-        // generally shouldn't change between executions, we can't serialize them
-        // as constant expressions because results change based on environment.
         return false;
     } else if (expression instanceof Within) {
         return false;
@@ -13850,12 +13998,6 @@ function isConstant(expression) {
     const isTypeAnnotation = expression instanceof Coercion || expression instanceof Assertion;
     let childrenConstant = true;
     expression.eachChild(child => {
-        // We can _almost_ assume that if `expressions` children are constant,
-        // they would already have been evaluated to Literal values when they
-        // were parsed.  Type annotations are the exception, because they might
-        // have been inferred and added after a child was parsed.
-        // So we recurse into isConstant() for the children of type annotations,
-        // but otherwise simply check whether they are Literals.
         if (isTypeAnnotation) {
             childrenConstant = childrenConstant && isConstant(child);
         } else {
@@ -13880,11 +14022,6 @@ function isConstant(expression) {
     ]);
 }
 
-//      
-/**
- * Returns the index of the last stop <= input, or 0 if it doesn't exist.
- * @private
- */
 function findStopLessThanOrEqualTo(stops, input) {
     const lastIndex = stops.length - 1;
     let lowerIndex = 0;
@@ -13897,7 +14034,6 @@ function findStopLessThanOrEqualTo(stops, input) {
         nextValue = stops[currentIndex + 1];
         if (currentValue <= input) {
             if (currentIndex === lastIndex || input < nextValue) {
-                // Search complete
                 return currentIndex;
             }
             lowerIndex = currentIndex + 1;
@@ -13910,7 +14046,6 @@ function findStopLessThanOrEqualTo(stops, input) {
     return 0;
 }
 
-//      
 class Step {
     constructor(type, input, stops) {
         this.type = type;
@@ -14067,32 +14202,7 @@ UnitBezier.prototype = {
 
 var UnitBezier$1 = /*@__PURE__*/getDefaultExportFromCjs(unitbezier);
 
-//      
-function number(a, b, t) {
-    return a * (1 - t) + b * t;
-}
-function color(from, to, t) {
-    return new Color$1(number(from.r, to.r, t), number(from.g, to.g, t), number(from.b, to.b, t), number(from.a, to.a, t));
-}
-function array(from, to, t) {
-    return from.map((d, i) => {
-        return number(d, to[i], t);
-    });
-}
-
-var interpolate = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  array: array,
-  color: color,
-  number: number
-});
-
-//      
-// Constants
-const Xn = 0.95047,
-    // D65 standard referent
-    Yn = 1, Zn = 1.08883, t0 = 4 / 29, t1 = 6 / 29, t2 = 3 * t1 * t1, t3 = t1 * t1 * t1, deg2rad = Math.PI / 180, rad2deg = 180 / Math.PI;
-// Utilities
+const Xn = 0.95047, Yn = 1, Zn = 1.08883, t0 = 4 / 29, t1 = 6 / 29, t2 = 3 * t1 * t1, t3 = t1 * t1 * t1, deg2rad = Math.PI / 180, rad2deg = 180 / Math.PI;
 function xyz2lab(t) {
     return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
 }
@@ -14106,7 +14216,6 @@ function rgb2xyz(x) {
     x /= 255;
     return x <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
 }
-// LAB
 function rgbToLab(rgbColor) {
     const b = rgb2xyz(rgbColor.r), a = rgb2xyz(rgbColor.g), l = rgb2xyz(rgbColor.b), x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn), y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.072175 * l) / Yn), z = xyz2lab((0.0193339 * b + 0.119192 * a + 0.9503041 * l) / Zn);
     return {
@@ -14121,7 +14230,7 @@ function labToRgb(labColor) {
     y = Yn * lab2xyz(y);
     x = Xn * lab2xyz(x);
     z = Zn * lab2xyz(z);
-    return new Color$1(xyz2rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB
+    return new Color(xyz2rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB
     xyz2rgb(-0.969266 * x + 1.8760108 * y + 0.041556 * z), xyz2rgb(0.0556434 * x - 0.2040259 * y + 1.0572252 * z), labColor.alpha);
 }
 function interpolateLab(from, to, t) {
@@ -14132,7 +14241,6 @@ function interpolateLab(from, to, t) {
         alpha: number(from.alpha, to.alpha, t)
     };
 }
-// HCL
 function rgbToHcl(rgbColor) {
     const {l, a, b} = rgbToLab(rgbColor);
     const h = Math.atan2(b, a) * rad2deg;
@@ -14181,7 +14289,6 @@ var colorSpaces = /*#__PURE__*/Object.freeze({
   lab: lab
 });
 
-//      
 class Interpolate {
     constructor(type, operator, interpolation, input, stops) {
         this.type = type;
@@ -14230,7 +14337,7 @@ class Interpolate {
             }
             interpolation = {
                 name: 'cubic-bezier',
-                controlPoints: controlPoints
+                controlPoints
             };
         } else {
             return context.error(`Unknown interpolation type ${ String(interpolation[0]) }`, 1, 0);
@@ -14297,7 +14404,7 @@ class Interpolate {
         const outputLower = outputs[index].evaluate(ctx);
         const outputUpper = outputs[index + 1].evaluate(ctx);
         if (this.operator === 'interpolate') {
-            return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t);    // eslint-disable-line import/namespace
+            return interpolate$1[this.type.kind.toLowerCase()](outputLower, outputUpper, t);
         } else if (this.operator === 'interpolate-hcl') {
             return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
         } else {
@@ -14340,41 +14447,6 @@ class Interpolate {
         return serialized;
     }
 }
-/**
- * Returns a ratio that can be used to interpolate between exponential function
- * stops.
- * How it works: Two consecutive stop values define a (scaled and shifted) exponential function `f(x) = a * base^x + b`, where `base` is the user-specified base,
- * and `a` and `b` are constants affording sufficient degrees of freedom to fit
- * the function to the given stops.
- *
- * Here's a bit of algebra that lets us compute `f(x)` directly from the stop
- * values without explicitly solving for `a` and `b`:
- *
- * First stop value: `f(x0) = y0 = a * base^x0 + b`
- * Second stop value: `f(x1) = y1 = a * base^x1 + b`
- * => `y1 - y0 = a(base^x1 - base^x0)`
- * => `a = (y1 - y0)/(base^x1 - base^x0)`
- *
- * Desired value: `f(x) = y = a * base^x + b`
- * => `f(x) = y0 + a * (base^x - base^x0)`
- *
- * From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
- * little algebra:
- * ```
- * a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
- *                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
- * ```
- *
- * If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
- * `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
- * an interpolation factor between the two stops' output values.
- *
- * (Note: a slightly different form for `ratio`,
- * `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
- * expensive `Math.pow()` operations.)
- *
- * @private
-*/
 function exponentialInterpolation(input, base, lowerValue, upperValue) {
     const difference = upperValue - lowerValue;
     const progress = input - lowerValue;
@@ -14403,17 +14475,12 @@ class Coalesce {
         }
         const parsedArgs = [];
         for (const arg of args.slice(1)) {
-            const parsed = context.parse(arg, 1 + parsedArgs.length, outputType, undefined, { typeAnnotation: 'omit' });
+            const parsed = context.parse(arg, 1 + parsedArgs.length, outputType, void 0, { typeAnnotation: 'omit' });
             if (!parsed)
                 return null;
             outputType = outputType || parsed.type;
             parsedArgs.push(parsed);
         }
-        // Above, we parse arguments without inferred type annotation so that
-        // they don't produce a runtime error for `null` input, which would
-        // preempt the desired null-coalescing behavior.
-        // Thus, if any of our arguments would have needed an annotation, we
-        // need to wrap the enclosing coalesce expression with it instead.
         const needsAnnotation = expectedType && parsedArgs.some(arg => checkSubtype(expectedType, arg.type));
         return needsAnnotation ? new Coalesce(ValueType, parsedArgs) : new Coalesce(outputType, parsedArgs);
     }
@@ -14424,15 +14491,11 @@ class Coalesce {
         for (const arg of this.args) {
             argCount++;
             result = arg.evaluate(ctx);
-            // we need to keep track of the first requested image in a coalesce statement
-            // if coalesce can't find a valid image, we return the first image so styleimagemissing can fire
             if (result && result instanceof ResolvedImage && !result.available) {
-                // set to first image
                 if (!firstImage) {
                     firstImage = result;
                 }
                 result = null;
-                // if we reach the end, return the first image
                 if (argCount === this.args.length) {
                     return firstImage;
                 }
@@ -14457,7 +14520,6 @@ class Coalesce {
     }
 }
 
-//      
 class Let {
     constructor(bindings, result) {
         this.type = result.type;
@@ -14511,7 +14573,6 @@ class Let {
     }
 }
 
-//      
 class At {
     constructor(type, index, input) {
         this.type = type;
@@ -14530,17 +14591,17 @@ class At {
     }
     evaluate(ctx) {
         const index = this.index.evaluate(ctx);
-        const array = this.input.evaluate(ctx);
+        const array2 = this.input.evaluate(ctx);
         if (index < 0) {
             throw new RuntimeError(`Array index out of bounds: ${ index } < 0.`);
         }
-        if (index >= array.length) {
-            throw new RuntimeError(`Array index out of bounds: ${ index } > ${ array.length - 1 }.`);
+        if (index >= array2.length) {
+            throw new RuntimeError(`Array index out of bounds: ${ index } > ${ array2.length - 1 }.`);
         }
         if (index !== Math.floor(index)) {
             throw new RuntimeError(`Array index must be an integer, but found ${ index } instead.`);
         }
-        return array[index];
+        return array2[index];
     }
     eachChild(fn) {
         fn(this.index);
@@ -14558,7 +14619,6 @@ class At {
     }
 }
 
-//      
 class In {
     constructor(needle, haystack) {
         this.type = BooleanType;
@@ -14621,7 +14681,6 @@ class In {
     }
 }
 
-//      
 class IndexOf {
     constructor(needle, haystack, fromIndex) {
         this.type = NumberType;
@@ -14689,7 +14748,7 @@ class IndexOf {
         return false;
     }
     serialize() {
-        if (this.fromIndex != null && this.fromIndex !== undefined) {
+        if (this.fromIndex != null && this.fromIndex !== void 0) {
             const fromIndex = this.fromIndex.serialize();
             return [
                 'index-of',
@@ -14706,7 +14765,6 @@ class IndexOf {
     }
 }
 
-// Map input label values to output expression index
 class Match {
     constructor(inputType, outputType, input, cases, outputs, otherwise) {
         this.inputType = inputType;
@@ -14790,35 +14848,26 @@ class Match {
             'match',
             this.input.serialize()
         ];
-        // Sort so serialization has an arbitrary defined order, even though
-        // branch order doesn't affect evaluation
         const sortedLabels = Object.keys(this.cases).sort();
-        // Group branches by unique match expression to support condensed
-        // serializations of the form [case1, case2, ...] -> matchExpression
         const groupedByOutput = [];
         const outputLookup = {};
-        // lookup index into groupedByOutput for a given output expression
         for (const label of sortedLabels) {
             const outputIndex = outputLookup[this.cases[label]];
-            if (outputIndex === undefined) {
-                // First time seeing this output, add it to the end of the grouped list
+            if (outputIndex === void 0) {
                 outputLookup[this.cases[label]] = groupedByOutput.length;
                 groupedByOutput.push([
                     this.cases[label],
                     [label]
                 ]);
             } else {
-                // We've seen this expression before, add the label to that output's group
                 groupedByOutput[outputIndex][1].push(label);
             }
         }
         const coerceLabel = label => this.inputType.kind === 'number' ? Number(label) : label;
         for (const [outputIndex, labels] of groupedByOutput) {
             if (labels.length === 1) {
-                // Only a single label matches this output expression
                 serialized.push(coerceLabel(labels[0]));
             } else {
-                // Array of literal labels pointing to this output expression
                 serialized.push(labels.map(coerceLabel));
             }
             serialized.push(this.outputs[outputIndex].serialize());
@@ -14889,7 +14938,6 @@ class Case {
     }
 }
 
-//      
 class Slice {
     constructor(type, input, beginIndex, endIndex) {
         this.type = type;
@@ -14947,7 +14995,7 @@ class Slice {
         return false;
     }
     serialize() {
-        if (this.endIndex != null && this.endIndex !== undefined) {
+        if (this.endIndex != null && this.endIndex !== void 0) {
             const endIndex = this.endIndex.serialize();
             return [
                 'slice',
@@ -14964,13 +15012,10 @@ class Slice {
     }
 }
 
-//      
 function isComparableType(op, type) {
     if (op === '==' || op === '!=') {
-        // equality operator
         return type.kind === 'boolean' || type.kind === 'string' || type.kind === 'number' || type.kind === 'null' || type.kind === 'value';
     } else {
-        // ordering operator
         return type.kind === 'string' || type.kind === 'number' || type.kind === 'value';
     }
 }
@@ -15010,26 +15055,8 @@ function lteqCollate(ctx, a, b, c) {
 function gteqCollate(ctx, a, b, c) {
     return c.compare(a, b) >= 0;
 }
-/**
- * Special form for comparison operators, implementing the signatures:
- * - (T, T, ?Collator) => boolean
- * - (T, value, ?Collator) => boolean
- * - (value, T, ?Collator) => boolean
- *
- * For inequalities, T must be either value, string, or number. For ==/!=, it
- * can also be boolean or null.
- *
- * Equality semantics are equivalent to Javascript's strict equality (===/!==)
- * -- i.e., when the arguments' types don't match, == evaluates to false, != to
- * true.
- *
- * When types don't match in an ordering comparison, a runtime error is thrown.
- *
- * @private
- */
 function makeComparison(op, compareBasic, compareWithCollator) {
     const isOrderComparison = op !== '==' && op !== '!=';
-    // $FlowFixMe[method-unbinding]
     return class Comparison {
         constructor(lhs, rhs, collator) {
             this.type = BooleanType;
@@ -15038,33 +15065,29 @@ function makeComparison(op, compareBasic, compareWithCollator) {
             this.collator = collator;
             this.hasUntypedArgument = lhs.type.kind === 'value' || rhs.type.kind === 'value';
         }
-        // $FlowFixMe[method-unbinding]
         static parse(args, context) {
             if (args.length !== 3 && args.length !== 4)
                 return context.error(`Expected two or three arguments.`);
-            const op = args[0];
+            const op2 = args[0];
             let lhs = context.parse(args[1], 1, ValueType);
             if (!lhs)
                 return null;
-            if (!isComparableType(op, lhs.type)) {
-                return context.concat(1).error(`"${ op }" comparisons are not supported for type '${ toString$1(lhs.type) }'.`);
+            if (!isComparableType(op2, lhs.type)) {
+                return context.concat(1).error(`"${ op2 }" comparisons are not supported for type '${ toString$1(lhs.type) }'.`);
             }
             let rhs = context.parse(args[2], 2, ValueType);
             if (!rhs)
                 return null;
-            if (!isComparableType(op, rhs.type)) {
-                return context.concat(2).error(`"${ op }" comparisons are not supported for type '${ toString$1(rhs.type) }'.`);
+            if (!isComparableType(op2, rhs.type)) {
+                return context.concat(2).error(`"${ op2 }" comparisons are not supported for type '${ toString$1(rhs.type) }'.`);
             }
             if (lhs.type.kind !== rhs.type.kind && lhs.type.kind !== 'value' && rhs.type.kind !== 'value') {
                 return context.error(`Cannot compare types '${ toString$1(lhs.type) }' and '${ toString$1(rhs.type) }'.`);
             }
             if (isOrderComparison) {
-                // typing rules specific to less/greater than operators
                 if (lhs.type.kind === 'value' && rhs.type.kind !== 'value') {
-                    // (value, T)
                     lhs = new Assertion(rhs.type, [lhs]);
                 } else if (lhs.type.kind !== 'value' && rhs.type.kind === 'value') {
-                    // (T, value)
                     rhs = new Assertion(lhs.type, [rhs]);
                 }
             }
@@ -15083,17 +15106,16 @@ function makeComparison(op, compareBasic, compareWithCollator) {
             const lhs = this.lhs.evaluate(ctx);
             const rhs = this.rhs.evaluate(ctx);
             if (isOrderComparison && this.hasUntypedArgument) {
-                const lt = typeOf(lhs);
+                const lt2 = typeOf(lhs);
                 const rt = typeOf(rhs);
-                // check that type is string or number, and equal
-                if (lt.kind !== rt.kind || !(lt.kind === 'string' || lt.kind === 'number')) {
-                    throw new RuntimeError(`Expected arguments for "${ op }" to be (string, string) or (number, number), but found (${ lt.kind }, ${ rt.kind }) instead.`);
+                if (lt2.kind !== rt.kind || !(lt2.kind === 'string' || lt2.kind === 'number')) {
+                    throw new RuntimeError(`Expected arguments for "${ op }" to be (string, string) or (number, number), but found (${ lt2.kind }, ${ rt.kind }) instead.`);
                 }
             }
             if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
-                const lt = typeOf(lhs);
+                const lt2 = typeOf(lhs);
                 const rt = typeOf(rhs);
-                if (lt.kind !== 'string' || rt.kind !== 'string') {
+                if (lt2.kind !== 'string' || rt.kind !== 'string') {
                     return compareBasic(ctx, lhs, rhs);
                 }
             }
@@ -15125,12 +15147,7 @@ const GreaterThan = makeComparison('>', gt, gtCollate);
 const LessThanOrEqual = makeComparison('<=', lteq, lteqCollate);
 const GreaterThanOrEqual = makeComparison('>=', gteq, gteqCollate);
 
-//      
 class NumberFormat {
-    // BCP 47 language tag
-    // ISO 4217 currency code, required if style=currency
-    // Simple units sanctioned for use in ECMAScript, required if style=unit. https://tc39.es/proposal-unified-intl-numberformat/section6/locales-currencies-tz_proposed_out.html#sec-issanctionedsimpleunitidentifier
-    // Default 0
     // Default 3
     constructor(number, locale, currency, unit, minFractionDigits, maxFractionDigits) {
         this.type = StringType;
@@ -15185,10 +15202,10 @@ class NumberFormat {
     evaluate(ctx) {
         return new Intl.NumberFormat(this.locale ? this.locale.evaluate(ctx) : [], {
             style: this.currency && 'currency' || this.unit && 'unit' || 'decimal',
-            currency: this.currency ? this.currency.evaluate(ctx) : undefined,
-            unit: this.unit ? this.unit.evaluate(ctx) : undefined,
-            minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(ctx) : undefined,
-            maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(ctx) : undefined
+            currency: this.currency ? this.currency.evaluate(ctx) : void 0,
+            unit: this.unit ? this.unit.evaluate(ctx) : void 0,
+            minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(ctx) : void 0,
+            maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(ctx) : void 0
         }).format(this.number.evaluate(ctx));
     }
     eachChild(fn) {
@@ -15237,7 +15254,6 @@ class NumberFormat {
     }
 }
 
-//      
 class Length {
     constructor(input) {
         this.type = NumberType;
@@ -15278,8 +15294,6 @@ class Length {
     }
 }
 
-//      
-// Seeded pseudo random generator function
 function mulberry32(a) {
     return function () {
         a |= 0;
@@ -15290,7 +15304,6 @@ function mulberry32(a) {
     };
 }
 
-//      
 const expressions = {
     // special forms
     '==': Equals,
@@ -15299,58 +15312,36 @@ const expressions = {
     '<': LessThan,
     '>=': GreaterThanOrEqual,
     '<=': LessThanOrEqual,
-    // $FlowFixMe[method-unbinding]
     'array': Assertion,
-    // $FlowFixMe[method-unbinding]
     'at': At,
     'boolean': Assertion,
-    // $FlowFixMe[method-unbinding]
     'case': Case,
-    // $FlowFixMe[method-unbinding]
     'coalesce': Coalesce,
-    // $FlowFixMe[method-unbinding]
     'collator': CollatorExpression,
-    // $FlowFixMe[method-unbinding]
     'format': FormatExpression,
-    // $FlowFixMe[method-unbinding]
     'image': ImageExpression,
-    // $FlowFixMe[method-unbinding]
     'in': In,
-    // $FlowFixMe[method-unbinding]
     'index-of': IndexOf,
-    // $FlowFixMe[method-unbinding]
     'interpolate': Interpolate,
     'interpolate-hcl': Interpolate,
     'interpolate-lab': Interpolate,
-    // $FlowFixMe[method-unbinding]
     'length': Length,
-    // $FlowFixMe[method-unbinding]
     'let': Let,
-    // $FlowFixMe[method-unbinding]
     'literal': Literal,
-    // $FlowFixMe[method-unbinding]
     'match': Match,
     'number': Assertion,
-    // $FlowFixMe[method-unbinding]
     'number-format': NumberFormat,
     'object': Assertion,
-    // $FlowFixMe[method-unbinding]
     'slice': Slice,
-    // $FlowFixMe[method-unbinding]
     'step': Step,
     'string': Assertion,
-    // $FlowFixMe[method-unbinding]
     'to-boolean': Coercion,
     'to-color': Coercion,
     'to-number': Coercion,
     'to-string': Coercion,
-    // $FlowFixMe[method-unbinding]
     'var': Var,
-    // $FlowFixMe[method-unbinding]
     'within': Within,
-    // $FlowFixMe[method-unbinding]
     'distance': Distance,
-    // $FlowFixMe[method-unbinding]
     'config': Config
 };
 function rgba(ctx, [r, g, b, a]) {
@@ -15361,7 +15352,7 @@ function rgba(ctx, [r, g, b, a]) {
     const error = validateRGBA(r, g, b, alpha);
     if (error)
         throw new RuntimeError(error);
-    return new Color$1(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
+    return new Color(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
 }
 function hsla(ctx, [h, s, l, a]) {
     h = h.evaluate(ctx);
@@ -15372,7 +15363,7 @@ function hsla(ctx, [h, s, l, a]) {
     if (error)
         throw new RuntimeError(error);
     const colorFunction = `hsla(${ h }, ${ s }%, ${ l }%, ${ alpha })`;
-    const color = Color$1.parse(colorFunction);
+    const color = Color.parse(colorFunction);
     if (!color)
         throw new RuntimeError(`Failed to parse HSLA color: ${ colorFunction }`);
     return color;
@@ -15428,7 +15419,7 @@ CompoundExpression.register(expressions, {
         array$1(NumberType, 4),
         [ColorType],
         (ctx, [v]) => {
-            return v.evaluate(ctx).toArray();
+            return v.evaluate(ctx).toRenderColor(null).toArray();
         }
     ],
     'rgb': [
@@ -15569,7 +15560,7 @@ CompoundExpression.register(expressions, {
     'accumulated': [
         ValueType,
         [],
-        ctx => ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated
+        ctx => ctx.globals.accumulated === void 0 ? null : ctx.globals.accumulated
     ],
     '+': [
         NumberType,
@@ -15718,9 +15709,6 @@ CompoundExpression.register(expressions, {
         [NumberType],
         (ctx, [n]) => {
             const v = n.evaluate(ctx);
-            // Javascript's Math.round() rounds towards +Infinity for halfway
-            // values, even when they're negative. It's more common to round
-            // away from 0 (e.g., this is what python and C++ do)
             return v < 0 ? -Math.round(-v) : Math.round(v);
         }
     ],
@@ -15844,7 +15832,7 @@ CompoundExpression.register(expressions, {
     'filter-has-id': [
         BooleanType,
         [],
-        ctx => ctx.id() !== null && ctx.id() !== undefined
+        ctx => ctx.id() !== null && ctx.id() !== void 0
     ],
     'filter-type-in': [
         BooleanType,
@@ -15984,13 +15972,6 @@ CompoundExpression.register(expressions, {
     ]
 });
 
-//      
-/**
- * A type used for returning and propagating errors. The first element of the union
- * represents success and contains a value, and the second represents an error and
- * contains an error value.
- * @private
- */
 function success(value) {
     return {
         result: 'success',
@@ -16004,7 +15985,6 @@ function error(value) {
     };
 }
 
-//      
 function expressionHasParameter(expression, parameter) {
     return !!expression && !!expression.parameters && expression.parameters.indexOf(parameter) > -1;
 }
@@ -16021,7 +16001,6 @@ function supportsInterpolation(spec) {
     return !!spec.expression && spec.expression.interpolated;
 }
 
-//        
 function isFunction(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -16031,7 +16010,7 @@ function identityFunction(x) {
 function createFunction(parameters, propertySpec) {
     const isColor = propertySpec.type === 'color';
     const zoomAndFeatureDependent = parameters.stops && typeof parameters.stops[0][0] === 'object';
-    const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
+    const featureDependent = zoomAndFeatureDependent || parameters.property !== void 0;
     const zoomDependent = zoomAndFeatureDependent || !featureDependent;
     const type = parameters.type || (supportsInterpolation(propertySpec) ? 'exponential' : 'interval');
     if (isColor) {
@@ -16040,18 +16019,17 @@ function createFunction(parameters, propertySpec) {
             parameters.stops = parameters.stops.map(stop => {
                 return [
                     stop[0],
-                    Color$1.parse(stop[1])
+                    Color.parse(stop[1])
                 ];
             });
         }
         if (parameters.default) {
-            parameters.default = Color$1.parse(parameters.default);
+            parameters.default = Color.parse(parameters.default);
         } else {
-            parameters.default = Color$1.parse(propertySpec.default);
+            parameters.default = Color.parse(propertySpec.default);
         }
     }
     if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace]) {
-        // eslint-disable-line import/namespace
         throw new Error(`Unknown color space: ${ parameters.colorSpace }`);
     }
     let innerFun;
@@ -16063,12 +16041,11 @@ function createFunction(parameters, propertySpec) {
         innerFun = evaluateIntervalFunction;
     } else if (type === 'categorical') {
         innerFun = evaluateCategoricalFunction;
-        // For categorical functions, generate an Object as a hashmap of the stops for fast searching
-        hashedStops = Object.create(null);
+        hashedStops = /* @__PURE__ */
+        Object.create(null);
         for (const stop of parameters.stops) {
             hashedStops[stop[0]] = stop[1];
         }
-        // Infer key type based on first stop key-- used to encforce strict type checking later
         categoricalKeyType = typeof parameters.stops[0][0];
     } else if (type === 'identity') {
         innerFun = evaluateIdentityFunction;
@@ -16081,7 +16058,7 @@ function createFunction(parameters, propertySpec) {
         for (let s = 0; s < parameters.stops.length; s++) {
             const stop = parameters.stops[s];
             const zoom = stop[0].zoom;
-            if (featureFunctions[zoom] === undefined) {
+            if (featureFunctions[zoom] === void 0) {
                 featureFunctions[zoom] = {
                     zoom,
                     type: parameters.type,
@@ -16107,7 +16084,7 @@ function createFunction(parameters, propertySpec) {
         return {
             kind: 'composite',
             interpolationType,
-            interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
+            interpolationFactor: Interpolate.interpolationFactor.bind(void 0, interpolationType),
             zoomStops: featureFunctionStops.map(s => s[0]),
             evaluate({zoom}, properties) {
                 return evaluateExponentialFunction({
@@ -16119,12 +16096,12 @@ function createFunction(parameters, propertySpec) {
     } else if (zoomDependent) {
         const interpolationType = type === 'exponential' ? {
             name: 'exponential',
-            base: parameters.base !== undefined ? parameters.base : 1
+            base: parameters.base !== void 0 ? parameters.base : 1
         } : null;
         return {
             kind: 'camera',
             interpolationType,
-            interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
+            interpolationFactor: Interpolate.interpolationFactor.bind(void 0, interpolationType),
             zoomStops: parameters.stops.map(s => s[0]),
             evaluate: ({zoom}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
         };
@@ -16132,8 +16109,8 @@ function createFunction(parameters, propertySpec) {
         return {
             kind: 'source',
             evaluate(_, feature) {
-                const value = feature && feature.properties ? feature.properties[parameters.property] : undefined;
-                if (value === undefined) {
+                const value = feature && feature.properties ? feature.properties[parameters.property] : void 0;
+                if (value === void 0) {
                     return coalesce$1(parameters.default, propertySpec.default);
                 }
                 return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
@@ -16142,20 +16119,18 @@ function createFunction(parameters, propertySpec) {
     }
 }
 function coalesce$1(a, b, c) {
-    if (a !== undefined)
+    if (a !== void 0)
         return a;
-    if (b !== undefined)
+    if (b !== void 0)
         return b;
-    if (c !== undefined)
+    if (c !== void 0)
         return c;
 }
 function evaluateCategoricalFunction(parameters, propertySpec, input, hashedStops, keyType) {
-    const evaluated = typeof input === keyType ? hashedStops[input] : undefined;
-    // Enforce strict typing on input
+    const evaluated = typeof input === keyType ? hashedStops[input] : void 0;
     return coalesce$1(evaluated, parameters.default, propertySpec.default);
 }
 function evaluateIntervalFunction(parameters, propertySpec, input) {
-    // Edge cases
     if (getType(input) !== 'number')
         return coalesce$1(parameters.default, propertySpec.default);
     const n = parameters.stops.length;
@@ -16169,8 +16144,7 @@ function evaluateIntervalFunction(parameters, propertySpec, input) {
     return parameters.stops[index][1];
 }
 function evaluateExponentialFunction(parameters, propertySpec, input) {
-    const base = parameters.base !== undefined ? parameters.base : 1;
-    // Edge cases
+    const base = parameters.base !== void 0 ? parameters.base : 1;
     if (getType(input) !== 'number')
         return coalesce$1(parameters.default, propertySpec.default);
     const n = parameters.stops.length;
@@ -16184,21 +16158,18 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
     const t = interpolationFactor(input, base, parameters.stops[index][0], parameters.stops[index + 1][0]);
     const outputLower = parameters.stops[index][1];
     const outputUpper = parameters.stops[index + 1][1];
-    let interp = interpolate[propertySpec.type] || identityFunction;
-    // eslint-disable-line import/namespace
+    let interp = interpolate$1[propertySpec.type] || identityFunction;
     if (parameters.colorSpace && parameters.colorSpace !== 'rgb') {
         const colorspace = colorSpaces[parameters.colorSpace];
-        // eslint-disable-line import/namespace
         interp = (a, b) => colorspace.reverse(colorspace.interpolate(colorspace.forward(a), colorspace.forward(b), t));
     }
     if (typeof outputLower.evaluate === 'function') {
         return {
             evaluate(...args) {
-                const evaluatedLower = outputLower.evaluate.apply(undefined, args);
-                const evaluatedUpper = outputUpper.evaluate.apply(undefined, args);
-                // Special case for fill-outline-color, which has no spec default.
-                if (evaluatedLower === undefined || evaluatedUpper === undefined) {
-                    return undefined;
+                const evaluatedLower = outputLower.evaluate.apply(void 0, args);
+                const evaluatedUpper = outputUpper.evaluate.apply(void 0, args);
+                if (evaluatedLower === void 0 || evaluatedUpper === void 0) {
+                    return void 0;
                 }
                 return interp(evaluatedLower, evaluatedUpper, t);
             }
@@ -16208,54 +16179,16 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
 }
 function evaluateIdentityFunction(parameters, propertySpec, input) {
     if (propertySpec.type === 'color') {
-        input = Color$1.parse(input);
+        input = Color.parse(input);
     } else if (propertySpec.type === 'formatted') {
         input = Formatted.fromString(input.toString());
     } else if (propertySpec.type === 'resolvedImage') {
         input = ResolvedImage.fromString(input.toString());
     } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
-        input = undefined;
+        input = void 0;
     }
     return coalesce$1(input, parameters.default, propertySpec.default);
 }
-/**
- * Returns a ratio that can be used to interpolate between exponential function
- * stops.
- *
- * How it works:
- * Two consecutive stop values define a (scaled and shifted) exponential
- * function `f(x) = a * base^x + b`, where `base` is the user-specified base,
- * and `a` and `b` are constants affording sufficient degrees of freedom to fit
- * the function to the given stops.
- *
- * Here's a bit of algebra that lets us compute `f(x)` directly from the stop
- * values without explicitly solving for `a` and `b`:
- *
- * First stop value: `f(x0) = y0 = a * base^x0 + b`
- * Second stop value: `f(x1) = y1 = a * base^x1 + b`
- * => `y1 - y0 = a(base^x1 - base^x0)`
- * => `a = (y1 - y0)/(base^x1 - base^x0)`
- *
- * Desired value: `f(x) = y = a * base^x + b`
- * => `f(x) = y0 + a * (base^x - base^x0)`
- *
- * From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
- * little algebra:
- * ```
- * a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
- *                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
- * ```
- *
- * If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
- * `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
- * an interpolation factor between the two stops' output values.
- *
- * (Note: a slightly different form for `ratio`,
- * `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
- * expensive `Math.pow()` operations.)
- *
- * @private
- */
 function interpolationFactor(input, base, lowerValue, upperValue) {
     const difference = upperValue - lowerValue;
     const progress = input - lowerValue;
@@ -16298,8 +16231,7 @@ class StyleExpression {
         this._evaluator.featureDistanceData = featureDistanceData || null;
         try {
             const val = this.expression.evaluate(this._evaluator);
-            // eslint-disable-next-line no-self-compare
-            if (val === null || val === undefined || typeof val === 'number' && val !== val) {
+            if (val === null || val === void 0 || typeof val === 'number' && val !== val) {
                 return this._defaultValue;
             }
             if (this._enumValues && !(val in this._enumValues)) {
@@ -16320,19 +16252,9 @@ class StyleExpression {
 function isExpression(expression) {
     return Array.isArray(expression) && expression.length > 0 && typeof expression[0] === 'string' && expression[0] in expressions;
 }
-/**
- * Parse and typecheck the given style spec JSON expression.  If
- * options.defaultValue is provided, then the resulting StyleExpression's
- * `evaluate()` method will handle errors by logging a warning (once per
- * message) and returning the default value.  Otherwise, it will throw
- * evaluation errors.
- *
- * @private
- */
 function createExpression(expression, propertySpec, scope, options) {
-    const parser = new ParsingContext(expressions, [], propertySpec ? getExpectedType(propertySpec) : undefined, undefined, undefined, scope, options);
-    // For string-valued properties, coerce to string at the top level rather than asserting.
-    const parsed = parser.parse(expression, undefined, undefined, undefined, propertySpec && propertySpec.type === 'string' ? { typeAnnotation: 'coerce' } : undefined);
+    const parser = new ParsingContext$1(expressions, [], propertySpec ? getExpectedType(propertySpec) : void 0, void 0, void 0, scope, options);
+    const parsed = parser.parse(expression, void 0, void 0, void 0, propertySpec && propertySpec.type === 'string' ? { typeAnnotation: 'coerce' } : void 0);
     if (!parsed) {
         return error(parser.errors);
     }
@@ -16409,13 +16331,15 @@ 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 ? new ZoomConstantExpression('constant', expression.value, isLightConstant) : new ZoomConstantExpression('source', expression.value, isLightConstant));
+        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));
     }
-    const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
-    return success(isFeatureConstant$1 ? new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant) : new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant));
+    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));
 }
-// serialization wrapper for old-style stop functions normalized to the
-// expression interface
 class StylePropertyFunction {
     constructor(parameters, specification) {
         this._parameters = parameters;
@@ -16438,14 +16362,13 @@ function normalizePropertyExpression(value, specification, scope, options) {
     } else if (isExpression(value) || Array.isArray(value) && value.length > 0) {
         const expression = createPropertyExpression(value, specification, scope, options);
         if (expression.result === 'error') {
-            // this should have been caught in validation
             throw new Error(expression.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
         }
         return expression.value;
     } else {
         let constant = value;
         if (typeof value === 'string' && specification.type === 'color') {
-            constant = Color$1.parse(value);
+            constant = Color.parse(value);
         }
         return {
             kind: 'constant',
@@ -16454,9 +16377,6 @@ function normalizePropertyExpression(value, specification, scope, options) {
         };
     }
 }
-// Zoom-dependent expressions may only use ["zoom"] as the input to a top-level "step" or "interpolate"
-// expression (collectively referred to as a "curve"). The curve may be wrapped in one or more "let" or
-// "coalesce" expressions.
 function findZoomCurve(expression) {
     let result = null;
     if (expression instanceof Let) {
@@ -16501,13 +16421,10 @@ function getExpectedType(spec) {
 }
 function getDefaultValue(spec) {
     if (spec.type === 'color' && (isFunction(spec.default) || Array.isArray(spec.default))) {
-        // Special case for heatmap-color: it uses the 'default:' to define a
-        // default color ramp, but createExpression expects a simple value to fall
-        // back to in case of runtime errors
-        return new Color$1(0, 0, 0, 0);
+        return new Color(0, 0, 0, 0);
     } else if (spec.type === 'color') {
-        return Color$1.parse(spec.default) || null;
-    } else if (spec.default === undefined) {
+        return Color.parse(spec.default) || null;
+    } else if (spec.default === void 0) {
         return null;
     } else {
         return spec.default;
@@ -16523,11 +16440,10 @@ function convertLiteral(value) {
 function convertFunction(parameters, propertySpec) {
     let stops = parameters.stops;
     if (!stops) {
-        // identity function
         return convertIdentityFunction(parameters, propertySpec);
     }
     const zoomAndFeatureDependent = stops && typeof stops[0][0] === 'object';
-    const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
+    const featureDependent = zoomAndFeatureDependent || parameters.property !== void 0;
     const zoomDependent = zoomAndFeatureDependent || !featureDependent;
     stops = stops.map(stop => {
         if (!featureDependent && propertySpec.tokens && typeof stop[1] === 'string') {
@@ -16554,9 +16470,7 @@ function convertIdentityFunction(parameters, propertySpec) {
         'get',
         parameters.property
     ];
-    if (parameters.default === undefined) {
-        // By default, expressions for string-valued properties get coerced. To preserve
-        // legacy function semantics, insert an explicit assertion instead.
+    if (parameters.default === void 0) {
         return propertySpec.type === 'string' ? [
             'string',
             get
@@ -16598,7 +16512,7 @@ function convertZoomAndPropertyFunction(parameters, propertySpec, stops) {
     for (let s = 0; s < stops.length; s++) {
         const stop = stops[s];
         const zoom = stop[0].zoom;
-        if (featureFunctionParameters[zoom] === undefined) {
+        if (featureFunctionParameters[zoom] === void 0) {
             featureFunctionParameters[zoom] = {
                 zoom,
                 type: parameters.type,
@@ -16613,10 +16527,6 @@ function convertZoomAndPropertyFunction(parameters, propertySpec, stops) {
             stop[1]
         ]);
     }
-    // the interpolation type for the zoom dimension of a zoom-and-property
-    // function is determined directly from the style property specification
-    // for which it's being used: linear for interpolatable properties, step
-    // otherwise.
     const functionType = getFunctionType({}, propertySpec);
     if (functionType === 'exponential') {
         const expression = [
@@ -16643,20 +16553,14 @@ function convertZoomAndPropertyFunction(parameters, propertySpec, stops) {
     }
 }
 function coalesce(a, b) {
-    if (a !== undefined)
+    if (a !== void 0)
         return a;
-    if (b !== undefined)
+    if (b !== void 0)
         return b;
 }
 function getFallback(parameters, propertySpec) {
     const defaultValue = convertLiteral(coalesce(parameters.default, propertySpec.default));
-    /*
-     * Some fields with type: resolvedImage have an undefined default.
-     * Because undefined is an invalid value for resolvedImage, set fallback to
-     * an empty string instead of undefined to ensure output
-     * passes validation.
-     */
-    if (defaultValue === undefined && propertySpec.type === 'resolvedImage') {
+    if (defaultValue === void 0 && propertySpec.type === 'resolvedImage') {
         return '';
     }
     return defaultValue;
@@ -16700,7 +16604,7 @@ function convertPropertyFunction(parameters, propertySpec, stops) {
             appendStopPair(expression, stop[0], stop[1], true);
         }
         fixupDegenerateStepCurve(expression);
-        return parameters.default === undefined ? expression : [
+        return parameters.default === void 0 ? expression : [
             'case',
             [
                 '==',
@@ -16714,7 +16618,7 @@ function convertPropertyFunction(parameters, propertySpec, stops) {
             convertLiteral(parameters.default)
         ];
     } else if (type === 'exponential') {
-        const base = parameters.base !== undefined ? parameters.base : 1;
+        const base = parameters.base !== void 0 ? parameters.base : 1;
         const expression = [
             getInterpolateOperator(parameters),
             base === 1 ? ['linear'] : [
@@ -16729,7 +16633,7 @@ function convertPropertyFunction(parameters, propertySpec, stops) {
         for (const stop of stops) {
             appendStopPair(expression, stop[0], stop[1], false);
         }
-        return parameters.default === undefined ? expression : [
+        return parameters.default === void 0 ? expression : [
             'case',
             [
                 '==',
@@ -16757,7 +16661,7 @@ function convertZoomFunction(parameters, propertySpec, stops, input = ['zoom'])
         ];
         isStep = true;
     } else if (type === 'exponential') {
-        const base = parameters.base !== undefined ? parameters.base : 1;
+        const base = parameters.base !== void 0 ? parameters.base : 1;
         expression = [
             getInterpolateOperator(parameters),
             base === 1 ? ['linear'] : [
@@ -16776,19 +16680,15 @@ function convertZoomFunction(parameters, propertySpec, stops, input = ['zoom'])
     return expression;
 }
 function fixupDegenerateStepCurve(expression) {
-    // degenerate step curve (i.e. a constant function): add a noop stop
     if (expression[0] === 'step' && expression.length === 3) {
         expression.push(0);
         expression.push(expression[3]);
     }
 }
 function appendStopPair(curve, input, output, isStep) {
-    // Skip duplicate stop values. They were not validated for functions, but they are for expressions.
-    // https://github.com/mapbox/mapbox-gl-js/issues/4107
     if (curve.length > 3 && input === curve[curve.length - 2]) {
         return;
     }
-    // step curves don't get the first input value, as it is redundant.
     if (!(isStep && curve.length === 2)) {
         curve.push(input);
     }
@@ -16801,7 +16701,6 @@ function getFunctionType(parameters, propertySpec) {
         return propertySpec.expression.interpolated ? 'exponential' : 'interval';
     }
 }
-// "String with {name} token" => ["concat", "String with ", ["get", "name"], " token"]
 function convertTokenString(s) {
     const result = ['concat'];
     const re = /{([^{}]+)}/g;
@@ -16830,8 +16729,6 @@ function convertTokenString(s) {
     return result;
 }
 
-//      
-// Turn jsonlint-lines-primitives objects into primitive objects
 function unbundle(value) {
     if (value instanceof Number || value instanceof String || value instanceof Boolean) {
         return value.valueOf();
@@ -16852,7 +16749,6 @@ function deepUnbundle(value) {
     return unbundle(value);
 }
 
-//      
 function isExpressionFilter(filter) {
     if (filter === true || filter === false) {
         return true;
@@ -16888,18 +16784,8 @@ function isExpressionFilter(filter) {
         return true;
     }
 }
-/**
- * Given a filter expressed as nested arrays, return a new function
- * that evaluates whether a given feature (with a .properties or .tags property)
- * passes its test.
- *
- * @private
- * @param {Array} filter mapbox gl filter
- * @param {string} layerType the type of the layer this filter will be applied to.
- * @returns {Function} filter-evaluating function
- */
 function createFilter(filter, layerType = 'fill') {
-    if (filter === null || filter === undefined) {
+    if (filter === null || filter === void 0) {
         return {
             filter: () => true,
             needGeometry: false,
@@ -16907,7 +16793,6 @@ function createFilter(filter, layerType = 'fill') {
         };
     }
     if (!isExpressionFilter(filter)) {
-        // $FlowFixMe[incompatible-call]
         filter = convertFilter$1(filter);
     }
     const filterExp = filter;
@@ -16923,7 +16808,6 @@ Filter Expression:
 ${ JSON.stringify(filterExp, null, 2) }
         `);
     }
-    // Compile the static component of the filter
     const filterSpec = v8[`filter_${ layerType }`];
     const compiledStaticFilter = createExpression(staticFilter, filterSpec);
     let filterFunc = null;
@@ -16932,8 +16816,6 @@ ${ JSON.stringify(filterExp, null, 2) }
     } else {
         filterFunc = (globalProperties, feature, canonical) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
     }
-    // If the static component is not equal to the entire filter then we have a dynamic component
-    // Compile the dynamic component separately
     let dynamicFilterFunc = null;
     let needFeature = null;
     if (staticFilter !== filterExp) {
@@ -16941,7 +16823,7 @@ ${ JSON.stringify(filterExp, null, 2) }
         if (compiledDynamicFilter.result === 'error') {
             throw new Error(compiledDynamicFilter.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
         } else {
-            dynamicFilterFunc = (globalProperties, feature, canonical, featureTileCoord, featureDistanceData) => compiledDynamicFilter.value.evaluate(globalProperties, feature, {}, canonical, undefined, undefined, featureTileCoord, featureDistanceData);
+            dynamicFilterFunc = (globalProperties, feature, canonical, featureTileCoord, featureDistanceData) => compiledDynamicFilter.value.evaluate(globalProperties, feature, {}, canonical, void 0, void 0, featureTileCoord, featureDistanceData);
             needFeature = !isFeatureConstant(compiledDynamicFilter.value.expression);
         }
     }
@@ -16949,7 +16831,7 @@ ${ JSON.stringify(filterExp, null, 2) }
     const needGeometry = geometryNeeded(staticFilter);
     return {
         filter: filterFunc,
-        dynamicFilter: dynamicFilterFunc ? dynamicFilterFunc : undefined,
+        dynamicFilter: dynamicFilterFunc ? dynamicFilterFunc : void 0,
         needGeometry,
         needFeature: !!needFeature
     };
@@ -16958,11 +16840,8 @@ function extractStaticFilter(filter) {
     if (!isDynamicFilter(filter)) {
         return filter;
     }
-    // Shallow copy so we can replace expressions in-place
     let result = deepUnbundle(filter);
-    // 1. Union branches
     unionDynamicBranches(result);
-    // 2. Collapse dynamic conditions to  `true`
     result = collapseDynamicBooleanExpressions(result);
     return result;
 }
@@ -16977,15 +16856,6 @@ function collapseDynamicBooleanExpressions(expression) {
         return collapsed.map(subExpression => collapseDynamicBooleanExpressions(subExpression));
     }
 }
-/**
- * Traverses the expression and replaces all instances of branching on a
- * `dynamic` conditional (such as `['pitch']` or `['distance-from-center']`)
- * into an `any` expression.
- * This ensures that all possible outcomes of a `dynamic` branch are considered
- * when evaluating the expression upfront during filtering.
- *
- * @param {Array<any>} filter the filter expression mutated in-place.
- */
 function unionDynamicBranches(filter) {
     let isBranchingDynamically = false;
     const branches = [];
@@ -17011,13 +16881,11 @@ function unionDynamicBranches(filter) {
         filter.length = 0;
         filter.push('any', ...branches);
     }
-    // traverse and recurse into children
     for (let i = 1; i < filter.length; i++) {
         unionDynamicBranches(filter[i]);
     }
 }
 function isDynamicFilter(filter) {
-    // Base Cases
     if (!Array.isArray(filter)) {
         return false;
     }
@@ -17035,7 +16903,8 @@ function isDynamicFilter(filter) {
 function isRootExpressionDynamic(expression) {
     return expression === 'pitch' || expression === 'distance-from-center';
 }
-const dynamicConditionExpressions = new Set([
+const dynamicConditionExpressions = /* @__PURE__ */
+new Set([
     'in',
     '==',
     '!=',
@@ -17056,7 +16925,6 @@ function collapsedExpression(expression) {
     }
     return expression;
 }
-// Comparison function to sort numbers and strings
 function compare(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
@@ -17077,7 +16945,9 @@ function convertFilter$1(filter) {
     const op = filter[0];
     if (filter.length <= 1)
         return op !== 'any';
-    const converted = op === '==' ? convertComparisonOp$1(filter[1], filter[2], '==') : op === '!=' ? convertNegation(convertComparisonOp$1(filter[1], filter[2], '==')) : op === '<' || op === '>' || op === '<=' || op === '>=' ? convertComparisonOp$1(filter[1], filter[2], op) : op === 'any' ? convertDisjunctionOp(filter.slice(1)) : op === 'all' ? ['all'].concat(filter.slice(1).map(convertFilter$1)) : op === 'none' ? ['all'].concat(filter.slice(1).map(convertFilter$1).map(convertNegation)) : op === 'in' ? convertInOp$1(filter[1], filter.slice(2)) : op === '!in' ? convertNegation(convertInOp$1(filter[1], filter.slice(2))) : op === 'has' ? convertHasOp$1(filter[1]) : op === '!has' ? convertNegation(convertHasOp$1(filter[1])) : true;
+    const converted = op === '==' ? convertComparisonOp$1(filter[1], filter[2], '==') : op === '!=' ? convertNegation(convertComparisonOp$1(filter[1], filter[2], '==')) : op === '<' || op === '>' || op === '<=' || op === '>=' ? convertComparisonOp$1(filter[1], filter[2], op) : op === 'any' ? convertDisjunctionOp(filter.slice(1)) : // @ts-expect-error - TS2769 - No overload matches this call.
+    op === 'all' ? ['all'].concat(filter.slice(1).map(convertFilter$1)) : // @ts-expect-error - TS2769 - No overload matches this call.
+    op === 'none' ? ['all'].concat(filter.slice(1).map(convertFilter$1).map(convertNegation)) : op === 'in' ? convertInOp$1(filter[1], filter.slice(2)) : op === '!in' ? convertNegation(convertInOp$1(filter[1], filter.slice(2))) : op === 'has' ? convertHasOp$1(filter[1]) : op === '!has' ? convertNegation(convertHasOp$1(filter[1])) : true;
     return converted;
 }
 function convertComparisonOp$1(property, value, op) {
@@ -17166,63 +17036,9 @@ function convertNegation(filter) {
     ];
 }
 
-//      
-/**
- * Convert the given legacy filter to (the JSON representation of) an
- * equivalent expression
- * @private
- */
 function convertFilter(filter) {
     return _convertFilter(filter, {});
 }
-/*
- * Convert the given filter to an expression, storing the expected types for
- * any feature properties referenced in expectedTypes.
- *
- * These expected types are needed in order to construct preflight type checks
- * needed for handling 'any' filters. A preflight type check is necessary in
- * order to mimic legacy filters' semantics around expected type mismatches.
- * For example, consider the legacy filter:
- *
- *     ["any", ["all", [">", "y", 0], [">", "y", 0]], [">", "x", 0]]
- *
- * Naively, we might convert this to the expression:
- *
- *     ["any", ["all", [">", ["get", "y"], 0], [">", ["get", "z"], 0]], [">", ["get", "x"], 0]]
- *
- * But if we tried to evaluate this against, say `{x: 1, y: null, z: 0}`, the
- * [">", ["get", "y"], 0] would cause an evaluation error, leading to the
- * entire filter returning false. Legacy filter semantics, though, ask for
- * [">", "y", 0] to simply return `false` when `y` is of the wrong type,
- * allowing the subsequent terms of the outer "any" expression to be evaluated
- * (resulting, in this case, in a `true` value, because x > 0).
- *
- * We account for this by inserting a preflight type-checking expression before
- * each "any" term, allowing us to avoid evaluating the actual converted filter
- * if any type mismatches would cause it to produce an evalaution error:
- *
- *     ["any",
- *       ["case",
- *         ["all", ["==", ["typeof", ["get", "y"]], "number"], ["==", ["typeof", ["get", "z"], "number]],
- *         ["all", [">", ["get", "y"], 0], [">", ["get", "z"], 0]],
- *         false
- *       ],
- *       ["case",
- *         ["==", ["typeof", ["get", "x"], "number"]],
- *         [">", ["get", "x"], 0],
- *         false
- *       ]
- *     ]
- *
- * An alternative, possibly more direct approach would be to use type checks
- * in the conversion of each comparison operator, so that the converted version
- * of each individual ==, >=, etc. would mimic the legacy filter semantics. The
- * downside of this approach is that it can lead to many more type checks than
- * would otherwise be necessary: outside the context of an "any" expression,
- * bailing out due to a runtime type error (expression semantics) and returning
- * false (legacy filter semantics) are equivalent: they cause the filter to
- * produce a `false` result.
- */
 function _convertFilter(filter, expectedTypes) {
     if (isExpressionFilter(filter)) {
         return filter;
@@ -17273,14 +17089,6 @@ function _convertFilter(filter, expectedTypes) {
     }
     return converted;
 }
-// Given a set of feature properties and an expected type for each one,
-// construct an boolean expression that tests whether each property has the
-// right type.
-// E.g.: for {name: 'string', population: 'number'}, return
-// [ 'all',
-//   ['==', ['typeof', ['get', 'name'], 'string']],
-//   ['==', ['typeof', ['get', 'population'], 'number]]
-// ]
 function runtimeTypeChecks(expectedTypes) {
     const conditions = [];
     for (const property in expectedTypes) {
@@ -17375,10 +17183,6 @@ function convertInOp(property, values, negate = false) {
             property
         ];
     }
-    // Determine if the list of values to be searched is homogenously typed.
-    // If so (and if the type is string or number), then we can use a
-    // [match, input, [...values], true, false] construction rather than a
-    // bunch of `==` tests.
     let uniformTypes = true;
     const type = typeof values[0];
     for (const value of values) {
@@ -17388,7 +17192,6 @@ function convertInOp(property, values, negate = false) {
         }
     }
     if (uniformTypes && (type === 'string' || type === 'number')) {
-        // Match expressions must have unique values.
         const uniqueValues = values.sort().filter((v, i) => i === 0 || values[i - 1] !== v);
         return [
             'match',
@@ -17398,7 +17201,8 @@ function convertInOp(property, values, negate = false) {
             negate
         ];
     }
-    return [negate ? 'all' : 'any'].concat(values.map(v => [
+    return [negate ? 'all' : 'any'].concat(// @ts-expect-error - TS2769 - No overload matches this call.
+    values.map(v => [
         negate ? '!=' : '==',
         get,
         v
@@ -17421,12 +17225,6 @@ function convertHasOp(property) {
     }
 }
 
-//      
-/**
- * Migrate the given style object in place to use expressions. Specifically,
- * this will convert (a) "stop" functions, and (b) legacy filters to their
- * expression equivalents.
- */
 function migrateToExpressions (style) {
     const converted = [];
     eachLayer(style, layer => {
@@ -17441,9 +17239,6 @@ function migrateToExpressions (style) {
         if (isExpression(value))
             return;
         if (typeof value === 'object' && !Array.isArray(value)) {
-            // $FlowFixMe[prop-missing]
-            // $FlowFixMe[incompatible-call]
-            // $FlowFixMe[incompatible-variance]
             set(convertFunction(value, reference));
             converted.push(path.join('.'));
         } else if (reference.tokens && typeof value === 'string') {
@@ -17453,20 +17248,6 @@ function migrateToExpressions (style) {
     return style;
 }
 
-//        
-/**
- * Migrate a Mapbox GL Style to the latest version.
- *
- * @private
- * @alias migrate
- * @param {object} style a Mapbox GL Style
- * @returns {Object} a migrated style
- * @example
- * var fs = require('fs');
- * var migrate = require('mapbox-gl-style-spec').migrate;
- * var style = fs.readFileSync('./style.json', 'utf8');
- * fs.writeFileSync('./style.json', JSON.stringify(migrate(style)));
- */
 function migrate (style) {
     let migrated = false;
     if (style.version === 7) {
@@ -17483,7 +17264,6 @@ function migrate (style) {
     return style;
 }
 
-//        
 function composite (style) {
     const styleIDs = [];
     const sourceIDs = [];
@@ -17523,7 +17303,6 @@ function composite (style) {
     return style;
 }
 
-//      
 var refProperties = [
     'type',
     'source',
@@ -17534,7 +17313,6 @@ var refProperties = [
     'layout'
 ];
 
-//      
 function deref(layer, parent) {
     const result = {};
     for (const k in layer) {
@@ -17549,22 +17327,10 @@ function deref(layer, parent) {
     });
     return result;
 }
-/**
- * Given an array of layers, some of which may contain `ref` properties
- * whose value is the `id` of another property, return a new array where
- * such layers have been augmented with the 'type', 'source', etc. properties
- * from the parent layer, and the `ref` property has been removed.
- *
- * The input is not modified. The output may contain references to portions
- * of the input.
- *
- * @private
- * @param {Array<Layer>} layers
- * @returns {Array<Layer>}
- */
 function derefLayers(layers) {
     layers = layers.slice();
-    const map = Object.create(null);
+    const map = /* @__PURE__ */
+    Object.create(null);
     for (let i = 0; i < layers.length; i++) {
         map[layers[i].id] = layers[i];
     }
@@ -17576,12 +17342,6 @@ function derefLayers(layers) {
     return layers;
 }
 
-//      
-/**
- * Deeply compares two object literals.
- *
- * @private
- */
 function deepEqual(a, b) {
     if (Array.isArray(a)) {
         if (!Array.isArray(b) || a.length !== b.length)
@@ -17607,119 +17367,118 @@ function deepEqual(a, b) {
     return a === b;
 }
 
-//      
 const operations = {
     /*
-     * { command: 'setStyle', args: [stylesheet] }
-     */
+   * { command: 'setStyle', args: [stylesheet] }
+   */
     setStyle: 'setStyle',
     /*
-     * { command: 'addLayer', args: [layer, 'beforeLayerId'] }
-     */
+   * { command: 'addLayer', args: [layer, 'beforeLayerId'] }
+   */
     addLayer: 'addLayer',
     /*
-     * { command: 'removeLayer', args: ['layerId'] }
-     */
+   * { command: 'removeLayer', args: ['layerId'] }
+   */
     removeLayer: 'removeLayer',
     /*
-     * { command: 'setPaintProperty', args: ['layerId', 'prop', value] }
-     */
+   * { command: 'setPaintProperty', args: ['layerId', 'prop', value] }
+   */
     setPaintProperty: 'setPaintProperty',
     /*
-     * { command: 'setLayoutProperty', args: ['layerId', 'prop', value] }
-     */
+   * { command: 'setLayoutProperty', args: ['layerId', 'prop', value] }
+   */
     setLayoutProperty: 'setLayoutProperty',
     /*
-     * { command: 'setSlot', args: ['layerId', slot] }
-     */
+   * { command: 'setSlot', args: ['layerId', slot] }
+   */
     setSlot: 'setSlot',
     /*
-     * { command: 'setFilter', args: ['layerId', filter] }
-     */
+   * { command: 'setFilter', args: ['layerId', filter] }
+   */
     setFilter: 'setFilter',
     /*
-     * { command: 'addSource', args: ['sourceId', source] }
-     */
+   * { command: 'addSource', args: ['sourceId', source] }
+   */
     addSource: 'addSource',
     /*
-     * { command: 'removeSource', args: ['sourceId'] }
-     */
+   * { command: 'removeSource', args: ['sourceId'] }
+   */
     removeSource: 'removeSource',
     /*
-     * { command: 'setGeoJSONSourceData', args: ['sourceId', data] }
-     */
+   * { command: 'setGeoJSONSourceData', args: ['sourceId', data] }
+   */
     setGeoJSONSourceData: 'setGeoJSONSourceData',
     /*
-     * { command: 'setLayerZoomRange', args: ['layerId', 0, 22] }
-     */
+   * { command: 'setLayerZoomRange', args: ['layerId', 0, 22] }
+   */
     setLayerZoomRange: 'setLayerZoomRange',
     /*
-     * { command: 'setLayerProperty', args: ['layerId', 'prop', value] }
-     */
+   * { command: 'setLayerProperty', args: ['layerId', 'prop', value] }
+   */
     setLayerProperty: 'setLayerProperty',
     /*
-     * { command: 'setCenter', args: [[lon, lat]] }
-     */
+   * { command: 'setCenter', args: [[lon, lat]] }
+   */
     setCenter: 'setCenter',
     /*
-     * { command: 'setZoom', args: [zoom] }
-     */
+   * { command: 'setZoom', args: [zoom] }
+   */
     setZoom: 'setZoom',
     /*
-     * { command: 'setBearing', args: [bearing] }
-     */
+   * { command: 'setBearing', args: [bearing] }
+   */
     setBearing: 'setBearing',
     /*
-     * { command: 'setPitch', args: [pitch] }
-     */
+   * { command: 'setPitch', args: [pitch] }
+   */
     setPitch: 'setPitch',
     /*
-     * { command: 'setSprite', args: ['spriteUrl'] }
-     */
+   * { command: 'setSprite', args: ['spriteUrl'] }
+   */
     setSprite: 'setSprite',
     /*
-     * { command: 'setGlyphs', args: ['glyphsUrl'] }
-     */
+   * { command: 'setGlyphs', args: ['glyphsUrl'] }
+   */
     setGlyphs: 'setGlyphs',
     /*
-     * { command: 'setTransition', args: [transition] }
-     */
+   * { command: 'setTransition', args: [transition] }
+   */
     setTransition: 'setTransition',
     /*
-     * { command: 'setLighting', args: [lightProperties] }
-     */
+   * { command: 'setLighting', args: [lightProperties] }
+   */
     setLight: 'setLight',
     /*
-     * { command: 'setTerrain', args: [terrainProperties] }
-     */
+   * { command: 'setTerrain', args: [terrainProperties] }
+   */
     setTerrain: 'setTerrain',
     /*
-     *  { command: 'setFog', args: [fogProperties] }
-     */
+   *  { command: 'setFog', args: [fogProperties] }
+   */
     setFog: 'setFog',
     /*
-     *  { command: 'setCamera', args: [cameraProperties] }
-     */
+   *  { command: 'setCamera', args: [cameraProperties] }
+   */
     setCamera: 'setCamera',
     /*
-     *  { command: 'setLights', args: [{light-3d},...] }
-     */
+   *  { command: 'setLights', args: [{light-3d},...] }
+   */
     setLights: 'setLights',
     /*
-     *  { command: 'setProjection', args: [projectionProperties] }
-     */
+   *  { command: 'setProjection', args: [projectionProperties] }
+   */
     setProjection: 'setProjection',
     /*
-     *  { command: 'addImport', args: [import] }
-     */
+   *  { command: 'addImport', args: [import] }
+   */
     addImport: 'addImport',
     /*
-     *  { command: 'removeImport', args: [importId] }
-     */
+   *  { command: 'removeImport', args: [importId] }
+   */
     removeImport: 'removeImport',
     /**
-     * { command: 'updateImport', args: [importId, importSpecification | styleUrl] }
-     */
+   * { command: 'updateImport', args: [importId, importSpecification | styleUrl] }
+   */
     updateImport: 'updateImport'
 };
 function addSource(sourceId, after, commands) {
@@ -17764,7 +17523,6 @@ function diffSources(before, after, commands, sourcesRemoved) {
     before = before || {};
     after = after || {};
     let sourceId;
-    // look for sources to remove
     for (sourceId in before) {
         if (!before.hasOwnProperty(sourceId))
             continue;
@@ -17772,7 +17530,6 @@ function diffSources(before, after, commands, sourcesRemoved) {
             removeSource(sourceId, commands, sourcesRemoved);
         }
     }
-    // look for sources to add/update
     for (sourceId in after) {
         if (!after.hasOwnProperty(sourceId))
             continue;
@@ -17789,7 +17546,6 @@ function diffSources(before, after, commands, sourcesRemoved) {
                     ]
                 });
             } else {
-                // no update command, must remove then add
                 updateSource(sourceId, after, commands, sourcesRemoved);
             }
         }
@@ -17840,18 +17596,14 @@ function indexById(group, item) {
 function diffLayers(before, after, commands) {
     before = before || [];
     after = after || [];
-    // order of layers by id
     const beforeOrder = before.map(pluckId);
     const afterOrder = after.map(pluckId);
-    // index of layer by id
     const beforeIndex = before.reduce(indexById, {});
     const afterIndex = after.reduce(indexById, {});
-    // track order of layers as if they have been mutated
     const tracker = beforeOrder.slice();
-    // layers that have been added do not need to be diffed
-    const clean = Object.create(null);
+    const clean = /* @__PURE__ */
+    Object.create(null);
     let i, d, layerId, beforeLayer, afterLayer, insertBeforeLayerId, prop;
-    // remove layers
     for (i = 0, d = 0; i < beforeOrder.length; i++) {
         layerId = beforeOrder[i];
         if (!afterIndex.hasOwnProperty(layerId)) {
@@ -17861,28 +17613,22 @@ function diffLayers(before, after, commands) {
             });
             tracker.splice(tracker.indexOf(layerId, d), 1);
         } else {
-            // limit where in tracker we need to look for a match
             d++;
         }
     }
-    // add/reorder layers
     for (i = 0, d = 0; i < afterOrder.length; i++) {
-        // work backwards as insert is before an existing layer
         layerId = afterOrder[afterOrder.length - 1 - i];
         if (tracker[tracker.length - 1 - i] === layerId)
             continue;
         if (beforeIndex.hasOwnProperty(layerId)) {
-            // remove the layer before we insert at the correct position
             commands.push({
                 command: operations.removeLayer,
                 args: [layerId]
             });
             tracker.splice(tracker.lastIndexOf(layerId, tracker.length - d), 1);
         } else {
-            // limit where in tracker we need to look for a match
             d++;
         }
-        // add layer at correct position
         insertBeforeLayerId = tracker[tracker.length - i];
         commands.push({
             command: operations.addLayer,
@@ -17894,24 +17640,17 @@ function diffLayers(before, after, commands) {
         tracker.splice(tracker.length - i, 0, layerId);
         clean[layerId] = true;
     }
-    // update layers
     for (i = 0; i < afterOrder.length; i++) {
         layerId = afterOrder[i];
         beforeLayer = beforeIndex[layerId];
         afterLayer = afterIndex[layerId];
-        // no need to update if previously added (new or moved)
         if (clean[layerId] || deepEqual(beforeLayer, afterLayer))
             continue;
-        // If source, source-layer, or type have changes, then remove the layer
-        // and add it back 'from scratch'.
-        // $FlowFixMe[prop-missing] - there is no `source-layer` in background and sky layers
         if (!deepEqual(beforeLayer.source, afterLayer.source) || !deepEqual(beforeLayer['source-layer'], afterLayer['source-layer']) || !deepEqual(beforeLayer.type, afterLayer.type)) {
             commands.push({
                 command: operations.removeLayer,
                 args: [layerId]
             });
-            // we add the layer back at the same position it was already in, so
-            // there's no need to update the `tracker`
             insertBeforeLayerId = tracker[tracker.lastIndexOf(layerId) + 1];
             commands.push({
                 command: operations.addLayer,
@@ -17922,7 +17661,6 @@ function diffLayers(before, after, commands) {
             });
             continue;
         }
-        // layout, paint, filter, minzoom, maxzoom
         diffLayerPropertyChanges(beforeLayer.layout, afterLayer.layout, commands, layerId, null, operations.setLayoutProperty);
         diffLayerPropertyChanges(beforeLayer.paint, afterLayer.paint, commands, layerId, null, operations.setPaintProperty);
         if (!deepEqual(beforeLayer.slot, afterLayer.slot)) {
@@ -17953,7 +17691,6 @@ function diffLayers(before, after, commands) {
                 ]
             });
         }
-        // handle all other layer props, including paint.*
         for (prop in beforeLayer) {
             if (!beforeLayer.hasOwnProperty(prop))
                 continue;
@@ -17995,16 +17732,12 @@ function diffLayers(before, after, commands) {
 function diffImports(before = [], after = [], commands) {
     before = before || [];
     after = after || [];
-    // order imports by id
     const beforeOrder = before.map(pluckId);
     const afterOrder = after.map(pluckId);
-    // index imports by id
     const beforeIndex = before.reduce(indexById, {});
     const afterIndex = after.reduce(indexById, {});
-    // track order of imports as if they have been mutated
     const tracker = beforeOrder.slice();
     let i, d, importId, insertBefore;
-    // remove imports
     for (i = 0, d = 0; i < beforeOrder.length; i++) {
         importId = beforeOrder[i];
         if (!afterIndex.hasOwnProperty(importId)) {
@@ -18014,28 +17747,22 @@ function diffImports(before = [], after = [], commands) {
             });
             tracker.splice(tracker.indexOf(importId, d), 1);
         } else {
-            // limit where in tracker we need to look for a match
             d++;
         }
     }
-    // add/reorder imports
     for (i = 0, d = 0; i < afterOrder.length; i++) {
-        // work backwards as insert is before an existing import
         importId = afterOrder[afterOrder.length - 1 - i];
         if (tracker[tracker.length - 1 - i] === importId)
             continue;
         if (beforeIndex.hasOwnProperty(importId)) {
-            // remove the import before we insert at the correct position
             commands.push({
                 command: operations.removeImport,
                 args: [importId]
             });
             tracker.splice(tracker.lastIndexOf(importId, tracker.length - d), 1);
         } else {
-            // limit where in tracker we need to look for a match
             d++;
         }
-        // add import at correct position
         insertBefore = tracker[tracker.length - i];
         commands.push({
             command: operations.addImport,
@@ -18046,7 +17773,6 @@ function diffImports(before = [], after = [], commands) {
         });
         tracker.splice(tracker.length - i, 0, importId);
     }
-    // update imports
     for (const afterImport of after) {
         const beforeImport = beforeIndex[afterImport.id];
         if (!beforeImport || deepEqual(beforeImport, afterImport))
@@ -18060,24 +17786,6 @@ function diffImports(before = [], after = [], commands) {
         });
     }
 }
-/**
- * Diff two stylesheet
- *
- * Creates semanticly aware diffs that can easily be applied at runtime.
- * Operations produced by the diff closely resemble the mapbox-gl-js API. Any
- * error creating the diff will fall back to the 'setStyle' operation.
- *
- * Example diff:
- * [
- *     { command: 'setConstant', args: ['@water', '#0000FF'] },
- *     { command: 'setPaintProperty', args: ['background', 'background-color', 'black'] }
- * ]
- *
- * @private
- * @param {*} [before] stylesheet to compare from
- * @param {*} after stylesheet to compare to
- * @returns Array list of changes
- */
 function diffStyles(before, after) {
     if (!before)
         return [{
@@ -18086,7 +17794,6 @@ function diffStyles(before, after) {
             }];
     let commands = [];
     try {
-        // Handle changes to top-level properties
         if (!deepEqual(before.version, after.version)) {
             return [{
                     command: operations.setStyle,
@@ -18129,7 +17836,6 @@ function diffStyles(before, after) {
                 args: [after.glyphs]
             });
         }
-        // Handle changes to `imports` before other mergable top-level properties
         if (!deepEqual(before.imports, after.imports)) {
             diffImports(before.imports, after.imports, commands);
         }
@@ -18169,18 +17875,15 @@ function diffStyles(before, after) {
                 args: [after.camera]
             });
         }
-        // Handle changes to `sources`
-        // If a source is to be removed, we also--before the removeSource
-        // command--need to remove all the style layers that depend on it.
+        if (!deepEqual(before['color-theme'], after['color-theme'])) {
+            return [{
+                    command: operations.setStyle,
+                    args: [after]
+                }];
+        }
         const sourcesRemoved = {};
-        // First collect the {add,remove}Source commands
         const removeOrAddSourceCommands = [];
         diffSources(before.sources, after.sources, removeOrAddSourceCommands, sourcesRemoved);
-        // Push a removeLayer command for each style layer that depends on a
-        // source that's being removed.
-        // Also, exclude any such layers them from the input to `diffLayers`
-        // below, so that diffLayers produces the appropriate `addLayers`
-        // command
         const beforeLayers = [];
         if (before.layers) {
             before.layers.forEach(layer => {
@@ -18194,30 +17897,25 @@ function diffStyles(before, after) {
                 }
             });
         }
-        // Remove the terrain if the source for that terrain is being removed
         let beforeTerrain = before.terrain;
         if (beforeTerrain) {
             if (sourcesRemoved[beforeTerrain.source]) {
                 commands.push({
                     command: operations.setTerrain,
-                    args: [undefined]
+                    args: [void 0]
                 });
-                beforeTerrain = undefined;
+                beforeTerrain = void 0;
             }
         }
         commands = commands.concat(removeOrAddSourceCommands);
-        // Even though terrain is a top-level property
-        // Its like a layer in the sense that it depends on a source being present.
         if (!deepEqual(beforeTerrain, after.terrain)) {
             commands.push({
                 command: operations.setTerrain,
                 args: [after.terrain]
             });
         }
-        // Handle changes to `layers`
         diffLayers(beforeLayers, after.layers, commands);
     } catch (e) {
-        // fall back to setStyle
         console.warn('Unable to compute style diff:', e);
         commands = [{
                 command: operations.setStyle,
@@ -18227,14 +17925,12 @@ function diffStyles(before, after) {
     return commands;
 }
 
-//      
-// Note: Do not inherit from Error. It breaks when transpiling to ES5.
 class ValidationError {
     constructor(key, value, message, identifier) {
         this.message = (key ? `${ key }: ` : '') + message;
         if (identifier)
             this.identifier = identifier;
-        if (value !== null && value !== undefined && value.__line__) {
+        if (value !== null && value !== void 0 && value.__line__) {
             this.line = value.__line__;
         }
     }
@@ -18242,8 +17938,6 @@ class ValidationError {
 class ValidationWarning extends ValidationError {
 }
 
-//      
-// Note: Do not inherit from Error. It breaks when transpiling to ES5.
 class ParsingError {
     constructor(error) {
         this.error = error;
@@ -18253,7 +17947,6 @@ class ParsingError {
     }
 }
 
-//      
 function validateObject(options) {
     const key = options.key;
     const object = options.value;
@@ -18268,7 +17961,6 @@ function validateObject(options) {
     }
     for (const objectKey in object) {
         const elementSpecKey = objectKey.split('.')[0];
-        // treat 'paint.*' as 'paint'
         const elementSpec = elementSpecs[elementSpecKey] || elementSpecs['*'];
         let validateElement;
         if (elementValidators[elementSpecKey]) {
@@ -18291,26 +17983,23 @@ function validateObject(options) {
             style,
             styleSpec,
             object,
-            objectKey    // $FlowFixMe[extra-arg]
+            objectKey
         }, object));
     }
     for (const elementSpecKey in elementSpecs) {
-        // Don't check `required` when there's a custom validator for that property.
         if (elementValidators[elementSpecKey]) {
             continue;
         }
-        if (elementSpecs[elementSpecKey].required && elementSpecs[elementSpecKey]['default'] === undefined && object[elementSpecKey] === undefined) {
+        if (elementSpecs[elementSpecKey].required && elementSpecs[elementSpecKey]['default'] === void 0 && object[elementSpecKey] === void 0) {
             errors.push(new ValidationError(key, object, `missing required property "${ elementSpecKey }"`));
         }
     }
     return errors;
 }
 
-//      
 function validateImport(options) {
     const {value, styleSpec} = options;
     const {data, ...importSpec} = value;
-    // Preserve __line__ from the value
     Object.defineProperty(importSpec, '__line__', {
         value: value.__line__,
         enumerable: false
@@ -18319,7 +18008,6 @@ function validateImport(options) {
         value: importSpec,
         valueSpec: styleSpec.import
     }));
-    // Empty string is reserved for the root style id
     if (unbundle(importSpec.id) === '') {
         const key = `${ options.key }.id`;
         errors.push(new ValidationError(key, importSpec, `import id can't be an empty string`));
@@ -18331,7 +18019,6 @@ function validateImport(options) {
     return errors;
 }
 
-//      
 function validateArray(options) {
     const array = options.value;
     const arraySpec = options.valueSpec;
@@ -18353,7 +18040,7 @@ function validateArray(options) {
         'values': arraySpec.values,
         'minimum': arraySpec.minimum,
         'maximum': arraySpec.maximum,
-        function: undefined
+        function: void 0
     };
     if (styleSpec.$version < 7) {
         arrayElementSpec.function = arraySpec.function;
@@ -18376,13 +18063,11 @@ function validateArray(options) {
     return errors;
 }
 
-//      
 function validateNumber(options) {
     const key = options.key;
     const value = options.value;
     const valueSpec = options.valueSpec;
     let type = getType(value);
-    // eslint-disable-next-line no-self-compare
     if (type === 'number' && value !== value) {
         type = 'NaN';
     }
@@ -18412,7 +18097,6 @@ function validateNumber(options) {
     return [];
 }
 
-//      
 function validateFunction(options) {
     const functionValueSpec = options.valueSpec;
     const functionType = unbundle(options.value.type);
@@ -18420,7 +18104,7 @@ function validateFunction(options) {
     let stopDomainValues = {};
     let previousStopDomainValue;
     let previousStopDomainZoom;
-    const isZoomFunction = functionType !== 'categorical' && options.value.property === undefined;
+    const isZoomFunction = functionType !== 'categorical' && options.value.property === void 0;
     const isPropertyFunction = !isZoomFunction;
     const isZoomAndPropertyFunction = getType(options.value.stops) === 'array' && getType(options.value.stops[0]) === 'array' && getType(options.value.stops[0][0]) === 'object';
     const errors = validateObject({
@@ -18450,33 +18134,33 @@ function validateFunction(options) {
             errors.push(new ValidationError(options.key, options.value, 'zoom functions not supported'));
         }
     }
-    if ((functionType === 'categorical' || isZoomAndPropertyFunction) && options.value.property === undefined) {
+    if ((functionType === 'categorical' || isZoomAndPropertyFunction) && options.value.property === void 0) {
         errors.push(new ValidationError(options.key, options.value, '"property" property is required'));
     }
     return errors;
-    function validateFunctionStops(options) {
+    function validateFunctionStops(options2) {
         if (functionType === 'identity') {
-            return [new ValidationError(options.key, options.value, 'identity function may not have a "stops" property')];
+            return [new ValidationError(options2.key, options2.value, 'identity function may not have a "stops" property')];
         }
-        let errors = [];
-        const value = options.value;
-        errors = errors.concat(validateArray({
-            key: options.key,
+        let errors2 = [];
+        const value = options2.value;
+        errors2 = errors2.concat(validateArray({
+            key: options2.key,
             value,
-            valueSpec: options.valueSpec,
-            style: options.style,
-            styleSpec: options.styleSpec,
+            valueSpec: options2.valueSpec,
+            style: options2.style,
+            styleSpec: options2.styleSpec,
             arrayElementValidator: validateFunctionStop
         }));
         if (getType(value) === 'array' && value.length === 0) {
-            errors.push(new ValidationError(options.key, value, 'array must have at least one stop'));
+            errors2.push(new ValidationError(options2.key, value, 'array must have at least one stop'));
         }
-        return errors;
+        return errors2;
     }
-    function validateFunctionStop(options) {
-        let errors = [];
-        const value = options.value;
-        const key = options.key;
+    function validateFunctionStop(options2) {
+        let errors2 = [];
+        const value = options2.value;
+        const key = options2.key;
         if (getType(value) !== 'array') {
             return [new ValidationError(key, value, `array expected, ${ getType(value) } found`)];
         }
@@ -18487,10 +18171,10 @@ function validateFunction(options) {
             if (getType(value[0]) !== 'object') {
                 return [new ValidationError(key, value, `object expected, ${ getType(value[0]) } found`)];
             }
-            if (value[0].zoom === undefined) {
+            if (value[0].zoom === void 0) {
                 return [new ValidationError(key, value, 'object stop key must have zoom')];
             }
-            if (value[0].value === undefined) {
+            if (value[0].value === void 0) {
                 return [new ValidationError(key, value, 'object stop key must have value')];
             }
             const nextStopDomainZoom = unbundle(value[0].zoom);
@@ -18502,86 +18186,85 @@ function validateFunction(options) {
             }
             if (nextStopDomainZoom !== previousStopDomainZoom) {
                 previousStopDomainZoom = nextStopDomainZoom;
-                previousStopDomainValue = undefined;
+                previousStopDomainValue = void 0;
                 stopDomainValues = {};
             }
-            errors = errors.concat(validateObject({
+            errors2 = errors2.concat(validateObject({
                 key: `${ key }[0]`,
                 value: value[0],
                 valueSpec: { zoom: {} },
-                style: options.style,
-                styleSpec: options.styleSpec,
+                style: options2.style,
+                styleSpec: options2.styleSpec,
                 objectElementValidators: {
                     zoom: validateNumber,
                     value: validateStopDomainValue
                 }
             }));
         } else {
-            errors = errors.concat(validateStopDomainValue({
+            errors2 = errors2.concat(validateStopDomainValue({
                 key: `${ key }[0]`,
                 value: value[0],
                 valueSpec: {},
-                style: options.style,
-                styleSpec: options.styleSpec
+                style: options2.style,
+                styleSpec: options2.styleSpec
             }, value));
         }
         if (isExpression(deepUnbundle(value[1]))) {
-            return errors.concat([new ValidationError(`${ key }[1]`, value[1], 'expressions are not allowed in function stops.')]);
+            return errors2.concat([new ValidationError(`${ key }[1]`, value[1], 'expressions are not allowed in function stops.')]);
         }
-        return errors.concat(validate({
+        return errors2.concat(validate({
             key: `${ key }[1]`,
             value: value[1],
             valueSpec: functionValueSpec,
-            style: options.style,
-            styleSpec: options.styleSpec
+            style: options2.style,
+            styleSpec: options2.styleSpec
         }));
     }
-    function validateStopDomainValue(options, stop) {
-        const type = getType(options.value);
-        const value = unbundle(options.value);
-        const reportValue = options.value !== null ? options.value : stop;
+    function validateStopDomainValue(options2, stop) {
+        const type = getType(options2.value);
+        const value = unbundle(options2.value);
+        const reportValue = options2.value !== null ? options2.value : stop;
         if (!stopKeyType) {
             stopKeyType = type;
         } else if (type !== stopKeyType) {
-            return [new ValidationError(options.key, reportValue, `${ type } stop domain type must match previous stop domain type ${ stopKeyType }`)];
+            return [new ValidationError(options2.key, reportValue, `${ type } stop domain type must match previous stop domain type ${ stopKeyType }`)];
         }
         if (type !== 'number' && type !== 'string' && type !== 'boolean' && typeof value !== 'number' && typeof value !== 'string' && typeof value !== 'boolean') {
-            return [new ValidationError(options.key, reportValue, 'stop domain value must be a number, string, or boolean')];
+            return [new ValidationError(options2.key, reportValue, 'stop domain value must be a number, string, or boolean')];
         }
         if (type !== 'number' && functionType !== 'categorical') {
             let message = `number expected, ${ type } found`;
-            if (supportsPropertyExpression(functionValueSpec) && functionType === undefined) {
+            if (supportsPropertyExpression(functionValueSpec) && functionType === void 0) {
                 message += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.';
             }
-            return [new ValidationError(options.key, reportValue, message)];
+            return [new ValidationError(options2.key, reportValue, message)];
         }
         if (functionType === 'categorical' && type === 'number' && (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value)) {
-            return [new ValidationError(options.key, reportValue, `integer expected, found ${ String(value) }`)];
+            return [new ValidationError(options2.key, reportValue, `integer expected, found ${ String(value) }`)];
         }
-        if (functionType !== 'categorical' && type === 'number' && typeof value === 'number' && typeof previousStopDomainValue === 'number' && previousStopDomainValue !== undefined && value < previousStopDomainValue) {
-            return [new ValidationError(options.key, reportValue, 'stop domain values must appear in ascending order')];
+        if (functionType !== 'categorical' && type === 'number' && typeof value === 'number' && typeof previousStopDomainValue === 'number' && previousStopDomainValue !== void 0 && value < previousStopDomainValue) {
+            return [new ValidationError(options2.key, reportValue, 'stop domain values must appear in ascending order')];
         } else {
             previousStopDomainValue = value;
         }
         if (functionType === 'categorical' && value in stopDomainValues) {
-            return [new ValidationError(options.key, reportValue, 'stop domain values must be unique')];
+            return [new ValidationError(options2.key, reportValue, 'stop domain values must be unique')];
         } else {
             stopDomainValues[value] = true;
         }
         return [];
     }
-    function validateFunctionDefault(options) {
+    function validateFunctionDefault(options2) {
         return validate({
-            key: options.key,
-            value: options.value,
+            key: options2.key,
+            value: options2.value,
             valueSpec: functionValueSpec,
-            style: options.style,
-            styleSpec: options.styleSpec
+            style: options2.style,
+            styleSpec: options2.styleSpec
         });
     }
 }
 
-//      
 function validateExpression(options) {
     const expression = (options.expressionContext === 'property' ? createPropertyExpression : createExpression)(deepUnbundle(options.value), options.valueSpec);
     if (expression.result === 'error') {
@@ -18613,7 +18296,8 @@ function validateExpression(options) {
     return [];
 }
 function disallowedFilterParameters(e, options) {
-    const disallowedParameters = new Set([
+    const disallowedParameters = /* @__PURE__ */
+    new Set([
         'zoom',
         'feature-state',
         'pitch',
@@ -18639,7 +18323,6 @@ function disallowedFilterParameters(e, options) {
     return errors;
 }
 
-//      
 function validateBoolean(options) {
     const value = options.value;
     const key = options.key;
@@ -18650,7 +18333,6 @@ function validateBoolean(options) {
     return [];
 }
 
-//      
 function validateColor(options) {
     const key = options.key;
     const value = options.value;
@@ -18664,19 +18346,16 @@ function validateColor(options) {
     return [];
 }
 
-//      
 function validateEnum(options) {
     const key = options.key;
     const value = options.value;
     const valueSpec = options.valueSpec;
     const errors = [];
     if (Array.isArray(valueSpec.values)) {
-        // <=v7
         if (valueSpec.values.indexOf(unbundle(value)) === -1) {
             errors.push(new ValidationError(key, value, `expected one of [${ valueSpec.values.join(', ') }], ${ JSON.stringify(value) } found`));
         }
     } else {
-        // >=v8
         if (Object.keys(valueSpec.values).indexOf(unbundle(value)) === -1) {
             errors.push(new ValidationError(key, value, `expected one of [${ Object.keys(valueSpec.values).join(', ') }], ${ JSON.stringify(value) } found`));
         }
@@ -18684,10 +18363,8 @@ function validateEnum(options) {
     return errors;
 }
 
-//      
 function validateFilter(options) {
     if (isExpressionFilter(deepUnbundle(options.value))) {
-        // We default to a layerType of `fill` because that points to a non-dynamic filter definition within the style-spec.
         const layerType = options.layerType || 'fill';
         return validateExpression(extend({}, options, {
             expressionContext: 'filter',
@@ -18724,13 +18401,11 @@ function validateNonExpressionFilter(options) {
         if (value.length >= 2 && unbundle(value[1]) === '$type') {
             errors.push(new ValidationError(key, value, `"$type" cannot be use with operator "${ value[0] }"`));
         }
-    /* falls through */
     case '==':
     case '!=':
         if (value.length !== 3) {
             errors.push(new ValidationError(key, value, `filter array for operator "${ value[0] }" must have 3 elements`));
         }
-    /* falls through */
     case 'in':
     case '!in':
         if (value.length >= 2) {
@@ -18779,7 +18454,6 @@ function validateNonExpressionFilter(options) {
     return errors;
 }
 
-//      
 function validateProperty(options, propertyType) {
     const key = options.key;
     const style = options.style;
@@ -18807,7 +18481,8 @@ function validateProperty(options, propertyType) {
     let tokenMatch;
     if (getType(value) === 'string' && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = /^{([^}]+)}$/.exec(value))) {
         const example = `\`{ "type": "identity", "property": ${ tokenMatch ? JSON.stringify(tokenMatch[1]) : '"_"' } }\``;
-        return [new ValidationError(key, value, `"${ propertyKey }" does not support interpolation syntax\n` + `Use an identity property function instead: ${ example }.`)];
+        return [new ValidationError(key, value, `"${ propertyKey }" does not support interpolation syntax
+Use an identity property function instead: ${ example }.`)];
     }
     const errors = [];
     if (options.layerType === 'symbol') {
@@ -18819,7 +18494,6 @@ function validateProperty(options, propertyType) {
         }
     } else if (options.layerType === 'model' && propertyType === 'paint' && layer && layer.layout && layer.layout.hasOwnProperty('model-id')) {
         if (supportsPropertyExpression(valueSpec) && (supportsLightExpression(valueSpec) || supportsZoomExpression(valueSpec))) {
-            // Performance related style spec limitation: zoom and light expressions are not allowed for e.g. trees.
             const expression = createPropertyExpression(deepUnbundle(value), valueSpec);
             const expressionObj = expression.value.expression || expression.value._styleExpression.expression;
             if (expressionObj && !isGlobalPropertyConstant(expressionObj, ['measure-light'])) {
@@ -18835,23 +18509,21 @@ function validateProperty(options, propertyType) {
         valueSpec,
         style,
         styleSpec,
+        // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'expressionContext' does not exist in type 'ValidationOptions'.
         expressionContext: 'property',
         propertyType,
         propertyKey
     }));
 }
 
-//      
 function validatePaintProperty(options) {
     return validateProperty(options, 'paint');
 }
 
-//      
 function validateLayoutProperty(options) {
     return validateProperty(options, 'layout');
 }
 
-//      
 function validateLayer(options) {
     let errors = [];
     const layer = options.value;
@@ -18868,7 +18540,6 @@ function validateLayer(options) {
         for (let i = 0; i < options.arrayIndex; i++) {
             const otherLayer = style.layers[i];
             if (unbundle(otherLayer.id) === layerId) {
-                // $FlowFixMe[prop-missing] - id.__line__ is added dynamically during the readStyle step
                 errors.push(new ValidationError(key, layer.id, `duplicate layer id "${ layer.id }", previously used at line ${ otherLayer.id.__line__ }`));
             }
         }
@@ -18886,13 +18557,13 @@ function validateLayer(options) {
             }
         });
         let parent;
-        style.layers.forEach(layer => {
-            if (unbundle(layer.id) === ref)
-                parent = layer;
+        style.layers.forEach(layer2 => {
+            if (unbundle(layer2.id) === ref)
+                parent = layer2;
         });
         if (!parent) {
             if (typeof ref === 'string')
-                errors.push(new ValidationError(key, layer.ref, `ref layer "${ ref }" not found`));    // $FlowFixMe[prop-missing] - ref is not defined on the LayerSpecification subtypes
+                errors.push(new ValidationError(key, layer.ref, `ref layer "${ ref }" not found`));
         } else if (parent.ref) {
             errors.push(new ValidationError(key, layer.ref, 'ref cannot reference another ref layer'));
         } else {
@@ -18918,11 +18589,11 @@ function validateLayer(options) {
                     'raster',
                     'raster-particle'
                 ].includes(type)) {
-                errors.push(new ValidationError(key, layer.source, `raster-array source can only be used with layer type \'raster\'.`));
+                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 === 'raster-particle' && sourceType !== 'raster-array') {
-                errors.push(new ValidationError(key, layer.source, `layer "${ layer.id }" requires a \'raster-array\' source.`));
+                errors.push(new ValidationError(key, layer.source, `layer "${ layer.id }" requires a 'raster-array' source.`));
             }
         }
     }
@@ -18945,42 +18616,45 @@ function validateLayer(options) {
                     valueSpec: styleSpec.layer.type,
                     style: options.style,
                     styleSpec: options.styleSpec,
+                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'object' does not exist in type 'ValidationOptions'.
                     object: layer,
                     objectKey: 'type'
                 });
             },
-            filter(options) {
-                return validateFilter(extend({ layerType: type }, options));
+            filter(options2) {
+                return validateFilter(extend({ layerType: type }, options2));
             },
-            layout(options) {
+            layout(options2) {
                 return validateObject({
+                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                     layer,
-                    key: options.key,
-                    value: options.value,
+                    key: options2.key,
+                    value: options2.value,
                     valueSpec: {},
-                    style: options.style,
-                    styleSpec: options.styleSpec,
+                    style: options2.style,
+                    styleSpec: options2.styleSpec,
                     objectElementValidators: {
-                        '*'(options) {
-                            return validateLayoutProperty(extend({ layerType: type }, options));
+                        '*'(options3) {
+                            return validateLayoutProperty(extend({ layerType: type }, options3));
                         }
                     }
                 });
             },
-            paint(options) {
+            paint(options2) {
                 return validateObject({
+                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                     layer,
-                    key: options.key,
-                    value: options.value,
+                    key: options2.key,
+                    value: options2.value,
                     valueSpec: {},
-                    style: options.style,
-                    styleSpec: options.styleSpec,
+                    style: options2.style,
+                    styleSpec: options2.styleSpec,
                     objectElementValidators: {
-                        '*'(options) {
+                        '*'(options3) {
                             return validatePaintProperty(extend({
                                 layerType: type,
                                 layer
-                            }, options));
+                            }, options3));
                         }
                     }
                 });
@@ -18990,7 +18664,6 @@ function validateLayer(options) {
     return errors;
 }
 
-//      
 function validateString(options) {
     const value = options.value;
     const key = options.key;
@@ -19001,7 +18674,6 @@ function validateString(options) {
     return [];
 }
 
-//      
 const objectElementValidators = { promoteId: validatePromoteId };
 function validateSource(options) {
     const value = options.value;
@@ -19125,12 +18797,10 @@ function validatePromoteId({key, value}) {
     }
 }
 
-//      
-// Allow any URL, use dummy base, if it's a relative URL
 function isValidUrl(str, allowRelativeUrls) {
     const isRelative = str.indexOf('://') === -1;
     try {
-        new URL(str, isRelative && allowRelativeUrls ? 'http://example.com' : undefined);
+        new URL(str, isRelative && allowRelativeUrls ? 'http://example.com' : void 0);
         return true;
     } catch (_) {
         return false;
@@ -19153,7 +18823,6 @@ function validateModel(options) {
     return errors;
 }
 
-//      
 function validateLight(options) {
     const light = options.value;
     const styleSpec = options.styleSpec;
@@ -19161,7 +18830,7 @@ function validateLight(options) {
     const style = options.style;
     let errors = [];
     const rootType = getType(light);
-    if (light === undefined) {
+    if (light === void 0) {
         return errors;
     } else if (rootType !== 'object') {
         errors = errors.concat([new ValidationError('light', light, `object expected, ${ rootType } found`)]);
@@ -19192,7 +18861,6 @@ function validateLight(options) {
     return errors;
 }
 
-//      
 function validateLights(options) {
     const light = options.value;
     let errors = [];
@@ -19209,21 +18877,20 @@ function validateLights(options) {
     const key = options.key;
     const style = options.style;
     const lights = options.style.lights;
-    for (const key of [
+    for (const key2 of [
             'type',
             'id'
         ]) {
-        if (!(key in light)) {
-            errors = errors.concat([new ValidationError('light-3d', light, `missing property ${ key } on light`)]);
+        if (!(key2 in light)) {
+            errors = errors.concat([new ValidationError('light-3d', light, `missing property ${ key2 } on light`)]);
             return errors;
         }
     }
     if (light.type && lights) {
         for (let i = 0; i < options.arrayIndex; i++) {
-            const lightType = unbundle(light.type);
+            const lightType2 = unbundle(light.type);
             const otherLight = lights[i];
-            if (unbundle(otherLight.type) === lightType) {
-                // $FlowFixMe[prop-missing] - id.__line__ is added dynamically during the readStyle step
+            if (unbundle(otherLight.type) === lightType2) {
                 errors.push(new ValidationError(key, light.id, `duplicate light type "${ light.type }", previously defined at line ${ otherLight.id.__line__ }`));
             }
         }
@@ -19234,9 +18901,9 @@ function validateLights(options) {
         return errors;
     }
     const lightPropertySpec = styleSpec[lightType];
-    for (const key in light) {
-        if (key === 'properties') {
-            const properties = light[key];
+    for (const key2 in light) {
+        if (key2 === 'properties') {
+            const properties = light[key2];
             const propertiesType = getType(properties);
             if (propertiesType !== 'object') {
                 errors = errors.concat([new ValidationError('properties', properties, `object expected, ${ propertiesType } found`)]);
@@ -19256,32 +18923,31 @@ function validateLights(options) {
                 }
             }
         } else {
-            const transitionMatch = key.match(/^(.*)-transition$/);
+            const transitionMatch = key2.match(/^(.*)-transition$/);
             if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
                 errors = errors.concat(validate({
-                    key,
-                    value: light[key],
+                    key: key2,
+                    value: light[key2],
                     valueSpec: styleSpec.transition,
                     style,
                     styleSpec
                 }));
-            } else if (lightSpec[key]) {
+            } else if (lightSpec[key2]) {
                 errors = errors.concat(validate({
-                    key,
-                    value: light[key],
-                    valueSpec: lightSpec[key],
+                    key: key2,
+                    value: light[key2],
+                    valueSpec: lightSpec[key2],
                     style,
                     styleSpec
                 }));
             } else {
-                errors = errors.concat([new ValidationWarning(key, light[key], `unknown property "${ key }"`)]);
+                errors = errors.concat([new ValidationWarning(key2, light[key2], `unknown property "${ key2 }"`)]);
             }
         }
     }
     return errors;
 }
 
-//      
 function validateTerrain(options) {
     const terrain = options.value;
     const key = options.key;
@@ -19290,7 +18956,7 @@ function validateTerrain(options) {
     const terrainSpec = styleSpec.terrain;
     let errors = [];
     const rootType = getType(terrain);
-    if (terrain === undefined) {
+    if (terrain === void 0) {
         return errors;
     } else if (rootType === 'null') {
         return errors;
@@ -19298,26 +18964,26 @@ function validateTerrain(options) {
         errors = errors.concat([new ValidationError('terrain', terrain, `object expected, ${ rootType } found`)]);
         return errors;
     }
-    for (const key in terrain) {
-        const transitionMatch = key.match(/^(.*)-transition$/);
+    for (const key2 in terrain) {
+        const transitionMatch = key2.match(/^(.*)-transition$/);
         if (transitionMatch && terrainSpec[transitionMatch[1]] && terrainSpec[transitionMatch[1]].transition) {
             errors = errors.concat(validate({
-                key,
-                value: terrain[key],
+                key: key2,
+                value: terrain[key2],
                 valueSpec: styleSpec.transition,
                 style,
                 styleSpec
             }));
-        } else if (terrainSpec[key]) {
+        } else if (terrainSpec[key2]) {
             errors = errors.concat(validate({
-                key,
-                value: terrain[key],
-                valueSpec: terrainSpec[key],
+                key: key2,
+                value: terrain[key2],
+                valueSpec: terrainSpec[key2],
                 style,
                 styleSpec
             }));
         } else {
-            errors = errors.concat([new ValidationWarning(key, terrain[key], `unknown property "${ key }"`)]);
+            errors = errors.concat([new ValidationWarning(key2, terrain[key2], `unknown property "${ key2 }"`)]);
         }
     }
     if (!terrain.source) {
@@ -19334,7 +19000,6 @@ function validateTerrain(options) {
     return errors;
 }
 
-//      
 function validateFog(options) {
     const fog = options.value;
     const style = options.style;
@@ -19342,7 +19007,7 @@ function validateFog(options) {
     const fogSpec = styleSpec.fog;
     let errors = [];
     const rootType = getType(fog);
-    if (fog === undefined) {
+    if (fog === void 0) {
         return errors;
     } else if (rootType !== 'object') {
         errors = errors.concat([new ValidationError('fog', fog, `object expected, ${ rootType } found`)]);
@@ -19373,7 +19038,6 @@ function validateFog(options) {
     return errors;
 }
 
-//      
 function validateFormatted(options) {
     if (validateString(options).length === 0) {
         return [];
@@ -19381,7 +19045,6 @@ function validateFormatted(options) {
     return validateExpression(options);
 }
 
-//      
 function validateImage(options) {
     if (validateString(options).length === 0) {
         return [];
@@ -19389,7 +19052,6 @@ function validateImage(options) {
     return validateExpression(options);
 }
 
-//      
 function validateProjection(options) {
     const projection = options.value;
     const styleSpec = options.styleSpec;
@@ -19413,7 +19075,6 @@ function validateProjection(options) {
     return errors;
 }
 
-//      
 const VALIDATORS = {
     '*'() {
         return [];
@@ -19439,15 +19100,6 @@ const VALIDATORS = {
     'projection': validateProjection,
     'import': validateImport
 };
-// Main recursive validation function. Tracks:
-//
-// - key: string representing location of validation in style tree. Used only
-//   for more informative error reporting.
-// - value: current value from style being evaluated. May be anything from a
-//   high level object that needs to be descended into deeper or a simple
-//   scalar value.
-// - valueSpec: current spec being evaluated. Tracks value.
-// - styleSpec: current full spec being evaluated.
 function validate(options, arrayAsExpression = false) {
     const value = options.value;
     const valueSpec = options.valueSpec;
@@ -19459,7 +19111,6 @@ function validate(options, arrayAsExpression = false) {
     } else if (valueSpec.type && VALIDATORS[valueSpec.type]) {
         const valid = VALIDATORS[valueSpec.type](options);
         if (arrayAsExpression === true && valid.length > 0 && getType(options.value) === 'array') {
-            // Try to validate as an expression
             return validateExpression(options);
         } else {
             return valid;
@@ -19470,7 +19121,6 @@ function validate(options, arrayAsExpression = false) {
     }
 }
 
-//      
 function validateGlyphsURL (options) {
     const value = options.value;
     const key = options.key;
@@ -19486,7 +19136,6 @@ function validateGlyphsURL (options) {
     return errors;
 }
 
-//      
 function validateStyle$2(style, styleSpec = v8, options = {}) {
     const errors = validate({
         key: options.key || '',
@@ -19494,6 +19143,7 @@ function validateStyle$2(style, styleSpec = v8, options = {}) {
         valueSpec: styleSpec.$root,
         styleSpec,
         style,
+        // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'objectElementValidators' does not exist in type 'ValidationOptions'.
         objectElementValidators: {
             glyphs: validateGlyphsURL,
             '*': () => []
@@ -19502,22 +19152,6 @@ function validateStyle$2(style, styleSpec = v8, options = {}) {
     return errors;
 }
 
-//      
-/**
- * Validate a Mapbox GL style against the style specification. This entrypoint,
- * `mapbox-gl-style-spec/lib/validate_style.min`, is designed to produce as
- * small a browserify bundle as possible by omitting unnecessary functionality
- * and legacy style specifications.
- *
- * @private
- * @param {Object} style The style to be validated.
- * @param {Object} [styleSpec] The style specification to validate against.
- *     If omitted, the latest style spec is used.
- * @returns {Array<ValidationError>}
- * @example
- *   var validate = require('mapbox-gl-style-spec/lib/validate_style.min');
- *   var errors = validate(style);
- */
 function validateStyle$1(style, styleSpec = v8) {
     const errors = validateStyle$2(style, styleSpec);
     return sortErrors(errors);
@@ -20588,9 +20222,8 @@ var jsonlint$1 = {};
 
 var jsonlint = /*@__PURE__*/getDefaultExportFromCjs(jsonlint$1);
 
-//        
 function readStyle(style) {
-    if (style instanceof String || typeof style === 'string' || style instanceof Buffer) {
+    if (style instanceof String || typeof style === 'string' || ArrayBuffer.isView(style)) {
         try {
             return jsonlint.parse(style.toString());
         } catch (e) {
@@ -20600,22 +20233,6 @@ function readStyle(style) {
     return style;
 }
 
-//      
-/**
- * Validate a Mapbox GL style against the style specification.
- *
- * @private
- * @alias validate
- * @param {Object|String|Buffer} style The style to be validated. If a `String`
- *     or `Buffer` is provided, the returned errors will contain line numbers.
- * @param {Object} [styleSpec] The style specification to validate against.
- *     If omitted, the spec version is inferred from the stylesheet.
- * @returns {Array<ValidationError|ParsingError>}
- * @example
- *   var validate = require('mapbox-gl-style-spec').validate;
- *   var style = fs.readFileSync('./style.json', 'utf8');
- *   var errors = validate(style);
- */
 function validateStyle(style, styleSpec = v8) {
     let s = style;
     try {
@@ -20626,7 +20243,6 @@ function validateStyle(style, styleSpec = v8) {
     return validateStyle$1(s, styleSpec);
 }
 
-//      
 const SUPPORTED_SPEC_VERSION = 8;
 const MAX_SOURCES_IN_STYLE = 15;
 function isValid(value, regex) {
@@ -20652,7 +20268,8 @@ function getAllowedKeyErrors(obj, keys, path) {
     });
     return errors;
 }
-const acceptedSourceTypes = new Set([
+const acceptedSourceTypes = /* @__PURE__ */
+new Set([
     'vector',
     'raster',
     'raster-dem',
@@ -20662,28 +20279,15 @@ const acceptedSourceTypes = new Set([
 ]);
 function getSourceErrors(source, i) {
     const errors = [];
-    /*
-     * Inlined sources are not supported by the Mapbox Styles API, so only
-     * "type", "url", and "tileSize" properties are valid
-     */
     const sourceKeys = [
         'type',
         'url',
         'tileSize'
     ];
     errors.push(...getAllowedKeyErrors(source, sourceKeys, 'source'));
-    /*
-     * "type" is required and must be one of "vector", "raster", "raster-dem", "raster-array"
-     */
     if (!acceptedSourceTypes.has(String(source.type))) {
         errors.push(new ValidationError(`sources[${ i }].type`, source.type, `Expected one of [${ Array.from(acceptedSourceTypes).join(', ') }]`));
     }
-    /*
-     * "source" is required. Valid examples:
-     * mapbox://mapbox.abcd1234
-     * mapbox://penny.abcd1234
-     * mapbox://mapbox.abcd1234,penny.abcd1234
-     */
     const sourceUrlPattern = /^mapbox:\/\/([^/]*)$/;
     if (!source.url || !isValid(source.url, sourceUrlPattern)) {
         errors.push(new ValidationError(`sources[${ i }].url`, source.url, 'Expected a valid Mapbox tileset url'));
@@ -20702,7 +20306,6 @@ function getSourcesErrors(sources) {
     let sourcesCount = 0;
     Object.keys(sources).forEach((s, i) => {
         const sourceErrors = getSourceErrors(sources[s], i);
-        // If source has errors, skip counting
         if (!sourceErrors.length) {
             sourcesCount = sourcesCount + getSourceCount(sources[s]);
         }
@@ -20716,8 +20319,8 @@ function getSourcesErrors(sources) {
 function getImportErrors(imports = []) {
     let errors = [];
     let sourcesCount = 0;
-    const validateImports = (imports = []) => {
-        for (const importSpec of imports) {
+    const validateImports = (imports2 = []) => {
+        for (const importSpec of imports2) {
             const style = importSpec.data;
             if (!style)
                 continue;
@@ -20743,14 +20346,6 @@ function getImportErrors(imports = []) {
 }
 function getRootErrors(style, specKeys) {
     const errors = [];
-    /*
-     * The following keys are optional but fully managed by the Mapbox Styles
-     * API. Values on stylesheet on POST or PATCH will be ignored: "owner",
-     * "id", "cacheControl", "draft", "created", "modified", "protected"
-     *
-     * The following keys are optional. The Mapbox Styles API respects value on
-     * stylesheet on PATCH, but ignores the value on POST: "visibility"
-     */
     const optionalRootProperties = [
         'owner',
         'id',
@@ -20771,49 +20366,23 @@ function getRootErrors(style, specKeys) {
     if (style.version > SUPPORTED_SPEC_VERSION || style.version < SUPPORTED_SPEC_VERSION) {
         errors.push(new ValidationError('version', style.version, `Style version must be ${ SUPPORTED_SPEC_VERSION }`));
     }
-    /*
-     * "glyphs" is optional. If present, valid examples:
-     * mapbox://fonts/penny/{fontstack}/{range}.pbf
-     * mapbox://fonts/mapbox/{fontstack}/{range}.pbf
-     */
     const glyphUrlPattern = /^mapbox:\/\/fonts\/([^/]*)\/{fontstack}\/{range}.pbf$/;
     if (!isValid(style.glyphs, glyphUrlPattern)) {
         errors.push(new ValidationError('glyphs', style.glyphs, 'Styles must reference glyphs hosted by Mapbox'));
     }
-    /*
-     * "sprite" is optional. If present, valid examples:
-     * mapbox://sprites/penny/abcd1234
-     * mapbox://sprites/mapbox/abcd1234/draft
-     * mapbox://sprites/cyrus/abcd1234/abcd1234
-     */
     const spriteUrlPattern = /^mapbox:\/\/sprites\/([^/]*)\/([^/]*)\/?([^/]*)?$/;
     if (!isValid(style.sprite, spriteUrlPattern)) {
         errors.push(new ValidationError('sprite', style.sprite, 'Styles must reference sprites hosted by Mapbox'));
     }
-    /*
-     * "visibility" is optional. If present, valid examples:
-     * "private"
-     * "public"
-     */
     const visibilityPattern = /^(public|private)$/;
     if (!isValid(style.visibility, visibilityPattern)) {
         errors.push(new ValidationError('visibility', style.visibility, 'Style visibility must be public or private'));
     }
-    if (style.protected !== undefined && getType(style.protected) !== 'boolean') {
+    if (style.protected !== void 0 && getType(style.protected) !== 'boolean') {
         errors.push(new ValidationError('protected', style.protected, 'Style protection must be true or false'));
     }
     return errors;
 }
-/**
- * Validate a Mapbox GL style against the style specification and check for
- * compatibility with the Mapbox Styles API.
- *
- * @param {Object} style The style to be validated.
- * @returns {Array<ValidationError>}
- * @example
- *   var validateMapboxApiSupported = require('mapbox-gl-style-spec/lib/validate_style_mapbox_api_supported.js');
- *   var errors = validateMapboxApiSupported(style);
- */
 function validateMapboxApiSupported(style, styleSpec = v8) {
     let s = style;
     try {
@@ -20837,7 +20406,6 @@ function validateMapboxApiSupported(style, styleSpec = v8) {
     return errors;
 }
 
-//      
 const expression = {
     StyleExpression,
     isExpression,
@@ -20860,5 +20428,5 @@ const visit = {
     eachProperty
 };
 
-export { Color$1 as Color, ParsingError, ValidationError, composite, convertFilter, derefLayers, diffStyles as diff, expression, createFilter as featureFilter, format, styleFunction as function, v8 as latest, migrate, v8, validateStyle as validate, validateMapboxApiSupported, visit };
+export { Color, ParsingError, ValidationError, composite, convertFilter, derefLayers, diffStyles as diff, expression, createFilter as featureFilter, format, styleFunction as function, v8 as latest, migrate, v8, validateStyle as validate, validateMapboxApiSupported, visit };
 //# sourceMappingURL=index.es.js.map