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

package/dist/index.cjs

@@ -117,6 +117,10 @@
   		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",
@@ -233,6 +237,10 @@
   	"default": {
   		type: "*",
   		doc: "Default configuration value for this option.",
+  		"property-type": "data-constant",
+  		expression: {
+  			interpolated: false
+  		},
   		required: true
   	},
   	type: {
@@ -816,6 +824,7 @@
   	}
   };
   var source_raster_array = {
+  	experimental: true,
   	type: {
   		required: true,
   		type: "enum",
@@ -1149,6 +1158,7 @@
   				}
   			},
   			"raster-particle": {
+  				experimental: true,
   				doc: "Particle animation driven by textures such as wind maps.",
   				"sdk-support": {
   					"basic functionality": {
@@ -1170,6 +1180,7 @@
   			},
   			model: {
   				doc: "A 3D model",
+  				experimental: true,
   				"sdk-support": {
   					"basic functionality": {
   						js: "3.0.0",
@@ -1207,6 +1218,17 @@
   						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.",
@@ -1261,6 +1283,7 @@
   	}
   };
   var layout = [
+  	"layout_clip",
   	"layout_fill",
   	"layout_line",
   	"layout_circle",
@@ -1396,6 +1419,35 @@
   		]
   	}
   };
+  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",
@@ -1688,6 +1740,32 @@
   		},
   		"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: {
@@ -4644,6 +4722,17 @@
   		"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",
@@ -4902,6 +4991,7 @@
   	"paint_fill-extrusion",
   	"paint_symbol",
   	"paint_raster",
+  	"paint_raster-particle",
   	"paint_hillshade",
   	"paint_background",
   	"paint_sky",
@@ -5484,7 +5574,7 @@
   	"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,
@@ -5516,6 +5606,81 @@
   		},
   		"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,
@@ -5598,6 +5763,29 @@
   			]
   		},
   		"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 = {
@@ -6122,6 +6310,39 @@
   		},
   		"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,
@@ -6438,6 +6659,39 @@
   		},
   		"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.",
@@ -7000,6 +7254,7 @@
   	"raster-array-band": {
   		type: "string",
   		required: false,
+  		experimental: true,
   		"property-type": "data-constant",
   		transition: false,
   		requires: [
@@ -7023,6 +7278,7 @@
   		"default": 0,
   		minimum: 0,
   		transition: true,
+  		experimental: true,
   		"sdk-support": {
   			"basic functionality": {
   				js: "3.1.0",
@@ -8069,6 +8325,7 @@
   	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,
@@ -8104,6 +8361,7 @@
   	},
   	"fill-extrusion-edge-radius": {
   		type: "number",
+  		experimental: true,
   		"private": true,
   		"default": 0,
   		minimum: 0,
@@ -8251,6 +8509,7 @@
   	expression_name: expression_name,
   	fog: fog,
   	camera: camera,
+  	colorTheme: colorTheme,
   	light: light,
   	projection: projection,
   	terrain: terrain,
@@ -8525,6 +8784,7 @@
   	"fill-extrusion-ambient-occlusion-wall-radius": {
   		"property-type": "data-constant",
   		type: "number",
+  		experimental: true,
   		"default": 3,
   		minimum: 0,
   		expression: {
@@ -8550,6 +8810,7 @@
   	"fill-extrusion-ambient-occlusion-ground-radius": {
   		"property-type": "data-constant",
   		type: "number",
+  		experimental: true,
   		"default": 3,
   		minimum: 0,
   		expression: {
@@ -8574,6 +8835,7 @@
   	"fill-extrusion-ambient-occlusion-ground-attenuation": {
   		"property-type": "data-constant",
   		type: "number",
+  		experimental: true,
   		"default": 0.69,
   		minimum: 0,
   		maximum: 1,
@@ -8599,6 +8861,7 @@
   	"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: [
@@ -8623,6 +8886,7 @@
   	"fill-extrusion-flood-light-intensity": {
   		"property-type": "data-constant",
   		type: "number",
+  		experimental: true,
   		"default": 0,
   		minimum: 0,
   		maximum: 1,
@@ -8649,6 +8913,7 @@
   	"fill-extrusion-flood-light-wall-radius": {
   		"property-type": "data-driven",
   		type: "number",
+  		experimental: true,
   		units: "meters",
   		"default": 0,
   		minimum: 0,
@@ -8680,6 +8945,7 @@
   	"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.",
@@ -8710,6 +8976,7 @@
   	"fill-extrusion-flood-light-ground-attenuation": {
   		"property-type": "data-constant",
   		type: "number",
+  		experimental: true,
   		"default": 0.69,
   		minimum: 0,
   		maximum: 1,
@@ -8735,6 +9002,7 @@
   	"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.",
@@ -8757,6 +9025,7 @@
   		"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"
@@ -9050,42 +9319,20 @@
       }(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) {
@@ -9094,7 +9341,6 @@
       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]]) {
@@ -9122,7 +9368,7 @@
   }
   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)
@@ -9153,7 +9399,6 @@
       });
   }
 
-  //        
   function eachLayout(layer, callback) {
       for (const k in layer) {
           if (k.indexOf('layout') === 0) {
@@ -9184,9 +9429,8 @@
   }
   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') {
@@ -9197,23 +9441,22 @@
       });
       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
@@ -9228,9 +9471,6 @@
       });
       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'];
@@ -9282,7 +9522,6 @@
               });
           }
           if (Array.isArray(font)) {
-              // Assume it's a previously migrated font-array.
               return font;
           } else if (typeof font === 'string') {
               return splitAndTrim(font);
@@ -9302,18 +9541,6 @@
               }
           });
       });
