@mapbox/mapbox-gl-style-spec 14.11.0 → 14.12.0

package/error/validation_error.ts

@@ -5,9 +5,7 @@ export default class ValidationError {
     identifier: string | null | undefined;
     line: number | null | undefined;
 
-    constructor(key: string | null | undefined, value: {
-        __line__: number;
-    } | null | undefined, message: string, identifier?: string | null) {
+    constructor(key: string | null | undefined, value: (string | number | boolean) & {__line__?: number} | null | undefined, message: string, identifier?: string | null) {
         this.message = (key ? `${key}: ` : '') + message;
         if (identifier) this.identifier = identifier;
 

package/expression/compound_expression.ts

@@ -73,7 +73,7 @@ class CompoundExpression implements Expression {
 
         const overloadParams = [];
 
-        let signatureContext: ParsingContext = (null as any);
+        let signatureContext: ParsingContext = null;
 
         let overloadIndex = -1;
 

package/expression/definitions/assertion.ts

@@ -40,7 +40,7 @@ class Assertion implements Expression {
         let i = 1;
         let type;
 
-        const name: string = (args[0] as any);
+        const name = args[0] as string;
         if (name === 'array') {
             let itemType;
             if (args.length > 2) {
@@ -82,6 +82,7 @@ class Assertion implements Expression {
         return new Assertion(type, parsed);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         for (let i = 0; i < this.args.length; i++) {
             const value = this.args[i].evaluate(ctx);

package/expression/definitions/at.ts

@@ -27,7 +27,7 @@ class At implements Expression {
 
         if (!index || !input) return null;
 
-        const t: ArrayType = (input.type as any);
+        const t = input.type as ArrayType;
         return new At(t.itemType, index, input);
     }
 

package/expression/definitions/at_interpolated.ts

@@ -27,7 +27,7 @@ class AtInterpolated implements Expression {
 
         if (!index || !input) return null;
 
-        const t: ArrayType = (input.type as any);
+        const t = input.type as ArrayType;
         return new AtInterpolated(t.itemType, index, input);
     }
 

package/expression/definitions/case.ts

@@ -50,9 +50,10 @@ class Case implements Expression {
         if (!otherwise) return null;
 
         assert(outputType);
-        return new Case((outputType as any), branches, otherwise);
+        return new Case(outputType, branches, otherwise);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         for (const [test, expression] of this.branches) {
             if (test.evaluate(ctx)) {
@@ -71,6 +72,7 @@ class Case implements Expression {
     }
 
     outputDefined(): boolean {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.branches.every(([_, out]: [any, any]) => out.outputDefined()) && this.otherwise.outputDefined();
     }
 

package/expression/definitions/coalesce.ts

@@ -21,7 +21,7 @@ class Coalesce implements Expression {
             // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Coalesce'.
             return context.error("Expectected at least one argument.");
         }
-        let outputType: Type = (null as any);
+        let outputType: Type = null;
         const expectedType = context.expectedType;
         if (expectedType && expectedType.kind !== 'value') {
             outputType = expectedType;
@@ -46,9 +46,10 @@ class Coalesce implements Expression {
 
         return needsAnnotation ?
             new Coalesce(ValueType, parsedArgs) :
-            new Coalesce((outputType as any), parsedArgs);
+            new Coalesce(outputType, parsedArgs);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         let result = null;
         let argCount = 0;

package/expression/definitions/coercion.ts

@@ -40,7 +40,7 @@ class Coercion implements Expression {
         if (args.length < 2)
             return context.error(`Expected at least one argument.`);
 
-        const name: string = (args[0] as any);
+        const name = args[0] as string;
         const parsed = [];
         let type: Type | ArrayType = NullType;
         if (name === 'to-array') {
@@ -93,6 +93,7 @@ class Coercion implements Expression {
         return new Coercion(type, parsed);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         if (this.type.kind === 'boolean') {
             return Boolean(this.args[0].evaluate(ctx));
@@ -136,6 +137,7 @@ class Coercion implements Expression {
         } else if (this.type.kind === 'resolvedImage') {
             return ResolvedImage.build(valueToString(this.args[0].evaluate(ctx)));
         } else if (this.type.kind === 'array') {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return this.args.map(arg => { return arg.evaluate(ctx); });
         } else {
             return valueToString(this.args[0].evaluate(ctx));

package/expression/definitions/collator.ts

@@ -24,7 +24,7 @@ export default class CollatorExpression implements Expression {
         // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected one argument.`);
 
-        const options = (args[1] as any);
+        const options = args[1];
         if (typeof options !== "object" || Array.isArray(options))
         // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Collator options argument must be an object.`);
@@ -69,6 +69,7 @@ export default class CollatorExpression implements Expression {
     }
 
     serialize(): SerializedExpression {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const options: Record<string, any> = {};
         options['case-sensitive'] = this.caseSensitive.serialize();
         options['diacritic-sensitive'] = this.diacriticSensitive.serialize();

package/expression/definitions/comparison.ts

@@ -26,18 +26,30 @@ function isComparableType(op: ComparisonOperator, type: Type) {
     }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function eq(ctx: EvaluationContext, a: any, b: any): boolean { return a === b; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function neq(ctx: EvaluationContext, a: any, b: any): boolean { return a !== b; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function lt(ctx: EvaluationContext, a: any, b: any): boolean { return a < b; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function gt(ctx: EvaluationContext, a: any, b: any): boolean { return a > b; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function lteq(ctx: EvaluationContext, a: any, b: any): boolean { return a <= b; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function gteq(ctx: EvaluationContext, a: any, b: any): boolean { return a >= b; }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function eqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) === 0; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function neqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return !eqCollate(ctx, a, b, c); }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function ltCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) < 0; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function gtCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) > 0; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function lteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) <= 0; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function gteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) >= 0; }
 
 /**
@@ -59,7 +71,9 @@ function gteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean {
  */
 function makeComparison(
     op: ComparisonOperator,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     compareBasic: (arg1: EvaluationContext, arg2?: any, arg3?: any) => boolean,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     compareWithCollator: (arg1: EvaluationContext, arg2?: any, arg3?: any, arg4?: any) => boolean,
 ): ExpressionRegistration {
     const isOrderComparison = op !== '==' && op !== '!=';
@@ -83,7 +97,7 @@ function makeComparison(
             if (args.length !== 3 && args.length !== 4)
                 return context.error(`Expected two or three arguments.`);
 
-            const op: ComparisonOperator = (args[0] as any);
+            const op = args[0] as ComparisonOperator;
 
             let lhs = context.parse(args[1], 1, ValueType);
             if (!lhs) return null;

package/expression/definitions/config.ts

@@ -9,6 +9,7 @@ import type {Expression, SerializedExpression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function coerceValue(type: string, value: any): any {
     switch (type) {
     case 'string': return valueToString(value);
@@ -74,6 +75,7 @@ class Config implements Expression {
         return new Config(type, valueToString(configKey.value));
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         const FQIDSeparator = '\u001F';
         const configKey = [this.key, this.scope, ctx.scope].filter(Boolean).join(FQIDSeparator);
@@ -101,7 +103,8 @@ class Config implements Expression {
             if (typeof result === 'number') {
                 result = clampToAllowedNumber(result, minValue, maxValue, stepValue);
             } else if (Array.isArray(result)) {
-                result = result.map((item) => typeof item === 'number' ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                result = result.map((item) => (typeof item === 'number' ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item));
             }
         }
 

package/expression/definitions/distance.ts

@@ -147,6 +147,7 @@ function getLngLatPoints(coordinates: Array<Point>, canonical: CanonicalTileID)
     for (let i = 0; i < coordinates.length; ++i) {
         coords.push(getLngLatPoint(coordinates[i], canonical));
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return coords;
 }
 
@@ -275,6 +276,7 @@ function polygonToPolygonDistance(polygon1: Array<Array<[number, number]>>, poly
     return dist;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function updateQueue(distQueue: any, miniDist: number, ruler: CheapRuler, pointSet1: Array<[number, number]>, pointSet2: Array<[number, number]>, r1: IndexRange | null, r2: IndexRange | null) {
     if (r1 === null || r2 === null) return;
     const tempDist = bboxToBBoxDistance(getBBox(pointSet1, r1), getBBox(pointSet2, r2), ruler);
@@ -527,19 +529,19 @@ class Distance implements Expression {
             return context.error(`'distance' expression requires either one argument, but found ' ${args.length - 1} instead.`);
         }
         if (isValue(args[1])) {
-            const geojson = (args[1] as any);
+            const geojson = args[1] as GeoJSON.GeoJSON;
             if (geojson.type === 'FeatureCollection') {
                 for (let i = 0; i < geojson.features.length; ++i) {
                     if (isTypeValid(geojson.features[i].geometry.type)) {
-                        return new Distance(geojson, geojson.features[i].geometry);
+                        return new Distance(geojson, geojson.features[i].geometry as DistanceGeometry);
                     }
                 }
             } else if (geojson.type === 'Feature') {
                 if (isTypeValid(geojson.geometry.type)) {
-                    return new Distance(geojson, geojson.geometry);
+                    return new Distance(geojson, geojson.geometry as DistanceGeometry);
                 }
             } else if (isTypeValid(geojson.type)) {
-                return new Distance(geojson, geojson);
+                return new Distance(geojson, geojson as DistanceGeometry);
             }
         }
         return context.error(

package/expression/definitions/format.ts

@@ -46,7 +46,7 @@ export default class FormatExpression implements Expression {
         const sections: Array<FormattedSectionExpression> = [];
         let nextTokenMayBeObject = false;
         for (let i = 1; i <= args.length - 1; ++i) {
-            const arg = (args[i] as any);
+            const arg = args[i];
 
             if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
                 nextTokenMayBeObject = false;

package/expression/definitions/index.ts

@@ -47,6 +47,7 @@ import Distance from './distance';
 import {mulberry32} from '../../util/random';
 
 import type {Type} from '../types';
+import type {Value} from '../values';
 import type EvaluationContext from '../evaluation_context';
 import type {Varargs} from '../compound_expression';
 import type {Expression, ExpressionRegistry} from '../expression';
@@ -120,6 +121,7 @@ function hsla(ctx: EvaluationContext, [h, s, l, a]: Expression[]) {
 function has(
     key: string,
     obj: {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         [key: string]: any;
     },
 ): boolean {
@@ -127,13 +129,17 @@ function has(
 }
 
 function get(key: string, obj: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [key: string]: any;
 }) {
     const v = obj[key];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return typeof v === 'undefined' ? null : v;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function binarySearch(v: any, a: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [key: number]: any;
 }, i: number, j: number) {
     while (i <= j) {
@@ -180,6 +186,7 @@ CompoundExpression.register(expressions, {
         array(NumberType, 4),
         [ColorType],
         (ctx, [v]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return v.evaluate(ctx).toRenderColor(null).toArray();
         }
     ],
@@ -187,6 +194,7 @@ CompoundExpression.register(expressions, {
         array(NumberType, 4),
         [ColorType],
         (ctx, [v]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return v.evaluate(ctx).toRenderColor(null).toHslaArray();
         }
     ],
@@ -227,9 +235,11 @@ CompoundExpression.register(expressions, {
         overloads: [
             [
                 [StringType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [key]) => get(key.evaluate(ctx), ctx.properties())
             ], [
                 [StringType, ObjectType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [key, obj]) => get(key.evaluate(ctx), obj.evaluate(ctx))
             ]
         ]
@@ -237,12 +247,13 @@ CompoundExpression.register(expressions, {
     'feature-state': [
         ValueType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [key]) => get(key.evaluate(ctx), ctx.featureState || {})
     ],
     'properties': [
         ObjectType,
         [],
-        (ctx) => ctx.properties()
+        (ctx) => ctx.properties() as Value
     ],
     'geometry-type': [
         StringType,
@@ -302,7 +313,7 @@ CompoundExpression.register(expressions, {
     'accumulated': [
         ValueType,
         [],
-        (ctx) => ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated
+        (ctx) => (ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated)
     ],
     '+': [
         NumberType,
@@ -421,11 +432,13 @@ CompoundExpression.register(expressions, {
     'min': [
         NumberType,
         varargs(NumberType),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, args) => Math.min(...args.map(arg => arg.evaluate(ctx)))
     ],
     'max': [
         NumberType,
         varargs(NumberType),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, args) => Math.max(...args.map(arg => arg.evaluate(ctx)))
     ],
     'abs': [
@@ -578,6 +591,7 @@ CompoundExpression.register(expressions, {
         overloads: [
             [
                 [BooleanType, BooleanType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [a, b]) => a.evaluate(ctx) && b.evaluate(ctx)
             ],
             [
@@ -597,6 +611,7 @@ CompoundExpression.register(expressions, {
         overloads: [
             [
                 [BooleanType, BooleanType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 (ctx, [a, b]) => a.evaluate(ctx) || b.evaluate(ctx)
             ],
             [
@@ -631,11 +646,13 @@ CompoundExpression.register(expressions, {
     'upcase': [
         StringType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [s]) => s.evaluate(ctx).toUpperCase()
     ],
     'downcase': [
         StringType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [s]) => s.evaluate(ctx).toLowerCase()
     ],
     'concat': [
@@ -646,17 +663,21 @@ CompoundExpression.register(expressions, {
     'resolved-locale': [
         StringType,
         [CollatorType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
     ],
     'random': [
         NumberType,
         [NumberType, NumberType, ValueType],
         (ctx, args) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             const [min, max, seed] = args.map(arg => arg.evaluate(ctx));
             if (min > max) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return min;
             }
             if (min === max) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return min;
             }
             let seedVal;
@@ -668,6 +689,7 @@ CompoundExpression.register(expressions, {
                 throw new RuntimeError(`Invalid seed input: ${seed}`);
             }
             const random = mulberry32(seedVal)();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return min + random * (max - min);
         }
     ],

package/expression/definitions/index_of.ts

@@ -54,6 +54,7 @@ class IndexOf implements Expression {
         }
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         const needle = (this.needle.evaluate(ctx));
         const haystack = (this.haystack.evaluate(ctx));

package/expression/definitions/interpolate.ts

@@ -91,7 +91,7 @@ class Interpolate implements Expression {
 
             interpolation = {
                 name: 'cubic-bezier',
-                controlPoints: (controlPoints as any)
+                controlPoints
             };
         } else {
             return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
@@ -110,7 +110,7 @@ class Interpolate implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = (null as any);
+        let outputType: Type = null;
         if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
             outputType = ColorType;
         } else if (context.expectedType && context.expectedType.kind !== 'value') {
@@ -157,16 +157,19 @@ class Interpolate implements Expression {
         const outputs = this.outputs;
 
         if (labels.length === 1) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return outputs[0].evaluate(ctx);
         }
 
         const value = (this.input.evaluate(ctx) as number);
         if (value <= labels[0]) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return outputs[0].evaluate(ctx);
         }
 
         const stopCount = labels.length;
         if (value >= labels[stopCount - 1]) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return outputs[stopCount - 1].evaluate(ctx);
         }
 
@@ -179,7 +182,8 @@ class Interpolate implements Expression {
         const outputUpper = outputs[index + 1].evaluate(ctx);
 
         if (this.operator === 'interpolate') {
-            return (interpolate[this.type.kind.toLowerCase()] as any)(outputLower, outputUpper, t);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t);
         } else if (this.operator === 'interpolate-hcl') {
             return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
         } else {

package/expression/definitions/let.ts

@@ -14,6 +14,7 @@ class Let implements Expression {
         this.result = result;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         return this.result.evaluate(ctx);
     }

package/expression/definitions/literal.ts

@@ -23,7 +23,7 @@ class Literal implements Expression {
         if (!isValue(args[1]))
             return context.error(`invalid value`);
 
-        const value = (args[1] as any);
+        const value = args[1] as Value;
         let type = typeOf(value);
 
         // special case: infer the item type if possible for zero-length arrays
@@ -67,7 +67,7 @@ class Literal implements Expression {
                 typeof this.value === 'string' ||
                 typeof this.value === 'number' ||
                 typeof this.value === 'boolean');
-            return this.value as any;
+            return this.value as SerializedExpression;
         }
     }
 }

package/expression/definitions/match.ts

@@ -39,6 +39,7 @@ class Match implements Expression {
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const cases: Record<string, any> = {};
         const outputs = [];
         for (let i = 2; i < args.length - 1; i += 2) {
@@ -94,9 +95,10 @@ class Match implements Expression {
             return null;
         }
 
-        return new Match((inputType), (outputType as any), input, cases, outputs, otherwise);
+        return new Match(inputType, outputType, input, cases, outputs, otherwise);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         const input = (this.input.evaluate(ctx));
         const output = (typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
@@ -138,7 +140,7 @@ class Match implements Expression {
             }
         }
 
-        const coerceLabel = (label: number | string) => this.inputType.kind === 'number' ? Number(label) : label;
+        const coerceLabel = (label: number | string) => (this.inputType.kind === 'number' ? Number(label) : label);
 
         for (const [outputIndex, labels] of groupedByOutput) {
             if (labels.length === 1) {

package/expression/definitions/number_format.ts

@@ -29,17 +29,15 @@ export default class NumberFormat implements Expression {
         this.maxFractionDigits = maxFractionDigits;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | void {
         if (args.length !== 3)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected two arguments.`);
 
         const number = context.parse(args[1], 1, NumberType);
         if (!number) return null;
 
-        const options = (args[2] as any);
+        const options = args[2];
         if (typeof options !== "object" || Array.isArray(options))
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`NumberFormat options argument must be an object.`);
 
         let locale = null;
@@ -113,6 +111,7 @@ export default class NumberFormat implements Expression {
     }
 
     serialize(): SerializedExpression {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const options: Record<string, any> = {};
         if (this.locale) {
             options['locale'] = this.locale.serialize();

package/expression/definitions/slice.ts

@@ -54,6 +54,7 @@ class Slice implements Expression {
         }
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         const input = (this.input.evaluate(ctx));
         const beginIndex = (this.beginIndex.evaluate(ctx) as number);

package/expression/definitions/step.ts

@@ -40,7 +40,7 @@ class Step implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = (null as any);
+        let outputType: Type = null;
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
@@ -69,6 +69,7 @@ class Step implements Expression {
         return new Step(outputType, input, stops);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         const labels = this.labels;
         const outputs = this.outputs;

package/expression/definitions/var.ts

@@ -26,6 +26,7 @@ class Var implements Expression {
         return new Var(name, context.scope.get(name));
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         return this.boundExpression.evaluate(ctx);
     }

package/expression/definitions/within.ts

@@ -85,6 +85,7 @@ function getTilePolygon(coordinates: Array<Array<GeoJSON.Position>>, bbox: BBox,
         }
         polygon.push(ring);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return polygon;
 }
 
@@ -94,6 +95,7 @@ function getTilePolygons(coordinates: Array<Array<Array<GeoJSON.Position>>>, bbo
         const polygon = getTilePolygon(coordinates[i], bbox, canonical);
         polygons.push(polygon);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return polygons;
 }
 
@@ -118,6 +120,7 @@ function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBB
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
     const tilePoints = [];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (!geometry) return tilePoints;
     for (const points of geometry) {
         for (const point of points) {
@@ -126,6 +129,7 @@ function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBB
             tilePoints.push(p);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return tilePoints;
 }
 
@@ -230,12 +234,12 @@ class Within implements Expression {
         if (args.length !== 2)
             return context.error(`'within' expression requires exactly one argument, but found ${args.length - 1} instead.`);
         if (isValue(args[1])) {
-            const geojson = (args[1] as any);
+            const geojson = args[1] as GeoJSON.GeoJSON;
             if (geojson.type === 'FeatureCollection') {
                 for (let i = 0; i < geojson.features.length; ++i) {
                     const type = geojson.features[i].geometry.type;
                     if (type === 'Polygon' || type === 'MultiPolygon') {
-                        return new Within(geojson, geojson.features[i].geometry);
+                        return new Within(geojson, geojson.features[i].geometry as GeoJSONPolygons);
                     }
                 }
             } else if (geojson.type === 'Feature') {