@mapbox/mapbox-gl-style-spec 14.23.0 → 14.24.0-rc.1

package/error/parsing_error.ts

@@ -1,5 +1,7 @@
 // Note: Do not inherit from Error. It breaks when transpiling to ES5.
 
+const LINE_NUMBER_RE = /line (\d+)/;
+
 export default class ParsingError {
     message: string;
     error: Error;
@@ -8,7 +10,7 @@ export default class ParsingError {
     constructor(error: Error) {
         this.error = error;
         this.message = error.message;
-        const match = error.message.match(/line (\d+)/);
+        const match = error.message.match(LINE_NUMBER_RE);
         this.line = match ? parseInt(match[1], 10) : 0;
     }
 }

package/expression/compound_expression.ts

@@ -83,9 +83,16 @@ class CompoundExpression implements Expression {
             overloadParams.push(params);
             overloadIndex++;
 
-            // Use a fresh context for each attempted signature so that, if
-            // we eventually succeed, we haven't polluted `context.errors`.
-            signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, undefined, context._scope, context.options, context.iconImageUseTheme);
+            // Use a fresh-looking context for each attempted signature so
+            // that, if we eventually succeed, we haven't polluted
+            // `context.errors`. We allocate the context once and reset its
+            // errors between overload attempts; the other fields are
+            // identical across attempts.
+            if (signatureContext === null) {
+                signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, [], context._scope, context.options, context.iconImageUseTheme);
+            } else {
+                signatureContext.errors.length = 0;
+            }
 
             // First parse all the args, potentially coercing to the
             // types expected by this overload.
