@loaders.gl/mvt 3.1.0-alpha.5 → 3.1.0-beta.5

package/dist/lib/binary-vector-tile/features-to-binary.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_EXPORTS = exports.featuresToBinary = void 0;
+/* eslint-disable indent */
+const polygon_1 = require("@math.gl/polygon");
+/**
+ * Convert binary features to flat binary arrays. Similar to
+ * `geojsonToBinary` helper function, except that it expects
+ * a binary representation of the feature data, which enables
+ * 2X-3X speed increase in parse speed, compared to using
+ * geoJSON. See `binary-vector-tile/VectorTileFeature` for
+ * data format detais
+ *
+ * @param features
+ * @param firstPassData
+ * @param options
+ * @returns filled arrays
+ */
+function featuresToBinary(features, firstPassData, options) {
+    return fillArrays(features, firstPassData, {
+        numericPropKeys: options ? options.numericPropKeys : extractNumericPropKeys(features),
+        PositionDataType: options ? options.PositionDataType : Float32Array
+    });
+}
+exports.featuresToBinary = featuresToBinary;
+exports.TEST_EXPORTS = {
+    extractNumericPropKeys,
+    fillArrays
+};
+/**
+ * Extracts properties that are always numeric
+ *
+ * @param features
+ * @returns object with numeric keys
+ */
+function extractNumericPropKeys(features) {
+    const numericPropKeys = {};
+    for (const feature of features) {
+        if (feature.properties) {
+            for (const key in feature.properties) {
+                // If property has not been seen before, or if property has been numeric
+                // in all previous features, check if numeric in this feature
+                // If not numeric, false is stored to prevent rechecking in the future
+                const numericSoFar = numericPropKeys[key];
+                if (numericSoFar || numericSoFar === undefined) {
+                    const val = feature.properties[key];
+                    numericPropKeys[key] = isNumeric(val);
+                }
+            }
+        }
+    }
+    return Object.keys(numericPropKeys).filter((k) => numericPropKeys[k]);
+}
+/**
+ * Fills coordinates into pre-allocated typed arrays
+ *
+ * @param features
+ * @param firstPassData
+ * @param options
+ * @returns an accessor object with value and size keys
+ */
+// eslint-disable-next-line complexity
+function fillArrays(features, firstPassData, options) {
+    const { pointPositionsCount, pointFeaturesCount, linePositionsCount, linePathsCount, lineFeaturesCount, polygonPositionsCount, polygonObjectsCount, polygonRingsCount, polygonFeaturesCount } = firstPassData;
+    const { numericPropKeys, PositionDataType = Float32Array } = options;
+    const hasGlobalId = features[0] && 'id' in features[0];
+    const coordLength = 2;
+    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+    const points = {
+        positions: new PositionDataType(pointPositionsCount * coordLength),
+        globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
+        featureIds: pointFeaturesCount > 65535
+            ? new Uint32Array(pointPositionsCount)
+            : new Uint16Array(pointPositionsCount),
+        numericProps: {},
+        properties: [],
+        fields: []
+    };
+    const lines = {
+        pathIndices: linePositionsCount > 65535
+            ? new Uint32Array(linePathsCount + 1)
+            : new Uint16Array(linePathsCount + 1),
+        positions: new PositionDataType(linePositionsCount * coordLength),
+        globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
+        featureIds: lineFeaturesCount > 65535
+            ? new Uint32Array(linePositionsCount)
+            : new Uint16Array(linePositionsCount),
+        numericProps: {},
+        properties: [],
+        fields: []
+    };
+    const polygons = {
+        polygonIndices: polygonPositionsCount > 65535
+            ? new Uint32Array(polygonObjectsCount + 1)
+            : new Uint16Array(polygonObjectsCount + 1),
+        primitivePolygonIndices: polygonPositionsCount > 65535
+            ? new Uint32Array(polygonRingsCount + 1)
+            : new Uint16Array(polygonRingsCount + 1),
+        positions: new PositionDataType(polygonPositionsCount * coordLength),
+        triangles: [],
+        globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+        featureIds: polygonFeaturesCount > 65535
+            ? new Uint32Array(polygonPositionsCount)
+            : new Uint16Array(polygonPositionsCount),
+        numericProps: {},
+        properties: [],
+        fields: []
+    };
+    // Instantiate numeric properties arrays; one value per vertex
+    for (const object of [points, lines, polygons]) {
+        for (const propName of numericPropKeys) {
+            // If property has been numeric in all previous features in which the property existed, check
+            // if numeric in this feature
+            object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);
+        }
+    }
+    // Set last element of path/polygon indices as positions length
+    lines.pathIndices[linePathsCount] = linePositionsCount;
+    polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
+    polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
+    const indexMap = {
+        pointPosition: 0,
+        pointFeature: 0,
+        linePosition: 0,
+        linePath: 0,
+        lineFeature: 0,
+        polygonPosition: 0,
+        polygonObject: 0,
+        polygonRing: 0,
+        polygonFeature: 0,
+        feature: 0
+    };
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        const properties = feature.properties || {};
+        switch (geometry.type) {
+            case 'Point':
+            case 'MultiPoint':
+                handlePoint(geometry, points, indexMap, coordLength, properties);
+                points.properties.push(keepStringProperties(properties, numericPropKeys));
+                if (hasGlobalId) {
+                    points.fields.push({ id: feature.id });
+                }
+                indexMap.pointFeature++;
+                break;
+            case 'LineString':
+            case 'MultiLineString':
+                handleLineString(geometry, lines, indexMap, coordLength, properties);
+                lines.properties.push(keepStringProperties(properties, numericPropKeys));
+                if (hasGlobalId) {
+                    lines.fields.push({ id: feature.id });
+                }
+                indexMap.lineFeature++;
+                break;
+            case 'Polygon':
+            case 'MultiPolygon':
+                handlePolygon(geometry, polygons, indexMap, coordLength, properties);
+                polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+                if (hasGlobalId) {
+                    polygons.fields.push({ id: feature.id });
+                }
+                indexMap.polygonFeature++;
+                break;
+            default:
+                throw new Error('Invalid geometry type');
+        }
+        indexMap.feature++;
+    }
+    // Wrap each array in an accessor object with value and size keys
+    return makeAccessorObjects(points, lines, polygons, coordLength);
+}
+/**
+ * Fills (Multi)Point coordinates into points object of arrays
+ *
+ * @param geometry
+ * @param points
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handlePoint(geometry, points, indexMap, coordLength, properties) {
+    points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
+    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    indexMap.pointPosition += nPositions;
+}
+/**
+ * Fills (Multi)LineString coordinates into lines object of arrays
+ *
+ * @param geometry
+ * @param lines
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handleLineString(geometry, lines, indexMap, coordLength, properties) {
+    lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
+    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    for (let i = 0, il = geometry.lines.length; i < il; ++i) {
+        // Extract range of data we are working with, defined by start
+        // and end indices (these index into the geometry.data array)
+        const start = geometry.lines[i];
+        const end = i === il - 1
+            ? geometry.data.length // last line, so read to end of data
+            : geometry.lines[i + 1]; // start index for next line
+        lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
+        indexMap.linePosition += (end - start) / coordLength;
+    }
+}
+/**
+ * Fills (Multi)Polygon coordinates into polygons object of arrays
+ *
+ * @param geometry
+ * @param polygons
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
+    polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
+    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    // Unlike Point & LineString geometry.lines is a 2D array
+    for (let l = 0, ll = geometry.lines.length; l < ll; ++l) {
+        const startPosition = indexMap.polygonPosition;
+        polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
+        const areas = geometry.areas[l];
+        const lines = geometry.lines[l];
+        const nextLines = geometry.lines[l + 1];
+        for (let i = 0, il = lines.length; i < il; ++i) {
+            const start = lines[i];
+            const end = i === il - 1
+                ? // last line, so either read to:
+                    nextLines === undefined
+                        ? geometry.data.length // end of data (no next lines)
+                        : nextLines[0] // start of first line in nextLines
+                : lines[i + 1]; // start index for next line
+            polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
+            indexMap.polygonPosition += (end - start) / coordLength;
+        }
+        const endPosition = indexMap.polygonPosition;
+        triangulatePolygon(polygons, areas, lines, { startPosition, endPosition, coordLength });
+    }
+}
+/**
+ * Triangulate polygon using earcut
+ *
+ * @param polygons
+ * @param areas
+ * @param lines
+ * @param param3
+ */
+function triangulatePolygon(polygons, areas, lines, { startPosition, endPosition, coordLength }) {
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    // Extract positions and holes for just this polygon
+    const polygonPositions = polygons.positions.subarray(start, end);
+    // Holes are referenced relative to outer polygon
+    const offset = lines[0];
+    const holes = lines.slice(1).map((n) => (n - offset) / coordLength);
+    // Compute triangulation
+    const indices = (0, polygon_1.earcut)(polygonPositions, holes, coordLength, areas);
+    // Indices returned by triangulation are relative to start
+    // of polygon, so we need to offset
+    for (let t = 0, tl = indices.length; t < tl; ++t) {
+        polygons.triangles.push(startPosition + indices[t]);
+    }
+}
+/**
+ * Wrap each array in an accessor object with value and size keys
+ *
+ * @param points
+ * @param lines
+ * @param polygons
+ * @param coordLength
+ * @returns object
+ */
+function makeAccessorObjects(points, lines, polygons, coordLength) {
+    const returnObj = {
+        points: {
+            ...points,
+            positions: { value: points.positions, size: coordLength },
+            globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
+            featureIds: { value: points.featureIds, size: 1 }
+        },
+        lines: {
+            ...lines,
+            pathIndices: { value: lines.pathIndices, size: 1 },
+            positions: { value: lines.positions, size: coordLength },
+            globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
+            featureIds: { value: lines.featureIds, size: 1 }
+        },
+        polygons: {
+            ...polygons,
+            polygonIndices: { value: polygons.polygonIndices, size: 1 },
+            primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
+            positions: { value: polygons.positions, size: coordLength },
+            triangles: { value: new Uint32Array(polygons.triangles), size: 1 },
+            globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
+            featureIds: { value: polygons.featureIds, size: 1 }
+        }
+    };
+    for (const geomType in returnObj) {
+        for (const numericProp in returnObj[geomType].numericProps) {
+            returnObj[geomType].numericProps[numericProp] = {
+                value: returnObj[geomType].numericProps[numericProp],
+                size: 1
+            };
+        }
+    }
+    return returnObj;
+}
+/**
+ * Add numeric properties to object
+ *
+ * @param object
+ * @param properties
+ * @param index
+ * @param length
+ */
+function fillNumericProperties(object, properties, index, length) {
+    for (const numericPropName in object.numericProps) {
+        if (numericPropName in properties) {
+            object.numericProps[numericPropName].fill(properties[numericPropName], index, index + length);
+        }
+    }
+}
+/**
+ * Keep string properties in object
+ *
+ * @param properties
+ * @param numericKeys
+ * @returns object
+ */
+function keepStringProperties(properties, numericKeys) {
+    const props = {};
+    for (const key in properties) {
+        if (!numericKeys.includes(key)) {
+            props[key] = properties[key];
+        }
+    }
+    return props;
+}
+function isNumeric(x) {
+    return Number.isFinite(x);
+}

