maplibre-gl 2.0.1 → 2.0.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maplibre-gl",
   "description": "BSD licensed community fork of mapbox-gl, a WebGL interactive maps library",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "main": "dist/maplibre-gl.js",
   "style": "dist/maplibre-gl.css",
   "license": "BSD-3-Clause",
@@ -22,11 +22,11 @@
     "@mapbox/unitbezier": "^0.0.1",
     "@mapbox/vector-tile": "^1.3.1",
     "@mapbox/whoots-js": "^3.1.0",
+    "@types/pbf": "^3.0.2",
     "csscolorparser": "~1.0.3",
     "earcut": "^2.2.2",
     "geojson-vt": "^3.2.1",
     "gl-matrix": "^3.2.1",
-    "grid-index": "^1.1.0",
     "murmurhash-js": "^1.0.0",
     "pbf": "^3.2.1",
     "potpack": "^1.0.1",
@@ -69,7 +69,6 @@
     "@types/node-notifier": "^8.0.0",
     "@types/npm-packlist": "^1.1.1",
     "@types/offscreencanvas": "^2019.6.3",
-    "@types/pbf": "^3.0.2",
     "@types/pixelmatch": "^5.2.2",
     "@types/pngjs": "^6.0.1",
     "@types/puppeteer": "^5.4.4",

package/src/data/array_types.ts

@@ -1031,6 +1031,25 @@ export class FeatureIndexArray extends StructArrayLayout1ul2ui8 {
 
 register('FeatureIndexArray', FeatureIndexArray);
 
+export class PosArray extends StructArrayLayout2i4 {}
+export class RasterBoundsArray extends StructArrayLayout4i8 {}
+export class CircleLayoutArray extends StructArrayLayout2i4 {}
+export class FillLayoutArray extends StructArrayLayout2i4 {}
+export class FillExtrusionLayoutArray extends StructArrayLayout2i4i12 {}
+export class HeatmapLayoutArray extends StructArrayLayout2i4 {}
+export class LineLayoutArray extends StructArrayLayout2i4ub8 {}
+export class LineExtLayoutArray extends StructArrayLayout2f8 {}
+export class PatternLayoutArray extends StructArrayLayout10ui20 {}
+export class SymbolLayoutArray extends StructArrayLayout4i4ui4i24 {}
+export class SymbolDynamicLayoutArray extends StructArrayLayout3f12 {}
+export class SymbolOpacityArray extends StructArrayLayout1ul4 {}
+export class CollisionBoxLayoutArray extends StructArrayLayout2i2i2i12 {}
+export class CollisionCircleLayoutArray extends StructArrayLayout2f1f2i16 {}
+export class CollisionVertexArray extends StructArrayLayout2ub2f12 {}
+export class QuadTriangleArray extends StructArrayLayout3ui6 {}
+export class TriangleIndexArray extends StructArrayLayout3ui6 {}
+export class LineIndexArray extends StructArrayLayout2ui4 {}
+export class LineStripIndexArray extends StructArrayLayout1ui2 {}
 export {
     StructArrayLayout2i4,
     StructArrayLayout4i8,
@@ -1053,24 +1072,5 @@ export {
     StructArrayLayout1ul2ui8,
     StructArrayLayout2ui4,
     StructArrayLayout1ui2,
-    StructArrayLayout4f16,
-    StructArrayLayout2i4 as PosArray,
-    StructArrayLayout4i8 as RasterBoundsArray,
-    StructArrayLayout2i4 as CircleLayoutArray,
-    StructArrayLayout2i4 as FillLayoutArray,
-    StructArrayLayout2i4i12 as FillExtrusionLayoutArray,
-    StructArrayLayout2i4 as HeatmapLayoutArray,
-    StructArrayLayout2i4ub8 as LineLayoutArray,
-    StructArrayLayout2f8 as LineExtLayoutArray,
-    StructArrayLayout10ui20 as PatternLayoutArray,
-    StructArrayLayout4i4ui4i24 as SymbolLayoutArray,
-    StructArrayLayout3f12 as SymbolDynamicLayoutArray,
-    StructArrayLayout1ul4 as SymbolOpacityArray,
-    StructArrayLayout2i2i2i12 as CollisionBoxLayoutArray,
-    StructArrayLayout2f1f2i16 as CollisionCircleLayoutArray,
-    StructArrayLayout2ub2f12 as CollisionVertexArray,
-    StructArrayLayout3ui6 as QuadTriangleArray,
-    StructArrayLayout3ui6 as TriangleIndexArray,
-    StructArrayLayout2ui4 as LineIndexArray,
-    StructArrayLayout1ui2 as LineStripIndexArray
+    StructArrayLayout4f16
 };

package/src/data/bucket/fill_bucket.test.ts

@@ -42,7 +42,7 @@ test('FillBucket', () => {
             new Point(10, 20)
         ]], undefined, undefined, undefined);
 
-        bucket.addFeature(feature, feature.loadGeometry(), undefined, undefined, undefined);
+        bucket.addFeature(feature as any, feature.loadGeometry(), undefined, undefined, undefined);
     }).not.toThrow();
 });
 