@@ -120,7 +127,7 @@ class CompoundExpression implements Expression {
             for (let i = 0; i < parsedArgs.length; i++) {
                 const expected = Array.isArray(params) ? params[i] : params.type;
                 const arg = parsedArgs[i];
-                signatureContext.concat(i + 1).checkSubtype(expected, arg.type);
+                signatureContext.checkSubtype(expected, arg.type, i + 1);
             }
 
             if (signatureContext.errors.length === 0) {

package/expression/definitions/assertion.ts

@@ -38,11 +38,11 @@ class Assertion implements Expression {
             return context.error(`Expected at least one argument.`);
 
         let i = 1;
-        let type;
+        let type: Type;
 
         const name = args[0] as string;
         if (name === 'array') {
-            let itemType;
+            let itemType: Type;
             if (args.length > 2) {
                 const type = args[1];
                 if (typeof type !== 'string' || !(type in types) || type === 'object')
@@ -67,7 +67,6 @@ class Assertion implements Expression {
                 i++;
             }
 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             type = array(itemType, N);
         } else {
             assert(types[name], name);

package/expression/definitions/case.ts

@@ -48,7 +48,7 @@ class Case implements Expression {
             outputType = outputType || result.type;
         }
 
-        const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+        const otherwise = context.parse(args.at(-1), args.length - 1, outputType);
         if (!otherwise) return null;
 
         assert(outputType);

package/expression/definitions/coercion.ts

@@ -65,7 +65,7 @@ class Coercion implements Expression {
             for (let i = 0; i < arrayLength; i++) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 const member = args[1][i];
-                let parsedMember;
+                let parsedMember: Expression | null | void;
                 if (Array.isArray(member)) {
                     parsedMember = context.parse(member, undefined, type.itemType);
                 } else {
@@ -103,8 +103,9 @@ class Coercion implements Expression {
         if (this.type.kind === 'boolean') {
             return Boolean(this.args[0].evaluate(ctx));
         } else if (this.type.kind === 'color') {
-            let input;
-            let error;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let input: any;
+            let error: string | null;
             for (const arg of this.args) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 input = arg.evaluate(ctx);
@@ -126,7 +127,6 @@ class Coercion implements Expression {
                     }
                 }
             }
-            // 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;

package/expression/definitions/format.ts

@@ -70,7 +70,7 @@ export default class FormatExpression implements Expression {
                     if (!textColor) return null;
                 }
 
-                const lastExpression = sections[sections.length - 1];
+                const lastExpression = sections.at(-1);
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 lastExpression.scale = scale;
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment

package/expression/definitions/image.ts

@@ -121,7 +121,7 @@ export default class ImageExpression implements Expression {
                         parsedParams[key] = value;
                     }
 
-                    imageExpression[imageExpression.length - 1].options.params = parsedParams;
+                    imageExpression.at(-1).options.params = parsedParams;
                 }
 
                 // Validate the iconset image options
@@ -136,7 +136,7 @@ export default class ImageExpression implements Expression {
                         return false;
                     }
 
-                    imageExpression[imageExpression.length - 1].options.iconset = iconset;
+                    imageExpression.at(-1).options.iconset = iconset;
                 }
 
                 nextArgId++;

package/expression/definitions/in.ts

@@ -66,7 +66,7 @@ class In implements Expression {
         }
 
         // Type assertions safe due to isValidNativeType checks above
-        return (haystack as string | unknown[]).indexOf(needle as string) >= 0;
+        return (haystack as string | unknown[]).includes(needle as string);
     }
 
     eachChild(fn: (_: Expression) => void) {

package/expression/definitions/index.ts

@@ -617,21 +617,21 @@ 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
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
+        (ctx, [v]) => (v).value.includes(ctx.geometryType())
     ],
     '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
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
+        (ctx, [v]) => (v).value.includes(ctx.id())
     ],
     '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
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
+        (ctx, [k, v]) => (v).value.includes(ctx.properties()[(k).value])
     ],
     'filter-in-large': [
         BooleanType,
@@ -736,7 +736,7 @@ CompoundExpression.register(expressions, {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return min;
             }
-            let seedVal;
+            let seedVal: number;
             if (typeof seed === 'string') {
                 seedVal = hashString(seed);
             } else if (typeof seed === 'number') {
@@ -744,7 +744,6 @@ 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/interpolate.ts

@@ -129,7 +129,7 @@ class Interpolate implements Expression {
                 return context.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
             }
 
-            if (stops.length && stops[stops.length - 1][0] >= label) {
+            if (stops.length && stops.at(-1)[0] >= label) {
                 return context.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 

package/expression/definitions/let.ts

@@ -3,6 +3,8 @@ import type {Expression, SerializedExpression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext  from '../evaluation_context';
 
+const INVALID_VAR_CHAR_RE = /[^a-zA-Z0-9_]/;
+
 class Let implements Expression {
     type: Type;
     bindings: Array<[string, Expression]>;
@@ -39,7 +41,7 @@ class Let implements Expression {
                 return context.error(`Expected string, but found ${typeof name} instead.`, i);
             }
 
-            if (/[^a-zA-Z0-9_]/.test(name)) {
+            if (INVALID_VAR_CHAR_RE.test(name)) {
                 return context.error(`Variable names must contain only alphanumeric characters or '_'.`, i);
             }
 
@@ -49,7 +51,7 @@ class Let implements Expression {
             bindings.push([name, value]);
         }
 
-        const result = context.parse(args[args.length - 1], args.length - 1, context.expectedType, bindings);
+        const result = context.parse(args.at(-1), args.length - 1, context.expectedType, bindings);
         if (!result) return null;
 
         return new Let(bindings, result);

package/expression/definitions/match.ts

@@ -86,7 +86,7 @@ class Match implements Expression {
         const input = context.parse(args[1], 1, ValueType);
         if (!input) return null;
 
-        const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+        const otherwise = context.parse(args.at(-1), args.length - 1, outputType);
         if (!otherwise) return null;
 
         assert(inputType && outputType);

package/expression/definitions/step.ts

@@ -56,7 +56,7 @@ class Step implements Expression {
                 return context.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
             }
 
-            if (stops.length && stops[stops.length - 1][0] >= label) {
+            if (stops.length && stops.at(-1)[0] >= label) {
                 return context.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 

package/expression/is_constant.ts

@@ -19,7 +19,7 @@ function isFeatureConstant(e: Expression): boolean {
             e.name === 'id'
         ) {
             return false;
-        } else if (/^filter-/.test(e.name)) {
+        } else if (e.name.startsWith('filter-')) {
             return false;
         }
     }
@@ -57,7 +57,7 @@ function isStateConstant(e: Expression): boolean {
 }
 
 function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boolean {
-    if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) { return false; }
+    if (e instanceof CompoundExpression && properties.includes(e.name)) { return false; }
     let result = true;
     e.eachChild((arg) => {
         if (result && !isGlobalPropertyConstant(arg, properties)) { result = false; }

package/expression/parsing_context.ts

@@ -24,7 +24,6 @@ import type {ConfigOptions} from '../types/config_options';
 class ParsingContext {
     registry: ExpressionRegistry;
     path: Array<number | string>;
-    key: string;
     scope: Scope;
     errors: Array<ParsingError>;
     _scope: string | null | undefined;
@@ -37,6 +36,9 @@ class ParsingContext {
     // `expectedType`.
     expectedType: Type | null | undefined;
 
+    // `key` is only consulted on the error path, so compute it lazily.
+    private _key: string | undefined;
+
     constructor(
         registry: ExpressionRegistry,
         path: Array<number | string> = [],
@@ -49,7 +51,6 @@ class ParsingContext {
     ) {
         this.registry = registry;
         this.path = path;
-        this.key = path.map(part => { if (typeof part === 'string') { return `['${part}']`; } return `[${part}]`; }).join('');
         this.scope = scope;
         this.errors = errors;
         this.expectedType = expectedType;
@@ -58,6 +59,19 @@ class ParsingContext {
         this.iconImageUseTheme = iconImageUseTheme;
     }
 
+    get key(): string {
+        if (this._key === undefined) {
+            const path = this.path;
+            let key = '';
+            for (let i = 0; i < path.length; i++) {
+                const part = path[i];
+                key += typeof part === 'string' ? `['${part}']` : `[${part}]`;
+            }
+            this._key = key;
+        }
+        return this._key;
+    }
+
     /**
      * @param expr the JSON expression to parse
      * @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
@@ -226,9 +240,9 @@ class ParsingContext {
      * Returns null if `t` is a subtype of `expected`; otherwise returns an
      * error message and also pushes it to `this.errors`.
      */
-    checkSubtype(expected: Type, t: Type): string | null | undefined {
+    checkSubtype(expected: Type, t: Type, index?: number): string | null | undefined {
         const error = checkSubtype(expected, t);
-        if (error) this.error(error);
+        if (error) this.error(error, ...(typeof index === 'number' ? [index] : []));
         return error;
     }
 }

package/expression/stops.ts

@@ -13,7 +13,8 @@ export function findStopLessThanOrEqualTo(stops: Array<number>, input: number):
     let lowerIndex = 0;
     let upperIndex = lastIndex;
     let currentIndex = 0;
-    let currentValue, nextValue;
+    let currentValue: number;
+    let nextValue: number;
 
     while (lowerIndex <= upperIndex) {
         currentIndex = Math.floor((lowerIndex + upperIndex) / 2);

package/expression/types/image_variant.ts

@@ -47,7 +47,10 @@ export class ImageVariant implements RasterizationOptions {
     }
 
     static parse(str: StringifiedImageVariant): ImageVariant | null {
-        let id, params, sx, sy;
+        let id: ImageIdSpec | undefined;
+        let params: Record<string, Color> | undefined;
+        let sx: number | undefined;
+        let sy: number | undefined;
 
         try {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -58,8 +61,7 @@ export class ImageVariant implements RasterizationOptions {
 
         if (!id) return null;
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        return new ImageVariant(id as ImageIdSpec, {params, sx, sy});
+        return new ImageVariant(id, {params, sx, sy});
     }
 
     scaleSelf(factor: number, yFactor: number = factor): this {

package/feature_filter/index.ts

@@ -160,7 +160,7 @@ ${JSON.stringify(filterExp, null, 2)}
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractStaticFilter(filter: any): any {
+function extractStaticFilter(filter: unknown | unknown[]): any {
     if (!isDynamicFilter(filter)) {
         return filter;
     }
@@ -169,7 +169,7 @@ function extractStaticFilter(filter: any): any {
     let result = deepUnbundle(filter);
 
     // 1. Union branches
-    unionDynamicBranches(result);
+    unionDynamicBranches(result as unknown[]);
 
     // 2. Collapse dynamic conditions to  `true`
     result = collapseDynamicBooleanExpressions(result);
@@ -202,59 +202,36 @@ function collapseDynamicBooleanExpressions(expression: any): any {
  *
  * @param {Array<any>} filter the filter expression mutated in-place.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function unionDynamicBranches(filter: any) {
+function unionDynamicBranches(filter: unknown[]) {
     let isBranchingDynamically = false;
-    const branches = [];
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const branches: unknown[] = [];
     if (filter[0] === 'case') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (let i = 1; i < filter.length - 1; i += 2) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[i]);
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             branches.push(filter[i + 1]);
         }
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        branches.push(filter[filter.length - 1]);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        branches.push(filter.at(-1));
     } else if (filter[0] === 'match') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[1]);
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (let i = 2; i < filter.length - 1; i += 2) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             branches.push(filter[i + 1]);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        branches.push(filter[filter.length - 1]);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        branches.push(filter.at(-1));
     } else if (filter[0] === 'step') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[1]);
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (let i = 1; i < filter.length - 1; i += 2) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             branches.push(filter[i + 1]);
         }
     }
 
     if (isBranchingDynamically) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         filter.length = 0;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         filter.push('any', ...branches);
     }
 
     // traverse and recurse into children
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     for (let i = 1; i < filter.length; i++) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        unionDynamicBranches(filter[i]);
+        unionDynamicBranches(filter[i] as unknown[]);
     }
 }
 

package/function/index.ts

@@ -60,9 +60,10 @@ export function createFunction(parameters, propertySpec) {
         throw new Error(`Unknown color space: ${parameters.colorSpace}`);
     }
 
-    let innerFun;
-    let hashedStops;
-    let categoricalKeyType;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let innerFun: ((parameters: any, propertySpec: any, input: any, hashedStops?: any, categoricalKeyType?: any) => any) | undefined;
+    let hashedStops: Record<string | number, unknown> | undefined;
+    let categoricalKeyType: string | undefined;
     if (type === 'exponential') {
         innerFun = evaluateExponentialFunction;
     } else if (type === 'interval') {
@@ -75,7 +76,7 @@ export function createFunction(parameters, propertySpec) {
         hashedStops = Object.create(null);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (const stop of parameters.stops) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             hashedStops[stop[0]] = stop[1];
         }
 
@@ -154,7 +155,7 @@ export function createFunction(parameters, propertySpec) {
             interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
             // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             zoomStops: parameters.stops.map(s => s[0]),
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             evaluate: ({zoom}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
         };
     } else {
@@ -167,7 +168,7 @@ export function createFunction(parameters, propertySpec) {
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
                     return coalesce(parameters.default, propertySpec.default);
                 }
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
             }
         };

package/migrate/v9.ts

@@ -21,7 +21,7 @@ export default function (style) {
     // remove class-specific paint properties
     eachLayer(style, (layer) => {
         for (const k in layer) {
-            if (/paint\..*/.test(k)) {
+            if (k.includes('paint.')) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 delete layer[k];
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.23.0",
+  "version": "14.24.0-rc.1",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",

package/reference/v8.json

@@ -8982,6 +8982,26 @@
         ]
       },
       "property-type": "data-constant"
+    },
+    "line-blend-additive-clamp": {
+      "type": "number",
+      "default": 0,
+      "minimum": 0,
+      "doc": "Controls the brightness of lines in additive blend mode. When set to 0 (the default), brightness is adjusted automatically based on the density of lines visible on screen. Increase this value if the lines appear too bright, or decrease it if they appear too faint.",
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+        "basic functionality": {
+          "js": "3.21.0"
+        }
+      },
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "paint_circle": {

package/types.ts

@@ -759,7 +759,11 @@ export type LineLayerSpecification = {
         /**
          * @experimental This property is experimental and subject to change in future versions.
          */
-        "line-blend-mode"?: PropertyValueSpecification<"default" | "multiply" | "additive">
+        "line-blend-mode"?: PropertyValueSpecification<"default" | "multiply" | "additive">,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "line-blend-additive-clamp"?: PropertyValueSpecification<number>
     },
     /**
      * @experimental This property is experimental and subject to change in future versions.

package/util/color.ts

@@ -1,5 +1,5 @@
 import {parseCSSColor} from 'csscolorparser';
-import {number as lerp} from './interpolate';
+import {number as lerp} from './lerp';
 
 import type {LUT} from '../types/lut';
 
@@ -74,12 +74,7 @@ class Color {
      * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
      */
     toString(): string {
-        const [r, g, b, a] = [
-            this.r,
-            this.g,
-            this.b,
-            this.a
-        ];
+        const {r, g, b, a} = this;
         return `rgba(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)},${a})`;
     }
 

package/util/geometry_util.ts

@@ -13,10 +13,9 @@ export type BBox = [number, number, number, number];
  */
 function calculateSignedArea(ring: Ring): number {
     let sum = 0;
-    for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
+    for (let i = 0, len = ring.length, j = len - 1, p1: Point, p2: Point; i < len; j = i++) {
         p1 = ring[i];
         p2 = ring[j];
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         sum += (p2.x - p1.x) * (p1.y + p2.y);
     }
     return sum;
@@ -33,8 +32,8 @@ export function classifyRings(rings: Array<Ring>, maxRings: number): Array<Array
     if (len <= 1) return [rings];
 
     const polygons: Array<Array<Ring>> = [];
-    let polygon,
-        ccw;
+    let polygon: Array<Ring>,
+        ccw: boolean;
 
     for (let i = 0; i < len; i++) {
         const area = calculateSignedArea(rings[i]);
@@ -45,16 +44,12 @@ export function classifyRings(rings: Array<Ring>, maxRings: number): Array<Array
         if (ccw === undefined) ccw = area < 0;
 
         if (ccw === area < 0) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             if (polygon) polygons.push(polygon);
             polygon = [rings[i]];
-
         } else {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             (polygon).push(rings[i]);
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     if (polygon) polygons.push(polygon);
 
     // Earcut performance degrades with the # of rings in a polygon. For this

package/util/interpolate.ts

@@ -1,8 +1,7 @@
 import Color from './color';
+import {number} from './lerp';
 
-export function number(a: number, b: number, t: number): number {
-    return (a * (1 - t)) + (b * t);
-}
+export {number};
 
 export function color(from: Color, to: Color, t: number): Color {
     return new Color(

package/util/lerp.ts

@@ -0,0 +1,3 @@
+export function number(a: number, b: number, t: number): number {
+    return (a * (1 - t)) + (b * t);
+}

package/util/properties.ts

@@ -1,12 +1,15 @@
 import type {PropertyExpressionSpecification, StylePropertySpecification} from '../style-spec';
 
+export const TRANSITION_KEY_RE = /^(.*)-transition$/;
+export const USE_THEME_KEY_RE = /^(.*)-use-theme$/;
+
 type ExpressionParameter = PropertyExpressionSpecification['parameters'][number];
 
 function expressionHasParameter(
     expression: PropertyExpressionSpecification | null | undefined,
     parameter: ExpressionParameter,
 ): boolean {
-    return !!expression && !!expression.parameters && expression.parameters.indexOf(parameter) > -1;
+    return !!expression && !!expression.parameters && expression.parameters.includes(parameter);
 }
 
 export function supportsPropertyExpression(spec: StylePropertySpecification): boolean {