-      // 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];
@@ -9328,7 +9555,6 @@
       return style;
   }
 
-  //      
   function extend (output, ...inputs) {
       for (const input of inputs) {
           for (const k in input) {
@@ -9338,7 +9564,6 @@
       return output;
   }
 
-  //      
   let ParsingError$1 = class ParsingError extends Error {
       constructor(key, message) {
           super(message);
@@ -9347,11 +9572,6 @@
       }
   };
 
-  //      
-  /**
-   * Tracks `let` bindings during expression parsing.
-   * @private
-   */
   class Scope {
       constructor(parent, bindings = []) {
           this.parent = parent;
@@ -9379,7 +9599,6 @@
       }
   }
 
-  //      
   const NullType = { kind: 'null' };
   const NumberType = { kind: 'number' };
   const StringType = { kind: 'string' };
@@ -9417,14 +9636,8 @@
       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)) {
@@ -10508,18 +10721,25 @@
   } 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;
@@ -10528,44 +10748,99 @@
           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 ? [
@@ -10581,10 +10856,10 @@
           ];
       }
       /**
-       * 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 ? [
@@ -10600,11 +10875,11 @@
           ];
       }
       /**
-       * 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 ? [
@@ -10618,10 +10893,10 @@
           ];
       }
       /**
-       * 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 [
@@ -10632,11 +10907,11 @@
           ];
       }
       /**
-       * 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 ? [
@@ -10657,9 +10932,7 @@
   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)
@@ -10676,16 +10949,12 @@
           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;
@@ -10739,7 +11008,7 @@
                   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);
           }
@@ -10747,7 +11016,6 @@
       }
   }
 
-  //      
   class ResolvedImage {
       constructor(options) {
           this.namePrimary = options.namePrimary;
@@ -10765,7 +11033,6 @@
       static fromString(namePrimary, nameSecondary) {
           if (!namePrimary)
               return null;
-          // treat empty values as no image
           return new ResolvedImage({
               namePrimary,
               nameSecondary,
@@ -10857,7 +11124,7 @@
           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;
@@ -10892,7 +11159,7 @@
           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;
@@ -10925,7 +11192,7 @@
           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);
@@ -10944,7 +11211,6 @@
               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;
@@ -10965,13 +11231,9 @@
                   '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;
@@ -10979,7 +11241,6 @@
       }
   }
 
-  //      
   class RuntimeError {
       constructor(message) {
           this.name = 'ExpressionEvaluationError';
@@ -11010,10 +11271,10 @@
           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;
@@ -11074,7 +11335,6 @@
       }
   }
 
-  //      
   class FormatExpression {
       constructor(sections) {
           this.type = FormattedType;
@@ -11159,8 +11419,6 @@
           }
       }
       outputDefined() {
-          // Technically the combinatoric set of all children
-          // Usually, this.text will be undefined anyway
           return false;
       }
       serialize() {
@@ -11183,7 +11441,6 @@
       }
   }
 
-  //      
   class ImageExpression {
       constructor(inputPrimary, inputSecondary) {
           this.type = ResolvedImageType;
@@ -11206,10 +11463,9 @@
           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;
               }
@@ -11223,12 +11479,10 @@
           }
       }
       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(),
@@ -11242,7 +11496,6 @@
       }
   }
 
-  //      
   function getType(val) {
       if (val instanceof Number) {
           return 'number';
@@ -11265,13 +11518,6 @@
       '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;
@@ -11301,11 +11547,10 @@
                   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) {
@@ -11313,7 +11558,7 @@
                       }
                       parsedMember = context.registry['literal'].parse([
                           'literal',
-                          member === undefined ? null : member
+                          member === void 0 ? null : member
                       ], context);
                   }
                   if (!parsedMember)
@@ -11342,7 +11587,7 @@
               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);
@@ -11355,7 +11600,7 @@
                           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]);
                       }
                   }
               }
@@ -11373,8 +11618,6 @@
               }
               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)));
@@ -11412,7 +11655,6 @@
       }
   }
 
-  //      
   const geometryTypes = [
       'Unknown',
       'Point',
@@ -11434,7 +11676,7 @@
           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;
@@ -11456,13 +11698,10 @@
               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;
           }
@@ -11471,7 +11710,7 @@
       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;
       }
@@ -11480,7 +11719,6 @@
       }
   }
 
-  //      
   class CompoundExpression {
       constructor(name, type, evaluate, args, overloadIndex) {
           this.name = name;
@@ -11491,7 +11729,6 @@
       }
       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];
           }
@@ -11512,7 +11749,6 @@
           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],
@@ -11524,19 +11760,15 @@
           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;
@@ -11545,8 +11777,6 @@
                   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)) {
@@ -11570,8 +11800,6 @@
               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)
@@ -11585,7 +11813,6 @@
       static register(registry, definitions) {
           CompoundExpression.definitions = definitions;
           for (const name in definitions) {
-              // $FlowFixMe[method-unbinding]
               registry[name] = CompoundExpression;
           }
       }
@@ -11598,7 +11825,6 @@
       }
   }
 
-  //      
   class CollatorExpression {
       constructor(caseSensitive, diacriticSensitive, locale) {
           this.type = CollatorType;
@@ -11612,10 +11838,10 @@
           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;
@@ -11637,10 +11863,6 @@
           }
       }
       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() {
@@ -11657,13 +11879,6 @@
       }
   }
 
-  //      
-  // 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++) {
@@ -11673,7 +11888,6 @@
       }
       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)
@@ -11685,7 +11899,7 @@
           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)
@@ -11726,7 +11940,6 @@
   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++) {
@@ -11745,9 +11958,7 @@
   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];
@@ -11760,11 +11971,7 @@
           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]
@@ -11775,15 +11982,11 @@
       ];
       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;
@@ -11809,7 +12012,6 @@
   }
   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];
@@ -11821,13 +12023,11 @@
       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;
@@ -12060,7 +12260,6 @@
       }
   }
 
-  /*       */
   const factors = {
       kilometers: 1,
       miles: 1000 / 1609.344,
@@ -12080,13 +12279,6 @@
   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 {
       /**
@@ -12094,7 +12286,7 @@
        *
        * @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);
@@ -12119,8 +12311,7 @@
        * 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
@@ -12143,8 +12334,8 @@
       /**
        * 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]);
@@ -12158,8 +12349,8 @@
       /**
        * 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]);
@@ -12173,10 +12364,10 @@
       /**
        * 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
@@ -12188,10 +12379,10 @@
       /**
        * 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
@@ -12205,7 +12396,7 @@
       /**
        * 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([
@@ -12224,7 +12415,7 @@
       /**
        * 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([[
@@ -12246,9 +12437,9 @@
       /**
        * 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
@@ -12263,7 +12454,7 @@
               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];
       }
@@ -12271,9 +12462,9 @@
        * 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]);
@@ -12283,9 +12474,8 @@
           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];
@@ -12303,16 +12493,19 @@
        * 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];
@@ -12352,10 +12545,10 @@
       /**
        * 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
@@ -12383,10 +12576,10 @@
       /**
        * 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
@@ -12400,10 +12593,10 @@
               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)
@@ -12414,9 +12607,9 @@
       /**
        * 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
@@ -12434,9 +12627,9 @@
       /**
        * 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
@@ -12454,21 +12647,32 @@
       /**
        * 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 [
@@ -12476,7 +12680,10 @@
           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;
@@ -12841,26 +13048,8 @@
       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;
   }
@@ -12893,9 +13082,6 @@
       }
       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 [
@@ -12973,28 +13159,21 @@
       }
       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];
       }
@@ -13042,10 +13221,13 @@
       }
       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) {
@@ -13153,7 +13335,6 @@
       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,
@@ -13161,8 +13342,6 @@
               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)
@@ -13186,7 +13365,6 @@
           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;
@@ -13255,7 +13433,6 @@
               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;
@@ -13294,7 +13471,7 @@
                   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;
       }
@@ -13339,13 +13516,13 @@
       }
       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;
   }
@@ -13360,12 +13537,12 @@
       }
       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)
@@ -13376,7 +13553,7 @@
       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)
@@ -13397,12 +13574,12 @@
       }
       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)
@@ -13478,7 +13655,6 @@
       }
   }
 
-  //      
   function coerceValue(type, value) {
       switch (type) {
       case 'string':
@@ -13488,7 +13664,7 @@
       case 'boolean':
           return !!value;
       case 'color':
-          return Color$1.parse(value);
+          return Color.parse(value);
       case 'formatted': {
               return Formatted.fromString(toString(value));
           }
@@ -13499,13 +13675,13 @@
       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;
@@ -13518,7 +13694,7 @@
       }
       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) {
@@ -13551,7 +13727,6 @@
           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);
@@ -13560,21 +13735,20 @@
           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;
@@ -13596,7 +13770,6 @@
       }
   }
 
-  //      
   function isFeatureConstant(e) {
       if (e instanceof CompoundExpression) {
           if (e.name === 'get' && e.args.length === 1) {
@@ -13664,7 +13837,6 @@
       return result;
   }
 
-  //      
   class Var {
       constructor(name, boundExpression) {
           this.type = boundExpression.type;
@@ -13696,16 +13868,7 @@
       }
   }
 
-  //      
-  /**
-   * 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;
@@ -13717,12 +13880,12 @@
           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);
@@ -13749,7 +13912,7 @@
               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)
@@ -13757,14 +13920,6 @@
                   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')) {
@@ -13773,10 +13928,6 @@
                           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 {
@@ -13788,7 +13939,6 @@
                   }
                   return parsed;
               }
-              // Try to parse as array
               return Coercion.parse([
                   'to-array',
                   expr
@@ -13802,33 +13952,33 @@
           }
       }
       /**
-       * 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)
@@ -13836,15 +13986,13 @@
           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;
@@ -13856,12 +14004,6 @@
       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 {
@@ -13886,11 +14028,6 @@
       ]);
   }
 
-  //      
-  /**
-   * 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;
@@ -13903,7 +14040,6 @@
           nextValue = stops[currentIndex + 1];
           if (currentValue <= input) {
               if (currentIndex === lastIndex || input < nextValue) {
-                  // Search complete
                   return currentIndex;
               }
               lowerIndex = currentIndex + 1;
@@ -13916,7 +14052,6 @@
       return 0;
   }
 
-  //      
   class Step {
       constructor(type, input, stops) {
           this.type = type;
@@ -14073,32 +14208,7 @@
 
   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;
   }
@@ -14112,7 +14222,6 @@
       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 {
@@ -14127,7 +14236,7 @@
       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) {
@@ -14138,7 +14247,6 @@
           alpha: number(from.alpha, to.alpha, t)
       };
   }
-  // HCL
   function rgbToHcl(rgbColor) {
       const {l, a, b} = rgbToLab(rgbColor);
       const h = Math.atan2(b, a) * rad2deg;
@@ -14187,7 +14295,6 @@
     lab: lab
   });
 
-  //      
   class Interpolate {
       constructor(type, operator, interpolation, input, stops) {
           this.type = type;
@@ -14236,7 +14343,7 @@
               }
               interpolation = {
                   name: 'cubic-bezier',
-                  controlPoints: controlPoints
+                  controlPoints
               };
           } else {
               return context.error(`Unknown interpolation type ${ String(interpolation[0]) }`, 1, 0);
@@ -14303,7 +14410,7 @@
           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 {
@@ -14346,41 +14453,6 @@
           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;
@@ -14409,17 +14481,12 @@
           }
           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);
       }
@@ -14430,15 +14497,11 @@
           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;
                   }
@@ -14463,7 +14526,6 @@
       }
   }
 
-  //      
   class Let {
       constructor(bindings, result) {
           this.type = result.type;
@@ -14517,7 +14579,6 @@
       }
   }
 
-  //      
   class At {
       constructor(type, index, input) {
           this.type = type;
@@ -14536,17 +14597,17 @@
       }
       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);
@@ -14564,7 +14625,6 @@
       }
   }
 
-  //      
   class In {
       constructor(needle, haystack) {
           this.type = BooleanType;
@@ -14627,7 +14687,6 @@
       }
   }
 
-  //      
   class IndexOf {
       constructor(needle, haystack, fromIndex) {
           this.type = NumberType;
@@ -14695,7 +14754,7 @@
           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',
@@ -14712,7 +14771,6 @@
       }
   }
 
-  // Map input label values to output expression index
   class Match {
       constructor(inputType, outputType, input, cases, outputs, otherwise) {
           this.inputType = inputType;
@@ -14796,35 +14854,26 @@
               '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());
@@ -14895,7 +14944,6 @@
       }
   }
 
-  //      
   class Slice {
       constructor(type, input, beginIndex, endIndex) {
           this.type = type;
@@ -14953,7 +15001,7 @@
           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',
@@ -14970,13 +15018,10 @@
       }
   }
 
-  //      
   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';
       }
   }
@@ -15016,26 +15061,8 @@
   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;
@@ -15044,33 +15071,29 @@
               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]);
                   }
               }
@@ -15089,17 +15112,16 @@
               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);
                   }
               }
@@ -15131,12 +15153,7 @@
   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;
@@ -15191,10 +15208,10 @@
       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) {
@@ -15243,7 +15260,6 @@
       }
   }
 
-  //      
   class Length {
       constructor(input) {
           this.type = NumberType;
@@ -15284,8 +15300,6 @@
       }
   }
 
-  //      
-  // Seeded pseudo random generator function
   function mulberry32(a) {
       return function () {
           a |= 0;
@@ -15296,7 +15310,6 @@
       };
   }
 
-  //      
   const expressions = {
       // special forms
       '==': Equals,
@@ -15305,58 +15318,36 @@
       '<': 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]) {
@@ -15367,7 +15358,7 @@
       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);
@@ -15378,7 +15369,7 @@
       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;
@@ -15434,7 +15425,7 @@
           array$1(NumberType, 4),
           [ColorType],
           (ctx, [v]) => {
-              return v.evaluate(ctx).toArray();
+              return v.evaluate(ctx).toRenderColor(null).toArray();
           }
       ],
       'rgb': [
@@ -15575,7 +15566,7 @@
       'accumulated': [
           ValueType,
           [],
-          ctx => ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated
+          ctx => ctx.globals.accumulated === void 0 ? null : ctx.globals.accumulated
       ],
       '+': [
           NumberType,
@@ -15724,9 +15715,6 @@
           [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);
           }
       ],
@@ -15850,7 +15838,7 @@
       'filter-has-id': [
           BooleanType,
           [],
-          ctx => ctx.id() !== null && ctx.id() !== undefined
+          ctx => ctx.id() !== null && ctx.id() !== void 0
       ],
       'filter-type-in': [
           BooleanType,
@@ -15990,13 +15978,6 @@
       ]
   });
 
-  //      
-  /**
-   * 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',
@@ -16010,7 +15991,6 @@
       };
   }
 
-  //      
   function expressionHasParameter(expression, parameter) {
       return !!expression && !!expression.parameters && expression.parameters.indexOf(parameter) > -1;
   }
@@ -16027,7 +16007,6 @@
       return !!spec.expression && spec.expression.interpolated;
   }
 
-  //        
   function isFunction(value) {
       return typeof value === 'object' && value !== null && !Array.isArray(value);
   }
@@ -16037,7 +16016,7 @@
   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) {
@@ -16046,18 +16025,17 @@
               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;
@@ -16069,12 +16047,11 @@
           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;
@@ -16087,7 +16064,7 @@
           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,
@@ -16113,7 +16090,7 @@
           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({
@@ -16125,12 +16102,12 @@
       } 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)
           };
@@ -16138,8 +16115,8 @@
           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);
@@ -16148,20 +16125,18 @@
       }
   }
   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;
@@ -16175,8 +16150,7 @@
       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;
@@ -16190,21 +16164,18 @@
       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);
               }
@@ -16214,54 +16185,16 @@
   }
   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;
@@ -16304,8 +16237,7 @@
           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)) {
@@ -16326,19 +16258,9 @@
   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);
       }
@@ -16415,13 +16337,15 @@
           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;
@@ -16444,14 +16368,13 @@
       } 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',
@@ -16460,9 +16383,6 @@
           };
       }
   }
-  // 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) {
@@ -16507,13 +16427,10 @@
   }
   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;
@@ -16529,11 +16446,10 @@
   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') {
@@ -16560,9 +16476,7 @@
           '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
@@ -16604,7 +16518,7 @@
       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,
@@ -16619,10 +16533,6 @@
               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 = [
@@ -16649,20 +16559,14 @@
       }
   }
   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;
@@ -16706,7 +16610,7 @@
               appendStopPair(expression, stop[0], stop[1], true);
           }
           fixupDegenerateStepCurve(expression);
-          return parameters.default === undefined ? expression : [
+          return parameters.default === void 0 ? expression : [
               'case',
               [
                   '==',
@@ -16720,7 +16624,7 @@
               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'] : [
@@ -16735,7 +16639,7 @@
           for (const stop of stops) {
               appendStopPair(expression, stop[0], stop[1], false);
           }
-          return parameters.default === undefined ? expression : [
+          return parameters.default === void 0 ? expression : [
               'case',
               [
                   '==',
@@ -16763,7 +16667,7 @@
           ];
           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'] : [
@@ -16782,19 +16686,15 @@
       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);
       }
@@ -16807,7 +16707,6 @@
           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;
@@ -16836,8 +16735,6 @@
       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();
@@ -16858,7 +16755,6 @@
       return unbundle(value);
   }
 
-  //      
   function isExpressionFilter(filter) {
       if (filter === true || filter === false) {
           return true;
@@ -16894,18 +16790,8 @@
           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,
@@ -16913,7 +16799,6 @@
           };
       }
       if (!isExpressionFilter(filter)) {
-          // $FlowFixMe[incompatible-call]
           filter = convertFilter$1(filter);
       }
       const filterExp = filter;
@@ -16929,7 +16814,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;
@@ -16938,8 +16822,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) {
@@ -16947,7 +16829,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);
           }
       }
@@ -16955,7 +16837,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
       };
@@ -16964,11 +16846,8 @@ ${ JSON.stringify(filterExp, null, 2) }
       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;
   }
@@ -16983,15 +16862,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           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 = [];
@@ -17017,13 +16887,11 @@ ${ JSON.stringify(filterExp, null, 2) }
           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;
       }
@@ -17041,7 +16909,8 @@ ${ JSON.stringify(filterExp, null, 2) }
   function isRootExpressionDynamic(expression) {
       return expression === 'pitch' || expression === 'distance-from-center';
   }
-  const dynamicConditionExpressions = new Set([
+  const dynamicConditionExpressions = /* @__PURE__ */
+  new Set([
       'in',
       '==',
       '!=',
@@ -17062,7 +16931,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
       return expression;
   }
-  // Comparison function to sort numbers and strings
   function compare(a, b) {
       return a < b ? -1 : a > b ? 1 : 0;
   }
@@ -17083,7 +16951,9 @@ ${ JSON.stringify(filterExp, null, 2) }
       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) {
@@ -17172,63 +17042,9 @@ ${ JSON.stringify(filterExp, null, 2) }
       ];
   }
 
-  //      
-  /**
-   * 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;
@@ -17279,14 +17095,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
       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) {
@@ -17381,10 +17189,6 @@ ${ JSON.stringify(filterExp, null, 2) }
               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) {
@@ -17394,7 +17198,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           }
       }
       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',
@@ -17404,7 +17207,8 @@ ${ JSON.stringify(filterExp, null, 2) }
               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
@@ -17427,12 +17231,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
   }
 
-  //      
-  /**
-   * 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 => {
@@ -17447,9 +17245,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           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') {
@@ -17459,20 +17254,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       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) {
@@ -17489,7 +17270,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return style;
   }
 
-  //        
   function composite (style) {
       const styleIDs = [];
       const sourceIDs = [];
@@ -17529,7 +17309,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return style;
   }
 
-  //      
   var refProperties = [
       'type',
       'source',
@@ -17540,7 +17319,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       'layout'
   ];
 
-  //      
   function deref(layer, parent) {
       const result = {};
       for (const k in layer) {
@@ -17555,22 +17333,10 @@ ${ JSON.stringify(filterExp, null, 2) }
       });
       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];
       }
@@ -17582,12 +17348,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return layers;
   }
 
-  //      
-  /**
-   * Deeply compares two object literals.
-   *
-   * @private
-   */
   function deepEqual(a, b) {
       if (Array.isArray(a)) {
           if (!Array.isArray(b) || a.length !== b.length)
@@ -17613,119 +17373,118 @@ ${ JSON.stringify(filterExp, null, 2) }
       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) {
@@ -17770,7 +17529,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       before = before || {};
       after = after || {};
       let sourceId;
-      // look for sources to remove
       for (sourceId in before) {
           if (!before.hasOwnProperty(sourceId))
               continue;
@@ -17778,7 +17536,6 @@ ${ JSON.stringify(filterExp, null, 2) }
               removeSource(sourceId, commands, sourcesRemoved);
           }
       }
-      // look for sources to add/update
       for (sourceId in after) {
           if (!after.hasOwnProperty(sourceId))
               continue;
@@ -17795,7 +17552,6 @@ ${ JSON.stringify(filterExp, null, 2) }
                       ]
                   });
               } else {
-                  // no update command, must remove then add
                   updateSource(sourceId, after, commands, sourcesRemoved);
               }
           }