package/dist/lib/binary-vector-tile/vector-tile-feature.d.ts

@@ -33,3 +33,4 @@ export default class VectorTileFeature {
         extent: any;
     }) => void)): MvtBinaryCoordinates;
 }
+//# sourceMappingURL=vector-tile-feature.d.ts.map

package/dist/lib/binary-vector-tile/vector-tile-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-vector-tile/vector-tile-feature.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,EAAC,oBAAoB,EAAE,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,UAAU,CAAC;AACrF,OAAO,EAAC,aAAa,EAAuB,MAAM,qCAAqC,CAAC;AAWxF,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,UAAU,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;KAAC,CAAC;IAC5D,MAAM,EAAE,GAAG,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;IAC9C,cAAc,EAAE,kBAAkB,CAAC;IACnC,MAAM,KAAK,KAAK,aAEf;gBAIC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,EAC5C,aAAa,EAAE,kBAAkB;IAmBnC,YAAY,IAAI,iBAAiB;IAqDjC;;;;OAIG;IACH,oBAAoB,CAAC,SAAS,KAAA;IA4E9B,mBAAmB,CACjB,OAAO,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,KAAK,IAAI,CAAC,GAC9F,oBAAoB;CAMxB"}

package/dist/lib/binary-vector-tile/vector-tile-feature.js

