@mapbox/mapbox-gl-style-spec 14.15.0-beta.2 → 14.16.0-beta.1

package/expression/compound_expression.ts

@@ -93,11 +93,13 @@ class CompoundExpression implements Expression {
             let argParseFailed = false;
             for (let i = 1; i < args.length; i++) {
                 const arg = args[i];
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 const expectedType = Array.isArray(params) ?
                     params[i - 1] :
                 // @ts-expect-error - TS2339 - Property 'type' does not exist on type 'Varargs | Evaluate'.
                     params.type;
 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
                 if (!parsed) {
                     argParseFailed = true;
@@ -120,8 +122,10 @@ class CompoundExpression implements Expression {
 
             for (let i = 0; i < parsedArgs.length; i++) {
                 // @ts-expect-error - TS2339 - Property 'type' does not exist on type 'Varargs | Evaluate'.
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 const expected = Array.isArray(params) ? params[i] : params.type;
                 const arg = parsedArgs[i];
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 signatureContext.concat(i + 1).checkSubtype(expected, arg.type);
             }
 

package/expression/definitions/assertion.ts

@@ -47,6 +47,7 @@ class Assertion implements Expression {
                 const type = args[1];
                 if (typeof type !== 'string' || !(type in types) || type === 'object')
                     return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 itemType = types[type];
                 i++;
             } else {
@@ -66,9 +67,11 @@ class Assertion implements Expression {
                 i++;
             }
 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             type = array(itemType, N);
         } else {
             assert(types[name], name);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             type = types[name];
         }
 
@@ -79,17 +82,21 @@ class Assertion implements Expression {
             parsed.push(input);
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         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++) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const value = this.args[i].evaluate(ctx);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const error = checkSubtype(this.type, typeOf(value));
             if (!error) {
                 return value;
             } else if (i === this.args.length - 1) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 throw new RuntimeError(`The expression ${JSON.stringify(this.args[i].serialize())} evaluated to ${toString(typeOf(value))} but was expected to be of type ${toString(this.type)}.`);
             }
         }

package/expression/definitions/case.ts

@@ -50,6 +50,7 @@ class Case implements Expression {
         if (!otherwise) return null;
 
         assert(outputType);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Case(outputType, branches, otherwise);
     }
 
@@ -72,7 +73,7 @@ class Case implements Expression {
     }
 
     outputDefined(): boolean {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         return this.branches.every(([_, out]: [any, any]) => out.outputDefined()) && this.otherwise.outputDefined();
     }
 

package/expression/definitions/coalesce.ts

@@ -42,10 +42,13 @@ class Coalesce implements Expression {
         // Thus, if any of our arguments would have needed an annotation, we
         // need to wrap the enclosing coalesce expression with it instead.
         const needsAnnotation = expectedType &&
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
             parsedArgs.some(arg => checkSubtype(expectedType, arg.type));
 
         return needsAnnotation ?
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             new Coalesce(ValueType, parsedArgs) :
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             new Coalesce(outputType, parsedArgs);
     }
 
@@ -56,6 +59,7 @@ class Coalesce implements Expression {
         let firstImage;
         for (const arg of this.args) {
             argCount++;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             result = arg.evaluate(ctx);
             // we need to keep track of the first requested image in a coalesce statement
             // if coalesce can't find a valid image, we return the first image so styleimagemissing can fire

package/expression/definitions/coercion.ts

@@ -55,12 +55,15 @@ class Coercion implements Expression {
                     return context.error(`Expected ${context.expectedType.kind} but found array.`);
                 }
             } else if (arrayLength > 0 && isValue(args[1][0])) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 const value = (args[1][0]);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 type = array(typeOf(value), arrayLength);
             } else {
                 return null;
             }
             for (let i = 0; i < arrayLength; i++) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 const member = args[1][i];
                 let parsedMember;
                 if (Array.isArray(member)) {
@@ -81,6 +84,7 @@ class Coercion implements Expression {
             if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
                 return context.error(`Expected one argument.`);
 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             type = types[name];
 
             for (let i = 1; i < args.length; i++) {
@@ -90,6 +94,7 @@ class Coercion implements Expression {
             }
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Coercion(type, parsed);
     }
 
@@ -101,6 +106,7 @@ class Coercion implements Expression {
             let input;
             let error;
             for (const arg of this.args) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 input = arg.evaluate(ctx);
                 error = null;
                 if (input instanceof Color) {
@@ -115,14 +121,17 @@ class Coercion implements Expression {
                         error = validateRGBA(input[0], input[1], input[2], input[3]);
                     }
                     if (!error) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                         return new Color((input[0]) / 255, (input[1]) / 255, (input[2]) / 255, (input[3]));
                     }
                 }
             }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             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) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 value = arg.evaluate(ctx);
                 if (value === null) return 0;
                 const num = Number(value);
@@ -133,13 +142,16 @@ class Coercion implements Expression {
         } 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.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return Formatted.fromString(valueToString(this.args[0].evaluate(ctx)));
         } else if (this.type.kind === 'resolvedImage') {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             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 {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return valueToString(this.args[0].evaluate(ctx));
         }
     }

package/expression/definitions/collator.ts

@@ -39,9 +39,9 @@ export default class CollatorExpression implements Expression {
             context.parseObjectValue(options['diacritic-sensitive'], 1, 'diacritic-sensitive', BooleanType);
         if (!diacriticSensitive) return null;
 
-        let locale = null;
+        let locale: Expression = null;
         if (options['locale']) {
-            locale = context.parseObjectValue(options['locale'], 1, 'locale', StringType);
+            locale = context.parseObjectValue(options['locale'], 1, 'locale', StringType) as Expression;
             if (!locale) return null;
         }
 
@@ -49,7 +49,11 @@ export default class CollatorExpression implements Expression {
     }
 
     evaluate(ctx: EvaluationContext): Collator {
-        return new Collator(this.caseSensitive.evaluate(ctx), this.diacriticSensitive.evaluate(ctx), this.locale ? this.locale.evaluate(ctx) : null);
+        return new Collator(
+            this.caseSensitive.evaluate(ctx) as boolean,
+            this.diacriticSensitive.evaluate(ctx) as boolean,
+            this.locale ? this.locale.evaluate(ctx) as string : null
+        );
     }
 
     eachChild(fn: (_: Expression) => void) {
@@ -69,8 +73,7 @@ export default class CollatorExpression implements Expression {
     }
 
     serialize(): SerializedExpression {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const options: Record<string, any> = {};
+        const options: Record<string, SerializedExpression> = {};
         options['case-sensitive'] = this.caseSensitive.serialize();
         options['diacritic-sensitive'] = this.diacriticSensitive.serialize();
         if (this.locale) {

package/expression/definitions/comparison.ts

@@ -39,17 +39,17 @@ 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
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
 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
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
 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
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
 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
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
 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
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
 function gteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) >= 0; }
 
 /**
@@ -143,15 +143,20 @@ function makeComparison(
                 if (!collator) return null;
             }
 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return new Comparison(lhs, rhs, collator);
         }
 
         evaluate(ctx: EvaluationContext): boolean {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const lhs = this.lhs.evaluate(ctx);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const rhs = this.rhs.evaluate(ctx);
 
             if (isOrderComparison && this.hasUntypedArgument) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 const lt = typeOf(lhs);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 const rt = typeOf(rhs);
                 // check that type is string or number, and equal
                 if (lt.kind !== rt.kind || !(lt.kind === 'string' || lt.kind === 'number')) {
@@ -160,7 +165,9 @@ function makeComparison(
             }
 
             if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 const lt = typeOf(lhs);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 const rt = typeOf(rhs);
                 if (lt.kind !== 'string' || rt.kind !== 'string') {
                     return compareBasic(ctx, lhs, rhs);

package/expression/definitions/config.ts

@@ -19,14 +19,18 @@ export function makeConfigFQID(id: string, ownScope?: string | null, contextScop
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function coerceValue(type: string, value: any): any {
     switch (type) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     case 'string': return valueToString(value);
     case 'number': return +value;
     case 'boolean': return !!value;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     case 'color': return Color.parse(value);
     case 'formatted': {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return Formatted.fromString(valueToString(value));
     }
     case 'resolvedImage': {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return ResolvedImage.build(valueToString(value));
     }
     }
@@ -105,17 +109,21 @@ class Config implements Expression {
 
         const {type, value, values, minValue, maxValue, stepValue} = config;
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const defaultValue = config.default.evaluate(ctx);
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         let result = defaultValue;
         if (value) {
             // temporarily override scope to parent to evaluate config expressions passed from the parent
             const originalScope = ctx.scope;
             ctx.scope = (originalScope || '').split(FQIDSeparator).slice(1).join(FQIDSeparator);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             result = value.evaluate(ctx);
             ctx.scope = originalScope;
         }
         if (type) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             result = coerceValue(type, result);
         }
 
@@ -130,14 +138,18 @@ class Config implements Expression {
 
         if (value !== undefined && result !== undefined && values && !values.includes(result)) {
             // The result is not among the allowed values. Instead, use the default value from the option.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             result = defaultValue;
             if (type) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 result = coerceValue(type, result);
             }
         }
 
         // @ts-expect-error - TS2367 - This comparison appears to be unintentional because the types 'string' and 'Type' have no overlap.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         if ((type && type !== this.type) || (result !== undefined && !typeEquals(typeOf(result), this.type))) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             result = coerceValue(this.type.kind, result);
         }
 

package/expression/definitions/distance.ts

@@ -275,8 +275,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) {
+function updateQueue(distQueue: TinyQueue<DistPair>, 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);
     // Insert new pair to the queue if the bbox distance is less than miniDist, the pair with biggest distance will be at the top
@@ -416,16 +415,20 @@ function pointsToGeometryDistance(originGeometry: Array<Array<Point>>, canonical
             lngLatPoints.push(getLngLatPoint(point, canonical));
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
     const ruler = new CheapRuler(lngLatPoints[0][1], 'meters');
     if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return pointSetsDistance(lngLatPoints, false /*isLine*/,
             (geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates) as Array<[number, number]>,
             geometry.type === 'LineString' /*isLine*/, ruler);
     }
     if (geometry.type === 'MultiLineString') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return pointSetToLinesDistance(lngLatPoints, false /*isLine*/, geometry.coordinates as Array<Array<[number, number]>>, ruler);
     }
     if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return pointSetToPolygonsDistance(lngLatPoints, false /*isLine*/,
             (geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates) as Array<Array<Array<[number, number]>>>, ruler);
     }