package/src/data/bucket/line_bucket.test.ts

@@ -96,7 +96,7 @@ describe('LineBucket', () => {
                 new Point(0, 0)
             ], polygon, undefined, undefined, undefined, undefined);
 
-            bucket.addFeature(feature, feature.loadGeometry(), undefined, undefined, undefined);
+            bucket.addFeature(feature as any, feature.loadGeometry(), undefined, undefined, undefined);
         }).not.toThrow();
     });
 

package/src/data/feature_index.ts

@@ -3,7 +3,7 @@ import loadGeometry from './load_geometry';
 import toEvaluationFeature from './evaluation_feature';
 import EXTENT from './extent';
 import featureFilter from '../style-spec/feature_filter';
-import TransferableGridIndex from 'grid-index';
+import TransferableGridIndex from '../util/transferable_grid_index';
 import DictionaryCoder from '../util/dictionary_coder';
 import vt from '@mapbox/vector-tile';
 import Protobuf from 'pbf';
@@ -296,7 +296,7 @@ class FeatureIndex {
         let id: string | number = feature.id;
         if (this.promoteId) {
             const propName = typeof this.promoteId === 'string' ? this.promoteId : this.promoteId[sourceLayerId];
-            id = feature.properties[propName];
+            id = feature.properties[propName] as string | number;
             if (typeof id === 'boolean') id = Number(id);
         }
         return id;

package/src/index.ts

@@ -1,5 +1,4 @@
 /// <reference path="./types/glsl.d.ts" />
-/// <reference path="./types/non-typed-modules.d.ts" />
 import assert from 'assert';
 import {supported} from '@mapbox/mapbox-gl-supported';
 

package/src/source/source.ts

@@ -117,11 +117,11 @@ export const create = function(id: string, specification: SourceSpecification, d
     return source;
 };
 
-export const getType = function (name: string) {
+export const getSourceType = function (name: string) {
     return sourceTypes[name];
 };
 
-export const setType = function (name: string, type: {
+export const setSourceType = function (name: string, type: {
   new (...args: any): Source;
 }) {
     sourceTypes[name] = type;

package/src/source/source_cache.test.ts

@@ -1,5 +1,5 @@
 import SourceCache from './source_cache';
-import {setType} from './source';
+import {setSourceType} from './source';
 import Tile from './tile';
 import {OverscaledTileID} from './tile_id';
 import Transform from '../geo/transform';
@@ -63,7 +63,7 @@ function createSource(id: string, sourceOptions: any, _dispatcher: any, eventedP
     return source;
 }
 
-setType('mock-source-type', createSource as any);
+setSourceType('mock-source-type', createSource as any);
 
 function createSourceCache(options?, used?) {
     const sc = new SourceCache('id', extend({

package/src/source/worker_tile.test.ts

@@ -4,6 +4,7 @@ import {OverscaledTileID} from '../source/tile_id';
 import StyleLayerIndex from '../style/style_layer_index';
 import {WorkerTileParameters} from './worker_source';
 import Actor from '../util/actor';
+import {VectorTile} from '@mapbox/vector-tile';
 
 function createWorkerTile() {
     return new WorkerTile({
@@ -87,7 +88,7 @@ describe('worker tile', () => {
                     version: 1
                 }
             }
-        };
+        } as any as VectorTile;
 
         const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
 

package/src/style/style.ts

@@ -13,7 +13,7 @@ import {getJSON, getReferrer, makeRequest, ResourceType} from '../util/ajax';
 import browser from '../util/browser';
 import Dispatcher from '../util/dispatcher';
 import {validateStyle, emitValidationErrors as _emitValidationErrors} from './validate_style';
-import {getType as getSourceType, setType as setSourceType, Source} from '../source/source';
+import {getSourceType, setSourceType, Source} from '../source/source';
 import type {SourceClass} from '../source/source';
 import {queryRenderedFeatures, queryRenderedSymbols, querySourceFeatures} from '../source/query_features';
 import SourceCache from '../source/source_cache';

package/src/style/style_layer.ts

@@ -32,21 +32,6 @@ import type {VectorTileFeature} from '@mapbox/vector-tile';
 
 const TRANSITION_SUFFIX = '-transition';
 
-// this interface is used to allow optional overload for this methods in the derived classes.
-interface StyleLayer {
-    queryRadius?(bucket: Bucket): number;
-    queryIntersectsFeature?(
-      queryGeometry: Array<Point>,
-      feature: VectorTileFeature,
-      featureState: FeatureState,
-      geometry: Array<Array<Point>>,
-      zoom: number,
-      transform: Transform,
-      pixelsToTileUnits: number,
-      pixelPosMatrix: mat4
-    ): boolean | number;
-}
-
 abstract class StyleLayer extends Evented {
     id: string;
     metadata: unknown;
@@ -71,6 +56,18 @@ abstract class StyleLayer extends Evented {
     readonly onAdd: ((map: Map) => void);
     readonly onRemove: ((map: Map) => void);
 
+    queryRadius?(bucket: Bucket): number;
+    queryIntersectsFeature?(
+      queryGeometry: Array<Point>,
+      feature: VectorTileFeature,
+      featureState: FeatureState,
+      geometry: Array<Array<Point>>,
+      zoom: number,
+      transform: Transform,
+      pixelsToTileUnits: number,
+      pixelPosMatrix: mat4
+    ): boolean | number;
+
     constructor(layer: LayerSpecification | CustomLayerInterface, properties: Readonly<{
       layout?: Properties<any>;
       paint?: Properties<any>;

package/src/types/packages-types/vector-tile/index.d.ts

@@ -0,0 +1,27 @@
+declare module '@mapbox/vector-tile' {
+    import '@mapbox/vector-tile';
+    import type Pbf from 'pbf';
+
+    export class VectorTileLayer {
+        version?: number;
+        name: string;
+        extent: number;
+        length: number;
+        feature(i: number): VectorTileFeature;
+    }
+
+    export class VectorTile {
+        constructor(pbf: Pbf);
+        layers: {[_: string]: VectorTileLayer};
+    }
+
+    export class VectorTileFeature {
+        static types: ['Unknown', 'Point', 'LineString', 'Polygon'];
+        extent: number;
+        type: 1 | 2 | 3;
+        id: number;
+        properties: {[_: string]: string | number | boolean};
+        loadGeometry(): Array<Array<Point>>;
+        toGeoJSON(x: number, y: number, z: number): GeoJSON.Feature;
+    }
+}

package/src/util/transferable_grid_index.test.ts

@@ -0,0 +1,56 @@
+import TransferableGridIndex from './transferable_grid_index';
+
+describe('TransferableGridIndex', () => {
+
+    test('indexes features', () => {
+        const grid = new TransferableGridIndex(100, 4, 1);
+        grid.insert(0, 4, 10, 6, 30);
+        grid.insert(1, 4, 10, 30, 12);
+        grid.insert(2, -10, 30, -5, 35);
+
+        expect(grid.query(4, 10, 5, 11).sort()).toEqual([0, 1]);
+        expect(grid.query(24, 10, 25, 11).sort()).toEqual([1]);
+        expect(grid.query(40, 40, 100, 100)).toEqual([]);
+        expect(grid.query(-6, 0, -7, 100)).toEqual([2]);
+        expect(grid.query(-Infinity, -Infinity, Infinity, Infinity).sort()).toEqual([0, 1, 2]);
+    });
+
+    test('returns multiple copies of a key if multiple boxes were inserted with the same key', () => {
+        const grid = new TransferableGridIndex(100, 4, 0);
+        const key = 123;
+        grid.insert(key, 3, 3, 4, 4);
+        grid.insert(key, 13, 13, 14, 14);
+        grid.insert(key, 23, 23, 24, 24);
+        expect(grid.query(0, 0, 30, 30)).toEqual([key, key, key]);
+    });
+
+    test('serializing to an arraybuffer', () => {
+        const originalGrid  = new TransferableGridIndex(100, 4, 1);
+        originalGrid.insert(0, 4, 10, 6, 30);
+        originalGrid.insert(1, 4, 10, 30, 12);
+        originalGrid.insert(2, -10, 30, -5, 35);
+
+        const arrayBuffer = originalGrid.toArrayBuffer();
+        const grid = new TransferableGridIndex(arrayBuffer);
+
+        expect(grid.query(4, 10, 5, 11).sort()).toEqual([0, 1]);
+        expect(grid.query(24, 10, 25, 11).sort()).toEqual([1]);
+        expect(grid.query(40, 40, 100, 100)).toEqual([]);
+        expect(grid.query(-6, 0, -7, 100)).toEqual([2]);
+        expect(grid.query(-Infinity, -Infinity, Infinity, Infinity).sort()).toEqual([0, 1, 2]);
+
+        expect(() => grid.insert(3, 0, 0, 0, 0)).toThrow();
+    });
+
+    test('serialize round trip', () => {
+        const grid = new TransferableGridIndex(100, 4, 0);
+        const key = 123;
+        grid.insert(key, 3, 3, 4, 4);
+        grid.insert(key, 13, 13, 14, 14);
+        grid.insert(key, 23, 23, 24, 24);
+        const serializedGrid = TransferableGridIndex.serialize(grid);
+        const deserializedGrid = TransferableGridIndex.deserialize(serializedGrid);
+        expect(deserializedGrid.query(0, 0, 30, 30)).toEqual([key, key, key]);
+    });
+
+});

package/src/util/transferable_grid_index.ts

@@ -0,0 +1,216 @@
+/*
+This file was copied from https://github.com/mapbox/grid-index and was
+migrated from JavaScript to TypeScript.
+
+Copyright (c) 2016, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
+const NUM_PARAMS = 3;
+
+export type SerializedGrid = {
+    buffer: ArrayBuffer;
+};
+
+class TransferableGridIndex {
+    cells: number[][];
+    arrayBuffer: ArrayBuffer;
+    d: number;
+    keys: number[];
+    bboxes: number[];
+    n: number;
+    extent: number;
+    padding: number;
+    scale: any;
+    uid: number;
+    min: number;
+    max: number;
+
+    constructor(extent: number | ArrayBuffer, n?: number, padding?: number) {
+        const cells = this.cells = [];
+
+        if (extent instanceof ArrayBuffer) {
+            this.arrayBuffer = extent;
+            const array = new Int32Array(this.arrayBuffer);
+            extent = array[0];
+            n = array[1];
+            padding = array[2];
+
+            this.d = n + 2 * padding;
+            for (let k = 0; k < this.d * this.d; k++) {
+                const start = array[NUM_PARAMS + k];
+                const end = array[NUM_PARAMS + k + 1];
+                cells.push(start === end ? null : array.subarray(start, end));
+            }
+            const keysOffset = array[NUM_PARAMS + cells.length];
+            const bboxesOffset = array[NUM_PARAMS + cells.length + 1];
+            this.keys = array.subarray(keysOffset, bboxesOffset) as any as number[];
+            this.bboxes = array.subarray(bboxesOffset) as any as number[];
+
+            this.insert = this._insertReadonly;
+
+        } else {
+            this.d = n + 2 * padding;
+            for (let i = 0; i < this.d * this.d; i++) {
+                cells.push([]);
+            }
+            this.keys = [];
+            this.bboxes = [];
+        }
+
+        this.n = n;
+        this.extent = extent;
+        this.padding = padding;
+        this.scale = n / extent;
+        this.uid = 0;
+
+        const p = (padding / n) * extent;
+        this.min = -p;
+        this.max = extent + p;
+    }
+
+    insert(key: number, x1: number, y1: number, x2: number, y2: number) {
+        this._forEachCell(x1, y1, x2, y2, this._insertCell, this.uid++, undefined, undefined);
+        this.keys.push(key);
+        this.bboxes.push(x1);
+        this.bboxes.push(y1);
+        this.bboxes.push(x2);
+        this.bboxes.push(y2);
+    }
+
+    _insertReadonly() {
+        throw new Error('Cannot insert into a GridIndex created from an ArrayBuffer.');
+    }
+
+    _insertCell(x1: number, y1: number, x2: number, y2: number, cellIndex: number, uid: number) {
+        this.cells[cellIndex].push(uid);
+    }
+
+    query(x1: number, y1: number, x2: number, y2: number, intersectionTest?: Function): number[] {
+        const min = this.min;
+        const max = this.max;
+        if (x1 <= min && y1 <= min && max <= x2 && max <= y2 && !intersectionTest) {
+            // We use `Array#slice` because `this.keys` may be a `Int32Array` and
+            // some browsers (Safari and IE) do not support `TypedArray#slice`
+            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice#Browser_compatibility
+            return Array.prototype.slice.call(this.keys);
+
+        } else {
+            const result = [];
+            const seenUids = {};
+            this._forEachCell(x1, y1, x2, y2, this._queryCell, result, seenUids, intersectionTest);
+            return result;
+        }
+    }
+
+    _queryCell(x1: number, y1: number, x2: number, y2:number, cellIndex:number, result, seenUids, intersectionTest: Function) {
+        const cell = this.cells[cellIndex];
+        if (cell !== null) {
+            const keys = this.keys;
+            const bboxes = this.bboxes;
+            for (let u = 0; u < cell.length; u++) {
+                const uid = cell[u];
+                if (seenUids[uid] === undefined) {
+                    const offset = uid * 4;
+                    if (intersectionTest ?
+                        intersectionTest(bboxes[offset + 0], bboxes[offset + 1], bboxes[offset + 2], bboxes[offset + 3]) :
+                        ((x1 <= bboxes[offset + 2]) &&
+                        (y1 <= bboxes[offset + 3]) &&
+                        (x2 >= bboxes[offset + 0]) &&
+                        (y2 >= bboxes[offset + 1]))) {
+                        seenUids[uid] = true;
+                        result.push(keys[uid]);
+                    } else {
+                        seenUids[uid] = false;
+                    }
+                }
+            }
+        }
+    }
+
+    _forEachCell(x1: number, y1: number, x2:number, y2:number, fn: Function, arg1, arg2, intersectionTest) {
+        const cx1 = this._convertToCellCoord(x1);
+        const cy1 = this._convertToCellCoord(y1);
+        const cx2 = this._convertToCellCoord(x2);
+        const cy2 = this._convertToCellCoord(y2);
+        for (let x = cx1; x <= cx2; x++) {
+            for (let y = cy1; y <= cy2; y++) {
+                const cellIndex = this.d * y + x;
+                if (intersectionTest && !intersectionTest(
+                            this._convertFromCellCoord(x),
+                            this._convertFromCellCoord(y),
+                            this._convertFromCellCoord(x + 1),
+                            this._convertFromCellCoord(y + 1))) continue;
+                if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, intersectionTest)) return;
+            }
+        }
+    }
+
+    _convertFromCellCoord (x) {
+        return (x - this.padding) / this.scale;
+    }
+
+    _convertToCellCoord(x) {
+        return Math.max(0, Math.min(this.d - 1, Math.floor(x * this.scale) + this.padding));
+    }
+
+    toArrayBuffer(): ArrayBuffer {
+        if (this.arrayBuffer) return this.arrayBuffer;
+
+        const cells = this.cells;
+
+        const metadataLength = NUM_PARAMS + this.cells.length + 1 + 1;
+        let totalCellLength = 0;
+        for (let i = 0; i < this.cells.length; i++) {
+            totalCellLength += this.cells[i].length;
+        }
+
+        const array = new Int32Array(metadataLength + totalCellLength + this.keys.length + this.bboxes.length);
+        array[0] = this.extent;
+        array[1] = this.n;
+        array[2] = this.padding;
+
+        let offset = metadataLength;
+        for (let k = 0; k < cells.length; k++) {
+            const cell = cells[k];
+            array[NUM_PARAMS + k] = offset;
+            array.set(cell, offset);
+            offset += cell.length;
+        }
+
+        array[NUM_PARAMS + cells.length] = offset;
+        array.set(this.keys, offset);
+        offset += this.keys.length;
+
+        array[NUM_PARAMS + cells.length + 1] = offset;
+        array.set(this.bboxes, offset);
+        offset += this.bboxes.length;
+
+        return array.buffer;
+    }
+
+    public static serialize(grid: TransferableGridIndex, transferables?: Array<Transferable>): SerializedGrid {
+        const buffer = grid.toArrayBuffer();
+        if (transferables) {
+            transferables.push(buffer);
+        }
+        return {buffer};
+    }
+
+    public static deserialize(serialized: SerializedGrid): TransferableGridIndex {
+        return new TransferableGridIndex(serialized.buffer);
+    }
+}
+
+export default TransferableGridIndex;

package/src/util/web_worker_transfer.ts

@@ -1,6 +1,6 @@
 import assert from 'assert';
 
-import TransferableGridIndex from 'grid-index';
+import TransferableGridIndex from './transferable_grid_index';
 import Color from '../style-spec/util/color';
 import {StylePropertyFunction, StyleExpression, ZoomDependentExpression, ZoomConstantExpression} from '../style-spec/expression';
 import CompoundExpression from '../style-spec/expression/compound_expression';
@@ -63,22 +63,6 @@ export function register<T extends any>(
 }
 
 register('Object', Object);
-
-type SerializedGrid = {
-  buffer: ArrayBuffer;
-};
-
-TransferableGridIndex.serialize = function serialize(grid: TransferableGridIndex, transferables?: Array<Transferable>): SerializedGrid {
-    const buffer = grid.toArrayBuffer();
-    if (transferables) {
-        transferables.push(buffer);
-    }
-    return {buffer};
-};
-
-TransferableGridIndex.deserialize = function deserialize(serialized: SerializedGrid): TransferableGridIndex {
-    return new TransferableGridIndex(serialized.buffer);
-};
 register('TransferableGridIndex', TransferableGridIndex);
 
 register('Color', Color);

package/src/types/non-typed-modules.d.ts

@@ -1,47 +0,0 @@
-import type Pbf from 'pbf';
-import type Point from '../util/point';
-
-declare module 'grid-index' {
-    class TransferableGridIndex {
-        constructor(extent: number, n: number, padding: number);
-        constructor(arrayBuffer: ArrayBuffer);
-        insert(key: number, x1: number, y1: number, x2: number, y2: number);
-        query(key: number, x1: number, y1: number, x2: number, y2: number, intersectionTest?: Function): number[];
-        toArrayBuffer(): ArrayBuffer;
-    }
-    export default TransferableGridIndex;
-}
-
-declare module '@mapbox/vector-tile' {
-    import '@mapbox/vector-tile';
-
-    interface VectorTileLayer {
-        version?: number;
-        name: string;
-        extent: number;
-        length: number;
-        feature(i: number): VectorTileFeature;
-    }
-
-    class VectorTile {
-        constructor(pbf: Pbf);
-        layers: {[_: string]: VectorTileLayer};
-    }
-
-    class VectorTileFeature {
-        static types: ['Unknown', 'Point', 'LineString', 'Polygon'];
-        extent: number;
-        type: 1 | 2 | 3;
-        id: number;
-        properties: {[_: string]: string | number | boolean};
-        loadGeometry(): Array<Array<Point>>;
-        toGeoJSON(x: number, y: number, z: number): GeoJSON.Feature;
-    }
-
-    let __exports: {
-        VectorTile: typeof VectorTile;
-        VectorTileFeature: typeof VectorTileFeature;
-    };
-
-    export = __exports
-}