@@ -17846,18 +17602,14 @@ ${ JSON.stringify(filterExp, null, 2) }
   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)) {
@@ -17867,28 +17619,22 @@ ${ JSON.stringify(filterExp, null, 2) }
               });
               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,
@@ -17900,24 +17646,17 @@ ${ JSON.stringify(filterExp, null, 2) }
           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,
@@ -17928,7 +17667,6 @@ ${ JSON.stringify(filterExp, null, 2) }
               });
               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)) {
@@ -17959,7 +17697,6 @@ ${ JSON.stringify(filterExp, null, 2) }
                   ]
               });
           }
-          // handle all other layer props, including paint.*
           for (prop in beforeLayer) {
               if (!beforeLayer.hasOwnProperty(prop))
                   continue;
@@ -18001,16 +17738,12 @@ ${ JSON.stringify(filterExp, null, 2) }
   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)) {
@@ -18020,28 +17753,22 @@ ${ JSON.stringify(filterExp, null, 2) }
               });
               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,
@@ -18052,7 +17779,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           });
           tracker.splice(tracker.length - i, 0, importId);
       }
-      // update imports
       for (const afterImport of after) {
           const beforeImport = beforeIndex[afterImport.id];
           if (!beforeImport || deepEqual(beforeImport, afterImport))
@@ -18066,24 +17792,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           });
       }
   }
