@mapbox/mapbox-gl-style-spec 14.6.0 → 14.7.0-beta.1

package/dist/index.cjs

@@ -214,6 +214,71 @@
   			"spruce1-lod1": "asset://spruce1-lod1.glb",
   			"spruce1-lod2": "asset://spruce1-lod2.glb"
   		}
+  	},
+  	featuresets: {
+  		experimental: true,
+  		type: "featuresets",
+  		doc: "Defines sets of features for querying, interaction, and feature state manipulation.",
+  		example: {
+  			poi: {
+  				selectors: [
+  					{
+  						layer: "poi",
+  						properties: {
+  							type: [
+  								"get",
+  								"type"
+  							],
+  							name: [
+  								"get",
+  								"name"
+  							],
+  							brand: "ABC"
+  						}
+  					}
+  				]
+  			}
+  		}
+  	}
+  };
+  var featuresets = {
+  	experimental: true,
+  	"*": {
+  		type: "featureset",
+  		doc: "Defines a combined set of features from one or more underlying layers within the current style. Features in a style featureset can be queried, interacted with, and their states can be queried and updated."
+  	}
+  };
+  var featureset = {
+  	experimental: true,
+  	selectors: {
+  		type: "array",
+  		value: "selector",
+  		doc: "A collection of categorized selectors."
+  	}
+  };
+  var selector = {
+  	experimental: true,
+  	layer: {
+  		type: "string",
+  		doc: "The ID of a layer that exists in the current style.",
+  		required: true
+  	},
+  	properties: {
+  		type: "selectorProperty",
+  		required: false,
+  		doc: "Properties accessible to the end user through queried feautures. If properties are empty, no feature properties are exposed. If undefined, all original feature properties will be accessible."
+  	},
+  	featureNamespace: {
+  		type: "string",
+  		required: false,
+  		doc: "An optional field that represents the feature namespace defined by the selector within a featureset to which this feature belongs. If the underlying source is the same for multiple selectors within a featureset, the same featureNamespace should be used across those selectors."
+  	}
+  };
+  var selectorProperty = {
+  	experimental: true,
+  	"*": {
+  		type: "*",
+  		doc: "The value of the property. It can be an expression that generates the returned value from the feature, or a constant value specifying the returned value."
   	}
   };
   var model = {
@@ -383,9 +448,6 @@
   		"default": false,
   		doc: "Enable/Disable shadow casting for this light",
   		transition: false,
-  		expression: {
-  			interpolated: false
-  		},
   		"property-type": "data-constant",
   		"sdk-support": {
   			"basic functionality": {
@@ -471,7 +533,7 @@
   				doc: "The position of the light source is aligned to the rotation of the map."
   			},
   			viewport: {
-  				doc: "The position of the light source is aligned to the rotation of the viewport."
+  				doc: "The position of the light source is aligned to the rotation of the viewport. If terrain is enabled, performance regressions may occur in certain scenarios, particularly on lower-end hardware. Ensure that you test your target scenarios on the appropriate hardware to verify performance."
   			}
   		},
   		"property-type": "data-constant",
@@ -5240,6 +5302,30 @@
   			]
   		},
   		"property-type": "data-constant"
+  	},
+  	"fill-z-offset": {
+  		type: "number",
+  		doc: "Specifies an uniform elevation in meters. Note: If the value is zero, the layer will be rendered on the ground. Non-zero values will elevate the layer from the sea level, which can cause it to be rendered below the terrain.",
+  		"default": 0,
+  		minimum: 0,
+  		transition: true,
+  		experimental: true,
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "3.7.0"
+  			},
+  			"data-driven styling": {
+  				js: "3.7.0"
+  			}
+  		},
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom",
+  				"feature"
+  			]
+  		},
+  		"property-type": "data-driven"
   	}
   };
   var paint_line = {
@@ -6974,6 +7060,62 @@
   			interpolated: false
   		},
   		"property-type": "data-constant"
