@mapbox/mapbox-gl-style-spec 14.4.0 → 14.5.0

package/expression/definitions/{interpolate.js → interpolate.ts}

@@ -1,23 +1,26 @@
-// @flow
-
 import UnitBezier from '@mapbox/unitbezier';
 
-import * as interpolate from '../../util/interpolate.js';
-import {toString, NumberType, ColorType} from '../types.js';
-import {findStopLessThanOrEqualTo} from '../stops.js';
-import {hcl, lab} from '../../util/color_spaces.js';
-import Color from '../../util/color.js';
-
-import type {Stops} from '../stops.js';
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type} from '../types.js';
-
-export type InterpolationType =
-    { name: 'linear' } |
-    { name: 'exponential', base: number } |
-    { name: 'cubic-bezier', controlPoints: [number, number, number, number] };
+import * as interpolate from '../../util/interpolate';
+import {toString, NumberType, ColorType} from '../types';
+import {findStopLessThanOrEqualTo} from '../stops';
+import {hcl, lab} from '../../util/color_spaces';
+import Color from '../../util/color';
+
+import type {Stops} from '../stops';
+import type {Expression, SerializedExpression} from '../expression';
+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];
+};
 
 class Interpolate implements Expression {
     type: Type;
@@ -42,7 +45,12 @@ class Interpolate implements Expression {
         }
     }
 
