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

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

@@ -1,16 +1,14 @@
-// @flow
+import {toString, ValueType, BooleanType, CollatorType} from '../types';
+import Assertion from './assertion';
+import {typeOf} from '../values';
+import RuntimeError from '../runtime_error';
 
-import {toString, ValueType, BooleanType, CollatorType} from '../types.js';
-import Assertion from './assertion.js';
-import {typeOf} from '../values.js';
-import RuntimeError from '../runtime_error.js';
+import type {Expression, SerializedExpression, ExpressionRegistration} from '../expression';
+import type EvaluationContext from '../evaluation_context';
+import type ParsingContext from '../parsing_context';
+import type {Type} from '../types';
 
-import type {Expression, SerializedExpression, ExpressionRegistration} from '../expression.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type ParsingContext from '../parsing_context.js';
-import type {Type} from '../types.js';
-
-type ComparisonOperator = '==' | '!=' | '<' | '>' | '<=' | '>=' ;
+type ComparisonOperator = '==' | '!=' | '<' | '>' | '<=' | '>=';
 
 function isComparableType(op: ComparisonOperator, type: Type) {
     if (op === '==' || op === '!=') {
@@ -59,18 +57,21 @@ function gteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean {
  *
  * @private
  */
-function makeComparison(op: ComparisonOperator, compareBasic: (EvaluationContext, any, any) => boolean, compareWithCollator: (EvaluationContext, any, any, any) => boolean): ExpressionRegistration {
+function makeComparison(
+    op: ComparisonOperator,
+    compareBasic: (arg1: EvaluationContext, arg2?: any, arg3?: any) => boolean,
+    compareWithCollator: (arg1: EvaluationContext, arg2?: any, arg3?: any, arg4?: any) => boolean,
+): ExpressionRegistration {
     const isOrderComparison = op !== '==' && op !== '!=';
 
-    // $FlowFixMe[method-unbinding]
     return class Comparison implements Expression {
         type: Type;
         lhs: Expression;
         rhs: Expression;
-        collator: ?Expression;
+        collator: Expression | null | undefined;
         hasUntypedArgument: boolean;
 
-        constructor(lhs: Expression, rhs: Expression, collator: ?Expression) {
+        constructor(lhs: Expression, rhs: Expression, collator?: Expression | null) {
             this.type = BooleanType;
             this.lhs = lhs;
             this.rhs = rhs;
@@ -78,21 +79,23 @@ function makeComparison(op: ComparisonOperator, compareBasic: (EvaluationContext
             this.hasUntypedArgument = lhs.type.kind === 'value' || rhs.type.kind === 'value';
         }
 
-        // $FlowFixMe[method-unbinding]
-        static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
             if (args.length !== 3 && args.length !== 4)
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                 return context.error(`Expected two or three arguments.`);
 
-            const op: ComparisonOperator = (args[0]: any);
+            const op: ComparisonOperator = (args[0] as any);
 
             let lhs = context.parse(args[1], 1, ValueType);
             if (!lhs) return null;
             if (!isComparableType(op, lhs.type)) {
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                 return context.concat(1).error(`"${op}" comparisons are not supported for type '${toString(lhs.type)}'.`);
             }
             let rhs = context.parse(args[2], 2, ValueType);
             if (!rhs) return null;
             if (!isComparableType(op, rhs.type)) {
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                 return context.concat(2).error(`"${op}" comparisons are not supported for type '${toString(rhs.type)}'.`);
             }
 
@@ -101,6 +104,7 @@ function makeComparison(op: ComparisonOperator, compareBasic: (EvaluationContext
                 lhs.type.kind !== 'value' &&
                 rhs.type.kind !== 'value'
             ) {
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                 return context.error(`Cannot compare types '${toString(lhs.type)}' and '${toString(rhs.type)}'.`);
             }
 
@@ -123,6 +127,7 @@ function makeComparison(op: ComparisonOperator, compareBasic: (EvaluationContext
                     lhs.type.kind !== 'value' &&
                     rhs.type.kind !== 'value'
                 ) {
+                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                     return context.error(`Cannot use collator to compare non-string types.`);
                 }
                 collator = context.parse(args[3], 3, CollatorType);
@@ -172,15 +177,16 @@ function makeComparison(op: ComparisonOperator, compareBasic: (EvaluationContext
 
         serialize(): SerializedExpression {
             const serialized = [op];
+            // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'ComparisonOperator'.
             this.eachChild(child => { serialized.push(child.serialize()); });
             return serialized;
         }
     };
 }
 
-export const Equals: $Call<typeof makeComparison, '==', typeof eq, typeof eqCollate> = makeComparison('==', eq, eqCollate);
-export const NotEquals: $Call<typeof makeComparison, '!=', typeof neq, typeof neqCollate> = makeComparison('!=', neq, neqCollate);
-export const LessThan: $Call<typeof makeComparison, '<', typeof lt, typeof ltCollate> = makeComparison('<', lt, ltCollate);
-export const GreaterThan: $Call<typeof makeComparison, '>', typeof gt, typeof gtCollate> = makeComparison('>', gt, gtCollate);
-export const LessThanOrEqual: $Call<typeof makeComparison, '<=', typeof lteq, typeof lteqCollate> = makeComparison('<=', lteq, lteqCollate);
-export const GreaterThanOrEqual: $Call<typeof makeComparison, '>=', typeof gteq, typeof gteqCollate> = makeComparison('>=', gteq, gteqCollate);
+export const Equals: ReturnType<typeof makeComparison> = makeComparison('==', eq, eqCollate);
+export const NotEquals: ReturnType<typeof makeComparison> = makeComparison('!=', neq, neqCollate);
+export const LessThan: ReturnType<typeof makeComparison> = makeComparison('<', lt, ltCollate);
+export const GreaterThan: ReturnType<typeof makeComparison> = makeComparison('>', gt, gtCollate);
+export const LessThanOrEqual: ReturnType<typeof makeComparison> = makeComparison('<=', lteq, lteqCollate);
+export const GreaterThanOrEqual: ReturnType<typeof makeComparison> = makeComparison('>=', gteq, gteqCollate);

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

@@ -1,17 +1,13 @@
-// @flow
+import {ValueType} from '../types';
+import {Color, typeOf, toString as valueToString} from '../values';
+import Formatted from '../types/formatted';
+import ResolvedImage from '../types/resolved_image';
+import Literal from './literal';
 
-import {
-    type Type,
-    ValueType
-} from '../types.js';
-import {Color, typeOf, toString as valueToString} from '../values.js';
-import Formatted from '../types/formatted.js';
-import ResolvedImage from '../types/resolved_image.js';
-import Literal from './literal.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';
 
 function coerceValue(type: string, value: any): any {
     switch (type) {
@@ -29,7 +25,7 @@ function coerceValue(type: string, value: any): any {
     return value;
 }
 
-function clampToAllowedNumber(value: number, min: number | void, max: number | void, step: number | void): number {
+function clampToAllowedNumber(value: number, min?: number, max?: number, step?: number): number {
     if (step !== undefined) {
         value = step * Math.round(value / step);
     }
@@ -45,7 +41,7 @@ function clampToAllowedNumber(value: number, min: number | void, max: number | v
 class Config implements Expression {
     type: Type;
     key: string;
-    scope: ?string;
+    scope: string | null | undefined;
 
     constructor(type: Type, key: string, scope?: string) {
         this.type = type;
@@ -53,23 +49,26 @@ class Config implements Expression {
         this.scope = scope;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Config {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Config | null | undefined {
         let type = context.expectedType;
         if (type === null || type === undefined) {
             type = ValueType;
         }
         if (args.length < 2 || args.length > 3) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Config'.
             return context.error(`Invalid number of arguments for 'config' expression.`);
         }
 
         const configKey = context.parse(args[1], 1);
         if (!(configKey instanceof Literal)) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Config'.
             return context.error(`Key name of 'config' expression must be a string literal.`);
         }
 
         if (args.length >= 3) {
             const configScope = context.parse(args[2], 2);
             if (!(configScope instanceof Literal)) {
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Config'.
                 return context.error(`Scope of 'config' expression must be a string literal.`);
             }
             return new Config(type, valueToString(configKey.value), valueToString(configScope.value));
@@ -117,6 +116,7 @@ class Config implements Expression {
             }
         }
 
+        // @ts-expect-error - TS2367 - This comparison appears to be unintentional because the types 'string' and 'Type' have no overlap.
         if ((type && type !== this.type) || (result !== undefined && typeOf(result) !== this.type)) {
             result = coerceValue(this.type.kind, result);
         }

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

@@ -1,40 +1,27 @@
-// @flow
-
-import {isValue} from "../values.js";
-import type {Type} from "../types.js";
-import {NumberType} 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 {
-    GeoJSON,
-    GeoJSONPosition,
-    GeoJSONPoint,
-    GeoJSONMultiPoint,
-    GeoJSONLineString,
-    GeoJSONMultiLineString,
-    GeoJSONPolygon,
-    GeoJSONMultiPolygon
-} from "@mapbox/geojson-types";
-import type {CanonicalTileID} from '../../../source/tile_id.js';
-import {classifyRings, updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util.js';
-import type {BBox} from '../../util/geometry_util.js';
+import {isValue} from '../values';
+import {NumberType} from '../types';
+import {classifyRings, updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
 import CheapRuler from "cheap-ruler";
 import Point from "@mapbox/point-geometry";
 import TinyQueue from "tinyqueue";
-import EXTENT from "../../data/extent.js";
+import EXTENT from '../../data/extent';
 
-type DistanceGeometry =
-    | GeoJSONPoint
-    | GeoJSONMultiPoint
-    | GeoJSONLineString
-    | GeoJSONMultiLineString
-    | GeoJSONPolygon
-    | GeoJSONMultiPolygon;
+import type ParsingContext from '../parsing_context';
+import type {BBox} from '../../util/geometry_util';
+import type {Type} from '../types';
+import type {Expression} from '../expression';
+import type {CanonicalTileID} from '../../types/tile_id';
+import type EvaluationContext from '../evaluation_context';
+
+type DistanceGeometry = GeoJSON.Point | GeoJSON.MultiPoint | GeoJSON.LineString | GeoJSON.MultiLineString | GeoJSON.Polygon | GeoJSON.MultiPolygon;
 
 // Inclusive index range for multipoint or linestring container
 type IndexRange = [number, number];
-type DistPair = { dist: number, range1: IndexRange, range2: IndexRange };
+type DistPair = {
+    dist: number;
+    range1: IndexRange;
+    range2: IndexRange;
+};
 function compareMax(a: DistPair, b: DistPair) {
     return b.dist - a.dist;
 }
@@ -92,19 +79,21 @@ function splitRange(range: IndexRange, isLine: boolean) {
     }
 }
 
-function getBBox(pointSets: Array<GeoJSONPosition>, range: IndexRange) {
+function getBBox(pointSets: Array<GeoJSON.Position>, range: IndexRange) {
     const bbox = [Infinity, Infinity, -Infinity, -Infinity];
     if (!isRangeSafe(range, pointSets.length)) return bbox;
     for (let i = range[0]; i <= range[1]; ++i) {
+        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         updateBBox(bbox, pointSets[i]);
     }
     return bbox;
 }
 
-function getPolygonBBox(polygon: Array<Array<GeoJSONPosition>>) {
+function getPolygonBBox(polygon: Array<Array<GeoJSON.Position>>) {
     const bbox = [Infinity, Infinity, -Infinity, -Infinity];
     for (let i = 0; i < polygon.length; ++i) {
         for (let j = 0; j < polygon[i].length; ++j) {
+            // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
             updateBBox(bbox, polygon[i][j]);
         }
     }
@@ -163,12 +152,14 @@ function getLngLatPoints(coordinates: Array<Point>, canonical: CanonicalTileID)
     return coords;
 }
 
-function pointToLineDistance(point: GeoJSONPosition, line: Array<GeoJSONPosition>, ruler: CheapRuler) {
+function pointToLineDistance(point: GeoJSON.Position, line: Array<GeoJSON.Position>, ruler: CheapRuler) {
+// @ts-expect-error - TS2345 - Argument of type 'Position[]' is not assignable to parameter of type 'Line'.
     const nearestPoint = ruler.pointOnLine(line, point).point;
+    // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
     return ruler.distance(point, nearestPoint);
 }
 
-function pointsToLineDistance(points: Array<GeoJSONPosition>, rangeA: IndexRange, line: Array<GeoJSONPosition>, rangeB: IndexRange, ruler: CheapRuler) {
+function pointsToLineDistance(points: Array<GeoJSON.Position>, rangeA: IndexRange, line: Array<GeoJSON.Position>, rangeB: IndexRange, ruler: CheapRuler) {
     const subLine = line.slice(rangeB[0], rangeB[1] + 1);
     let dist = Infinity;
     for (let i = rangeA[0]; i <= rangeA[1]; ++i) {
@@ -178,20 +169,24 @@ function pointsToLineDistance(points: Array<GeoJSONPosition>, rangeA: IndexRange
 }
 
 // precondition is two segments are not intersecting with each other
-function segmentToSegmentDistance(p1: GeoJSONPosition, p2: GeoJSONPosition, q1: GeoJSONPosition, q2: GeoJSONPosition, ruler: CheapRuler) {
+function segmentToSegmentDistance(p1: GeoJSON.Position, p2: GeoJSON.Position, q1: GeoJSON.Position, q2: GeoJSON.Position, ruler: CheapRuler) {
     const dist1 = Math.min(
+        // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
         ruler.pointToSegmentDistance(p1, q1, q2),
+        // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
         ruler.pointToSegmentDistance(p2, q1, q2)
     );
     const dist2 = Math.min(
+        // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
         ruler.pointToSegmentDistance(q1, p1, p2),
+        // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
         ruler.pointToSegmentDistance(q2, p1, p2)
     );
 
     return Math.min(dist1, dist2);
 }
 
-function lineToLineDistance(line1: Array<GeoJSONPosition>, range1: IndexRange, line2: Array<GeoJSONPosition>, range2: IndexRange, ruler: CheapRuler) {
+function lineToLineDistance(line1: Array<GeoJSON.Position>, range1: IndexRange, line2: Array<GeoJSON.Position>, range2: IndexRange, ruler: CheapRuler) {
     if (!isRangeSafe(range1, line1.length) || !isRangeSafe(range2, line2.length)) {
         return NaN;
     }
@@ -205,20 +200,21 @@ function lineToLineDistance(line1: Array<GeoJSONPosition>, range1: IndexRange, l
     return dist;
 }
 
-function pointsToPointsDistance(pointSet1: Array<GeoJSONPosition>, range1: IndexRange, pointSet2: Array<GeoJSONPosition>, range2: IndexRange, ruler: CheapRuler) {
+function pointsToPointsDistance(pointSet1: Array<GeoJSON.Position>, range1: IndexRange, pointSet2: Array<GeoJSON.Position>, range2: IndexRange, ruler: CheapRuler) {
     if (!isRangeSafe(range1, pointSet1.length) || !isRangeSafe(range2, pointSet2.length)) {
         return NaN;
     }
     let dist = Infinity;
     for (let i = range1[0]; i <= range1[1]; ++i) {
         for (let j = range2[0]; j <= range2[1]; ++j) {
+            // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
             if ((dist = Math.min(dist, ruler.distance(pointSet1[i], pointSet2[j]))) === 0.0) return dist;
         }
     }
     return dist;
 }
 
-function pointToPolygonDistance(point: GeoJSONPosition, polygon: Array<Array<GeoJSONPosition>>, ruler: CheapRuler) {
+function pointToPolygonDistance(point: GeoJSON.Position, polygon: Array<Array<GeoJSON.Position>>, ruler: CheapRuler) {
     if (pointWithinPolygon(point, polygon, true /*trueOnBoundary*/)) return 0.0;
     let dist = Infinity;
     for (const ring of polygon) {
@@ -228,6 +224,7 @@ function pointToPolygonDistance(point: GeoJSONPosition, polygon: Array<Array<Geo
             return NaN;
         }
         if (ring[0] !== ring[ringLen - 1]) {
+            // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
             if ((dist = Math.min(dist, ruler.pointToSegmentDistance(point, ring[ringLen - 1], ring[0]))) === 0.0) return dist;
         }
         if ((dist = Math.min(dist, pointToLineDistance(point, ring, ruler))) === 0.0) return dist;
@@ -235,7 +232,7 @@ function pointToPolygonDistance(point: GeoJSONPosition, polygon: Array<Array<Geo
     return dist;
 }
 
-function lineToPolygonDistance(line: Array<GeoJSONPosition>, range: IndexRange, polygon: Array<Array<GeoJSONPosition>>, ruler: CheapRuler) {
+function lineToPolygonDistance(line: Array<GeoJSON.Position>, range: IndexRange, polygon: Array<Array<GeoJSON.Position>>, ruler: CheapRuler) {
     if (!isRangeSafe(range, line.length)) {
         return NaN;
     }
@@ -254,7 +251,7 @@ function lineToPolygonDistance(line: Array<GeoJSONPosition>, range: IndexRange,
     return dist;
 }
 
-function polygonIntersect(polygon1: Array<Array<GeoJSONPosition>>, polygon2: Array<Array<GeoJSONPosition>>) {
+function polygonIntersect(polygon1: Array<Array<GeoJSON.Position>>, polygon2: Array<Array<GeoJSON.Position>>) {
     for (const ring of polygon1) {
         for (let i = 0; i <= ring.length - 1; ++i) {
             if (pointWithinPolygon(ring[i], polygon2, true /*trueOnBoundary*/)) return true;
@@ -263,12 +260,14 @@ function polygonIntersect(polygon1: Array<Array<GeoJSONPosition>>, polygon2: Arr
     return false;
 }
 
-function polygonToPolygonDistance(polygon1: Array<Array<GeoJSONPosition>>, polygon2: Array<Array<GeoJSONPosition>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
+function polygonToPolygonDistance(polygon1: Array<Array<GeoJSON.Position>>, polygon2: Array<Array<GeoJSON.Position>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
     const bbox1 = getPolygonBBox(polygon1);
     const bbox2 = getPolygonBBox(polygon2);
+    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
     if (currentMiniDist !== Infinity && bboxToBBoxDistance(bbox1, bbox2, ruler) >= currentMiniDist) {
         return currentMiniDist;
     }
+    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
     if (boxWithinBox(bbox1, bbox2)) {
         if (polygonIntersect(polygon1, polygon2)) return 0.0;
     } else if (polygonIntersect(polygon2, polygon1)) {
@@ -288,8 +287,9 @@ function polygonToPolygonDistance(polygon1: Array<Array<GeoJSONPosition>>, polyg
     return dist;
 }
 
-function updateQueue(distQueue: any, miniDist: number, ruler: CheapRuler, pointSet1: Array<GeoJSONPosition>, pointSet2: Array<GeoJSONPosition>, r1: IndexRange | null, r2: IndexRange | null) {
+function updateQueue(distQueue: any, miniDist: number, ruler: CheapRuler, pointSet1: Array<GeoJSON.Position>, pointSet2: Array<GeoJSON.Position>, r1: IndexRange | null, r2: IndexRange | null) {
     if (r1 === null || r2 === null) return;
+    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
     const tempDist = bboxToBBoxDistance(getBBox(pointSet1, r1), getBBox(pointSet2, r2), ruler);
     // Insert new pair to the queue if the bbox distance is less than miniDist, the pair with biggest distance will be at the top
     if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: r1, range2: r2});
@@ -297,7 +297,8 @@ function updateQueue(distQueue: any, miniDist: number, ruler: CheapRuler, pointS
 
 // Divide and conquer, the time complexity is O(n*lgn), faster than Brute force O(n*n)
 // Most of the time, use index for in-place processing.
-function pointSetToPolygonDistance(pointSets: Array<GeoJSONPosition>, isLine: boolean, polygon: Array<Array<GeoJSONPosition>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
+function pointSetToPolygonDistance(pointSets: Array<GeoJSON.Position>, isLine: boolean, polygon: Array<Array<GeoJSON.Position>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
+// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
     let miniDist = Math.min(ruler.distance(pointSets[0], polygon[0][0]), currentMiniDist);
     if (miniDist === 0.0) return miniDist;
     const initialDistPair: DistPair = {
@@ -329,10 +330,12 @@ function pointSetToPolygonDistance(pointSets: Array<GeoJSONPosition>, isLine: bo
         } else {
             const newRanges = splitRange(range, isLine);
             if (newRanges[0] !== null) {
+                // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
                 const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[0]), polyBBox, ruler);
                 if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: newRanges[0], range2: [0, 0]});
             }
             if (newRanges[1] !== null) {
+                // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
                 const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[1]), polyBBox, ruler);
                 if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: newRanges[1], range2: [0, 0]});
             }
@@ -341,7 +344,8 @@ function pointSetToPolygonDistance(pointSets: Array<GeoJSONPosition>, isLine: bo
     return miniDist;
 }
 
-function pointSetsDistance(pointSet1: Array<GeoJSONPosition>, isLine1: boolean, pointSet2: Array<GeoJSONPosition>, isLine2: boolean, ruler: CheapRuler, currentMiniDist: number = Infinity) {
+function pointSetsDistance(pointSet1: Array<GeoJSON.Position>, isLine1: boolean, pointSet2: Array<GeoJSON.Position>, isLine2: boolean, ruler: CheapRuler, currentMiniDist: number = Infinity) {
+// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
     let miniDist = Math.min(currentMiniDist, ruler.distance(pointSet1[0], pointSet2[0]));
     if (miniDist === 0.0) return miniDist;
     const initialDistPair: DistPair = {
@@ -386,10 +390,11 @@ function pointSetsDistance(pointSet1: Array<GeoJSONPosition>, isLine1: boolean,
     return miniDist;
 }
 
-function pointSetToLinesDistance(pointSet: Array<GeoJSONPosition>, isLine: boolean, lines: Array<Array<GeoJSONPosition>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
+function pointSetToLinesDistance(pointSet: Array<GeoJSON.Position>, isLine: boolean, lines: Array<Array<GeoJSON.Position>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
     let dist = currentMiniDist;
     const bbox1 = getBBox(pointSet, [0, pointSet.length - 1]);
     for (const line of lines) {
+        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (dist !== Infinity && bboxToBBoxDistance(bbox1, getBBox(line, [0, line.length - 1]), ruler) >= dist) continue;
         dist = Math.min(dist, pointSetsDistance(pointSet, isLine, line, true /*isLine*/, ruler, dist));
         if (dist === 0.0) return dist;
@@ -397,10 +402,11 @@ function pointSetToLinesDistance(pointSet: Array<GeoJSONPosition>, isLine: boole
     return dist;
 }
 
-function pointSetToPolygonsDistance(points: Array<GeoJSONPosition>, isLine: boolean, polygons: Array<Array<Array<GeoJSONPosition>>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
+function pointSetToPolygonsDistance(points: Array<GeoJSON.Position>, isLine: boolean, polygons: Array<Array<Array<GeoJSON.Position>>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
     let dist = currentMiniDist;
     const bbox1 = getBBox(points, [0, points.length - 1]);
     for (const polygon of polygons) {
+        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (dist !== Infinity && bboxToBBoxDistance(bbox1, getPolygonBBox(polygon), ruler) >= dist) continue;
         const tempDist = pointSetToPolygonDistance(points, isLine, polygon, ruler, dist);
         if (isNaN(tempDist)) return tempDist;
@@ -409,7 +415,7 @@ function pointSetToPolygonsDistance(points: Array<GeoJSONPosition>, isLine: bool
     return dist;
 }
 
-function polygonsToPolygonsDistance(polygons1: Array<Array<Array<GeoJSONPosition>>>, polygons2: Array<Array<Array<GeoJSONPosition>>>, ruler: CheapRuler) {
+function polygonsToPolygonsDistance(polygons1: Array<Array<Array<GeoJSON.Position>>>, polygons2: Array<Array<Array<GeoJSON.Position>>>, ruler: CheapRuler) {
     let dist = Infinity;
     for (const polygon1 of polygons1) {
         for (const polygon2 of polygons2) {
@@ -526,24 +532,25 @@ function isTypeValid(type: string) {
 }
 class Distance implements Expression {
     type: Type;
-    geojson: GeoJSON;
+    geojson: GeoJSON.GeoJSON;
     geometries: DistanceGeometry;
 
-    constructor(geojson: GeoJSON, geometries: DistanceGeometry) {
+    constructor(geojson: GeoJSON.GeoJSON, geometries: DistanceGeometry) {
         this.type = NumberType;
         this.geojson = geojson;
         this.geometries = geometries;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Distance {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Distance | null | undefined {
         if (args.length !== 2) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Distance'.
             return context.error(
                 `'distance' expression requires either one argument, but found ' ${args.length -
                     1} instead.`
             );
         }
         if (isValue(args[1])) {
-            const geojson = (args[1]: Object);
+            const geojson = (args[1] as any);
             if (geojson.type === 'FeatureCollection') {
                 for (let i = 0; i < geojson.features.length; ++i) {
                     if (isTypeValid(geojson.features[i].geometry.type)) {
@@ -558,6 +565,7 @@ class Distance implements Expression {
                 return new Distance(geojson, geojson);
             }
         }
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Distance'.
         return context.error(
             "'distance' expression needs to be an array with format [\'Distance\', GeoJSONObj]."
         );
@@ -589,7 +597,7 @@ class Distance implements Expression {
         return true;
     }
 
-    serialize(): Array<mixed> {
+    serialize(): Array<unknown> {
         return ['distance', this.geojson];
     }
 }

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

@@ -1,22 +1,28 @@
-// @flow
-
-import {NumberType, ValueType, FormattedType, array, StringType, ColorType, ResolvedImageType} from '../types.js';
-import Formatted, {FormattedSection} from '../types/formatted.js';
-import {toString, typeOf} from '../values.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 {
+    NumberType,
+    ValueType,
+    FormattedType,
+    array,
+    StringType,
+    ColorType,
+    ResolvedImageType,
+} from '../types';
+import Formatted, {FormattedSection} from '../types/formatted';
+import {toString, typeOf} from '../values';
+
+import type {Expression, SerializedExpression} from '../expression';
+import type EvaluationContext from '../evaluation_context';
+import type ParsingContext from '../parsing_context';
+import type {Type} from '../types';
 
 export type FormattedSectionExpression = {
     // Content of a section may be Image expression or other
     // type of expression that is coercable to 'string'.
-    content: Expression,
+    content: Expression;
     scale: Expression | null;
     font: Expression | null;
     textColor: Expression | null;
-}
+};
 
 export default class FormatExpression implements Expression {
     type: Type;
@@ -27,20 +33,22 @@ export default class FormatExpression implements Expression {
         this.sections = sections;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
         if (args.length < 2) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected at least one argument.`);
         }
 
         const firstArg = args[1];
         if (!Array.isArray(firstArg) && typeof firstArg === 'object')  {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`First argument must be an image or text section.`);
         }
 
         const sections: Array<FormattedSectionExpression> = [];
         let nextTokenMayBeObject = false;
         for (let i = 1; i <= args.length - 1; ++i) {
-            const arg = (args[i]: any);
+            const arg = (args[i] as any);
 
             if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
                 nextTokenMayBeObject = false;
@@ -73,6 +81,7 @@ export default class FormatExpression implements Expression {
 
                 const kind = content.type.kind;
                 if (kind !== 'string' && kind !== 'value' && kind !== 'null' && kind !== 'resolvedImage')
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                     return context.error(`Formatted text type must be 'string', 'value', 'image' or 'null'.`);
 
                 nextTokenMayBeObject = true;
@@ -126,8 +135,9 @@ export default class FormatExpression implements Expression {
     serialize(): SerializedExpression {
         const serialized = ["format"];
         for (const section of this.sections) {
+            // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
             serialized.push(section.content.serialize());
-            const options = {};
+            const options: Record<string, any> = {};
             if (section.scale) {
                 options['font-scale'] = section.scale.serialize();
             }
@@ -137,6 +147,7 @@ export default class FormatExpression implements Expression {
             if (section.textColor) {
                 options['text-color'] = section.textColor.serialize();
             }
+            // @ts-expect-error - TS2345 - Argument of type 'Record<string, any>' is not assignable to parameter of type 'string'.
             serialized.push(options);
         }
         return serialized;