+  	},
+  	"symbol-z-offset": {
+  		type: "number",
+  		doc: "Specifies an uniform elevation from the ground, in meters.",
+  		"default": 0,
+  		minimum: 0,
+  		transition: true,
+  		experimental: true,
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "3.7.0",
+  				android: "11.7.0",
+  				ios: "11.7.0"
+  			},
+  			"data-driven styling": {
+  				js: "3.7.0",
+  				android: "11.7.0",
+  				ios: "11.7.0"
+  			}
+  		},
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom",
+  				"feature"
+  			]
+  		},
+  		"property-type": "data-driven"
+  	},
+  	"symbol-elevation-reference": {
+  		type: "enum",
+  		doc: "Selects the base of symbol-elevation.",
+  		values: {
+  			sea: {
+  				doc: "Elevate symbols relative to the sea level."
+  			},
+  			ground: {
+  				doc: "Elevate symbols relative to the ground's height below them."
+  			}
+  		},
+  		"default": "ground",
+  		experimental: true,
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "3.7.0",
+  				android: "11.7.0",
+  				ios: "11.7.0"
+  			}
+  		},
+  		expression: {
+  			interpolated: false,
+  			parameters: [
+  				"zoom"
+  			]
+  		},
+  		"property-type": "data-constant"
   	}
   };
   var paint_raster = {
@@ -8246,6 +8388,10 @@
   var v8 = {
   	$version: $version,
   	$root: $root,
+  	featuresets: featuresets,
+  	featureset: featureset,
+  	selector: selector,
+  	selectorProperty: selectorProperty,
   	model: model,
   	"import": {
   	id: {
@@ -8374,7 +8520,6 @@
   	"fill-extrusion-edge-radius": {
   		type: "number",
   		experimental: true,
-  		"private": true,
   		"default": 0,
   		minimum: 0,
   		maximum: 1,
@@ -8748,7 +8893,6 @@
   	"fill-extrusion-ambient-occlusion-intensity": {
   		"property-type": "data-constant",
   		type: "number",
-  		"private": true,
   		"default": 0,
   		minimum: 0,
   		maximum: 1,
@@ -8771,7 +8915,6 @@
   	"fill-extrusion-ambient-occlusion-radius": {
   		"property-type": "data-constant",
   		type: "number",
-  		"private": true,
   		"default": 3,
   		minimum: 0,
   		expression: {
@@ -8960,7 +9103,7 @@
   		experimental: true,
   		units: "meters",
   		"default": 0,
-  		doc: "The extent of the flood light effect on the ground beneath the extruded buildings in meters.",
+  		doc: "The extent of the flood light effect on the ground beneath the extruded buildings in meters. Note: this experimental property is evaluated once per tile, during tile initialization. Changing the property value could trigger tile reload. The `feature-state` styling is deprecated and will get removed soon.",
   		requires: [
   			"lights"
   		],
@@ -9107,14 +9250,19 @@
   		"default": 0,
   		minimum: 0,
   		transition: true,
+  		experimental: true,
   		units: "meters",
   		doc: "If a non-zero value is provided, it sets the fill-extrusion layer into wall rendering mode. The value is used to render the feature with the given width over the outlines of the geometry. Note: This property is experimental and some other fill-extrusion properties might not be supported with non-zero line width.",
   		"sdk-support": {
   			"basic functionality": {
-  				js: "3.7.0"
+  				js: "3.7.0",
+  				android: "11.7.0",
+  				ios: "11.7.0"
   			},
   			"data-driven styling": {
-  				js: "3.7.0"
+  				js: "3.7.0",
+  				android: "11.7.0",
+  				ios: "11.7.0"
   			}
   		},
   		expression: {
@@ -9128,27 +9276,16 @@
   		},
   		"property-type": "data-driven"
   	},
-  	"fill-extrusion-line-alignment": {
-  		type: "enum",
-  		values: {
-  			inside: {
-  				doc: "Aligns the wall inside of the outline."
-  			},
-  			outside: {
-  				doc: "Aligns the wall outside of the outline."
-  			},
-  			center: {
-  				doc: "Aligns the wall relative to the center of the outline."
-  			}
-  		},
-  		"default": "center",
-  		doc: "Specifies the alignment for offset of the walls relative to the outlines of the geometry. For open-ended line string geometries the positioning is considered based on the ordering of the points, where inside is in clockwise order and outside is counter-clockwise. This property only has an effect if a non-zero fill-extrusion-line-width is used. Center alignment is automatically used for non-closed lines.",
-  		requires: [
-  			"fill-extrusion-line-width"
-  		],
+  	"fill-extrusion-cast-shadows": {
+  		type: "boolean",
+  		"default": true,
+  		doc: "Enable/Disable shadow casting for this layer",
+  		transition: false,
   		"sdk-support": {
   			"basic functionality": {
-  				js: "3.7.0"
+  				js: "3.7.0",
+  				android: "11.8.0",
+  				ios: "11.8.0"
   			}
   		},
   		"property-type": "data-constant"
@@ -11440,19 +11577,19 @@
                   nextTokenMayBeObject = false;
                   let scale = null;
                   if (arg['font-scale']) {
-                      scale = context.parse(arg['font-scale'], 1, NumberType);
+                      scale = context.parseObjectValue(arg['font-scale'], i, 'font-scale', NumberType);
                       if (!scale)
                           return null;
                   }
                   let font = null;
                   if (arg['text-font']) {
-                      font = context.parse(arg['text-font'], 1, array$1(StringType));
+                      font = context.parseObjectValue(arg['text-font'], i, 'text-font', array$1(StringType));
                       if (!font)
                           return null;
                   }
                   let textColor = null;
                   if (arg['text-color']) {
-                      textColor = context.parse(arg['text-color'], 1, ColorType);
+                      textColor = context.parseObjectValue(arg['text-color'], i, 'text-color', ColorType);
                       if (!textColor)
                           return null;
                   }
@@ -11461,7 +11598,7 @@
                   lastExpression.font = font;
                   lastExpression.textColor = textColor;
               } else {
-                  const content = context.parse(args[i], 1, ValueType);
+                  const content = context.parse(args[i], i, ValueType);
                   if (!content)
                       return null;
                   const kind = content.type.kind;
@@ -11922,15 +12059,15 @@
           const options = args[1];
           if (typeof options !== 'object' || Array.isArray(options))
               return context.error(`Collator options argument must be an object.`);
-          const caseSensitive = context.parse(options['case-sensitive'] === void 0 ? false : options['case-sensitive'], 1, BooleanType);
+          const caseSensitive = options['case-sensitive'] === void 0 ? context.parse(false, 1, BooleanType) : context.parseObjectValue(options['case-sensitive'], 1, 'case-sensitive', BooleanType);
           if (!caseSensitive)
               return null;
-          const diacriticSensitive = context.parse(options['diacritic-sensitive'] === void 0 ? false : options['diacritic-sensitive'], 1, BooleanType);
+          const diacriticSensitive = options['diacritic-sensitive'] === void 0 ? context.parse(false, 1, BooleanType) : context.parseObjectValue(options['diacritic-sensitive'], 1, 'diacritic-sensitive', BooleanType);
           if (!diacriticSensitive)
               return null;
           let locale = null;
           if (options['locale']) {
-              locale = context.parse(options['locale'], 1, StringType);
+              locale = context.parseObjectValue(options['locale'], 1, 'locale', StringType);
               if (!locale)
                   return null;
           }
@@ -12776,295 +12913,6 @@
       return deg;
   }
 
-  /**
-   * A standalone point geometry with useful accessor, comparison, and
-   * modification methods.
-   *
-   * @class Point
-   * @param {Number} x the x-coordinate. this could be longitude or screen
-   * pixels, or any other sort of unit.
-   * @param {Number} y the y-coordinate. this could be latitude or screen
-   * pixels, or any other sort of unit.
-   * @example
-   * var point = new Point(-77, 38);
-   */
-  function Point(x, y) {
-      this.x = x;
-      this.y = y;
-  }
-  Point.prototype = {
-      /**
-       * Clone this point, returning a new point that can be modified
-       * without affecting the old one.
-       * @return {Point} the clone
-       */
-      clone: function () {
-          return new Point(this.x, this.y);
-      },
-      /**
-       * Add this point's x & y coordinates to another point,
-       * yielding a new point.
-       * @param {Point} p the other point
-       * @return {Point} output point
-       */
-      add: function (p) {
-          return this.clone()._add(p);
-      },
-      /**
-       * Subtract this point's x & y coordinates to from point,
-       * yielding a new point.
-       * @param {Point} p the other point
-       * @return {Point} output point
-       */
-      sub: function (p) {
-          return this.clone()._sub(p);
-      },
-      /**
-       * Multiply this point's x & y coordinates by point,
-       * yielding a new point.
-       * @param {Point} p the other point
-       * @return {Point} output point
-       */
-      multByPoint: function (p) {
-          return this.clone()._multByPoint(p);
-      },
-      /**
-       * Divide this point's x & y coordinates by point,
-       * yielding a new point.
-       * @param {Point} p the other point
-       * @return {Point} output point
-       */
-      divByPoint: function (p) {
-          return this.clone()._divByPoint(p);
-      },
-      /**
-       * Multiply this point's x & y coordinates by a factor,
-       * yielding a new point.
-       * @param {Point} k factor
-       * @return {Point} output point
-       */
-      mult: function (k) {
-          return this.clone()._mult(k);
-      },
-      /**
-       * Divide this point's x & y coordinates by a factor,
-       * yielding a new point.
-       * @param {Point} k factor
-       * @return {Point} output point
-       */
-      div: function (k) {
-          return this.clone()._div(k);
-      },
-      /**
-       * Rotate this point around the 0, 0 origin by an angle a,
-       * given in radians
-       * @param {Number} a angle to rotate around, in radians
-       * @return {Point} output point
-       */
-      rotate: function (a) {
-          return this.clone()._rotate(a);
-      },
-      /**
-       * Rotate this point around p point by an angle a,
-       * given in radians
-       * @param {Number} a angle to rotate around, in radians
-       * @param {Point} p Point to rotate around
-       * @return {Point} output point
-       */
-      rotateAround: function (a, p) {
-          return this.clone()._rotateAround(a, p);
-      },
-      /**
-       * Multiply this point by a 4x1 transformation matrix
-       * @param {Array<Number>} m transformation matrix
-       * @return {Point} output point
-       */
-      matMult: function (m) {
-          return this.clone()._matMult(m);
-      },
-      /**
-       * Calculate this point but as a unit vector from 0, 0, meaning
-       * that the distance from the resulting point to the 0, 0
-       * coordinate will be equal to 1 and the angle from the resulting
-       * point to the 0, 0 coordinate will be the same as before.
-       * @return {Point} unit vector point
-       */
-      unit: function () {
-          return this.clone()._unit();
-      },
-      /**
-       * Compute a perpendicular point, where the new y coordinate
-       * is the old x coordinate and the new x coordinate is the old y
-       * coordinate multiplied by -1
-       * @return {Point} perpendicular point
-       */
-      perp: function () {
-          return this.clone()._perp();
-      },
-      /**
-       * Return a version of this point with the x & y coordinates
-       * rounded to integers.
-       * @return {Point} rounded point
-       */
-      round: function () {
-          return this.clone()._round();
-      },
-      /**
-       * Return the magitude of this point: this is the Euclidean
-       * distance from the 0, 0 coordinate to this point's x and y
-       * coordinates.
-       * @return {Number} magnitude
-       */
-      mag: function () {
-          return Math.sqrt(this.x * this.x + this.y * this.y);
-      },
-      /**
-       * Judge whether this point is equal to another point, returning
-       * true or false.
-       * @param {Point} other the other point
-       * @return {boolean} whether the points are equal
-       */
-      equals: function (other) {
-          return this.x === other.x && this.y === other.y;
-      },
-      /**
-       * Calculate the distance from this point to another point
-       * @param {Point} p the other point
-       * @return {Number} distance
-       */
-      dist: function (p) {
-          return Math.sqrt(this.distSqr(p));
-      },
-      /**
-       * Calculate the distance from this point to another point,
-       * without the square root step. Useful if you're comparing
-       * relative distances.
-       * @param {Point} p the other point
-       * @return {Number} distance
-       */
-      distSqr: function (p) {
-          var dx = p.x - this.x, dy = p.y - this.y;
-          return dx * dx + dy * dy;
-      },
-      /**
-       * Get the angle from the 0, 0 coordinate to this point, in radians
-       * coordinates.
-       * @return {Number} angle
-       */
-      angle: function () {
-          return Math.atan2(this.y, this.x);
-      },
-      /**
-       * Get the angle from this point to another point, in radians
-       * @param {Point} b the other point
-       * @return {Number} angle
-       */
-      angleTo: function (b) {
-          return Math.atan2(this.y - b.y, this.x - b.x);
-      },
-      /**
-       * Get the angle between this point and another point, in radians
-       * @param {Point} b the other point
-       * @return {Number} angle
-       */
-      angleWith: function (b) {
-          return this.angleWithSep(b.x, b.y);
-      },
-      /*
-       * Find the angle of the two vectors, solving the formula for
-       * the cross product a x b = |a||b|sin(θ) for θ.
-       * @param {Number} x the x-coordinate
-       * @param {Number} y the y-coordinate
-       * @return {Number} the angle in radians
-       */
-      angleWithSep: function (x, y) {
-          return Math.atan2(this.x * y - this.y * x, this.x * x + this.y * y);
-      },
-      _matMult: function (m) {
-          var x = m[0] * this.x + m[1] * this.y, y = m[2] * this.x + m[3] * this.y;
-          this.x = x;
-          this.y = y;
-          return this;
-      },
-      _add: function (p) {
-          this.x += p.x;
-          this.y += p.y;
-          return this;
-      },
-      _sub: function (p) {
-          this.x -= p.x;
-          this.y -= p.y;
-          return this;
-      },
-      _mult: function (k) {
-          this.x *= k;
-          this.y *= k;
-          return this;
-      },
-      _div: function (k) {
-          this.x /= k;
-          this.y /= k;
-          return this;
-      },
-      _multByPoint: function (p) {
-          this.x *= p.x;
-          this.y *= p.y;
-          return this;
-      },
-      _divByPoint: function (p) {
-          this.x /= p.x;
-          this.y /= p.y;
-          return this;
-      },
-      _unit: function () {
-          this._div(this.mag());
-          return this;
-      },
-      _perp: function () {
-          var y = this.y;
-          this.y = this.x;
-          this.x = -y;
-          return this;
-      },
-      _rotate: function (angle) {
-          var cos = Math.cos(angle), sin = Math.sin(angle), x = cos * this.x - sin * this.y, y = sin * this.x + cos * this.y;
-          this.x = x;
-          this.y = y;
-          return this;
-      },
-      _rotateAround: function (angle, p) {
-          var cos = Math.cos(angle), sin = Math.sin(angle), x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y), y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
-          this.x = x;
-          this.y = y;
-          return this;
-      },
-      _round: function () {
-          this.x = Math.round(this.x);
-          this.y = Math.round(this.y);
-          return this;
-      }
-  };
-  /**
-   * Construct a point from an array if necessary, otherwise if the input
-   * is already a Point, or an unknown type, return it unchanged
-   * @param {Array<Number>|Point|*} a any kind of input value
-   * @return {Point} constructed point, or passed-through value.
-   * @example
-   * // this
-   * var point = Point.convert([0, 1]);
-   * // is equivalent to
-   * var point = new Point(0, 1);
-   */
-  Point.convert = function (a) {
-      if (a instanceof Point) {
-          return a;
-      }
-      if (Array.isArray(a)) {
-          return new Point(a[0], a[1]);
-      }
-      return a;
-  };
-
   class TinyQueue {
       constructor(data = [], compare = (a, b) => a < b ? -1 : a > b ? 1 : 0) {
           this.data = data;
@@ -13955,7 +13803,12 @@
       constructor(registry, path = [], expectedType, scope = new Scope(), errors = [], _scope, options) {
           this.registry = registry;
           this.path = path;
-          this.key = path.map(part => `[${ part }]`).join('');
+          this.key = path.map(part => {
+              if (typeof part === 'string') {
+                  return `['${ part }']`;
+              }
+              return `[${ part }]`;
+          }).join('');
           this.scope = scope;
           this.errors = errors;
           this.expectedType = expectedType;
@@ -13971,10 +13824,21 @@
      */
       parse(expr, index, expectedType, bindings, options = {}) {
           if (index || expectedType) {
-              return this.concat(index, expectedType, bindings)._parse(expr, options);
+              return this.concat(index, null, expectedType, bindings)._parse(expr, options);
           }
           return this._parse(expr, options);
       }
+      /**
+     * @param expr the JSON expression to parse
+     * @param index the optional argument index if parent object being is an argument of another expression
+     * @param key key of parent object being parsed
+     * @param options
+     * @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
+     * @private
+     */
+      parseObjectValue(expr, index, key, expectedType, bindings, options = {}) {
+          return this.concat(index, key, expectedType, bindings)._parse(expr, options);
+      }
       _parse(expr, options) {
           if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
               expr = [
@@ -14042,8 +13906,9 @@
      * parsing, is copied by reference rather than cloned.
      * @private
      */
-      concat(index, expectedType, bindings) {
-          const path = typeof index === 'number' ? this.path.concat(index) : this.path;
+      concat(index, key, expectedType, bindings) {
+          let path = typeof index === 'number' ? this.path.concat(index) : this.path;
+          path = typeof key === 'string' ? path.concat(key) : path;
           const scope = bindings ? this.scope.concat(bindings) : this.scope;
           return new ParsingContext(this.registry, path, expectedType || null, scope, this.errors, this._scope, this.options);
       }
@@ -15258,31 +15123,31 @@
               return context.error(`NumberFormat options argument must be an object.`);
           let locale = null;
           if (options['locale']) {
-              locale = context.parse(options['locale'], 1, StringType);
+              locale = context.parseObjectValue(options['locale'], 2, 'locale', StringType);
               if (!locale)
                   return null;
           }
           let currency = null;
           if (options['currency']) {
-              currency = context.parse(options['currency'], 1, StringType);
+              currency = context.parseObjectValue(options['currency'], 2, 'currency', StringType);
               if (!currency)
                   return null;
           }
           let unit = null;
           if (options['unit']) {
-              unit = context.parse(options['unit'], 1, StringType);
+              unit = context.parseObjectValue(options['unit'], 2, 'unit', StringType);
               if (!unit)
                   return null;
           }
           let minFractionDigits = null;
           if (options['min-fraction-digits']) {
-              minFractionDigits = context.parse(options['min-fraction-digits'], 1, NumberType);
+              minFractionDigits = context.parseObjectValue(options['min-fraction-digits'], 2, 'min-fraction-digits', NumberType);
               if (!minFractionDigits)
                   return null;
           }
           let maxFractionDigits = null;
           if (options['max-fraction-digits']) {
-              maxFractionDigits = context.parse(options['max-fraction-digits'], 1, NumberType);
+              maxFractionDigits = context.parseObjectValue(options['max-fraction-digits'], 2, 'max-fraction-digits', NumberType);
               if (!maxFractionDigits)
                   return null;
           }
@@ -16874,7 +16739,7 @@
           return true;
       }
   }
-  function createFilter(filter, layerType = 'fill') {
+  function createFilter(filter, scope = '', options = null, layerType = 'fill') {
       if (filter === null || filter === void 0) {
           return {
               filter: () => true,
@@ -16899,7 +16764,7 @@ ${ JSON.stringify(filterExp, null, 2) }
         `);
       }
       const filterSpec = v8[`filter_${ layerType }`];
-      const compiledStaticFilter = createExpression(staticFilter, filterSpec);
+      const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
       let filterFunc = null;
       if (compiledStaticFilter.result === 'error') {
           throw new Error(compiledStaticFilter.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
@@ -16909,7 +16774,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       let dynamicFilterFunc = null;
       let needFeature = null;
       if (staticFilter !== filterExp) {
-          const compiledDynamicFilter = createExpression(filterExp, filterSpec);
+          const compiledDynamicFilter = createExpression(filterExp, filterSpec, scope, options);
           if (compiledDynamicFilter.result === 'error') {
               throw new Error(compiledDynamicFilter.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
           } else {
@@ -18486,15 +18351,19 @@ ${ JSON.stringify(filterExp, null, 2) }
       case '<':
       case '<=':
       case '>':
+      // @ts-expect-error - falls through
       case '>=':
           if (value.length >= 2 && unbundle(value[1]) === '$type') {
               errors.push(new ValidationError(key, value, `"$type" cannot be use with operator "${ value[0] }"`));
           }
+      /* falls through */
       case '==':
+      // @ts-expect-error - falls through
       case '!=':
           if (value.length !== 3) {
               errors.push(new ValidationError(key, value, `filter array for operator "${ value[0] }" must have 3 elements`));
           }
+      /* falls through */
       case 'in':
       case '!in':
           if (value.length >= 2) {