@mapgis/vector-tile 16.6.0

package/.eslintrc

@@ -0,0 +1,3 @@
+{
+  "extends": "eslint-config-unstyled"
+}

package/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+sudo: false
+node_js:
+  - 4
+script:
+  - npm test
+  - npm run cov

package/CHANGELOG.md

@@ -0,0 +1,41 @@
+## vector-tile-js changelog
+
+### 1.3.1 (2017-03-02)
+
+- Fix bug causing infinite loop when parsing ClosePath command (#61) h/t @sanjin-saric
+- Pin node-mapnik dependency to `~3.6.0` (#62, see also https://github.com/mapnik/node-mapnik/issues/848)
+
+### 1.3.0 (2016-07-18)
+
+- Added "id" property to VectorTileFeature (#43)
+
+### 1.2.1 (2016-05-18)
+
+- Fixed geometry structure of MultiPoints, Polygons, and MultiPolygons in toGeoJSON()
+
+### 1.2.0 (2015-12-10)
+
+- Added "id" property to toGeoJSON() output
+
+### 1.1.3 (2015-06-15)
+
+- Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+
+### 1.1.2 (2015-03-05)
+
+- Fixed decoding of negative values in feature properties
+
+### 1.1.1 (2015-02-25)
+
+- Remove sphericalmercator dependency
+- Correctly handle MultiPoint and MultiLineString features in toGeoJSON()
+
+### 1.1.0 (2015-02-21)
+
+- Added VectorTileFeature#toGeoJSON()
+
+### 1.0.0 (2014-12-26)
+
+### 0.0.1 (2014-04-13)
+
+- Initial release

package/LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright (c) 2014, Mapbox
+
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of Mapbox nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,104 @@
+# vector-tile
+
+[![build status](https://secure.travis-ci.org/mapbox/vector-tile-js.svg)](http://travis-ci.org/mapbox/vector-tile-js) [![Coverage Status](https://coveralls.io/repos/mapbox/vector-tile-js/badge.svg)](https://coveralls.io/r/mapbox/vector-tile-js)
+
+This library reads [Mapbox Vector Tiles](https://github.com/mapbox/vector-tile-spec) and allows access to the layers and features.
+
+## Example
+
+```js
+var VectorTile = require('@mapbox/vector-tile').VectorTile;
+var Protobuf = require('pbf');
+
+var tile = new VectorTile(new Protobuf(data));
+
+// Contains a map of all layers
+tile.layers;
+
+var landuse = tile.layers.landuse;
+
+// Amount of features in this layer
+landuse.length;
+
+// Returns the first feature
+landuse.feature(0);
+```
+
+Vector tiles contained in [serialtiles-spec](https://github.com/mapbox/serialtiles-spec)
+are gzip-encoded, so a complete example of parsing them with the native
+zlib module would be:
+
+```js
+var VectorTile = require('vector-tile').VectorTile;
+var Protobuf = require('pbf');
+var zlib = require('zlib');
+
+zlib.gunzip(data, function(err, buffer) {
+    var tile = new VectorTile(new Protobuf(buffer));
+});
+```
+
+## Depends
+
+ - Node.js v0.10.x or v0.8.x
+
+
+## Install
+
+To install:
+
+    npm install @mapbox/vector-tile
+
+
+## API Reference
+
+
+### VectorTile
+
+An object that parses vector tile data and makes it readable.
+
+#### Constructor
+
+- **new VectorTile(protobuf[, end])** —
+  parses the vector tile data contained in the given [Protobuf](https://github.com/mapbox/pbf) object,
+  saving resulting layers in the created object as a `layers` property. Optionally accepts end index.
+
+#### Properties
+
+- **layers** (Object) &mdash; an object containing parsed layers in the form of `{<name>: <layer>, ...}`,
+where each layer is a `VectorTileLayer` object.
+
+
+### VectorTileLayer
+
+An object that contains the data for a single vector tile layer.
+
+#### Properties
+
+- **version** (`Number`, default: `1`)
+- **name** (`String) `&mdash; layer name
+- **extent** (`Number`, default: `4096`) &mdash; tile extent size
+- **length** (`Number`) &mdash; number of features in the layer
+
+#### Methods
+
+- **feature(i)** &mdash; get a feature (`VectorTileFeature`) by the given index from the layer.
+
+
+### VectorTileFeature
+
+An object that contains the data for a single feature.
+
+#### Properties
+
+- **type** (`Number`) &mdash; type of the feature (also see `VectorTileFeature.types`)
+- **extent** (`Number`) &mdash; feature extent size
+- **id** (`Number`) &mdash; feature identifier, if present
+- **properties** (`Object`) &mdash; object literal with feature properties
+
+#### Methods
+
+- **loadGeometry()** &mdash; parses feature geometry and returns an array of
+  [Point](https://github.com/mapbox/point-geometry) arrays (with each point having `x` and `y` properties)
+- **bbox()** &mdash; calculates and returns the bounding box of the feature in the form `[x1, y1, x2, y2]`
+- **toGeoJSON(x, y, z)** &mdash; returns a GeoJSON representation of the feature. (`x`, `y`, and `z` refer to the containing tile's index.)

package/fixtures.js

@@ -0,0 +1,157 @@
+var mapnik = require('mapnik');
+var path = require('path');
+var fs = require('fs');
+
+mapnik.register_datasource(path.join(mapnik.settings.paths.input_plugins, 'geojson.input'));
+
+var fixtures = {
+    "zero-point": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPoint",
+                    "coordinates": []
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "zero-line": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiLineString",
+                    "coordinates": []
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "zero-polygon": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPolygon",
+                    "coordinates": []
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "singleton-multi-point": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPoint",
+                    "coordinates": [[1, 2]]
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "singleton-multi-line": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiLineString",
+                    "coordinates": [[[1, 2], [3, 4]]]
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "singleton-multi-polygon": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPolygon",
+                    "coordinates": [[[[0, 0], [1, 0], [1, 1], [0, 0]]]]
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "multi-point": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPoint",
+                    "coordinates": [[1, 2], [3, 4]]
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "multi-line": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiLineString",
+                    "coordinates": [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "multi-polygon": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPolygon",
+                    "coordinates": [[[[0, 0], [1, 0], [1, 1], [0, 0]]], [[[0, 0], [-1, 0], [-1, -1], [0, 0]]]]
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "polygon-with-inner": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Polygon",
+                    "coordinates": [[[-2, 2], [2, 2], [2, -2], [-2, -2], [-2, 2]], [[-1, 1], [1, 1], [1, -1], [-1, -1], [-1, 1]]]
+                },
+                "properties": {}
+            }
+        ]
+    },
+    "stacked-multipolygon": {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPolygon",
+                    "coordinates": [[[[-2, 2], [2, 2], [2, -2], [-2, -2], [-2, 2]]], [[[-1, 1], [1, 1], [1, -1], [-1, -1], [-1, 1]]]]
+                },
+                "properties": {}
+            }
+        ]
+    }
+}
+
+for (var fixture in fixtures) {
+    var vtile = new mapnik.VectorTile(0, 0, 0);
+    vtile.addGeoJSON(JSON.stringify(fixtures[fixture]), "geojson");
+    fs.writeFileSync('./test/fixtures/' + fixture + '.pbf', vtile.getData());
+}

package/index.js

@@ -0,0 +1,3 @@
+module.exports.VectorTile = require('./lib/vectortile.js');
+module.exports.VectorTileFeature = require('./lib/vectortilefeature.js');
+module.exports.VectorTileLayer = require('./lib/vectortilelayer.js');

package/lib/vectortile.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var VectorTileLayer = require('./vectortilelayer');
+
+module.exports = VectorTile;
+
+function VectorTile(pbf, end) {
+    this.layers = pbf.readFields(readTile, {}, end);
+}
+
+function readTile(tag, layers, pbf) {
+    if (tag === 3) {
+        var layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+        if (layer.length) layers[layer.name] = layer;
+    }
+}
+

package/lib/vectortilefeature.js

@@ -0,0 +1,245 @@
+'use strict';
+
+var Point = require('@mapbox/point-geometry');
+
+module.exports = VectorTileFeature;
+
+function VectorTileFeature(pbf, end, extent, keys, values) {
+    // Public
+    this.properties = {};
+    this.extent = extent;
+    this.type = 0;
+
+    // Private
+    this._pbf = pbf;
+    this._geometry = -1;
+    this._keys = keys;
+    this._values = values;
+
+    pbf.readFields(readFeature, this, end);
+}
+
+function readFeature(tag, feature, pbf) {
+    if (tag == 1) feature.id = pbf.readVarint();
+    else if (tag == 2) readTag(pbf, feature);
+    else if (tag == 3) feature.type = pbf.readVarint();
+    else if (tag == 4) feature._geometry = pbf.pos;
+}
+
+function readTag(pbf, feature) {
+    var end = pbf.readVarint() + pbf.pos;
+
+    while (pbf.pos < end) {
+        var key = feature._keys[pbf.readVarint()],
+            value = feature._values[pbf.readVarint()];
+        feature.properties[key] = value;
+    }
+}
+
+VectorTileFeature.types = ['Unknown', 'Point', 'LineString', 'Polygon'];
+
+VectorTileFeature.prototype.loadGeometry = function() {
+    var pbf = this._pbf;
+    pbf.pos = this._geometry;
+
+    var end = pbf.readVarint() + pbf.pos,
+        cmd = 1,
+        length = 0,
+        x = 0,
+        y = 0,
+        lines = [],
+        line;
+
+    while (pbf.pos < end) {
+        if (length <= 0) {
+            var 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 = [];
+            }
+
+            line.push(new Point(x, y));
+
+        } else if (cmd === 7) {
+
+            // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+            if (line) {
+                line.push(line[0].clone()); // closePolygon
+            }
+
+        } else {
+            throw new Error('unknown command ' + cmd);
+        }
+    }
+
+    if (line) lines.push(line);
+
+    return lines;
+};
+
+VectorTileFeature.prototype.bbox = function() {
+    var pbf = this._pbf;
+    pbf.pos = this._geometry;
+
+    var end = pbf.readVarint() + pbf.pos,
+        cmd = 1,
+        length = 0,
+        x = 0,
+        y = 0,
+        x1 = Infinity,
+        x2 = -Infinity,
+        y1 = Infinity,
+        y2 = -Infinity;
+
+    while (pbf.pos < end) {
+        if (length <= 0) {
+            var 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];
+};
+
+VectorTileFeature.prototype.toGeoJSON = function(x, y, z, epsg) {
+    console.log('epsg', epsg);
+    epsg = epsg || 'EPSG:3857' // EPSG:4326 or  EPSG:3857
+    var size = this.extent * Math.pow(2, z),
+        x0 = this.extent * x,
+        y0 = this.extent * y,
+        coords = this.loadGeometry(),
+        type = VectorTileFeature.types[this.type],
+        i, j;
+
+    function project(line) {
+        if (epsg === 'EPSG:3857') {
+            for (var j = 0; j < line.length; j++) {
+                var p = line[j], y2 = 180 - (p.y + y0) * 360 / size;
+                line[j] = [
+                    (p.x + x0) * 360 / size - 180,
+                    360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90
+                ];
+            }
+        } else if (epsg === 'EPSG:4326') {
+            for (var j = 0; j < line.length; j++) {
+                var p = line[j]
+                line[j] = [
+                    (p.x + x0) * 360 / size - 180,
+                    90 - (p.y + y0) * 360 / size ,
+                ];
+            }
+        }
+    }
+
+    switch (this.type) {
+    case 1:
+        var points = [];
+        for (i = 0; i < coords.length; i++) {
+            points[i] = coords[i][0];
+        }
+        coords = points;
+        project(coords);
+        break;
+
+    case 2:
+        for (i = 0; i < coords.length; i++) {
+            project(coords[i]);
+        }
+        break;
+
+    case 3:
+        coords = classifyRings(coords);
+        for (i = 0; i < coords.length; i++) {
+            for (j = 0; j < coords[i].length; j++) {
+                project(coords[i][j]);
+            }
+        }
+        break;
+    }
+
+    if (coords.length === 1) {
+        coords = coords[0];
+    } else {
+        type = 'Multi' + type;
+    }
+
+    var result = {
+        type: "Feature",
+        geometry: {
+            type: type,
+            coordinates: coords
+        },
+        properties: this.properties
+    };
+
+    if ('id' in this) {
+        result.id = this.id;
+    }
+
+    return result;
+};
+
+// classifies an array of rings into polygons with outer rings and holes
+
+function classifyRings(rings) {
+    var len = rings.length;
+
+    if (len <= 1) return [rings];
+
+    var polygons = [],
+        polygon,
+        ccw;
+
+    for (var i = 0; i < len; i++) {
+        var area = signedArea(rings[i]);
+        if (area === 0) continue;
+
+        if (ccw === undefined) ccw = area < 0;
+
+        if (ccw === area < 0) {
+            if (polygon) polygons.push(polygon);
+            polygon = [rings[i]];
+
+        } else {
+            polygon.push(rings[i]);
+        }
+    }
+    if (polygon) polygons.push(polygon);
+
+    return polygons;
+}
+
+function signedArea(ring) {
+    var sum = 0;
+    for (var i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
+        p1 = ring[i];
+        p2 = ring[j];
+        sum += (p2.x - p1.x) * (p1.y + p2.y);
+    }
+    return sum;
+}

package/lib/vectortilelayer.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var VectorTileFeature = require('./vectortilefeature.js');
+
+module.exports = VectorTileLayer;
+
+function VectorTileLayer(pbf, end) {
+    // Public
+    this.version = 1;
+    this.name = null;
+    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;
+}
+
+function readLayer(tag, 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));
+}
+
+function readValueMessage(pbf) {
+    var value = null,
+        end = pbf.readVarint() + pbf.pos;
+
+    while (pbf.pos < end) {
+        var 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;
+}
+
+// return feature `i` from this layer as a `VectorTileFeature`
+VectorTileLayer.prototype.feature = function(i) {
+    if (i < 0 || i >= this._features.length) throw new Error('feature index out of bounds');
+
+    this._pbf.pos = this._features[i];
+
+    var end = this._pbf.readVarint() + this._pbf.pos;
+    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mapgis/vector-tile",
+  "description": "Parses vector tiles",
+  "repository": "https://github.com/mapbox/vector-tile-js.git",
+"version":"16.6.0",
+  "license": "BSD-3-Clause",
+  "main": "index.js",
+  "dependencies": {
+    "@mapbox/point-geometry": "~0.1.0"
+  },
+  "devDependencies": {
+    "benchmark": "^1.0.0",
+    "coveralls": "~2.11.2",
+    "istanbul": "~0.3.6",
+    "mapnik": "~3.6.0",
+    "jshint": "^2.6.3",
+    "pbf": "^1.3.2",
+    "tape": "~3.5.0",
+    "eslint": "~1.00.0",
+    "eslint-config-unstyled": "^1.1.0"
+  },
+  "jshintConfig": {
+    "trailing": true,
+    "undef": true,
+    "unused": true,
+    "indent": 4,
+    "node": true
+  },
+  "scripts": {
+    "test": "eslint lib index.js && jshint lib && tape test/parse.test.js",
+    "cov": "istanbul cover ./node_modules/.bin/tape test/parse.test.js && coveralls < ./coverage/lcov.info"
+  }
+}

package/proto/vector_tile.proto

@@ -0,0 +1,88 @@
+// Protocol Version 1
+
+message tile {
+    enum GeomType {
+        Unknown = 0;
+        Point = 1;
+        LineString = 2;
+        Polygon = 3;
+    }
+
+    // Variant type encoding
+    message value {
+        // Exactly one of these values may be present in a valid message
+        optional string string_value = 1;
+        optional float float_value = 2;
+        optional double double_value = 3;
+        optional int64 int_value = 4;
+        optional uint64 uint_value = 5;
+        optional sint64 sint_value = 6;
+        optional bool bool_value = 7;
+
+        extensions 8 to max;
+    }
+
+    message feature {
+        optional uint64 id = 1;
+
+        // Tags of this feature. Even numbered values refer to the nth
+        // value in the keys list on the tile message, odd numbered
+        // values refer to the nth value in the values list on the tile
+        // message.
+        repeated uint32 tags = 2 [ packed = true ];
+
+        // The type of geometry stored in this feature.
+        optional GeomType type = 3 [ default = Unknown ];
+
+        // Contains a stream of commands and parameters (vertices). The
+        // repeat count is shifted to the left by 3 bits. This means
+        // that the command has 3 bits (0-7). The repeat count
+        // indicates how often this command is to be repeated. Defined
+        // commands are:
+        // - MoveTo:    1   (2 parameters follow)
+        // - LineTo:    2   (2 parameters follow)
+        // - ClosePath: 7   (no parameters follow)
+        //
+        // Ex.: MoveTo(3, 6), LineTo(8, 12), LineTo(20, 34), ClosePath
+        // Encoded as: [ 9 3 6 18 5 6 12 22 15 ]
+        //                                  == command type 7 (ClosePath), length 1
+        //                             ===== relative LineTo(+12, +22) == LineTo(20, 34)
+        //                         === relative LineTo(+5, +6) == LineTo(8, 12)
+        //                      == [00010 010] = command type 2 (LineTo), length 2
+        //                  === relative MoveTo(+3, +6)
+        //              == [00001 001] = command type 1 (MoveTo), length 1
+        // Commands are encoded as uint32 varints, vertex parameters are
+        // encoded as sint32 varints (zigzag). Vertex parameters are
+        // also encoded as deltas to the previous position. The original
+        // position is (0,0)
+        repeated uint32 geometry = 4 [ packed = true ];
+    }
+
+    message layer {
+        // Any compliant implementation must first read the version
+        // number encoded in this message and choose the correct
+        // implementation for this version number before proceeding to
+        // decode other parts of this message.
+        required uint32 version = 15 [ default = 1 ];
+
+        required string name = 1;
+
+        // The actual features in this tile.
+        repeated feature features = 2;
+
+        // Dictionary encoding for keys
+        repeated string keys = 3;
+
+        // Dictionary encoding for values
+        repeated value values = 4;
+
+        // The bounding box in this tile spans from 0..4095 units
+        optional uint32 extent = 5 [ default = 4096 ];
+
+        extensions 16 to max;
+    }
+
+    repeated layer layers = 3;
+
+    extensions 16 to 8191;
+}

package/test/bench.js

@@ -0,0 +1,36 @@
+var Pbf = require('pbf'),
+    VectorTile = require('..').VectorTile,
+    Benchmark = require('benchmark'),
+    fs = require('fs');
+
+var suite = new Benchmark.Suite(),
+    data = fs.readFileSync(__dirname + '/fixtures/14-8801-5371.vector.Pbf');
+
+readTile(); // output any errors before running the suite
+readTile(true);
+
+suite
+.add('read tile with geometries', function() {
+    readTile(true);
+})
+.add('read tile without geometries', function() {
+    readTile();
+})
+.on('cycle', function(event) {
+    console.log(String(event.target));
+})
+.run();
+
+
+function readTile(loadGeom, loadPacked) {
+    var buf = new Pbf(data),
+        vt = new VectorTile(buf);
+
+    for (var id in vt.layers) {
+        var layer = vt.layers[id];
+        for (var i = 0; i < layer.length; i++) {
+            var feature = layer.feature(i);
+            if (loadGeom) feature.loadGeometry();
+        }
+    }
+}

package/test/fixtures/multi-line.pbf

@@ -0,0 +1,4 @@
+$x
+geojson(� "	� �
+.-	.+
+.-

package/test/fixtures/multi-point.pbf

@@ -0,0 +1,2 @@
+x
+geojson(� 

package/test/fixtures/singleton-multi-line.pbf

@@ -0,0 +1,3 @@
+x
+geojson(� "	� �
+.-

package/test/fixtures/singleton-multi-point.pbf

@@ -0,0 +1,2 @@
+x
+geojson(� 
"	� �

package/test/parse.test.js

@@ -0,0 +1,225 @@
+var test = require('tape'),
+    fs = require('fs'),
+    Protobuf = require('pbf'),
+    VectorTile = require('..').VectorTile,
+    VectorTileLayer = require('..').VectorTileLayer,
+    VectorTileFeature = require('..').VectorTileFeature;
+
+function approximateDeepEqual(a, b, epsilon) {
+    epsilon = epsilon || 1e-6;
+
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a === 'number')
+        return Math.abs(a - b) < epsilon;
+    if (a === null || typeof a !== 'object')
+        return a === b;
+
+    var ka = Object.keys(a);
+    var kb = Object.keys(b);
+
+    if (ka.length != kb.length)
+        return false;
+
+    ka.sort();
+    kb.sort();
+
+    for (var i = 0; i < ka.length; i++)
+        if (ka[i] != kb[i] || !approximateDeepEqual(a[ka[i]], b[ka[i]], epsilon))
+            return false;
+
+    return true;
+}
+
+test('parsing vector tiles', function(t) {
+    var data = fs.readFileSync(__dirname + '/fixtures/14-8801-5371.vector.pbf');
+
+    t.test('should have all layers', function(t) {
+        var tile = new VectorTile(new Protobuf(data));
+
+        t.deepEqual(Object.keys(tile.layers), [
+            'landuse', 'waterway', 'water', 'barrier_line', 'building',
+            'landuse_overlay', 'tunnel', 'road', 'bridge', 'place_label',
+            'water_label', 'poi_label', 'road_label', 'waterway_label' ]);
+
+        t.end();
+    });
+
+    t.test('should extract the tags of a feature', function(t) {
+        var tile = new VectorTile(new Protobuf(data));
+
+        t.equal(tile.layers.poi_label.length, 558);
+
+        var park = tile.layers.poi_label.feature(11);
+
+        t.deepEqual(park.bbox(), [ 3898, 1731, 3898, 1731 ]);
+
+        t.throws(function() {
+            var park = tile.layers.poi_label.feature(1e9);
+        }, 'throws on reading a feature out of bounds');
+
+        t.equal(park.id, 3000003150561);
+
+        t.equal(park.properties.name, 'Mauerpark');
+        t.equal(park.properties.type, 'Park');
+
+        // Check point geometry
+        t.deepEqual(park.loadGeometry(), [ [ { x: 3898, y: 1731 } ] ]);
+
+        // Check line geometry
+        t.deepEqual(tile.layers.road.feature(656).loadGeometry(), [ [ { x: 1988, y: 306 }, { x: 1808, y: 321 }, { x: 1506, y: 347 } ] ]);
+        t.end();
+    });
+
+    t.test('changing first point of a polygon should not change last point', function(t) {
+        var tile = new VectorTile(new Protobuf(data));
+
+        var building = tile.layers.building.feature(0).loadGeometry();
+        t.deepEqual(building, [ [ { x: 2039, y: -32 }, { x: 2035, y: -31 }, { x: 2032, y: -31 }, { x: 2032, y: -32 }, { x: 2039, y: -32 } ] ]);
+        building[0][0].x = 1;
+        building[0][0].y = 2;
+        building[0][1].x = 3;
+        building[0][1].y = 4;
+        t.deepEqual(building, [ [ { x: 1, y: 2 }, { x: 3, y: 4 }, { x: 2032, y: -31 }, { x: 2032, y: -32 }, { x: 2039, y: -32 } ] ]);
+        t.end();
+    });
+
+    t.test('toGeoJSON', function(t) {
+        var tile = new VectorTile(new Protobuf(data));
+
+        t.ok(approximateDeepEqual(tile.layers.poi_label.feature(11).toGeoJSON(8801, 5371, 14), {
+            type: 'Feature',
+            id: 3000003150561,
+            properties: {
+                localrank: 1,
+                maki: 'park',
+                name: 'Mauerpark',
+                name_de: 'Mauerpark',
+                name_en: 'Mauerpark',
+                name_es: 'Mauerpark',
+                name_fr: 'Mauerpark',
+                osm_id: 3000003150561,
+                ref: '',
+                scalerank: 2,
+                type: 'Park'
+            },
+            geometry: {
+                type: 'Point',
+                coordinates: [13.402258157730103, 52.54398925380624]
+            }
+        }));
+
+        t.ok(approximateDeepEqual(tile.layers.bridge.feature(0).toGeoJSON(8801, 5371, 14), {
+            type: 'Feature',
+            id: 238162948,
+            properties: {
+                class: 'service',
+                oneway: 0,
+                osm_id: 238162948,
+                type: 'service'
+            },
+            geometry: {
+                type: 'LineString',
+                coordinates: [[13.399457931518555, 52.546334844036416], [13.399441838264465, 52.546504478525016]]
+            }
+        }));
+
+        t.ok(approximateDeepEqual(tile.layers.building.feature(0).toGeoJSON(8801, 5371, 14), {
+            type: 'Feature',
+            id: 1000267229912,
+            properties: {
+                osm_id: 1000267229912
+            },
+            geometry: {
+                type: 'Polygon',
+                coordinates: [[[13.392285704612732, 52.54974045706258], [13.392264246940613, 52.549737195107554],
+                    [13.392248153686523, 52.549737195107554], [13.392248153686523, 52.54974045706258],
+                    [13.392285704612732, 52.54974045706258]]]
+            }
+        }));
+
+        function geoJSONFromFixture(name) {
+            var tile = new VectorTile(new Protobuf(fs.readFileSync(__dirname + '/fixtures/' + name + '.pbf')));
+            return tile.layers.geojson.feature(0).toGeoJSON(0, 0, 0);
+        }
+
+        // https://github.com/mapbox/vector-tile-spec/issues/30
+        t.ok(approximateDeepEqual(geoJSONFromFixture("singleton-multi-point").geometry, {
+            type: 'Point',
+            coordinates: [1, 2]
+        }, 1e-1));
+        t.ok(approximateDeepEqual(geoJSONFromFixture("singleton-multi-line").geometry, {
+            type: 'LineString',
+            coordinates: [[1, 2], [3, 4]]
+        }, 1e-1));
+        t.ok(approximateDeepEqual(geoJSONFromFixture("singleton-multi-polygon").geometry, {
+            type: 'Polygon',
+            coordinates: [[[1, 0], [0, 0], [1, 1], [1, 0]]]
+        }, 1e-1));
+
+        t.ok(approximateDeepEqual(geoJSONFromFixture("multi-point").geometry, {
+            type: 'MultiPoint',
+            coordinates: [[1, 2], [3, 4]]
+        }, 1e-1));
+        t.ok(approximateDeepEqual(geoJSONFromFixture("multi-line").geometry, {
+            type: 'MultiLineString',
+            coordinates: [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+        }, 1e-1));
+        t.ok(approximateDeepEqual(geoJSONFromFixture("multi-polygon").geometry, {
+            type: 'MultiPolygon',
+            coordinates: [[[[1, 0], [0, 0], [1, 1], [1, 0]]], [[[-1, -1], [-1, 0], [0, 0], [-1, -1]]]]
+        }, 1e-1));
+
+        // https://github.com/mapbox/vector-tile-js/issues/32
+        t.ok(approximateDeepEqual(geoJSONFromFixture("polygon-with-inner").geometry, {
+            type: 'Polygon',
+            coordinates: [[[2, -2], [-2, -2], [-2, 2], [2, 2], [2, -2]], [[-1, 1], [-1, -1], [1, -1], [1, 1], [-1, 1]]]
+        }, 1e-1));
+        t.ok(approximateDeepEqual(geoJSONFromFixture("stacked-multipolygon").geometry, {
+            type: 'MultiPolygon',
+            coordinates: [[[[2, -2], [-2, -2], [-2, 2], [2, 2], [2, -2]]], [[[1, -1], [-1, -1], [-1, 1], [1, 1], [1, -1]]]]
+        }, 1e-1));
+
+        t.end();
+    })
+});
+
+test('VectorTileLayer', function(t) {
+    var emptyLayer = new VectorTileLayer(new Protobuf(new Buffer([])));
+    t.ok(emptyLayer, 'can be created with no values');
+    t.end();
+});
+
+test('VectorTileFeature', function(t) {
+    var emptyFeature = new VectorTileFeature(new Protobuf(new Buffer([])));
+    t.ok(emptyFeature, 'can be created with no values');
+    t.ok(Array.isArray(VectorTileFeature.types));
+    t.deepEqual(VectorTileFeature.types, ['Unknown', 'Point', 'LineString', 'Polygon']);
+    t.end();
+});
+
+test('https://github.com/mapbox/vector-tile-js/issues/15', function(t) {
+    var data = fs.readFileSync(__dirname + '/fixtures/lots-of-tags.vector.pbf');
+    var tile = new VectorTile(new Protobuf(data));
+    t.ok(tile.layers["stuttgart-rails"].feature(0));
+    t.end();
+});
+
+test('https://github.com/mapbox/mapbox-gl-js/issues/1019', function(t) {
+    var data = fs.readFileSync(__dirname + '/fixtures/12-1143-1497.vector.pbf');
+    var tile = new VectorTile(new Protobuf(data));
+    t.ok(tile.layers["water"].feature(1).loadGeometry());
+    t.end();
+});
+
+test('https://github.com/mapbox/vector-tile-js/issues/60', function(t) {
+    var data = fs.readFileSync(__dirname + '/fixtures/multipolygon-with-closepath.pbf');
+    var tile = new VectorTile(new Protobuf(data));
+    for (var id in tile.layers) {
+        var layer = tile.layers[id];
+        for (var i = 0; i < layer.length; i++) {
+            layer.feature(i).loadGeometry();
+        }
+    }
+    t.end();
+});