-  /**
-   * 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 [{
@@ -18092,7 +17800,6 @@ ${ JSON.stringify(filterExp, null, 2) }
               }];
       let commands = [];
       try {
-          // Handle changes to top-level properties
           if (!deepEqual(before.version, after.version)) {
               return [{
                       command: operations.setStyle,
@@ -18135,7 +17842,6 @@ ${ JSON.stringify(filterExp, null, 2) }
                   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);
           }
@@ -18175,18 +17881,15 @@ ${ JSON.stringify(filterExp, null, 2) }
                   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 => {
@@ -18200,30 +17903,25 @@ ${ JSON.stringify(filterExp, null, 2) }
                   }
               });
           }
-          // 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,
@@ -18233,14 +17931,12 @@ ${ JSON.stringify(filterExp, null, 2) }
       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__;
           }
       }
@@ -18248,8 +17944,6 @@ ${ JSON.stringify(filterExp, null, 2) }
   class ValidationWarning extends ValidationError {
   }
 
-  //      
-  // Note: Do not inherit from Error. It breaks when transpiling to ES5.
   class ParsingError {
       constructor(error) {
           this.error = error;
@@ -18259,7 +17953,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
   }
 
-  //      
   function validateObject(options) {
       const key = options.key;
       const object = options.value;
@@ -18274,7 +17967,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
       for (const objectKey in object) {
           const elementSpecKey = objectKey.split('.')[0];
-          // treat 'paint.*' as 'paint'
           const elementSpec = elementSpecs[elementSpecKey] || elementSpecs['*'];
           let validateElement;
           if (elementValidators[elementSpecKey]) {
@@ -18297,26 +17989,23 @@ ${ JSON.stringify(filterExp, null, 2) }
               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
@@ -18325,7 +18014,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           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`));
@@ -18337,7 +18025,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateArray(options) {
       const array = options.value;
       const arraySpec = options.valueSpec;
@@ -18359,7 +18046,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           'values': arraySpec.values,
           'minimum': arraySpec.minimum,
           'maximum': arraySpec.maximum,
-          function: undefined
+          function: void 0
       };
       if (styleSpec.$version < 7) {
           arrayElementSpec.function = arraySpec.function;
@@ -18382,13 +18069,11 @@ ${ JSON.stringify(filterExp, null, 2) }
       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';
       }
@@ -18418,7 +18103,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return [];
   }
 
-  //      
   function validateFunction(options) {
       const functionValueSpec = options.valueSpec;
       const functionType = unbundle(options.value.type);
@@ -18426,7 +18110,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       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({
@@ -18456,33 +18140,33 @@ ${ JSON.stringify(filterExp, null, 2) }
               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`)];
           }
@@ -18493,10 +18177,10 @@ ${ JSON.stringify(filterExp, null, 2) }
               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);
@@ -18508,86 +18192,85 @@ ${ JSON.stringify(filterExp, null, 2) }
               }
               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') {
@@ -18619,7 +18302,8 @@ ${ JSON.stringify(filterExp, null, 2) }
       return [];
   }
   function disallowedFilterParameters(e, options) {
-      const disallowedParameters = new Set([
+      const disallowedParameters = /* @__PURE__ */
+      new Set([
           'zoom',
           'feature-state',
           'pitch',
@@ -18645,7 +18329,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateBoolean(options) {
       const value = options.value;
       const key = options.key;
@@ -18656,7 +18339,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return [];
   }
 
-  //      
   function validateColor(options) {
       const key = options.key;
       const value = options.value;
@@ -18670,19 +18352,16 @@ ${ JSON.stringify(filterExp, null, 2) }
       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`));
           }
@@ -18690,10 +18369,8 @@ ${ JSON.stringify(filterExp, null, 2) }
       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',
@@ -18730,13 +18407,11 @@ ${ JSON.stringify(filterExp, null, 2) }
           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) {
@@ -18785,7 +18460,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateProperty(options, propertyType) {
       const key = options.key;
       const style = options.style;
@@ -18813,7 +18487,8 @@ ${ JSON.stringify(filterExp, null, 2) }
       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') {
@@ -18825,7 +18500,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           }
       } 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'])) {
@@ -18841,23 +18515,21 @@ ${ JSON.stringify(filterExp, null, 2) }
           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;
@@ -18874,7 +18546,6 @@ ${ JSON.stringify(filterExp, null, 2) }
           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__ }`));
               }
           }
