@mapbox/mapbox-gl-style-spec 13.24.0-alpha.2 → 13.24.0-beta.1

package/expression/definitions/literal.js

@@ -6,7 +6,7 @@ import Formatted from '../types/formatted.js';
 
 import type {Type} from '../types.js';
 import type {Value}  from '../values.js';
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 
 class Literal implements Expression {
@@ -18,7 +18,7 @@ class Literal implements Expression {
         this.value = value;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): void | Literal {
         if (args.length !== 2)
             return context.error(`'literal' expression requires exactly one argument, but found ${args.length - 1} instead.`);
 
@@ -43,17 +43,17 @@ class Literal implements Expression {
         return new Literal(type, value);
     }
 
-    evaluate() {
+    evaluate(): Value {
         return this.value;
     }
 
     eachChild() {}
 
-    outputDefined() {
+    outputDefined(): boolean {
         return true;
     }
 
-    serialize(): Array<mixed> {
+    serialize(): SerializedExpression {
         if (this.type.kind === 'array' || this.type.kind === 'object') {
             return ["literal", this.value];
         } else if (this.value instanceof Color) {

package/expression/definitions/match.js

@@ -5,7 +5,7 @@ import assert from 'assert';
 import {typeOf} from '../values.js';
 import {ValueType, type Type} from '../types.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 
@@ -30,7 +30,7 @@ class Match implements Expression {
         this.otherwise = otherwise;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Match {
         if (args.length < 5)
             return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         if (args.length % 2 !== 1)
@@ -99,7 +99,7 @@ class Match implements Expression {
         return new Match((inputType: any), (outputType: any), input, cases, outputs, otherwise);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any {
         const input = (this.input.evaluate(ctx): any);
         const output = (typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
         return output.evaluate(ctx);
@@ -115,7 +115,7 @@ class Match implements Expression {
         return this.outputs.every(out => out.outputDefined()) && this.otherwise.outputDefined();
     }
 
-    serialize(): Array<mixed> {
+    serialize(): SerializedExpression {
         const serialized = ["match", this.input.serialize()];
 
         // Sort so serialization has an arbitrary defined order, even though

package/expression/definitions/number_format.js

@@ -2,7 +2,7 @@
 
 import {StringType, NumberType} from '../types.js';
 
-import type {Expression} from '../expression.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';
@@ -93,7 +93,7 @@ export default class NumberFormat implements Expression {
         return new NumberFormat(number, locale, currency, minFractionDigits, maxFractionDigits);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): string {
         return new Intl.NumberFormat(this.locale ? this.locale.evaluate(ctx) : [],
             {
                 style: this.currency ? "currency" : "decimal",
@@ -119,11 +119,11 @@ export default class NumberFormat implements Expression {
         }
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const options = {};
         if (this.locale) {
             options['locale'] = this.locale.serialize();

package/expression/definitions/slice.js

@@ -4,7 +4,7 @@ import {ValueType, NumberType, StringType, array, toString, isValidType, isValid
 import RuntimeError from '../runtime_error.js';
 import {typeOf} from '../values.js';
 
-import type {Expression} from '../expression.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';
@@ -23,7 +23,7 @@ class Slice implements Expression {
 
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Slice {
         if (args.length <= 2 ||  args.length >= 5) {
             return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
         }
@@ -46,7 +46,7 @@ class Slice implements Expression {
         }
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any {
         const input = (this.input.evaluate(ctx): any);
         const beginIndex = (this.beginIndex.evaluate(ctx): number);
 
@@ -70,11 +70,11 @@ class Slice implements Expression {
         }
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         if (this.endIndex != null && this.endIndex !== undefined) {
             const endIndex = this.endIndex.serialize();
             return ["slice", this.input.serialize(), this.beginIndex.serialize(), endIndex];

package/expression/definitions/step.js

@@ -5,7 +5,7 @@ import {NumberType} from '../types.js';
 import {findStopLessThanOrEqualTo} from '../stops.js';
 
 import type {Stops} from '../stops.js';
-import type {Expression} from '../expression.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';
@@ -29,7 +29,7 @@ class Step implements Expression {
         }
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Step {
         if (args.length - 1 < 4) {
             return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         }
@@ -72,7 +72,7 @@ class Step implements Expression {
         return new Step(outputType, input, stops);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any {
         const labels = this.labels;
         const outputs = this.outputs;
 
@@ -105,7 +105,7 @@ class Step implements Expression {
         return this.outputs.every(out => out.outputDefined());
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const serialized = ["step", this.input.serialize()];
         for (let i = 0; i < this.labels.length; i++) {
             if (i > 0) {

package/expression/definitions/var.js

@@ -16,7 +16,7 @@ class Var implements Expression {
         this.boundExpression = boundExpression;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): void | Var {
         if (args.length !== 2 || typeof args[1] !== 'string')
             return context.error(`'var' expression requires exactly one string literal argument.`);
 
@@ -28,17 +28,17 @@ class Var implements Expression {
         return new Var(name, context.scope.get(name));
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any {
         return this.boundExpression.evaluate(ctx);
     }
 
     eachChild() {}
 
-    outputDefined() {
+    outputDefined(): boolean {
         return false;
     }
 
-    serialize() {
+    serialize(): Array<string> {
         return ["var", this.name];
     }
 }

package/expression/definitions/within.js

@@ -3,7 +3,7 @@
 import {isValue} from '../values.js';
 import type {Type} from '../types.js';
 import {BooleanType} from '../types.js';
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {GeoJSON, GeoJSONPolygon, GeoJSONMultiPolygon} from '@mapbox/geojson-types';
@@ -148,7 +148,7 @@ function lineStringWithinPolygons(line, polygons) {
     return false;
 }
 
-function getTilePolygon(coordinates, bbox, canonical) {
+function getTilePolygon(coordinates, bbox: BBox, canonical: CanonicalTileID) {
     const polygon = [];
     for (let i = 0; i < coordinates.length; i++) {
         const ring = [];
@@ -162,7 +162,7 @@ function getTilePolygon(coordinates, bbox, canonical) {
     return polygon;
 }
 
-function getTilePolygons(coordinates, bbox, canonical) {
+function getTilePolygons(coordinates, bbox, canonical: CanonicalTileID) {
     const polygons = [];
     for (let i = 0; i < coordinates.length; i++) {
         const polygon = getTilePolygon(coordinates[i], bbox, canonical);
@@ -188,10 +188,11 @@ function resetBBox(bbox) {
     bbox[2] = bbox[3] = -Infinity;
 }
 
-function getTilePoints(geometry, pointBBox, polyBBox, canonical) {
+function getTilePoints(geometry, pointBBox, polyBBox, canonical: CanonicalTileID) {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
     const tilePoints = [];
+    if (!geometry) return tilePoints;
     for (const points of geometry) {
         for (const point of points) {
             const p = [point.x + shifts[0], point.y + shifts[1]];
@@ -202,10 +203,11 @@ function getTilePoints(geometry, pointBBox, polyBBox, canonical) {
     return tilePoints;
 }
 
-function getTileLines(geometry, lineBBox, polyBBox, canonical) {
+function getTileLines(geometry, lineBBox, polyBBox, canonical: CanonicalTileID) {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
     const tileLines = [];
+    if (!geometry) return tileLines;
     for (const line of geometry) {
         const tileLine = [];
         for (const point of line) {
@@ -231,6 +233,9 @@ function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPo
     const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
 
     const canonical = ctx.canonicalID();
+    if (!canonical) {
+        return false;
+    }
 
     if (polygonGeometry.type === 'Polygon') {
         const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
@@ -259,6 +264,9 @@ function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPol
     const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
 
     const canonical = ctx.canonicalID();
+    if (!canonical) {
+        return false;
+    }
 
     if (polygonGeometry.type === 'Polygon') {
         const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
@@ -292,7 +300,7 @@ class Within implements Expression {
         this.geometries = geometries;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Within {
         if (args.length !== 2)
             return context.error(`'within' expression requires exactly one argument, but found ${args.length - 1} instead.`);
         if (isValue(args[1])) {
@@ -316,7 +324,7 @@ class Within implements Expression {
         return context.error(`'within' expression requires valid geojson object that contains polygon geometry type.`);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): boolean {
         if (ctx.geometry() != null && ctx.canonicalID() != null) {
             if (ctx.geometryType() === 'Point') {
                 return pointsWithinPolygons(ctx, this.geometries);
@@ -333,7 +341,7 @@ class Within implements Expression {
         return true;
     }
 
-    serialize(): Array<mixed> {
+    serialize(): SerializedExpression {
         return ["within", this.geojson];
     }
 

package/expression/evaluation_context.js

@@ -16,7 +16,7 @@ class EvaluationContext {
     featureState: ?FeatureState;
     formattedSection: ?FormattedSection;
     availableImages: ?Array<string>;
-    canonical: ?CanonicalTileID;
+    canonical: null | CanonicalTileID;
     featureTileCoord: ?Point;
     featureDistanceData: ?FeatureDistanceData;
 
@@ -34,27 +34,27 @@ class EvaluationContext {
         this.featureDistanceData = null;
     }
 
-    id() {
-        return this.feature && 'id' in this.feature ? this.feature.id : null;
+    id(): number | null {
+        return this.feature && 'id' in this.feature && this.feature.id ? this.feature.id : null;
     }
 
-    geometryType() {
+    geometryType(): null | string {
         return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
     }
 
-    geometry() {
+    geometry(): ?Array<Array<Point>> {
         return this.feature && 'geometry' in this.feature ? this.feature.geometry : null;
     }
 
-    canonicalID() {
+    canonicalID(): null | CanonicalTileID {
         return this.canonical;
     }
 
-    properties() {
-        return this.feature && this.feature.properties || {};
+    properties(): {[string]: any} {
+        return (this.feature && this.feature.properties) || {};
     }
 
-    distanceFromCenter() {
+    distanceFromCenter(): number {
         if (this.featureTileCoord && this.featureDistanceData) {
 
             const c = this.featureDistanceData.center;

package/expression/expression.js

@@ -4,7 +4,7 @@ import type {Type} from './types.js';
 import type ParsingContext from './parsing_context.js';
 import type EvaluationContext from './evaluation_context.js';
 
-type SerializedExpression = Array<mixed> | string | number | boolean | null;
+export type SerializedExpression = Array<mixed> | Array<string> | string | number | boolean | null;
 
 export interface Expression {
     +type: Type;

package/expression/index.js

@@ -31,7 +31,7 @@ import type {FeatureDistanceData} from '../feature_filter/index.js';
 
 export type Feature = {
     +type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon',
-    +id?: any,
+    +id?: number | null,
     +properties: {[_: string]: any},
     +patterns?: {[_: string]: {"min": string, "mid": string, "max": string}},
     +geometry?: Array<Array<Point>>
@@ -69,7 +69,7 @@ export class StyleExpression {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature;
         this._evaluator.featureState = featureState;
-        this._evaluator.canonical = canonical;
+        this._evaluator.canonical = canonical || null;
         this._evaluator.availableImages = availableImages || null;
         this._evaluator.formattedSection = formattedSection;
         this._evaluator.featureTileCoord = featureTileCoord || null;
@@ -82,7 +82,7 @@ export class StyleExpression {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature || null;
         this._evaluator.featureState = featureState || null;
-        this._evaluator.canonical = canonical;
+        this._evaluator.canonical = canonical || null;
         this._evaluator.availableImages = availableImages || null;
         this._evaluator.formattedSection = formattedSection || null;
         this._evaluator.featureTileCoord = featureTileCoord || null;
@@ -110,7 +110,7 @@ export class StyleExpression {
     }
 }
 
-export function isExpression(expression: mixed) {
+export function isExpression(expression: mixed): boolean {
     return Array.isArray(expression) && expression.length > 0 &&
         typeof expression[0] === 'string' && expression[0] in definitions;
 }
@@ -286,11 +286,11 @@ export class StylePropertyFunction<T> {
         extend(this, createFunction(this._parameters, this._specification));
     }
 
-    static deserialize(serialized: {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification}) {
-        return ((new StylePropertyFunction(serialized._parameters, serialized._specification)): StylePropertyFunction<T>);
+    static deserialize(serialized: {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification}): StylePropertyFunction<T> {
+        return new StylePropertyFunction(serialized._parameters, serialized._specification);
     }
 
-    static serialize(input: StylePropertyFunction<T>) {
+    static serialize(input: StylePropertyFunction<T>): {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification} {
         return {
             _parameters: input._parameters,
             _specification: input._specification

package/expression/is_constant.js

@@ -4,7 +4,7 @@ import CompoundExpression from './compound_expression.js';
 import Within from './definitions/within.js';
 import type {Expression} from './expression.js';
 
-function isFeatureConstant(e: Expression) {
+function isFeatureConstant(e: Expression): boolean {
     if (e instanceof CompoundExpression) {
         if (e.name === 'get' && e.args.length === 1) {
             return false;
@@ -34,7 +34,7 @@ function isFeatureConstant(e: Expression) {
     return result;
 }
 
-function isStateConstant(e: Expression) {
+function isStateConstant(e: Expression): boolean {
     if (e instanceof CompoundExpression) {
         if (e.name === 'feature-state') {
             return false;
@@ -47,7 +47,7 @@ function isStateConstant(e: Expression) {
     return result;
 }
 
-function isGlobalPropertyConstant(e: Expression, properties: Array<string>) {
+function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boolean {
     if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) { return false; }
     let result = true;
     e.eachChild((arg) => {

package/expression/parsing_context.js

@@ -155,7 +155,7 @@ class ParsingContext {
      * parsing, is copied by reference rather than cloned.
      * @private
      */
-    concat(index: number, expectedType?: ?Type, bindings?: Array<[string, Expression]>) {
+    concat(index: number, expectedType?: ?Type, 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(

package/expression/runtime_error.js

@@ -9,7 +9,7 @@ class RuntimeError {
         this.message = message;
     }
 
-    toJSON() {
+    toJSON(): string {
         return this.message;
     }
 }

package/expression/scope.js

@@ -17,7 +17,7 @@ class Scope {
         }
     }
 
-    concat(bindings: Array<[string, Expression]>) {
+    concat(bindings: Array<[string, Expression]>): Scope {
         return new Scope(this, bindings);
     }
 

package/expression/stops.js

@@ -10,7 +10,7 @@ export type Stops = Array<[number, Expression]>;
  * Returns the index of the last stop <= input, or 0 if it doesn't exist.
  * @private
  */
-export function findStopLessThanOrEqualTo(stops: Array<number>, input: number) {
+export function findStopLessThanOrEqualTo(stops: Array<number>, input: number): number {
     const lastIndex = stops.length - 1;
     let lowerIndex = 0;
     let upperIndex = lastIndex;

package/expression/values.js

@@ -107,7 +107,7 @@ export function typeOf(value: Value): Type {
     }
 }
 
-export function toString(value: Value) {
+export function toString(value: Value): string {
     const type = typeof value;
     if (value === null) {
         return '';

package/feature_filter/convert.js

@@ -94,7 +94,7 @@ function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedType
         const children = (filter: any).slice(1).map(f => _convertFilter(f, expectedTypes));
         return children.length > 1 ? ['all'].concat(children) : [].concat(...children);
     } else if (op === 'none') {
-        return ['!', _convertFilter(['any'].concat(filter.slice(1)), {})];
+        return ['!', _convertFilter(['any'].concat((filter: any).slice(1)), {})];
     } else if (op === 'in') {
         converted = convertInOp((filter[1]: any), filter.slice(2));
     } else if (op === '!in') {

package/feature_filter/index.js

@@ -9,13 +9,13 @@ import type {CanonicalTileID} from '../../source/tile_id.js';
 import type Point from '@mapbox/point-geometry';
 
 export type FeatureDistanceData = {bearing: [number, number], center: [number, number], scale: number};
-type FilterExpression = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData) => boolean;
+export type FilterExpression = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData) => boolean;
 export type FeatureFilter = {filter: FilterExpression, dynamicFilter?: FilterExpression, needGeometry: boolean, needFeature: boolean};
 
 export default createFilter;
 export {isExpressionFilter, isDynamicFilter, extractStaticFilter};
 
-function isExpressionFilter(filter: any) {
+function isExpressionFilter(filter: any): boolean {
     if (filter === true || filter === false) {
         return true;
     }

package/flow-typed/gl-matrix.js

@@ -0,0 +1,103 @@
+// @flow
+type VecType = Array<number> | Float32Array | Float64Array;
+
+declare module "gl-matrix" {
+    declare type Vec2 = VecType;
+    declare type Vec3 = VecType;
+    declare type Vec4 = VecType;
+    declare type Quat = VecType;
+    declare type Mat2 = VecType;
+    declare type Mat3 = VecType;
+    declare type Mat4 = VecType;
+
+    declare var vec2: {
+        exactEquals(Vec2, Vec2): boolean
+    };
+
+    declare var vec3: {
+        create(): Float32Array,
+        fromValues(number, number, number): Float32Array,
+        length(Vec3): number,
+        len(Vec3): number,
+        squaredLength(Vec3): number,
+        dot(Vec3, Vec3): number,
+        equals(Vec3, Vec3): boolean,
+        exactEquals(Vec3, Vec3): boolean,
+
+        clone<T: Vec3>(T): T,
+        normalize<T: Vec3>(T, Vec3): T,
+        add<T: Vec3>(T, Vec3, Vec3): T,
+        sub<T: Vec3>(T, Vec3, Vec3): T,
+        subtract<T: Vec3>(T, Vec3, Vec3): T,
+        cross<T: Vec3>(T, Vec3, Vec3): T,
+        negate<T: Vec3>(T, Vec3): T,
+        scale<T: Vec3>(T, Vec3, number): T,
+        scaleAndAdd<T: Vec3>(T, Vec3, Vec3, number): T,
+        multiply<T: Vec3>(T, Vec3, Vec3): T,
+        mul<T: Vec3>(T, Vec3, Vec3): T,
+        div<T: Vec3>(T, Vec3, Vec3): T,
+        min<T: Vec3>(T, Vec3, Vec3): T,
+        max<T: Vec3>(T, Vec3, Vec3): T,
+        lerp<T: Vec3>(T, Vec3, Vec3, number): T,
+        transformQuat<T: Vec3>(T, Vec3, Quat): T,
+        transformMat3<T: Vec3>(T, Vec3, Mat3): T,
+        transformMat4<T: Vec3>(T, Vec3, Mat4): T
+    };
+
+    declare var vec4: {
+        scale<T: Vec4>(T, Vec4, number): T,
+        mul<T: Vec4>(T, Vec4, Vec4): T,
+        transformMat4<T: Vec4>(T, Vec4, Mat4): T
+    };
+
+    declare var mat2: {
+        create(): Float32Array,
+        rotate<T: Mat2>(T, Mat2, number): T,
+        invert<T: Mat2>(T, Mat2): T,
+        scale<T: Mat2>(T, Mat2, Vec2): T
+    };
+
+    declare var mat3: {
+        create(): Float32Array,
+
+        fromMat4<T: Mat3>(T, Mat4): T,
+        fromRotation<T: Mat3>(T, number): T,
+        mul<T: Mat3>(T, Mat3, Mat3): T,
+        multiply<T: Mat3>(T, Mat3, Mat3): T,
+        adjoint<T: Mat3>(T, Mat3): T,
+        transpose<T: Mat3>(T, Mat3): T
+    };
+
+    declare var mat4: {
+        create(): Float32Array,
+
+        fromScaling<T: Mat4>(T, Vec3): T,
+        fromQuat<T: Mat4>(T, Quat): T,
+        ortho<T: Mat4>(T, number, number, number, number, number, number): T,
+        perspective<T: Mat4>(T, number, number, number, number): T,
+        identity<T: Mat4>(T): T,
+        scale<T: Mat4>(T, Mat4, Vec3): T,
+        mul<T: Mat4>(T, Mat4, Mat4): T,
+        multiply<T: Mat4>(T, Mat4, Mat4): T,
+        rotateX<T: Mat4>(T, Mat4, number): T,
+        rotateY<T: Mat4>(T, Mat4, number): T,
+        rotateZ<T: Mat4>(T, Mat4, number): T,
+        translate<T: Mat4>(T, Mat4, Vec3): T,
+        invert<T: Mat4>(T, Mat4): T,
+        copy<T: Mat4>(T, Mat4): T,
+        clone<T: Mat4>(T): T
+    };
+
+    declare var quat: {
+        create(): Float32Array,
+        length(Quat): number,
+        exactEquals(Quat, Quat): boolean,
+
+        normalize<T: Quat>(T, Quat): T,
+        conjugate<T: Quat>(T, Quat): T,
+        identity<T: Quat>(T): T,
+        rotateX<T: Quat>(T, Quat, number): T,
+        rotateY<T: Quat>(T, Quat, number): T,
+        rotateZ<T: Quat>(T, Quat, number): T
+    }
+}

package/flow-typed/grid-index.js

@@ -0,0 +1,13 @@
+// @flow strict
+declare module 'grid-index' {
+    declare class GridIndex {
+        constructor(extent: number, n: number, padding: number): GridIndex;
+        constructor(data: ArrayBuffer): GridIndex;
+
+        insert(key: number, x1: number, y1: number, x2: number, y2: number): void;
+        query(x1: number, y1: number, x2: number, y2: number, intersectionText?: (number, number, number, number) => boolean): Array<number>;
+        toArrayBuffer(): ArrayBuffer;
+    }
+
+    declare export default Class<GridIndex>;
+}

package/flow-typed/pbf.js

@@ -1,3 +1,4 @@
+// @flow
 declare module "pbf" {
     declare type ReadFunction<T> = (tag: number, result: T, pbf: Pbf) => void;
 
@@ -21,5 +22,5 @@ declare module "pbf" {
         readBytes(): Uint8Array;
     }
 
-    declare module.exports: typeof Pbf
+    declare export default Class<Pbf>;
 }