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

package/expression/{index.js → index.ts}

@@ -1,61 +1,65 @@
-// @flow
-
 import assert from 'assert';
 
-import extend from '../util/extend.js';
-import ParsingError from './parsing_error.js';
-import ParsingContext from './parsing_context.js';
-import EvaluationContext from './evaluation_context.js';
-import CompoundExpression from './compound_expression.js';
-import Step from './definitions/step.js';
-import Interpolate from './definitions/interpolate.js';
-import Coalesce from './definitions/coalesce.js';
-import Let from './definitions/let.js';
-import definitions from './definitions/index.js';
-import * as isConstant from './is_constant.js';
-import RuntimeError from './runtime_error.js';
-import {success, error} from '../util/result.js';
+import extend from '../util/extend';
+import ParsingError from './parsing_error';
+import ParsingContext from './parsing_context';
+import EvaluationContext from './evaluation_context';
+import CompoundExpression from './compound_expression';
+import Step from './definitions/step';
+import Interpolate from './definitions/interpolate';
+import Coalesce from './definitions/coalesce';
+import Let from './definitions/let';
+import definitions from './definitions/index';
+import * as isConstant from './is_constant';
+import RuntimeError from './runtime_error';
+import {success, error} from '../util/result';
 import {
     supportsPropertyExpression,
     supportsZoomExpression,
     supportsLightExpression,
     supportsInterpolation
-} from '../util/properties.js';
-
-import type {Type, EvaluationKind} from './types.js';
-import type {Value} from './values.js';
-import type {Expression} from './expression.js';
-import type {StylePropertySpecification} from '../style-spec.js';
-import type {Result} from '../util/result.js';
-import type {InterpolationType} from './definitions/interpolate.js';
-import type {PropertyValueSpecification} from '../types.js';
-import type {FormattedSection} from './types/formatted.js';
+} from '../util/properties';
+
+import type {Type, EvaluationKind} from './types';
+import type {Value} from './values';
+import type {Expression} from './expression';
+import type {StylePropertySpecification} from '../style-spec';
+import type {Result} from '../util/result';
+import type {InterpolationType} from './definitions/interpolate';
+import type {PropertyValueSpecification} from '../types';
+import type {FormattedSection} from './types/formatted';
 import type Point from '@mapbox/point-geometry';
-import type {CanonicalTileID} from '../../source/tile_id.js';
-import type {FeatureDistanceData} from '../feature_filter/index.js';
-import type {ConfigOptions} from '../../style/properties.js';
+import type {CanonicalTileID} from '../types/tile_id';
+import type {FeatureDistanceData} from '../feature_filter/index';
+import type {ConfigOptions} from '../types/config_options';
 
 export interface Feature {
-    +type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
-    +id?: number | null;
-    +properties: {[_: string]: any};
-    +patterns?: {[_: string]: string};
-    +geometry?: Array<Array<Point>>;
+    readonly type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
+    readonly id?: number | null;
+    readonly properties: {
+        [_: string]: any;
+    };
+    readonly patterns?: {
+        [_: string]: string;
+    };
+    readonly geometry?: Array<Array<Point>>;
 }
 