@@ -0,0 +1,159 @@
+"use strict";
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_EXPORTS = void 0;
+const binary_util_functions_1 = require("../../helpers/binary-util-functions");
+// Reduce GC by reusing variables
+let endPos;
+let cmd;
+let cmdLen;
+let length;
+let x;
+let y;
+let i;
+exports.TEST_EXPORTS = {
+    classifyRings: binary_util_functions_1.classifyRings
+};
+class VectorTileFeature {
+    // eslint-disable-next-line max-params
+    constructor(pbf, end, extent, keys, values, firstPassData) {
+        // Public
+        this.properties = {};
+        this.extent = extent;
+        this.type = 0;
+        this.id = null;
+        // Private
+        this._pbf = pbf;
+        this._geometry = -1;
+        this._keys = keys;
+        this._values = values;
+        this._firstPassData = firstPassData;
+        pbf.readFields(binary_util_functions_1.readFeature, this, end);
+    }
+    static get types() {
+        return ['Unknown', 'Point', 'LineString', 'Polygon'];
+    }
+    // eslint-disable-next-line complexity, max-statements
+    loadGeometry() {
+        const pbf = this._pbf;
+        pbf.pos = this._geometry;
+        endPos = pbf.readVarint() + pbf.pos;
+        cmd = 1;
+        length = 0;
+        x = 0;
+        y = 0;
+        i = 0;
+        // Note: I attempted to replace the `data` array with a
+        // Float32Array, but performance was worse, both using
+        // `set()` and direct index access. Also, we cannot
+        // know how large the buffer should be, so it would
+        // increase memory usage
+        const lines = []; // Indices where lines start
+        const data = []; // Flat array of coordinate data
+        while (pbf.pos < endPos) {
+            if (length <= 0) {
+                cmdLen = pbf.readVarint();
+                cmd = cmdLen & 0x7;
+                length = cmdLen >> 3;
+            }
+            length--;
+            if (cmd === 1 || cmd === 2) {
+                x += pbf.readSVarint();
+                y += pbf.readSVarint();
+                if (cmd === 1) {
+                    // New line
+                    lines.push(i);
+                }
+                data.push(x, y);
+                i += 2;
+            }
+            else if (cmd === 7) {
+                // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+                if (i > 0) {
+                    const start = lines[lines.length - 1]; // start index of polygon
+                    data.push(data[start], data[start + 1]); // closePolygon
+                    i += 2;
+                }
+            }
+            else {
+                throw new Error(`unknown command ${cmd}`);
+            }
+        }
+        return { data, lines };
+    }
+    /**
+     *
+     * @param transform
+     * @returns result
+     */
+    _toBinaryCoordinates(transform) {
+        // Expands the protobuf data to an intermediate `lines`
+        // data format, which maps closely to the binary data buffers.
+        // It is similar to GeoJSON, but rather than storing the coordinates
+        // in multidimensional arrays, we have a 1D `data` with all the
+        // coordinates, and then index into this using the `lines`
+        // parameter, e.g.
+        //
+        // geometry: {
+        //   type: 'Point', data: [1,2], lines: [0]
+        // }
+        // geometry: {
+        //   type: 'LineString', data: [1,2,3,4,...], lines: [0]
+        // }
+        // geometry: {
+        //   type: 'Polygon', data: [1,2,3,4,...], lines: [[0, 2]]
+        // }
+        // Thus the lines member lets us look up the relevant range
+        // from the data array.
+        // The Multi* versions of the above types share the same data
+        // structure, just with multiple elements in the lines array
+        let geom = this.loadGeometry();
+        // Apply the supplied transformation to data
+        transform(geom.data, this);
+        const coordLength = 2;
+        // eslint-disable-next-line default-case
+        switch (this.type) {
+            case 1: // Point
+                this._firstPassData.pointFeaturesCount++;
+                this._firstPassData.pointPositionsCount += geom.lines.length;
+                break;
+            case 2: // LineString
+                this._firstPassData.lineFeaturesCount++;
+                this._firstPassData.linePathsCount += geom.lines.length;
+                this._firstPassData.linePositionsCount += geom.data.length / coordLength;
+                break;
+            case 3: // Polygon
+                const classified = (0, binary_util_functions_1.classifyRings)(geom);
+                // Unlike Point & LineString geom.lines is a 2D array, thanks
+                // to the classifyRings method
+                this._firstPassData.polygonFeaturesCount++;
+                this._firstPassData.polygonObjectsCount += classified.lines.length;
+                for (const lines of classified.lines) {
+                    this._firstPassData.polygonRingsCount += lines.length;
+                }
+                this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
+                geom = classified;
+                break;
+        }
+        geom.type = VectorTileFeature.types[this.type];
+        if (geom.lines.length > 1) {
+            geom.type = `Multi${geom.type}`;
+        }
+        const result = {
+            type: 'Feature',
+            geometry: geom,
+            properties: this.properties
+        };
+        if (this.id !== null) {
+            result.id = this.id;
+        }
+        return result;
+    }
+    toBinaryCoordinates(options) {
+        if (typeof options === 'function') {
+            return this._toBinaryCoordinates(options);
+        }
+        return this._toBinaryCoordinates(binary_util_functions_1.project);
+    }
+}
+exports.default = VectorTileFeature;