-    static interpolationFactor(interpolation: InterpolationType, input: number, lower: number, upper: number): number {
+    static interpolationFactor(
+        interpolation: InterpolationType,
+        input: number,
+        lower: number,
+        upper: number,
+    ): number {
         let t = 0;
         if (interpolation.name === 'exponential') {
             t = exponentialInterpolation(input, interpolation.base, lower, upper);
@@ -56,10 +64,11 @@ class Interpolate implements Expression {
         return t;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Interpolate {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Interpolate | null | undefined {
         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);
         }
 
@@ -68,6 +77,7 @@ 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',
@@ -79,22 +89,26 @@ 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);
             }
 
             interpolation = {
                 name: 'cubic-bezier',
-                controlPoints: (controlPoints: any)
+                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 < 4) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         }
 
         if ((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.`);
         }
 
@@ -103,7 +117,7 @@ class Interpolate implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = (null: any);
+        let outputType: Type = (null as any);
         if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
             outputType = ColorType;
         } else if (context.expectedType && context.expectedType.kind !== 'value') {
@@ -118,10 +132,12 @@ 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);
             }
 
@@ -139,10 +155,12 @@ 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.`);
         }
 
-        return new Interpolate(outputType, (operator: any), interpolation, input, stops);
+        // @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, stops);
     }
 
     evaluate(ctx: EvaluationContext): Color {
@@ -153,7 +171,7 @@ class Interpolate implements Expression {
             return outputs[0].evaluate(ctx);
         }
 
-        const value = ((this.input.evaluate(ctx): any): number);
+        const value = (this.input.evaluate(ctx) as number);
         if (value <= labels[0]) {
             return outputs[0].evaluate(ctx);
         }
@@ -172,7 +190,7 @@ class Interpolate implements Expression {
         const outputUpper = outputs[index + 1].evaluate(ctx);
 
         if (this.operator === 'interpolate') {
-            return (interpolate[this.type.kind.toLowerCase()]: any)(outputLower, outputUpper, t); // eslint-disable-line import/namespace
+            return (interpolate[this.type.kind.toLowerCase()] as any)(outputLower, outputUpper, t); // eslint-disable-line import/namespace
         } else if (this.operator === 'interpolate-hcl') {
             return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
         } else {
@@ -202,6 +220,7 @@ class Interpolate implements Expression {
                 interpolation = ["exponential", this.interpolation.base];
             }
         } else {
+            // @ts-expect-error - TS2769 - No overload matches this call.
             interpolation = ["cubic-bezier" ].concat(this.interpolation.controlPoints);
         }
 

package/expression/definitions/{length.js → length.ts}

@@ -1,14 +1,12 @@
-// @flow
+import {NumberType, toString} from '../types';
 
-import {NumberType, toString} from '../types.js';
+import {typeOf} from '../values';
+import RuntimeError from '../runtime_error';
 
-import {typeOf} from '../values.js';
-import RuntimeError from '../runtime_error.js';
-
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 class Length implements Expression {
     type: Type;
@@ -19,14 +17,16 @@ class Length implements Expression {
         this.input = input;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Length {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Length | null | undefined {
         if (args.length !== 2)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Length'.
             return context.error(`Expected 1 argument, but found ${args.length - 1} instead.`);
 
         const input = context.parse(args[1], 1);
         if (!input) return null;
 
         if (input.type.kind !== 'array' && input.type.kind !== 'string' && input.type.kind !== 'value')
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Length'.
             return context.error(`Expected argument of type string or array, but found ${toString(input.type)} instead.`);
 
         return new Length(input);
@@ -53,6 +53,7 @@ class Length implements Expression {
 
     serialize(): SerializedExpression {
         const serialized = ["length"];
+        // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
         this.eachChild(child => { serialized.push(child.serialize()); });
         return serialized;
     }

package/expression/definitions/{let.js → let.ts}

@@ -1,9 +1,7 @@
-// @flow
-
-import type {Type} from '../types.js';
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext  from '../evaluation_context.js';
+import type {Type} from '../types';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext  from '../evaluation_context';
 
 class Let implements Expression {
     type: Type;
@@ -27,8 +25,9 @@ class Let implements Expression {
         fn(this.result);
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Let {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Let | null | undefined {
         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]> = [];
@@ -36,10 +35,12 @@ 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);
             }
 
@@ -62,8 +63,10 @@ class Let implements Expression {
     serialize(): SerializedExpression {
         const serialized = ["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.js → literal.ts}

@@ -1,13 +1,11 @@
-// @flow
-
 import assert from 'assert';
-import {isValue, typeOf, Color} from '../values.js';
-import Formatted from '../types/formatted.js';
+import {isValue, typeOf, Color} from '../values';
+import Formatted from '../types/formatted';
 
-import type {Type} from '../types.js';
-import type {Value}  from '../values.js';
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
+import type {Type} from '../types';
+import type {Value}  from '../values';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
 
 class Literal implements Expression {
     type: Type;
@@ -18,14 +16,14 @@ class Literal implements Expression {
         this.value = value;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): void | Literal {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): void | Literal {
         if (args.length !== 2)
             return context.error(`'literal' expression requires exactly one argument, but found ${args.length - 1} instead.`);
 
         if (!isValue(args[1]))
             return context.error(`invalid value`);
 
-        const value = (args[1]: any);
+        const value = (args[1] as any);
         let type = typeOf(value);
 
         // special case: infer the item type if possible for zero-length arrays
@@ -60,7 +58,8 @@ 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
-            return ["rgba"].concat(this.value.toArray());
+            // @ts-expect-error - TS2769 - No overload matches this call.
+            return ["rgba"].concat(this.value.toRenderColor(null).toArray());
         } else if (this.value instanceof Formatted) {
             // Same as Color
             return this.value.serialize();
@@ -69,7 +68,7 @@ class Literal implements Expression {
                 typeof this.value === 'string' ||
                 typeof this.value === 'number' ||
                 typeof this.value === 'boolean');
-            return (this.value: any);
+            return this.value as any;
         }
     }
 }

package/expression/definitions/{match.js → match.ts}

@@ -1,16 +1,15 @@
-// @flow
-
 import assert from 'assert';
 
-import {typeOf} from '../values.js';
-import {ValueType, type Type} from '../types.js';
+import {typeOf} from '../values';
+import {ValueType} from '../types';
 
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
 
 // Map input label values to output expression index
-type Cases = {[number | string]: number};
+type Cases = Partial<Record<number | string, number>>;
 
 class Match implements Expression {
     type: Type;
@@ -30,18 +29,20 @@ class Match implements Expression {
         this.otherwise = otherwise;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Match {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Match | null | undefined {
         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;
-        let outputType: ?Type;
+        let outputType: Type | null | undefined;
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
-        const cases = {};
+        const cases: Record<string, any> = {};
         const outputs = [];
         for (let i = 2; i < args.length - 1; i += 2) {
             let labels = args[i];
@@ -52,17 +53,23 @@ 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'.
                 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) {
                 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) {
@@ -72,6 +79,7 @@ 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.');
                 }
 
@@ -92,15 +100,15 @@ class Match implements Expression {
 
         assert(inputType && outputType);
 
-        if (input.type.kind !== 'value' && context.concat(1).checkSubtype((inputType: any), input.type)) {
+        if (input.type.kind !== 'value' && context.concat(1).checkSubtype((inputType), input.type)) {
             return null;
         }
 
-        return new Match((inputType: any), (outputType: any), input, cases, outputs, otherwise);
+        return new Match((inputType), (outputType as any), input, cases, outputs, otherwise);
     }
 
     evaluate(ctx: EvaluationContext): any {
-        const input = (this.input.evaluate(ctx): any);
+        const input = (this.input.evaluate(ctx));
         const output = (typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
         return output.evaluate(ctx);
     }
@@ -125,7 +133,9 @@ class Match implements Expression {
         // Group branches by unique match expression to support condensed
         // serializations of the form [case1, case2, ...] -> matchExpression
         const groupedByOutput: Array<[number, Array<number | string>]> = [];
-        const outputLookup: {[index: number]: number} = {}; // lookup index into groupedByOutput for a given output expression
+        const outputLookup: {
+            [index: number]: number;
+        } = {}; // lookup index into groupedByOutput for a given output expression
         for (const label of sortedLabels) {
             const outputIndex = outputLookup[this.cases[label]];
             if (outputIndex === undefined) {

package/expression/definitions/{number_format.js → number_format.ts}

@@ -1,11 +1,9 @@
-// @flow
+import {StringType, NumberType} from '../types';
 
-import {StringType, NumberType} from '../types.js';
-
-import type {Expression, SerializedExpression} from '../expression.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type ParsingContext from '../parsing_context.js';
-import type {Type} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type EvaluationContext from '../evaluation_context';
+import type ParsingContext from '../parsing_context';
+import type {Type} from '../types';
 
 export default class NumberFormat implements Expression {
     type: Type;
@@ -31,15 +29,17 @@ export default class NumberFormat implements Expression {
         this.maxFractionDigits = maxFractionDigits;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
         if (args.length !== 3)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected two arguments.`);
 
         const number = context.parse(args[1], 1, NumberType);
         if (!number) return null;
 
-        const options = (args[2]: any);
+        const options = (args[2] as any);
         if (typeof options !== "object" || Array.isArray(options))
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`NumberFormat options argument must be an object.`);
 
         let locale = null;
@@ -113,7 +113,7 @@ export default class NumberFormat implements Expression {
     }
 
     serialize(): SerializedExpression {
-        const options = {};
+        const options: Record<string, any> = {};
         if (this.locale) {
             options['locale'] = this.locale.serialize();
         }

package/expression/definitions/{slice.js → slice.ts}

@@ -1,19 +1,25 @@
-// @flow
-
-import {ValueType, NumberType, StringType, array, toString, isValidType, isValidNativeType} from '../types.js';
-import RuntimeError from '../runtime_error.js';
-import {typeOf} from '../values.js';
-
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type} from '../types.js';
+import {
+    ValueType,
+    NumberType,
+    StringType,
+    array,
+    toString,
+    isValidType,
+    isValidNativeType,
+} from '../types';
+import RuntimeError from '../runtime_error';
+import {typeOf} from '../values';
+
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 class Slice implements Expression {
     type: Type;
     input: Expression;
     beginIndex: Expression;
-    endIndex: ?Expression;
+    endIndex: Expression | null | undefined;
 
     constructor(type: Type, input: Expression, beginIndex: Expression, endIndex?: Expression) {
         this.type = type;
@@ -23,8 +29,9 @@ class Slice implements Expression {
 
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Slice {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Slice | null | undefined {
         if (args.length <= 2 ||  args.length >= 5) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Slice'.
             return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
         }
 
@@ -34,6 +41,7 @@ class Slice implements Expression {
         if (!input || !beginIndex) return null;
 
         if (!isValidType(input.type, [array(ValueType), StringType, ValueType])) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Slice'.
             return context.error(`Expected first argument to be of type array or string, but found ${toString(input.type)} instead`);
         }
 
@@ -47,15 +55,15 @@ class Slice implements Expression {
     }
 
     evaluate(ctx: EvaluationContext): any {
-        const input = (this.input.evaluate(ctx): any);
-        const beginIndex = (this.beginIndex.evaluate(ctx): number);
+        const input = (this.input.evaluate(ctx));
+        const beginIndex = (this.beginIndex.evaluate(ctx) as number);
 
         if (!isValidNativeType(input, ['string', 'array'])) {
             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): number);
+            const endIndex = (this.endIndex.evaluate(ctx) as number);
             return input.slice(beginIndex, endIndex);
         }
 

package/expression/definitions/{step.js → step.ts}

@@ -1,14 +1,12 @@
-// @flow
+import {NumberType} from '../types';
 
-import {NumberType} from '../types.js';
+import {findStopLessThanOrEqualTo} from '../stops';
 
-import {findStopLessThanOrEqualTo} from '../stops.js';
-
-import type {Stops} from '../stops.js';
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type} from '../types.js';
+import type {Stops} from '../stops';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 class Step implements Expression {
     type: Type;
@@ -29,12 +27,14 @@ class Step implements Expression {
         }
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Step {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Step | null | undefined {
         if (args.length - 1 < 4) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
             return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         }
 
         if ((args.length - 1) % 2 !== 0) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
             return context.error(`Expected an even number of arguments.`);
         }
 
@@ -43,7 +43,7 @@ class Step implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = (null: any);
+        let outputType: Type = (null as any);
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
@@ -56,10 +56,12 @@ class Step implements Expression {
             const valueKey = i + 1;
 
             if (typeof label !== 'number') {
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
                 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) {
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
                 return context.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 
@@ -80,7 +82,7 @@ class Step implements Expression {
             return outputs[0].evaluate(ctx);
         }
 
-        const value = ((this.input.evaluate(ctx): any): number);
+        const value = (this.input.evaluate(ctx) as number);
         if (value <= labels[0]) {
             return outputs[0].evaluate(ctx);
         }

package/expression/definitions/{var.js → var.ts}

@@ -1,9 +1,7 @@
-// @flow
-
-import type {Type} from '../types.js';
-import type {Expression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext  from '../evaluation_context.js';
+import type {Type} from '../types';
+import type {Expression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext  from '../evaluation_context';
 
 class Var implements Expression {
     type: Type;
@@ -16,7 +14,7 @@ class Var implements Expression {
         this.boundExpression = boundExpression;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): void | Var {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): void | Var {
         if (args.length !== 2 || typeof args[1] !== 'string')
             return context.error(`'var' expression requires exactly one string literal argument.`);