@mapbox/mapbox-gl-style-spec 14.10.0 → 14.11.0-beta.2

package/expression/definitions/image.ts

@@ -1,56 +1,71 @@
-import {ColorType, ResolvedImageType, StringType} from '../types';
 import ResolvedImage from '../types/resolved_image';
+import {ImageId} from '../types/image_id';
+import {ColorType, ResolvedImageType, StringType} from '../types';
 
 import type Color from '../../util/color';
-import type {Expression, SerializedExpression} from '../expression';
-import type EvaluationContext from '../evaluation_context';
 import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
 import type {Type} from '../types';
+import type {Expression, SerializedExpression} from '../expression';
 
 export type ImageParams = Record<string, Expression>;
+export type IconsetParams = {id: string};
 
 export type ImageOptions = {
-    params: ImageParams;
+    params?: ImageParams;
+    iconset?: IconsetParams;
 }
 
-function isImageOptions(value: unknown) {
-    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-        return true;
-    }
+type SerializedImageOptions = {
+    params?: Record<string, SerializedExpression>;
+    iconset?: IconsetParams;
+};
 
-    return false;
+function isImageOptions(value: unknown): value is ImageOptions {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
 export default class ImageExpression implements Expression {
     type: Type;
-    inputPrimary: Expression;
-    inputPrimaryParams: Record<string, Expression> | undefined;
-    inputSecondary: Expression | null | undefined;
-    inputSecondaryParams: Record<string, Expression> | undefined;
+
+    namePrimary: Expression;
+    paramsPrimary?: ImageParams;
+    iconsetIdPrimary?: string;
+
+    nameSecondary?: Expression;
+    paramsSecondary?: ImageParams;
+    iconsetIdSecondary?: string;
 
     _imageWarnHistory: Record<string, boolean> = {};
 
     constructor(
         inputPrimary: Expression,
         inputSecondary?: Expression | null,
-        inputPrimaryParams?: Record<string, Expression>,
-        inputSecondaryParams?: Record<string, Expression>
+        inputPrimaryOptions?: ImageOptions,
+        inputSecondaryOptions?: ImageOptions
     ) {
         this.type = ResolvedImageType;
-        this.inputPrimary = inputPrimary;
-        this.inputSecondary = inputSecondary;
-        this.inputPrimaryParams = inputPrimaryParams;
-        this.inputSecondaryParams = inputSecondaryParams;
+        this.namePrimary = inputPrimary;
+        this.nameSecondary = inputSecondary;
+
+        if (inputPrimaryOptions) {
+            this.paramsPrimary = inputPrimaryOptions.params;
+            this.iconsetIdPrimary = inputPrimaryOptions.iconset ? inputPrimaryOptions.iconset.id : undefined;
+        }
+
+        if (inputSecondaryOptions) {
+            this.paramsSecondary = inputSecondaryOptions.params;
+            this.iconsetIdSecondary = inputSecondaryOptions.iconset ? inputSecondaryOptions.iconset.id : undefined;
+        }
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | void {
         if (args.length < 2) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected two or more arguments.`);
         }
 
         let nextArgId = 1;
-        const imageExpression: Array<{image: Expression, options: Record<string, Expression>}> = [];
+        const imageExpression: Array<{image: Expression, options?: ImageOptions}> = [];
 
         function tryParseImage() {
             if (nextArgId < args.length) {
@@ -60,7 +75,7 @@ export default class ImageExpression implements Expression {
                     return false;
                 }
 
-                imageExpression.push({image: imageName, options: undefined});
+                imageExpression.push({image: imageName, options: {}});
                 return true;
             }
 
@@ -69,45 +84,62 @@ export default class ImageExpression implements Expression {
 
         function tryParseOptions() {
             if (nextArgId < args.length) {
-                if (!isImageOptions(args[nextArgId])) {
+                const options = args[nextArgId];
+                if (!isImageOptions(options)) {
                     return true;
                 }
 
-                const params = (args[nextArgId] as ImageOptions).params;
-
+                const params = options.params;
+                const iconset = options.iconset;
                 const optionsContext = context.concat(nextArgId);
 
-                if (!params) {
+                if (!params && !iconset) {
                     nextArgId++;
                     return true;
                 }
 
-                if (typeof params !== 'object' || params.constructor !== Object) {
-                    optionsContext.error(`Image options \"params\" should be an object`);
-                    return false;
-                }
+                // Parse the image options params as expressions
+                if (params) {
+                    if (typeof params !== 'object' || params.constructor !== Object) {
+                        optionsContext.error(`Image options \"params\" should be an object`);
+                        return false;
+                    }
 
-                const parsed = {};
+                    const parsedParams: ImageParams = {};
+                    const childContext = optionsContext.concat(undefined, 'params');
+                    for (const key in params) {
+                        if (!key) {
+                            childContext.error(`Image parameter name should be non-empty`);
+                            return false;
+                        }
 
-                const childContext = optionsContext.concat(undefined, 'params');
+                        const value = childContext.concat(undefined, key).parse(params[key], undefined, ColorType, undefined, {typeAnnotation: 'coerce'});
+                        if (!value) {
+                            return false;
+                        }
 
-                for (const key in params) {
-                    if (!key) {
-                        childContext.error(`Image parameter name should be non-empty`);
+                        parsedParams[key] = value;
+                    }
+
+                    imageExpression[imageExpression.length - 1].options.params = parsedParams;
+                }
+
+                // Validate the iconset image options
+                if (iconset) {
+                    if (typeof iconset !== 'object' || iconset.constructor !== Object) {
+                        optionsContext.error(`Image options \"iconset\" should be an object`);
                         return false;
                     }
 
-                    const value = childContext.concat(undefined, key).parse(params[key], undefined, ColorType, undefined, {typeAnnotation: 'coerce'});
-                    if (!value) {
+                    if (!iconset.id) {
+                        optionsContext.error(`Image options \"iconset\" should have an \"id\" property`);
                         return false;
                     }
 
-                    parsed[key] = value;
+                    imageExpression[imageExpression.length - 1].options.iconset = iconset;
                 }
 
-                imageExpression[imageExpression.length - 1].options = parsed;
                 nextArgId++;
-
                 return true;
             }
 
@@ -163,17 +195,30 @@ export default class ImageExpression implements Expression {
     }
 
     evaluate(ctx: EvaluationContext): null | ResolvedImage {
+        const primaryId = {
+            name: this.namePrimary.evaluate(ctx),
+            iconsetId: this.iconsetIdPrimary
+        };
+
+        const secondaryId = this.nameSecondary ? {
+            name: this.nameSecondary.evaluate(ctx),
+            iconsetId: this.iconsetIdSecondary
+        } : undefined;
+
         const value = ResolvedImage.build(
-            this.inputPrimary.evaluate(ctx),
-            this.inputSecondary ? this.inputSecondary.evaluate(ctx) : undefined,
-            this.inputPrimaryParams ? this.evaluateParams(ctx, this.inputPrimaryParams) : undefined,
-            this.inputSecondaryParams ? this.evaluateParams(ctx, this.inputSecondaryParams) : undefined
+            primaryId,
+            secondaryId,
+            this.paramsPrimary ? this.evaluateParams(ctx, this.paramsPrimary) : undefined,
+            this.paramsSecondary ? this.evaluateParams(ctx, this.paramsSecondary) : undefined
         );
+
         if (value && ctx.availableImages) {
-            value.available = ctx.availableImages.indexOf(value.namePrimary) > -1;
-            // If there's a secondary variant, only mark it available if both are present
-            if (value.nameSecondary && value.available && ctx.availableImages) {
-                value.available = ctx.availableImages.indexOf(value.nameSecondary) > -1;
+            const primaryId = value.getPrimary().id;
+            value.available = ctx.availableImages.some((id) => ImageId.isEqual(id, primaryId));
+            if (value.available) {
+                // If there's a secondary variant, only mark it available if both are present
+                const secondaryId = value.getSecondary() ? value.getSecondary().id : null;
+                if (secondaryId) value.available = ctx.availableImages.some((id) => ImageId.isEqual(id, secondaryId));
             }
         }
 
@@ -181,20 +226,22 @@ export default class ImageExpression implements Expression {
     }
 
     eachChild(fn: (_: Expression) => void) {
-        fn(this.inputPrimary);
-        if (this.inputPrimaryParams) {
-            for (const key in this.inputPrimaryParams) {
-                if (this.inputPrimaryParams[key]) {
-                    fn(this.inputPrimaryParams[key]);
+        fn(this.namePrimary);
+
+        if (this.paramsPrimary) {
+            for (const key in this.paramsPrimary) {
+                if (this.paramsPrimary[key]) {
+                    fn(this.paramsPrimary[key]);
                 }
             }
         }
-        if (this.inputSecondary) {
-            fn(this.inputSecondary);
-            if (this.inputSecondaryParams) {
-                for (const key in this.inputSecondaryParams) {
-                    if (this.inputSecondaryParams[key]) {
-                        fn(this.inputSecondaryParams[key]);
+
+        if (this.nameSecondary) {
+            fn(this.nameSecondary);
+            if (this.paramsSecondary) {
+                for (const key in this.paramsSecondary) {
+                    if (this.paramsSecondary[key]) {
+                        fn(this.paramsSecondary[key]);
                     }
                 }
             }
@@ -206,33 +253,39 @@ export default class ImageExpression implements Expression {
         return false;
     }
 
-    serializeParams(params: Record<string, Expression> | undefined): {params: Record<string, SerializedExpression>} {
-        const result: Record<string, SerializedExpression> = {};
+    serializeOptions(params: ImageParams, iconsetId: string): SerializedImageOptions | undefined {
+        const result: SerializedImageOptions = {};
+
+        if (iconsetId) {
+            result.iconset = {id: iconsetId};
+        }
+
         if (params) {
+            result.params = {};
             for (const key in params) {
                 if (params[key]) {
-                    result[key] = params[key].serialize();
+                    result.params[key] = params[key].serialize();
                 }
             }
-        } else {
-            return undefined;
         }
 
-        return {params: result};
+        return Object.keys(result).length > 0 ? result : undefined;
     }
 
     serialize(): SerializedExpression {
-        const serialized: SerializedExpression = ["image", this.inputPrimary.serialize()];
+        const serialized: SerializedExpression = ['image', this.namePrimary.serialize()];
 
-        if (this.inputPrimaryParams) {
-            serialized.push(this.serializeParams(this.inputPrimaryParams));
+        if (this.paramsPrimary || this.iconsetIdPrimary) {
+            const options = this.serializeOptions(this.paramsPrimary, this.iconsetIdPrimary);
+            if (options) serialized.push(options);
         }
 
-        if (this.inputSecondary) {
-            serialized.push(this.inputSecondary.serialize());
+        if (this.nameSecondary) {
+            serialized.push(this.nameSecondary.serialize());
 
-            if (this.inputSecondaryParams) {
-                serialized.push(this.serializeParams(this.inputSecondaryParams));
+            if (this.paramsSecondary || this.iconsetIdSecondary) {
+                const options = this.serializeOptions(this.paramsSecondary, this.iconsetIdSecondary);
+                if (options) serialized.push(options);
             }
         }
 

package/expression/definitions/index.ts

@@ -19,6 +19,7 @@ import Literal from './literal';
 import Assertion from './assertion';
 import Coercion from './coercion';
 import At from './at';
+import AtInterpolated from './at_interpolated';
 import In from './in';
 import IndexOf from './index_of';
 import Match from './match';
@@ -60,6 +61,7 @@ const expressions: ExpressionRegistry = {
     '<=': LessThanOrEqual,
     'array': Assertion,
     'at': At,
+    'at-interpolated': AtInterpolated,
     'boolean': Assertion,
     'case': Case,
     'coalesce': Coalesce,
@@ -98,8 +100,7 @@ function rgba(ctx: EvaluationContext, [r, g, b, a]: Expression[]) {
     const alpha = a ? a.evaluate(ctx) : 1;
     const error = validateRGBA(r, g, b, alpha);
     if (error) throw new RuntimeError(error);
-    // @ts-expect-error
-    return new Color(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
+    return new Color(r as unknown as number / 255 * alpha, g as unknown as number / 255 * alpha, b as unknown as number / 255 * alpha, alpha);
 }
 
 function hsla(ctx: EvaluationContext, [h, s, l, a]: Expression[]) {

package/expression/definitions/interpolate.ts

@@ -1,10 +1,8 @@
 import UnitBezier from '@mapbox/unitbezier';
 import * as interpolate from '../../util/interpolate';
-import {toString, NumberType, ColorType, ValueType} from '../types';
+import {toString, NumberType, ColorType} from '../types';
 import {findStopLessThanOrEqualTo} from '../stops';
 import {hcl, lab} from '../../util/color_spaces';
-import Literal from './literal';
-import RuntimeError from '../runtime_error';
 
 import type Color from '../../util/color';
 import type {Stops} from '../stops';
@@ -13,32 +11,30 @@ import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
 import type {Type} from '../types';
 
-export type InterpolationType = {
-    name: 'linear';
-} | {
-    name: 'exponential';
-    base: number;
-} | {
-    name: 'cubic-bezier';
-    controlPoints: [number, number, number, number];
-};
+export type InterpolationType =
+    | {name: 'linear'}
+    | {name: 'exponential'; base: number}
+    | {name: 'cubic-bezier'; controlPoints: [number, number, number, number]};
+
+export type InterpolationOperator =
+    | 'interpolate'
+    | 'interpolate-hcl'
+    | 'interpolate-lab';
 
 class Interpolate implements Expression {
     type: Type;
 
-    operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab';
+    operator: InterpolationOperator;
     interpolation: InterpolationType;
     input: Expression;
-    dynamicStops: Expression | null;
     labels: Array<number>;
     outputs: Array<Expression>;
 
-    constructor(type: Type, operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab', interpolation: InterpolationType, input: Expression, dynamicStops: Expression | null, stops: Stops) {
+    constructor(type: Type, operator: InterpolationOperator, interpolation: InterpolationType, input: Expression, stops: Stops) {
         this.type = type;
         this.operator = operator;
         this.interpolation = interpolation;
         this.input = input;
-        this.dynamicStops = dynamicStops;
 
         this.labels = [];
         this.outputs = [];
@@ -67,11 +63,10 @@ class Interpolate implements Expression {
         return t;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Interpolate | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Interpolate | null | void {
         let [operator, interpolation, input, ...rest] = args;
 
         if (!Array.isArray(interpolation) || interpolation.length === 0) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Expected an interpolation type expression.`, 1);
         }
 
@@ -80,7 +75,6 @@ class Interpolate implements Expression {
         } else if (interpolation[0] === 'exponential') {
             const base = interpolation[1];
             if (typeof base !== 'number')
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 return context.error(`Exponential interpolation requires a numeric base.`, 1, 1);
             interpolation = {
                 name: 'exponential',
@@ -92,7 +86,6 @@ class Interpolate implements Expression {
                 controlPoints.length !== 4 ||
                 controlPoints.some(t => typeof t !== 'number' || t < 0 || t > 1)
             ) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 return context.error('Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.', 1);
             }
 
@@ -101,17 +94,14 @@ class Interpolate implements Expression {
                 controlPoints: (controlPoints as any)
             };
         } else {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
         }
 
-        if (args.length - 1 < 3) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
-            return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
+        if (args.length - 1 < 4) {
+            return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         }
 
         if (args.length - 1 > 3 && (args.length - 1) % 2 !== 0) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Expected an even number of arguments.`);
         }
 
@@ -127,15 +117,6 @@ class Interpolate implements Expression {
             outputType = context.expectedType;
         }
 
-        // Exactly 3 arguments means that the steps are created by an expression
-        if (args.length - 1 === 3) {
-            const dynamicStops = context.parse(rest[0], 3, ValueType);
-            if (!dynamicStops) return null;
-
-            // @ts-expect-error - TS2345 - Argument of type 'unknown' is not assignable to parameter of type 'InterpolationType'.
-            return new Interpolate(outputType, (operator as any), interpolation, input, dynamicStops, stops);
-        }
-
         for (let i = 0; i < rest.length; i += 2) {
             const label = rest[i];
             const value = rest[i + 1];
@@ -144,12 +125,10 @@ class Interpolate implements Expression {
             const valueKey = i + 4;
 
             if (typeof label !== 'number') {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 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) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 return context.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 
@@ -167,41 +146,15 @@ class Interpolate implements Expression {
                 typeof outputType.N === 'number'
             )
         ) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Type ${toString(outputType)} is not interpolatable.`);
         }
 
-        // @ts-expect-error - TS2345 - Argument of type 'unknown' is not assignable to parameter of type 'InterpolationType'.
-        return new Interpolate(outputType, (operator as any), interpolation, input, null, stops);
+        return new Interpolate(outputType, operator as InterpolationOperator, interpolation as InterpolationType, input as Expression, stops);
     }
 
     evaluate(ctx: EvaluationContext): Color {
-        let labels = this.labels;
-        let outputs = this.outputs;
-
-        if (this.dynamicStops) {
-            const dynamicStopsValue = (this.dynamicStops.evaluate(ctx) as [number]);
-            if (dynamicStopsValue.length % 2 !== 0) {
-                throw new RuntimeError('Expected an even number of arguments.');
-            }
-            labels = [];
-            outputs = [];
-            for (let i = 0; i < dynamicStopsValue.length; i += 2) {
-                const label = dynamicStopsValue[i];
-                const output = new Literal(NumberType, dynamicStopsValue[i + 1]);
-                if (typeof label !== 'number') {
-                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.');
-                }
-                if (labels.length && labels[labels.length - 1] >= label) {
-                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.');
-                }
-                labels.push(label);
-                outputs.push(output);
-            }
-            if (labels.length === 0) {
-                throw new RuntimeError('Expected at least one input/output pair.');
-            }
-        }
+        const labels = this.labels;
+        const outputs = this.outputs;
 
         if (labels.length === 1) {
             return outputs[0].evaluate(ctx);
@@ -246,31 +199,26 @@ class Interpolate implements Expression {
     }
 
     serialize(): SerializedExpression {
-        let interpolation;
+        let interpolation: [InterpolationType['name'], ...number[]];
         if (this.interpolation.name === 'linear') {
-            interpolation = ["linear"];
+            interpolation = ['linear'];
         } else if (this.interpolation.name === 'exponential') {
             if  (this.interpolation.base === 1) {
-                interpolation = ["linear"];
+                interpolation = ['linear'];
             } else {
-                interpolation = ["exponential", this.interpolation.base];
+                interpolation = ['exponential', this.interpolation.base];
             }
         } else {
-            // @ts-expect-error - TS2769 - No overload matches this call.
-            interpolation = ["cubic-bezier" ].concat(this.interpolation.controlPoints);
+            interpolation = ['cubic-bezier', ...this.interpolation.controlPoints];
         }
 
         const serialized = [this.operator, interpolation, this.input.serialize()];
 
-        if (this.dynamicStops) {
-            serialized.push(this.dynamicStops.serialize());
-        } else {
-            for (let i = 0; i < this.labels.length; i++) {
-                serialized.push(
-                    this.labels[i],
-                    this.outputs[i].serialize()
-                );
-            }
+        for (let i = 0; i < this.labels.length; i++) {
+            serialized.push(
+                this.labels[i],
+                this.outputs[i].serialize()
+            );
         }
         return serialized;
     }

package/expression/definitions/let.ts

@@ -25,9 +25,8 @@ class Let implements Expression {
         fn(this.result);
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Let | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Let | null | void {
         if (args.length < 4)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Let'.
             return context.error(`Expected at least 3 arguments, but found ${args.length - 1} instead.`);
 
         const bindings: Array<[string, Expression]> = [];
@@ -35,12 +34,10 @@ class Let implements Expression {
             const name = args[i];
 
             if (typeof name !== 'string') {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Let'.
                 return context.error(`Expected string, but found ${typeof name} instead.`, i);
             }
 
             if (/[^a-zA-Z0-9_]/.test(name)) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Let'.
                 return context.error(`Variable names must contain only alphanumeric characters or '_'.`, i);
             }
 
@@ -61,12 +58,10 @@ class Let implements Expression {
     }
 
     serialize(): SerializedExpression {
-        const serialized = ["let"];
+        const serialized: SerializedExpression[] = ["let"];
         for (const [name, expr] of this.bindings) {
-            // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
             serialized.push(name, expr.serialize());
         }
-        // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
         serialized.push(this.result.serialize());
         return serialized;
     }

package/expression/definitions/literal.ts

@@ -58,8 +58,7 @@ class Literal implements Expression {
             // Constant-folding can generate Literal expressions that you
             // couldn't actually generate with a "literal" expression,
             // so we have to implement an equivalent serialization here
-            // @ts-expect-error - TS2769 - No overload matches this call.
-            return ["rgba"].concat(this.value.toRenderColor(null).toArray());
+            return ["rgba" as SerializedExpression].concat(this.value.toRenderColor(null).toArray());
         } else if (this.value instanceof Formatted) {
             // Same as Color
             return this.value.serialize();

package/expression/definitions/match.ts

@@ -28,12 +28,10 @@ class Match implements Expression {
         this.otherwise = otherwise;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Match | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Match | null | void {
         if (args.length < 5)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
             return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         if (args.length % 2 !== 1)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
             return context.error(`Expected an even number of arguments.`);
 
         let inputType;
@@ -52,23 +50,17 @@ class Match implements Expression {
             }
 
             const labelContext = context.concat(i);
-            // @ts-expect-error - TS2339 - Property 'length' does not exist on type 'unknown'.
-            if (labels.length === 0) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
+            if ((labels as unknown[]).length === 0) {
                 return labelContext.error('Expected at least one branch label.');
             }
 
-            // @ts-expect-error - TS2488 - Type 'unknown' must have a '[Symbol.iterator]()' method that returns an iterator.
-            for (const label of labels) {
+            for (const label of (labels as unknown[])) {
                 if (typeof label !== 'number' && typeof label !== 'string') {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error(`Branch labels must be numbers or strings.`);
                 } else if (typeof label === 'number' && Math.abs(label) > Number.MAX_SAFE_INTEGER) {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
 
                 } else if (typeof label === 'number' && Math.floor(label) !== label) {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error(`Numeric branch labels must be integer values.`);
 
                 } else if (!inputType) {
@@ -78,7 +70,6 @@ class Match implements Expression {
                 }
 
                 if (typeof cases[String(label)] !== 'undefined') {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error('Branch labels must be unique.');
                 }