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

package/dist/index.cjs

@@ -963,11 +963,21 @@
   	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 = {
@@ -7904,6 +7914,43 @@
   			}
   		},
   		"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 = {
@@ -9299,7 +9346,6 @@
           this.key = key;
       }
   };
-  var ParsingError$2 = ParsingError$1;
 
   //      
   /**
@@ -9332,7 +9378,6 @@
           return this.parent ? this.parent.has(name) : false;
       }
   }
-  var Scope$1 = Scope;
 
   //      
   const NullType = { kind: 'null' };
@@ -10933,7 +10978,6 @@
           }
       }
   }
-  var Literal$1 = Literal;
 
   //      
   class RuntimeError {
@@ -10945,7 +10989,6 @@
           return this.message;
       }
   }
-  var RuntimeError$1 = RuntimeError;
 
   const types$1 = {
       string: StringType,
@@ -11003,7 +11046,7 @@
               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;
@@ -11030,7 +11073,6 @@
           return serialized.concat(this.args.map(arg => arg.serialize()));
       }
   }
-  var Assertion$1 = Assertion;
 
   //      
   class FormatExpression {
@@ -11317,7 +11359,7 @@
                       }
                   }
               }
-              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) {
@@ -11329,7 +11371,7 @@
                       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.
@@ -11369,7 +11411,6 @@
           return serialized;
       }
   }
-  var Coercion$1 = Coercion;
 
   //      
   const geometryTypes = [
@@ -11438,7 +11479,6 @@
           return this.options ? this.options.get(id) : null;
       }
   }
-  var EvaluationContext$1 = EvaluationContext;
 
   //      
   class CompoundExpression {
@@ -11489,7 +11529,7 @@
               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 = [];
@@ -11557,7 +11597,6 @@
           return `(${ toString$1(signature.type) }...)`;
       }
   }
-  var CompoundExpression$1 = CompoundExpression;
 
   //      
   class CollatorExpression {
@@ -11618,57 +11657,6 @@
       }
   }
 
-  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
   /**
@@ -11685,9 +11673,6 @@
       }
       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;
@@ -11712,16 +11697,6 @@
       }
       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) {
@@ -12084,7 +12059,6 @@
           ];
       }
   }
-  var Within$1 = Within;
 
   /*       */
   const factors = {
@@ -13414,7 +13388,7 @@
   }
   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));
@@ -13503,7 +13477,6 @@
           ];
       }
   }
-  var Distance$1 = Distance;
 
   //      
   function coerceValue(type, value) {
@@ -13552,12 +13525,12 @@
               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));
@@ -13622,11 +13595,10 @@
           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') {
@@ -13639,10 +13611,10 @@
               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;
@@ -13654,7 +13626,7 @@
       return result;
   }
   function isStateConstant(e) {
-      if (e instanceof CompoundExpression$1) {
+      if (e instanceof CompoundExpression) {
           if (e.name === 'feature-state') {
               return false;
           }
@@ -13668,7 +13640,7 @@
       return result;
   }
   function isConfigConstant(e) {
-      if (e instanceof Config$1) {
+      if (e instanceof Config) {
           return false;
       }
       let result = true;
@@ -13680,7 +13652,7 @@
       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;
@@ -13723,7 +13695,6 @@
           ];
       }
   }
-  var Var$1 = Var;
 
   //      
   /**
@@ -13735,7 +13706,7 @@
       // 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('');
@@ -13767,9 +13738,9 @@
           }
           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;
               }
@@ -13806,10 +13777,10 @@
                   // 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;
@@ -13818,7 +13789,7 @@
                   return parsed;
               }
               // Try to parse as array
-              return Coercion$1.parse([
+              return Coercion.parse([
                   'to-array',
                   expr
               ], this);
@@ -13852,7 +13823,7 @@
        */
       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
@@ -13865,25 +13836,24 @@
           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,
@@ -13895,7 +13865,7 @@
           if (isTypeAnnotation) {
               childrenConstant = childrenConstant && isConstant(child);
           } else {
-              childrenConstant = childrenConstant && child instanceof Literal$1;
+              childrenConstant = childrenConstant && child instanceof Literal;
           }
       });
       if (!childrenConstant) {
@@ -13940,7 +13910,7 @@
           } 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;
@@ -14035,7 +14005,6 @@
           return serialized;
       }
   }
-  var Step$1 = Step;
 
   var unitbezier = UnitBezier;
   function UnitBezier(p1x, p1y, p2x, p2y) {
@@ -14423,7 +14392,6 @@
           return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
       }
   }
-  var Interpolate$1 = Interpolate;
 
   class Coalesce {
       constructor(type, args) {
@@ -14494,7 +14462,6 @@
           return serialized;
       }
   }
-  var Coalesce$1 = Coalesce;
 
   //      
   class Let {
@@ -14549,7 +14516,6 @@
           return serialized;
       }
   }
-  var Let$1 = Let;
 
   //      
   class At {
@@ -14572,13 +14538,13 @@
           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];
       }
@@ -14597,7 +14563,6 @@
           ];
       }
   }
-  var At$1 = At;
 
   //      
   class In {
@@ -14636,13 +14601,13 @@
                   '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;
       }
@@ -14661,7 +14626,6 @@
           ];
       }
   }
-  var In$1 = In;
 
   //      
   class IndexOf {
@@ -14706,13 +14670,13 @@
                   '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);
@@ -14747,7 +14711,6 @@
           ];
       }
   }
-  var IndexOf$1 = IndexOf;
 
   // Map input label values to output expression index
   class Match {
@@ -14870,7 +14833,6 @@
           return serialized;
       }
   }
-  var Match$1 = Match;
 
   class Case {
       constructor(type, branches, otherwise) {
@@ -14932,7 +14894,6 @@
           return serialized;
       }
   }
-  var Case$1 = Case;
 
   //      
   class Slice {
@@ -14973,7 +14934,7 @@
                   '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);
@@ -15008,7 +14969,6 @@
           ];
       }
   }
-  var Slice$1 = Slice;
 
   //      
   function isComparableType(op, type) {
@@ -15108,10 +15068,10 @@
                   // 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;
@@ -15133,7 +15093,7 @@
                   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) {
@@ -15306,7 +15266,7 @@
           } 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) {
@@ -15323,7 +15283,6 @@
           return serialized;
       }
   }
-  var Length$1 = Length;
 
   //      
   // Seeded pseudo random generator function
@@ -15347,14 +15306,14 @@
       '>=': 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]
@@ -15362,43 +15321,43 @@
       // $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);
@@ -15407,7 +15366,7 @@
       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]) {
@@ -15417,11 +15376,11 @@
       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) {
@@ -15458,12 +15417,12 @@
       }
       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': [
@@ -16023,14 +15982,13 @@
               } 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;
 
   //      
   /**
@@ -16155,7 +16113,7 @@
           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({
@@ -16172,7 +16130,7 @@
           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)
           };
@@ -16320,7 +16278,7 @@
       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;
       }
@@ -16351,7 +16309,7 @@
                   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) {
@@ -16366,7 +16324,7 @@
       }
   }
   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
@@ -16378,7 +16336,7 @@
    * @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) {
@@ -16419,7 +16377,7 @@
       }
       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;
           }
@@ -16433,7 +16391,7 @@
       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',
@@ -16441,25 +16399,25 @@
           '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
@@ -16507,27 +16465,27 @@
   // "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;
@@ -18676,7 +18634,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           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 }`)];
           }