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

package/dist/index.es.js

@@ -208,6 +208,71 @@ var $root = {
 			"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 = {
@@ -377,9 +442,6 @@ var properties_light_directional = {
 		"default": false,
 		doc: "Enable/Disable shadow casting for this light",
 		transition: false,
-		expression: {
-			interpolated: false
-		},
 		"property-type": "data-constant",
 		"sdk-support": {
 			"basic functionality": {
@@ -465,7 +527,7 @@ var properties_light_flat = {
 				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",
@@ -5234,6 +5296,30 @@ var paint_fill = {
 			]
 		},
 		"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 = {
@@ -6968,6 +7054,62 @@ var paint_symbol = {
 			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 = {
@@ -8240,6 +8382,10 @@ var promoteId = {
 var v8 = {
 	$version: $version,
 	$root: $root,
+	featuresets: featuresets,
+	featureset: featureset,
+	selector: selector,
+	selectorProperty: selectorProperty,
 	model: model,
 	"import": {
 	id: {
@@ -8368,7 +8514,6 @@ var v8 = {
 	"fill-extrusion-edge-radius": {
 		type: "number",
 		experimental: true,
-		"private": true,
 		"default": 0,
 		minimum: 0,
 		maximum: 1,
@@ -8742,7 +8887,6 @@ var v8 = {
 	"fill-extrusion-ambient-occlusion-intensity": {
 		"property-type": "data-constant",
 		type: "number",
-		"private": true,
 		"default": 0,
 		minimum: 0,
 		maximum: 1,
@@ -8765,7 +8909,6 @@ var v8 = {
 	"fill-extrusion-ambient-occlusion-radius": {
 		"property-type": "data-constant",
 		type: "number",
-		"private": true,
 		"default": 3,
 		minimum: 0,
 		expression: {
@@ -8954,7 +9097,7 @@ var v8 = {
 		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"
 		],
@@ -9101,14 +9244,19 @@ var v8 = {
 		"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: {
@@ -9122,27 +9270,16 @@ var v8 = {
 		},
 		"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"
@@ -11434,19 +11571,19 @@ class FormatExpression {
                 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;
                 }
@@ -11455,7 +11592,7 @@ class FormatExpression {
                 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;
@@ -11916,15 +12053,15 @@ class CollatorExpression {
         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;
         }
@@ -12770,295 +12907,6 @@ function wrap(deg) {
     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;
@@ -13949,7 +13797,12 @@ class ParsingContext {
     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;
@@ -13965,10 +13818,21 @@ class ParsingContext {
    */
     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 = [
@@ -14036,8 +13900,9 @@ class ParsingContext {
    * 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);
     }
@@ -15252,31 +15117,31 @@ class NumberFormat {
             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;
         }
@@ -16868,7 +16733,7 @@ function isExpressionFilter(filter) {
         return true;
     }
 }
-function createFilter(filter, layerType = 'fill') {
+function createFilter(filter, scope = '', options = null, layerType = 'fill') {
     if (filter === null || filter === void 0) {
         return {
             filter: () => true,
@@ -16893,7 +16758,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(', '));
@@ -16903,7 +16768,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 {
@@ -18480,15 +18345,19 @@ function validateNonExpressionFilter(options) {
     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) {