@mapbox/mapbox-gl-style-spec 13.24.0-alpha.6 → 13.25.0-beta.1

package/dist/index.es.js

@@ -62,7 +62,7 @@ var $root = {
 	},
 	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,
@@ -2636,7 +2636,7 @@ var function_stop = {
 	length: 2,
 	doc: "Zoom level and value pair."
 };
-var expression = {
+var expression$1 = {
 	type: "array",
 	value: "*",
 	minimum: 1,
@@ -3741,7 +3741,9 @@ var fog = {
 		],
 		"sdk-support": {
 			"basic functionality": {
-				js: "2.3.0"
+				js: "2.3.0",
+				android: "10.6.0",
+				ios: "10.6.0"
 			}
 		}
 	},
@@ -3756,17 +3758,83 @@ var fog = {
 			]
 		},
 		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: {
@@ -3776,10 +3844,46 @@ var fog = {
 			]
 		},
 		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"
 			}
 		}
 	}
@@ -4008,6 +4112,9 @@ var terrain = {
 		},
 		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",
@@ -4575,6 +4682,35 @@ var paint_line = {
 			]
 		},
 		"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 gradient range [0.0, 1.0]. If either 'trim-start' or 'trim-end' offset is out of valid range, the default range will be set.",
+		length: 2,
+		"default": [
+			0,
+			0
+		],
+		transition: false,
+		requires: [
+			"line-gradient",
+			{
+				source: "geojson",
+				has: {
+					lineMetrics: true
+				}
+			}
+		],
+		"sdk-support": {
+			"basic functionality": {
+				js: "2.3.0",
+				android: "10.5.0",
+				ios: "10.5.0",
+				macos: "10.5.0"
+			}
+		},
+		"property-type": "constant"
 	}
 };
 var paint_circle = {
@@ -6320,7 +6456,7 @@ var v8 = {
 	}
 },
 	function_stop: function_stop,
-	expression: expression,
+	expression: expression$1,
 	expression_name: expression_name,
 	fog: fog,
 	light: light,
@@ -6694,6 +6830,8 @@ var jsonStringifyPrettyCompact = function stringify(passedObj, options) {
   })(passedObj, "", 0);
 };
 
+var stringifyPretty = jsonStringifyPrettyCompact;
+
 function sortKeysBy(obj, reference) {
     const result = {};
     for (const key in reference) {
@@ -6708,12 +6846,12 @@ function sortKeysBy(obj, reference) {
     }
     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 : {};
@@ -7381,7 +7519,7 @@ exports.encode = exports.stringify = encode;
 var parse = urlParse;
 var resolve = urlResolve;
 var resolveObject = urlResolveObject;
-var format$1 = urlFormat;
+var format = urlFormat;
 
 var Url_1 = Url;
 
@@ -8088,7 +8226,7 @@ var url = {
 	parse: parse,
 	resolve: resolve,
 	resolveObject: resolveObject,
-	format: format$1,
+	format: format,
 	Url: Url_1
 };
 
@@ -8169,7 +8307,7 @@ function resolveConstant(style, value) {
         return value;
     }
 }
-function isFunction(value) {
+function isFunction$1(value) {
     return Array.isArray(value.stops);
 }
 function renameProperty(obj, from, to) {
@@ -8211,7 +8349,7 @@ function migrateToV8 (style) {
         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]);
             });
@@ -8302,13 +8440,14 @@ function extend (output, ...inputs) {
     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 = []) {
@@ -8336,6 +8475,7 @@ class Scope {
         return this.parent ? this.parent.has(name) : false;
     }
 }
+var Scope$1 = Scope;
 
 const NullType = { kind: 'null' };
 const NumberType = { kind: 'number' };
@@ -8348,16 +8488,16 @@ const ErrorType = { kind: 'error' };
 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;
@@ -8371,7 +8511,7 @@ const valueMemberTypes = [
     ColorType,
     FormattedType,
     ObjectType,
-    array(ValueType),
+    array$1(ValueType),
     ResolvedImageType
 ];
 function checkSubtype(expected, t) {
@@ -8390,7 +8530,7 @@ function checkSubtype(expected, t) {
             }
         }
     }
