@mapbox/mapbox-gl-style-spec 13.24.0 → 13.25.0

package/dist/index.cjs

@@ -2,7 +2,7 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.mapboxGlStyleSpecification = {}));
-}(this, (function (exports) { 'use strict';
+})(this, (function (exports) { 'use strict';
 
   var $version = 8;
   var $root = {
@@ -68,7 +68,7 @@
   	},
   	fog: {
   		type: "fog",
-  		doc: "A global effect that fades layers and markers based on their distance to the camera. The fog can be used to approximate the effect of atmosphere on distant objects and enhance the depth perception of the map when used with terrain or 3D features."
+  		doc: "A global effect that fades layers and markers based on their distance to the camera. The fog can be used to approximate the effect of atmosphere on distant objects and enhance the depth perception of the map when used with terrain or 3D features. Note: fog is renamed to atmosphere in the Android and iOS SDKs and planned to be changed in GL-JS v.3.0.0."
   	},
   	sources: {
   		required: true,
@@ -101,7 +101,7 @@
   	},
   	projection: {
   		type: "projection",
-  		doc: "The projection the map should be rendered in. Supported projections are Albers, Equal Earth, Equirectangular (WGS84), Lambert conformal conic, Mercator, Natural Earth, and Winkel Tripel. Terrain, fog, sky and CustomLayerInterface are not supported for projections other than mercator.",
+  		doc: "The projection the map should be rendered in. Supported projections are Mercator, Globe, Albers, Equal Earth, Equirectangular (WGS84), Lambert conformal conic, Natural Earth, and Winkel Tripel. Terrain, sky and fog are supported by only Mercator and globe. CustomLayerInterface is not supported outside of Mercator.",
   		example: {
   			name: "albers",
   			center: [
@@ -2642,7 +2642,7 @@
   	length: 2,
   	doc: "Zoom level and value pair."
   };
-  var expression = {
+  var expression$1 = {
   	type: "array",
   	value: "*",
   	minimum: 1,
@@ -3747,7 +3747,9 @@
   		],
   		"sdk-support": {
   			"basic functionality": {
-  				js: "2.3.0"
+  				js: "2.3.0",
+  				android: "10.6.0",
+  				ios: "10.6.0"
   			}
   		}
   	},
@@ -3762,17 +3764,83 @@
   			]
   		},
   		transition: true,
-  		doc: "The color of the fog. Using opacity is recommended only for smoothly transitioning fog on/off as anything less than 100% opacity results in more tiles loaded and drawn.",
+  		doc: "The color of the atmosphere region immediately below the horizon and within the `range` and above the horizon and within `horizon-blend`. Using opacity is recommended only for smoothly transitioning fog on/off as anything less than 100% opacity results in more tiles loaded and drawn.",
   		"sdk-support": {
   			"basic functionality": {
-  				js: "2.3.0"
+  				js: "2.3.0",
+  				android: "10.6.0",
+  				ios: "10.6.0"
+  			}
+  		}
+  	},
+  	"high-color": {
+  		type: "color",
+  		"property-type": "data-constant",
+  		"default": "#245cdf",
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom"
+  			]
+  		},
+  		transition: true,
+  		doc: "The color of the atmosphere region above the horizon, `high-color` extends further above the horizon than the `color` property and its spread can be controlled with `horizon-blend`. The opacity can be set to `0` to remove the high atmosphere color contribution.",
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "2.9.0",
+  				android: "10.6.0",
+  				ios: "10.6.0"
+  			}
+  		}
+  	},
+  	"space-color": {
+  		type: "color",
+  		"property-type": "data-constant",
+  		"default": [
+  			"interpolate",
+  			[
+  				"linear"
+  			],
+  			[
+  				"zoom"
+  			],
+  			4,
+  			"#010b19",
+  			7,
+  			"#367ab9"
+  		],
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom"
+  			]
+  		},
+  		transition: true,
+  		doc: "The color of the region above the horizon and after the end of the `horizon-blend` contribution. The opacity can be set to `0` to have a transparent background.",
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "2.9.0",
+  				android: "10.6.0",
+  				ios: "10.6.0"
   			}
   		}
   	},
   	"horizon-blend": {
   		type: "number",
   		"property-type": "data-constant",
-  		"default": 0.1,
+  		"default": [
+  			"interpolate",
+  			[
+  				"linear"
+  			],
+  			[
+  				"zoom"
+  			],
+  			4,
+  			0.2,
+  			7,
+  			0.1
+  		],
   		minimum: 0,
   		maximum: 1,
   		expression: {
@@ -3782,10 +3850,46 @@
   			]
   		},
   		transition: true,
-  		doc: "Horizon blend applies a smooth fade from the color of the fog to the color of the sky. A value of zero leaves a sharp transition from fog to sky. Increasing the value blends the color of fog into increasingly high angles of the sky.",
+  		doc: "Horizon blend applies a smooth fade from the color of the atmosphere to the color of space. A value of zero leaves a sharp transition from atmosphere to space. Increasing the value blends the color of atmosphere into increasingly high angles of the sky.",
   		"sdk-support": {
   			"basic functionality": {
-  				js: "2.3.0"
+  				js: "2.3.0",
+  				android: "10.6.0",
+  				ios: "10.6.0"
+  			}
+  		}
+  	},
+  	"star-intensity": {
+  		type: "number",
+  		"property-type": "data-constant",
+  		"default": [
+  			"interpolate",
+  			[
+  				"linear"
+  			],
+  			[
+  				"zoom"
+  			],
+  			5,
+  			0.35,
+  			6,
+  			0
+  		],
+  		minimum: 0,
+  		maximum: 1,
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom"
+  			]
+  		},
+  		transition: true,
+  		doc: "A value controlling the star intensity where `0` will show no stars and `1` will show stars at their maximum intensity.",
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "2.9.0",
+  				android: "10.6.0",
+  				ios: "10.6.0"
   			}
   		}
   	}
@@ -3922,6 +4026,9 @@
   			},
   			winkelTripel: {
   				doc: "A Winkel Tripel projection."
+  			},
+  			globe: {
+  				doc: "A globe projection."
   			}
   		},
   		"default": "mercator",
@@ -3938,6 +4045,14 @@
   		length: 2,
   		value: "number",
   		"property-type": "data-constant",
+  		minimum: [
+  			-180,
+  			-90
+  		],
+  		maximum: [
+  			180,
+  			90
+  		],
   		transition: false,
   		doc: "The reference longitude and latitude of the projection. `center` takes the form of [lng, lat]. This property is only configurable for conic projections (Albers and Lambert Conformal Conic). All other projections are centered on [0, 0].",
   		example: [
@@ -3963,6 +4078,14 @@
   		length: 2,
   		value: "number",
   		"property-type": "data-constant",
+  		minimum: [
+  			-90,
+  			-90
+  		],
+  		maximum: [
+  			90,
+  			90
+  		],
   		transition: false,
   		doc: "The standard parallels of the projection, denoting the desired latitude range with minimal distortion. `parallels` takes the form of [lat0, lat1]. This property is only configurable for conic projections (Albers and Lambert Conformal Conic).",
   		example: [
@@ -4011,6 +4134,9 @@
   		},
   		transition: true,
   		doc: "Exaggerates the elevation of the terrain by multiplying the data from the DEM with this value.",
+  		requires: [
+  			"source"
+  		],
   		"sdk-support": {
   			"basic functionality": {
   				js: "2.0.0",
@@ -4578,6 +4704,42 @@
   			]
   		},
   		"property-type": "color-ramp"
+  	},
+  	"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].",
+  		length: 2,
+  		"default": [
+  			0,
+  			0
+  		],
+  		minimum: [
+  			0,
+  			0
+  		],
+  		maximum: [
+  			1,
+  			1
+  		],
+  		transition: false,
+  		requires: [
+  			{
+  				source: "geojson",
+  				has: {
+  					lineMetrics: true
+  				}
+  			}
+  		],
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "2.9.0",
+  				android: "10.5.0",
+  				ios: "10.5.0",
+  				macos: "10.5.0"
+  			}
+  		},
+  		"property-type": "constant"
   	}
   };
   var paint_circle = {
@@ -6323,7 +6485,7 @@
   	}
   },
   	function_stop: function_stop,
