@mapbox/mapbox-gl-style-spec 14.4.0-beta.1 → 14.4.0

package/dist/index.es.js

@@ -957,11 +957,21 @@ var source_geojson = {
 	generateId: {
 		type: "boolean",
 		"default": false,
-		doc: "Whether to generate ids for the geojson features. When enabled, the `feature.id` property will be auto assigned based on its index in the `features` array, over-writing any previous values."
+		doc: "Whether to generate ids for the GeoJSON features. When enabled, the `feature.id` property will be auto assigned based on its index in the `features` array, over-writing any previous values."
 	},
 	promoteId: {
 		type: "promoteId",
 		doc: "A property to use as a feature id (for feature state). Either a property name, or an object of the form `{<sourceLayer>: <propertyName>}`."
+	},
+	dynamic: {
+		type: "boolean",
+		"default": false,
+		doc: "Whether to optimize this source for frequent data updates (e.g. animating features).",
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.4.0"
+			}
+		}
 	}
 };
 var source_video = {
@@ -7898,6 +7908,43 @@ var paint_model = {
 			}
 		},
 		"property-type": "data-constant"
+	},
+	"model-front-cutoff": {
+		type: "array",
+		"private": true,
+		value: "number",
+		"property-type": "data-constant",
+		transition: false,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		length: 3,
+		"default": [
+			0,
+			0,
+			1
+		],
+		minimum: [
+			0,
+			0,
+			0
+		],
+		maximum: [
+			1,
+			1,
+			1
+		],
+		doc: "An array for configuring the fade-out effect for the front cutoff of content on pitched map views. It contains three values: start, range and final opacity. The start parameter defines the point at which the fade-out effect begins, with smaller values causing the effect to start earlier. The range parameter specifies how long the fade-out effect will last. A value of 0.0 for range makes content disappear immediately without a fade-out effect. The final opacity determines content opacity at the end of the fade-out effect. A value of 1.0 for final opacity means that the cutoff is completely disabled.",
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.5.0",
+				android: "11.5.0",
+				ios: "11.5.0"
+			}
+		}
 	}
 };
 var transition = {
@@ -9293,7 +9340,6 @@ let ParsingError$1 = class ParsingError extends Error {
         this.key = key;
     }
 };