-    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);
@@ -8654,12 +8794,36 @@ class Color {
             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) {
@@ -8801,7 +8965,7 @@ function isValue(mixed) {
         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;
@@ -8836,7 +9000,7 @@ function typeOf(value) {
         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;
@@ -8858,18 +9022,18 @@ function typeOf(value) {
                 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);
@@ -8908,7 +9072,7 @@ class Literal {
                 '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();
@@ -8917,6 +9081,7 @@ class Literal {
         }
     }
 }
+var Literal$1 = Literal;
 
 class RuntimeError {
     constructor(message) {
@@ -8927,8 +9092,9 @@ class RuntimeError {
         return this.message;
     }
 }
+var RuntimeError$1 = RuntimeError;
 
-const types = {
+const types$1 = {
     string: StringType,
     number: NumberType,
     boolean: BooleanType,
@@ -8949,9 +9115,9 @@ class Assertion {
             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;
@@ -8964,9 +9130,9 @@ class Assertion {
                 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++) {
@@ -8984,7 +9150,7 @@ class Assertion {
             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;
@@ -9011,6 +9177,7 @@ class Assertion {
         return serialized.concat(this.args.map(arg => arg.serialize()));
     }
 }
+var Assertion$1 = Assertion;
 
 class FormatExpression {
     constructor(sections) {
@@ -9039,7 +9206,7 @@ class FormatExpression {
                 }
                 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;
                 }
@@ -9077,7 +9244,7 @@ class FormatExpression {
             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));
     }
@@ -9153,7 +9320,7 @@ class ImageExpression {
     }
 }
 
-const types$1 = {
+const types = {
     'to-boolean': BooleanType,
     'to-color': ColorType,
     'to-number': NumberType,
@@ -9170,7 +9337,7 @@ class Coercion {
         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);
@@ -9189,7 +9356,7 @@ class Coercion {
             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);
@@ -9202,11 +9369,11 @@ class Coercion {
                         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) {
@@ -9218,13 +9385,13 @@ class Coercion {
                     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) {
@@ -9252,6 +9419,7 @@ class Coercion {
         return serialized;
     }
 }
+var Coercion$1 = Coercion;
 
 const geometryTypes = [
     'Unknown',
@@ -9272,7 +9440,7 @@ class EvaluationContext {
         this.featureDistanceData = null;
     }
     id() {
-        return this.feature && 'id' in this.feature ? this.feature.id : null;
+        return this.feature && 'id' in this.feature && this.feature.id ? this.feature.id : null;
     }
     geometryType() {
         return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
@@ -9303,11 +9471,12 @@ class EvaluationContext {
     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) {
@@ -9342,7 +9511,7 @@ class CompoundExpression {
         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++) {
@@ -9383,7 +9552,7 @@ class CompoundExpression {
                 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.`);
         }
@@ -9398,11 +9567,12 @@ class CompoundExpression {
 }
 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) {
@@ -9625,6 +9795,8 @@ function getTilePoints(geometry, pointBBox, polyBBox, canonical) {
         canonical.y * EXTENT
     ];
     const tilePoints = [];
+    if (!geometry)
+        return tilePoints;
     for (const points of geometry) {
         for (const point of points) {
             const p = [
@@ -9644,6 +9816,8 @@ function getTileLines(geometry, lineBBox, polyBBox, canonical) {
         canonical.y * EXTENT
     ];
     const tileLines = [];
+    if (!geometry)
+        return tileLines;
     for (const line of geometry) {
         const tileLine = [];
         for (const point of line) {
@@ -9680,6 +9854,9 @@ function pointsWithinPolygons(ctx, polygonGeometry) {
         -Infinity
     ];
     const canonical = ctx.canonicalID();
+    if (!canonical) {
+        return false;
+    }
     if (polygonGeometry.type === 'Polygon') {
         const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
         const tilePoints = getTilePoints(ctx.geometry(), pointBBox, polyBBox, canonical);
@@ -9716,6 +9893,9 @@ function linesWithinPolygons(ctx, polygonGeometry) {
         -Infinity
     ];
     const canonical = ctx.canonicalID();
+    if (!canonical) {
+        return false;
+    }
     if (polygonGeometry.type === 'Polygon') {
         const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
         const tileLines = getTileLines(ctx.geometry(), lineBBox, polyBBox, canonical);
@@ -9789,9 +9969,10 @@ class Within {
         ];
     }
 }
+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') {
@@ -9804,7 +9985,7 @@ function isFeatureConstant(e) {
             return false;
         }
     }
-    if (e instanceof Within) {
+    if (e instanceof Within$1) {
         return false;
     }
     let result = true;
@@ -9816,7 +9997,7 @@ function isFeatureConstant(e) {
     return result;
 }
 function isStateConstant(e) {
-    if (e instanceof CompoundExpression) {
+    if (e instanceof CompoundExpression$1) {
         if (e.name === 'feature-state') {
             return false;
         }
@@ -9830,7 +10011,7 @@ function isStateConstant(e) {
     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;
@@ -9872,9 +10053,10 @@ class Var {
         ];
     }
 }
+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('');
@@ -9897,9 +10079,9 @@ class ParsingContext {
         }
         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;
             }
@@ -9929,10 +10111,10 @@ class ParsingContext {
                         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;
@@ -9956,7 +10138,7 @@ class ParsingContext {
     }
     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);
@@ -9965,23 +10147,24 @@ class ParsingContext {
         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) {
@@ -10017,7 +10200,7 @@ function findStopLessThanOrEqualTo(stops, input) {
         } 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;
@@ -10111,6 +10294,7 @@ class Step {
         return serialized;
     }
 }
+var Step$1 = Step;
 
 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
@@ -10221,9 +10405,9 @@ 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));
+    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);
     });
@@ -10233,7 +10417,7 @@ var interpolate = /*#__PURE__*/Object.freeze({
   __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;
@@ -10264,7 +10448,7 @@ function labToRgb(labColor) {
     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 {
@@ -10412,7 +10596,7 @@ class Interpolate {
             ]);
         }
         if (outputType.kind !== 'number' && outputType.kind !== 'color' && !(outputType.kind === 'array' && outputType.itemType.kind === 'number' && typeof outputType.N === 'number')) {
-            return context.error(`Type ${ toString(outputType) } is not interpolatable.`);
+            return context.error(`Type ${ toString$1(outputType) } is not interpolatable.`);
         }
         return new Interpolate(outputType, operator, interpolation, input, stops);
     }
@@ -10491,6 +10675,7 @@ function exponentialInterpolation(input, base, lowerValue, upperValue) {
         return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
     }
 }
+var Interpolate$1 = Interpolate;
 
 class Coalesce {
     constructor(type, args) {
@@ -10552,6 +10737,7 @@ class Coalesce {
         return serialized;
     }
 }
+var Coalesce$1 = Coalesce;
 
 class Let {
     constructor(bindings, result) {
@@ -10605,6 +10791,7 @@ class Let {
         return serialized;
     }
 }
+var Let$1 = Let;
 
 class At {
     constructor(type, index, input) {
@@ -10616,7 +10803,7 @@ class At {
         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;
@@ -10626,13 +10813,13 @@ class At {
         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];
     }
@@ -10651,6 +10838,7 @@ class At {
         ];
     }
 }
+var At$1 = At;
 
 class In {
     constructor(needle, haystack) {
@@ -10673,7 +10861,7 @@ class In {
                 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);
     }
@@ -10688,13 +10876,13 @@ class In {
                 '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;
     }
@@ -10713,6 +10901,7 @@ class In {
         ];
     }
 }
+var In$1 = In;
 
 class IndexOf {
     constructor(needle, haystack, fromIndex) {
@@ -10736,7 +10925,7 @@ class IndexOf {
                 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);
@@ -10756,13 +10945,13 @@ class IndexOf {
                 '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);
@@ -10797,6 +10986,7 @@ class IndexOf {
         ];
     }
 }
+var IndexOf$1 = IndexOf;
 
 class Match {
     constructor(inputType, outputType, input, cases, outputs, otherwise) {
@@ -10909,6 +11099,7 @@ class Match {
         return serialized;
     }
 }
+var Match$1 = Match;
 
 class Case {
     constructor(type, branches, otherwise) {
@@ -10970,6 +11161,7 @@ class Case {
         return serialized;
     }
 }
+var Case$1 = Case;
 
 class Slice {
     constructor(type, input, beginIndex, endIndex) {
@@ -10987,11 +11179,11 @@ class Slice {
         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);
@@ -11009,7 +11201,7 @@ class Slice {
                 '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);
@@ -11044,6 +11236,7 @@ class Slice {
         ];
     }
 }
+var Slice$1 = Slice;
 
 function isComparableType(op, type) {
     if (op === '==' || op === '!=') {
@@ -11106,22 +11299,22 @@ function makeComparison(op, compareBasic, compareWithCollator) {
             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;
@@ -11142,7 +11335,7 @@ function makeComparison(op, compareBasic, compareWithCollator) {
                 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) {
@@ -11284,7 +11477,7 @@ class Length {
         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) {
@@ -11294,7 +11487,7 @@ class Length {
         } 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) {
@@ -11311,6 +11504,7 @@ class Length {
         return serialized;
     }
 }
+var Length$1 = Length;
 
 const expressions = {
     '==': Equals,
@@ -11319,35 +11513,35 @@ const expressions = {
     '<': 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);
@@ -11356,8 +11550,8 @@ function rgba(ctx, [r, g, b, a]) {
     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;
@@ -11381,21 +11575,21 @@ function binarySearch(v, a, i, j) {
 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();
@@ -11781,19 +11975,19 @@ CompoundExpression.register(expressions, {
     ],
     '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
     ],
@@ -11801,7 +11995,7 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [
             StringType,
-            array(ValueType)
+            array$1(ValueType)
         ],
         (ctx, [k, v]) => binarySearch(ctx.properties()[k.value], v.value, 0, v.value.length - 1)
     ],
@@ -11878,7 +12072,7 @@ CompoundExpression.register(expressions, {
     '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,
@@ -11886,6 +12080,7 @@ CompoundExpression.register(expressions, {
         (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
     ]
 });
+var definitions = expressions;
 
 function success(value) {
     return {
@@ -11926,7 +12121,7 @@ function getType(val) {
     }
 }
 
-function isFunction$1(value) {
+function isFunction(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function identityFunction(x) {
@@ -11944,14 +12139,14 @@ function createFunction(parameters, propertySpec) {
             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]) {
@@ -12008,7 +12203,7 @@ function createFunction(parameters, propertySpec) {
         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({
@@ -12025,7 +12220,7 @@ function createFunction(parameters, propertySpec) {
         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)
         };
@@ -12035,14 +12230,14 @@ function createFunction(parameters, propertySpec) {
             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)
@@ -12052,11 +12247,11 @@ function coalesce(a, b, c) {
 }
 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];
@@ -12070,7 +12265,7 @@ function evaluateIntervalFunction(parameters, propertySpec, input) {
 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];
@@ -12103,7 +12298,7 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
 }
 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') {
@@ -12111,7 +12306,7 @@ function evaluateIdentityFunction(parameters, propertySpec, input) {
     } 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;
@@ -12129,7 +12324,7 @@ class StyleExpression {
     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;
     }
@@ -12137,7 +12332,7 @@ class StyleExpression {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature;
         this._evaluator.featureState = featureState;
-        this._evaluator.canonical = canonical;
+        this._evaluator.canonical = canonical || null;
         this._evaluator.availableImages = availableImages || null;
         this._evaluator.formattedSection = formattedSection;
         this._evaluator.featureTileCoord = featureTileCoord || null;
@@ -12148,7 +12343,7 @@ class StyleExpression {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature || null;
         this._evaluator.featureState = featureState || null;
-        this._evaluator.canonical = canonical;
+        this._evaluator.canonical = canonical || null;
         this._evaluator.availableImages = availableImages || null;
         this._evaluator.formattedSection = formattedSection || null;
         this._evaluator.featureTileCoord = featureTileCoord || null;
@@ -12159,7 +12354,7 @@ class StyleExpression {
                 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) {
@@ -12174,10 +12369,10 @@ class StyleExpression {
     }
 }
 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);
@@ -12213,7 +12408,7 @@ class ZoomDependentExpression {
     }
     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;
         }
@@ -12227,7 +12422,7 @@ function createPropertyExpression(expression, propertySpec) {
     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',
@@ -12235,20 +12430,20 @@ function createPropertyExpression(expression, propertySpec) {
         '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 {
@@ -12268,7 +12463,7 @@ class StylePropertyFunction {
     }
 }
 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);
@@ -12279,7 +12474,7 @@ function normalizePropertyExpression(value, specification) {
     } else {
         let constant = value;
         if (typeof value === 'string' && specification.type === 'color') {
-            constant = Color.parse(value);
+            constant = Color$1.parse(value);
         }
         return {
             kind: 'constant',
@@ -12289,29 +12484,29 @@ function normalizePropertyExpression(value, specification) {
 }
 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;
@@ -12327,15 +12522,15 @@ function getExpectedType(spec) {
         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 {
@@ -12464,14 +12659,14 @@ function convertZoomAndPropertyFunction(parameters, propertySpec, stops) {
         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 '';
     }
@@ -12705,7 +12900,7 @@ function createFilter(filter, layerType = 'fill') {
         };
     }
     if (!isExpressionFilter(filter)) {
-        filter = convertFilter(filter);
+        filter = convertFilter$1(filter);
     }
     const filterExp = filter;
     let staticFilter = true;
@@ -12850,16 +13045,16 @@ function geometryNeeded(filter) {
     }
     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 [
@@ -12880,9 +13075,9 @@ function convertComparisonOp(property, value, op) {
     }
 }
 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;
     }
@@ -12925,7 +13120,7 @@ function convertInOp(property, values) {
         }
     }
 }
-function convertHasOp(property) {
+function convertHasOp$1(property) {
     switch (property) {
     case '$type':
         return true;
@@ -12945,7 +13140,7 @@ function convertNegation(filter) {
     ];
 }
 
-function convertFilter$1(filter) {
+function convertFilter(filter) {
     return _convertFilter(filter, {});
 }
 function _convertFilter(filter, expectedTypes) {
@@ -12960,7 +13155,7 @@ function _convertFilter(filter, expectedTypes) {
     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 = {};
@@ -12983,15 +13178,15 @@ function _convertFilter(filter, expectedTypes) {
             _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;
@@ -13020,7 +13215,7 @@ function runtimeTypeChecks(expectedTypes) {
         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 [
@@ -13076,7 +13271,7 @@ function convertComparisonOp$1(property, value, op, expectedTypes) {
         value
     ];
 }
-function convertInOp$1(property, values, negate = false) {
+function convertInOp(property, values, negate = false) {
     if (values.length === 0)
         return negate;
     let get;
@@ -13114,7 +13309,7 @@ function convertInOp$1(property, values, negate = false) {
         v
     ]));
 }
-function convertHasOp$1(property) {
+function convertHasOp(property) {
     if (property === '$type') {
         return true;
     } else if (property === '$id') {
@@ -13135,7 +13330,7 @@ function migrateToExpressions (style) {
     const converted = [];
     eachLayer(style, layer => {
         if (layer.filter) {
-            layer.filter = convertFilter$1(layer.filter);
+            layer.filter = convertFilter(layer.filter);
         }
     });
     eachProperty(style, {
@@ -13662,7 +13857,7 @@ class ValidationError {
     }
 }
 
-class ParsingError$1 {
+class ParsingError {
     constructor(error) {
         this.error = error;
         this.message = error.message;
@@ -13695,7 +13890,8 @@ function validateObject(options) {
             validateElement = elementValidators['*'];
         } else if (elementSpecs['*']) {
             validateElement = validate;
-        } else {
+        }
+        if (!validateElement) {
             errors.push(new ValidationError(key, object[objectKey], `unknown property "${ objectKey }"`));
             continue;
         }
@@ -13740,7 +13936,8 @@ function validateArray(options) {
         'type': arraySpec.value,
         'values': arraySpec.values,
         'minimum': arraySpec.minimum,
-        'maximum': arraySpec.maximum
+        'maximum': arraySpec.maximum,
+        function: undefined
     };
     if (styleSpec.$version < 7) {
         arrayElementSpec.function = arraySpec.function;
@@ -13877,11 +14074,15 @@ function validateFunction(options) {
             if (value[0].value === undefined) {
                 return [new ValidationError(key, value, 'object stop key must have value')];
             }
-            if (previousStopDomainZoom && previousStopDomainZoom > unbundle(value[0].zoom)) {
+            const nextStopDomainZoom = unbundle(value[0].zoom);
+            if (typeof nextStopDomainZoom !== 'number') {
+                return [new ValidationError(key, value[0].zoom, 'stop zoom values must be numbers')];
+            }
+            if (previousStopDomainZoom && previousStopDomainZoom > nextStopDomainZoom) {
                 return [new ValidationError(key, value[0].zoom, 'stop zoom values must appear in ascending order')];
             }
-            if (unbundle(value[0].zoom) !== previousStopDomainZoom) {
-                previousStopDomainZoom = unbundle(value[0].zoom);
+            if (nextStopDomainZoom !== previousStopDomainZoom) {
+                previousStopDomainZoom = nextStopDomainZoom;
                 previousStopDomainValue = undefined;
                 stopDomainValues = {};
             }
@@ -13925,7 +14126,7 @@ function validateFunction(options) {
         } else if (type !== stopKeyType) {
             return [new ValidationError(options.key, reportValue, `${ type } stop domain type must match previous stop domain type ${ stopKeyType }`)];
         }
-        if (type !== 'number' && type !== 'string' && type !== 'boolean') {
+        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')];
         }
         if (type !== 'number' && functionType !== 'categorical') {
@@ -13935,10 +14136,10 @@ function validateFunction(options) {
             }
             return [new ValidationError(options.key, reportValue, message)];
         }
-        if (functionType === 'categorical' && type === 'number' && (!isFinite(value) || Math.floor(value) !== value)) {
-            return [new ValidationError(options.key, reportValue, `integer expected, found ${ value }`)];
+        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) }`)];
         }
-        if (functionType !== 'categorical' && type === 'number' && previousStopDomainValue !== undefined && value < previousStopDomainValue) {
+        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')];
         } else {
             previousStopDomainValue = value;
@@ -13998,14 +14199,16 @@ function disallowedFilterParameters(e, options) {
         'pitch',
         'distance-from-center'
     ]);
-    for (const param of options.valueSpec.expression.parameters) {
-        disallowedParameters.delete(param);
+    if (options.valueSpec && options.valueSpec.expression) {
+        for (const param of options.valueSpec.expression.parameters) {
+            disallowedParameters.delete(param);
+        }
     }
     if (disallowedParameters.size === 0) {
         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 }`)];
         }
@@ -14058,10 +14261,10 @@ function validateEnum(options) {
 
 function validateFilter(options) {
     if (isExpressionFilter(deepUnbundle(options.value))) {
-        const layerType = deepUnbundle(options.layerType);
+        const layerType = options.layerType || 'fill';
         return validateExpression(extend({}, options, {
             expressionContext: 'filter',
-            valueSpec: options.styleSpec[`filter_${ layerType || 'fill' }`]
+            valueSpec: options.styleSpec[`filter_${ layerType }`]
         }));
     } else {
         return validateNonExpressionFilter(options);
@@ -14187,7 +14390,7 @@ function validateProperty(options, propertyType) {
         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'));
         }
     }
@@ -14249,7 +14452,8 @@ function validateLayer(options) {
                 parent = layer;
         });
         if (!parent) {
-            errors.push(new ValidationError(key, layer.ref, `ref layer "${ ref }" not found`));
+            if (typeof ref === 'string')
+                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 {
@@ -14273,6 +14477,8 @@ function validateLayer(options) {
                 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)) {
                 errors.push(new ValidationError(key, layer, `layer "${ layer.id }" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`));
+            } else if (type === 'line' && layer.paint && layer.paint['line-trim-offset'] && !layer.paint['line-gradient']) {
+                errors.push(new ValidationError(key, layer, `layer "${ layer.id }" specifies a line-trim-offset, which requires line-gradient enabled.`));
             }
         }
     }
@@ -14305,6 +14511,7 @@ function validateLayer(options) {
                     layer,
                     key: options.key,
                     value: options.value,
+                    valueSpec: {},
                     style: options.style,
                     styleSpec: options.styleSpec,
                     objectElementValidators: {
@@ -14319,6 +14526,7 @@ function validateLayer(options) {
                     layer,
                     key: options.key,
                     value: options.value,
+                    valueSpec: {},
                     style: options.style,
                     styleSpec: options.styleSpec,
                     objectElementValidators: {
@@ -14537,7 +14745,7 @@ function validateTerrain(options) {
         if (!source) {
             errors.push(new ValidationError(key, terrain.source, `source "${ terrain.source }" not found`));
         } else if (sourceType !== 'raster-dem') {
-            errors.push(new ValidationError(key, terrain.source, `terrain cannot be used with a source of type ${ sourceType }, it only be used with a "raster-dem" source type`));
+            errors.push(new ValidationError(key, terrain.source, `terrain cannot be used with a source of type ${ String(sourceType) }, it only be used with a "raster-dem" source type`));
         }
     }
     return errors;
@@ -14644,7 +14852,7 @@ function validate(options) {
     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);
@@ -14671,7 +14879,7 @@ function validateGlyphsURL (options) {
     return errors;
 }
 
-function validateStyle(style, styleSpec = v8) {
+function validateStyle$1(style, styleSpec = v8) {
     const errors = validate({
         key: '',
         value: style,
@@ -14686,7 +14894,7 @@ function validateStyle(style, styleSpec = v8) {
     return sortErrors(errors);
 }
 function sortErrors(errors) {
-    return errors.slice().sort((a, b) => a.line - b.line);
+    return errors.slice().sort((a, b) => a.line && b.line ? a.line - b.line : 0);
 }
 
 /* parser generated by jison 0.4.15 */
@@ -15348,25 +15556,27 @@ exports.parse = function () { return parser.parse.apply(parser, arguments); };
 }
 });
 
+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;
@@ -15475,14 +15685,14 @@ function validateMapboxApiSupported(style) {
     } 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,
@@ -15496,7 +15706,7 @@ const expression$1 = {
 const styleFunction = {
     convertFunction,
     createFunction,
-    isFunction: isFunction$1
+    isFunction
 };
 const visit = {
     eachSource,
@@ -15504,5 +15714,5 @@ const visit = {
     eachProperty
 };
 
-export { Color, ParsingError$1 as ParsingError, ValidationError, composite, convertFilter$1 as convertFilter, derefLayers, diffStyles as diff, expression$1 as expression, createFilter as featureFilter, format, styleFunction as function, v8 as latest, migrate, v8, validateStyle$1 as validate, validateMapboxApiSupported, visit };
+export { Color$1 as Color, ParsingError, ValidationError, composite, convertFilter, derefLayers, diffStyles as diff, expression, createFilter as featureFilter, format$1 as format, styleFunction as function, v8 as latest, migrate, v8, validateStyle as validate, validateMapboxApiSupported, visit };
 //# sourceMappingURL=index.es.js.map