@@ -18892,13 +18563,13 @@ ${ JSON.stringify(filterExp, null, 2) }
               }
           });
           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 {
@@ -18924,11 +18595,11 @@ ${ JSON.stringify(filterExp, null, 2) }
                       '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.`));
               }
           }
       }
@@ -18951,42 +18622,45 @@ ${ JSON.stringify(filterExp, null, 2) }
                       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));
                           }
                       }
                   });
@@ -18996,7 +18670,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateString(options) {
       const value = options.value;
       const key = options.key;
@@ -19007,7 +18680,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return [];
   }
 
-  //      
   const objectElementValidators = { promoteId: validatePromoteId };
   function validateSource(options) {
       const value = options.value;
@@ -19131,12 +18803,10 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
   }
 
-  //      
-  // 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;
@@ -19159,7 +18829,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateLight(options) {
       const light = options.value;
       const styleSpec = options.styleSpec;
@@ -19167,7 +18836,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       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`)]);
@@ -19198,7 +18867,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateLights(options) {
       const light = options.value;
       let errors = [];
@@ -19215,21 +18883,20 @@ ${ JSON.stringify(filterExp, null, 2) }
       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__ }`));
               }
           }
@@ -19240,9 +18907,9 @@ ${ JSON.stringify(filterExp, null, 2) }
           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`)]);
@@ -19262,32 +18929,31 @@ ${ JSON.stringify(filterExp, null, 2) }
                   }
               }
           } 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;
@@ -19296,7 +18962,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       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;
@@ -19304,26 +18970,26 @@ ${ JSON.stringify(filterExp, null, 2) }
           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) {
@@ -19340,7 +19006,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateFog(options) {
       const fog = options.value;
       const style = options.style;
@@ -19348,7 +19013,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       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`)]);
@@ -19379,7 +19044,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateFormatted(options) {
       if (validateString(options).length === 0) {
           return [];
@@ -19387,7 +19051,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return validateExpression(options);
   }
 
-  //      
   function validateImage(options) {
       if (validateString(options).length === 0) {
           return [];
@@ -19395,7 +19058,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return validateExpression(options);
   }
 
-  //      
   function validateProjection(options) {
       const projection = options.value;
       const styleSpec = options.styleSpec;
@@ -19419,7 +19081,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   const VALIDATORS = {
       '*'() {
           return [];
@@ -19445,15 +19106,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       '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;
@@ -19465,7 +19117,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       } 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;
@@ -19476,7 +19127,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
   }
 
-  //      
   function validateGlyphsURL (options) {
       const value = options.value;
       const key = options.key;
@@ -19492,7 +19142,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   function validateStyle$2(style, styleSpec = v8, options = {}) {
       const errors = validate({
           key: options.key || '',
@@ -19500,6 +19149,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           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,
               '*': () => []
@@ -19508,22 +19158,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       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);
@@ -20594,9 +20228,8 @@ ${ JSON.stringify(filterExp, null, 2) }
 
   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) {
@@ -20606,22 +20239,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       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 {
@@ -20632,7 +20249,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return validateStyle$1(s, styleSpec);
   }
 
-  //      
   const SUPPORTED_SPEC_VERSION = 8;
   const MAX_SOURCES_IN_STYLE = 15;
   function isValid(value, regex) {
@@ -20658,7 +20274,8 @@ ${ JSON.stringify(filterExp, null, 2) }
       });
       return errors;
   }
-  const acceptedSourceTypes = new Set([
+  const acceptedSourceTypes = /* @__PURE__ */
+  new Set([
       'vector',
       'raster',
       'raster-dem',
@@ -20668,28 +20285,15 @@ ${ JSON.stringify(filterExp, null, 2) }
   ]);
   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'));
@@ -20708,7 +20312,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       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]);
           }
@@ -20722,8 +20325,8 @@ ${ JSON.stringify(filterExp, null, 2) }
   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;
@@ -20749,14 +20352,6 @@ ${ JSON.stringify(filterExp, null, 2) }
   }
   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',
@@ -20777,49 +20372,23 @@ ${ JSON.stringify(filterExp, null, 2) }
       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 {
@@ -20843,7 +20412,6 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  //      
   const expression = {
       StyleExpression,
       isExpression,
@@ -20866,7 +20434,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       eachProperty
   };
 
-  exports.Color = Color$1;
+  exports.Color = Color;
   exports.ParsingError = ParsingError;
   exports.ValidationError = ValidationError;
   exports.composite = composite;