package/dist/lib/binary-vector-tile/vector-tile-layer.d.ts

@@ -20,3 +20,4 @@ export default class VectorTileLayer {
      */
     feature(i: number, firstPassData: MvtFirstPassedData): VectorTileFeature;
 }
+//# sourceMappingURL=vector-tile-layer.d.ts.map

package/dist/lib/binary-vector-tile/vector-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile-layer.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-vector-tile/vector-tile-layer.ts"],"names":[],"mappings":"AAGA,OAAO,iBAAiB,MAAM,uBAAuB,CAAC;AACtD,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,EAAC,kBAAkB,EAAC,MAAM,UAAU,CAAC;AAE5C,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;IAC9C,SAAS,EAAE,MAAM,EAAE,CAAC;gBACR,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM;IAkBtC;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,kBAAkB,GAAG,iBAAiB;CAiBzE"}

package/dist/lib/binary-vector-tile/vector-tile-layer.js

@@ -0,0 +1,91 @@
+"use strict";
+/* eslint-disable indent */
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vector_tile_feature_1 = __importDefault(require("./vector-tile-feature"));
+class VectorTileLayer {
+    constructor(pbf, end) {
+        // Public
+        this.version = 1;
+        this.name = '';
+        this.extent = 4096;
+        this.length = 0;
+        // Private
+        this._pbf = pbf;
+        this._keys = [];
+        this._values = [];
+        this._features = [];
+        pbf.readFields(readLayer, this, end);
+        this.length = this._features.length;
+    }
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     *
+     * @param index
+     * @param firstPassData
+     * @returns {VectorTileFeature}
+     */
+    feature(i, firstPassData) {
+        if (i < 0 || i >= this._features.length) {
+            throw new Error('feature index out of bounds');
+        }
+        this._pbf.pos = this._features[i];
+        const end = this._pbf.readVarint() + this._pbf.pos;
+        return new vector_tile_feature_1.default(this._pbf, end, this.extent, this._keys, this._values, firstPassData);
+    }
+}
+exports.default = VectorTileLayer;
+/**
+ *
+ * @param tag
+ * @param layer
+ * @param pbf
+ */
+function readLayer(tag, layer, pbf) {
+    if (layer && pbf) {
+        if (tag === 15)
+            layer.version = pbf.readVarint();
+        else if (tag === 1)
+            layer.name = pbf.readString();
+        else if (tag === 5)
+            layer.extent = pbf.readVarint();
+        else if (tag === 2)
+            layer._features.push(pbf.pos);
+        else if (tag === 3)
+            layer._keys.push(pbf.readString());
+        else if (tag === 4)
+            layer._values.push(readValueMessage(pbf));
+    }
+}
+/**
+ *
+ * @param pbf
+ * @returns value
+ */
+function readValueMessage(pbf) {
+    let value = null;
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+        const tag = pbf.readVarint() >> 3;
+        value =
+            tag === 1
+                ? pbf.readString()
+                : tag === 2
+                    ? pbf.readFloat()
+                    : tag === 3
+                        ? pbf.readDouble()
+                        : tag === 4
+                            ? pbf.readVarint64()
+                            : tag === 5
+                                ? pbf.readVarint()
+                                : tag === 6
+                                    ? pbf.readSVarint()
+                                    : tag === 7
+                                        ? pbf.readBoolean()
+                                        : null;
+    }
+    return value;
+}

