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

package/expression/definitions/index.ts

@@ -97,19 +97,28 @@ const expressions: ExpressionRegistry = {
 };
 
 function rgba(ctx: EvaluationContext, [r, g, b, a]: Expression[]) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     r = r.evaluate(ctx);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     g = g.evaluate(ctx);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     b = b.evaluate(ctx);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const alpha = a ? a.evaluate(ctx) : 1;
     const error = validateRGBA(r, g, b, alpha);
     if (error) throw new RuntimeError(error);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     return new Color(r as unknown as number / 255, g as unknown as number / 255, b as unknown as number / 255, alpha);
 }
 
 function hsla(ctx: EvaluationContext, [h, s, l, a]: Expression[]) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     h = h.evaluate(ctx);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     s = s.evaluate(ctx);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     l = l.evaluate(ctx);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const alpha = a ? a.evaluate(ctx) : 1;
     const error = validateHSLA(h, s, l, alpha);
     if (error) throw new RuntimeError(error);
@@ -163,18 +172,20 @@ CompoundExpression.register(expressions, {
     'error': [
         ErrorType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [v]) => { throw new RuntimeError(v.evaluate(ctx)); }
     ],
     'typeof': [
         StringType,
         [ValueType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [v]) => typeToString(typeOf(v.evaluate(ctx)))
     ],
     'to-rgba': [
         array(NumberType, 4),
         [ColorType],
         (ctx, [v]) => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             return v.evaluate(ctx).toNonPremultipliedRenderColor(null).toArray();
         }
     ],
@@ -182,7 +193,7 @@ CompoundExpression.register(expressions, {
         array(NumberType, 4),
         [ColorType],
         (ctx, [v]) => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             return v.evaluate(ctx).toNonPremultipliedRenderColor(null).toHslaArray();
         }
     ],
@@ -211,9 +222,11 @@ CompoundExpression.register(expressions, {
         overloads: [
             [
                 [StringType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 (ctx, [key]) => has(key.evaluate(ctx), ctx.properties())
             ], [
                 [StringType, ObjectType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 (ctx, [key, obj]) => has(key.evaluate(ctx), obj.evaluate(ctx))
             ]
         ]
@@ -223,10 +236,11 @@ CompoundExpression.register(expressions, {
         overloads: [
             [
                 [StringType],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 (ctx, [key]) => get(key.evaluate(ctx), ctx.properties())
             ], [
                 [StringType, ObjectType],
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument
                 (ctx, [key, obj]) => get(key.evaluate(ctx), obj.evaluate(ctx))
             ]
         ]
@@ -234,6 +248,7 @@ CompoundExpression.register(expressions, {
     'feature-state': [
         ValueType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [key]) => get(key.evaluate(ctx), ctx.featureState || {}) as Value
     ],
     'properties': [
@@ -274,6 +289,7 @@ CompoundExpression.register(expressions, {
     'measure-light': [
         NumberType,
         [StringType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [s]) => ctx.measureLight(s.evaluate(ctx))
     ],
     'heatmap-density': [
@@ -368,99 +384,116 @@ CompoundExpression.register(expressions, {
     '^': [
         NumberType,
         [NumberType, NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [b, e]) => Math.pow(b.evaluate(ctx), e.evaluate(ctx))
     ],
     'sqrt': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [x]) => Math.sqrt(x.evaluate(ctx))
     ],
     'log10': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.log(n.evaluate(ctx)) / Math.LN10
     ],
     'ln': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.log(n.evaluate(ctx))
     ],
     'log2': [
         NumberType,
         [NumberType],
-        (ctx, [n]) => Math.log(n.evaluate(ctx)) / Math.LN2
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        (ctx, [n]) => Math.log2(n.evaluate(ctx))
     ],
     'sin': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.sin(n.evaluate(ctx))
     ],
     'cos': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.cos(n.evaluate(ctx))
     ],
     'tan': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.tan(n.evaluate(ctx))
     ],
     'asin': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.asin(n.evaluate(ctx))
     ],
     'acos': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.acos(n.evaluate(ctx))
     ],
     'atan': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.atan(n.evaluate(ctx))
     ],
     'min': [
         NumberType,
         varargs(NumberType),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument
         (ctx, args) => Math.min(...args.map(arg => arg.evaluate(ctx)))
     ],
     'max': [
         NumberType,
         varargs(NumberType),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument
         (ctx, args) => Math.max(...args.map(arg => arg.evaluate(ctx)))
     ],
     'abs': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.abs(n.evaluate(ctx))
     ],
     'round': [
         NumberType,
         [NumberType],
         (ctx, [n]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const v = n.evaluate(ctx);
             // Javascript's Math.round() rounds towards +Infinity for halfway
             // values, even when they're negative. It's more common to round
             // away from 0 (e.g., this is what python and C++ do)
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return v < 0 ? -Math.round(-v) : Math.round(v);
         }
     ],
     'floor': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.floor(n.evaluate(ctx))
     ],
     'ceil': [
         NumberType,
         [NumberType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, [n]) => Math.ceil(n.evaluate(ctx))
     ],
     'filter-==': [
         BooleanType,
         [StringType, ValueType],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         (ctx, [k, v]) => ctx.properties()[(k).value] === (v).value
     ],
     'filter-id-==': [
@@ -477,7 +510,9 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             const a = ctx.properties()[(k).value];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a < b;
         }
@@ -487,6 +522,7 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a < b;
         }