-  	expression: expression,
+  	expression: expression$1,
   	expression_name: expression_name,
   	fog: fog,
   	light: light,
@@ -6697,6 +6859,8 @@
     })(passedObj, "", 0);
   };
 
+  var stringifyPretty = jsonStringifyPrettyCompact;
+
   function sortKeysBy(obj, reference) {
       const result = {};
       for (const key in reference) {
@@ -6711,12 +6875,12 @@
       }
       return result;
   }
-  function format(style, space = 2) {
+  function format$1(style, space = 2) {
       style = sortKeysBy(style, v8.$root);
       if (style.layers) {
           style.layers = style.layers.map(layer => sortKeysBy(layer, v8.layer));
       }
-      return jsonStringifyPrettyCompact(style, { indent: space });
+      return stringifyPretty(style, { indent: space });
   }
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -7384,7 +7548,7 @@
   var parse = urlParse;
   var resolve = urlResolve;
   var resolveObject = urlResolveObject;
-  var format$1 = urlFormat;
+  var format = urlFormat;
 
   var Url_1 = Url;
 
@@ -8091,7 +8255,7 @@
   	parse: parse,
   	resolve: resolve,
   	resolveObject: resolveObject,
-  	format: format$1,
+  	format: format,
   	Url: Url_1
   };
 
@@ -8172,7 +8336,7 @@
           return value;
       }
   }
-  function isFunction(value) {
+  function isFunction$1(value) {
       return Array.isArray(value.stops);
   }
   function renameProperty(obj, from, to) {
@@ -8214,7 +8378,7 @@
           layout: true
       }, property => {
           const value = resolveConstant(style, property.value);
-          if (isFunction(value)) {
+          if (isFunction$1(value)) {
               value.stops.forEach(stop => {
                   stop[1] = resolveConstant(style, stop[1]);
               });
@@ -8305,13 +8469,14 @@
       return output;
   }
 
-  class ParsingError extends Error {
+  class ParsingError$1 extends Error {
       constructor(key, message) {
           super(message);
           this.message = message;
           this.key = key;
       }
   }
+  var ParsingError$2 = ParsingError$1;
 
   class Scope {
       constructor(parent, bindings = []) {
@@ -8339,6 +8504,7 @@
           return this.parent ? this.parent.has(name) : false;
       }
   }
+  var Scope$1 = Scope;
 
   const NullType = { kind: 'null' };
   const NumberType = { kind: 'number' };
@@ -8351,16 +8517,16 @@
   const CollatorType = { kind: 'collator' };
   const FormattedType = { kind: 'formatted' };
   const ResolvedImageType = { kind: 'resolvedImage' };
-  function array(itemType, N) {
+  function array$1(itemType, N) {
       return {
           kind: 'array',
           itemType,
           N
       };
   }
-  function toString(type) {
+  function toString$1(type) {
       if (type.kind === 'array') {
-          const itemType = toString(type.itemType);
+          const itemType = toString$1(type.itemType);
           return typeof type.N === 'number' ? `array<${ itemType }, ${ type.N }>` : type.itemType.kind === 'value' ? 'array' : `array<${ itemType }>`;
       } else {
           return type.kind;
@@ -8374,7 +8540,7 @@
       ColorType,
       FormattedType,
       ObjectType,
-      array(ValueType),
+      array$1(ValueType),
       ResolvedImageType
   ];
   function checkSubtype(expected, t) {
@@ -8393,7 +8559,7 @@
               }
           }
       }
-      return `Expected ${ toString(expected) } but found ${ toString(t) } instead.`;
+      return `Expected ${ toString$1(expected) } but found ${ toString$1(t) } instead.`;
   }
   function isValidType(provided, allowedTypes) {
       return allowedTypes.some(t => t.kind === provided.kind);
@@ -8657,12 +8823,36 @@
               a
           ];
       }
+      toArray01() {
+          const {r, g, b, a} = this;
+          return a === 0 ? [
+              0,
+              0,
+              0,
+              0
+          ] : [
+              r / a,
+              g / a,
+              b / a,
+              a
+          ];
+      }
+      toArray01PremultipliedAlpha() {
+          const {r, g, b, a} = this;
+          return [
+              r,
+              g,
+              b,
+              a
+          ];
+      }
   }
   Color.black = new Color(0, 0, 0, 1);
   Color.white = new Color(1, 1, 1, 1);
   Color.transparent = new Color(0, 0, 0, 0);
   Color.red = new Color(1, 0, 0, 1);
   Color.blue = new Color(0, 0, 1, 1);
+  var Color$1 = Color;
 
   class Collator {
       constructor(caseSensitive, diacriticSensitive, locale) {
@@ -8804,7 +8994,7 @@
           return true;
       } else if (typeof mixed === 'number') {
           return true;
-      } else if (mixed instanceof Color) {
+      } else if (mixed instanceof Color$1) {
           return true;
       } else if (mixed instanceof Collator) {
           return true;
@@ -8839,7 +9029,7 @@
           return BooleanType;
       } else if (typeof value === 'number') {
           return NumberType;
-      } else if (value instanceof Color) {
+      } else if (value instanceof Color$1) {
           return ColorType;
       } else if (value instanceof Collator) {
           return CollatorType;
@@ -8861,18 +9051,18 @@
                   break;
               }
           }
-          return array(itemType || ValueType, length);
+          return array$1(itemType || ValueType, length);
       } else {
           return ObjectType;
       }
   }
-  function toString$1(value) {
+  function toString(value) {
       const type = typeof value;
       if (value === null) {
           return '';
       } else if (type === 'string' || type === 'number' || type === 'boolean') {
           return String(value);
-      } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
+      } else if (value instanceof Color$1 || value instanceof Formatted || value instanceof ResolvedImage) {
           return value.toString();
       } else {
           return JSON.stringify(value);
@@ -8911,7 +9101,7 @@
                   'literal',
                   this.value
               ];
-          } else if (this.value instanceof Color) {
+          } else if (this.value instanceof Color$1) {
               return ['rgba'].concat(this.value.toArray());
           } else if (this.value instanceof Formatted) {
               return this.value.serialize();
@@ -8920,6 +9110,7 @@
           }
       }
   }
+  var Literal$1 = Literal;
 
   class RuntimeError {
       constructor(message) {
@@ -8930,8 +9121,9 @@
           return this.message;
       }
   }
+  var RuntimeError$1 = RuntimeError;
 