package/dist/lib/binary-vector-tile/vector-tile.d.ts

@@ -6,3 +6,4 @@ export default class VectorTile {
     };
     constructor(pbf: Protobuf, end?: number);
 }
+//# sourceMappingURL=vector-tile.d.ts.map

package/dist/lib/binary-vector-tile/vector-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-vector-tile/vector-tile.ts"],"names":[],"mappings":"AAEA,OAAO,eAAe,MAAM,qBAAqB,CAAC;AAClD,OAAO,QAAQ,MAAM,KAAK,CAAC;AAE3B,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,MAAM,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,eAAe,CAAA;KAAC,CAAC;gBAC3B,GAAG,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,MAAM;CAGxC"}

package/dist/lib/binary-vector-tile/vector-tile.js

@@ -0,0 +1,29 @@
+"use strict";
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vector_tile_layer_1 = __importDefault(require("./vector-tile-layer"));
+class VectorTile {
+    constructor(pbf, end) {
+        this.layers = pbf.readFields(readTile, {}, end);
+    }
+}
+exports.default = VectorTile;
+/**
+ *
+ * @param tag
+ * @param layers
+ * @param pbf
+ */
+function readTile(tag, layers, pbf) {
+    if (tag === 3) {
+        if (pbf) {
+            const layer = new vector_tile_layer_1.default(pbf, pbf.readVarint() + pbf.pos);
+            if (layer.length && layers) {
+                layers[layer.name] = layer;
+            }
+        }
+    }
+}

package/dist/lib/mapbox-vector-tile/vector-tile-feature.d.ts

@@ -24,3 +24,4 @@ export default class VectorTileFeature {
         extent: any;
     }) => void)): MvtMapboxCoordinates;
 }
+//# sourceMappingURL=vector-tile-feature.d.ts.map

package/dist/lib/mapbox-vector-tile/vector-tile-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/mapbox-vector-tile/vector-tile-feature.ts"],"names":[],"mappings":"AACA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,EAAC,oBAAoB,EAAE,iBAAiB,EAAC,MAAM,UAAU,CAAC;AAGjE,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,UAAU,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;KAAC,CAAC;IAC5D,MAAM,EAAE,GAAG,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;IAC9C,MAAM,KAAK,KAAK,aAEf;gBAGC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE;IAkB9C,YAAY,IAAI,iBAAiB;IA+CjC,IAAI;IAsCJ,UAAU,CAAC,SAAS,KAAA;IAuDpB,SAAS,CACP,OAAO,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,KAAK,IAAI,CAAC,GAC9F,oBAAoB;CAmBxB"}