@@ -441,15 +444,18 @@ function linesToGeometryDistance(originGeometry: Array<Array<Point>>, canonical:
         }
         lngLatLines.push(lngLatLine);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
     const ruler = new CheapRuler(lngLatLines[0][0][1], 'meters');
     if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
         return pointSetToLinesDistance(
             (geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates) as Array<[number, number]>,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             geometry.type === 'LineString' /*isLine*/, lngLatLines, ruler);
     }
     if (geometry.type === 'MultiLineString') {
         let dist = Infinity;
         for (let i = 0; i < geometry.coordinates.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const tempDist = pointSetToLinesDistance(geometry.coordinates[i] as Array<[number, number]>, true /*isLine*/, lngLatLines, ruler, dist);
             if (isNaN(tempDist)) return tempDist;
             if ((dist = Math.min(dist, tempDist)) === 0.0) return dist;
@@ -459,6 +465,7 @@ function linesToGeometryDistance(originGeometry: Array<Array<Point>>, canonical:
     if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
         let dist = Infinity;
         for (let i = 0; i < lngLatLines.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const tempDist = pointSetToPolygonsDistance(lngLatLines[i], true /*isLine*/,
                 (geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates) as Array<Array<Array<[number, number]>>>,
                 ruler, dist);
@@ -479,15 +486,18 @@ function polygonsToGeometryDistance(originGeometry: Array<Array<Point>>, canonic
         }
         lngLatPolygons.push(lngLatPolygon);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
     const ruler = new CheapRuler(lngLatPolygons[0][0][0][1], 'meters');
     if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
         return pointSetToPolygonsDistance(
             (geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates) as Array<[number, number]>,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             geometry.type === 'LineString' /*isLine*/, lngLatPolygons, ruler);
     }
     if (geometry.type === 'MultiLineString') {
         let dist = Infinity;
         for (let i = 0; i < geometry.coordinates.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const tempDist = pointSetToPolygonsDistance(geometry.coordinates[i] as Array<[number, number]>, true /*isLine*/, lngLatPolygons, ruler, dist);
             if (isNaN(tempDist)) return tempDist;
             if ((dist = Math.min(dist, tempDist)) === 0.0) return dist;
@@ -497,6 +507,7 @@ function polygonsToGeometryDistance(originGeometry: Array<Array<Point>>, canonic
     if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
         return polygonsToPolygonsDistance(
             (geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates) as Array<Array<Array<[number, number]>>>,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             lngLatPolygons, ruler);
     }
     return null;

package/expression/definitions/format.ts

@@ -71,8 +71,11 @@ export default class FormatExpression implements Expression {
                 }
 
                 const lastExpression = sections[sections.length - 1];
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 lastExpression.scale = scale;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 lastExpression.font = font;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 lastExpression.textColor = textColor;
             } else {
                 const content = context.parse(args[i], i, ValueType);
@@ -92,16 +95,23 @@ export default class FormatExpression implements Expression {
 
     evaluate(ctx: EvaluationContext): Formatted {
         const evaluateSection = (section: FormattedSectionExpression) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const evaluatedContent = section.content.evaluate(ctx);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             if (typeEquals(typeOf(evaluatedContent), ResolvedImageType)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 return new FormattedSection('', evaluatedContent, null, null, null);
             }
 
             return new FormattedSection(
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                     toString(evaluatedContent),
                     null,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                     section.scale ? section.scale.evaluate(ctx) : null,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
                     section.font ? section.font.evaluate(ctx).join(',') : null,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                     section.textColor ? section.textColor.evaluate(ctx) : null
             );
         };

package/expression/definitions/image.ts

@@ -167,6 +167,7 @@ export default class ImageExpression implements Expression {
             for (const key in params) {
                 if (params[key]) {
                     try {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                         result[key] = params[key].evaluate(ctx);
                     } catch (err) {
                         continue;
@@ -186,11 +187,13 @@ export default class ImageExpression implements Expression {
 
     evaluate(ctx: EvaluationContext): null | ResolvedImage {
         const primaryId = {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             name: this.namePrimary.evaluate(ctx),
             iconsetId: this.iconsetIdPrimary
         };
 
         const secondaryId = this.nameSecondary ? {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             name: this.nameSecondary.evaluate(ctx),
             iconsetId: this.iconsetIdSecondary
         } : undefined;

package/expression/definitions/in.ts

@@ -48,19 +48,24 @@ class In implements Expression {
     }
 
     evaluate(ctx: EvaluationContext): boolean {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const needle = (this.needle.evaluate(ctx));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const haystack = (this.haystack.evaluate(ctx));
 
         if (haystack == null) return false;
 
         if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);
         }
 
         if (!isValidNativeType(haystack, ['string', 'array'])) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             throw new RuntimeError(`Expected second argument to be of type array or string, but found ${toString(typeOf(haystack))} instead.`);
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         return haystack.indexOf(needle) >= 0;
     }