-  const types = {
+  const types$1 = {
       string: StringType,
       number: NumberType,
       boolean: BooleanType,
@@ -8952,9 +9144,9 @@
               let itemType;
               if (args.length > 2) {
                   const type = args[1];
-                  if (typeof type !== 'string' || !(type in types) || type === 'object')
+                  if (typeof type !== 'string' || !(type in types$1) || type === 'object')
                       return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
-                  itemType = types[type];
+                  itemType = types$1[type];
                   i++;
               } else {
                   itemType = ValueType;
@@ -8967,9 +9159,9 @@
                   N = args[2];
                   i++;
               }
-              type = array(itemType, N);
+              type = array$1(itemType, N);
           } else {
-              type = types[name];
+              type = types$1[name];
           }
           const parsed = [];
           for (; i < args.length; i++) {
@@ -8987,7 +9179,7 @@
               if (!error) {
                   return value;
               } else if (i === this.args.length - 1) {
-                  throw new RuntimeError(`Expected value to be of type ${ toString(this.type) }, but found ${ toString(typeOf(value)) } instead.`);
+                  throw new RuntimeError$1(`Expected value to be of type ${ toString$1(this.type) }, but found ${ toString$1(typeOf(value)) } instead.`);
               }
           }
           return null;
@@ -9014,6 +9206,7 @@
           return serialized.concat(this.args.map(arg => arg.serialize()));
       }
   }
+  var Assertion$1 = Assertion;
 
   class FormatExpression {
       constructor(sections) {
@@ -9042,7 +9235,7 @@
                   }
                   let font = null;
                   if (arg['text-font']) {
-                      font = context.parse(arg['text-font'], 1, array(StringType));
+                      font = context.parse(arg['text-font'], 1, array$1(StringType));
                       if (!font)
                           return null;
                   }
@@ -9080,7 +9273,7 @@
               if (typeOf(evaluatedContent) === ResolvedImageType) {
                   return new FormattedSection('', evaluatedContent, null, null, null);
               }
-              return new FormattedSection(toString$1(evaluatedContent), null, section.scale ? section.scale.evaluate(ctx) : null, section.font ? section.font.evaluate(ctx).join(',') : null, section.textColor ? section.textColor.evaluate(ctx) : null);
+              return new FormattedSection(toString(evaluatedContent), null, section.scale ? section.scale.evaluate(ctx) : null, section.font ? section.font.evaluate(ctx).join(',') : null, section.textColor ? section.textColor.evaluate(ctx) : null);
           };
           return new Formatted(this.sections.map(evaluateSection));
       }
@@ -9156,7 +9349,7 @@
       }
   }
 