-export type FeatureState = {[_: string]: any};
+export type FeatureState = {
+    [_: string]: any;
+};
 
 export interface GlobalProperties {
-    zoom: number,
-    pitch?: number,
-    heatmapDensity?: number,
-    lineProgress?: number,
-    rasterValue?: number,
-    rasterParticleSpeed?: number,
-    skyRadialProgress?: number,
-    +isSupportedScript?: (_: string) => boolean,
-    accumulated?: Value,
-    brightness?: number
+    zoom: number;
+    pitch?: number;
+    heatmapDensity?: number;
+    lineProgress?: number;
+    rasterValue?: number;
+    rasterParticleSpeed?: number;
+    skyRadialProgress?: number;
+    readonly isSupportedScript?: (_: string) => boolean;
+    accumulated?: Value;
+    brightness?: number;
 }
 
 export class StyleExpression {
@@ -64,9 +68,9 @@ export class StyleExpression {
     _evaluator: EvaluationContext;
     _defaultValue: Value;
     _warningHistory: {[key: string]: boolean};
-    _enumValues: ?{[_: string]: any};
+    _enumValues?: {[_: string]: unknown};
 
-    constructor(expression: Expression, propertySpec: ?StylePropertySpecification, scope?: ?string, options?: ?ConfigOptions) {
+    constructor(expression: Expression, propertySpec?: StylePropertySpecification, scope?: string, options?: ConfigOptions) {
         this.expression = expression;
         this._warningHistory = {};
         this._evaluator = new EvaluationContext(scope, options);
@@ -74,7 +78,16 @@ export class StyleExpression {
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
     }
 
-    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any {
+    evaluateWithoutErrorHandling(
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+        featureTileCoord?: Point,
+        featureDistanceData?: FeatureDistanceData,
+    ): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature;
         this._evaluator.featureState = featureState;
@@ -87,7 +100,16 @@ export class StyleExpression {
         return this.expression.evaluate(this._evaluator);
     }
 
-    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any {
+    evaluate(
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+        featureTileCoord?: Point,
+        featureDistanceData?: FeatureDistanceData,
+    ): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature || null;
         this._evaluator.featureState = featureState || null;
@@ -107,7 +129,7 @@ export class StyleExpression {
                 throw new RuntimeError(`Expected value to be one of ${Object.keys(this._enumValues).map(v => JSON.stringify(v)).join(', ')}, but found ${JSON.stringify(val)} instead.`);
             }
             return val;
-        } catch (e) {
+        } catch (e: any) {
             if (!this._warningHistory[e.message]) {
                 this._warningHistory[e.message] = true;
                 if (typeof console !== 'undefined') {
@@ -119,7 +141,7 @@ export class StyleExpression {
     }
 }
 
-export function isExpression(expression: mixed): boolean {
+export function isExpression(expression: unknown): boolean {
     return Array.isArray(expression) && expression.length > 0 &&
         typeof expression[0] === 'string' && expression[0] in definitions;
 }
@@ -133,7 +155,12 @@ export function isExpression(expression: mixed): boolean {
  *
  * @private
  */
-export function createExpression(expression: mixed, propertySpec: ?StylePropertySpecification, scope?: ?string, options?: ?ConfigOptions): Result<StyleExpression, Array<ParsingError>> {
+export function createExpression(
+    expression: unknown,
+    propertySpec?: StylePropertySpecification | null,
+    scope?: string | null,
+    options?: ConfigOptions | null,
+): Result<StyleExpression, Array<ParsingError>> {
     const parser = new ParsingContext(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined, undefined, undefined, scope, options);
 
     // For string-valued properties, coerce to string at the top level rather than asserting.
@@ -148,55 +175,83 @@ export function createExpression(expression: mixed, propertySpec: ?StyleProperty
     return success(new StyleExpression(parsed, propertySpec, scope, options));
 }
 
-export class ZoomConstantExpression<Kind: EvaluationKind> {
+export class ZoomConstantExpression<Kind extends EvaluationKind> {
     kind: Kind;
     isStateDependent: boolean;
     isConfigDependent: boolean;
     _styleExpression: StyleExpression;
-    isLightConstant: ?boolean;
+    isLightConstant: boolean | null | undefined;
 
-    constructor(kind: Kind, expression: StyleExpression, isLightConstant: ?boolean) {
+    constructor(kind: Kind, expression: StyleExpression, isLightConstant?: boolean | null) {
         this.kind = kind;
         this._styleExpression = expression;
         this.isLightConstant = isLightConstant;
-        this.isStateDependent = kind !== ('constant': EvaluationKind) && !isConstant.isStateConstant(expression.expression);
+        this.isStateDependent = kind !== ('constant' as EvaluationKind) && !isConstant.isStateConstant(expression.expression);
         this.isConfigDependent = !isConstant.isConfigConstant(expression.expression);
     }
 
-    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+    evaluateWithoutErrorHandling(
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+    ): any {
         return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
-    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+    evaluate(
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+    ): any {
         return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 }
 
-export class ZoomDependentExpression<Kind: EvaluationKind> {
+export class ZoomDependentExpression<Kind extends EvaluationKind> {
     kind: Kind;
     zoomStops: Array<number>;
     isStateDependent: boolean;
-    isLightConstant: ?boolean;
+    isLightConstant: boolean | null | undefined;
     isConfigDependent: boolean;
 
     _styleExpression: StyleExpression;
-    interpolationType: ?InterpolationType;
+    interpolationType: InterpolationType | null | undefined;
 
-    constructor(kind: Kind, expression: StyleExpression, zoomStops: Array<number>, interpolationType?: InterpolationType, isLightConstant: ?boolean) {
+    constructor(kind: Kind, expression: StyleExpression, zoomStops: Array<number>, interpolationType?: InterpolationType, isLightConstant?: boolean | null) {
         this.kind = kind;
         this.zoomStops = zoomStops;
         this._styleExpression = expression;
-        this.isStateDependent = kind !== ('camera': EvaluationKind) && !isConstant.isStateConstant(expression.expression);
+        this.isStateDependent = kind !== ('camera' as EvaluationKind) && !isConstant.isStateConstant(expression.expression);
         this.isLightConstant = isLightConstant;
         this.isConfigDependent = !isConstant.isConfigConstant(expression.expression);
         this.interpolationType = interpolationType;
     }
 
-    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+    evaluateWithoutErrorHandling(
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+    ): any {
         return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
-    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+    evaluate(
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+    ): any {
         return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
@@ -209,53 +264,83 @@ export class ZoomDependentExpression<Kind: EvaluationKind> {
     }
 }
 
-export type ConstantExpression = interface {
-    kind: 'constant',
-    isConfigDependent: boolean,
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
-}
+export type ConstantExpression = {
+    kind: 'constant';
+    isConfigDependent: boolean;
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+    ) => any;
+};
 
-export type SourceExpression = interface {
-    kind: 'source',
-    isStateDependent: boolean,
-    isLightConstant: ?boolean;
-    isConfigDependent: boolean,
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
+export type SourceExpression = {
+    kind: 'source';
+    isStateDependent: boolean;
+    isLightConstant: boolean | null | undefined;
+    isConfigDependent: boolean;
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+    ) => any;
 };
 
-export type CameraExpression = interface {
-    kind: 'camera',
-    isStateDependent: boolean,
-    isConfigDependent: boolean,
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
-    +interpolationFactor: (input: number, lower: number, upper: number) => number,
-    zoomStops: Array<number>,
-    interpolationType: ?InterpolationType
+export type CameraExpression = {
+    kind: 'camera';
+    isStateDependent: boolean;
+    isConfigDependent: boolean;
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+    ) => any;
+    readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
+    zoomStops: Array<number>;
+    interpolationType: InterpolationType | null | undefined;
 };
 
 export interface CompositeExpression {
     kind: 'composite';
     isStateDependent: boolean;
-    isLightConstant: ?boolean;
+    isLightConstant: boolean | null | undefined;
     isConfigDependent: boolean;
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any;
-    +interpolationFactor: (input: number, lower: number, upper: number) => number;
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection,
+    ) => any;
+    readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
     zoomStops: Array<number>;
-    interpolationType: ?InterpolationType;
+    interpolationType: InterpolationType | null | undefined;
 }
 
-export type StylePropertyExpression =
-    | ConstantExpression
-    | SourceExpression
-    | CameraExpression
-    | CompositeExpression;
+export type StylePropertyExpression = ConstantExpression | SourceExpression | CameraExpression | CompositeExpression;
 
-export function createPropertyExpression(expression: mixed, propertySpec: StylePropertySpecification, scope?: ?string, options?: ?ConfigOptions): Result<StylePropertyExpression, Array<ParsingError>> {
+export function createPropertyExpression(
+    expression: unknown,
+    propertySpec: StylePropertySpecification,
+    scope?: string | null,
+    options?: ConfigOptions | null,
+): Result<StylePropertyExpression, Array<ParsingError>> {
     expression = createExpression(expression, propertySpec, scope, options);
+    // @ts-expect-error - TS2339 - Property 'result' does not exist on type 'unknown'.
     if (expression.result === 'error') {
+        // @ts-expect-error - TS2322 - Type 'unknown' is not assignable to type 'Result<StylePropertyExpression, ParsingError[]>'.
         return expression;
     }
 
+    // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
     const parsed = expression.value.expression;
 
     const isFeatureConstant = isConstant.isFeatureConstant(parsed);
@@ -285,23 +370,23 @@ export function createPropertyExpression(expression: mixed, propertySpec: StyleP
 
     if (!zoomCurve) {
         return success(isFeatureConstant ?
-            // $FlowFixMe[method-unbinding]
-            (new ZoomConstantExpression('constant', expression.value, isLightConstant): ConstantExpression) :
-            // $FlowFixMe[method-unbinding]
-            (new ZoomConstantExpression('source', expression.value, isLightConstant): SourceExpression));
+        // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+            (new ZoomConstantExpression('constant', expression.value, isLightConstant) as ConstantExpression) :
+        // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+            (new ZoomConstantExpression('source', expression.value, isLightConstant) as SourceExpression));
     }
 
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
 
     return success(isFeatureConstant ?
-        // $FlowFixMe[method-unbinding]
-        (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant): CameraExpression) :
-        // $FlowFixMe[method-unbinding]
-        (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant): CompositeExpression));
+    // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+        (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant) as CameraExpression) :
+    // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
+        (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant) as CompositeExpression));
 }
 
-import {isFunction, createFunction} from '../function/index.js';
-import {Color} from './values.js';
+import {isFunction, createFunction} from '../function/index';
+import {Color} from './values';
 
 // serialization wrapper for old-style stop functions normalized to the
 // expression interface
@@ -311,8 +396,8 @@ export class StylePropertyFunction<T> {
 
     kind: EvaluationKind;
     evaluate: (globals: GlobalProperties, feature?: Feature) => any;
-    interpolationFactor: ?(input: number, lower: number, upper: number) => number;
-    zoomStops: ?Array<number>;
+    interpolationFactor: (input: number, lower: number, upper: number) => number | null | undefined;
+    zoomStops: Array<number> | null | undefined;
 
     constructor(parameters: PropertyValueSpecification<T>, specification: StylePropertySpecification) {
         this._parameters = parameters;
@@ -320,11 +405,19 @@ export class StylePropertyFunction<T> {
         extend(this, createFunction(this._parameters, this._specification));
     }
 
-    static deserialize(serialized: {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification}): StylePropertyFunction<T> {
+    static deserialize<T>(
+        serialized: {
+            _parameters: PropertyValueSpecification<T>;
+            _specification: StylePropertySpecification;
+        },
+    ): StylePropertyFunction<T> {
         return new StylePropertyFunction(serialized._parameters, serialized._specification);
     }
 
-    static serialize(input: StylePropertyFunction<T>): {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification} {
+    static serialize<T>(input: StylePropertyFunction<T>): {
+        _parameters: PropertyValueSpecification<T>;
+        _specification: StylePropertySpecification;
+    } {
         return {
             _parameters: input._parameters,
             _specification: input._specification
@@ -332,9 +425,14 @@ export class StylePropertyFunction<T> {
     }
 }
 
-export function normalizePropertyExpression<T>(value: PropertyValueSpecification<T>, specification: StylePropertySpecification, scope?: ?string, options?: ?ConfigOptions): StylePropertyExpression {
+export function normalizePropertyExpression<T>(
+    value: PropertyValueSpecification<T>,
+    specification: StylePropertySpecification,
+    scope?: string | null,
+    options?: ConfigOptions | null,
+): StylePropertyExpression {
     if (isFunction(value)) {
-        return (new StylePropertyFunction(value, specification): any);
+        return new StylePropertyFunction(value, specification) as any;
 
     } else if (isExpression(value) || (Array.isArray(value) && value.length > 0)) {
         const expression = createPropertyExpression(value, specification, scope, options);
@@ -396,7 +494,7 @@ function findZoomCurve(expression: Expression): Step | Interpolate | ParsingErro
     return result;
 }
 
-import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, array} from './types.js';
+import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, array} from './types';
 
 function getExpectedType(spec: StylePropertySpecification): Type {
     const types = {

package/expression/{is_constant.js → is_constant.ts}

@@ -1,10 +1,8 @@
-// @flow
-
-import CompoundExpression from './compound_expression.js';
-import Within from './definitions/within.js';
-import Distance from './definitions/distance.js';
-import Config from './definitions/config.js';
-import type {Expression} from './expression.js';
+import CompoundExpression from './compound_expression';
+import Within from './definitions/within';
+import Distance from './definitions/distance';
+import Config from './definitions/config';
+import type {Expression} from './expression';
 
 function isFeatureConstant(e: Expression): boolean {
     if (e instanceof CompoundExpression) {

package/expression/{parsing_context.js → parsing_context.ts}

@@ -1,23 +1,21 @@
-// @flow
-
-import Scope from './scope.js';
-import {checkSubtype} from './types.js';
-import ParsingError from './parsing_error.js';
-import Literal from './definitions/literal.js';
-import Assertion from './definitions/assertion.js';
-import Coercion from './definitions/coercion.js';
-import EvaluationContext from './evaluation_context.js';
-import CompoundExpression from './compound_expression.js';
-import CollatorExpression from './definitions/collator.js';
-import Within from './definitions/within.js';
-import Distance from './definitions/distance.js';
-import Config from './definitions/config.js';
-import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant.js';
-import Var from './definitions/var.js';
-
-import type {Expression, ExpressionRegistry} from './expression.js';
-import type {Type} from './types.js';
-import type {ConfigOptions} from '../../style/properties.js';
+import Scope from './scope';
+import {checkSubtype} from './types';
+import ParsingError from './parsing_error';
+import Literal from './definitions/literal';
+import Assertion from './definitions/assertion';
+import Coercion from './definitions/coercion';
+import EvaluationContext from './evaluation_context';
+import CompoundExpression from './compound_expression';
+import CollatorExpression from './definitions/collator';
+import Within from './definitions/within';
+import Distance from './definitions/distance';
+import Config from './definitions/config';
+import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant';
+import Var from './definitions/var';
+
+import type {Expression, ExpressionRegistry} from './expression';
+import type {Type} from './types';
+import type {ConfigOptions} from '../types/config_options';
 
 /**
  * State associated parsing at a given point in an expression tree.
@@ -29,23 +27,23 @@ class ParsingContext {
     key: string;
     scope: Scope;
     errors: Array<ParsingError>;
-    _scope: ?string;
-    options: ?ConfigOptions;
+    _scope: string | null | undefined;
+    options: ConfigOptions | null | undefined;
 
     // The expected type of this expression. Provided only to allow Expression
     // implementations to infer argument types: Expression#parse() need not
     // check that the output type of the parsed expression matches
     // `expectedType`.
-    expectedType: ?Type;
+    expectedType: Type | null | undefined;
 
     constructor(
         registry: ExpressionRegistry,
         path: Array<number> = [],
-        expectedType: ?Type,
+        expectedType?: Type | null,
         scope: Scope = new Scope(),
         errors: Array<ParsingError> = [],
-        _scope: ?string,
-        options?: ?ConfigOptions
+        _scope?: string | null,
+        options?: ConfigOptions | null
     ) {
         this.registry = registry;
         this.path = path;
@@ -65,19 +63,26 @@ class ParsingContext {
      * @private
      */
     parse(
-        expr: mixed,
+        expr: unknown,
         index?: number,
-        expectedType?: ?Type,
+        expectedType?: Type | null,
         bindings?: Array<[string, Expression]>,
-        options: {typeAnnotation?: 'assert' | 'coerce' | 'omit'} = {}
-    ): ?Expression {
+        options: {
+            typeAnnotation?: 'assert' | 'coerce' | 'omit';
+        } = {},
+    ): Expression | null | undefined {
         if (index || expectedType) {
             return this.concat(index, expectedType, bindings)._parse(expr, options);
         }
         return this._parse(expr, options);
     }
 
-    _parse(expr: mixed, options: {typeAnnotation?: 'assert' | 'coerce' | 'omit'}): ?Expression {
+    _parse(
+        expr: unknown,
+        options: {
+            typeAnnotation?: 'assert' | 'coerce' | 'omit';
+        },
+    ): Expression | null | undefined {
         if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
             expr = ['literal', expr];
         }
@@ -94,6 +99,7 @@ class ParsingContext {
 
         if (Array.isArray(expr)) {
             if (expr.length === 0) {
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                 return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
             }
 
@@ -131,7 +137,7 @@ class ParsingContext {
                     const ec = new EvaluationContext(this._scope, this.options);
                     try {
                         parsed = new Literal(parsed.type, parsed.evaluate(ec));
-                    } catch (e) {
+                    } catch (e: any) {
                         this.error(e.message);
                         return null;
                     }
@@ -143,10 +149,13 @@ class ParsingContext {
             // Try to parse as array
             return Coercion.parse(['to-array', expr], this);
         } else if (typeof expr === 'undefined') {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return this.error(`'undefined' value invalid. Use null instead.`);
         } else if (typeof expr === 'object') {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return this.error(`Bare objects invalid. Use ["literal", {...}] instead.`);
         } else {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return this.error(`Expected an array, but found ${typeof expr} instead.`);
         }
     }
@@ -159,7 +168,11 @@ class ParsingContext {
      * parsing, is copied by reference rather than cloned.
      * @private
      */
-    concat(index: ?number, expectedType?: ?Type, bindings?: Array<[string, Expression]>): ParsingContext {
+    concat(
+        index?: number | null,
+        expectedType?: Type | null,
+        bindings?: Array<[string, Expression]>,
+    ): ParsingContext {
         const path = typeof index === 'number' ? this.path.concat(index) : this.path;
         const scope = bindings ? this.scope.concat(bindings) : this.scope;
         return new ParsingContext(
@@ -189,7 +202,7 @@ 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 {
+    checkSubtype(expected: Type, t: Type): string | null | undefined {
         const error = checkSubtype(expected, t);
         if (error) this.error(error);
         return error;