@loaders.gl/mvt 3.1.0-alpha.4 → 3.1.0-beta.3

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

@@ -0,0 +1,27 @@
+import Protobuf from 'pbf';
+import { MvtMapboxCoordinates, MvtMapboxGeometry } from '../types';
+export default class VectorTileFeature {
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    extent: any;
+    type: number;
+    id: number | null;
+    _pbf: Protobuf;
+    _geometry: number;
+    _keys: string[];
+    _values: (string | number | boolean | null)[];
+    static get types(): string[];
+    constructor(pbf: Protobuf, end: number, extent: any, keys: string[], values: (string | number | boolean | null)[]);
+    loadGeometry(): MvtMapboxGeometry;
+    bbox(): number[];
+    _toGeoJSON(transform: any): MvtMapboxCoordinates;
+    toGeoJSON(options: {
+        x: number;
+        y: number;
+        z: number;
+    } | ((data: number[], feature: {
+        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"}

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

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapbox_util_functions_1 = require("../../helpers/mapbox-util-functions");
+class VectorTileFeature {
+    constructor(pbf, end, extent, keys, values) {
+        // 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;
+        pbf.readFields(mapbox_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;
+        const end = pbf.readVarint() + pbf.pos;
+        let cmd = 1;
+        let length = 0;
+        let x = 0;
+        let y = 0;
+        const lines = [];
+        let line;
+        while (pbf.pos < end) {
+            if (length <= 0) {
+                const cmdLen = pbf.readVarint();
+                cmd = cmdLen & 0x7;
+                length = cmdLen >> 3;
+            }
+            length--;
+            if (cmd === 1 || cmd === 2) {
+                x += pbf.readSVarint();
+                y += pbf.readSVarint();
+                if (cmd === 1) {
+                    // moveTo
+                    if (line)
+                        lines.push(line);
+                    line = [];
+                }
+                if (line)
+                    line.push([x, y]);
+            }
+            else if (cmd === 7) {
+                // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+                if (line) {
+                    line.push(line[0].slice()); // closePolygon
+                }
+            }
+            else {
+                throw new Error(`unknown command ${cmd}`);
+            }
+        }
+        if (line)
+            lines.push(line);
+        return lines;
+    }
+    // eslint-disable-next-line max-statements
+    bbox() {
+        const pbf = this._pbf;
+        pbf.pos = this._geometry;
+        const end = pbf.readVarint() + pbf.pos;
+        let cmd = 1;
+        let length = 0;
+        let x = 0;
+        let y = 0;
+        let x1 = Infinity;
+        let x2 = -Infinity;
+        let y1 = Infinity;
+        let y2 = -Infinity;
+        while (pbf.pos < end) {
+            if (length <= 0) {
+                const cmdLen = pbf.readVarint();
+                cmd = cmdLen & 0x7;
+                length = cmdLen >> 3;
+            }
+            length--;
+            if (cmd === 1 || cmd === 2) {
+                x += pbf.readSVarint();
+                y += pbf.readSVarint();
+                if (x < x1)
+                    x1 = x;
+                if (x > x2)
+                    x2 = x;
+                if (y < y1)
+                    y1 = y;
+                if (y > y2)
+                    y2 = y;
+            }
+            else if (cmd !== 7) {
+                throw new Error(`unknown command ${cmd}`);
+            }
+        }
+        return [x1, y1, x2, y2];
+    }
+    _toGeoJSON(transform) {
+        let coords = this.loadGeometry();
+        let type = VectorTileFeature.types[this.type];
+        let i;
+        let j;
+        // eslint-disable-next-line default-case
+        switch (this.type) {
+            case 1:
+                const points = [];
+                for (i = 0; i < coords.length; i++) {
+                    points[i] = coords[i][0];
+                }
+                coords = points;
+                transform(coords, this);
+                break;
+            case 2:
+                for (i = 0; i < coords.length; i++) {
+                    transform(coords[i], this);
+                }
+                break;
+            case 3:
+                coords = (0, mapbox_util_functions_1.classifyRings)(coords);
+                for (i = 0; i < coords.length; i++) {
+                    for (j = 0; j < coords[i].length; j++) {
+                        transform(coords[i][j], this);
+                    }
+                }
+                break;
+        }
+        if (coords.length === 1) {
+            coords = coords[0];
+        }
+        else {
+            type = `Multi${type}`;
+        }
+        const result = {
+            type: 'Feature',
+            geometry: {
+                type,
+                coordinates: coords
+            },
+            properties: this.properties
+        };
+        if (this.id !== null) {
+            result.id = this.id;
+        }
+        return result;
+    }
+    toGeoJSON(options) {
+        if (typeof options === 'function') {
+            return this._toGeoJSON(options);
+        }
+        const { x, y, z } = options;
+        const size = this.extent * Math.pow(2, z);
+        const x0 = this.extent * x;
+        const y0 = this.extent * y;
+        function project(line) {
+            for (let j = 0; j < line.length; j++) {
+                const p = line[j];
+                p[0] = ((p[0] + x0) * 360) / size - 180;
+                const y2 = 180 - ((p[1] + y0) * 360) / size;
+                p[1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
+            }
+        }
+        return this._toGeoJSON(project);
+    }
+}
+exports.default = VectorTileFeature;

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

@@ -0,0 +1,20 @@
+import Protobuf from 'pbf';
+import VectorTileFeature from './vector-tile-feature';
+export default class VectorTileLayer {
+    version: number;
+    name: string;
+    extent: number;
+    length: number;
+    _pbf: Protobuf;
+    _keys: string[];
+    _values: (string | number | boolean | null)[];
+    _features: number[];
+    constructor(pbf: Protobuf, end: number);
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     * @param index
+     * @returns feature
+     */
+    feature(i: number): VectorTileFeature;
+}
+//# sourceMappingURL=vector-tile-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile-layer.d.ts","sourceRoot":"","sources":["../../../src/lib/mapbox-vector-tile/vector-tile-layer.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,iBAAiB,MAAM,uBAAuB,CAAC;AAEtD,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;;;;OAIG;IAEH,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,iBAAiB;CAUtC"}

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

@@ -0,0 +1,89 @@
+"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
+     * @returns feature
+     */
+    feature(i) {
+        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);
+    }
+}
+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/mapbox-vector-tile/vector-tile.d.ts

@@ -0,0 +1,9 @@
+import VectorTileLayer from './vector-tile-layer';
+import Protobuf from 'pbf';
+export default class VectorTile {
+    layers: {
+        [x: string]: VectorTileLayer;
+    };
+    constructor(pbf: Protobuf, end?: number);
+}
+//# sourceMappingURL=vector-tile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/mapbox-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/mapbox-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/parse-mvt.d.ts

@@ -0,0 +1,85 @@
+import { MvtBinaryCoordinates, MvtMapboxCoordinates } from '../lib/types';
+import { LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * Parse MVT arrayBuffer and return GeoJSON.
+ *
+ * @param arrayBuffer A MVT arrayBuffer
+ * @param options
+ * @returns A GeoJSON geometry object or a binary representation
+ */
+export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions): {
+    points: {
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    lines: {
+        pathIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    polygons: {
+        polygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        primitivePolygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        triangles: {
+            value: Uint32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+} | (MvtBinaryCoordinates | MvtMapboxCoordinates)[];
+//# sourceMappingURL=parse-mvt.d.ts.map

package/dist/lib/parse-mvt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-mvt.d.ts","sourceRoot":"","sources":["../../src/lib/parse-mvt.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,oBAAoB,EAAE,oBAAoB,EAAa,MAAM,cAAc,CAAC;AAGpF,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAyDjF"}

package/dist/lib/parse-mvt.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// import {VectorTile} from '@mapbox/vector-tile';
+const vector_tile_1 = __importDefault(require("./mapbox-vector-tile/vector-tile"));
+const vector_tile_2 = __importDefault(require("./binary-vector-tile/vector-tile"));
+const features_to_binary_1 = require("./binary-vector-tile/features-to-binary");
+const pbf_1 = __importDefault(require("pbf"));
+/**
+ * Parse MVT arrayBuffer and return GeoJSON.
+ *
+ * @param arrayBuffer A MVT arrayBuffer
+ * @param options
+ * @returns A GeoJSON geometry object or a binary representation
+ */
+function parseMVT(arrayBuffer, options) {
+    options = normalizeOptions(options);
+    const features = [];
+    if (options) {
+        const binary = options.gis.format === 'binary';
+        const firstPassData = {
+            pointPositionsCount: 0,
+            pointFeaturesCount: 0,
+            linePositionsCount: 0,
+            linePathsCount: 0,
+            lineFeaturesCount: 0,
+            polygonPositionsCount: 0,
+            polygonObjectsCount: 0,
+            polygonRingsCount: 0,
+            polygonFeaturesCount: 0
+        };
+        if (arrayBuffer.byteLength > 0) {
+            const tile = binary
+                ? new vector_tile_2.default(new pbf_1.default(arrayBuffer))
+                : new vector_tile_1.default(new pbf_1.default(arrayBuffer));
+            const loaderOptions = options.mvt;
+            const selectedLayers = Array.isArray(loaderOptions.layers)
+                ? loaderOptions.layers
+                : Object.keys(tile.layers);
+            selectedLayers.forEach((layerName) => {
+                const vectorTileLayer = tile.layers[layerName];
+                const featureOptions = { ...loaderOptions, layerName };
+                if (!vectorTileLayer) {
+                    return;
+                }
+                for (let i = 0; i < vectorTileLayer.length; i++) {
+                    const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);
+                    const decodedFeature = binary
+                        ? getDecodedFeatureBinary(vectorTileFeature, featureOptions)
+                        : getDecodedFeature(vectorTileFeature, featureOptions);
+                    features.push(decodedFeature);
+                }
+            });
+        }
+        if (binary) {
+            const data = (0, features_to_binary_1.featuresToBinary)(features, firstPassData);
+            // Add the original byteLength (as a reasonable approximation of the size of the binary data)
+            // TODO decide where to store extra fields like byteLength (header etc) and document
+            // @ts-ignore
+            data.byteLength = arrayBuffer.byteLength;
+            return data;
+        }
+    }
+    return features;
+}
+exports.default = parseMVT;
+/**
+ * @param options
+ * @returns options
+ */
+function normalizeOptions(options) {
+    if (options) {
+        options = {
+            ...options,
+            mvt: options.mvt || {},
+            gis: options.gis || {}
+        };
+        // Validate
+        const wgs84Coordinates = options.coordinates === 'wgs84';
+        const { tileIndex } = options;
+        const hasTileIndex = tileIndex &&
+            Number.isFinite(tileIndex.x) &&
+            Number.isFinite(tileIndex.y) &&
+            Number.isFinite(tileIndex.z);
+        if (wgs84Coordinates && !hasTileIndex) {
+            throw new Error('MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.');
+        }
+    }
+    return options;
+}
+/**
+ * @param feature
+ * @param options
+ * @returns decoded feature
+ */
+function getDecodedFeature(feature, options) {
+    const decodedFeature = feature.toGeoJSON(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates);
+    // Add layer name to GeoJSON properties
+    if (options.layerProperty) {
+        decodedFeature.properties[options.layerProperty] = options.layerName;
+    }
+    return decodedFeature;
+}
+/**
+ * @param feature
+ * @param options
+ * @returns decoded binary feature
+ */
+function getDecodedFeatureBinary(feature, options) {
+    const decodedFeature = feature.toBinaryCoordinates(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary);
+    // Add layer name to GeoJSON properties
+    if (options.layerProperty) {
+        decodedFeature.properties[options.layerProperty] = options.layerName;
+    }
+    return decodedFeature;
+}
+/**
+ * @param line
+ * @param feature
+ */
+function transformToLocalCoordinates(line, feature) {
+    // This function transforms local coordinates in a
+    // [0 - bufferSize, this.extent + bufferSize] range to a
+    // [0 - (bufferSize / this.extent), 1 + (bufferSize / this.extent)] range.
+    // The resulting extent would be 1.
+    const { extent } = feature;
+    for (let i = 0; i < line.length; i++) {
+        const p = line[i];
+        p[0] /= extent;
+        p[1] /= extent;
+    }
+}
+function transformToLocalCoordinatesBinary(data, feature) {
+    // For the binary code path, the feature data is just
+    // one big flat array, so we just divide each value
+    const { extent } = feature;
+    for (let i = 0, il = data.length; i < il; ++i) {
+        data[i] /= extent;
+    }
+}