@@ -495,7 +531,9 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             const a = ctx.properties()[(k).value];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a > b;
         }
@@ -505,6 +543,7 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a > b;
         }
@@ -513,7 +552,9 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             const a = ctx.properties()[(k).value];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a <= b;
         }
@@ -523,6 +564,7 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a <= b;
         }
@@ -531,7 +573,9 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             const a = ctx.properties()[(k).value];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a >= b;
         }
@@ -541,6 +585,7 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const b = (v).value;
             return typeof a === typeof b && a >= b;
         }
@@ -558,23 +603,27 @@ CompoundExpression.register(expressions, {
     'filter-type-in': [
         BooleanType,
         [array(StringType)],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         (ctx, [v]) => (v).value.indexOf(ctx.geometryType()) >= 0
     ],
     'filter-id-in': [
         BooleanType,
         [array(ValueType)],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         (ctx, [v]) => (v).value.indexOf(ctx.id()) >= 0
     ],
     'filter-in-small': [
         BooleanType,
         [StringType, array(ValueType)],
         // assumes v is an array literal
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         (ctx, [k, v]) => (v).value.indexOf(ctx.properties()[(k).value]) >= 0
     ],
     'filter-in-large': [
         BooleanType,
         [StringType, array(ValueType)],
         // assumes v is a array literal with values sorted in ascending order and of a single type
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
         (ctx, [k, v]) => binarySearch(ctx.properties()[(k).value], (v).value, 0, (v).value.length - 1)
     ],
     'all': {
@@ -629,6 +678,7 @@ CompoundExpression.register(expressions, {
         (ctx, [s]) => {
             const isSupportedScript = ctx.globals && ctx.globals.isSupportedScript;
             if (isSupportedScript) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 return isSupportedScript(s.evaluate(ctx));
             }
             return true;
@@ -637,31 +687,32 @@ CompoundExpression.register(expressions, {
     'upcase': [
         StringType,
         [StringType],
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         (ctx, [s]) => s.evaluate(ctx).toUpperCase()
     ],
     'downcase': [
         StringType,
         [StringType],
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         (ctx, [s]) => s.evaluate(ctx).toLowerCase()
     ],
     'concat': [
         StringType,
         varargs(ValueType),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (ctx, args) => args.map(arg => valueToString(arg.evaluate(ctx))).join('')
     ],
     'resolved-locale': [
         StringType,
         [CollatorType],
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
     ],
     'random': [
         NumberType,
         [NumberType, NumberType, ValueType],
         (ctx, args) => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
             const [min, max, seed] = args.map(arg => arg.evaluate(ctx));
             if (min > max) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -679,6 +730,7 @@ CompoundExpression.register(expressions, {
             } else {
                 throw new RuntimeError(`Invalid seed input: ${seed}`);
             }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const random = mulberry32(seedVal)();
             // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return min + random * (max - min);

package/expression/definitions/index_of.ts

@@ -56,22 +56,28 @@ class IndexOf implements Expression {
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
+        // 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 (!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.`);
         }
 
         if (this.fromIndex) {
             const fromIndex = (this.fromIndex.evaluate(ctx) as number);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             return haystack.indexOf(needle, fromIndex);
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         return haystack.indexOf(needle);
     }
 

package/expression/definitions/interpolate.ts

@@ -73,6 +73,7 @@ class Interpolate implements Expression {
         if (interpolation[0] === 'linear') {
             interpolation = {name: 'linear'};
         } else if (interpolation[0] === 'exponential') {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const base = interpolation[1];
             if (typeof base !== 'number')
                 return context.error(`Exponential interpolation requires a numeric base.`, 1, 1);
@@ -160,6 +161,7 @@ class Interpolate implements Expression {
             return outputs[0].evaluate(ctx) as Color;
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const value: number = this.input.evaluate(ctx);
         if (value <= labels[0]) {
             return outputs[0].evaluate(ctx) as Color;
@@ -175,11 +177,13 @@ class Interpolate implements Expression {
         const upper = labels[index + 1];
         const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const outputLower: Color = outputs[index].evaluate(ctx);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const outputUpper: Color = outputs[index + 1].evaluate(ctx);
 
         if (this.operator === 'interpolate') {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
             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));

package/expression/definitions/length.ts

@@ -32,12 +32,14 @@ class Length implements Expression {
     }
 
     evaluate(ctx: EvaluationContext): number {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const input = this.input.evaluate(ctx);
         if (typeof input === 'string') {
             return input.length;
         } else if (Array.isArray(input)) {
             return input.length;
         } else {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             throw new RuntimeError(`Expected value to be of type string or array, but found ${toString(typeOf(input))} instead.`);
         }
     }

package/expression/definitions/let.ts

@@ -10,6 +10,7 @@ class Let implements Expression {
 
     constructor(bindings: Array<[string, Expression]>, result: Expression) {
         this.type = result.type;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         this.bindings = [].concat(bindings);
         this.result = result;
     }

package/expression/definitions/match.ts

@@ -66,6 +66,7 @@ class Match implements Expression {
 
                 } else if (!inputType) {
                     inputType = typeOf(label);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 } else if (labelContext.checkSubtype(inputType, typeOf(label))) {
                     return null;
                 }
@@ -91,16 +92,20 @@ class Match implements Expression {
 
         assert(inputType && outputType);
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         if (input.type.kind !== 'value' && context.concat(1).checkSubtype((inputType), input.type)) {
             return null;
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Match(inputType, outputType, input, cases, outputs, otherwise);
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const input = (this.input.evaluate(ctx));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
         const output = (typeEquals(typeOf(input), this.inputType) && this.outputs[this.cases[input]]) || this.otherwise;
         return output.evaluate(ctx);
     }

package/expression/definitions/number_format.ts

@@ -70,20 +70,27 @@ export default class NumberFormat implements Expression {
             if (!maxFractionDigits) return null;
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new NumberFormat(number, locale, currency, unit, minFractionDigits, maxFractionDigits);
     }
 
     evaluate(ctx: EvaluationContext): string {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Intl.NumberFormat(this.locale ? this.locale.evaluate(ctx) : [],
             {
                 style:
                     (this.currency && "currency") ||
                     (this.unit && "unit") ||
                     "decimal",
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 currency: this.currency ? this.currency.evaluate(ctx) : undefined,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 unit: this.unit ? this.unit.evaluate(ctx) : undefined,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(ctx) : undefined,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(ctx) : undefined,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             }).format(this.number.evaluate(ctx));
     }
 

package/expression/definitions/slice.ts

@@ -56,18 +56,22 @@ class Slice implements Expression {
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const input = (this.input.evaluate(ctx));
         const beginIndex = (this.beginIndex.evaluate(ctx) as number);
 
         if (!isValidNativeType(input, ['string', 'array'])) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             throw new RuntimeError(`Expected first argument to be of type array or string, but found ${toString(typeOf(input))} instead.`);
         }
 
         if (this.endIndex) {
             const endIndex = (this.endIndex.evaluate(ctx) as number);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             return input.slice(beginIndex, endIndex);
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         return input.slice(beginIndex);
     }
 

package/expression/definitions/within.ts

@@ -144,6 +144,7 @@ function getTileLines(geometry: Array<Array<Point>> | null | undefined, lineBBox
             updateBBox(lineBBox, p);
             tileLine.push(p);
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         tileLines.push(tileLine);
     }
     if (lineBBox[2] - lineBBox[0] <= worldSize / 2) {