-  const types$1 = {
+  const types = {
       'to-boolean': BooleanType,
       'to-color': ColorType,
       'to-number': NumberType,
@@ -9173,7 +9366,7 @@
           const name = args[0];
           if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
               return context.error(`Expected one argument.`);
-          const type = types$1[name];
+          const type = types[name];
           const parsed = [];
           for (let i = 1; i < args.length; i++) {
               const input = context.parse(args[i], i, ValueType);
@@ -9192,7 +9385,7 @@
               for (const arg of this.args) {
                   input = arg.evaluate(ctx);
                   error = null;
-                  if (input instanceof Color) {
+                  if (input instanceof Color$1) {
                       return input;
                   } else if (typeof input === 'string') {
                       const c = ctx.parseColor(input);
@@ -9205,11 +9398,11 @@
                           error = validateRGBA(input[0], input[1], input[2], input[3]);
                       }
                       if (!error) {
-                          return new Color(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
+                          return new Color$1(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
                       }
                   }
               }
-              throw new RuntimeError(error || `Could not parse color from value '${ typeof input === 'string' ? input : String(JSON.stringify(input)) }'`);
+              throw new RuntimeError$1(error || `Could not parse color from value '${ typeof input === 'string' ? input : String(JSON.stringify(input)) }'`);
           } else if (this.type.kind === 'number') {
               let value = null;
               for (const arg of this.args) {
@@ -9221,13 +9414,13 @@
                       continue;
                   return num;
               }
-              throw new RuntimeError(`Could not convert ${ JSON.stringify(value) } to number.`);
+              throw new RuntimeError$1(`Could not convert ${ JSON.stringify(value) } to number.`);
           } else if (this.type.kind === 'formatted') {
-              return Formatted.fromString(toString$1(this.args[0].evaluate(ctx)));
+              return Formatted.fromString(toString(this.args[0].evaluate(ctx)));
           } else if (this.type.kind === 'resolvedImage') {
-              return ResolvedImage.fromString(toString$1(this.args[0].evaluate(ctx)));
+              return ResolvedImage.fromString(toString(this.args[0].evaluate(ctx)));
           } else {
-              return toString$1(this.args[0].evaluate(ctx));
+              return toString(this.args[0].evaluate(ctx));
           }
       }
       eachChild(fn) {
@@ -9255,6 +9448,7 @@
           return serialized;
       }
   }
+  var Coercion$1 = Coercion;
 
   const geometryTypes = [
       'Unknown',
@@ -9306,11 +9500,12 @@
       parseColor(input) {
           let cached = this._parseColorCache[input];
           if (!cached) {
-              cached = this._parseColorCache[input] = Color.parse(input);
+              cached = this._parseColorCache[input] = Color$1.parse(input);
           }
           return cached;
       }
   }
+  var EvaluationContext$1 = EvaluationContext;
 
   class CompoundExpression {
       constructor(name, type, evaluate, args) {
@@ -9345,7 +9540,7 @@
           const overloads = availableOverloads.filter(([signature]) => !Array.isArray(signature) || signature.length === args.length - 1);
           let signatureContext = null;
           for (const [params, evaluate] of overloads) {
-              signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);
+              signatureContext = new ParsingContext$1(context.registry, context.path, null, context.scope);
               const parsedArgs = [];
               let argParseFailed = false;
               for (let i = 1; i < args.length; i++) {
@@ -9386,7 +9581,7 @@
                   const parsed = context.parse(args[i], 1 + actualTypes.length);
                   if (!parsed)
                       return null;
-                  actualTypes.push(toString(parsed.type));
+                  actualTypes.push(toString$1(parsed.type));
               }
               context.error(`Expected arguments of type ${ signatures }, but found (${ actualTypes.join(', ') }) instead.`);
           }
@@ -9401,11 +9596,12 @@
   }
   function stringifySignature(signature) {
       if (Array.isArray(signature)) {
-          return `(${ signature.map(toString).join(', ') })`;
+          return `(${ signature.map(toString$1).join(', ') })`;
       } else {
-          return `(${ toString(signature.type) }...)`;
+          return `(${ toString$1(signature.type) }...)`;
       }
   }
+  var CompoundExpression$1 = CompoundExpression;
 
   class CollatorExpression {
       constructor(caseSensitive, diacriticSensitive, locale) {
@@ -9802,9 +9998,10 @@
           ];
       }
   }
+  var Within$1 = Within;
 
   function isFeatureConstant(e) {
-      if (e instanceof CompoundExpression) {
+      if (e instanceof CompoundExpression$1) {
           if (e.name === 'get' && e.args.length === 1) {
               return false;
           } else if (e.name === 'feature-state') {
@@ -9817,7 +10014,7 @@
               return false;
           }
       }
-      if (e instanceof Within) {
+      if (e instanceof Within$1) {
           return false;
       }
       let result = true;
@@ -9829,7 +10026,7 @@
       return result;
   }
   function isStateConstant(e) {
-      if (e instanceof CompoundExpression) {
+      if (e instanceof CompoundExpression$1) {
           if (e.name === 'feature-state') {
               return false;
           }
@@ -9843,7 +10040,7 @@
       return result;
   }
   function isGlobalPropertyConstant(e, properties) {
-      if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) {
+      if (e instanceof CompoundExpression$1 && properties.indexOf(e.name) >= 0) {
           return false;
       }
       let result = true;
@@ -9885,9 +10082,10 @@
           ];
       }
   }
+  var Var$1 = Var;
 
   class ParsingContext {
-      constructor(registry, path = [], expectedType, scope = new Scope(), errors = []) {
+      constructor(registry, path = [], expectedType, scope = new Scope$1(), errors = []) {
           this.registry = registry;
           this.path = path;
           this.key = path.map(part => `[${ part }]`).join('');
@@ -9910,9 +10108,9 @@
           }
           function annotate(parsed, type, typeAnnotation) {
               if (typeAnnotation === 'assert') {
-                  return new Assertion(type, [parsed]);
+                  return new Assertion$1(type, [parsed]);
               } else if (typeAnnotation === 'coerce') {
-                  return new Coercion(type, [parsed]);
+                  return new Coercion$1(type, [parsed]);
               } else {
                   return parsed;
               }
@@ -9942,10 +10140,10 @@
                           return null;
                       }
                   }
-                  if (!(parsed instanceof Literal) && parsed.type.kind !== 'resolvedImage' && isConstant(parsed)) {
-                      const ec = new EvaluationContext();
+                  if (!(parsed instanceof Literal$1) && parsed.type.kind !== 'resolvedImage' && isConstant(parsed)) {
+                      const ec = new EvaluationContext$1();
                       try {
-                          parsed = new Literal(parsed.type, parsed.evaluate(ec));
+                          parsed = new Literal$1(parsed.type, parsed.evaluate(ec));
                       } catch (e) {
                           this.error(e.message);
                           return null;
@@ -9969,7 +10167,7 @@
       }
       error(error, ...keys) {
           const key = `${ this.key }${ keys.map(k => `[${ k }]`).join('') }`;
-          this.errors.push(new ParsingError(key, error));
+          this.errors.push(new ParsingError$2(key, error));
       }
       checkSubtype(expected, t) {
           const error = checkSubtype(expected, t);
@@ -9978,23 +10176,24 @@
           return error;
       }
   }
+  var ParsingContext$1 = ParsingContext;
   function isConstant(expression) {
-      if (expression instanceof Var) {
+      if (expression instanceof Var$1) {
           return isConstant(expression.boundExpression);
-      } else if (expression instanceof CompoundExpression && expression.name === 'error') {
+      } else if (expression instanceof CompoundExpression$1 && expression.name === 'error') {
           return false;
       } else if (expression instanceof CollatorExpression) {
           return false;
-      } else if (expression instanceof Within) {
+      } else if (expression instanceof Within$1) {
           return false;
       }
-      const isTypeAnnotation = expression instanceof Coercion || expression instanceof Assertion;
+      const isTypeAnnotation = expression instanceof Coercion$1 || expression instanceof Assertion$1;
       let childrenConstant = true;
       expression.eachChild(child => {
           if (isTypeAnnotation) {
               childrenConstant = childrenConstant && isConstant(child);
           } else {
-              childrenConstant = childrenConstant && child instanceof Literal;
+              childrenConstant = childrenConstant && child instanceof Literal$1;
           }
       });
       if (!childrenConstant) {
@@ -10030,7 +10229,7 @@
           } else if (currentValue > input) {
               upperIndex = currentIndex - 1;
           } else {
-              throw new RuntimeError('Input is not a number.');
+              throw new RuntimeError$1('Input is not a number.');
           }
       }
       return 0;
@@ -10124,6 +10323,7 @@
           return serialized;
       }
   }
+  var Step$1 = Step;
 
   /*
    * Copyright (C) 2008 Apple Inc. All Rights Reserved.
@@ -10234,9 +10434,9 @@
       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));
+      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$1(from, to, t) {
+  function array(from, to, t) {
       return from.map((d, i) => {
           return number(d, to[i], t);
       });
@@ -10246,7 +10446,7 @@
     __proto__: null,
     number: number,
     color: color,
-    array: array$1
+    array: array
   });
 
   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;
@@ -10277,7 +10477,7 @@
       y = Yn * lab2xyz(y);
       x = Xn * lab2xyz(x);
       z = Zn * lab2xyz(z);
-      return new Color(xyz2rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z), xyz2rgb(-0.969266 * x + 1.8760108 * y + 0.041556 * z), xyz2rgb(0.0556434 * x - 0.2040259 * y + 1.0572252 * z), labColor.alpha);
+      return new Color$1(xyz2rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z), 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) {
       return {
@@ -10425,7 +10625,7 @@
               ]);
           }
           if (outputType.kind !== 'number' && outputType.kind !== 'color' && !(outputType.kind === 'array' && outputType.itemType.kind === 'number' && typeof outputType.N === 'number')) {
-              return context.error(`Type ${ toString(outputType) } is not interpolatable.`);
+              return context.error(`Type ${ toString$1(outputType) } is not interpolatable.`);
           }
           return new Interpolate(outputType, operator, interpolation, input, stops);
       }
@@ -10504,6 +10704,7 @@
           return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
       }
   }
+  var Interpolate$1 = Interpolate;
 
   class Coalesce {
       constructor(type, args) {
@@ -10565,6 +10766,7 @@
           return serialized;
       }
   }
+  var Coalesce$1 = Coalesce;
 
   class Let {
       constructor(bindings, result) {
@@ -10618,6 +10820,7 @@
           return serialized;
       }
   }
+  var Let$1 = Let;
 
   class At {
       constructor(type, index, input) {
@@ -10629,7 +10832,7 @@
           if (args.length !== 3)
               return context.error(`Expected 2 arguments, but found ${ args.length - 1 } instead.`);
           const index = context.parse(args[1], 1, NumberType);
-          const input = context.parse(args[2], 2, array(context.expectedType || ValueType));
+          const input = context.parse(args[2], 2, array$1(context.expectedType || ValueType));
           if (!index || !input)
               return null;
           const t = input.type;
@@ -10639,13 +10842,13 @@
           const index = this.index.evaluate(ctx);
           const array = this.input.evaluate(ctx);
           if (index < 0) {
-              throw new RuntimeError(`Array index out of bounds: ${ index } < 0.`);
+              throw new RuntimeError$1(`Array index out of bounds: ${ index } < 0.`);
           }
           if (index >= array.length) {
-              throw new RuntimeError(`Array index out of bounds: ${ index } > ${ array.length - 1 }.`);
+              throw new RuntimeError$1(`Array index out of bounds: ${ index } > ${ array.length - 1 }.`);
           }
           if (index !== Math.floor(index)) {
-              throw new RuntimeError(`Array index must be an integer, but found ${ index } instead.`);
+              throw new RuntimeError$1(`Array index must be an integer, but found ${ index } instead.`);
           }
           return array[index];
       }
@@ -10664,6 +10867,7 @@
           ];
       }
   }
+  var At$1 = At;
 
   class In {
       constructor(needle, haystack) {
@@ -10686,7 +10890,7 @@
                   NullType,
                   ValueType
               ])) {
-              return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${ toString(needle.type) } instead`);
+              return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${ toString$1(needle.type) } instead`);
           }
           return new In(needle, haystack);
       }
@@ -10701,13 +10905,13 @@
                   'number',
                   'null'
               ])) {
-              throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${ toString(typeOf(needle)) } instead.`);
+              throw new RuntimeError$1(`Expected first argument to be of type boolean, string, number or null, but found ${ toString$1(typeOf(needle)) } instead.`);
           }
           if (!isValidNativeType(haystack, [
                   'string',
                   'array'
               ])) {
-              throw new RuntimeError(`Expected second argument to be of type array or string, but found ${ toString(typeOf(haystack)) } instead.`);
+              throw new RuntimeError$1(`Expected second argument to be of type array or string, but found ${ toString$1(typeOf(haystack)) } instead.`);
           }
           return haystack.indexOf(needle) >= 0;
       }
@@ -10726,6 +10930,7 @@
           ];
       }
   }
+  var In$1 = In;
 
   class IndexOf {
       constructor(needle, haystack, fromIndex) {
@@ -10749,7 +10954,7 @@
                   NullType,
                   ValueType
               ])) {
-              return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${ toString(needle.type) } instead`);
+              return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${ toString$1(needle.type) } instead`);
           }
           if (args.length === 4) {
               const fromIndex = context.parse(args[3], 3, NumberType);
@@ -10769,13 +10974,13 @@
                   'number',
                   'null'
               ])) {
-              throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${ toString(typeOf(needle)) } instead.`);
+              throw new RuntimeError$1(`Expected first argument to be of type boolean, string, number or null, but found ${ toString$1(typeOf(needle)) } instead.`);
           }
           if (!isValidNativeType(haystack, [
                   'string',
                   'array'
               ])) {
-              throw new RuntimeError(`Expected second argument to be of type array or string, but found ${ toString(typeOf(haystack)) } instead.`);
+              throw new RuntimeError$1(`Expected second argument to be of type array or string, but found ${ toString$1(typeOf(haystack)) } instead.`);
           }
           if (this.fromIndex) {
               const fromIndex = this.fromIndex.evaluate(ctx);
@@ -10810,6 +11015,7 @@
           ];
       }
   }
+  var IndexOf$1 = IndexOf;
 
   class Match {
       constructor(inputType, outputType, input, cases, outputs, otherwise) {
@@ -10922,6 +11128,7 @@
           return serialized;
       }
   }
+  var Match$1 = Match;
 
   class Case {
       constructor(type, branches, otherwise) {
@@ -10983,6 +11190,7 @@
           return serialized;
       }
   }
+  var Case$1 = Case;
 
   class Slice {
       constructor(type, input, beginIndex, endIndex) {
@@ -11000,11 +11208,11 @@
           if (!input || !beginIndex)
               return null;
           if (!isValidType(input.type, [
-                  array(ValueType),
+                  array$1(ValueType),
                   StringType,
                   ValueType
               ])) {
-              return context.error(`Expected first argument to be of type array or string, but found ${ toString(input.type) } instead`);
+              return context.error(`Expected first argument to be of type array or string, but found ${ toString$1(input.type) } instead`);
           }
           if (args.length === 4) {
               const endIndex = context.parse(args[3], 3, NumberType);
@@ -11022,7 +11230,7 @@
                   'string',
                   'array'
               ])) {
-              throw new RuntimeError(`Expected first argument to be of type array or string, but found ${ toString(typeOf(input)) } instead.`);
+              throw new RuntimeError$1(`Expected first argument to be of type array or string, but found ${ toString$1(typeOf(input)) } instead.`);
           }
           if (this.endIndex) {
               const endIndex = this.endIndex.evaluate(ctx);
@@ -11057,6 +11265,7 @@
           ];
       }
   }
+  var Slice$1 = Slice;
 
   function isComparableType(op, type) {
       if (op === '==' || op === '!=') {
@@ -11119,22 +11328,22 @@
               if (!lhs)
                   return null;
               if (!isComparableType(op, lhs.type)) {
-                  return context.concat(1).error(`"${ op }" comparisons are not supported for type '${ toString(lhs.type) }'.`);
+                  return context.concat(1).error(`"${ op }" 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(rhs.type) }'.`);
+                  return context.concat(2).error(`"${ op }" 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(lhs.type) }' and '${ toString(rhs.type) }'.`);
+                  return context.error(`Cannot compare types '${ toString$1(lhs.type) }' and '${ toString$1(rhs.type) }'.`);
               }
               if (isOrderComparison) {
                   if (lhs.type.kind === 'value' && rhs.type.kind !== 'value') {
-                      lhs = new Assertion(rhs.type, [lhs]);
+                      lhs = new Assertion$1(rhs.type, [lhs]);
                   } else if (lhs.type.kind !== 'value' && rhs.type.kind === 'value') {
-                      rhs = new Assertion(lhs.type, [rhs]);
+                      rhs = new Assertion$1(lhs.type, [rhs]);
                   }
               }
               let collator = null;
@@ -11155,7 +11364,7 @@
                   const lt = typeOf(lhs);
                   const rt = typeOf(rhs);
                   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.`);
+                      throw new RuntimeError$1(`Expected arguments for "${ op }" to be (string, string) or (number, number), but found (${ lt.kind }, ${ rt.kind }) instead.`);
                   }
               }
               if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
@@ -11297,7 +11506,7 @@
           if (!input)
               return null;
           if (input.type.kind !== 'array' && input.type.kind !== 'string' && input.type.kind !== 'value')
-              return context.error(`Expected argument of type string or array, but found ${ toString(input.type) } instead.`);
+              return context.error(`Expected argument of type string or array, but found ${ toString$1(input.type) } instead.`);
           return new Length(input);
       }
       evaluate(ctx) {
@@ -11307,7 +11516,7 @@
           } else if (Array.isArray(input)) {
               return input.length;
           } else {
-              throw new RuntimeError(`Expected value to be of type string or array, but found ${ toString(typeOf(input)) } instead.`);
+              throw new RuntimeError$1(`Expected value to be of type string or array, but found ${ toString$1(typeOf(input)) } instead.`);
           }
       }
       eachChild(fn) {
@@ -11324,6 +11533,7 @@
           return serialized;
       }
   }
+  var Length$1 = Length;
 
   const expressions = {
       '==': Equals,
@@ -11332,35 +11542,35 @@
       '<': LessThan,
       '>=': GreaterThanOrEqual,
       '<=': LessThanOrEqual,
-      'array': Assertion,
-      'at': At,
-      'boolean': Assertion,
-      'case': Case,
-      'coalesce': Coalesce,
+      'array': Assertion$1,
+      'at': At$1,
+      'boolean': Assertion$1,
+      'case': Case$1,
+      'coalesce': Coalesce$1,
       'collator': CollatorExpression,
       'format': FormatExpression,
       'image': ImageExpression,
-      'in': In,
-      'index-of': IndexOf,
-      'interpolate': Interpolate,
-      'interpolate-hcl': Interpolate,
-      'interpolate-lab': Interpolate,
-      'length': Length,
-      'let': Let,
-      'literal': Literal,
-      'match': Match,
-      'number': Assertion,
+      'in': In$1,
+      'index-of': IndexOf$1,
+      'interpolate': Interpolate$1,
+      'interpolate-hcl': Interpolate$1,
+      'interpolate-lab': Interpolate$1,
+      'length': Length$1,
+      'let': Let$1,
+      'literal': Literal$1,
+      'match': Match$1,
+      'number': Assertion$1,
       'number-format': NumberFormat,
-      'object': Assertion,
-      'slice': Slice,
-      'step': Step,
-      'string': Assertion,
-      'to-boolean': Coercion,
-      'to-color': Coercion,
-      'to-number': Coercion,
-      'to-string': Coercion,
-      'var': Var,
-      'within': Within
+      'object': Assertion$1,
+      'slice': Slice$1,
+      'step': Step$1,
+      'string': Assertion$1,
+      'to-boolean': Coercion$1,
+      'to-color': Coercion$1,
+      'to-number': Coercion$1,
+      'to-string': Coercion$1,
+      'var': Var$1,
+      'within': Within$1
   };
   function rgba(ctx, [r, g, b, a]) {
       r = r.evaluate(ctx);
@@ -11369,8 +11579,8 @@
       const alpha = a ? a.evaluate(ctx) : 1;
       const error = validateRGBA(r, g, b, alpha);
       if (error)
-          throw new RuntimeError(error);
-      return new Color(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
+          throw new RuntimeError$1(error);
+      return new Color$1(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
   }
   function has(key, obj) {
       return key in obj;
@@ -11394,21 +11604,21 @@
   function varargs(type) {
       return { type };
   }
-  CompoundExpression.register(expressions, {
+  CompoundExpression$1.register(expressions, {
       'error': [
           ErrorType,
           [StringType],
           (ctx, [v]) => {
-              throw new RuntimeError(v.evaluate(ctx));
+              throw new RuntimeError$1(v.evaluate(ctx));
           }
       ],
       'typeof': [
           StringType,
           [ValueType],
-          (ctx, [v]) => toString(typeOf(v.evaluate(ctx)))
+          (ctx, [v]) => toString$1(typeOf(v.evaluate(ctx)))
       ],
       'to-rgba': [
-          array(NumberType, 4),
+          array$1(NumberType, 4),
           [ColorType],
           (ctx, [v]) => {
               return v.evaluate(ctx).toArray();
@@ -11794,19 +12004,19 @@
       ],
       'filter-type-in': [
           BooleanType,
-          [array(StringType)],
+          [array$1(StringType)],
           (ctx, [v]) => v.value.indexOf(ctx.geometryType()) >= 0
       ],
       'filter-id-in': [
           BooleanType,
-          [array(ValueType)],
+          [array$1(ValueType)],
           (ctx, [v]) => v.value.indexOf(ctx.id()) >= 0
       ],
       'filter-in-small': [
           BooleanType,
           [
               StringType,
-              array(ValueType)
+              array$1(ValueType)
           ],
           (ctx, [k, v]) => v.value.indexOf(ctx.properties()[k.value]) >= 0
       ],
@@ -11814,7 +12024,7 @@
           BooleanType,
           [
               StringType,
-              array(ValueType)
+              array$1(ValueType)
           ],
           (ctx, [k, v]) => binarySearch(ctx.properties()[k.value], v.value, 0, v.value.length - 1)
       ],
@@ -11891,7 +12101,7 @@
       'concat': [
           StringType,
           varargs(ValueType),
-          (ctx, args) => args.map(arg => toString$1(arg.evaluate(ctx))).join('')
+          (ctx, args) => args.map(arg => toString(arg.evaluate(ctx))).join('')
       ],
       'resolved-locale': [
           StringType,
@@ -11899,6 +12109,7 @@
           (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
       ]
   });
+  var definitions = expressions;
 
   function success(value) {
       return {
@@ -11939,7 +12150,7 @@
       }
   }
 
-  function isFunction$1(value) {
+  function isFunction(value) {
       return typeof value === 'object' && value !== null && !Array.isArray(value);
   }
   function identityFunction(x) {
@@ -11957,14 +12168,14 @@
               parameters.stops = parameters.stops.map(stop => {
                   return [
                       stop[0],
-                      Color.parse(stop[1])
+                      Color$1.parse(stop[1])
                   ];
               });
           }
           if (parameters.default) {
-              parameters.default = Color.parse(parameters.default);
+              parameters.default = Color$1.parse(parameters.default);
           } else {
-              parameters.default = Color.parse(propertySpec.default);
+              parameters.default = Color$1.parse(propertySpec.default);
           }
       }
       if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace]) {
@@ -12021,7 +12232,7 @@
           return {
               kind: 'composite',
               interpolationType,
-              interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
+              interpolationFactor: Interpolate$1.interpolationFactor.bind(undefined, interpolationType),
               zoomStops: featureFunctionStops.map(s => s[0]),
               evaluate({zoom}, properties) {
                   return evaluateExponentialFunction({
@@ -12038,7 +12249,7 @@
           return {
               kind: 'camera',
               interpolationType,
-              interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
+              interpolationFactor: Interpolate$1.interpolationFactor.bind(undefined, interpolationType),
               zoomStops: parameters.stops.map(s => s[0]),
               evaluate: ({zoom}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
           };
@@ -12048,14 +12259,14 @@
               evaluate(_, feature) {
                   const value = feature && feature.properties ? feature.properties[parameters.property] : undefined;
                   if (value === undefined) {
-                      return coalesce(parameters.default, propertySpec.default);
+                      return coalesce$1(parameters.default, propertySpec.default);
                   }
                   return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
               }
           };
       }
   }
-  function coalesce(a, b, c) {
+  function coalesce$1(a, b, c) {
       if (a !== undefined)
           return a;
       if (b !== undefined)
@@ -12065,11 +12276,11 @@
   }
   function evaluateCategoricalFunction(parameters, propertySpec, input, hashedStops, keyType) {
       const evaluated = typeof input === keyType ? hashedStops[input] : undefined;
-      return coalesce(evaluated, parameters.default, propertySpec.default);
+      return coalesce$1(evaluated, parameters.default, propertySpec.default);
   }
   function evaluateIntervalFunction(parameters, propertySpec, input) {
       if (getType(input) !== 'number')
-          return coalesce(parameters.default, propertySpec.default);
+          return coalesce$1(parameters.default, propertySpec.default);
       const n = parameters.stops.length;
       if (n === 1)
           return parameters.stops[0][1];
@@ -12083,7 +12294,7 @@
   function evaluateExponentialFunction(parameters, propertySpec, input) {
       const base = parameters.base !== undefined ? parameters.base : 1;
       if (getType(input) !== 'number')
-          return coalesce(parameters.default, propertySpec.default);
+          return coalesce$1(parameters.default, propertySpec.default);
       const n = parameters.stops.length;
       if (n === 1)
           return parameters.stops[0][1];
@@ -12116,7 +12327,7 @@
   }
   function evaluateIdentityFunction(parameters, propertySpec, input) {
       if (propertySpec.type === 'color') {
-          input = Color.parse(input);
+          input = Color$1.parse(input);
       } else if (propertySpec.type === 'formatted') {
           input = Formatted.fromString(input.toString());
       } else if (propertySpec.type === 'resolvedImage') {
@@ -12124,7 +12335,7 @@
       } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
           input = undefined;
       }
-      return coalesce(input, parameters.default, propertySpec.default);
+      return coalesce$1(input, parameters.default, propertySpec.default);
   }
   function interpolationFactor(input, base, lowerValue, upperValue) {
       const difference = upperValue - lowerValue;
@@ -12142,7 +12353,7 @@
       constructor(expression, propertySpec) {
           this.expression = expression;
           this._warningHistory = {};
-          this._evaluator = new EvaluationContext();
+          this._evaluator = new EvaluationContext$1();
           this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
           this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
       }
@@ -12172,7 +12383,7 @@
                   return this._defaultValue;
               }
               if (this._enumValues && !(val in this._enumValues)) {
-                  throw new RuntimeError(`Expected value to be one of ${ Object.keys(this._enumValues).map(v => JSON.stringify(v)).join(', ') }, but found ${ JSON.stringify(val) } instead.`);
+                  throw new RuntimeError$1(`Expected value to be one of ${ Object.keys(this._enumValues).map(v => JSON.stringify(v)).join(', ') }, but found ${ JSON.stringify(val) } instead.`);
               }
               return val;
           } catch (e) {
@@ -12187,10 +12398,10 @@
       }
   }
   function isExpression(expression) {
-      return Array.isArray(expression) && expression.length > 0 && typeof expression[0] === 'string' && expression[0] in expressions;
+      return Array.isArray(expression) && expression.length > 0 && typeof expression[0] === 'string' && expression[0] in definitions;
   }
   function createExpression(expression, propertySpec) {
-      const parser = new ParsingContext(expressions, [], propertySpec ? getExpectedType(propertySpec) : undefined);
+      const parser = new ParsingContext$1(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined);
       const parsed = parser.parse(expression, undefined, undefined, undefined, propertySpec && propertySpec.type === 'string' ? { typeAnnotation: 'coerce' } : undefined);
       if (!parsed) {
           return error(parser.errors);
@@ -12226,7 +12437,7 @@
       }
       interpolationFactor(input, lower, upper) {
           if (this.interpolationType) {
-              return Interpolate.interpolationFactor(this.interpolationType, input, lower, upper);
+              return Interpolate$1.interpolationFactor(this.interpolationType, input, lower, upper);
           } else {
               return 0;
           }
@@ -12240,7 +12451,7 @@
       const parsed = expression.value.expression;
       const isFeatureConstant$1 = isFeatureConstant(parsed);
       if (!isFeatureConstant$1 && !supportsPropertyExpression(propertySpec)) {
-          return error([new ParsingError('', 'data expressions not supported')]);
+          return error([new ParsingError$2('', 'data expressions not supported')]);
       }
       const isZoomConstant = isGlobalPropertyConstant(parsed, [
           'zoom',
@@ -12248,20 +12459,20 @@
           'distance-from-center'
       ]);
       if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
-          return error([new ParsingError('', 'zoom expressions not supported')]);
+          return error([new ParsingError$2('', 'zoom expressions not supported')]);
       }
       const zoomCurve = findZoomCurve(parsed);
       if (!zoomCurve && !isZoomConstant) {
-          return error([new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
-      } else if (zoomCurve instanceof ParsingError) {
+          return error([new ParsingError$2('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+      } else if (zoomCurve instanceof ParsingError$2) {
           return error([zoomCurve]);
-      } else if (zoomCurve instanceof Interpolate && !supportsInterpolation(propertySpec)) {
-          return error([new ParsingError('', '"interpolate" expressions cannot be used with this property')]);
+      } else if (zoomCurve instanceof Interpolate$1 && !supportsInterpolation(propertySpec)) {
+          return error([new ParsingError$2('', '"interpolate" expressions cannot be used with this property')]);
       }
       if (!zoomCurve) {
           return success(isFeatureConstant$1 ? new ZoomConstantExpression('constant', expression.value) : new ZoomConstantExpression('source', expression.value));
       }
-      const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
+      const interpolationType = zoomCurve instanceof Interpolate$1 ? zoomCurve.interpolation : undefined;
       return success(isFeatureConstant$1 ? new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType) : new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType));
   }
   class StylePropertyFunction {
@@ -12281,7 +12492,7 @@
       }
   }
   function normalizePropertyExpression(value, specification) {
-      if (isFunction$1(value)) {
+      if (isFunction(value)) {
           return new StylePropertyFunction(value, specification);
       } else if (isExpression(value)) {
           const expression = createPropertyExpression(value, specification);
@@ -12292,7 +12503,7 @@
       } else {
           let constant = value;
           if (typeof value === 'string' && specification.type === 'color') {
-              constant = Color.parse(value);
+              constant = Color$1.parse(value);
           }
           return {
               kind: 'constant',
@@ -12302,29 +12513,29 @@
   }
   function findZoomCurve(expression) {
       let result = null;
-      if (expression instanceof Let) {
+      if (expression instanceof Let$1) {
           result = findZoomCurve(expression.result);
-      } else if (expression instanceof Coalesce) {
+      } else if (expression instanceof Coalesce$1) {
           for (const arg of expression.args) {
               result = findZoomCurve(arg);
               if (result) {
                   break;
               }
           }
-      } else if ((expression instanceof Step || expression instanceof Interpolate) && expression.input instanceof CompoundExpression && expression.input.name === 'zoom') {
+      } else if ((expression instanceof Step$1 || expression instanceof Interpolate$1) && expression.input instanceof CompoundExpression$1 && expression.input.name === 'zoom') {
           result = expression;
       }
-      if (result instanceof ParsingError) {
+      if (result instanceof ParsingError$2) {
           return result;
       }
       expression.eachChild(child => {
           const childResult = findZoomCurve(child);
-          if (childResult instanceof ParsingError) {
+          if (childResult instanceof ParsingError$2) {
               result = childResult;
           } else if (!result && childResult) {
-              result = new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.');
+              result = new ParsingError$2('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.');
           } else if (result && childResult && result !== childResult) {
-              result = new ParsingError('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
+              result = new ParsingError$2('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
           }
       });
       return result;
@@ -12340,15 +12551,15 @@
           resolvedImage: ResolvedImageType
       };
       if (spec.type === 'array') {
-          return array(types[spec.value] || ValueType, spec.length);
+          return array$1(types[spec.value] || ValueType, spec.length);
       }
       return types[spec.type];
   }
   function getDefaultValue(spec) {
-      if (spec.type === 'color' && isFunction$1(spec.default)) {
-          return new Color(0, 0, 0, 0);
+      if (spec.type === 'color' && (isFunction(spec.default) || Array.isArray(spec.default))) {
+          return new Color$1(0, 0, 0, 0);
       } else if (spec.type === 'color') {
-          return Color.parse(spec.default) || null;
+          return Color$1.parse(spec.default) || null;
       } else if (spec.default === undefined) {
           return null;
       } else {
@@ -12477,14 +12688,14 @@
           return expression;
       }
   }
-  function coalesce$1(a, b) {
+  function coalesce(a, b) {
       if (a !== undefined)
           return a;
       if (b !== undefined)
           return b;
   }
   function getFallback(parameters, propertySpec) {
-      const defaultValue = convertLiteral(coalesce$1(parameters.default, propertySpec.default));
+      const defaultValue = convertLiteral(coalesce(parameters.default, propertySpec.default));
       if (defaultValue === undefined && propertySpec.type === 'resolvedImage') {
           return '';
       }
@@ -12718,7 +12929,7 @@
           };
       }
       if (!isExpressionFilter(filter)) {
-          filter = convertFilter(filter);
+          filter = convertFilter$1(filter);
       }
       const filterExp = filter;
       let staticFilter = true;
@@ -12863,16 +13074,16 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
       return false;
   }
-  function convertFilter(filter) {
+  function convertFilter$1(filter) {
       if (!filter)
           return true;
       const op = filter[0];
       if (filter.length <= 1)
           return op !== 'any';
-      const converted = op === '==' ? convertComparisonOp(filter[1], filter[2], '==') : op === '!=' ? convertNegation(convertComparisonOp(filter[1], filter[2], '==')) : op === '<' || op === '>' || op === '<=' || op === '>=' ? convertComparisonOp(filter[1], filter[2], op) : op === 'any' ? convertDisjunctionOp(filter.slice(1)) : op === 'all' ? ['all'].concat(filter.slice(1).map(convertFilter)) : op === 'none' ? ['all'].concat(filter.slice(1).map(convertFilter).map(convertNegation)) : op === 'in' ? convertInOp(filter[1], filter.slice(2)) : op === '!in' ? convertNegation(convertInOp(filter[1], filter.slice(2))) : op === 'has' ? convertHasOp(filter[1]) : op === '!has' ? convertNegation(convertHasOp(filter[1])) : op === 'within' ? filter : 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)) : 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])) : op === 'within' ? filter : true;
       return converted;
   }
-  function convertComparisonOp(property, value, op) {
+  function convertComparisonOp$1(property, value, op) {
       switch (property) {
       case '$type':
           return [
@@ -12893,9 +13104,9 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
   }
   function convertDisjunctionOp(filters) {
-      return ['any'].concat(filters.map(convertFilter));
+      return ['any'].concat(filters.map(convertFilter$1));
   }
-  function convertInOp(property, values) {
+  function convertInOp$1(property, values) {
       if (values.length === 0) {
           return false;
       }
@@ -12938,7 +13149,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           }
       }
   }
-  function convertHasOp(property) {
+  function convertHasOp$1(property) {
       switch (property) {
       case '$type':
           return true;
@@ -12958,7 +13169,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       ];
   }
 
-  function convertFilter$1(filter) {
+  function convertFilter(filter) {
       return _convertFilter(filter, {});
   }
   function _convertFilter(filter, expectedTypes) {
@@ -12973,7 +13184,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       let converted;
       if (op === '==' || op === '!=' || op === '<' || op === '>' || op === '<=' || op === '>=') {
           const [, property, value] = filter;
-          converted = convertComparisonOp$1(property, value, op, expectedTypes);
+          converted = convertComparisonOp(property, value, op, expectedTypes);
       } else if (op === 'any') {
           const children = filter.slice(1).map(f => {
               const types = {};
@@ -12996,15 +13207,15 @@ ${ JSON.stringify(filterExp, null, 2) }
               _convertFilter(['any'].concat(filter.slice(1)), {})
           ];
       } else if (op === 'in') {
-          converted = convertInOp$1(filter[1], filter.slice(2));
+          converted = convertInOp(filter[1], filter.slice(2));
       } else if (op === '!in') {
-          converted = convertInOp$1(filter[1], filter.slice(2), true);
+          converted = convertInOp(filter[1], filter.slice(2), true);
       } else if (op === 'has') {
-          converted = convertHasOp$1(filter[1]);
+          converted = convertHasOp(filter[1]);
       } else if (op === '!has') {
           converted = [
               '!',
-              convertHasOp$1(filter[1])
+              convertHasOp(filter[1])
           ];
       } else {
           converted = true;
@@ -13033,7 +13244,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           return conditions[0];
       return ['all'].concat(conditions);
   }
-  function convertComparisonOp$1(property, value, op, expectedTypes) {
+  function convertComparisonOp(property, value, op, expectedTypes) {
       let get;
       if (property === '$type') {
           return [
@@ -13089,7 +13300,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           value
       ];
   }
-  function convertInOp$1(property, values, negate = false) {
+  function convertInOp(property, values, negate = false) {
       if (values.length === 0)
           return negate;
       let get;
@@ -13127,7 +13338,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           v
       ]));
   }
-  function convertHasOp$1(property) {
+  function convertHasOp(property) {
       if (property === '$type') {
           return true;
       } else if (property === '$id') {
@@ -13148,7 +13359,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       const converted = [];
       eachLayer(style, layer => {
           if (layer.filter) {
-              layer.filter = convertFilter$1(layer.filter);
+              layer.filter = convertFilter(layer.filter);
           }
       });
       eachProperty(style, {
@@ -13675,7 +13886,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
   }
 
-  class ParsingError$1 {
+  class ParsingError {
       constructor(error) {
           this.error = error;
           this.message = error.message;
@@ -14026,7 +14237,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           return [];
       }
       const errors = [];
-      if (e instanceof CompoundExpression) {
+      if (e instanceof CompoundExpression$1) {
           if (disallowedParameters.has(e.name)) {
               return [new ValidationError(options.key, options.value, `["${ e.name }"] expression is not supported in a filter for a ${ options.object.type } layer with id: ${ options.object.id }`)];
           }
@@ -14208,7 +14419,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           if (propertyKey === 'text-field' && style && !style.glyphs) {
               errors.push(new ValidationError(key, value, 'use of "text-field" requires a style "glyphs" property'));
           }
-          if (propertyKey === 'text-font' && isFunction$1(deepUnbundle(value)) && unbundle(value.type) === 'identity') {
+          if (propertyKey === 'text-font' && isFunction(deepUnbundle(value)) && unbundle(value.type) === 'identity') {
               errors.push(new ValidationError(key, value, '"text-font" does not support identity functions'));
           }
       }
@@ -14293,7 +14504,7 @@ ${ JSON.stringify(filterExp, null, 2) }
                   errors.push(new ValidationError(key, layer, `layer "${ layer.id }" must specify a "source-layer"`));
               } else if (sourceType === 'raster-dem' && type !== 'hillshade') {
                   errors.push(new ValidationError(key, layer.source, 'raster-dem source can only be used with layer type \'hillshade\'.'));
-              } else if (type === 'line' && layer.paint && layer.paint['line-gradient'] && (sourceType !== 'geojson' || !source.lineMetrics)) {
+              } 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.`));
               }
           }
@@ -14668,7 +14879,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       const value = options.value;
       const valueSpec = options.valueSpec;
       const styleSpec = options.styleSpec;
-      if (valueSpec.expression && isFunction$1(unbundle(value))) {
+      if (valueSpec.expression && isFunction(unbundle(value))) {
           return validateFunction(options);
       } else if (valueSpec.expression && isExpression(deepUnbundle(value))) {
           return validateExpression(options);
@@ -14695,7 +14906,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       return errors;
   }
 
-  function validateStyle(style, styleSpec = v8) {
+  function validateStyle$1(style, styleSpec = v8) {
       const errors = validate({
           key: '',
           value: style,
@@ -15372,25 +15583,27 @@ ${ JSON.stringify(filterExp, null, 2) }
   }
   });
 
+  var jsonlint$1 = jsonlint;
+
   function readStyle(style) {
       if (style instanceof String || typeof style === 'string' || style instanceof Buffer) {
           try {
-              return jsonlint.parse(style.toString());
+              return jsonlint$1.parse(style.toString());
           } catch (e) {
-              throw new ParsingError$1(e);
+              throw new ParsingError(e);
           }
       }
       return style;
   }
 
-  function validateStyle$1(style, styleSpec = v8) {
+  function validateStyle(style, styleSpec = v8) {
       let s = style;
       try {
           s = readStyle(s);
       } catch (e) {
           return [e];
       }
-      return validateStyle(s, styleSpec);
+      return validateStyle$1(s, styleSpec);
   }
 
   const SUPPORTED_SPEC_VERSION = 8;
@@ -15499,14 +15712,14 @@ ${ JSON.stringify(filterExp, null, 2) }
       } catch (e) {
           return [e];
       }
-      let errors = validateStyle(s, v8).concat(getRootErrors(s, Object.keys(v8.$root)));
+      let errors = validateStyle$1(s, v8).concat(getRootErrors(s, Object.keys(v8.$root)));
       if (s.sources) {
           errors = errors.concat(getSourcesErrors(s.sources));
       }
       return errors;
   }
 
-  const expression$1 = {
+  const expression = {
       StyleExpression,
       isExpression,
       isExpressionFilter,
@@ -15520,7 +15733,7 @@ ${ JSON.stringify(filterExp, null, 2) }
   const styleFunction = {
       convertFunction,
       createFunction,
-      isFunction: isFunction$1
+      isFunction
   };
   const visit = {
       eachSource,
@@ -15528,25 +15741,25 @@ ${ JSON.stringify(filterExp, null, 2) }
       eachProperty
   };
 
-  exports.Color = Color;
-  exports.ParsingError = ParsingError$1;
+  exports.Color = Color$1;
+  exports.ParsingError = ParsingError;
   exports.ValidationError = ValidationError;
   exports.composite = composite;
-  exports.convertFilter = convertFilter$1;
+  exports.convertFilter = convertFilter;
   exports.derefLayers = derefLayers;
   exports.diff = diffStyles;
-  exports.expression = expression$1;
+  exports.expression = expression;
   exports.featureFilter = createFilter;
-  exports.format = format;
-  exports.function = styleFunction;
+  exports.format = format$1;
+  exports["function"] = styleFunction;
   exports.latest = v8;
   exports.migrate = migrate;
   exports.v8 = v8;
-  exports.validate = validateStyle$1;
+  exports.validate = validateStyle;
   exports.validateMapboxApiSupported = validateMapboxApiSupported;
   exports.visit = visit;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=index.cjs.map