-var ParsingError$2 = ParsingError$1;
 
 //      
 /**
@@ -9326,7 +9372,6 @@ class Scope {
         return this.parent ? this.parent.has(name) : false;
     }
 }
-var Scope$1 = Scope;
 
 //      
 const NullType = { kind: 'null' };
@@ -10927,7 +10972,6 @@ class Literal {
         }
     }
 }
-var Literal$1 = Literal;
 
 //      
 class RuntimeError {
@@ -10939,7 +10983,6 @@ class RuntimeError {
         return this.message;
     }
 }
-var RuntimeError$1 = RuntimeError;
 
 const types$1 = {
     string: StringType,
@@ -10997,7 +11040,7 @@ class Assertion {
             if (!error) {
                 return value;
             } else if (i === this.args.length - 1) {
-                throw new RuntimeError$1(`Expected value to be of type ${ toString$1(this.type) }, but found ${ toString$1(typeOf(value)) } instead.`);
+                throw new RuntimeError(`Expected value to be of type ${ toString$1(this.type) }, but found ${ toString$1(typeOf(value)) } instead.`);
             }
         }
         return null;
@@ -11024,7 +11067,6 @@ class Assertion {
         return serialized.concat(this.args.map(arg => arg.serialize()));
     }
 }
-var Assertion$1 = Assertion;
 
 //      
 class FormatExpression {
@@ -11311,7 +11353,7 @@ class Coercion {
                     }
                 }
             }
-            throw new RuntimeError$1(error || `Could not parse color from value '${ typeof input === 'string' ? input : String(JSON.stringify(input)) }'`);
+            throw new RuntimeError(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) {
@@ -11323,7 +11365,7 @@ class Coercion {
                     continue;
                 return num;
             }
-            throw new RuntimeError$1(`Could not convert ${ JSON.stringify(value) } to number.`);
+            throw new RuntimeError(`Could not convert ${ JSON.stringify(value) } to number.`);
         } else if (this.type.kind === 'formatted') {
             // There is no explicit 'to-formatted' but this coercion can be implicitly
             // created by properties that expect the 'formatted' type.
@@ -11363,7 +11405,6 @@ class Coercion {
         return serialized;
     }
 }
-var Coercion$1 = Coercion;
 
 //      
 const geometryTypes = [
@@ -11432,7 +11473,6 @@ class EvaluationContext {
         return this.options ? this.options.get(id) : null;
     }
 }
-var EvaluationContext$1 = EvaluationContext;
 
 //      
 class CompoundExpression {
@@ -11483,7 +11523,7 @@ class CompoundExpression {
             overloadIndex++;
             // Use a fresh context for each attempted signature so that, if
             // we eventually succeed, we haven't polluted `context.errors`.
-            signatureContext = new ParsingContext$1(context.registry, context.path, null, context.scope, undefined, context._scope, context.options);
+            signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, undefined, context._scope, context.options);
             // First parse all the args, potentially coercing to the
             // types expected by this overload.
             const parsedArgs = [];
@@ -11551,7 +11591,6 @@ function stringifySignature(signature) {
         return `(${ toString$1(signature.type) }...)`;
     }
 }
-var CompoundExpression$1 = CompoundExpression;
 
 //      
 class CollatorExpression {
@@ -11612,57 +11651,6 @@ class CollatorExpression {
     }
 }
 
-function quickselect(arr, k, left, right, compare) {
-    quickselectStep(arr, k, left || 0, right || arr.length - 1, compare || defaultCompare$1);
-}
-function quickselectStep(arr, k, left, right, compare) {
-    while (right > left) {
-        if (right - left > 600) {
-            var n = right - left + 1;
-            var m = k - left + 1;
-            var z = Math.log(n);
-            var s = 0.5 * Math.exp(2 * z / 3);
-            var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
-            var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
-            var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
-            quickselectStep(arr, k, newLeft, newRight, compare);
-        }
-        var t = arr[k];
-        var i = left;
-        var j = right;
-        swap(arr, left, k);
-        if (compare(arr[right], t) > 0)
-            swap(arr, left, right);
-        while (i < j) {
-            swap(arr, i, j);
-            i++;
-            j--;
-            while (compare(arr[i], t) < 0)
-                i++;
-            while (compare(arr[j], t) > 0)
-                j--;
-        }
-        if (compare(arr[left], t) === 0)
-            swap(arr, left, j);
-        else {
-            j++;
-            swap(arr, j, right);
-        }
-        if (j <= k)
-            left = j + 1;
-        if (k <= j)
-            right = j - 1;
-    }
-}
-function swap(arr, i, j) {
-    var tmp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = tmp;
-}
-function defaultCompare$1(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-
 //      
 // minX, minY, maxX, maxY
 /**
@@ -11679,9 +11667,6 @@ function calculateSignedArea(ring) {
     }
     return sum;
 }
-function compareAreas(a, b) {
-    return b.area - a.area;
-}
 // classifies an array of rings into polygons with outer rings and holes
 function classifyRings(rings, maxRings) {
     const len = rings.length;
@@ -11706,16 +11691,6 @@ function classifyRings(rings, maxRings) {
     }
     if (polygon)
         polygons.push(polygon);
-    // Earcut performance degrades with the # of rings in a polygon. For this
-    // reason, we limit strip out all but the `maxRings` largest rings.
-    if (maxRings > 1) {
-        for (let j = 0; j < polygons.length; j++) {
-            if (polygons[j].length <= maxRings)
-                continue;
-            quickselect(polygons[j], maxRings, 1, polygons[j].length - 1, compareAreas);
-            polygons[j] = polygons[j].slice(0, maxRings);
-        }
-    }
     return polygons;
 }
 function updateBBox(bbox, coord) {
@@ -12078,7 +12053,6 @@ class Within {
         ];
     }
 }
-var Within$1 = Within;
 
 /*       */
 const factors = {
@@ -13408,7 +13382,7 @@ function linesToGeometryDistance(originGeometry, canonical, geometry) {
 }
 function polygonsToGeometryDistance(originGeometry, canonical, geometry) {
     const lngLatPolygons = [];
-    for (const polygon of classifyRings(originGeometry, 0)) {
+    for (const polygon of classifyRings(originGeometry)) {
         const lngLatPolygon = [];
         for (let i = 0; i < polygon.length; ++i) {
             lngLatPolygon.push(getLngLatPoints(polygon[i], canonical));
@@ -13497,7 +13471,6 @@ class Distance {
         ];
     }
 }
-var Distance$1 = Distance;
 
 //      
 function coerceValue(type, value) {
@@ -13546,12 +13519,12 @@ class Config {
             return context.error(`Invalid number of arguments for 'config' expression.`);
         }
         const configKey = context.parse(args[1], 1);
-        if (!(configKey instanceof Literal$1)) {
+        if (!(configKey instanceof Literal)) {
             return context.error(`Key name of 'config' expression must be a string literal.`);
         }
         if (args.length >= 3) {
             const configScope = context.parse(args[2], 2);
-            if (!(configScope instanceof Literal$1)) {
+            if (!(configScope instanceof Literal)) {
                 return context.error(`Scope of 'config' expression must be a string literal.`);
             }
             return new Config(type, toString(configKey.value), toString(configScope.value));
@@ -13616,11 +13589,10 @@ class Config {
         return res;
     }
 }
-var Config$1 = Config;
 
 //      
 function isFeatureConstant(e) {
-    if (e instanceof CompoundExpression$1) {
+    if (e instanceof CompoundExpression) {
         if (e.name === 'get' && e.args.length === 1) {
             return false;
         } else if (e.name === 'feature-state') {
@@ -13633,10 +13605,10 @@ function isFeatureConstant(e) {
             return false;
         }
     }
-    if (e instanceof Within$1) {
+    if (e instanceof Within) {
         return false;
     }
-    if (e instanceof Distance$1) {
+    if (e instanceof Distance) {
         return false;
     }
     let result = true;
@@ -13648,7 +13620,7 @@ function isFeatureConstant(e) {
     return result;
 }
 function isStateConstant(e) {
-    if (e instanceof CompoundExpression$1) {
+    if (e instanceof CompoundExpression) {
         if (e.name === 'feature-state') {
             return false;
         }
@@ -13662,7 +13634,7 @@ function isStateConstant(e) {
     return result;
 }
 function isConfigConstant(e) {
-    if (e instanceof Config$1) {
+    if (e instanceof Config) {
         return false;
     }
     let result = true;
@@ -13674,7 +13646,7 @@ function isConfigConstant(e) {
     return result;
 }
 function isGlobalPropertyConstant(e, properties) {
-    if (e instanceof CompoundExpression$1 && properties.indexOf(e.name) >= 0) {
+    if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) {
         return false;
     }
     let result = true;
@@ -13717,7 +13689,6 @@ class Var {
         ];
     }
 }
-var Var$1 = Var;
 
 //      
 /**
@@ -13729,7 +13700,7 @@ class ParsingContext {
     // implementations to infer argument types: Expression#parse() need not
     // check that the output type of the parsed expression matches
     // `expectedType`.
-    constructor(registry, path = [], expectedType, scope = new Scope$1(), errors = [], _scope, options) {
+    constructor(registry, path = [], expectedType, scope = new Scope(), errors = [], _scope, options) {
         this.registry = registry;
         this.path = path;
         this.key = path.map(part => `[${ part }]`).join('');
@@ -13761,9 +13732,9 @@ class ParsingContext {
         }
         function annotate(parsed, type, typeAnnotation) {
             if (typeAnnotation === 'assert') {
-                return new Assertion$1(type, [parsed]);
+                return new Assertion(type, [parsed]);
             } else if (typeAnnotation === 'coerce') {
-                return new Coercion$1(type, [parsed]);
+                return new Coercion(type, [parsed]);
             } else {
                 return parsed;
             }
@@ -13800,10 +13771,10 @@ class ParsingContext {
                 // it immediately and replace it with a literal value in the
                 // parsed/compiled result. Expressions that expect an image should
                 // not be resolved here so we can later get the available images.
-                if (!(parsed instanceof Literal$1) && parsed.type.kind !== 'resolvedImage' && isConstant(parsed)) {
-                    const ec = new EvaluationContext$1(this._scope, this.options);
+                if (!(parsed instanceof Literal) && parsed.type.kind !== 'resolvedImage' && isConstant(parsed)) {
+                    const ec = new EvaluationContext(this._scope, this.options);
                     try {
-                        parsed = new Literal$1(parsed.type, parsed.evaluate(ec));
+                        parsed = new Literal(parsed.type, parsed.evaluate(ec));
                     } catch (e) {
                         this.error(e.message);
                         return null;
@@ -13812,7 +13783,7 @@ class ParsingContext {
                 return parsed;
             }
             // Try to parse as array
-            return Coercion$1.parse([
+            return Coercion.parse([
                 'to-array',
                 expr
             ], this);
@@ -13846,7 +13817,7 @@ class ParsingContext {
      */
     error(error, ...keys) {
         const key = `${ this.key }${ keys.map(k => `[${ k }]`).join('') }`;
-        this.errors.push(new ParsingError$2(key, error));
+        this.errors.push(new ParsingError$1(key, error));
     }
     /**
      * Returns null if `t` is a subtype of `expected`; otherwise returns an
@@ -13859,25 +13830,24 @@ class ParsingContext {
         return error;
     }
 }
-var ParsingContext$1 = ParsingContext;
 function isConstant(expression) {
-    if (expression instanceof Var$1) {
+    if (expression instanceof Var) {
         return isConstant(expression.boundExpression);
-    } else if (expression instanceof CompoundExpression$1 && expression.name === 'error') {
+    } else if (expression instanceof CompoundExpression && expression.name === 'error') {
         return false;
     } else if (expression instanceof CollatorExpression) {
         // Although the results of a Collator expression with fixed arguments
         // generally shouldn't change between executions, we can't serialize them
         // as constant expressions because results change based on environment.
         return false;
-    } else if (expression instanceof Within$1) {
+    } else if (expression instanceof Within) {
         return false;
-    } else if (expression instanceof Distance$1) {
+    } else if (expression instanceof Distance) {
         return false;
-    } else if (expression instanceof Config$1) {
+    } else if (expression instanceof Config) {
         return false;
     }
-    const isTypeAnnotation = expression instanceof Coercion$1 || expression instanceof Assertion$1;
+    const isTypeAnnotation = expression instanceof Coercion || expression instanceof Assertion;
     let childrenConstant = true;
     expression.eachChild(child => {
         // We can _almost_ assume that if `expressions` children are constant,
@@ -13889,7 +13859,7 @@ function isConstant(expression) {
         if (isTypeAnnotation) {
             childrenConstant = childrenConstant && isConstant(child);
         } else {
-            childrenConstant = childrenConstant && child instanceof Literal$1;
+            childrenConstant = childrenConstant && child instanceof Literal;
         }
     });
     if (!childrenConstant) {
@@ -13934,7 +13904,7 @@ function findStopLessThanOrEqualTo(stops, input) {
         } else if (currentValue > input) {
             upperIndex = currentIndex - 1;
         } else {
-            throw new RuntimeError$1('Input is not a number.');
+            throw new RuntimeError('Input is not a number.');
         }
     }
     return 0;
@@ -14029,7 +13999,6 @@ class Step {
         return serialized;
     }
 }
-var Step$1 = Step;
 
 var unitbezier = UnitBezier;
 function UnitBezier(p1x, p1y, p2x, p2y) {
@@ -14417,7 +14386,6 @@ 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) {
@@ -14488,7 +14456,6 @@ class Coalesce {
         return serialized;
     }
 }
-var Coalesce$1 = Coalesce;
 
 //      
 class Let {
@@ -14543,7 +14510,6 @@ class Let {
         return serialized;
     }
 }
-var Let$1 = Let;
 
 //      
 class At {
@@ -14566,13 +14532,13 @@ class At {
         const index = this.index.evaluate(ctx);
         const array = this.input.evaluate(ctx);
         if (index < 0) {
-            throw new RuntimeError$1(`Array index out of bounds: ${ index } < 0.`);
+            throw new RuntimeError(`Array index out of bounds: ${ index } < 0.`);
         }
         if (index >= array.length) {
-            throw new RuntimeError$1(`Array index out of bounds: ${ index } > ${ array.length - 1 }.`);
+            throw new RuntimeError(`Array index out of bounds: ${ index } > ${ array.length - 1 }.`);
         }
         if (index !== Math.floor(index)) {
-            throw new RuntimeError$1(`Array index must be an integer, but found ${ index } instead.`);
+            throw new RuntimeError(`Array index must be an integer, but found ${ index } instead.`);
         }
         return array[index];
     }
@@ -14591,7 +14557,6 @@ class At {
         ];
     }
 }
-var At$1 = At;
 
 //      
 class In {
@@ -14630,13 +14595,13 @@ class In {
                 'number',
                 'null'
             ])) {
-            throw new RuntimeError$1(`Expected first argument to be of type boolean, string, number or null, but found ${ toString$1(typeOf(needle)) } instead.`);
+            throw new RuntimeError(`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$1(`Expected second argument to be of type array or string, but found ${ toString$1(typeOf(haystack)) } instead.`);
+            throw new RuntimeError(`Expected second argument to be of type array or string, but found ${ toString$1(typeOf(haystack)) } instead.`);
         }
         return haystack.indexOf(needle) >= 0;
     }
@@ -14655,7 +14620,6 @@ class In {
         ];
     }
 }
-var In$1 = In;
 
 //      
 class IndexOf {
@@ -14700,13 +14664,13 @@ class IndexOf {
                 'number',
                 'null'
             ])) {
-            throw new RuntimeError$1(`Expected first argument to be of type boolean, string, number or null, but found ${ toString$1(typeOf(needle)) } instead.`);
+            throw new RuntimeError(`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$1(`Expected second argument to be of type array or string, but found ${ toString$1(typeOf(haystack)) } instead.`);
+            throw new RuntimeError(`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);
@@ -14741,7 +14705,6 @@ class IndexOf {
         ];
     }
 }
-var IndexOf$1 = IndexOf;
 
 // Map input label values to output expression index
 class Match {
@@ -14864,7 +14827,6 @@ class Match {
         return serialized;
     }
 }
-var Match$1 = Match;
 
 class Case {
     constructor(type, branches, otherwise) {
@@ -14926,7 +14888,6 @@ class Case {
         return serialized;
     }
 }
-var Case$1 = Case;
 
 //      
 class Slice {
@@ -14967,7 +14928,7 @@ class Slice {
                 'string',
                 'array'
             ])) {
-            throw new RuntimeError$1(`Expected first argument to be of type array or string, but found ${ toString$1(typeOf(input)) } instead.`);
+            throw new RuntimeError(`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);
@@ -15002,7 +14963,6 @@ class Slice {
         ];
     }
 }
-var Slice$1 = Slice;
 
 //      
 function isComparableType(op, type) {
@@ -15102,10 +15062,10 @@ function makeComparison(op, compareBasic, compareWithCollator) {
                 // typing rules specific to less/greater than operators
                 if (lhs.type.kind === 'value' && rhs.type.kind !== 'value') {
                     // (value, T)
-                    lhs = new Assertion$1(rhs.type, [lhs]);
+                    lhs = new Assertion(rhs.type, [lhs]);
                 } else if (lhs.type.kind !== 'value' && rhs.type.kind === 'value') {
                     // (T, value)
-                    rhs = new Assertion$1(lhs.type, [rhs]);
+                    rhs = new Assertion(lhs.type, [rhs]);
                 }
             }
             let collator = null;
@@ -15127,7 +15087,7 @@ function makeComparison(op, compareBasic, compareWithCollator) {
                 const rt = typeOf(rhs);
                 // check that type is string or number, and equal
                 if (lt.kind !== rt.kind || !(lt.kind === 'string' || lt.kind === 'number')) {
-                    throw new RuntimeError$1(`Expected arguments for "${ op }" to be (string, string) or (number, number), but found (${ lt.kind }, ${ rt.kind }) instead.`);
+                    throw new RuntimeError(`Expected arguments for "${ op }" to be (string, string) or (number, number), but found (${ lt.kind }, ${ rt.kind }) instead.`);
                 }
             }
             if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
@@ -15300,7 +15260,7 @@ class Length {
         } else if (Array.isArray(input)) {
             return input.length;
         } else {
-            throw new RuntimeError$1(`Expected value to be of type string or array, but found ${ toString$1(typeOf(input)) } instead.`);
+            throw new RuntimeError(`Expected value to be of type string or array, but found ${ toString$1(typeOf(input)) } instead.`);
         }
     }
     eachChild(fn) {
@@ -15317,7 +15277,6 @@ class Length {
         return serialized;
     }
 }
-var Length$1 = Length;
 
 //      
 // Seeded pseudo random generator function
@@ -15341,14 +15300,14 @@ const expressions = {
     '>=': GreaterThanOrEqual,
     '<=': LessThanOrEqual,
     // $FlowFixMe[method-unbinding]
-    'array': Assertion$1,
+    'array': Assertion,
     // $FlowFixMe[method-unbinding]
-    'at': At$1,
-    'boolean': Assertion$1,
+    'at': At,
+    'boolean': Assertion,
     // $FlowFixMe[method-unbinding]
-    'case': Case$1,
+    'case': Case,
     // $FlowFixMe[method-unbinding]
-    'coalesce': Coalesce$1,
+    'coalesce': Coalesce,
     // $FlowFixMe[method-unbinding]
     'collator': CollatorExpression,
     // $FlowFixMe[method-unbinding]
@@ -15356,43 +15315,43 @@ const expressions = {
     // $FlowFixMe[method-unbinding]
     'image': ImageExpression,
     // $FlowFixMe[method-unbinding]
-    'in': In$1,
+    'in': In,
     // $FlowFixMe[method-unbinding]
-    'index-of': IndexOf$1,
+    'index-of': IndexOf,
     // $FlowFixMe[method-unbinding]
-    'interpolate': Interpolate$1,
-    'interpolate-hcl': Interpolate$1,
-    'interpolate-lab': Interpolate$1,
+    'interpolate': Interpolate,
+    'interpolate-hcl': Interpolate,
+    'interpolate-lab': Interpolate,
     // $FlowFixMe[method-unbinding]
-    'length': Length$1,
+    'length': Length,
     // $FlowFixMe[method-unbinding]
-    'let': Let$1,
+    'let': Let,
     // $FlowFixMe[method-unbinding]
-    'literal': Literal$1,
+    'literal': Literal,
     // $FlowFixMe[method-unbinding]
-    'match': Match$1,
-    'number': Assertion$1,
+    'match': Match,
+    'number': Assertion,
     // $FlowFixMe[method-unbinding]
     'number-format': NumberFormat,
-    'object': Assertion$1,
+    'object': Assertion,
     // $FlowFixMe[method-unbinding]
-    'slice': Slice$1,
+    'slice': Slice,
     // $FlowFixMe[method-unbinding]
-    'step': Step$1,
-    'string': Assertion$1,
+    'step': Step,
+    'string': Assertion,
     // $FlowFixMe[method-unbinding]
-    'to-boolean': Coercion$1,
-    'to-color': Coercion$1,
-    'to-number': Coercion$1,
-    'to-string': Coercion$1,
+    'to-boolean': Coercion,
+    'to-color': Coercion,
+    'to-number': Coercion,
+    'to-string': Coercion,
     // $FlowFixMe[method-unbinding]
-    'var': Var$1,
+    'var': Var,
     // $FlowFixMe[method-unbinding]
-    'within': Within$1,
+    'within': Within,
     // $FlowFixMe[method-unbinding]
-    'distance': Distance$1,
+    'distance': Distance,
     // $FlowFixMe[method-unbinding]
-    'config': Config$1
+    'config': Config
 };
 function rgba(ctx, [r, g, b, a]) {
     r = r.evaluate(ctx);
@@ -15401,7 +15360,7 @@ 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$1(error);
+        throw new RuntimeError(error);
     return new Color$1(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
 }
 function hsla(ctx, [h, s, l, a]) {
@@ -15411,11 +15370,11 @@ function hsla(ctx, [h, s, l, a]) {
     const alpha = a ? a.evaluate(ctx) : 1;
     const error = validateHSLA(h, s, l, alpha);
     if (error)
-        throw new RuntimeError$1(error);
+        throw new RuntimeError(error);
     const colorFunction = `hsla(${ h }, ${ s }%, ${ l }%, ${ alpha })`;
     const color = Color$1.parse(colorFunction);
     if (!color)
-        throw new RuntimeError$1(`Failed to parse HSLA color: ${ colorFunction }`);
+        throw new RuntimeError(`Failed to parse HSLA color: ${ colorFunction }`);
     return color;
 }
 function has(key, obj) {
@@ -15452,12 +15411,12 @@ function hashString(str) {
     }
     return hash;
 }
-CompoundExpression$1.register(expressions, {
+CompoundExpression.register(expressions, {
     'error': [
         ErrorType,
         [StringType],
         (ctx, [v]) => {
-            throw new RuntimeError$1(v.evaluate(ctx));
+            throw new RuntimeError(v.evaluate(ctx));
         }
     ],
     'typeof': [
@@ -16017,14 +15976,13 @@ CompoundExpression$1.register(expressions, {
             } else if (typeof seed === 'number') {
                 seedVal = seed;
             } else {
-                throw new RuntimeError$1(`Invalid seed input: ${ seed }`);
+                throw new RuntimeError(`Invalid seed input: ${ seed }`);
             }
             const random = mulberry32(seedVal)();
             return min + random * (max - min);
         }
     ]
 });
-var definitions = expressions;
 
 //      
 /**
@@ -16149,7 +16107,7 @@ function createFunction(parameters, propertySpec) {
         return {
             kind: 'composite',
             interpolationType,
-            interpolationFactor: Interpolate$1.interpolationFactor.bind(undefined, interpolationType),
+            interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
             zoomStops: featureFunctionStops.map(s => s[0]),
             evaluate({zoom}, properties) {
                 return evaluateExponentialFunction({
@@ -16166,7 +16124,7 @@ function createFunction(parameters, propertySpec) {
         return {
             kind: 'camera',
             interpolationType,
-            interpolationFactor: Interpolate$1.interpolationFactor.bind(undefined, interpolationType),
+            interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
             zoomStops: parameters.stops.map(s => s[0]),
             evaluate: ({zoom}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
         };
@@ -16314,7 +16272,7 @@ class StyleExpression {
     constructor(expression, propertySpec, scope, options) {
         this.expression = expression;
         this._warningHistory = {};
-        this._evaluator = new EvaluationContext$1(scope, options);
+        this._evaluator = new EvaluationContext(scope, options);
         this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
     }
@@ -16345,7 +16303,7 @@ class StyleExpression {
                 return this._defaultValue;
             }
             if (this._enumValues && !(val in this._enumValues)) {
-                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.`);
+                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.`);
             }
             return val;
         } catch (e) {
@@ -16360,7 +16318,7 @@ class StyleExpression {
     }
 }
 function isExpression(expression) {
-    return Array.isArray(expression) && expression.length > 0 && typeof expression[0] === 'string' && expression[0] in definitions;
+    return Array.isArray(expression) && expression.length > 0 && typeof expression[0] === 'string' && expression[0] in expressions;
 }
 /**
  * Parse and typecheck the given style spec JSON expression.  If
@@ -16372,7 +16330,7 @@ function isExpression(expression) {
  * @private
  */
 function createExpression(expression, propertySpec, scope, options) {
-    const parser = new ParsingContext$1(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined, undefined, undefined, scope, options);
+    const parser = new ParsingContext(expressions, [], propertySpec ? getExpectedType(propertySpec) : undefined, undefined, undefined, scope, options);
     // For string-valued properties, coerce to string at the top level rather than asserting.
     const parsed = parser.parse(expression, undefined, undefined, undefined, propertySpec && propertySpec.type === 'string' ? { typeAnnotation: 'coerce' } : undefined);
     if (!parsed) {
@@ -16413,7 +16371,7 @@ class ZoomDependentExpression {
     }
     interpolationFactor(input, lower, upper) {
         if (this.interpolationType) {
-            return Interpolate$1.interpolationFactor(this.interpolationType, input, lower, upper);
+            return Interpolate.interpolationFactor(this.interpolationType, input, lower, upper);
         } else {
             return 0;
         }
@@ -16427,7 +16385,7 @@ function createPropertyExpression(expression, propertySpec, scope, options) {
     const parsed = expression.value.expression;
     const isFeatureConstant$1 = isFeatureConstant(parsed);
     if (!isFeatureConstant$1 && !supportsPropertyExpression(propertySpec)) {
-        return error([new ParsingError$2('', 'data expressions not supported')]);
+        return error([new ParsingError$1('', 'data expressions not supported')]);
     }
     const isZoomConstant = isGlobalPropertyConstant(parsed, [
         'zoom',
@@ -16435,25 +16393,25 @@ function createPropertyExpression(expression, propertySpec, scope, options) {
         'distance-from-center'
     ]);
     if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
-        return error([new ParsingError$2('', 'zoom expressions not supported')]);
+        return error([new ParsingError$1('', 'zoom expressions not supported')]);
     }
     const isLightConstant = isGlobalPropertyConstant(parsed, ['measure-light']);
     if (!isLightConstant && !supportsLightExpression(propertySpec)) {
-        return error([new ParsingError$2('', 'measure-light expression not supported')]);
+        return error([new ParsingError$1('', 'measure-light expression not supported')]);
     }
     const canRelaxZoomRestriction = propertySpec.expression && propertySpec.expression.relaxZoomRestriction;
     const zoomCurve = findZoomCurve(parsed);
     if (!zoomCurve && !isZoomConstant && !canRelaxZoomRestriction) {
-        return error([new ParsingError$2('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression, or in the properties of atmosphere.')]);
-    } else if (zoomCurve instanceof ParsingError$2) {
+        return error([new ParsingError$1('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression, or in the properties of atmosphere.')]);
+    } else if (zoomCurve instanceof ParsingError$1) {
         return error([zoomCurve]);
-    } else if (zoomCurve instanceof Interpolate$1 && !supportsInterpolation(propertySpec)) {
-        return error([new ParsingError$2('', '"interpolate" expressions cannot be used with this property')]);
+    } else if (zoomCurve instanceof Interpolate && !supportsInterpolation(propertySpec)) {
+        return error([new ParsingError$1('', '"interpolate" expressions cannot be used with this property')]);
     }
     if (!zoomCurve) {
         return success(isFeatureConstant$1 ? new ZoomConstantExpression('constant', expression.value, isLightConstant) : new ZoomConstantExpression('source', expression.value, isLightConstant));
     }
-    const interpolationType = zoomCurve instanceof Interpolate$1 ? zoomCurve.interpolation : undefined;
+    const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
     return success(isFeatureConstant$1 ? new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant) : new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant));
 }
 // serialization wrapper for old-style stop functions normalized to the
@@ -16501,27 +16459,27 @@ function normalizePropertyExpression(value, specification, scope, options) {
 // "coalesce" expressions.
 function findZoomCurve(expression) {
     let result = null;
-    if (expression instanceof Let$1) {
+    if (expression instanceof Let) {
         result = findZoomCurve(expression.result);
-    } else if (expression instanceof Coalesce$1) {
+    } else if (expression instanceof Coalesce) {
         for (const arg of expression.args) {
             result = findZoomCurve(arg);
             if (result) {
                 break;
             }
         }
-    } else if ((expression instanceof Step$1 || expression instanceof Interpolate$1) && expression.input instanceof CompoundExpression$1 && expression.input.name === 'zoom') {
+    } else if ((expression instanceof Step || expression instanceof Interpolate) && expression.input instanceof CompoundExpression && expression.input.name === 'zoom') {
         result = expression;
     }
-    if (result instanceof ParsingError$2) {
+    if (result instanceof ParsingError$1) {
         return result;
     }
     expression.eachChild(child => {
         const childResult = findZoomCurve(child);
-        if (childResult instanceof ParsingError$2) {
+        if (childResult instanceof ParsingError$1) {
             result = childResult;
         } else if (result && childResult && result !== childResult) {
-            result = new ParsingError$2('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
+            result = new ParsingError$1('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
         }
     });
     return result;
@@ -18670,7 +18628,7 @@ function disallowedFilterParameters(e, options) {
         return [];
     }
     const errors = [];
-    if (e instanceof CompoundExpression$1) {
+    if (e instanceof CompoundExpression) {
         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 }`)];
         }