From 1e8a51a070ab3c24fc6c9685c6e277f94cd67799 Mon Sep 17 00:00:00 2001 From: Wil Gieseler Date: Tue, 7 Jun 2016 13:46:01 -0700 Subject: [PATCH 1/2] factor out tile loading --- src/MVTSource.js | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/MVTSource.js b/src/MVTSource.js index 9035801..58d9927 100644 --- a/src/MVTSource.js +++ b/src/MVTSource.js @@ -189,6 +189,15 @@ module.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({ }, _draw: function(ctx) { + _fetchVectorTileXHR(ctx); + }, + + _vectorTileLoaded: function(ctx, vt) { + this.checkVectorTileLayers(parseVT(vt), ctx); + tileLoaded(this, ctx); + } + + _fetchVectorTileXHR: function(ctx) { var self = this; // //This works to skip fetching and processing tiles if they've already been processed. @@ -218,8 +227,7 @@ module.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({ console.log("Fetched tile for zoom level " + ctx.zoom + ". Map is at zoom level " + self._map.getZoom()); return; } - self.checkVectorTileLayers(parseVT(vt), ctx); - tileLoaded(self, ctx); + _vectorTileLoaded(vt, ctx); } //either way, reduce the count of tilesToProcess tiles here From cdf4f2a7de1904af4a711a32629a1e1a84910a9a Mon Sep 17 00:00:00 2001 From: Wil Gieseler Date: Tue, 7 Jun 2016 14:41:09 -0700 Subject: [PATCH 2/2] add on-the-fly slicing --- dist/Leaflet.MapboxVectorTile.js | 6544 ++++++++++++++---------------- examples/geojson.html | 23 + examples/geojson.js | 41 + package.json | 4 +- src/MVTSource.js | 30 +- 5 files changed, 3232 insertions(+), 3410 deletions(-) create mode 100644 examples/geojson.html create mode 100644 examples/geojson.js diff --git a/dist/Leaflet.MapboxVectorTile.js b/dist/Leaflet.MapboxVectorTile.js index 9abb8eb..a0b4236 100644 --- a/dist/Leaflet.MapboxVectorTile.js +++ b/dist/Leaflet.MapboxVectorTile.js @@ -1,2350 +1,2424 @@ -(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= k1 && maxAll <= k2) return features; // trivial accept + else if (minAll > k2 || maxAll < k1) return null; // trivial reject -// === READING ================================================================= + var clipped = []; -Protobuf.prototype.readUInt32 = function() { - var val = this.buf.readUInt32LE(this.pos); - this.pos += 4; - return val; -}; + for (var i = 0; i < features.length; i++) { -Protobuf.prototype.readUInt64 = function() { - var val = this.buf.readUInt64LE(this.pos); - this.pos += 8; - return val; -}; + var feature = features[i], + geometry = feature.geometry, + type = feature.type, + min, max; + + min = feature.min[axis]; + max = feature.max[axis]; + + if (min >= k1 && max <= k2) { // trivial accept + clipped.push(feature); + continue; + } else if (min > k2 || max < k1) continue; // trivial reject + + var slices = type === 1 ? + clipPoints(geometry, k1, k2, axis) : + clipGeometry(geometry, k1, k2, axis, intersect, type === 3); + + if (slices.length) { + // if a feature got clipped, it will likely get clipped on the next zoom level as well, + // so there's no need to recalculate bboxes + clipped.push({ + geometry: slices, + type: type, + tags: features[i].tags || null, + min: feature.min, + max: feature.max + }); + } + } -Protobuf.prototype.readDouble = function() { - var val = ieee754.read(this.buf, this.pos, true, 52, 8); - this.pos += 8; - return val; -}; + return clipped.length ? clipped : null; +} -Protobuf.prototype.readVarint = function() { - // TODO: bounds checking - var pos = this.pos; - if (this.buf[pos] <= 0x7f) { - this.pos++; - return this.buf[pos]; - } else if (this.buf[pos + 1] <= 0x7f) { - this.pos += 2; - return (this.buf[pos] & 0x7f) | (this.buf[pos + 1] << 7); - } else if (this.buf[pos + 2] <= 0x7f) { - this.pos += 3; - return (this.buf[pos] & 0x7f) | (this.buf[pos + 1] & 0x7f) << 7 | (this.buf[pos + 2]) << 14; - } else if (this.buf[pos + 3] <= 0x7f) { - this.pos += 4; - return (this.buf[pos] & 0x7f) | (this.buf[pos + 1] & 0x7f) << 7 | (this.buf[pos + 2] & 0x7f) << 14 | (this.buf[pos + 3]) << 21; - } else if (this.buf[pos + 4] <= 0x7f) { - this.pos += 5; - return ((this.buf[pos] & 0x7f) | (this.buf[pos + 1] & 0x7f) << 7 | (this.buf[pos + 2] & 0x7f) << 14 | (this.buf[pos + 3]) << 21) + (this.buf[pos + 4] * 268435456); - } else { - this.skip(Protobuf.Varint); - return 0; - // throw new Error("TODO: Handle 6+ byte varints"); - } -}; +function clipPoints(geometry, k1, k2, axis) { + var slice = []; -Protobuf.prototype.readSVarint = function() { - var num = this.readVarint(); - if (num > 2147483647) throw new Error('TODO: Handle numbers >= 2^30'); - // zigzag encoding - return ((num >> 1) ^ -(num & 1)); -}; + for (var i = 0; i < geometry.length; i++) { + var a = geometry[i], + ak = a[axis]; -Protobuf.prototype.readString = function() { - var bytes = this.readVarint(); - // TODO: bounds checking - var chr = String.fromCharCode; - var b = this.buf; - var p = this.pos; - var end = this.pos + bytes; - var str = ''; - while (p < end) { - if (b[p] <= 0x7F) str += chr(b[p++]); - else if (b[p] <= 0xBF) throw new Error('Invalid UTF-8 codepoint: ' + b[p]); - else if (b[p] <= 0xDF) str += chr((b[p++] & 0x1F) << 6 | (b[p++] & 0x3F)); - else if (b[p] <= 0xEF) str += chr((b[p++] & 0x1F) << 12 | (b[p++] & 0x3F) << 6 | (b[p++] & 0x3F)); - else if (b[p] <= 0xF7) p += 4; // We can't handle these codepoints in JS, so skip. - else if (b[p] <= 0xFB) p += 5; - else if (b[p] <= 0xFD) p += 6; - else throw new Error('Invalid UTF-8 codepoint: ' + b[p]); + if (ak >= k1 && ak <= k2) slice.push(a); } - this.pos += bytes; - return str; -}; + return slice; +} -Protobuf.prototype.readBuffer = function() { - var bytes = this.readVarint(); - var buffer = this.buf.subarray(this.pos, this.pos + bytes); - this.pos += bytes; - return buffer; -}; +function clipGeometry(geometry, k1, k2, axis, intersect, closed) { -Protobuf.prototype.readPacked = function(type) { - // TODO: bounds checking - var bytes = this.readVarint(); - var end = this.pos + bytes; - var array = []; - while (this.pos < end) { - array.push(this['read' + type]()); - } - return array; -}; + var slices = []; -Protobuf.prototype.skip = function(val) { - // TODO: bounds checking - var type = val & 0x7; - switch (type) { - /* varint */ case Protobuf.Varint: while (this.buf[this.pos++] > 0x7f); break; - /* 64 bit */ case Protobuf.Int64: this.pos += 8; break; - /* length */ case Protobuf.Message: var bytes = this.readVarint(); this.pos += bytes; break; - /* 32 bit */ case Protobuf.Int32: this.pos += 4; break; - default: throw new Error('Unimplemented type: ' + type); - } -}; + for (var i = 0; i < geometry.length; i++) { -// === WRITING ================================================================= + var ak = 0, + bk = 0, + b = null, + points = geometry[i], + area = points.area, + dist = points.dist, + len = points.length, + a, j, last; -Protobuf.prototype.writeTag = function(tag, type) { - this.writeVarint((tag << 3) | type); -}; + var slice = []; -Protobuf.prototype.realloc = function(min) { - var length = this.buf.length; - while (length < this.pos + min) length *= 2; - if (length != this.buf.length) { - var buf = new Buffer(length); - this.buf.copy(buf); - this.buf = buf; - } -}; + for (j = 0; j < len - 1; j++) { + a = b || points[j]; + b = points[j + 1]; + ak = bk || a[axis]; + bk = b[axis]; -Protobuf.prototype.finish = function() { - return this.buf.slice(0, this.pos); -}; + if (ak < k1) { -Protobuf.prototype.writePacked = function(type, tag, items) { - if (!items.length) return; + if ((bk > k2)) { // ---|-----|--> + slice.push(intersect(a, b, k1), intersect(a, b, k2)); + if (!closed) slice = newSlice(slices, slice, area, dist); - var message = new Protobuf(); - for (var i = 0; i < items.length; i++) { - message['write' + type](items[i]); - } - var data = message.finish(); + } else if (bk >= k1) slice.push(intersect(a, b, k1)); // ---|--> | - this.writeTag(tag, Protobuf.Packed); - this.writeBuffer(data); -}; + } else if (ak > k2) { -Protobuf.prototype.writeUInt32 = function(val) { - this.realloc(4); - this.buf.writeUInt32LE(val, this.pos); - this.pos += 4; -}; + if ((bk < k1)) { // <--|-----|--- + slice.push(intersect(a, b, k2), intersect(a, b, k1)); + if (!closed) slice = newSlice(slices, slice, area, dist); -Protobuf.prototype.writeTaggedUInt32 = function(tag, val) { - this.writeTag(tag, Protobuf.Int32); - this.writeUInt32(val); -}; + } else if (bk <= k2) slice.push(intersect(a, b, k2)); // | <--|--- -Protobuf.prototype.writeVarint = function(val) { - val = Number(val); - if (isNaN(val)) { - val = 0; - } + } else { - if (val <= 0x7f) { - this.realloc(1); - this.buf[this.pos++] = val; - } else if (val <= 0x3fff) { - this.realloc(2); - this.buf[this.pos++] = 0x80 | ((val >>> 0) & 0x7f); - this.buf[this.pos++] = 0x00 | ((val >>> 7) & 0x7f); - } else if (val <= 0x1ffffff) { - this.realloc(3); - this.buf[this.pos++] = 0x80 | ((val >>> 0) & 0x7f); - this.buf[this.pos++] = 0x80 | ((val >>> 7) & 0x7f); - this.buf[this.pos++] = 0x00 | ((val >>> 14) & 0x7f); - } else if (val <= 0xfffffff) { - this.realloc(4); - this.buf[this.pos++] = 0x80 | ((val >>> 0) & 0x7f); - this.buf[this.pos++] = 0x80 | ((val >>> 7) & 0x7f); - this.buf[this.pos++] = 0x80 | ((val >>> 14) & 0x7f); - this.buf[this.pos++] = 0x00 | ((val >>> 21) & 0x7f); - } else { - while (val > 0) { - var b = val & 0x7f; - val = Math.floor(val / 128); - if (val > 0) b |= 0x80 - this.realloc(1); - this.buf[this.pos++] = b; - } - } -}; + slice.push(a); -Protobuf.prototype.writeTaggedVarint = function(tag, val) { - this.writeTag(tag, Protobuf.Varint); - this.writeVarint(val); -}; + if (bk < k1) { // <--|--- | + slice.push(intersect(a, b, k1)); + if (!closed) slice = newSlice(slices, slice, area, dist); -Protobuf.prototype.writeSVarint = function(val) { - if (val >= 0) { - this.writeVarint(val * 2); - } else { - this.writeVarint(val * -2 - 1); - } -}; + } else if (bk > k2) { // | ---|--> + slice.push(intersect(a, b, k2)); + if (!closed) slice = newSlice(slices, slice, area, dist); + } + // | --> | + } + } -Protobuf.prototype.writeTaggedSVarint = function(tag, val) { - this.writeTag(tag, Protobuf.Varint); - this.writeSVarint(val); -}; + // add the last point + a = points[len - 1]; + ak = a[axis]; + if (ak >= k1 && ak <= k2) slice.push(a); -Protobuf.prototype.writeBoolean = function(val) { - this.writeVarint(Boolean(val)); -}; + // close the polygon if its endpoints are not the same after clipping -Protobuf.prototype.writeTaggedBoolean = function(tag, val) { - this.writeTaggedVarint(tag, Boolean(val)); -}; + last = slice[slice.length - 1]; + if (closed && last && (slice[0][0] !== last[0] || slice[0][1] !== last[1])) slice.push(slice[0]); -Protobuf.prototype.writeString = function(str) { - str = String(str); - var bytes = Buffer.byteLength(str); - this.writeVarint(bytes); - this.realloc(bytes); - this.buf.write(str, this.pos); - this.pos += bytes; -}; + // add the final slice + newSlice(slices, slice, area, dist); + } -Protobuf.prototype.writeTaggedString = function(tag, str) { - this.writeTag(tag, Protobuf.String); - this.writeString(str); -}; + return slices; +} -Protobuf.prototype.writeFloat = function(val) { - this.realloc(4); - this.buf.writeFloatLE(val, this.pos); - this.pos += 4; -}; +function newSlice(slices, slice, area, dist) { + if (slice.length) { + // we don't recalculate the area/length of the unclipped geometry because the case where it goes + // below the visibility threshold as a result of clipping is rare, so we avoid doing unnecessary work + slice.area = area; + slice.dist = dist; -Protobuf.prototype.writeTaggedFloat = function(tag, val) { - this.writeTag(tag, Protobuf.Int32); - this.writeFloat(val); -}; + slices.push(slice); + } + return []; +} -Protobuf.prototype.writeDouble = function(val) { - this.realloc(8); - this.buf.writeDoubleLE(val, this.pos); - this.pos += 8; -}; +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/convert.js":[function(require,module,exports){ +'use strict'; -Protobuf.prototype.writeTaggedDouble = function(tag, val) { - this.writeTag(tag, Protobuf.Int64); - this.writeDouble(val); -}; +module.exports = convert; -Protobuf.prototype.writeBuffer = function(buffer) { - var bytes = buffer.length; - this.writeVarint(bytes); - this.realloc(bytes); - buffer.copy(this.buf, this.pos); - this.pos += bytes; -}; +var simplify = require('./simplify'); -Protobuf.prototype.writeTaggedBuffer = function(tag, buffer) { - this.writeTag(tag, Protobuf.String); - this.writeBuffer(buffer); -}; +// converts GeoJSON feature into an intermediate projected JSON vector format with simplification data -Protobuf.prototype.writeMessage = function(tag, protobuf) { - var buffer = protobuf.finish(); - this.writeTag(tag, Protobuf.Message); - this.writeBuffer(buffer); -}; +function convert(data, tolerance) { + var features = []; -}).call(this,require("buffer").Buffer) + if (data.type === 'FeatureCollection') { + for (var i = 0; i < data.features.length; i++) { + convertFeature(features, data.features[i], tolerance); + } + } else if (data.type === 'Feature') { + convertFeature(features, data, tolerance); -},{"buffer":14,"ieee754":2}],2:[function(require,module,exports){ -exports.read = function (buffer, offset, isLE, mLen, nBytes) { - var e, m - var eLen = nBytes * 8 - mLen - 1 - var eMax = (1 << eLen) - 1 - var eBias = eMax >> 1 - var nBits = -7 - var i = isLE ? (nBytes - 1) : 0 - var d = isLE ? -1 : 1 - var s = buffer[offset + i] + } else { + // single geometry or a geometry collection + convertFeature(features, {geometry: data}, tolerance); + } + return features; +} - i += d +function convertFeature(features, feature, tolerance) { + var geom = feature.geometry, + type = geom.type, + coords = geom.coordinates, + tags = feature.properties, + i, j, rings; - e = s & ((1 << (-nBits)) - 1) - s >>= (-nBits) - nBits += eLen - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} + if (type === 'Point') { + features.push(create(tags, 1, [projectPoint(coords)])); - m = e & ((1 << (-nBits)) - 1) - e >>= (-nBits) - nBits += mLen - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} + } else if (type === 'MultiPoint') { + features.push(create(tags, 1, project(coords))); - if (e === 0) { - e = 1 - eBias - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen) - e = e - eBias - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} + } else if (type === 'LineString') { + features.push(create(tags, 2, [project(coords, tolerance)])); -exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c - var eLen = nBytes * 8 - mLen - 1 - var eMax = (1 << eLen) - 1 - var eBias = eMax >> 1 - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) - var i = isLE ? 0 : (nBytes - 1) - var d = isLE ? 1 : -1 - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + } else if (type === 'MultiLineString' || type === 'Polygon') { + rings = []; + for (i = 0; i < coords.length; i++) { + rings.push(project(coords[i], tolerance)); + } + features.push(create(tags, type === 'Polygon' ? 3 : 2, rings)); - value = Math.abs(value) + } else if (type === 'MultiPolygon') { + rings = []; + for (i = 0; i < coords.length; i++) { + for (j = 0; j < coords[i].length; j++) { + rings.push(project(coords[i][j], tolerance)); + } + } + features.push(create(tags, 3, rings)); + + } else if (type === 'GeometryCollection') { + for (i = 0; i < geom.geometries.length; i++) { + convertFeature(features, { + geometry: geom.geometries[i], + properties: tags + }, tolerance); + } - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0 - e = eMax - } else { - e = Math.floor(Math.log(value) / Math.LN2) - if (value * (c = Math.pow(2, -e)) < 1) { - e-- - c *= 2 - } - if (e + eBias >= 1) { - value += rt / c } else { - value += rt * Math.pow(2, 1 - eBias) - } - if (value * c >= 2) { - e++ - c /= 2 + throw new Error('Input data is not a valid GeoJSON object.'); } +} - if (e + eBias >= eMax) { - m = 0 - e = eMax - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen) - e = e + eBias - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) - e = 0 +function create(tags, type, geometry) { + var feature = { + geometry: geometry, + type: type, + tags: tags || null, + min: [2, 1], // initial bbox values; + max: [-1, 0] // note that coords are usually in [0..1] range + }; + calcBBox(feature); + return feature; +} + +function project(lonlats, tolerance) { + var projected = []; + for (var i = 0; i < lonlats.length; i++) { + projected.push(projectPoint(lonlats[i])); } - } + if (tolerance) { + simplify(projected, tolerance); + calcSize(projected); + } + return projected; +} - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} +function projectPoint(p) { + var sin = Math.sin(p[1] * Math.PI / 180), + x = (p[0] / 360 + 0.5), + y = (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI); - e = (e << mLen) | m - eLen += mLen - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + y = y < -1 ? -1 : + y > 1 ? 1 : y; - buffer[offset + i - d] |= s * 128 + return [x, y, 0]; } -},{}],3:[function(require,module,exports){ -'use strict'; +// calculate area and length of the poly +function calcSize(points) { + var area = 0, + dist = 0; -module.exports = Point; + for (var i = 0, a, b; i < points.length - 1; i++) { + a = b || points[i]; + b = points[i + 1]; -function Point(x, y) { - this.x = x; - this.y = y; -} + area += a[0] * b[1] - b[0] * a[1]; -Point.prototype = { - clone: function() { return new Point(this.x, this.y); }, + // use Manhattan distance instead of Euclidian one to avoid expensive square root computation + dist += Math.abs(b[0] - a[0]) + Math.abs(b[1] - a[1]); + } + points.area = Math.abs(area / 2); + points.dist = dist; +} - add: function(p) { return this.clone()._add(p); }, - sub: function(p) { return this.clone()._sub(p); }, - mult: function(k) { return this.clone()._mult(k); }, - div: function(k) { return this.clone()._div(k); }, - rotate: function(a) { return this.clone()._rotate(a); }, - matMult: function(m) { return this.clone()._matMult(m); }, - unit: function() { return this.clone()._unit(); }, - perp: function() { return this.clone()._perp(); }, - round: function() { return this.clone()._round(); }, +// calculate the feature bounding box for faster clipping later +function calcBBox(feature) { + var geometry = feature.geometry, + min = feature.min, + max = feature.max; - mag: function() { - return Math.sqrt(this.x * this.x + this.y * this.y); - }, + if (feature.type === 1) calcRingBBox(min, max, geometry); + else for (var i = 0; i < geometry.length; i++) calcRingBBox(min, max, geometry[i]); - equals: function(p) { - return this.x === p.x && - this.y === p.y; - }, + return feature; +} - dist: function(p) { - return Math.sqrt(this.distSqr(p)); - }, +function calcRingBBox(min, max, points) { + for (var i = 0, p; i < points.length; i++) { + p = points[i]; + min[0] = Math.min(p[0], min[0]); + max[0] = Math.max(p[0], max[0]); + min[1] = Math.min(p[1], min[1]); + max[1] = Math.max(p[1], max[1]); + } +} - distSqr: function(p) { - var dx = p.x - this.x, - dy = p.y - this.y; - return dx * dx + dy * dy; - }, +},{"./simplify":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/simplify.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/index.js":[function(require,module,exports){ +'use strict'; - angle: function() { - return Math.atan2(this.y, this.x); - }, +module.exports = geojsonvt; - angleTo: function(b) { - return Math.atan2(this.y - b.y, this.x - b.x); - }, +var convert = require('./convert'), // GeoJSON conversion and preprocessing + transform = require('./transform'), // coordinate transformation + clip = require('./clip'), // stripe clipping algorithm + wrap = require('./wrap'), // date line processing + createTile = require('./tile'); // final simplified tile generation - angleWith: function(b) { - return this.angleWithSep(b.x, b.y); - }, - // Find the angle of the two vectors, solving the formula for the cross product a x b = |a||b|sin(θ) for θ. - angleWithSep: function(x, y) { - return Math.atan2( - this.x * y - this.y * x, - this.x * x + this.y * y); - }, +function geojsonvt(data, options) { + return new GeoJSONVT(data, options); +} - _matMult: function(m) { - var x = m[0] * this.x + m[1] * this.y, - y = m[2] * this.x + m[3] * this.y; - this.x = x; - this.y = y; - return this; - }, +function GeoJSONVT(data, options) { + options = this.options = extend(Object.create(this.options), options); - _add: function(p) { - this.x += p.x; - this.y += p.y; - return this; - }, + var debug = options.debug; - _sub: function(p) { - this.x -= p.x; - this.y -= p.y; - return this; - }, + if (debug) console.time('preprocess data'); - _mult: function(k) { - this.x *= k; - this.y *= k; - return this; - }, + var z2 = 1 << options.maxZoom, // 2^z + features = convert(data, options.tolerance / (z2 * options.extent)); - _div: function(k) { - this.x /= k; - this.y /= k; - return this; - }, + this.tiles = {}; + this.tileCoords = []; - _unit: function() { - this._div(this.mag()); - return this; - }, + if (debug) { + console.timeEnd('preprocess data'); + console.log('index: maxZoom: %d, maxPoints: %d', options.indexMaxZoom, options.indexMaxPoints); + console.time('generate tiles'); + this.stats = {}; + this.total = 0; + } - _perp: function() { - var y = this.y; - this.y = this.x; - this.x = -y; - return this; - }, + features = wrap(features, options.buffer / options.extent, intersectX); - _rotate: function(angle) { - var cos = Math.cos(angle), - sin = Math.sin(angle), - x = cos * this.x - sin * this.y, - y = sin * this.x + cos * this.y; - this.x = x; - this.y = y; - return this; - }, + // start slicing from the top tile down + if (features.length) this.splitTile(features, 0, 0, 0); - _round: function() { - this.x = Math.round(this.x); - this.y = Math.round(this.y); - return this; + if (debug) { + if (features.length) console.log('features: %d, points: %d', this.tiles[0].numFeatures, this.tiles[0].numPoints); + console.timeEnd('generate tiles'); + console.log('tiles generated:', this.total, JSON.stringify(this.stats)); } +} + +GeoJSONVT.prototype.options = { + maxZoom: 14, // max zoom to preserve detail on + indexMaxZoom: 5, // max zoom in the tile index + indexMaxPoints: 100000, // max number of points per tile in the tile index + solidChildren: false, // whether to tile solid square tiles further + tolerance: 3, // simplification tolerance (higher means simpler) + extent: 4096, // tile extent + buffer: 64, // tile buffer on each side + debug: 0 // logging level (0, 1 or 2) }; -// constructs Point from an array if necessary -Point.convert = function (a) { - if (a instanceof Point) { - return a; - } - if (Array.isArray(a)) { - return new Point(a[0], a[1]); - } - return a; -}; +GeoJSONVT.prototype.splitTile = function (features, z, x, y, cz, cx, cy) { -},{}],4:[function(require,module,exports){ -module.exports.VectorTile = require('./lib/vectortile.js'); -module.exports.VectorTileFeature = require('./lib/vectortilefeature.js'); -module.exports.VectorTileLayer = require('./lib/vectortilelayer.js'); + var stack = [features, z, x, y], + options = this.options, + debug = options.debug, + solid = null; -},{"./lib/vectortile.js":5,"./lib/vectortilefeature.js":6,"./lib/vectortilelayer.js":7}],5:[function(require,module,exports){ -'use strict'; + // avoid recursion by using a processing queue + while (stack.length) { + y = stack.pop(); + x = stack.pop(); + z = stack.pop(); + features = stack.pop(); -var VectorTileLayer = require('./vectortilelayer'); + var z2 = 1 << z, + id = toID(z, x, y), + tile = this.tiles[id], + tileTolerance = z === options.maxZoom ? 0 : options.tolerance / (z2 * options.extent); -module.exports = VectorTile; + if (!tile) { + if (debug > 1) console.time('creation'); -function VectorTile(buffer, end) { + tile = this.tiles[id] = createTile(features, z2, x, y, tileTolerance, z === options.maxZoom); + this.tileCoords.push({z: z, x: x, y: y}); - this.layers = {}; - this._buffer = buffer; + if (debug) { + if (debug > 1) { + console.log('tile z%d-%d-%d (features: %d, points: %d, simplified: %d)', + z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified); + console.timeEnd('creation'); + } + var key = 'z' + z; + this.stats[key] = (this.stats[key] || 0) + 1; + this.total++; + } + } - end = end || buffer.length; + // save reference to original geometry in tile so that we can drill down later if we stop now + tile.source = features; - while (buffer.pos < end) { - var val = buffer.readVarint(), - tag = val >> 3; + // if it's the first-pass tiling + if (!cz) { + // stop tiling if we reached max zoom, or if the tile is too simple + if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints) continue; - if (tag == 3) { - var layer = this.readLayer(); - if (layer.length) this.layers[layer.name] = layer; + // if a drilldown to a specific tile } else { - buffer.skip(val); + // stop tiling if we reached base zoom or our target tile zoom + if (z === options.maxZoom || z === cz) continue; + + // stop tiling if it's not an ancestor of the target tile + var m = 1 << (cz - z); + if (x !== Math.floor(cx / m) || y !== Math.floor(cy / m)) continue; + } + + // stop tiling if the tile is solid clipped square + if (!options.solidChildren && isClippedSquare(tile, options.extent, options.buffer)) { + if (cz) solid = z; // and remember the zoom if we're drilling down + continue; } - } -} -VectorTile.prototype.readLayer = function() { - var buffer = this._buffer, - bytes = buffer.readVarint(), - end = buffer.pos + bytes, - layer = new VectorTileLayer(buffer, end); + // if we slice further down, no need to keep source geometry + tile.source = null; - buffer.pos = end; + if (debug > 1) console.time('clipping'); - return layer; + // values we'll use for clipping + var k1 = 0.5 * options.buffer / options.extent, + k2 = 0.5 - k1, + k3 = 0.5 + k1, + k4 = 1 + k1, + tl, bl, tr, br, left, right; + + tl = bl = tr = br = null; + + left = clip(features, z2, x - k1, x + k3, 0, intersectX, tile.min[0], tile.max[0]); + right = clip(features, z2, x + k2, x + k4, 0, intersectX, tile.min[0], tile.max[0]); + + if (left) { + tl = clip(left, z2, y - k1, y + k3, 1, intersectY, tile.min[1], tile.max[1]); + bl = clip(left, z2, y + k2, y + k4, 1, intersectY, tile.min[1], tile.max[1]); + } + + if (right) { + tr = clip(right, z2, y - k1, y + k3, 1, intersectY, tile.min[1], tile.max[1]); + br = clip(right, z2, y + k2, y + k4, 1, intersectY, tile.min[1], tile.max[1]); + } + + if (debug > 1) console.timeEnd('clipping'); + + if (tl) stack.push(tl, z + 1, x * 2, y * 2); + if (bl) stack.push(bl, z + 1, x * 2, y * 2 + 1); + if (tr) stack.push(tr, z + 1, x * 2 + 1, y * 2); + if (br) stack.push(br, z + 1, x * 2 + 1, y * 2 + 1); + } + + return solid; }; -},{"./vectortilelayer":7}],6:[function(require,module,exports){ -'use strict'; +GeoJSONVT.prototype.getTile = function (z, x, y) { + var options = this.options, + extent = options.extent, + debug = options.debug; -var Point = require('point-geometry'); + var z2 = 1 << z; + x = ((x % z2) + z2) % z2; // wrap tile x coordinate -module.exports = VectorTileFeature; + var id = toID(z, x, y); + if (this.tiles[id]) return transform.tile(this.tiles[id], extent); -function VectorTileFeature(buffer, end, extent, keys, values) { + if (debug > 1) console.log('drilling down to z%d-%d-%d', z, x, y); - this.properties = {}; + var z0 = z, + x0 = x, + y0 = y, + parent; - // Public - this.extent = extent; - this.type = 0; + while (!parent && z0 > 0) { + z0--; + x0 = Math.floor(x0 / 2); + y0 = Math.floor(y0 / 2); + parent = this.tiles[toID(z0, x0, y0)]; + } - // Private - this._buffer = buffer; - this._geometry = -1; + if (!parent || !parent.source) return null; - end = end || buffer.length; + // if we found a parent tile containing the original geometry, we can drill down from it + if (debug > 1) console.log('found parent tile z%d-%d-%d', z0, x0, y0); - while (buffer.pos < end) { - var val = buffer.readVarint(), - tag = val >> 3; + // it parent tile is a solid clipped square, return it instead since it's identical + if (isClippedSquare(parent, extent, options.buffer)) return transform.tile(parent, extent); - if (tag == 1) { - this._id = buffer.readVarint(); + if (debug > 1) console.time('drilling down'); + var solid = this.splitTile(parent.source, z0, x0, y0, z, x, y); + if (debug > 1) console.timeEnd('drilling down'); - } else if (tag == 2) { - var tagLen = buffer.readVarint(), - tagEnd = buffer.pos + tagLen; + // one of the parent tiles was a solid clipped square + if (solid !== null) { + var m = 1 << (z - solid); + id = toID(solid, Math.floor(x / m), Math.floor(y / m)); + } - while (buffer.pos < tagEnd) { - var key = keys[buffer.readVarint()]; - var value = values[buffer.readVarint()]; - this.properties[key] = value; - } + return this.tiles[id] ? transform.tile(this.tiles[id], extent) : null; +}; + +function toID(z, x, y) { + return (((1 << z) * y + x) * 32) + z; +} - } else if (tag == 3) { - this.type = buffer.readVarint(); +function intersectX(a, b, x) { + return [x, (x - a[0]) * (b[1] - a[1]) / (b[0] - a[0]) + a[1], 1]; +} +function intersectY(a, b, y) { + return [(y - a[1]) * (b[0] - a[0]) / (b[1] - a[1]) + a[0], y, 1]; +} - } else if (tag == 4) { - this._geometry = buffer.pos; - buffer.skip(val); +function extend(dest, src) { + for (var i in src) dest[i] = src[i]; + return dest; +} - } else { - buffer.skip(val); - } +// checks whether a tile is a whole-area fill after clipping; if it is, there's no sense slicing it further +function isClippedSquare(tile, extent, buffer) { + + var features = tile.source; + if (features.length !== 1) return false; + + var feature = features[0]; + if (feature.type !== 3 || feature.geometry.length > 1) return false; + + var len = feature.geometry[0].length; + if (len !== 5) return false; + + for (var i = 0; i < len; i++) { + var p = transform.point(feature.geometry[0][i], extent, tile.z2, tile.x, tile.y); + if ((p[0] !== -buffer && p[0] !== extent + buffer) || + (p[1] !== -buffer && p[1] !== extent + buffer)) return false; } + + return true; } -VectorTileFeature.types = ['Unknown', 'Point', 'LineString', 'Polygon']; +},{"./clip":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/clip.js","./convert":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/convert.js","./tile":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/tile.js","./transform":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/transform.js","./wrap":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/wrap.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/simplify.js":[function(require,module,exports){ +'use strict'; -VectorTileFeature.prototype.loadGeometry = function() { - var buffer = this._buffer; - buffer.pos = this._geometry; +module.exports = simplify; - var bytes = buffer.readVarint(), - end = buffer.pos + bytes, - cmd = 1, - length = 0, - x = 0, - y = 0, - lines = [], - line; +// calculate simplification data using optimized Douglas-Peucker algorithm - while (buffer.pos < end) { - if (!length) { - var cmd_length = buffer.readVarint(); - cmd = cmd_length & 0x7; - length = cmd_length >> 3; - } +function simplify(points, tolerance) { - length--; + var sqTolerance = tolerance * tolerance, + len = points.length, + first = 0, + last = len - 1, + stack = [], + i, maxSqDist, sqDist, index; - if (cmd === 1 || cmd === 2) { - x += buffer.readSVarint(); - y += buffer.readSVarint(); + // always retain the endpoints (1 is the max value) + points[first][2] = 1; + points[last][2] = 1; - if (cmd === 1) { - // moveTo - if (line) { - lines.push(line); - } - line = []; + // avoid recursion by using a stack + while (last) { + + maxSqDist = 0; + + for (i = first + 1; i < last; i++) { + sqDist = getSqSegDist(points[i], points[first], points[last]); + + if (sqDist > maxSqDist) { + index = i; + maxSqDist = sqDist; } + } + + if (maxSqDist > sqTolerance) { + points[index][2] = maxSqDist; // save the point importance in squared pixels as a z coordinate + stack.push(first); + stack.push(index); + first = index; - line.push(new Point(x, y)); - } else if (cmd === 7) { - // closePolygon - line.push(line[0].clone()); } else { - throw new Error('unknown command ' + cmd); + last = stack.pop(); + first = stack.pop(); } } +} - if (line) lines.push(line); +// square distance from a point to a segment +function getSqSegDist(p, a, b) { - return lines; -}; + var x = a[0], y = a[1], + bx = b[0], by = b[1], + px = p[0], py = p[1], + dx = bx - x, + dy = by - y; -VectorTileFeature.prototype.bbox = function() { - var buffer = this._buffer; - buffer.pos = this._geometry; + if (dx !== 0 || dy !== 0) { - var bytes = buffer.readVarint(), - end = buffer.pos + bytes, + var t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy); - cmd = 1, - length = 0, - x = 0, - y = 0, - x1 = Infinity, - x2 = -Infinity, - y1 = Infinity, - y2 = -Infinity; + if (t > 1) { + x = bx; + y = by; - while (buffer.pos < end) { - if (!length) { - var cmd_length = buffer.readVarint(); - cmd = cmd_length & 0x7; - length = cmd_length >> 3; + } else if (t > 0) { + x += dx * t; + y += dy * t; } + } - length--; + dx = px - x; + dy = py - y; - if (cmd === 1 || cmd === 2) { - x += buffer.readSVarint(); - y += buffer.readSVarint(); - if (x < x1) x1 = x; - if (x > x2) x2 = x; - if (y < y1) y1 = y; - if (y > y2) y2 = y; + return dx * dx + dy * dy; +} - } else if (cmd !== 7) { - throw new Error('unknown command ' + cmd); - } - } +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/tile.js":[function(require,module,exports){ +'use strict'; - return [x1, y1, x2, y2]; -}; +module.exports = createTile; + +function createTile(features, z2, tx, ty, tolerance, noSimplify) { + var tile = { + features: [], + numPoints: 0, + numSimplified: 0, + numFeatures: 0, + source: null, + x: tx, + y: ty, + z2: z2, + transformed: false, + min: [2, 1], + max: [-1, 0] + }; + for (var i = 0; i < features.length; i++) { + tile.numFeatures++; + addFeature(tile, features[i], tolerance, noSimplify); -},{"point-geometry":3}],7:[function(require,module,exports){ -'use strict'; + var min = features[i].min, + max = features[i].max; -var VectorTileFeature = require('./vectortilefeature.js'); + if (min[0] < tile.min[0]) tile.min[0] = min[0]; + if (min[1] < tile.min[1]) tile.min[1] = min[1]; + if (max[0] > tile.max[0]) tile.max[0] = max[0]; + if (max[1] > tile.max[1]) tile.max[1] = max[1]; + } + return tile; +} -module.exports = VectorTileLayer; -function VectorTileLayer(buffer, end) { - // Public - this.version = 1; - this.name = null; - this.extent = 4096; - this.length = 0; +function addFeature(tile, feature, tolerance, noSimplify) { - // Private - this._buffer = buffer; - this._keys = []; - this._values = []; - this._features = []; + var geom = feature.geometry, + type = feature.type, + simplified = [], + sqTolerance = tolerance * tolerance, + i, j, ring, p; - var val, tag; - - end = end || buffer.length; - - while (buffer.pos < end) { - val = buffer.readVarint(); - tag = val >> 3; - - if (tag === 15) { - this.version = buffer.readVarint(); - } else if (tag === 1) { - this.name = buffer.readString(); - } else if (tag === 5) { - this.extent = buffer.readVarint(); - } else if (tag === 2) { - this.length++; - this._features.push(buffer.pos); - buffer.skip(val); - - } else if (tag === 3) { - this._keys.push(buffer.readString()); - } else if (tag === 4) { - this._values.push(this.readFeatureValue()); - } else { - buffer.skip(val); + if (type === 1) { + for (i = 0; i < geom.length; i++) { + simplified.push(geom[i]); + tile.numPoints++; + tile.numSimplified++; } - } -} -VectorTileLayer.prototype.readFeatureValue = function() { - var buffer = this._buffer, - value = null, - bytes = buffer.readVarint(), - end = buffer.pos + bytes, - val, tag; - - while (buffer.pos < end) { - val = buffer.readVarint(); - tag = val >> 3; - - if (tag == 1) { - value = buffer.readString(); - } else if (tag == 2) { - throw new Error('read float'); - } else if (tag == 3) { - value = buffer.readDouble(); - } else if (tag == 4) { - value = buffer.readVarint(); - } else if (tag == 5) { - throw new Error('read uint'); - } else if (tag == 6) { - value = buffer.readSVarint(); - } else if (tag == 7) { - value = Boolean(buffer.readVarint()); - } else { - buffer.skip(val); + } else { + + // simplify and transform projected coordinates for tile geometry + for (i = 0; i < geom.length; i++) { + ring = geom[i]; + + // filter out tiny polylines & polygons + if (!noSimplify && ((type === 2 && ring.dist < tolerance) || + (type === 3 && ring.area < sqTolerance))) { + tile.numPoints += ring.length; + continue; + } + + var simplifiedRing = []; + + for (j = 0; j < ring.length; j++) { + p = ring[j]; + // keep points with importance > tolerance + if (noSimplify || p[2] > sqTolerance) { + simplifiedRing.push(p); + tile.numSimplified++; + } + tile.numPoints++; + } + + simplified.push(simplifiedRing); } } - return value; -}; + if (simplified.length) { + tile.features.push({ + geometry: simplified, + type: type, + tags: feature.tags || null + }); + } +} -// 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'); +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/transform.js":[function(require,module,exports){ +'use strict'; - this._buffer.pos = this._features[i]; - var end = this._buffer.readVarint() + this._buffer.pos; +exports.tile = transformTile; +exports.point = transformPoint; - return new VectorTileFeature(this._buffer, end, this.extent, this._keys, this._values); -}; +// Transforms the coordinates of each feature in the given tile from +// mercator-projected space into (extent x extent) tile space. +function transformTile(tile, extent) { + if (tile.transformed) return tile; -},{"./vectortilefeature.js":6}],8:[function(require,module,exports){ -/** - * Created by Ryan Whitley, Daniel Duarte, and Nicholas Hallahan - * on 6/03/14. - */ -var Util = require('./MVTUtil'); -var StaticLabel = require('./StaticLabel/StaticLabel.js'); + var z2 = tile.z2, + tx = tile.x, + ty = tile.y, + i, j, k; -module.exports = MVTFeature; + for (i = 0; i < tile.features.length; i++) { + var feature = tile.features[i], + geom = feature.geometry, + type = feature.type; -function MVTFeature(mvtLayer, vtf, ctx, id, style) { - if (!vtf) return null; + if (type === 1) { + for (j = 0; j < geom.length; j++) geom[j] = transformPoint(geom[j], extent, z2, tx, ty); - // Apply all of the properties of vtf to this object. - for (var key in vtf) { - this[key] = vtf[key]; - } + } else { + for (j = 0; j < geom.length; j++) { + var ring = geom[j]; + for (k = 0; k < ring.length; k++) ring[k] = transformPoint(ring[k], extent, z2, tx, ty); + } + } + } - this.mvtLayer = mvtLayer; - this.mvtSource = mvtLayer.mvtSource; - this.map = mvtLayer.mvtSource.map; + tile.transformed = true; - this.id = id; + return tile; +} - this.layerLink = this.mvtSource.layerLink; - this.toggleEnabled = true; - this.selected = false; +function transformPoint(p, extent, z2, tx, ty) { + var x = Math.round(extent * (p[0] * z2 - tx)), + y = Math.round(extent * (p[1] * z2 - ty)); + return [x, y]; +} - // how much we divide the coordinate from the vector tile - this.divisor = vtf.extent / ctx.tileSize; - this.extent = vtf.extent; - this.tileSize = ctx.tileSize; +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/wrap.js":[function(require,module,exports){ +'use strict'; - //An object to store the paths and contexts for this feature - this.tiles = {}; +var clip = require('./clip'); - this.style = style; +module.exports = wrap; - //Add to the collection - this.addTileFeature(vtf, ctx); +function wrap(features, buffer, intersectX) { + var merged = features, + left = clip(features, 1, -1 - buffer, buffer, 0, intersectX, -1, 2), // left world copy + right = clip(features, 1, 1 - buffer, 2 + buffer, 0, intersectX, -1, 2); // right world copy - var self = this; - this.map.on('zoomend', function() { - self.staticLabel = null; - }); + if (left || right) { + merged = clip(features, 1, -buffer, 1 + buffer, 0, intersectX, -1, 2); // center world copy - if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') { - this.dynamicLabel = this.mvtSource.dynamicLabel.createFeature(this); - } + if (left) merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center + if (right) merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center + } - ajax(self); + return merged; } +function shiftFeatureCoords(features, offset) { + var newFeatures = []; -function ajax(self) { - var style = self.style; - if (style && style.ajaxSource && typeof style.ajaxSource === 'function') { - var ajaxEndpoint = style.ajaxSource(self); - if (ajaxEndpoint) { - Util.getJSON(ajaxEndpoint, function(error, response, body) { - if (error) { - throw ['ajaxSource AJAX Error', error]; + for (var i = 0; i < features.length; i++) { + var feature = features[i], + type = feature.type; + + var newGeometry; + + if (type === 1) { + newGeometry = shiftCoords(feature.geometry, offset); } else { - ajaxCallback(self, response); - return true; + newGeometry = []; + for (var j = 0; j < feature.geometry.length; j++) { + newGeometry.push(shiftCoords(feature.geometry[j], offset)); + } } - }); + + newFeatures.push({ + geometry: newGeometry, + type: type, + tags: feature.tags, + min: [feature.min[0] + offset, feature.min[1]], + max: [feature.max[0] + offset, feature.max[1]] + }); } - } - return false; -} -function ajaxCallback(self, response) { - self.ajaxData = response; + return newFeatures; +} - /** - * You can attach a callback function to a feature in your app - * that will get called whenever new ajaxData comes in. This - * can be used to update UI that looks at data from within a feature. - * - * setStyle may possibly have a style with a different ajaxData source, - * and you would potentially get new contextual data for your feature. - * - * TODO: This needs to be documented. - */ - if (typeof self.ajaxDataReceived === 'function') { - self.ajaxDataReceived(self, response); - } +function shiftCoords(points, offset) { + var newPoints = []; + newPoints.area = points.area; + newPoints.dist = points.dist; - self._setStyle(self.mvtLayer.style); - redrawTiles(self); + for (var i = 0; i < points.length; i++) { + newPoints.push([points[i][0] + offset, points[i][1], points[i][2]]); + } + return newPoints; } -MVTFeature.prototype._setStyle = function(styleFn) { - this.style = styleFn(this, this.ajaxData); +},{"./clip":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/clip.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/buffer.js":[function(require,module,exports){ +'use strict'; - // The label gets removed, and the (re)draw, - // that is initiated by the MVTLayer creates a new label. - this.removeLabel(); -}; +// lightweight Buffer shim for pbf browser build +// based on code from github.com/feross/buffer (MIT-licensed) -MVTFeature.prototype.setStyle = function(styleFn) { - this.ajaxData = null; - this.style = styleFn(this, null); - var hasAjaxSource = ajax(this); - if (!hasAjaxSource) { - // The label gets removed, and the (re)draw, - // that is initiated by the MVTLayer creates a new label. - this.removeLabel(); - } -}; +module.exports = Buffer; -MVTFeature.prototype.draw = function(canvasID) { - //Get the info from the tiles list - var tileInfo = this.tiles[canvasID]; +var ieee754 = require('ieee754'); - var vtf = tileInfo.vtf; - var ctx = tileInfo.ctx; +var BufferMethods; + +function Buffer(length) { + var arr; + if (length && length.length) { + arr = length; + length = arr.length; + } + var buf = new Uint8Array(length || 0); + if (arr) buf.set(arr); + + buf.readUInt32LE = BufferMethods.readUInt32LE; + buf.writeUInt32LE = BufferMethods.writeUInt32LE; + buf.readInt32LE = BufferMethods.readInt32LE; + buf.writeInt32LE = BufferMethods.writeInt32LE; + buf.readFloatLE = BufferMethods.readFloatLE; + buf.writeFloatLE = BufferMethods.writeFloatLE; + buf.readDoubleLE = BufferMethods.readDoubleLE; + buf.writeDoubleLE = BufferMethods.writeDoubleLE; + buf.toString = BufferMethods.toString; + buf.write = BufferMethods.write; + buf.slice = BufferMethods.slice; + buf.copy = BufferMethods.copy; + + buf._isBuffer = true; + return buf; +} + +var lastStr, lastStrEncoded; + +BufferMethods = { + readUInt32LE: function(pos) { + return ((this[pos]) | + (this[pos + 1] << 8) | + (this[pos + 2] << 16)) + + (this[pos + 3] * 0x1000000); + }, - //Get the actual canvas from the parent layer's _tiles object. - var xy = canvasID.split(":").slice(1, 3).join(":"); - ctx.canvas = this.mvtLayer._tiles[xy]; + writeUInt32LE: function(val, pos) { + this[pos] = val; + this[pos + 1] = (val >>> 8); + this[pos + 2] = (val >>> 16); + this[pos + 3] = (val >>> 24); + }, -// This could be used to directly compute the style function from the layer on every draw. -// This is much less efficient... -// this.style = this.mvtLayer.style(this); + readInt32LE: function(pos) { + return ((this[pos]) | + (this[pos + 1] << 8) | + (this[pos + 2] << 16)) + + (this[pos + 3] << 24); + }, - if (this.selected) { - var style = this.style.selected || this.style; - } else { - var style = this.style; - } + readFloatLE: function(pos) { return ieee754.read(this, pos, true, 23, 4); }, + readDoubleLE: function(pos) { return ieee754.read(this, pos, true, 52, 8); }, - switch (vtf.type) { - case 1: //Point - this._drawPoint(ctx, vtf.coordinates, style); - if (!this.staticLabel && typeof this.style.staticLabel === 'function') { - if (this.style.ajaxSource && !this.ajaxData) { - break; + writeFloatLE: function(val, pos) { return ieee754.write(this, val, pos, true, 23, 4); }, + writeDoubleLE: function(val, pos) { return ieee754.write(this, val, pos, true, 52, 8); }, + + toString: function(encoding, start, end) { + var str = '', + tmp = ''; + + start = start || 0; + end = Math.min(this.length, end || this.length); + + for (var i = start; i < end; i++) { + var ch = this[i]; + if (ch <= 0x7F) { + str += decodeURIComponent(tmp) + String.fromCharCode(ch); + tmp = ''; + } else { + tmp += '%' + ch.toString(16); + } } - this._drawStaticLabel(ctx, vtf.coordinates, style); - } - break; - case 2: //LineString - this._drawLineString(ctx, vtf.coordinates, style); - break; + str += decodeURIComponent(tmp); - case 3: //Polygon - this._drawPolygon(ctx, vtf.coordinates, style); - break; + return str; + }, - default: - throw new Error('Unmanaged type: ' + vtf.type); - } + write: function(str, pos) { + var bytes = str === lastStr ? lastStrEncoded : encodeString(str); + for (var i = 0; i < bytes.length; i++) { + this[pos + i] = bytes[i]; + } + }, + slice: function(start, end) { + return this.subarray(start, end); + }, + + copy: function(buf, pos) { + pos = pos || 0; + for (var i = 0; i < this.length; i++) { + buf[pos + i] = this[i]; + } + } }; -MVTFeature.prototype.getPathsForTile = function(canvasID) { - //Get the info from the parts list - return this.tiles[canvasID].paths; +BufferMethods.writeInt32LE = BufferMethods.writeUInt32LE; + +Buffer.byteLength = function(str) { + lastStr = str; + lastStrEncoded = encodeString(str); + return lastStrEncoded.length; }; -MVTFeature.prototype.addTileFeature = function(vtf, ctx) { - //Store the important items in the tiles list +Buffer.isBuffer = function(buf) { + return !!(buf && buf._isBuffer); +}; - //We only want to store info for tiles for the current map zoom. If it is tile info for another zoom level, ignore it - //Also, if there are existing tiles in the list for other zoom levels, expunge them. - var zoom = this.map.getZoom(); +function encodeString(str) { + var length = str.length, + bytes = []; - if(ctx.zoom != zoom) return; + for (var i = 0, c, lead; i < length; i++) { + c = str.charCodeAt(i); // code point - this.clearTileFeatures(zoom); //TODO: This iterates thru all tiles every time a new tile is added. Figure out a better way to do this. + if (c > 0xD7FF && c < 0xE000) { - this.tiles[ctx.id] = { - ctx: ctx, - vtf: vtf, - paths: [] - }; + if (lead) { + if (c < 0xDC00) { + bytes.push(0xEF, 0xBF, 0xBD); + lead = c; + continue; -}; + } else { + c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000; + lead = null; + } + } else { + if (c > 0xDBFF || (i + 1 === length)) bytes.push(0xEF, 0xBF, 0xBD); + else lead = c; -/** - * Clear the inner list of tile features if they don't match the given zoom. - * - * @param zoom - */ -MVTFeature.prototype.clearTileFeatures = function(zoom) { - //If stored tiles exist for other zoom levels, expunge them from the list. - for (var key in this.tiles) { - if(key.split(":")[0] != zoom) delete this.tiles[key]; - } -}; + continue; + } -/** - * Redraws all of the tiles associated with a feature. Useful for - * style change and toggling. - * - * @param self - */ -function redrawTiles(self) { - //Redraw the whole tile, not just this vtf - var tiles = self.tiles; - var mvtLayer = self.mvtLayer; + } else if (lead) { + bytes.push(0xEF, 0xBF, 0xBD); + lead = null; + } - for (var id in tiles) { - var tileZoom = parseInt(id.split(':')[0]); - var mapZoom = self.map.getZoom(); - if (tileZoom === mapZoom) { - //Redraw the tile - mvtLayer.redrawTile(id); + if (c < 0x80) bytes.push(c); + else if (c < 0x800) bytes.push(c >> 0x6 | 0xC0, c & 0x3F | 0x80); + else if (c < 0x10000) bytes.push(c >> 0xC | 0xE0, c >> 0x6 & 0x3F | 0x80, c & 0x3F | 0x80); + else bytes.push(c >> 0x12 | 0xF0, c >> 0xC & 0x3F | 0x80, c >> 0x6 & 0x3F | 0x80, c & 0x3F | 0x80); } - } + return bytes; } -MVTFeature.prototype.toggle = function() { - if (this.selected) { - this.deselect(); - } else { - this.select(); - } -}; +},{"ieee754":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/node_modules/ieee754/index.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/index.js":[function(require,module,exports){ +(function (global){ +'use strict'; -MVTFeature.prototype.select = function() { - this.selected = true; - this.mvtSource.featureSelected(this); - redrawTiles(this); - var linkedFeature = this.linkedFeature(); - if (linkedFeature && linkedFeature.staticLabel && !linkedFeature.staticLabel.selected) { - linkedFeature.staticLabel.select(); - } -}; +module.exports = Pbf; -MVTFeature.prototype.deselect = function() { - this.selected = false; - this.mvtSource.featureDeselected(this); - redrawTiles(this); - var linkedFeature = this.linkedFeature(); - if (linkedFeature && linkedFeature.staticLabel && linkedFeature.staticLabel.selected) { - linkedFeature.staticLabel.deselect(); - } -}; +var Buffer = global.Buffer || require('./buffer'); -MVTFeature.prototype.on = function(eventType, callback) { - this._eventHandlers[eventType] = callback; -}; +function Pbf(buf) { + this.buf = !Buffer.isBuffer(buf) ? new Buffer(buf || 0) : buf; + this.pos = 0; + this.length = this.buf.length; +} -MVTFeature.prototype._drawPoint = function(ctx, coordsArray, style) { - if (!style) return; - if (!ctx || !ctx.canvas) return; +Pbf.Varint = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum +Pbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64 +Pbf.Bytes = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields +Pbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32 - var tile = this.tiles[ctx.id]; +var SHIFT_LEFT_32 = (1 << 16) * (1 << 16), + SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32, + POW_2_63 = Math.pow(2, 63); - //Get radius - var radius = 1; - if (typeof style.radius === 'function') { - radius = style.radius(ctx.zoom); //Allows for scale dependent rednering - } - else{ - radius = style.radius; - } +Pbf.prototype = { - var p = this._tilePoint(coordsArray[0][0]); - var c = ctx.canvas; - var ctx2d; - try{ - ctx2d = c.getContext('2d'); - } - catch(e){ - console.log("_drawPoint error: " + e); - return; - } + destroy: function() { + this.buf = null; + }, - ctx2d.beginPath(); - ctx2d.fillStyle = style.color; - ctx2d.arc(p.x, p.y, radius, 0, Math.PI * 2); - ctx2d.closePath(); - ctx2d.fill(); + // === READING ================================================================= - if(style.lineWidth && style.strokeStyle){ - ctx2d.lineWidth = style.lineWidth; - ctx2d.strokeStyle = style.strokeStyle; - ctx2d.stroke(); - } + readFields: function(readField, result, end) { + end = end || this.length; - ctx2d.restore(); - tile.paths.push([p]); -}; + while (this.pos < end) { + var val = this.readVarint(), + tag = val >> 3, + startPos = this.pos; -MVTFeature.prototype._drawLineString = function(ctx, coordsArray, style) { - if (!style) return; - if (!ctx || !ctx.canvas) return; + readField(tag, result, this); - var ctx2d = ctx.canvas.getContext('2d'); - ctx2d.strokeStyle = style.color; - ctx2d.lineWidth = style.size; - ctx2d.beginPath(); + if (this.pos === startPos) this.skip(val); + } + return result; + }, - var projCoords = []; - var tile = this.tiles[ctx.id]; + readMessage: function(readField, result) { + return this.readFields(readField, result, this.readVarint() + this.pos); + }, - for (var gidx in coordsArray) { - var coords = coordsArray[gidx]; + readFixed32: function() { + var val = this.buf.readUInt32LE(this.pos); + this.pos += 4; + return val; + }, - for (i = 0; i < coords.length; i++) { - var method = (i === 0 ? 'move' : 'line') + 'To'; - var proj = this._tilePoint(coords[i]); - projCoords.push(proj); - ctx2d[method](proj.x, proj.y); - } - } + readSFixed32: function() { + var val = this.buf.readInt32LE(this.pos); + this.pos += 4; + return val; + }, - ctx2d.stroke(); - ctx2d.restore(); + // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed) - tile.paths.push(projCoords); -}; + readFixed64: function() { + var val = this.buf.readUInt32LE(this.pos) + this.buf.readUInt32LE(this.pos + 4) * SHIFT_LEFT_32; + this.pos += 8; + return val; + }, -MVTFeature.prototype._drawPolygon = function(ctx, coordsArray, style) { - if (!style) return; - if (!ctx || !ctx.canvas) return; + readSFixed64: function() { + var val = this.buf.readUInt32LE(this.pos) + this.buf.readInt32LE(this.pos + 4) * SHIFT_LEFT_32; + this.pos += 8; + return val; + }, - var ctx2d = ctx.canvas.getContext('2d'); - var outline = style.outline; + readFloat: function() { + var val = this.buf.readFloatLE(this.pos); + this.pos += 4; + return val; + }, - // color may be defined via function to make choropleth work right - if (typeof style.color === 'function') { - ctx2d.fillStyle = style.color(ctx2d); - } else { - ctx2d.fillStyle = style.color; - } + readDouble: function() { + var val = this.buf.readDoubleLE(this.pos); + this.pos += 8; + return val; + }, - if (outline) { - ctx2d.strokeStyle = outline.color; - ctx2d.lineWidth = outline.size; - } - ctx2d.beginPath(); + readVarint: function() { + var buf = this.buf, + val, b, b0, b1, b2, b3; - var projCoords = []; - var tile = this.tiles[ctx.id]; + b0 = buf[this.pos++]; if (b0 < 0x80) return b0; b0 = b0 & 0x7f; + b1 = buf[this.pos++]; if (b1 < 0x80) return b0 | b1 << 7; b1 = (b1 & 0x7f) << 7; + b2 = buf[this.pos++]; if (b2 < 0x80) return b0 | b1 | b2 << 14; b2 = (b2 & 0x7f) << 14; + b3 = buf[this.pos++]; if (b3 < 0x80) return b0 | b1 | b2 | b3 << 21; - var featureLabel = this.dynamicLabel; - if (featureLabel) { - featureLabel.addTilePolys(ctx, coordsArray); - } + val = b0 | b1 | b2 | (b3 & 0x7f) << 21; - for (var gidx = 0, len = coordsArray.length; gidx < len; gidx++) { - var coords = coordsArray[gidx]; + b = buf[this.pos++]; val += (b & 0x7f) * 0x10000000; if (b < 0x80) return val; + b = buf[this.pos++]; val += (b & 0x7f) * 0x800000000; if (b < 0x80) return val; + b = buf[this.pos++]; val += (b & 0x7f) * 0x40000000000; if (b < 0x80) return val; + b = buf[this.pos++]; val += (b & 0x7f) * 0x2000000000000; if (b < 0x80) return val; + b = buf[this.pos++]; val += (b & 0x7f) * 0x100000000000000; if (b < 0x80) return val; + b = buf[this.pos++]; val += (b & 0x7f) * 0x8000000000000000; if (b < 0x80) return val; - for (var i = 0; i < coords.length; i++) { - var coord = coords[i]; - var method = (i === 0 ? 'move' : 'line') + 'To'; - var proj = this._tilePoint(coords[i]); - projCoords.push(proj); - ctx2d[method](proj.x, proj.y); - } - } + throw new Error('Expected varint not more than 10 bytes'); + }, - ctx2d.closePath(); - ctx2d.fill(); - if (outline) { - ctx2d.stroke(); - } + readVarint64: function() { + var startPos = this.pos, + val = this.readVarint(); - tile.paths.push(projCoords); + if (val < POW_2_63) return val; -}; + var pos = this.pos - 2; + while (this.buf[pos] === 0xff) pos--; + if (pos < startPos) pos = startPos; -MVTFeature.prototype._drawStaticLabel = function(ctx, coordsArray, style) { - if (!style) return; - if (!ctx) return; + val = 0; + for (var i = 0; i < pos - startPos + 1; i++) { + var b = ~this.buf[startPos + i] & 0x7f; + val += i < 4 ? b << i * 7 : b * Math.pow(2, i * 7); + } - // If the corresponding layer is not on the map, - // we dont want to put on a label. - if (!this.mvtLayer._map) return; + return -val - 1; + }, - var vecPt = this._tilePoint(coordsArray[0][0]); + readSVarint: function() { + var num = this.readVarint(); + return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding + }, - // We're making a standard Leaflet Marker for this label. - var p = this._project(vecPt, ctx.tile.x, ctx.tile.y, this.extent, this.tileSize); //vectile pt to merc pt - var mercPt = L.point(p.x, p.y); // make into leaflet obj - var latLng = this.map.unproject(mercPt); // merc pt to latlng + readBoolean: function() { + return Boolean(this.readVarint()); + }, - this.staticLabel = new StaticLabel(this, ctx, latLng, style); - this.mvtLayer.featureWithLabelAdded(this); -}; + readString: function() { + var end = this.readVarint() + this.pos, + str = this.buf.toString('utf8', this.pos, end); + this.pos = end; + return str; + }, -MVTFeature.prototype.removeLabel = function() { - if (!this.staticLabel) return; - this.staticLabel.remove(); - this.staticLabel = null; -}; - -/** - * Projects a vector tile point to the Spherical Mercator pixel space for a given zoom level. - * - * @param vecPt - * @param tileX - * @param tileY - * @param extent - * @param tileSize - */ -MVTFeature.prototype._project = function(vecPt, tileX, tileY, extent, tileSize) { - var xOffset = tileX * tileSize; - var yOffset = tileY * tileSize; - return { - x: Math.floor(vecPt.x + xOffset), - y: Math.floor(vecPt.y + yOffset) - }; -}; - -/** - * Takes a coordinate from a vector tile and turns it into a Leaflet Point. - * - * @param ctx - * @param coords - * @returns {eGeomType.Point} - * @private - */ -MVTFeature.prototype._tilePoint = function(coords) { - return new L.Point(coords.x / this.divisor, coords.y / this.divisor); -}; + readBytes: function() { + var end = this.readVarint() + this.pos, + buffer = this.buf.slice(this.pos, end); + this.pos = end; + return buffer; + }, -MVTFeature.prototype.linkedFeature = function() { - var linkedLayer = this.mvtLayer.linkedLayer(); - if(linkedLayer){ - var linkedFeature = linkedLayer.features[this.id]; - return linkedFeature; - }else{ - return null; - } -}; + // verbose for performance reasons; doesn't affect gzipped size + readPackedVarint: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readVarint()); + return arr; + }, + readPackedSVarint: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readSVarint()); + return arr; + }, + readPackedBoolean: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readBoolean()); + return arr; + }, + readPackedFloat: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readFloat()); + return arr; + }, + readPackedDouble: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readDouble()); + return arr; + }, + readPackedFixed32: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readFixed32()); + return arr; + }, + readPackedSFixed32: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readSFixed32()); + return arr; + }, + readPackedFixed64: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readFixed64()); + return arr; + }, + readPackedSFixed64: function() { + var end = this.readVarint() + this.pos, arr = []; + while (this.pos < end) arr.push(this.readSFixed64()); + return arr; + }, -},{"./MVTUtil":11,"./StaticLabel/StaticLabel.js":12}],9:[function(require,module,exports){ -/** - * Created by Ryan Whitley on 5/17/14. - */ -/** Forked from https://gist.github.com/DGuidi/1716010 **/ -var MVTFeature = require('./MVTFeature'); -var Util = require('./MVTUtil'); + skip: function(val) { + var type = val & 0x7; + if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {} + else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos; + else if (type === Pbf.Fixed32) this.pos += 4; + else if (type === Pbf.Fixed64) this.pos += 8; + else throw new Error('Unimplemented type: ' + type); + }, -module.exports = L.TileLayer.Canvas.extend({ + // === WRITING ================================================================= - options: { - debug: false, - isHiddenLayer: false, - getIDForLayerFeature: function() {}, - tileSize: 256, - lineClickTolerance: 2 - }, + writeTag: function(tag, type) { + this.writeVarint((tag << 3) | type); + }, - _featureIsClicked: {}, + realloc: function(min) { + var length = this.length || 16; - _isPointInPoly: function(pt, poly) { - if(poly && poly.length) { - for (var c = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i) - ((poly[i].y <= pt.y && pt.y < poly[j].y) || (poly[j].y <= pt.y && pt.y < poly[i].y)) - && (pt.x < (poly[j].x - poly[i].x) * (pt.y - poly[i].y) / (poly[j].y - poly[i].y) + poly[i].x) - && (c = !c); - return c; - } - }, + while (length < this.pos + min) length *= 2; - _getDistanceFromLine: function(pt, pts) { - var min = Number.POSITIVE_INFINITY; - if (pts && pts.length > 1) { - pt = L.point(pt.x, pt.y); - for (var i = 0, l = pts.length - 1; i < l; i++) { - var test = this._projectPointOnLineSegment(pt, pts[i], pts[i + 1]); - if (test.distance <= min) { - min = test.distance; + if (length !== this.length) { + var buf = new Buffer(length); + this.buf.copy(buf); + this.buf = buf; + this.length = length; } - } - } - return min; - }, + }, - _projectPointOnLineSegment: function(p, r0, r1) { - var lineLength = r0.distanceTo(r1); - if (lineLength < 1) { - return {distance: p.distanceTo(r0), coordinate: r0}; - } - var u = ((p.x - r0.x) * (r1.x - r0.x) + (p.y - r0.y) * (r1.y - r0.y)) / Math.pow(lineLength, 2); - if (u < 0.0000001) { - return {distance: p.distanceTo(r0), coordinate: r0}; - } - if (u > 0.9999999) { - return {distance: p.distanceTo(r1), coordinate: r1}; - } - var a = L.point(r0.x + u * (r1.x - r0.x), r0.y + u * (r1.y - r0.y)); - return {distance: p.distanceTo(a), point: a}; - }, + finish: function() { + this.length = this.pos; + this.pos = 0; + return this.buf.slice(0, this.length); + }, - initialize: function(mvtSource, options) { - var self = this; - self.mvtSource = mvtSource; - L.Util.setOptions(this, options); + writeFixed32: function(val) { + this.realloc(4); + this.buf.writeUInt32LE(val, this.pos); + this.pos += 4; + }, - this.style = options.style; - this.name = options.name; - this._canvasIDToFeatures = {}; - this.features = {}; - this.featuresWithLabels = []; - this._highestCount = 0; - }, + writeSFixed32: function(val) { + this.realloc(4); + this.buf.writeInt32LE(val, this.pos); + this.pos += 4; + }, - onAdd: function(map) { - var self = this; - self.map = map; - L.TileLayer.Canvas.prototype.onAdd.call(this, map); - map.on('layerremove', function(e) { - // we only want to do stuff when the layerremove event is on this layer - if (e.layer._leaflet_id === self._leaflet_id) { - removeLabels(self); - } - }); - }, + writeFixed64: function(val) { + this.realloc(8); + this.buf.writeInt32LE(val & -1, this.pos); + this.buf.writeUInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4); + this.pos += 8; + }, - drawTile: function(canvas, tilePoint, zoom) { + writeSFixed64: function(val) { + this.realloc(8); + this.buf.writeInt32LE(val & -1, this.pos); + this.buf.writeInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4); + this.pos += 8; + }, - var ctx = { - canvas: canvas, - tile: tilePoint, - zoom: zoom, - tileSize: this.options.tileSize - }; + writeVarint: function(val) { + val = +val; - ctx.id = Util.getContextID(ctx); + if (val <= 0x7f) { + this.realloc(1); + this.buf[this.pos++] = val; + + } else if (val <= 0x3fff) { + this.realloc(2); + this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80; + this.buf[this.pos++] = ((val >>> 7) & 0x7f); + + } else if (val <= 0x1fffff) { + this.realloc(3); + this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80; + this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80; + this.buf[this.pos++] = ((val >>> 14) & 0x7f); + + } else if (val <= 0xfffffff) { + this.realloc(4); + this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80; + this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80; + this.buf[this.pos++] = ((val >>> 14) & 0x7f) | 0x80; + this.buf[this.pos++] = ((val >>> 21) & 0x7f); - if (!this._canvasIDToFeatures[ctx.id]) { - this._initializeFeaturesHash(ctx); - } - if (!this.features) { - this.features = {}; - } + } else { + var pos = this.pos; + while (val >= 0x80) { + this.realloc(1); + this.buf[this.pos++] = (val & 0xff) | 0x80; + val /= 0x80; + } + this.realloc(1); + this.buf[this.pos++] = val | 0; + if (this.pos - pos > 10) throw new Error('Given varint doesn\'t fit into 10 bytes'); + } + }, - }, + writeSVarint: function(val) { + this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2); + }, - _initializeFeaturesHash: function(ctx){ - this._canvasIDToFeatures[ctx.id] = {}; - this._canvasIDToFeatures[ctx.id].features = []; - this._canvasIDToFeatures[ctx.id].canvas = ctx.canvas; - }, + writeBoolean: function(val) { + this.writeVarint(Boolean(val)); + }, - _draw: function(ctx) { - //Draw is handled by the parent MVTSource object - }, - getCanvas: function(parentCtx){ - //This gets called if a vector tile feature has already been parsed. - //We've already got the geom, just get on with the drawing. - //Need a way to pluck a canvas element from this layer given the parent layer's id. - //Wait for it to get loaded before proceeding. - var tilePoint = parentCtx.tile; - var ctx = this._tiles[tilePoint.x + ":" + tilePoint.y]; + writeString: function(str) { + str = String(str); + var bytes = Buffer.byteLength(str); + this.writeVarint(bytes); + this.realloc(bytes); + this.buf.write(str, this.pos); + this.pos += bytes; + }, - if(ctx){ - parentCtx.canvas = ctx; - this.redrawTile(parentCtx.id); - return; - } + writeFloat: function(val) { + this.realloc(4); + this.buf.writeFloatLE(val, this.pos); + this.pos += 4; + }, - var self = this; + writeDouble: function(val) { + this.realloc(8); + this.buf.writeDoubleLE(val, this.pos); + this.pos += 8; + }, - //This is a timer that will wait for a criterion to return true. - //If not true within the timeout duration, it will move on. - waitFor(function () { - ctx = self._tiles[tilePoint.x + ":" + tilePoint.y]; - if(ctx) { - return true; - } - }, - function(){ - //When it finishes, do this. - ctx = self._tiles[tilePoint.x + ":" + tilePoint.y]; - parentCtx.canvas = ctx; - self.redrawTile(parentCtx.id); + writeBytes: function(buffer) { + var len = buffer.length; + this.writeVarint(len); + this.realloc(len); + for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i]; + }, - }, //when done, go to next flow - 2000); //The Timeout milliseconds. After this, give up and move on + writeRawMessage: function(fn, obj) { + this.pos++; // reserve 1 byte for short message length - }, + // write the message directly to the buffer and see how much was written + var startPos = this.pos; + fn(obj, this); + var len = this.pos - startPos; - parseVectorTileLayer: function(vtl, ctx) { - var self = this; - var tilePoint = ctx.tile; - var layerCtx = { canvas: null, id: ctx.id, tile: ctx.tile, zoom: ctx.zoom, tileSize: ctx.tileSize}; + var varintLen = + len <= 0x7f ? 1 : + len <= 0x3fff ? 2 : + len <= 0x1fffff ? 3 : + len <= 0xfffffff ? 4 : Math.ceil(Math.log(len) / (Math.LN2 * 7)); - //See if we can pluck the child tile from this PBF tile layer based on the master layer's tile id. - layerCtx.canvas = self._tiles[tilePoint.x + ":" + tilePoint.y]; + // if 1 byte isn't enough for encoding message length, shift the data to the right + if (varintLen > 1) { + this.realloc(varintLen - 1); + for (var i = this.pos - 1; i >= startPos; i--) this.buf[i + varintLen - 1] = this.buf[i]; + } + // finally, write the message length in the reserved place and restore the position + this.pos = startPos - 1; + this.writeVarint(len); + this.pos += len; + }, + writeMessage: function(tag, fn, obj) { + this.writeTag(tag, Pbf.Bytes); + this.writeRawMessage(fn, obj); + }, - //Initialize this tile's feature storage hash, if it hasn't already been created. Used for when filters are updated, and features are cleared to prepare for a fresh redraw. - if (!this._canvasIDToFeatures[layerCtx.id]) { - this._initializeFeaturesHash(layerCtx); - }else{ - //Clear this tile's previously saved features. - this.clearTileFeatureHash(layerCtx.id); + writePackedVarint: function(tag, arr) { this.writeMessage(tag, writePackedVarint, arr); }, + writePackedSVarint: function(tag, arr) { this.writeMessage(tag, writePackedSVarint, arr); }, + writePackedBoolean: function(tag, arr) { this.writeMessage(tag, writePackedBoolean, arr); }, + writePackedFloat: function(tag, arr) { this.writeMessage(tag, writePackedFloat, arr); }, + writePackedDouble: function(tag, arr) { this.writeMessage(tag, writePackedDouble, arr); }, + writePackedFixed32: function(tag, arr) { this.writeMessage(tag, writePackedFixed32, arr); }, + writePackedSFixed32: function(tag, arr) { this.writeMessage(tag, writePackedSFixed32, arr); }, + writePackedFixed64: function(tag, arr) { this.writeMessage(tag, writePackedFixed64, arr); }, + writePackedSFixed64: function(tag, arr) { this.writeMessage(tag, writePackedSFixed64, arr); }, + + writeBytesField: function(tag, buffer) { + this.writeTag(tag, Pbf.Bytes); + this.writeBytes(buffer); + }, + writeFixed32Field: function(tag, val) { + this.writeTag(tag, Pbf.Fixed32); + this.writeFixed32(val); + }, + writeSFixed32Field: function(tag, val) { + this.writeTag(tag, Pbf.Fixed32); + this.writeSFixed32(val); + }, + writeFixed64Field: function(tag, val) { + this.writeTag(tag, Pbf.Fixed64); + this.writeFixed64(val); + }, + writeSFixed64Field: function(tag, val) { + this.writeTag(tag, Pbf.Fixed64); + this.writeSFixed64(val); + }, + writeVarintField: function(tag, val) { + this.writeTag(tag, Pbf.Varint); + this.writeVarint(val); + }, + writeSVarintField: function(tag, val) { + this.writeTag(tag, Pbf.Varint); + this.writeSVarint(val); + }, + writeStringField: function(tag, str) { + this.writeTag(tag, Pbf.Bytes); + this.writeString(str); + }, + writeFloatField: function(tag, val) { + this.writeTag(tag, Pbf.Fixed32); + this.writeFloat(val); + }, + writeDoubleField: function(tag, val) { + this.writeTag(tag, Pbf.Fixed64); + this.writeDouble(val); + }, + writeBooleanField: function(tag, val) { + this.writeVarintField(tag, Boolean(val)); } +}; - var features = vtl.parsedFeatures; - for (var i = 0, len = features.length; i < len; i++) { - var vtf = features[i]; //vector tile feature - vtf.layer = vtl; +function writePackedVarint(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]); } +function writePackedSVarint(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]); } +function writePackedFloat(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]); } +function writePackedDouble(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]); } +function writePackedBoolean(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]); } +function writePackedFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]); } +function writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); } +function writePackedFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]); } +function writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); } - /** - * Apply filter on feature if there is one. Defined in the options object - * of TileLayer.MVTSource.js - */ - var filter = self.options.filter; - if (typeof filter === 'function') { - if ( filter(vtf, layerCtx) === false ) continue; - } +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/pbf/index.js"],"names":[],"mappings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file":"generated.js","sourceRoot":"","sourcesContent":["'use strict';\n\nmodule.exports = Pbf;\n\nvar Buffer = global.Buffer || require('./buffer');\n\nfunction Pbf(buf) {\n    this.buf = !Buffer.isBuffer(buf) ? new Buffer(buf || 0) : buf;\n    this.pos = 0;\n    this.length = this.buf.length;\n}\n\nPbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum\nPbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64\nPbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields\nPbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32\n\nvar SHIFT_LEFT_32 = (1 << 16) * (1 << 16),\n    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32,\n    POW_2_63 = Math.pow(2, 63);\n\nPbf.prototype = {\n\n    destroy: function() {\n        this.buf = null;\n    },\n\n    // === READING =================================================================\n\n    readFields: function(readField, result, end) {\n        end = end || this.length;\n\n        while (this.pos < end) {\n            var val = this.readVarint(),\n                tag = val >> 3,\n                startPos = this.pos;\n\n            readField(tag, result, this);\n\n            if (this.pos === startPos) this.skip(val);\n        }\n        return result;\n    },\n\n    readMessage: function(readField, result) {\n        return this.readFields(readField, result, this.readVarint() + this.pos);\n    },\n\n    readFixed32: function() {\n        var val = this.buf.readUInt32LE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readSFixed32: function() {\n        var val = this.buf.readInt32LE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)\n\n    readFixed64: function() {\n        var val = this.buf.readUInt32LE(this.pos) + this.buf.readUInt32LE(this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readSFixed64: function() {\n        var val = this.buf.readUInt32LE(this.pos) + this.buf.readInt32LE(this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readFloat: function() {\n        var val = this.buf.readFloatLE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readDouble: function() {\n        var val = this.buf.readDoubleLE(this.pos);\n        this.pos += 8;\n        return val;\n    },\n\n    readVarint: function() {\n        var buf = this.buf,\n            val, b, b0, b1, b2, b3;\n\n        b0 = buf[this.pos++]; if (b0 < 0x80) return b0;                 b0 = b0 & 0x7f;\n        b1 = buf[this.pos++]; if (b1 < 0x80) return b0 | b1 << 7;       b1 = (b1 & 0x7f) << 7;\n        b2 = buf[this.pos++]; if (b2 < 0x80) return b0 | b1 | b2 << 14; b2 = (b2 & 0x7f) << 14;\n        b3 = buf[this.pos++]; if (b3 < 0x80) return b0 | b1 | b2 | b3 << 21;\n\n        val = b0 | b1 | b2 | (b3 & 0x7f) << 21;\n\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x10000000;         if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x800000000;        if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x40000000000;      if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x2000000000000;    if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x100000000000000;  if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x8000000000000000; if (b < 0x80) return val;\n\n        throw new Error('Expected varint not more than 10 bytes');\n    },\n\n    readVarint64: function() {\n        var startPos = this.pos,\n            val = this.readVarint();\n\n        if (val < POW_2_63) return val;\n\n        var pos = this.pos - 2;\n        while (this.buf[pos] === 0xff) pos--;\n        if (pos < startPos) pos = startPos;\n\n        val = 0;\n        for (var i = 0; i < pos - startPos + 1; i++) {\n            var b = ~this.buf[startPos + i] & 0x7f;\n            val += i < 4 ? b << i * 7 : b * Math.pow(2, i * 7);\n        }\n\n        return -val - 1;\n    },\n\n    readSVarint: function() {\n        var num = this.readVarint();\n        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding\n    },\n\n    readBoolean: function() {\n        return Boolean(this.readVarint());\n    },\n\n    readString: function() {\n        var end = this.readVarint() + this.pos,\n            str = this.buf.toString('utf8', this.pos, end);\n        this.pos = end;\n        return str;\n    },\n\n    readBytes: function() {\n        var end = this.readVarint() + this.pos,\n            buffer = this.buf.slice(this.pos, end);\n        this.pos = end;\n        return buffer;\n    },\n\n    // verbose for performance reasons; doesn't affect gzipped size\n\n    readPackedVarint: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readVarint());\n        return arr;\n    },\n    readPackedSVarint: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSVarint());\n        return arr;\n    },\n    readPackedBoolean: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readBoolean());\n        return arr;\n    },\n    readPackedFloat: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFloat());\n        return arr;\n    },\n    readPackedDouble: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readDouble());\n        return arr;\n    },\n    readPackedFixed32: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFixed32());\n        return arr;\n    },\n    readPackedSFixed32: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSFixed32());\n        return arr;\n    },\n    readPackedFixed64: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFixed64());\n        return arr;\n    },\n    readPackedSFixed64: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSFixed64());\n        return arr;\n    },\n\n    skip: function(val) {\n        var type = val & 0x7;\n        if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}\n        else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;\n        else if (type === Pbf.Fixed32) this.pos += 4;\n        else if (type === Pbf.Fixed64) this.pos += 8;\n        else throw new Error('Unimplemented type: ' + type);\n    },\n\n    // === WRITING =================================================================\n\n    writeTag: function(tag, type) {\n        this.writeVarint((tag << 3) | type);\n    },\n\n    realloc: function(min) {\n        var length = this.length || 16;\n\n        while (length < this.pos + min) length *= 2;\n\n        if (length !== this.length) {\n            var buf = new Buffer(length);\n            this.buf.copy(buf);\n            this.buf = buf;\n            this.length = length;\n        }\n    },\n\n    finish: function() {\n        this.length = this.pos;\n        this.pos = 0;\n        return this.buf.slice(0, this.length);\n    },\n\n    writeFixed32: function(val) {\n        this.realloc(4);\n        this.buf.writeUInt32LE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeSFixed32: function(val) {\n        this.realloc(4);\n        this.buf.writeInt32LE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeFixed64: function(val) {\n        this.realloc(8);\n        this.buf.writeInt32LE(val & -1, this.pos);\n        this.buf.writeUInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeSFixed64: function(val) {\n        this.realloc(8);\n        this.buf.writeInt32LE(val & -1, this.pos);\n        this.buf.writeInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeVarint: function(val) {\n        val = +val;\n\n        if (val <= 0x7f) {\n            this.realloc(1);\n            this.buf[this.pos++] = val;\n\n        } else if (val <= 0x3fff) {\n            this.realloc(2);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f);\n\n        } else if (val <= 0x1fffff) {\n            this.realloc(3);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 14) & 0x7f);\n\n        } else if (val <= 0xfffffff) {\n            this.realloc(4);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 14) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 21) & 0x7f);\n\n        } else {\n            var pos = this.pos;\n            while (val >= 0x80) {\n                this.realloc(1);\n                this.buf[this.pos++] = (val & 0xff) | 0x80;\n                val /= 0x80;\n            }\n            this.realloc(1);\n            this.buf[this.pos++] = val | 0;\n            if (this.pos - pos > 10) throw new Error('Given varint doesn\\'t fit into 10 bytes');\n        }\n    },\n\n    writeSVarint: function(val) {\n        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);\n    },\n\n    writeBoolean: function(val) {\n        this.writeVarint(Boolean(val));\n    },\n\n    writeString: function(str) {\n        str = String(str);\n        var bytes = Buffer.byteLength(str);\n        this.writeVarint(bytes);\n        this.realloc(bytes);\n        this.buf.write(str, this.pos);\n        this.pos += bytes;\n    },\n\n    writeFloat: function(val) {\n        this.realloc(4);\n        this.buf.writeFloatLE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeDouble: function(val) {\n        this.realloc(8);\n        this.buf.writeDoubleLE(val, this.pos);\n        this.pos += 8;\n    },\n\n    writeBytes: function(buffer) {\n        var len = buffer.length;\n        this.writeVarint(len);\n        this.realloc(len);\n        for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];\n    },\n\n    writeRawMessage: function(fn, obj) {\n        this.pos++; // reserve 1 byte for short message length\n\n        // write the message directly to the buffer and see how much was written\n        var startPos = this.pos;\n        fn(obj, this);\n        var len = this.pos - startPos;\n\n        var varintLen =\n            len <= 0x7f ? 1 :\n            len <= 0x3fff ? 2 :\n            len <= 0x1fffff ? 3 :\n            len <= 0xfffffff ? 4 : Math.ceil(Math.log(len) / (Math.LN2 * 7));\n\n        // if 1 byte isn't enough for encoding message length, shift the data to the right\n        if (varintLen > 1) {\n            this.realloc(varintLen - 1);\n            for (var i = this.pos - 1; i >= startPos; i--) this.buf[i + varintLen - 1] = this.buf[i];\n        }\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeMessage: function(tag, fn, obj) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeRawMessage(fn, obj);\n    },\n\n    writePackedVarint:   function(tag, arr) { this.writeMessage(tag, writePackedVarint, arr);   },\n    writePackedSVarint:  function(tag, arr) { this.writeMessage(tag, writePackedSVarint, arr);  },\n    writePackedBoolean:  function(tag, arr) { this.writeMessage(tag, writePackedBoolean, arr);  },\n    writePackedFloat:    function(tag, arr) { this.writeMessage(tag, writePackedFloat, arr);    },\n    writePackedDouble:   function(tag, arr) { this.writeMessage(tag, writePackedDouble, arr);   },\n    writePackedFixed32:  function(tag, arr) { this.writeMessage(tag, writePackedFixed32, arr);  },\n    writePackedSFixed32: function(tag, arr) { this.writeMessage(tag, writePackedSFixed32, arr); },\n    writePackedFixed64:  function(tag, arr) { this.writeMessage(tag, writePackedFixed64, arr);  },\n    writePackedSFixed64: function(tag, arr) { this.writeMessage(tag, writePackedSFixed64, arr); },\n\n    writeBytesField: function(tag, buffer) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeBytes(buffer);\n    },\n    writeFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFixed32(val);\n    },\n    writeSFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeSFixed32(val);\n    },\n    writeFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeFixed64(val);\n    },\n    writeSFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeSFixed64(val);\n    },\n    writeVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeVarint(val);\n    },\n    writeSVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeSVarint(val);\n    },\n    writeStringField: function(tag, str) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeString(str);\n    },\n    writeFloatField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFloat(val);\n    },\n    writeDoubleField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeDouble(val);\n    },\n    writeBooleanField: function(tag, val) {\n        this.writeVarintField(tag, Boolean(val));\n    }\n};\n\nfunction writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }\nfunction writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }\nfunction writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }\nfunction writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }\nfunction writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }\nfunction writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }\nfunction writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }\nfunction writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }\nfunction writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }\n"]} +},{"./buffer":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/buffer.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/node_modules/ieee754/index.js":[function(require,module,exports){ +exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] - var getIDForLayerFeature; - if (typeof self.options.getIDForLayerFeature === 'function') { - getIDForLayerFeature = self.options.getIDForLayerFeature; - } else { - getIDForLayerFeature = Util.getIDForLayerFeature; - } - var uniqueID = self.options.getIDForLayerFeature(vtf) || i; - var mvtFeature = self.features[uniqueID]; + i += d - /** - * Use layerOrdering function to apply a zIndex property to each vtf. This is defined in - * TileLayer.MVTSource.js. Used below to sort features.npm - */ - var layerOrdering = self.options.layerOrdering; - if (typeof layerOrdering === 'function') { - layerOrdering(vtf, layerCtx); //Applies a custom property to the feature, which is used after we're thru iterating to sort - } + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - //Create a new MVTFeature if one doesn't already exist for this feature. - if (!mvtFeature) { - //Get a style for the feature - set it just once for each new MVTFeature - var style = self.style(vtf); + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - //create a new feature - self.features[uniqueID] = mvtFeature = new MVTFeature(self, vtf, layerCtx, uniqueID, style); - if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') { - self.featuresWithLabels.push(mvtFeature); - } - } else { - //Add the new part to the existing feature - mvtFeature.addTileFeature(vtf, layerCtx); - } + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) +} - //Associate & Save this feature with this tile for later - if(layerCtx && layerCtx.id) self._canvasIDToFeatures[layerCtx.id]['features'].push(mvtFeature); +exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 } - /** - * Apply sorting (zIndex) on feature if there is a function defined in the options object - * of TileLayer.MVTSource.js - */ - var layerOrdering = self.options.layerOrdering; - if (layerOrdering) { - //We've assigned the custom zIndex property when iterating above. Now just sort. - self._canvasIDToFeatures[layerCtx.id].features = self._canvasIDToFeatures[layerCtx.id].features.sort(function(a, b) { - return -(b.properties.zIndex - a.properties.zIndex) - }); + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 } + } - self.redrawTile(layerCtx.id); - }, + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - setStyle: function(styleFn) { - // refresh the number for the highest count value - // this is used only for choropleth - this._highestCount = 0; + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - // lowest count should not be 0, since we want to figure out the lowest - this._lowestCount = null; + buffer[offset + i - d] |= s * 128 +} - this.style = styleFn; - for (var key in this.features) { - var feat = this.features[key]; - feat.setStyle(styleFn); - } - var z = this.map.getZoom(); - for (var key in this._tiles) { - var id = z + ':' + key; - this.redrawTile(id); +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/point-geometry/index.js":[function(require,module,exports){ +'use strict'; + +module.exports = Point; + +function Point(x, y) { + this.x = x; + this.y = y; +} + +Point.prototype = { + clone: function() { return new Point(this.x, this.y); }, + + add: function(p) { return this.clone()._add(p); }, + sub: function(p) { return this.clone()._sub(p); }, + mult: function(k) { return this.clone()._mult(k); }, + div: function(k) { return this.clone()._div(k); }, + rotate: function(a) { return this.clone()._rotate(a); }, + matMult: function(m) { return this.clone()._matMult(m); }, + unit: function() { return this.clone()._unit(); }, + perp: function() { return this.clone()._perp(); }, + round: function() { return this.clone()._round(); }, + + mag: function() { + return Math.sqrt(this.x * this.x + this.y * this.y); + }, + + equals: function(p) { + return this.x === p.x && + this.y === p.y; + }, + + dist: function(p) { + return Math.sqrt(this.distSqr(p)); + }, + + distSqr: function(p) { + var dx = p.x - this.x, + dy = p.y - this.y; + return dx * dx + dy * dy; + }, + + angle: function() { + return Math.atan2(this.y, this.x); + }, + + angleTo: function(b) { + return Math.atan2(this.y - b.y, this.x - b.x); + }, + + angleWith: function(b) { + return this.angleWithSep(b.x, b.y); + }, + + // Find the angle of the two vectors, solving the formula for the cross product a x b = |a||b|sin(θ) for θ. + angleWithSep: function(x, y) { + return Math.atan2( + this.x * y - this.y * x, + this.x * x + this.y * y); + }, + + _matMult: function(m) { + var x = m[0] * this.x + m[1] * this.y, + y = m[2] * this.x + m[3] * this.y; + this.x = x; + this.y = y; + return this; + }, + + _add: function(p) { + this.x += p.x; + this.y += p.y; + return this; + }, + + _sub: function(p) { + this.x -= p.x; + this.y -= p.y; + return this; + }, + + _mult: function(k) { + this.x *= k; + this.y *= k; + return this; + }, + + _div: function(k) { + this.x /= k; + this.y /= k; + return this; + }, + + _unit: function() { + this._div(this.mag()); + return this; + }, + + _perp: function() { + var y = this.y; + this.y = this.x; + this.x = -y; + return this; + }, + + _rotate: function(angle) { + var cos = Math.cos(angle), + sin = Math.sin(angle), + x = cos * this.x - sin * this.y, + y = sin * this.x + cos * this.y; + this.x = x; + this.y = y; + return this; + }, + + _round: function() { + this.x = Math.round(this.x); + this.y = Math.round(this.y); + return this; } - }, +}; - /** - * As counts for choropleths come in with the ajax data, - * we want to keep track of which value is the highest - * to create the color ramp for the fills of polygons. - * @param count - */ - setHighestCount: function(count) { - if (count > this._highestCount) { - this._highestCount = count; +// constructs Point from an array if necessary +Point.convert = function (a) { + if (a instanceof Point) { + return a; } - }, + if (Array.isArray(a)) { + return new Point(a[0], a[1]); + } + return a; +}; - /** - * Returns the highest number of all of the counts that have come in - * from setHighestCount. This is assumed to be set via ajax callbacks. - * @returns {number} - */ - getHighestCount: function() { - return this._highestCount; - }, +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/index.js":[function(require,module,exports){ +module.exports.VectorTile = require('./lib/vectortile.js'); +module.exports.VectorTileFeature = require('./lib/vectortilefeature.js'); +module.exports.VectorTileLayer = require('./lib/vectortilelayer.js'); - setLowestCount: function(count) { - if (!this._lowestCount || count < this._lowestCount) { - this._lowestCount = count; +},{"./lib/vectortile.js":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortile.js","./lib/vectortilefeature.js":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilefeature.js","./lib/vectortilelayer.js":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilelayer.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortile.js":[function(require,module,exports){ +'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; } - }, +} - getLowestCount: function() { - return this._lowestCount; - }, - setCountRange: function(count) { - this.setHighestCount(count); - this.setLowestCount(count); - }, +},{"./vectortilelayer":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilelayer.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilefeature.js":[function(require,module,exports){ +'use strict'; - //This is the old way. It works, but is slow for mouseover events. Fine for click events. - handleClickEvent: function(evt, cb) { - //Click happened on the GroupLayer (Manager) and passed it here - var tileID = evt.tileID.split(":").slice(1, 3).join(":"); - var zoom = evt.tileID.split(":")[0]; - var canvas = this._tiles[tileID]; - if(!canvas) (cb(evt)); //break out - var x = evt.layerPoint.x - canvas._leaflet_pos.x; - var y = evt.layerPoint.y - canvas._leaflet_pos.y; +var Point = require('point-geometry'); - var tilePoint = {x: x, y: y}; - var features = this._canvasIDToFeatures[evt.tileID].features; +module.exports = VectorTileFeature; - var minDistance = Number.POSITIVE_INFINITY; - var nearest = null; - var j, paths, distance; +function VectorTileFeature(pbf, end, extent, keys, values) { + // Public + this.properties = {}; + this.extent = extent; + this.type = 0; - for (var i = 0; i < features.length; i++) { - var feature = features[i]; - switch (feature.type) { + // Private + this._pbf = pbf; + this._geometry = -1; + this._keys = keys; + this._values = values; - case 1: //Point - currently rendered as circular paths. Intersect with that. + pbf.readFields(readFeature, this, end); +} - //Find the radius of the point. - var radius = 3; - if (typeof feature.style.radius === 'function') { - radius = feature.style.radius(zoom); //Allows for scale dependent rednering - } - else{ - radius = feature.style.radius; - } +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; +} - paths = feature.getPathsForTile(evt.tileID); - for (j = 0; j < paths.length; j++) { - //Builds a circle of radius feature.style.radius (assuming circular point symbology). - if(in_circle(paths[j][0].x, paths[j][0].y, radius, x, y)){ - nearest = feature; - minDistance = 0; - } - } - break; +function readTag(pbf, feature) { + var end = pbf.readVarint() + pbf.pos; - case 2: //LineString - paths = feature.getPathsForTile(evt.tileID); - for (j = 0; j < paths.length; j++) { - if (feature.style) { - var distance = this._getDistanceFromLine(tilePoint, paths[j]); - var thickness = (feature.selected && feature.style.selected ? feature.style.selected.size : feature.style.size); - if (distance < thickness / 2 + this.options.lineClickTolerance && distance < minDistance) { - nearest = feature; - minDistance = distance; - } - } - } - break; + while (pbf.pos < end) { + var key = feature._keys[pbf.readVarint()], + value = feature._values[pbf.readVarint()]; + feature.properties[key] = value; + } +} - case 3: //Polygon - paths = feature.getPathsForTile(evt.tileID); - for (j = 0; j < paths.length; j++) { - if (this._isPointInPoly(tilePoint, paths[j])) { - nearest = feature; - minDistance = 0; // point is inside the polygon, so distance is zero +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) { + 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 = []; } - } - break; - } - if (minDistance == 0) break; - } - if (nearest && nearest.toggleEnabled) { - nearest.toggle(); - } - evt.feature = nearest; - cb(evt); - }, + line.push(new Point(x, y)); - clearTile: function(id) { - //id is the entire zoom:x:y. we just want x:y. - var ca = id.split(":"); - var canvasId = ca[1] + ":" + ca[2]; - if (typeof this._tiles[canvasId] === 'undefined') { - console.error("typeof this._tiles[canvasId] === 'undefined'"); - return; + } 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); + } } - var canvas = this._tiles[canvasId]; - var context = canvas.getContext('2d'); - context.clearRect(0, 0, canvas.width, canvas.height); - }, + if (line) lines.push(line); - clearTileFeatureHash: function(canvasID){ - this._canvasIDToFeatures[canvasID] = { features: []}; //Get rid of all saved features - }, + return lines; +}; - clearLayerFeatureHash: function(){ - this.features = {}; - }, +VectorTileFeature.prototype.bbox = function() { + var pbf = this._pbf; + pbf.pos = this._geometry; - redrawTile: function(canvasID) { - //First, clear the canvas - this.clearTile(canvasID); + var end = pbf.readVarint() + pbf.pos, + cmd = 1, + length = 0, + x = 0, + y = 0, + x1 = Infinity, + x2 = -Infinity, + y1 = Infinity, + y2 = -Infinity; - // If the features are not in the tile, then there is nothing to redraw. - // This may happen if you call redraw before features have loaded and initially - // drawn the tile. - var featfeats = this._canvasIDToFeatures[canvasID]; - if (!featfeats) { - return; - } + while (pbf.pos < end) { + if (!length) { + var cmdLen = pbf.readVarint(); + cmd = cmdLen & 0x7; + length = cmdLen >> 3; + } - //Get the features for this tile, and redraw them. - var features = featfeats.features; + length--; - // we want to skip drawing the selected features and draw them last - var selectedFeatures = []; + 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; - // drawing all of the non-selected features - for (var i = 0; i < features.length; i++) { - var feature = features[i]; - if (feature.selected) { - selectedFeatures.push(feature); - } else { - feature.draw(canvasID); - } + } else if (cmd !== 7) { + throw new Error('unknown command ' + cmd); + } } - // drawing the selected features last - for (var j = 0, len2 = selectedFeatures.length; j < len2; j++) { - var selFeat = selectedFeatures[j]; - selFeat.draw(canvasID); + return [x1, y1, x2, y2]; +}; + +VectorTileFeature.prototype.toGeoJSON = function(x, y, z) { + var size = this.extent * Math.pow(2, z), + x0 = this.extent * x, + y0 = this.extent * y, + coords = this.loadGeometry(), + type = VectorTileFeature.types[this.type]; + + for (var i = 0; i < coords.length; i++) { + var line = coords[i]; + 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 + ]; + } } - }, - _resetCanvasIDToFeatures: function(canvasID, canvas) { + if (type === 'Point' && coords.length === 1) { + coords = coords[0][0]; + } else if (type === 'Point') { + coords = coords[0]; + type = 'MultiPoint'; + } else if (type === 'LineString' && coords.length === 1) { + coords = coords[0]; + } else if (type === 'LineString') { + type = 'MultiLineString'; + } + + return { + type: "Feature", + geometry: { + type: type, + coordinates: coords + }, + properties: this.properties + }; +}; - this._canvasIDToFeatures[canvasID] = {}; - this._canvasIDToFeatures[canvasID].features = []; - this._canvasIDToFeatures[canvasID].canvas = canvas; +},{"point-geometry":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/point-geometry/index.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilelayer.js":[function(require,module,exports){ +'use strict'; - }, +var VectorTileFeature = require('./vectortilefeature.js'); - linkedLayer: function() { - if(this.mvtSource.layerLink) { - var linkName = this.mvtSource.layerLink(this.name); - return this.mvtSource.layers[linkName]; - } - else{ - return null; - } - }, +module.exports = VectorTileLayer; - featureWithLabelAdded: function(feature) { - this.featuresWithLabels.push(feature); - } +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); -function removeLabels(self) { - var features = self.featuresWithLabels; - for (var i = 0, len = features.length; i < len; i++) { - var feat = features[i]; - feat.removeLabel(); - } - self.featuresWithLabels = []; + this.length = this._features.length; } -function in_circle(center_x, center_y, radius, x, y) { - var square_dist = Math.pow((center_x - x), 2) + Math.pow((center_y - y), 2); - return square_dist <= Math.pow(radius, 2); +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)); } -/** - * See https://github.com/ariya/phantomjs/blob/master/examples/waitfor.js - * - * Wait until the test condition is true or a timeout occurs. Useful for waiting - * on a server response or for a ui change (fadeIn, etc.) to occur. - * - * @param testFx javascript condition that evaluates to a boolean, - * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or - * as a callback function. - * @param onReady what to do when testFx condition is fulfilled, - * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or - * as a callback function. - * @param timeOutMillis the max amount of time to wait. If not specified, 3 sec is used. - */ -function waitFor(testFx, onReady, timeOutMillis) { - var maxtimeOutMillis = timeOutMillis ? timeOutMillis : 3000, //< Default Max Timout is 3s - start = new Date().getTime(), - condition = (typeof (testFx) === "string" ? eval(testFx) : testFx()), //< defensive code - interval = setInterval(function () { - if ((new Date().getTime() - start < maxtimeOutMillis) && !condition) { - // If not time-out yet and condition not yet fulfilled - condition = (typeof (testFx) === "string" ? eval(testFx) : testFx()); //< defensive code - } else { - if (!condition) { - // If condition still not fulfilled (timeout but condition is 'false') - console.log("'waitFor()' timeout"); - clearInterval(interval); //< Stop this interval - typeof (onReady) === "string" ? eval(onReady) : onReady('timeout'); //< Do what it's supposed to do once the condition is fulfilled - } else { - // Condition fulfilled (timeout and/or condition is 'true') - console.log("'waitFor()' finished in " + (new Date().getTime() - start) + "ms."); - clearInterval(interval); //< Stop this interval - typeof (onReady) === "string" ? eval(onReady) : onReady('success'); //< Do what it's supposed to do once the condition is fulfilled - } - } - }, 50); //< repeat check every 50ms -}; -},{"./MVTFeature":8,"./MVTUtil":11}],10:[function(require,module,exports){ -var VectorTile = require('vector-tile').VectorTile; -var Protobuf = require('pbf'); -var Point = require('point-geometry'); -var Util = require('./MVTUtil'); -var MVTLayer = require('./MVTLayer'); +function readValueMessage(pbf) { + var value = null, + end = pbf.readVarint() + pbf.pos; -module.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({ + while (pbf.pos < end) { + var tag = pbf.readVarint() >> 3; - options: { - debug: false, - url: "", //URL TO Vector Tile Source, - getIDForLayerFeature: function() {}, - tileSize: 256, - visibleLayers: [], - xhrHeaders: {} - }, - layers: {}, //Keep a list of the layers contained in the PBFs - processedTiles: {}, //Keep a list of tiles that have been processed already - _eventHandlers: {}, - _triggerOnTilesLoadedEvent: true, //whether or not to fire the onTilesLoaded event when all of the tiles finish loading. - _url: "", //internal URL property + 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; + } - style: function(feature) { - var style = {}; + return value; +} - var type = feature.type; - switch (type) { - case 1: //'Point' - style.color = 'rgba(49,79,79,1)'; - style.radius = 5; - style.selected = { - color: 'rgba(255,255,0,0.5)', - radius: 6 - }; - break; - case 2: //'LineString' - style.color = 'rgba(161,217,155,0.8)'; - style.size = 3; - style.selected = { - color: 'rgba(255,25,0,0.5)', - size: 4 - }; - break; - case 3: //'Polygon' - style.color = 'rgba(49,79,79,1)'; - style.outline = { - color: 'rgba(161,217,155,0.8)', - size: 1 - }; - style.selected = { - color: 'rgba(255,140,0,0.3)', - outline: { - color: 'rgba(255,140,0,1)', - size: 2 - } - }; - break; - } - return style; - }, +// 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]; - initialize: function(options) { - L.Util.setOptions(this, options); + var end = this._pbf.readVarint() + this._pbf.pos; + return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values); +}; - //a list of the layers contained in the PBFs - this.layers = {}; +},{"./vectortilefeature.js":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilefeature.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/index.js":[function(require,module,exports){ +var Pbf = require('pbf') +var vtpb = require('./vector-tile-pb') +var GeoJSONWrapper = require('./lib/geojson_wrapper') - // tiles currently in the viewport - this.activeTiles = {}; +module.exports = fromVectorTileJs +module.exports.fromVectorTileJs = fromVectorTileJs +module.exports.fromGeojsonVt = fromGeojsonVt +module.exports.GeoJSONWrapper = GeoJSONWrapper - // thats that have been loaded and drawn - this.loadedTiles = {}; +/** + * Serialize a vector-tile-js-created tile to pbf + * + * @param {Object} tile + * @return {Buffer} uncompressed, pbf-serialized tile data + */ +function fromVectorTileJs (tile) { + var layers = [] + for (var l in tile.layers) { + layers.push(prepareLayer(tile.layers[l])) + } - this._url = this.options.url; + var out = new Pbf() + vtpb.tile.write({ layers: layers }, out) + return out.finish() +} - /** - * For some reason, Leaflet has some code that resets the - * z index in the options object. I'm having trouble tracking - * down exactly what does this and why, so for now, we should - * just copy the value to this.zIndex so we can have the right - * number when we make the subsequent MVTLayers. - */ - this.zIndex = options.zIndex; +/** + * Serialized a geojson-vt-created tile to pbf. + * + * @param {Object} layers - An object mapping layer names to geojson-vt-created vector tile objects + * @return {Buffer} uncompressed, pbf-serialized tile data + */ +function fromGeojsonVt (layers) { + var l = {} + for (var k in layers) { + l[k] = new GeoJSONWrapper(layers[k].features) + l[k].name = k + } + return fromVectorTileJs({layers: l}) +} - if (typeof options.style === 'function') { - this.style = options.style; +/** + * Prepare the given layer to be serialized by the auto-generated pbf + * serializer by encoding the feature geometry and properties. + */ +function prepareLayer (layer) { + var preparedLayer = { + name: layer.name || '', + version: layer.version || 1, + extent: layer.extent || 4096, + keys: [], + values: [], + features: [] + } + + var keycache = {} + var valuecache = {} + + for (var i = 0; i < layer.length; i++) { + var feature = layer.feature(i) + feature.geometry = encodeGeometry(feature.loadGeometry()) + + var tags = [] + for (var key in feature.properties) { + var keyIndex = keycache[key] + if (typeof keyIndex === 'undefined') { + preparedLayer.keys.push(key) + keyIndex = preparedLayer.keys.length - 1 + keycache[key] = keyIndex + } + var value = wrapValue(feature.properties[key]) + var valueIndex = valuecache[value.key] + if (typeof valueIndex === 'undefined') { + preparedLayer.values.push(value) + valueIndex = preparedLayer.values.length - 1 + valuecache[value.key] = valueIndex + } + tags.push(keyIndex) + tags.push(valueIndex) } - if (typeof options.ajaxSource === 'function') { - this.ajaxSource = options.ajaxSource; - } + feature.tags = tags + preparedLayer.features.push(feature) + } - this.layerLink = options.layerLink; + return preparedLayer +} - this._eventHandlers = {}; +function command (cmd, length) { + return (length << 3) + (cmd & 0x7) +} - this._tilesToProcess = 0; //store the max number of tiles to be loaded. Later, we can use this count to count down PBF loading. - }, +function zigzag (num) { + return (num << 1) ^ (num >> 31) +} - redraw: function(triggerOnTilesLoadedEvent){ - //Only set to false if it actually is passed in as 'false' - if (triggerOnTilesLoadedEvent === false) { - this._triggerOnTilesLoadedEvent = false; +/** + * Encode a polygon's geometry into an array ready to be serialized + * to mapbox vector tile specified geometry data. + * + * @param {Array} Rings, each being an array of [x, y] tile-space coordinates + * @return {Array} encoded geometry + */ +function encodeGeometry (geometry) { + var encoded = [] + var x = 0 + var y = 0 + var rings = geometry.length + for (var r = 0; r < rings; r++) { + var ring = geometry[r] + encoded.push(command(1, 1)) // moveto + for (var i = 0; i < ring.length; i++) { + if (i === 1) { + encoded.push(command(2, ring.length - 1)) // lineto + } + var dx = ring[i].x - x + var dy = ring[i].y - y + encoded.push(zigzag(dx), zigzag(dy)) + x += dx + y += dy } + } - L.TileLayer.Canvas.prototype.redraw.call(this); - }, + return encoded +} - onAdd: function(map) { - var self = this; - self.map = map; - L.TileLayer.Canvas.prototype.onAdd.call(this, map); +/** + * Wrap a property value according to its type. The returned object + * is of the form { xxxx_value: primitiveValue }, which is what the generated + * protobuf serializer expects. + */ +function wrapValue (value) { + var result + var type = typeof value + if (type === 'string') { + result = { string_value: value } + } else if (type === 'boolean') { + result = { bool_value: value } + } else if (type === 'number') { + if (value !== (value | 0)) { + result = { float_value: value } + } else if (value < 0) { + result = { sint_value: value } + } else { + result = { uint_value: value } + } + } else { + result = { string_value: '' + value } + } - var mapOnClickCallback = function(e) { - self._onClick(e); - }; + result.key = type + ':' + value + return result +} - map.on('click', mapOnClickCallback); +},{"./lib/geojson_wrapper":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/lib/geojson_wrapper.js","./vector-tile-pb":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/vector-tile-pb.js","pbf":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/index.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/lib/geojson_wrapper.js":[function(require,module,exports){ +'use strict' - map.on("layerremove", function(e) { - // check to see if the layer removed is this one - // call a method to remove the child layers (the ones that actually have something drawn on them). - if (e.layer._leaflet_id === self._leaflet_id && e.layer.removeChildLayers) { - e.layer.removeChildLayers(map); - map.off('click', mapOnClickCallback); - } - }); +var Point = require('point-geometry') +var VectorTileFeature = require('vector-tile').VectorTileFeature - self.addChildLayers(map); +module.exports = GeoJSONWrapper - if (typeof DynamicLabel === 'function' ) { - this.dynamicLabel = new DynamicLabel(map, this, {}); - } +// conform to vectortile api +function GeoJSONWrapper (features) { + this.features = features + this.length = features.length +} - }, +GeoJSONWrapper.prototype.feature = function (i) { + return new FeatureWrapper(this.features[i]) +} - drawTile: function(canvas, tilePoint, zoom) { - var ctx = { - id: [zoom, tilePoint.x, tilePoint.y].join(":"), - canvas: canvas, - tile: tilePoint, - zoom: zoom, - tileSize: this.options.tileSize - }; +function FeatureWrapper (feature) { + this.type = feature.type + this.rawGeometry = feature.type === 1 ? [feature.geometry] : feature.geometry + this.properties = feature.tags + this.extent = 4096 +} - //Capture the max number of the tiles to load here. this._tilesToProcess is an internal number we use to know when we've finished requesting PBFs. - if(this._tilesToProcess < this._tilesToLoad) this._tilesToProcess = this._tilesToLoad; +FeatureWrapper.prototype.loadGeometry = function () { + var rings = this.rawGeometry + this.geometry = [] - var id = ctx.id = Util.getContextID(ctx); - this.activeTiles[id] = ctx; + for (var i = 0; i < rings.length; i++) { + var ring = rings[i] + var newRing = [] + for (var j = 0; j < ring.length; j++) { + newRing.push(new Point(ring[j][0], ring[j][1])) + } + this.geometry.push(newRing) + } + return this.geometry +} - if(!this.processedTiles[ctx.zoom]) this.processedTiles[ctx.zoom] = {}; +FeatureWrapper.prototype.bbox = function () { + if (!this.geometry) this.loadGeometry() - if (this.options.debug) { - this._drawDebugInfo(ctx); - } - this._draw(ctx); - }, + var rings = this.geometry + var x1 = Infinity + var x2 = -Infinity + var y1 = Infinity + var y2 = -Infinity - setOpacity:function(opacity) { - this._setVisibleLayersStyle('opacity',opacity); - }, + for (var i = 0; i < rings.length; i++) { + var ring = rings[i] - setZIndex:function(zIndex) { - this._setVisibleLayersStyle('zIndex',zIndex); - }, + for (var j = 0; j < ring.length; j++) { + var coord = ring[j] - _setVisibleLayersStyle:function(style, value) { - for(var key in this.layers) { - this.layers[key]._tileContainer.style[style] = value; + x1 = Math.min(x1, coord.x) + x2 = Math.max(x2, coord.x) + y1 = Math.min(y1, coord.y) + y2 = Math.max(y2, coord.y) } - }, + } - _drawDebugInfo: function(ctx) { - var max = this.options.tileSize; - var g = ctx.canvas.getContext('2d'); - g.strokeStyle = '#000000'; - g.fillStyle = '#FFFF00'; - g.strokeRect(0, 0, max, max); - g.font = "12px Arial"; - g.fillRect(0, 0, 5, 5); - g.fillRect(0, max - 5, 5, 5); - g.fillRect(max - 5, 0, 5, 5); - g.fillRect(max - 5, max - 5, 5, 5); - g.fillRect(max / 2 - 5, max / 2 - 5, 10, 10); - g.strokeText(ctx.zoom + ' ' + ctx.tile.x + ' ' + ctx.tile.y, max / 2 - 30, max / 2 - 10); - }, + return [x1, y1, x2, y2] +} - _draw: function(ctx) { - var self = this; +FeatureWrapper.prototype.toGeoJSON = VectorTileFeature.prototype.toGeoJSON -// //This works to skip fetching and processing tiles if they've already been processed. -// var vectorTile = this.processedTiles[ctx.zoom][ctx.id]; -// //if we've already parsed it, don't get it again. -// if(vectorTile){ -// console.log("Skipping fetching " + ctx.id); -// self.checkVectorTileLayers(parseVT(vectorTile), ctx, true); -// self.reduceTilesToProcessCount(); -// return; -// } +},{"point-geometry":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/point-geometry/index.js","vector-tile":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/index.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/vector-tile-pb.js":[function(require,module,exports){ +'use strict'; - if (!this._url) return; - var src = this.getTileUrl({ x: ctx.tile.x, y: ctx.tile.y, z: ctx.zoom }); +// tile ======================================== - var xhr = new XMLHttpRequest(); - xhr.onload = function() { - if (xhr.status == "200") { +var tile = exports.tile = {read: readTile, write: writeTile}; - if(!xhr.response) return; +tile.GeomType = { + "Unknown": 0, + "Point": 1, + "LineString": 2, + "Polygon": 3 +}; - var arrayBuffer = new Uint8Array(xhr.response); - var buf = new Protobuf(arrayBuffer); - var vt = new VectorTile(buf); - //Check the current map layer zoom. If fast zooming is occurring, then short circuit tiles that are for a different zoom level than we're currently on. - if(self.map && self.map.getZoom() != ctx.zoom) { - console.log("Fetched tile for zoom level " + ctx.zoom + ". Map is at zoom level " + self._map.getZoom()); - return; - } - self.checkVectorTileLayers(parseVT(vt), ctx); - tileLoaded(self, ctx); - } +function readTile(pbf, end) { + return pbf.readFields(readTileField, {"layers": []}, end); +} - //either way, reduce the count of tilesToProcess tiles here - self.reduceTilesToProcessCount(); - }; +function readTileField(tag, tile, pbf) { + if (tag === 3) tile.layers.push(readLayer(pbf, pbf.readVarint() + pbf.pos)); +} - xhr.onerror = function() { - console.log("xhr error: " + xhr.status) - }; +function writeTile(tile, pbf) { + var i; + if (tile.layers !== undefined) for (i = 0; i < tile.layers.length; i++) pbf.writeMessage(3, writeLayer, tile.layers[i]); +} - xhr.open('GET', src, true); //async is true - var headers = self.options.xhrHeaders; - for (var header in headers) { - xhr.setRequestHeader(header, headers[header]) - } - xhr.responseType = 'arraybuffer'; - xhr.send(); - }, +// value ======================================== - reduceTilesToProcessCount: function(){ - this._tilesToProcess--; - if(!this._tilesToProcess){ - //Trigger event letting us know that all PBFs have been loaded and processed (or 404'd). - if(this._eventHandlers["PBFLoad"]) this._eventHandlers["PBFLoad"](); - this._pbfLoaded(); - } - }, +tile.value = {read: readValue, write: writeValue}; - checkVectorTileLayers: function(vt, ctx, parsed) { - var self = this; +function readValue(pbf, end) { + return pbf.readFields(readValueField, {}, end); +} - //Check if there are specified visible layers - if(self.options.visibleLayers && self.options.visibleLayers.length > 0){ - //only let thru the layers listed in the visibleLayers array - for(var i=0; i < self.options.visibleLayers.length; i++){ - var layerName = self.options.visibleLayers[i]; - if(vt.layers[layerName]){ - //Proceed with parsing - self.prepareMVTLayers(vt.layers[layerName], layerName, ctx, parsed); - } - } - }else{ - //Parse all vt.layers - for (var key in vt.layers) { - self.prepareMVTLayers(vt.layers[key], key, ctx, parsed); - } - } - }, +function readValueField(tag, value, pbf) { + if (tag === 1) value.string_value = pbf.readString(); + else if (tag === 2) value.float_value = pbf.readFloat(); + else if (tag === 3) value.double_value = pbf.readDouble(); + else if (tag === 4) value.int_value = pbf.readVarint(); + else if (tag === 5) value.uint_value = pbf.readVarint(); + else if (tag === 6) value.sint_value = pbf.readSVarint(); + else if (tag === 7) value.bool_value = pbf.readBoolean(); +} - prepareMVTLayers: function(lyr ,key, ctx, parsed) { - var self = this; +function writeValue(value, pbf) { + if (value.string_value !== undefined) pbf.writeStringField(1, value.string_value); + if (value.float_value !== undefined) pbf.writeFloatField(2, value.float_value); + if (value.double_value !== undefined) pbf.writeDoubleField(3, value.double_value); + if (value.int_value !== undefined) pbf.writeVarintField(4, value.int_value); + if (value.uint_value !== undefined) pbf.writeVarintField(5, value.uint_value); + if (value.sint_value !== undefined) pbf.writeSVarintField(6, value.sint_value); + if (value.bool_value !== undefined) pbf.writeBooleanField(7, value.bool_value); +} - if (!self.layers[key]) { - //Create MVTLayer or MVTPointLayer for user - self.layers[key] = self.createMVTLayer(key, lyr.parsedFeatures[0].type || null); - } +// feature ======================================== - if (parsed) { - //We've already parsed it. Go get canvas and draw. - self.layers[key].getCanvas(ctx, lyr); - } else { - self.layers[key].parseVectorTileLayer(lyr, ctx); - } +tile.feature = {read: readFeature, write: writeFeature}; - }, +function readFeature(pbf, end) { + var feature = pbf.readFields(readFeatureField, {}, end); + if (feature.type === undefined) feature.type = "Unknown"; + return feature; +} - createMVTLayer: function(key, type) { - var self = this; +function readFeatureField(tag, feature, pbf) { + if (tag === 1) feature.id = pbf.readVarint(); + else if (tag === 2) feature.tags = pbf.readPackedVarint(); + else if (tag === 3) feature.type = pbf.readVarint(); + else if (tag === 4) feature.geometry = pbf.readPackedVarint(); +} - var getIDForLayerFeature; - if (typeof self.options.getIDForLayerFeature === 'function') { - getIDForLayerFeature = self.options.getIDForLayerFeature; - } else { - getIDForLayerFeature = Util.getIDForLayerFeature; - } +function writeFeature(feature, pbf) { + if (feature.id !== undefined) pbf.writeVarintField(1, feature.id); + if (feature.tags !== undefined) pbf.writePackedVarint(2, feature.tags); + if (feature.type !== undefined) pbf.writeVarintField(3, feature.type); + if (feature.geometry !== undefined) pbf.writePackedVarint(4, feature.geometry); +} - var options = { - getIDForLayerFeature: getIDForLayerFeature, - filter: self.options.filter, - layerOrdering: self.options.layerOrdering, - style: self.style, - name: key, - asynch: true - }; +// layer ======================================== - if (self.options.zIndex) { - options.zIndex = self.zIndex; - } +tile.layer = {read: readLayer, write: writeLayer}; - //Take the layer and create a new MVTLayer or MVTPointLayer if one doesn't exist. - var layer = new MVTLayer(self, options).addTo(self.map); +function readLayer(pbf, end) { + return pbf.readFields(readLayerField, {"features": [], "keys": [], "values": []}, end); +} - return layer; - }, +function readLayerField(tag, layer, pbf) { + if (tag === 15) layer.version = pbf.readVarint(); + else if (tag === 1) layer.name = pbf.readString(); + else if (tag === 2) layer.features.push(readFeature(pbf, pbf.readVarint() + pbf.pos)); + else if (tag === 3) layer.keys.push(pbf.readString()); + else if (tag === 4) layer.values.push(readValue(pbf, pbf.readVarint() + pbf.pos)); + else if (tag === 5) layer.extent = pbf.readVarint(); +} - getLayers: function() { - return this.layers; - }, +function writeLayer(layer, pbf) { + if (layer.version !== undefined) pbf.writeVarintField(15, layer.version); + if (layer.name !== undefined) pbf.writeStringField(1, layer.name); + var i; + if (layer.features !== undefined) for (i = 0; i < layer.features.length; i++) pbf.writeMessage(2, writeFeature, layer.features[i]); + if (layer.keys !== undefined) for (i = 0; i < layer.keys.length; i++) pbf.writeStringField(3, layer.keys[i]); + if (layer.values !== undefined) for (i = 0; i < layer.values.length; i++) pbf.writeMessage(4, writeValue, layer.values[i]); + if (layer.extent !== undefined) pbf.writeVarintField(5, layer.extent); +} - hideLayer: function(id) { - if (this.layers[id]) { - this._map.removeLayer(this.layers[id]); - if(this.options.visibleLayers.indexOf("id") > -1){ - this.visibleLayers.splice(this.options.visibleLayers.indexOf("id"), 1); - } - } - }, +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTFeature.js":[function(require,module,exports){ +/** + * Created by Ryan Whitley, Daniel Duarte, and Nicholas Hallahan + * on 6/03/14. + */ +var Util = require('./MVTUtil'); +var StaticLabel = require('./StaticLabel/StaticLabel.js'); - showLayer: function(id) { - if (this.layers[id]) { - this._map.addLayer(this.layers[id]); - if(this.options.visibleLayers.indexOf("id") == -1){ - this.visibleLayers.push(id); - } - } - //Make sure manager layer is always in front - this.bringToFront(); - }, +module.exports = MVTFeature; + +function MVTFeature(mvtLayer, vtf, ctx, id, style) { + if (!vtf) return null; + + // Apply all of the properties of vtf to this object. + for (var key in vtf) { + this[key] = vtf[key]; + } - removeChildLayers: function(map){ - //Remove child layers of this group layer - for (var key in this.layers) { - var layer = this.layers[key]; - map.removeLayer(layer); - } - }, + this.mvtLayer = mvtLayer; + this.mvtSource = mvtLayer.mvtSource; + this.map = mvtLayer.mvtSource.map; - addChildLayers: function(map) { - var self = this; - if(self.options.visibleLayers.length > 0){ - //only let thru the layers listed in the visibleLayers array - for(var i=0; i < self.options.visibleLayers.length; i++){ - var layerName = self.options.visibleLayers[i]; - var layer = this.layers[layerName]; - if(layer){ - //Proceed with parsing - map.addLayer(layer); - } - } - }else{ - //Add all layers - for (var key in this.layers) { - var layer = this.layers[key]; - // layer is set to visible and is not already on map - if (!layer._map) { - map.addLayer(layer); - } - } - } - }, + this.id = id; - bind: function(eventType, callback) { - this._eventHandlers[eventType] = callback; - }, + this.layerLink = this.mvtSource.layerLink; + this.toggleEnabled = true; + this.selected = false; - _onClick: function(evt) { - //Here, pass the event on to the child MVTLayer and have it do the hit test and handle the result. - var self = this; - var onClick = self.options.onClick; - var clickableLayers = self.options.clickableLayers; - var layers = self.layers; + // how much we divide the coordinate from the vector tile + this.divisor = vtf.extent / ctx.tileSize; + this.extent = vtf.extent; + this.tileSize = ctx.tileSize; - evt.tileID = getTileURL(evt.latlng.lat, evt.latlng.lng, this.map.getZoom()); + //An object to store the paths and contexts for this feature + this.tiles = {}; - // We must have an array of clickable layers, otherwise, we just pass - // the event to the public onClick callback in options. + this.style = style; - if(!clickableLayers){ - clickableLayers = Object.keys(self.layers); - } + //Add to the collection + this.addTileFeature(vtf, ctx); - if (clickableLayers && clickableLayers.length > 0) { - for (var i = 0, len = clickableLayers.length; i < len; i++) { - var key = clickableLayers[i]; - var layer = layers[key]; - if (layer) { - layer.handleClickEvent(evt, function(evt) { - if (typeof onClick === 'function') { - onClick(evt); - } - }); - } - } - } else { - if (typeof onClick === 'function') { - onClick(evt); - } - } + var self = this; + this.map.on('zoomend', function() { + self.staticLabel = null; + }); - }, + if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') { + this.dynamicLabel = this.mvtSource.dynamicLabel.createFeature(this); + } - setFilter: function(filterFunction, layerName) { - //take in a new filter function. - //Propagate to child layers. + ajax(self); +} - //Add filter to all child layers if no layer is specified. - for (var key in this.layers) { - var layer = this.layers[key]; - if (layerName){ - if(key.toLowerCase() == layerName.toLowerCase()){ - layer.options.filter = filterFunction; //Assign filter to child layer, only if name matches - //After filter is set, the old feature hashes are invalid. Clear them for next draw. - layer.clearLayerFeatureHash(); - //layer.clearTileFeatureHash(); +function ajax(self) { + var style = self.style; + if (style && style.ajaxSource && typeof style.ajaxSource === 'function') { + var ajaxEndpoint = style.ajaxSource(self); + if (ajaxEndpoint) { + Util.getJSON(ajaxEndpoint, function(error, response, body) { + if (error) { + throw ['ajaxSource AJAX Error', error]; + } else { + ajaxCallback(self, response); + return true; } - } - else{ - layer.options.filter = filterFunction; //Assign filter to child layer - //After filter is set, the old feature hashes are invalid. Clear them for next draw. - layer.clearLayerFeatureHash(); - //layer.clearTileFeatureHash(); - } + }); } - }, + } + return false; +} + +function ajaxCallback(self, response) { + self.ajaxData = response; /** - * Take in a new style function and propogate to child layers. - * If you do not set a layer name, it resets the style for all of the layers. - * @param styleFunction - * @param layerName + * You can attach a callback function to a feature in your app + * that will get called whenever new ajaxData comes in. This + * can be used to update UI that looks at data from within a feature. + * + * setStyle may possibly have a style with a different ajaxData source, + * and you would potentially get new contextual data for your feature. + * + * TODO: This needs to be documented. */ - setStyle: function(styleFn, layerName) { - for (var key in this.layers) { - var layer = this.layers[key]; - if (layerName) { - if(key.toLowerCase() == layerName.toLowerCase()) { - layer.setStyle(styleFn); - } - } else { - layer.setStyle(styleFn); - } - } - }, + if (typeof self.ajaxDataReceived === 'function') { + self.ajaxDataReceived(self, response); + } - featureSelected: function(mvtFeature) { - if (this.options.mutexToggle) { - if (this._selectedFeature) { - this._selectedFeature.deselect(); - } - this._selectedFeature = mvtFeature; - } - if (this.options.onSelect) { - this.options.onSelect(mvtFeature); - } - }, + self._setStyle(self.mvtLayer.style); + redrawTiles(self); +} - featureDeselected: function(mvtFeature) { - if (this.options.mutexToggle && this._selectedFeature) { - this._selectedFeature = null; - } - if (this.options.onDeselect) { - this.options.onDeselect(mvtFeature); - } - }, +MVTFeature.prototype._setStyle = function(styleFn) { + this.style = styleFn(this, this.ajaxData); - _pbfLoaded: function() { - //Fires when all tiles from this layer have been loaded and drawn (or 404'd). + // The label gets removed, and the (re)draw, + // that is initiated by the MVTLayer creates a new label. + this.removeLabel(); +}; - //Make sure manager layer is always in front - this.bringToFront(); +MVTFeature.prototype.setStyle = function(styleFn) { + this.ajaxData = null; + this.style = styleFn(this, null); + var hasAjaxSource = ajax(this); + if (!hasAjaxSource) { + // The label gets removed, and the (re)draw, + // that is initiated by the MVTLayer creates a new label. + this.removeLabel(); + } +}; - //See if there is an event to execute - var self = this; - var onTilesLoaded = self.options.onTilesLoaded; +MVTFeature.prototype.draw = function(canvasID) { + //Get the info from the tiles list + var tileInfo = this.tiles[canvasID]; - if (onTilesLoaded && typeof onTilesLoaded === 'function' && this._triggerOnTilesLoadedEvent === true) { - onTilesLoaded(this); - } - self._triggerOnTilesLoadedEvent = true; //reset - if redraw() is called with the optinal 'false' parameter to temporarily disable the onTilesLoaded event from firing. This resets it back to true after a single time of firing as 'false'. - } + var vtf = tileInfo.vtf; + var ctx = tileInfo.ctx; -}); + //Get the actual canvas from the parent layer's _tiles object. + var xy = canvasID.split(":").slice(1, 3).join(":"); + ctx.canvas = this.mvtLayer._tiles[xy]; +// This could be used to directly compute the style function from the layer on every draw. +// This is much less efficient... +// this.style = this.mvtLayer.style(this); -if (typeof(Number.prototype.toRad) === "undefined") { - Number.prototype.toRad = function() { - return this * Math.PI / 180; + if (this.selected) { + var style = this.style.selected || this.style; + } else { + var style = this.style; } -} -function getTileURL(lat, lon, zoom) { - var xtile = parseInt(Math.floor( (lon + 180) / 360 * (1< - * on 8/15/14. - */ -var Util = module.exports = {}; -Util.getContextID = function(ctx) { - return [ctx.zoom, ctx.tile.x, ctx.tile.y].join(":"); }; -/** - * Default function that gets the id for a layer feature. - * Sometimes this needs to be done in a different way and - * can be specified by the user in the options for L.TileLayer.MVTSource. - * - * @param feature - * @returns {ctx.id|*|id|string|jsts.index.chain.MonotoneChain.id|number} - */ -Util.getIDForLayerFeature = function(feature) { - return feature.properties.id; +MVTFeature.prototype.getPathsForTile = function(canvasID) { + //Get the info from the parts list + return this.tiles[canvasID].paths; }; -Util.getJSON = function(url, callback) { - var xmlhttp = typeof XMLHttpRequest !== 'undefined' ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP'); - xmlhttp.onreadystatechange = function() { - var status = xmlhttp.status; - if (xmlhttp.readyState === 4 && status >= 200 && status < 300) { - var json = JSON.parse(xmlhttp.responseText); - callback(null, json); - } else { - callback( { error: true, status: status } ); - } - }; - xmlhttp.open("GET", url, true); - xmlhttp.send(); -}; +MVTFeature.prototype.addTileFeature = function(vtf, ctx) { + //Store the important items in the tiles list -},{}],12:[function(require,module,exports){ -/** - * Created by Nicholas Hallahan - * on 7/31/14. - */ -var Util = require('../MVTUtil'); -module.exports = StaticLabel; + //We only want to store info for tiles for the current map zoom. If it is tile info for another zoom level, ignore it + //Also, if there are existing tiles in the list for other zoom levels, expunge them. + var zoom = this.map.getZoom(); -function StaticLabel(mvtFeature, ctx, latLng, style) { - var self = this; - this.mvtFeature = mvtFeature; - this.map = mvtFeature.map; - this.zoom = ctx.zoom; - this.latLng = latLng; - this.selected = false; + if(ctx.zoom != zoom) return; - if (mvtFeature.linkedFeature) { - var linkedFeature = mvtFeature.linkedFeature(); - if (linkedFeature && linkedFeature.selected) { - self.selected = true; - } - } + this.clearTileFeatures(zoom); //TODO: This iterates thru all tiles every time a new tile is added. Figure out a better way to do this. - init(self, mvtFeature, ctx, latLng, style) -} + this.tiles[ctx.id] = { + ctx: ctx, + vtf: vtf, + paths: [] + }; -function init(self, mvtFeature, ctx, latLng, style) { - var ajaxData = mvtFeature.ajaxData; - var sty = self.style = style.staticLabel(mvtFeature, ajaxData); - var icon = self.icon = L.divIcon({ - className: sty.cssClass || 'label-icon-text', - html: sty.html, - iconSize: sty.iconSize || [50,50] - }); +}; - self.marker = L.marker(latLng, {icon: icon}).addTo(self.map); - if (self.selected) { - self.marker._icon.classList.add(self.style.cssSelectedClass || 'label-icon-text-selected'); +/** + * Clear the inner list of tile features if they don't match the given zoom. + * + * @param zoom + */ +MVTFeature.prototype.clearTileFeatures = function(zoom) { + //If stored tiles exist for other zoom levels, expunge them from the list. + for (var key in this.tiles) { + if(key.split(":")[0] != zoom) delete this.tiles[key]; } +}; - self.marker.on('click', function(e) { - self.toggle(); - }); +/** + * Redraws all of the tiles associated with a feature. Useful for + * style change and toggling. + * + * @param self + */ +function redrawTiles(self) { + //Redraw the whole tile, not just this vtf + var tiles = self.tiles; + var mvtLayer = self.mvtLayer; - self.map.on('zoomend', function(e) { - var newZoom = e.target.getZoom(); - if (self.zoom !== newZoom) { - self.map.removeLayer(self.marker); + for (var id in tiles) { + var tileZoom = parseInt(id.split(':')[0]); + var mapZoom = self.map.getZoom(); + if (tileZoom === mapZoom) { + //Redraw the tile + mvtLayer.redrawTile(id); } - }); + } } - -StaticLabel.prototype.toggle = function() { +MVTFeature.prototype.toggle = function() { if (this.selected) { this.deselect(); } else { @@ -2352,1749 +2426,1409 @@ StaticLabel.prototype.toggle = function() { } }; -StaticLabel.prototype.select = function() { +MVTFeature.prototype.select = function() { this.selected = true; - this.marker._icon.classList.add(this.style.cssSelectedClass || 'label-icon-text-selected'); - var linkedFeature = this.mvtFeature.linkedFeature(); - if (!linkedFeature.selected) linkedFeature.select(); + this.mvtSource.featureSelected(this); + redrawTiles(this); + var linkedFeature = this.linkedFeature(); + if (linkedFeature && linkedFeature.staticLabel && !linkedFeature.staticLabel.selected) { + linkedFeature.staticLabel.select(); + } }; -StaticLabel.prototype.deselect = function() { +MVTFeature.prototype.deselect = function() { this.selected = false; - this.marker._icon.classList.remove(this.style.cssSelectedClass || 'label-icon-text-selected'); - var linkedFeature = this.mvtFeature.linkedFeature(); - if (linkedFeature.selected) linkedFeature.deselect(); + this.mvtSource.featureDeselected(this); + redrawTiles(this); + var linkedFeature = this.linkedFeature(); + if (linkedFeature && linkedFeature.staticLabel && linkedFeature.staticLabel.selected) { + linkedFeature.staticLabel.deselect(); + } }; -StaticLabel.prototype.remove = function() { - if (!this.map || !this.marker) return; - this.map.removeLayer(this.marker); +MVTFeature.prototype.on = function(eventType, callback) { + this._eventHandlers[eventType] = callback; }; -},{"../MVTUtil":11}],13:[function(require,module,exports){ -/** - * Copyright (c) 2014, Spatial Development International - * All rights reserved. - * - * Source code can be found at: - * https://github.com/SpatialServer/Leaflet.MapboxVectorTile - * - * @license ISC - */ +MVTFeature.prototype._drawPoint = function(ctx, coordsArray, style) { + if (!style) return; + if (!ctx || !ctx.canvas) return; -module.exports = require('./MVTSource'); + var tile = this.tiles[ctx.id]; -},{"./MVTSource":10}],14:[function(require,module,exports){ -(function (global){ -/*! - * The buffer module from node.js, for the browser. - * - * @author Feross Aboukhadijeh - * @license MIT - */ -/* eslint-disable no-proto */ + //Get radius + var radius = 1; + if (typeof style.radius === 'function') { + radius = style.radius(ctx.zoom); //Allows for scale dependent rednering + } + else{ + radius = style.radius; + } + + var p = this._tilePoint(coordsArray[0][0]); + var c = ctx.canvas; + var ctx2d; + try{ + ctx2d = c.getContext('2d'); + } + catch(e){ + console.log("_drawPoint error: " + e); + return; + } -var base64 = require('base64-js') -var ieee754 = require('ieee754') -var isArray = require('is-array') + ctx2d.beginPath(); + ctx2d.fillStyle = style.color; + ctx2d.arc(p.x, p.y, radius, 0, Math.PI * 2); + ctx2d.closePath(); + ctx2d.fill(); -exports.Buffer = Buffer -exports.SlowBuffer = SlowBuffer -exports.INSPECT_MAX_BYTES = 50 -Buffer.poolSize = 8192 // not used by this implementation + if(style.lineWidth && style.strokeStyle){ + ctx2d.lineWidth = style.lineWidth; + ctx2d.strokeStyle = style.strokeStyle; + ctx2d.stroke(); + } -var rootParent = {} + ctx2d.restore(); + tile.paths.push([p]); +}; -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property - * on objects. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. +MVTFeature.prototype._drawLineString = function(ctx, coordsArray, style) { + if (!style) return; + if (!ctx || !ctx.canvas) return; + + var ctx2d = ctx.canvas.getContext('2d'); + ctx2d.strokeStyle = style.color; + ctx2d.lineWidth = style.size; + ctx2d.beginPath(); + + var projCoords = []; + var tile = this.tiles[ctx.id]; + + for (var gidx in coordsArray) { + var coords = coordsArray[gidx]; + + for (i = 0; i < coords.length; i++) { + var method = (i === 0 ? 'move' : 'line') + 'To'; + var proj = this._tilePoint(coords[i]); + projCoords.push(proj); + ctx2d[method](proj.x, proj.y); + } + } + + ctx2d.stroke(); + ctx2d.restore(); + + tile.paths.push(projCoords); +}; + +MVTFeature.prototype._drawPolygon = function(ctx, coordsArray, style) { + if (!style) return; + if (!ctx || !ctx.canvas) return; + + var ctx2d = ctx.canvas.getContext('2d'); + var outline = style.outline; + + // color may be defined via function to make choropleth work right + if (typeof style.color === 'function') { + ctx2d.fillStyle = style.color(ctx2d); + } else { + ctx2d.fillStyle = style.color; + } - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined - ? global.TYPED_ARRAY_SUPPORT - : typedArraySupport() - -function typedArraySupport () { - function Bar () {} - try { - var arr = new Uint8Array(1) - arr.foo = function () { return 42 } - arr.constructor = Bar - return arr.foo() === 42 && // typed array instances can be augmented - arr.constructor === Bar && // constructor can be set - typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` - arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` - } catch (e) { - return false + if (outline) { + ctx2d.strokeStyle = outline.color; + ctx2d.lineWidth = outline.size; } -} + ctx2d.beginPath(); -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} + var projCoords = []; + var tile = this.tiles[ctx.id]; -/** - * Class: Buffer - * ============= - * - * The Buffer constructor returns instances of `Uint8Array` that are augmented - * with function properties for all the node `Buffer` API functions. We use - * `Uint8Array` so that square bracket notation works as expected -- it returns - * a single octet. - * - * By augmenting the instances, we can avoid modifying the `Uint8Array` - * prototype. - */ -function Buffer (arg) { - if (!(this instanceof Buffer)) { - // Avoid going through an ArgumentsAdaptorTrampoline in the common case. - if (arguments.length > 1) return new Buffer(arg, arguments[1]) - return new Buffer(arg) + var featureLabel = this.dynamicLabel; + if (featureLabel) { + featureLabel.addTilePolys(ctx, coordsArray); } - this.length = 0 - this.parent = undefined + for (var gidx = 0, len = coordsArray.length; gidx < len; gidx++) { + var coords = coordsArray[gidx]; - // Common case. - if (typeof arg === 'number') { - return fromNumber(this, arg) + for (var i = 0; i < coords.length; i++) { + var coord = coords[i]; + var method = (i === 0 ? 'move' : 'line') + 'To'; + var proj = this._tilePoint(coords[i]); + projCoords.push(proj); + ctx2d[method](proj.x, proj.y); + } } - // Slightly less common case. - if (typeof arg === 'string') { - return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8') + ctx2d.closePath(); + ctx2d.fill(); + if (outline) { + ctx2d.stroke(); } - // Unusual. - return fromObject(this, arg) -} + tile.paths.push(projCoords); -function fromNumber (that, length) { - that = allocate(that, length < 0 ? 0 : checked(length) | 0) - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < length; i++) { - that[i] = 0 - } - } - return that -} +}; -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8' +MVTFeature.prototype._drawStaticLabel = function(ctx, coordsArray, style) { + if (!style) return; + if (!ctx) return; - // Assumption: byteLength() return value is always < kMaxLength. - var length = byteLength(string, encoding) | 0 - that = allocate(that, length) + // If the corresponding layer is not on the map, + // we dont want to put on a label. + if (!this.mvtLayer._map) return; - that.write(string, encoding) - return that -} + var vecPt = this._tilePoint(coordsArray[0][0]); -function fromObject (that, object) { - if (Buffer.isBuffer(object)) return fromBuffer(that, object) + // We're making a standard Leaflet Marker for this label. + var p = this._project(vecPt, ctx.tile.x, ctx.tile.y, this.extent, this.tileSize); //vectile pt to merc pt + var mercPt = L.point(p.x, p.y); // make into leaflet obj + var latLng = this.map.unproject(mercPt); // merc pt to latlng - if (isArray(object)) return fromArray(that, object) + this.staticLabel = new StaticLabel(this, ctx, latLng, style); + this.mvtLayer.featureWithLabelAdded(this); +}; - if (object == null) { - throw new TypeError('must start with number, buffer, array or string') - } +MVTFeature.prototype.removeLabel = function() { + if (!this.staticLabel) return; + this.staticLabel.remove(); + this.staticLabel = null; +}; - if (typeof ArrayBuffer !== 'undefined') { - if (object.buffer instanceof ArrayBuffer) { - return fromTypedArray(that, object) - } - if (object instanceof ArrayBuffer) { - return fromArrayBuffer(that, object) - } - } +/** + * Projects a vector tile point to the Spherical Mercator pixel space for a given zoom level. + * + * @param vecPt + * @param tileX + * @param tileY + * @param extent + * @param tileSize + */ +MVTFeature.prototype._project = function(vecPt, tileX, tileY, extent, tileSize) { + var xOffset = tileX * tileSize; + var yOffset = tileY * tileSize; + return { + x: Math.floor(vecPt.x + xOffset), + y: Math.floor(vecPt.y + yOffset) + }; +}; - if (object.length) return fromArrayLike(that, object) +/** + * Takes a coordinate from a vector tile and turns it into a Leaflet Point. + * + * @param ctx + * @param coords + * @returns {eGeomType.Point} + * @private + */ +MVTFeature.prototype._tilePoint = function(coords) { + return new L.Point(coords.x / this.divisor, coords.y / this.divisor); +}; - return fromJsonObject(that, object) -} +MVTFeature.prototype.linkedFeature = function() { + var linkedLayer = this.mvtLayer.linkedLayer(); + if(linkedLayer){ + var linkedFeature = linkedLayer.features[this.id]; + return linkedFeature; + }else{ + return null; + } +}; -function fromBuffer (that, buffer) { - var length = checked(buffer.length) | 0 - that = allocate(that, length) - buffer.copy(that, 0, 0, length) - return that -} -function fromArray (that, array) { - var length = checked(array.length) | 0 - that = allocate(that, length) - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 - } - return that -} +},{"./MVTUtil":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTUtil.js","./StaticLabel/StaticLabel.js":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/StaticLabel/StaticLabel.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTLayer.js":[function(require,module,exports){ +/** + * Created by Ryan Whitley on 5/17/14. + */ +/** Forked from https://gist.github.com/DGuidi/1716010 **/ +var MVTFeature = require('./MVTFeature'); +var Util = require('./MVTUtil'); -// Duplicate of fromArray() to keep fromArray() monomorphic. -function fromTypedArray (that, array) { - var length = checked(array.length) | 0 - that = allocate(that, length) - // Truncating the elements is probably not what people expect from typed - // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior - // of the old Buffer constructor. - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 - } - return that -} +module.exports = L.TileLayer.Canvas.extend({ -function fromArrayBuffer (that, array) { - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - array.byteLength - that = Buffer._augment(new Uint8Array(array)) - } else { - // Fallback: Return an object instance of the Buffer class - that = fromTypedArray(that, new Uint8Array(array)) - } - return that -} + options: { + debug: false, + isHiddenLayer: false, + getIDForLayerFeature: function() {}, + tileSize: 256, + lineClickTolerance: 2 + }, -function fromArrayLike (that, array) { - var length = checked(array.length) | 0 - that = allocate(that, length) - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 - } - return that -} + _featureIsClicked: {}, -// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object. -// Returns a zero-length buffer for inputs that don't conform to the spec. -function fromJsonObject (that, object) { - var array - var length = 0 + _isPointInPoly: function(pt, poly) { + if(poly && poly.length) { + for (var c = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i) + ((poly[i].y <= pt.y && pt.y < poly[j].y) || (poly[j].y <= pt.y && pt.y < poly[i].y)) + && (pt.x < (poly[j].x - poly[i].x) * (pt.y - poly[i].y) / (poly[j].y - poly[i].y) + poly[i].x) + && (c = !c); + return c; + } + }, - if (object.type === 'Buffer' && isArray(object.data)) { - array = object.data - length = checked(array.length) | 0 - } - that = allocate(that, length) + _getDistanceFromLine: function(pt, pts) { + var min = Number.POSITIVE_INFINITY; + if (pts && pts.length > 1) { + pt = L.point(pt.x, pt.y); + for (var i = 0, l = pts.length - 1; i < l; i++) { + var test = this._projectPointOnLineSegment(pt, pts[i], pts[i + 1]); + if (test.distance <= min) { + min = test.distance; + } + } + } + return min; + }, - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 - } - return that -} + _projectPointOnLineSegment: function(p, r0, r1) { + var lineLength = r0.distanceTo(r1); + if (lineLength < 1) { + return {distance: p.distanceTo(r0), coordinate: r0}; + } + var u = ((p.x - r0.x) * (r1.x - r0.x) + (p.y - r0.y) * (r1.y - r0.y)) / Math.pow(lineLength, 2); + if (u < 0.0000001) { + return {distance: p.distanceTo(r0), coordinate: r0}; + } + if (u > 0.9999999) { + return {distance: p.distanceTo(r1), coordinate: r1}; + } + var a = L.point(r0.x + u * (r1.x - r0.x), r0.y + u * (r1.y - r0.y)); + return {distance: p.distanceTo(a), point: a}; + }, -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype - Buffer.__proto__ = Uint8Array -} + initialize: function(mvtSource, options) { + var self = this; + self.mvtSource = mvtSource; + L.Util.setOptions(this, options); -function allocate (that, length) { - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = Buffer._augment(new Uint8Array(length)) - that.__proto__ = Buffer.prototype - } else { - // Fallback: Return an object instance of the Buffer class - that.length = length - that._isBuffer = true - } + this.style = options.style; + this.name = options.name; + this._canvasIDToFeatures = {}; + this.features = {}; + this.featuresWithLabels = []; + this._highestCount = 0; + }, - var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1 - if (fromPool) that.parent = rootParent + onAdd: function(map) { + var self = this; + self.map = map; + L.TileLayer.Canvas.prototype.onAdd.call(this, map); + map.on('layerremove', function(e) { + // we only want to do stuff when the layerremove event is on this layer + if (e.layer._leaflet_id === self._leaflet_id) { + removeLabels(self); + } + }); + }, - return that -} + drawTile: function(canvas, tilePoint, zoom) { -function checked (length) { - // Note: cannot use `length < kMaxLength` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} + var ctx = { + canvas: canvas, + tile: tilePoint, + zoom: zoom, + tileSize: this.options.tileSize + }; -function SlowBuffer (subject, encoding) { - if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding) + ctx.id = Util.getContextID(ctx); - var buf = new Buffer(subject, encoding) - delete buf.parent - return buf -} + if (!this._canvasIDToFeatures[ctx.id]) { + this._initializeFeaturesHash(ctx); + } + if (!this.features) { + this.features = {}; + } -Buffer.isBuffer = function isBuffer (b) { - return !!(b != null && b._isBuffer) -} + }, -Buffer.compare = function compare (a, b) { - if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } + _initializeFeaturesHash: function(ctx){ + this._canvasIDToFeatures[ctx.id] = {}; + this._canvasIDToFeatures[ctx.id].features = []; + this._canvasIDToFeatures[ctx.id].canvas = ctx.canvas; + }, - if (a === b) return 0 + _draw: function(ctx) { + //Draw is handled by the parent MVTSource object + }, + getCanvas: function(parentCtx){ + //This gets called if a vector tile feature has already been parsed. + //We've already got the geom, just get on with the drawing. + //Need a way to pluck a canvas element from this layer given the parent layer's id. + //Wait for it to get loaded before proceeding. + var tilePoint = parentCtx.tile; + var ctx = this._tiles[tilePoint.x + ":" + tilePoint.y]; - var x = a.length - var y = b.length + if(ctx){ + parentCtx.canvas = ctx; + this.redrawTile(parentCtx.id); + return; + } - var i = 0 - var len = Math.min(x, y) - while (i < len) { - if (a[i] !== b[i]) break + var self = this; - ++i - } + //This is a timer that will wait for a criterion to return true. + //If not true within the timeout duration, it will move on. + waitFor(function () { + ctx = self._tiles[tilePoint.x + ":" + tilePoint.y]; + if(ctx) { + return true; + } + }, + function(){ + //When it finishes, do this. + ctx = self._tiles[tilePoint.x + ":" + tilePoint.y]; + parentCtx.canvas = ctx; + self.redrawTile(parentCtx.id); - if (i !== len) { - x = a[i] - y = b[i] - } + }, //when done, go to next flow + 2000); //The Timeout milliseconds. After this, give up and move on - if (x < y) return -1 - if (y < x) return 1 - return 0 -} + }, -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'binary': - case 'base64': - case 'raw': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -} + parseVectorTileLayer: function(vtl, ctx) { + var self = this; + var tilePoint = ctx.tile; + var layerCtx = { canvas: null, id: ctx.id, tile: ctx.tile, zoom: ctx.zoom, tileSize: ctx.tileSize}; + + //See if we can pluck the child tile from this PBF tile layer based on the master layer's tile id. + layerCtx.canvas = self._tiles[tilePoint.x + ":" + tilePoint.y]; -Buffer.concat = function concat (list, length) { - if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.') - if (list.length === 0) { - return new Buffer(0) - } - var i - if (length === undefined) { - length = 0 - for (i = 0; i < list.length; i++) { - length += list[i].length + //Initialize this tile's feature storage hash, if it hasn't already been created. Used for when filters are updated, and features are cleared to prepare for a fresh redraw. + if (!this._canvasIDToFeatures[layerCtx.id]) { + this._initializeFeaturesHash(layerCtx); + }else{ + //Clear this tile's previously saved features. + this.clearTileFeatureHash(layerCtx.id); } - } - var buf = new Buffer(length) - var pos = 0 - for (i = 0; i < list.length; i++) { - var item = list[i] - item.copy(buf, pos) - pos += item.length - } - return buf -} + var features = vtl.parsedFeatures; + for (var i = 0, len = features.length; i < len; i++) { + var vtf = features[i]; //vector tile feature + vtf.layer = vtl; -function byteLength (string, encoding) { - if (typeof string !== 'string') string = '' + string - - var len = string.length - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false - for (;;) { - switch (encoding) { - case 'ascii': - case 'binary': - // Deprecated - case 'raw': - case 'raws': - return len - case 'utf8': - case 'utf-8': - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase() - loweredCase = true - } - } -} -Buffer.byteLength = byteLength + /** + * Apply filter on feature if there is one. Defined in the options object + * of TileLayer.MVTSource.js + */ + var filter = self.options.filter; + if (typeof filter === 'function') { + if ( filter(vtf, layerCtx) === false ) continue; + } + + var getIDForLayerFeature; + if (typeof self.options.getIDForLayerFeature === 'function') { + getIDForLayerFeature = self.options.getIDForLayerFeature; + } else { + getIDForLayerFeature = Util.getIDForLayerFeature; + } + var uniqueID = self.options.getIDForLayerFeature(vtf) || i; + var mvtFeature = self.features[uniqueID]; -// pre-set for values that may exist in the future -Buffer.prototype.length = undefined -Buffer.prototype.parent = undefined + /** + * Use layerOrdering function to apply a zIndex property to each vtf. This is defined in + * TileLayer.MVTSource.js. Used below to sort features.npm + */ + var layerOrdering = self.options.layerOrdering; + if (typeof layerOrdering === 'function') { + layerOrdering(vtf, layerCtx); //Applies a custom property to the feature, which is used after we're thru iterating to sort + } -function slowToString (encoding, start, end) { - var loweredCase = false + //Create a new MVTFeature if one doesn't already exist for this feature. + if (!mvtFeature) { + //Get a style for the feature - set it just once for each new MVTFeature + var style = self.style(vtf); - start = start | 0 - end = end === undefined || end === Infinity ? this.length : end | 0 + //create a new feature + self.features[uniqueID] = mvtFeature = new MVTFeature(self, vtf, layerCtx, uniqueID, style); + if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') { + self.featuresWithLabels.push(mvtFeature); + } + } else { + //Add the new part to the existing feature + mvtFeature.addTileFeature(vtf, layerCtx); + } - if (!encoding) encoding = 'utf8' - if (start < 0) start = 0 - if (end > this.length) end = this.length - if (end <= start) return '' + //Associate & Save this feature with this tile for later + if(layerCtx && layerCtx.id) self._canvasIDToFeatures[layerCtx.id]['features'].push(mvtFeature); - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) + } - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) + /** + * Apply sorting (zIndex) on feature if there is a function defined in the options object + * of TileLayer.MVTSource.js + */ + var layerOrdering = self.options.layerOrdering; + if (layerOrdering) { + //We've assigned the custom zIndex property when iterating above. Now just sort. + self._canvasIDToFeatures[layerCtx.id].features = self._canvasIDToFeatures[layerCtx.id].features.sort(function(a, b) { + return -(b.properties.zIndex - a.properties.zIndex) + }); + } - case 'ascii': - return asciiSlice(this, start, end) + self.redrawTile(layerCtx.id); + }, - case 'binary': - return binarySlice(this, start, end) + setStyle: function(styleFn) { + // refresh the number for the highest count value + // this is used only for choropleth + this._highestCount = 0; - case 'base64': - return base64Slice(this, start, end) + // lowest count should not be 0, since we want to figure out the lowest + this._lowestCount = null; - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) + this.style = styleFn; + for (var key in this.features) { + var feat = this.features[key]; + feat.setStyle(styleFn); + } + var z = this.map.getZoom(); + for (var key in this._tiles) { + var id = z + ':' + key; + this.redrawTile(id); + } + }, - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase() - loweredCase = true + /** + * As counts for choropleths come in with the ajax data, + * we want to keep track of which value is the highest + * to create the color ramp for the fills of polygons. + * @param count + */ + setHighestCount: function(count) { + if (count > this._highestCount) { + this._highestCount = count; } - } -} + }, -Buffer.prototype.toString = function toString () { - var length = this.length | 0 - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -} + /** + * Returns the highest number of all of the counts that have come in + * from setHighestCount. This is assumed to be set via ajax callbacks. + * @returns {number} + */ + getHighestCount: function() { + return this._highestCount; + }, -Buffer.prototype.equals = function equals (b) { - if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -} + setLowestCount: function(count) { + if (!this._lowestCount || count < this._lowestCount) { + this._lowestCount = count; + } + }, -Buffer.prototype.inspect = function inspect () { - var str = '' - var max = exports.INSPECT_MAX_BYTES - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') - if (this.length > max) str += ' ... ' - } - return '' -} + getLowestCount: function() { + return this._lowestCount; + }, -Buffer.prototype.compare = function compare (b) { - if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return 0 - return Buffer.compare(this, b) -} + setCountRange: function(count) { + this.setHighestCount(count); + this.setLowestCount(count); + }, -Buffer.prototype.indexOf = function indexOf (val, byteOffset) { - if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff - else if (byteOffset < -0x80000000) byteOffset = -0x80000000 - byteOffset >>= 0 + //This is the old way. It works, but is slow for mouseover events. Fine for click events. + handleClickEvent: function(evt, cb) { + //Click happened on the GroupLayer (Manager) and passed it here + var tileID = evt.tileID.split(":").slice(1, 3).join(":"); + var zoom = evt.tileID.split(":")[0]; + var canvas = this._tiles[tileID]; + if(!canvas) (cb(evt)); //break out + var x = evt.layerPoint.x - canvas._leaflet_pos.x; + var y = evt.layerPoint.y - canvas._leaflet_pos.y; - if (this.length === 0) return -1 - if (byteOffset >= this.length) return -1 + var tilePoint = {x: x, y: y}; + var features = this._canvasIDToFeatures[evt.tileID].features; - // Negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0) + var minDistance = Number.POSITIVE_INFINITY; + var nearest = null; + var j, paths, distance; - if (typeof val === 'string') { - if (val.length === 0) return -1 // special case: looking for empty string always fails - return String.prototype.indexOf.call(this, val, byteOffset) - } - if (Buffer.isBuffer(val)) { - return arrayIndexOf(this, val, byteOffset) - } - if (typeof val === 'number') { - if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') { - return Uint8Array.prototype.indexOf.call(this, val, byteOffset) - } - return arrayIndexOf(this, [ val ], byteOffset) - } + for (var i = 0; i < features.length; i++) { + var feature = features[i]; + switch (feature.type) { - function arrayIndexOf (arr, val, byteOffset) { - var foundIndex = -1 - for (var i = 0; byteOffset + i < arr.length; i++) { - if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) { - if (foundIndex === -1) foundIndex = i - if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex - } else { - foundIndex = -1 - } - } - return -1 - } + case 1: //Point - currently rendered as circular paths. Intersect with that. - throw new TypeError('val must be string, number or Buffer') -} + //Find the radius of the point. + var radius = 3; + if (typeof feature.style.radius === 'function') { + radius = feature.style.radius(zoom); //Allows for scale dependent rednering + } + else{ + radius = feature.style.radius; + } -// `get` is deprecated -Buffer.prototype.get = function get (offset) { - console.log('.get() is deprecated. Access using array indexes instead.') - return this.readUInt8(offset) -} + paths = feature.getPathsForTile(evt.tileID); + for (j = 0; j < paths.length; j++) { + //Builds a circle of radius feature.style.radius (assuming circular point symbology). + if(in_circle(paths[j][0].x, paths[j][0].y, radius, x, y)){ + nearest = feature; + minDistance = 0; + } + } + break; -// `set` is deprecated -Buffer.prototype.set = function set (v, offset) { - console.log('.set() is deprecated. Access using array indexes instead.') - return this.writeUInt8(v, offset) -} + case 2: //LineString + paths = feature.getPathsForTile(evt.tileID); + for (j = 0; j < paths.length; j++) { + if (feature.style) { + var distance = this._getDistanceFromLine(tilePoint, paths[j]); + var thickness = (feature.selected && feature.style.selected ? feature.style.selected.size : feature.style.size); + if (distance < thickness / 2 + this.options.lineClickTolerance && distance < minDistance) { + nearest = feature; + minDistance = distance; + } + } + } + break; -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0 - var remaining = buf.length - offset - if (!length) { - length = remaining - } else { - length = Number(length) - if (length > remaining) { - length = remaining + case 3: //Polygon + paths = feature.getPathsForTile(evt.tileID); + for (j = 0; j < paths.length; j++) { + if (this._isPointInPoly(tilePoint, paths[j])) { + nearest = feature; + minDistance = 0; // point is inside the polygon, so distance is zero + } + } + break; + } + if (minDistance == 0) break; } - } - // must be an even number of digits - var strLen = string.length - if (strLen % 2 !== 0) throw new Error('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2 - } - for (var i = 0; i < length; i++) { - var parsed = parseInt(string.substr(i * 2, 2), 16) - if (isNaN(parsed)) throw new Error('Invalid hex string') - buf[offset + i] = parsed - } - return i -} + if (nearest && nearest.toggleEnabled) { + nearest.toggle(); + } + evt.feature = nearest; + cb(evt); + }, -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} + clearTile: function(id) { + //id is the entire zoom:x:y. we just want x:y. + var ca = id.split(":"); + var canvasId = ca[1] + ":" + ca[2]; + if (typeof this._tiles[canvasId] === 'undefined') { + console.error("typeof this._tiles[canvasId] === 'undefined'"); + return; + } + var canvas = this._tiles[canvasId]; -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} + var context = canvas.getContext('2d'); + context.clearRect(0, 0, canvas.width, canvas.height); + }, -function binaryWrite (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} + clearTileFeatureHash: function(canvasID){ + this._canvasIDToFeatures[canvasID] = { features: []}; //Get rid of all saved features + }, -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} + clearLayerFeatureHash: function(){ + this.features = {}; + }, -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} + redrawTile: function(canvasID) { + //First, clear the canvas + this.clearTile(canvasID); -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8' - length = this.length - offset = 0 - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset - length = this.length - offset = 0 - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0 - if (isFinite(length)) { - length = length | 0 - if (encoding === undefined) encoding = 'utf8' - } else { - encoding = length - length = undefined + // If the features are not in the tile, then there is nothing to redraw. + // This may happen if you call redraw before features have loaded and initially + // drawn the tile. + var featfeats = this._canvasIDToFeatures[canvasID]; + if (!featfeats) { + return; } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - var swap = encoding - encoding = offset - offset = length | 0 - length = swap - } - var remaining = this.length - offset - if (length === undefined || length > remaining) length = remaining + //Get the features for this tile, and redraw them. + var features = featfeats.features; - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('attempt to write outside buffer bounds') - } + // we want to skip drawing the selected features and draw them last + var selectedFeatures = []; + + // drawing all of the non-selected features + for (var i = 0; i < features.length; i++) { + var feature = features[i]; + if (feature.selected) { + selectedFeatures.push(feature); + } else { + feature.draw(canvasID); + } + } - if (!encoding) encoding = 'utf8' + // drawing the selected features last + for (var j = 0, len2 = selectedFeatures.length; j < len2; j++) { + var selFeat = selectedFeatures[j]; + selFeat.draw(canvasID); + } + }, - var loweredCase = false - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) + _resetCanvasIDToFeatures: function(canvasID, canvas) { - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) + this._canvasIDToFeatures[canvasID] = {}; + this._canvasIDToFeatures[canvasID].features = []; + this._canvasIDToFeatures[canvasID].canvas = canvas; - case 'ascii': - return asciiWrite(this, string, offset, length) + }, - case 'binary': - return binaryWrite(this, string, offset, length) + linkedLayer: function() { + if(this.mvtSource.layerLink) { + var linkName = this.mvtSource.layerLink(this.name); + return this.mvtSource.layers[linkName]; + } + else{ + return null; + } + }, - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) + featureWithLabelAdded: function(feature) { + this.featuresWithLabels.push(feature); + } - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) +}); - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase() - loweredCase = true - } - } -} -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) +function removeLabels(self) { + var features = self.featuresWithLabels; + for (var i = 0, len = features.length; i < len; i++) { + var feat = features[i]; + feat.removeLabel(); } + self.featuresWithLabels = []; } -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return base64.fromByteArray(buf) - } else { - return base64.fromByteArray(buf.slice(start, end)) - } +function in_circle(center_x, center_y, radius, x, y) { + var square_dist = Math.pow((center_x - x), 2) + Math.pow((center_y - y), 2); + return square_dist <= Math.pow(radius, 2); } - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end) - var res = [] - - var i = start - while (i < end) { - var firstByte = buf[i] - var codePoint = null - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1 - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte - } - break - case 2: - secondByte = buf[i + 1] - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint - } - } - break - case 3: - secondByte = buf[i + 1] - thirdByte = buf[i + 2] - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint - } - } - break - case 4: - secondByte = buf[i + 1] - thirdByte = buf[i + 2] - fourthByte = buf[i + 3] - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint - } - } +/** + * See https://github.com/ariya/phantomjs/blob/master/examples/waitfor.js + * + * Wait until the test condition is true or a timeout occurs. Useful for waiting + * on a server response or for a ui change (fadeIn, etc.) to occur. + * + * @param testFx javascript condition that evaluates to a boolean, + * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or + * as a callback function. + * @param onReady what to do when testFx condition is fulfilled, + * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or + * as a callback function. + * @param timeOutMillis the max amount of time to wait. If not specified, 3 sec is used. + */ +function waitFor(testFx, onReady, timeOutMillis) { + var maxtimeOutMillis = timeOutMillis ? timeOutMillis : 3000, //< Default Max Timout is 3s + start = new Date().getTime(), + condition = (typeof (testFx) === "string" ? eval(testFx) : testFx()), //< defensive code + interval = setInterval(function () { + if ((new Date().getTime() - start < maxtimeOutMillis) && !condition) { + // If not time-out yet and condition not yet fulfilled + condition = (typeof (testFx) === "string" ? eval(testFx) : testFx()); //< defensive code + } else { + if (!condition) { + // If condition still not fulfilled (timeout but condition is 'false') + console.log("'waitFor()' timeout"); + clearInterval(interval); //< Stop this interval + typeof (onReady) === "string" ? eval(onReady) : onReady('timeout'); //< Do what it's supposed to do once the condition is fulfilled + } else { + // Condition fulfilled (timeout and/or condition is 'true') + console.log("'waitFor()' finished in " + (new Date().getTime() - start) + "ms."); + clearInterval(interval); //< Stop this interval + typeof (onReady) === "string" ? eval(onReady) : onReady('success'); //< Do what it's supposed to do once the condition is fulfilled + } } - } + }, 50); //< repeat check every 50ms +}; +},{"./MVTFeature":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTFeature.js","./MVTUtil":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTUtil.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTSource.js":[function(require,module,exports){ +var VectorTile = require('vector-tile').VectorTile; +var Protobuf = require('pbf'); +var Point = require('point-geometry'); +var Util = require('./MVTUtil'); +var MVTLayer = require('./MVTLayer'); +var geojsonvt = require('geojson-vt'); +var vtpbf = require('vt-pbf'); - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD - bytesPerSequence = 1 - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000 - res.push(codePoint >>> 10 & 0x3FF | 0xD800) - codePoint = 0xDC00 | codePoint & 0x3FF - } +module.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({ - res.push(codePoint) - i += bytesPerSequence - } + options: { + debug: false, + url: "", //URL TO Vector Tile Source, + getIDForLayerFeature: function() {}, + tileSize: 256, + visibleLayers: [], + xhrHeaders: {} + }, + layers: {}, //Keep a list of the layers contained in the PBFs + processedTiles: {}, //Keep a list of tiles that have been processed already + _eventHandlers: {}, + _triggerOnTilesLoadedEvent: true, //whether or not to fire the onTilesLoaded event when all of the tiles finish loading. + _url: "", //internal URL property - return decodeCodePointsArray(res) -} + style: function(feature) { + var style = {}; -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000 + var type = feature.type; + switch (type) { + case 1: //'Point' + style.color = 'rgba(49,79,79,1)'; + style.radius = 5; + style.selected = { + color: 'rgba(255,255,0,0.5)', + radius: 6 + }; + break; + case 2: //'LineString' + style.color = 'rgba(161,217,155,0.8)'; + style.size = 3; + style.selected = { + color: 'rgba(255,25,0,0.5)', + size: 4 + }; + break; + case 3: //'Polygon' + style.color = 'rgba(49,79,79,1)'; + style.outline = { + color: 'rgba(161,217,155,0.8)', + size: 1 + }; + style.selected = { + color: 'rgba(255,140,0,0.3)', + outline: { + color: 'rgba(255,140,0,1)', + size: 2 + } + }; + break; + } + return style; + }, -function decodeCodePointsArray (codePoints) { - var len = codePoints.length - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - // Decode in chunks to avoid "call stack size exceeded". - var res = '' - var i = 0 - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ) - } - return res -} + initialize: function(options) { + L.Util.setOptions(this, options); -function asciiSlice (buf, start, end) { - var ret = '' - end = Math.min(buf.length, end) + //a list of the layers contained in the PBFs + this.layers = {}; - for (var i = start; i < end; i++) { - ret += String.fromCharCode(buf[i] & 0x7F) - } - return ret -} + // tiles currently in the viewport + this.activeTiles = {}; -function binarySlice (buf, start, end) { - var ret = '' - end = Math.min(buf.length, end) + // thats that have been loaded and drawn + this.loadedTiles = {}; - for (var i = start; i < end; i++) { - ret += String.fromCharCode(buf[i]) - } - return ret -} + this._url = this.options.url; -function hexSlice (buf, start, end) { - var len = buf.length + /** + * For some reason, Leaflet has some code that resets the + * z index in the options object. I'm having trouble tracking + * down exactly what does this and why, so for now, we should + * just copy the value to this.zIndex so we can have the right + * number when we make the subsequent MVTLayers. + */ + this.zIndex = options.zIndex; - if (!start || start < 0) start = 0 - if (!end || end < 0 || end > len) end = len + if (typeof options.style === 'function') { + this.style = options.style; + } - var out = '' - for (var i = start; i < end; i++) { - out += toHex(buf[i]) - } - return out -} + if (typeof options.ajaxSource === 'function') { + this.ajaxSource = options.ajaxSource; + } -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end) - var res = '' - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) - } - return res -} + this.layerLink = options.layerLink; -Buffer.prototype.slice = function slice (start, end) { - var len = this.length - start = ~~start - end = end === undefined ? len : ~~end + this._eventHandlers = {}; - if (start < 0) { - start += len - if (start < 0) start = 0 - } else if (start > len) { - start = len - } + this._tilesToProcess = 0; //store the max number of tiles to be loaded. Later, we can use this count to count down PBF loading. + }, - if (end < 0) { - end += len - if (end < 0) end = 0 - } else if (end > len) { - end = len - } + redraw: function(triggerOnTilesLoadedEvent){ + //Only set to false if it actually is passed in as 'false' + if (triggerOnTilesLoadedEvent === false) { + this._triggerOnTilesLoadedEvent = false; + } - if (end < start) end = start + L.TileLayer.Canvas.prototype.redraw.call(this); + }, - var newBuf - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = Buffer._augment(this.subarray(start, end)) - } else { - var sliceLen = end - start - newBuf = new Buffer(sliceLen, undefined) - for (var i = 0; i < sliceLen; i++) { - newBuf[i] = this[i + start] - } - } + onAdd: function(map) { + var self = this; + self.map = map; + L.TileLayer.Canvas.prototype.onAdd.call(this, map); - if (newBuf.length) newBuf.parent = this.parent || this + var mapOnClickCallback = function(e) { + self._onClick(e); + }; - return newBuf -} + map.on('click', mapOnClickCallback); -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} + map.on("layerremove", function(e) { + // check to see if the layer removed is this one + // call a method to remove the child layers (the ones that actually have something drawn on them). + if (e.layer._leaflet_id === self._leaflet_id && e.layer.removeChildLayers) { + e.layer.removeChildLayers(map); + map.off('click', mapOnClickCallback); + } + }); -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) + self.addChildLayers(map); - var val = this[offset] - var mul = 1 - var i = 0 - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul - } + if (typeof DynamicLabel === 'function' ) { + this.dynamicLabel = new DynamicLabel(map, this, {}); + } - return val -} + }, -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) { - checkOffset(offset, byteLength, this.length) - } + drawTile: function(canvas, tilePoint, zoom) { + var ctx = { + id: [zoom, tilePoint.x, tilePoint.y].join(":"), + canvas: canvas, + tile: tilePoint, + zoom: zoom, + tileSize: this.options.tileSize + }; - var val = this[offset + --byteLength] - var mul = 1 - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul - } + //Capture the max number of the tiles to load here. this._tilesToProcess is an internal number we use to know when we've finished requesting PBFs. + if(this._tilesToProcess < this._tilesToLoad) this._tilesToProcess = this._tilesToLoad; - return val -} + var id = ctx.id = Util.getContextID(ctx); + this.activeTiles[id] = ctx; -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length) - return this[offset] -} + if(!this.processedTiles[ctx.zoom]) this.processedTiles[ctx.zoom] = {}; -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - return this[offset] | (this[offset + 1] << 8) -} + if (this.options.debug) { + this._drawDebugInfo(ctx); + } + this._draw(ctx); + }, -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - return (this[offset] << 8) | this[offset + 1] -} + setOpacity:function(opacity) { + this._setVisibleLayersStyle('opacity',opacity); + }, -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + setZIndex:function(zIndex) { + this._setVisibleLayersStyle('zIndex',zIndex); + }, - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -} + _setVisibleLayersStyle:function(style, value) { + for(var key in this.layers) { + this.layers[key]._tileContainer.style[style] = value; + } + }, -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + _drawDebugInfo: function(ctx) { + var max = this.options.tileSize; + var g = ctx.canvas.getContext('2d'); + g.strokeStyle = '#000000'; + g.fillStyle = '#FFFF00'; + g.strokeRect(0, 0, max, max); + g.font = "12px Arial"; + g.fillRect(0, 0, 5, 5); + g.fillRect(0, max - 5, 5, 5); + g.fillRect(max - 5, 0, 5, 5); + g.fillRect(max - 5, max - 5, 5, 5); + g.fillRect(max / 2 - 5, max / 2 - 5, 10, 10); + g.strokeText(ctx.zoom + ' ' + ctx.tile.x + ' ' + ctx.tile.y, max / 2 - 30, max / 2 - 10); + }, - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -} + _draw: function(ctx) { + if (this.options.geoJson) { + this._fetchVectorTileGeojsonVt(ctx); + } else { + this._fetchVectorTileXHR(ctx); + } + }, -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) + _vectorTileLoaded: function(ctx, vt) { + this.checkVectorTileLayers(parseVT(vt), ctx); + tileLoaded(this, ctx); + }, - var val = this[offset] - var mul = 1 - var i = 0 - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul - } - mul *= 0x80 + _fetchVectorTileGeojsonVt: function(ctx) { + var self = this; + if (!self._geojsonvtTileIndex) { + self._geojsonvtTileIndex = geojsonvt(self.options.geoJson); + } + // TODO: Timeout is neccessary because other operations depend on this being asynchronous + // 0ms timeout does not quite solve the problem, for reasons unknown. + window.setTimeout(function(){ + var vectorTileJson = self._geojsonvtTileIndex.getTile(ctx.zoom, ctx.tile.x, ctx.tile.y); + if (vectorTileJson) { + var reformatted = vtpbf.fromGeojsonVt({ 'geojsonLayer': vectorTileJson }); + self._vectorTileLoaded(ctx, new VectorTile(new Protobuf(reformatted))); + self.reduceTilesToProcessCount(); + } + }, 5); + }, - if (val >= mul) val -= Math.pow(2, 8 * byteLength) + _fetchVectorTileXHR: function(ctx) { + var self = this; - return val -} +// //This works to skip fetching and processing tiles if they've already been processed. +// var vectorTile = this.processedTiles[ctx.zoom][ctx.id]; +// //if we've already parsed it, don't get it again. +// if(vectorTile){ +// console.log("Skipping fetching " + ctx.id); +// self.checkVectorTileLayers(parseVT(vectorTile), ctx, true); +// self.reduceTilesToProcessCount(); +// return; +// } -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) + if (!this._url) return; + var src = this.getTileUrl({ x: ctx.tile.x, y: ctx.tile.y, z: ctx.zoom }); - var i = byteLength - var mul = 1 - var val = this[offset + --i] - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul - } - mul *= 0x80 + var xhr = new XMLHttpRequest(); + xhr.onload = function() { + if (xhr.status == "200") { - if (val >= mul) val -= Math.pow(2, 8 * byteLength) + if(!xhr.response) return; - return val -} + var arrayBuffer = new Uint8Array(xhr.response); + var buf = new Protobuf(arrayBuffer); + var vt = new VectorTile(buf); + //Check the current map layer zoom. If fast zooming is occurring, then short circuit tiles that are for a different zoom level than we're currently on. + if(self.map && self.map.getZoom() != ctx.zoom) { + console.log("Fetched tile for zoom level " + ctx.zoom + ". Map is at zoom level " + self._map.getZoom()); + return; + } + self._vectorTileLoaded(ctx, vt); + } -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length) - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -} + //either way, reduce the count of tilesToProcess tiles here + self.reduceTilesToProcessCount(); + }; -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - var val = this[offset] | (this[offset + 1] << 8) - return (val & 0x8000) ? val | 0xFFFF0000 : val -} + xhr.onerror = function() { + console.log("xhr error: " + xhr.status) + }; -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - var val = this[offset + 1] | (this[offset] << 8) - return (val & 0x8000) ? val | 0xFFFF0000 : val -} + xhr.open('GET', src, true); //async is true + var headers = self.options.xhrHeaders; + for (var header in headers) { + xhr.setRequestHeader(header, headers[header]) + } + xhr.responseType = 'arraybuffer'; + xhr.send(); + }, -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + reduceTilesToProcessCount: function(){ + this._tilesToProcess--; + if(!this._tilesToProcess){ + //Trigger event letting us know that all PBFs have been loaded and processed (or 404'd). + if(this._eventHandlers["PBFLoad"]) this._eventHandlers["PBFLoad"](); + this._pbfLoaded(); + } + }, - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -} + checkVectorTileLayers: function(vt, ctx, parsed) { + var self = this; -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + //Check if there are specified visible layers + if(self.options.visibleLayers && self.options.visibleLayers.length > 0){ + //only let thru the layers listed in the visibleLayers array + for(var i=0; i < self.options.visibleLayers.length; i++){ + var layerName = self.options.visibleLayers[i]; + if(vt.layers[layerName]){ + //Proceed with parsing + self.prepareMVTLayers(vt.layers[layerName], layerName, ctx, parsed); + } + } + }else{ + //Parse all vt.layers + for (var key in vt.layers) { + self.prepareMVTLayers(vt.layers[key], key, ctx, parsed); + } + } + }, - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -} + prepareMVTLayers: function(lyr ,key, ctx, parsed) { + var self = this; -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) - return ieee754.read(this, offset, true, 23, 4) -} + if (!self.layers[key]) { + //Create MVTLayer or MVTPointLayer for user + self.layers[key] = self.createMVTLayer(key, lyr.parsedFeatures[0].type || null); + } -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) - return ieee754.read(this, offset, false, 23, 4) -} + if (parsed) { + //We've already parsed it. Go get canvas and draw. + self.layers[key].getCanvas(ctx, lyr); + } else { + self.layers[key].parseVectorTileLayer(lyr, ctx); + } -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length) - return ieee754.read(this, offset, true, 52, 8) -} + }, -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length) - return ieee754.read(this, offset, false, 52, 8) -} + createMVTLayer: function(key, type) { + var self = this; -function checkInt (buf, value, offset, ext, max, min) { - if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance') - if (value > max || value < min) throw new RangeError('value is out of bounds') - if (offset + ext > buf.length) throw new RangeError('index out of range') -} + var getIDForLayerFeature; + if (typeof self.options.getIDForLayerFeature === 'function') { + getIDForLayerFeature = self.options.getIDForLayerFeature; + } else { + getIDForLayerFeature = Util.getIDForLayerFeature; + } -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) - - var mul = 1 - var i = 0 - this[offset] = value & 0xFF - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF - } + var options = { + getIDForLayerFeature: getIDForLayerFeature, + filter: self.options.filter, + layerOrdering: self.options.layerOrdering, + style: self.style, + name: key, + asynch: true + }; - return offset + byteLength -} + if (self.options.zIndex) { + options.zIndex = self.zIndex; + } -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) - - var i = byteLength - 1 - var mul = 1 - this[offset + i] = value & 0xFF - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF - } + //Take the layer and create a new MVTLayer or MVTPointLayer if one doesn't exist. + var layer = new MVTLayer(self, options).addTo(self.map); - return offset + byteLength -} + return layer; + }, -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) - this[offset] = (value & 0xff) - return offset + 1 -} + getLayers: function() { + return this.layers; + }, -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1 - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8 - } -} + hideLayer: function(id) { + if (this.layers[id]) { + this._map.removeLayer(this.layers[id]); + if(this.options.visibleLayers.indexOf("id") > -1){ + this.visibleLayers.splice(this.options.visibleLayers.indexOf("id"), 1); + } + } + }, -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - } else { - objectWriteUInt16(this, value, offset, true) - } - return offset + 2 -} + showLayer: function(id) { + if (this.layers[id]) { + this._map.addLayer(this.layers[id]); + if(this.options.visibleLayers.indexOf("id") == -1){ + this.visibleLayers.push(id); + } + } + //Make sure manager layer is always in front + this.bringToFront(); + }, -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8) - this[offset + 1] = (value & 0xff) - } else { - objectWriteUInt16(this, value, offset, false) - } - return offset + 2 -} + removeChildLayers: function(map){ + //Remove child layers of this group layer + for (var key in this.layers) { + var layer = this.layers[key]; + map.removeLayer(layer); + } + }, -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1 - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff - } -} + addChildLayers: function(map) { + var self = this; + if(self.options.visibleLayers.length > 0){ + //only let thru the layers listed in the visibleLayers array + for(var i=0; i < self.options.visibleLayers.length; i++){ + var layerName = self.options.visibleLayers[i]; + var layer = this.layers[layerName]; + if(layer){ + //Proceed with parsing + map.addLayer(layer); + } + } + }else{ + //Add all layers + for (var key in this.layers) { + var layer = this.layers[key]; + // layer is set to visible and is not already on map + if (!layer._map) { + map.addLayer(layer); + } + } + } + }, -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24) - this[offset + 2] = (value >>> 16) - this[offset + 1] = (value >>> 8) - this[offset] = (value & 0xff) - } else { - objectWriteUInt32(this, value, offset, true) - } - return offset + 4 -} + bind: function(eventType, callback) { + this._eventHandlers[eventType] = callback; + }, -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24) - this[offset + 1] = (value >>> 16) - this[offset + 2] = (value >>> 8) - this[offset + 3] = (value & 0xff) - } else { - objectWriteUInt32(this, value, offset, false) - } - return offset + 4 -} + _onClick: function(evt) { + //Here, pass the event on to the child MVTLayer and have it do the hit test and handle the result. + var self = this; + var onClick = self.options.onClick; + var clickableLayers = self.options.clickableLayers; + var layers = self.layers; -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1) + evt.tileID = getTileURL(evt.latlng.lat, evt.latlng.lng, this.map.getZoom()); - checkInt(this, value, offset, byteLength, limit - 1, -limit) - } + // We must have an array of clickable layers, otherwise, we just pass + // the event to the public onClick callback in options. - var i = 0 - var mul = 1 - var sub = value < 0 ? 1 : 0 - this[offset] = value & 0xFF - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF - } + if(!clickableLayers){ + clickableLayers = Object.keys(self.layers); + } - return offset + byteLength -} + if (clickableLayers && clickableLayers.length > 0) { + for (var i = 0, len = clickableLayers.length; i < len; i++) { + var key = clickableLayers[i]; + var layer = layers[key]; + if (layer) { + layer.handleClickEvent(evt, function(evt) { + if (typeof onClick === 'function') { + onClick(evt); + } + }); + } + } + } else { + if (typeof onClick === 'function') { + onClick(evt); + } + } -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1) + }, - checkInt(this, value, offset, byteLength, limit - 1, -limit) - } + setFilter: function(filterFunction, layerName) { + //take in a new filter function. + //Propagate to child layers. - var i = byteLength - 1 - var mul = 1 - var sub = value < 0 ? 1 : 0 - this[offset + i] = value & 0xFF - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF - } + //Add filter to all child layers if no layer is specified. + for (var key in this.layers) { + var layer = this.layers[key]; - return offset + byteLength -} + if (layerName){ + if(key.toLowerCase() == layerName.toLowerCase()){ + layer.options.filter = filterFunction; //Assign filter to child layer, only if name matches + //After filter is set, the old feature hashes are invalid. Clear them for next draw. + layer.clearLayerFeatureHash(); + //layer.clearTileFeatureHash(); + } + } + else{ + layer.options.filter = filterFunction; //Assign filter to child layer + //After filter is set, the old feature hashes are invalid. Clear them for next draw. + layer.clearLayerFeatureHash(); + //layer.clearTileFeatureHash(); + } + } + }, -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) - if (value < 0) value = 0xff + value + 1 - this[offset] = (value & 0xff) - return offset + 1 -} + /** + * Take in a new style function and propogate to child layers. + * If you do not set a layer name, it resets the style for all of the layers. + * @param styleFunction + * @param layerName + */ + setStyle: function(styleFn, layerName) { + for (var key in this.layers) { + var layer = this.layers[key]; + if (layerName) { + if(key.toLowerCase() == layerName.toLowerCase()) { + layer.setStyle(styleFn); + } + } else { + layer.setStyle(styleFn); + } + } + }, -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - } else { - objectWriteUInt16(this, value, offset, true) - } - return offset + 2 -} + featureSelected: function(mvtFeature) { + if (this.options.mutexToggle) { + if (this._selectedFeature) { + this._selectedFeature.deselect(); + } + this._selectedFeature = mvtFeature; + } + if (this.options.onSelect) { + this.options.onSelect(mvtFeature); + } + }, -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8) - this[offset + 1] = (value & 0xff) - } else { - objectWriteUInt16(this, value, offset, false) - } - return offset + 2 -} + featureDeselected: function(mvtFeature) { + if (this.options.mutexToggle && this._selectedFeature) { + this._selectedFeature = null; + } + if (this.options.onDeselect) { + this.options.onDeselect(mvtFeature); + } + }, -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - this[offset + 2] = (value >>> 16) - this[offset + 3] = (value >>> 24) - } else { - objectWriteUInt32(this, value, offset, true) - } - return offset + 4 -} + _pbfLoaded: function() { + //Fires when all tiles from this layer have been loaded and drawn (or 404'd). -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) - if (value < 0) value = 0xffffffff + value + 1 - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24) - this[offset + 1] = (value >>> 16) - this[offset + 2] = (value >>> 8) - this[offset + 3] = (value & 0xff) - } else { - objectWriteUInt32(this, value, offset, false) - } - return offset + 4 -} + //Make sure manager layer is always in front + this.bringToFront(); -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (value > max || value < min) throw new RangeError('value is out of bounds') - if (offset + ext > buf.length) throw new RangeError('index out of range') - if (offset < 0) throw new RangeError('index out of range') -} + //See if there is an event to execute + var self = this; + var onTilesLoaded = self.options.onTilesLoaded; -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + if (onTilesLoaded && typeof onTilesLoaded === 'function' && this._triggerOnTilesLoadedEvent === true) { + onTilesLoaded(this); + } + self._triggerOnTilesLoadedEvent = true; //reset - if redraw() is called with the optinal 'false' parameter to temporarily disable the onTilesLoaded event from firing. This resets it back to true after a single time of firing as 'false'. } - ieee754.write(buf, value, offset, littleEndian, 23, 4) - return offset + 4 -} -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -} +}); -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -} -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) +if (typeof(Number.prototype.toRad) === "undefined") { + Number.prototype.toRad = function() { + return this * Math.PI / 180; } - ieee754.write(buf, value, offset, littleEndian, 52, 8) - return offset + 8 } -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) +function getTileURL(lat, lon, zoom) { + var xtile = parseInt(Math.floor( (lon + 180) / 360 * (1<= target.length) targetStart = target.length - if (!targetStart) targetStart = 0 - if (end > 0 && end < start) end = start - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start +function parseVT(vt){ + for (var key in vt.layers) { + var lyr = vt.layers[key]; + parseVTFeatures(lyr); } + return vt; +} - var len = end - start - var i - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; i--) { - target[i + targetStart] = this[i + start] - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; i++) { - target[i + targetStart] = this[i + start] - } - } else { - target._set(this.subarray(start, start + len), targetStart) +function parseVTFeatures(vtl){ + vtl.parsedFeatures = []; + var features = vtl._features; + for (var i = 0, len = features.length; i < len; i++) { + var vtf = vtl.feature(i); + vtf.coordinates = vtf.loadGeometry(); + vtl.parsedFeatures.push(vtf); } - - return len + return vtl; } -// fill(value, start=0, end=buffer.length) -Buffer.prototype.fill = function fill (value, start, end) { - if (!value) value = 0 - if (!start) start = 0 - if (!end) end = this.length - - if (end < start) throw new RangeError('end < start') - - // Fill 0 bytes; we're done - if (end === start) return - if (this.length === 0) return - - if (start < 0 || start >= this.length) throw new RangeError('start out of bounds') - if (end < 0 || end > this.length) throw new RangeError('end out of bounds') - - var i - if (typeof value === 'number') { - for (i = start; i < end; i++) { - this[i] = value - } - } else { - var bytes = utf8ToBytes(value.toString()) - var len = bytes.length - for (i = start; i < end; i++) { - this[i] = bytes[i % len] - } - } +},{"./MVTLayer":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTLayer.js","./MVTUtil":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTUtil.js","geojson-vt":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/index.js","pbf":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/index.js","point-geometry":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/point-geometry/index.js","vector-tile":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/index.js","vt-pbf":"/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/index.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTUtil.js":[function(require,module,exports){ +/** + * Created by Nicholas Hallahan + * on 8/15/14. + */ +var Util = module.exports = {}; - return this -} +Util.getContextID = function(ctx) { + return [ctx.zoom, ctx.tile.x, ctx.tile.y].join(":"); +}; /** - * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance. - * Added in Node 0.12. Only available in browsers that support ArrayBuffer. + * Default function that gets the id for a layer feature. + * Sometimes this needs to be done in a different way and + * can be specified by the user in the options for L.TileLayer.MVTSource. + * + * @param feature + * @returns {ctx.id|*|id|string|jsts.index.chain.MonotoneChain.id|number} */ -Buffer.prototype.toArrayBuffer = function toArrayBuffer () { - if (typeof Uint8Array !== 'undefined') { - if (Buffer.TYPED_ARRAY_SUPPORT) { - return (new Buffer(this)).buffer +Util.getIDForLayerFeature = function(feature) { + return feature.properties.id; +}; + +Util.getJSON = function(url, callback) { + var xmlhttp = typeof XMLHttpRequest !== 'undefined' ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP'); + xmlhttp.onreadystatechange = function() { + var status = xmlhttp.status; + if (xmlhttp.readyState === 4 && status >= 200 && status < 300) { + var json = JSON.parse(xmlhttp.responseText); + callback(null, json); } else { - var buf = new Uint8Array(this.length) - for (var i = 0, len = buf.length; i < len; i += 1) { - buf[i] = this[i] - } - return buf.buffer + callback( { error: true, status: status } ); } - } else { - throw new TypeError('Buffer.toArrayBuffer not supported in this browser') - } -} - -// HELPER FUNCTIONS -// ================ - -var BP = Buffer.prototype + }; + xmlhttp.open("GET", url, true); + xmlhttp.send(); +}; +},{}],"/Users/wil/Code/Leaflet.MapboxVectorTile/src/StaticLabel/StaticLabel.js":[function(require,module,exports){ /** - * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods + * Created by Nicholas Hallahan + * on 7/31/14. */ -Buffer._augment = function _augment (arr) { - arr.constructor = Buffer - arr._isBuffer = true - - // save reference to original Uint8Array set method before overwriting - arr._set = arr.set - - // deprecated - arr.get = BP.get - arr.set = BP.set - - arr.write = BP.write - arr.toString = BP.toString - arr.toLocaleString = BP.toString - arr.toJSON = BP.toJSON - arr.equals = BP.equals - arr.compare = BP.compare - arr.indexOf = BP.indexOf - arr.copy = BP.copy - arr.slice = BP.slice - arr.readUIntLE = BP.readUIntLE - arr.readUIntBE = BP.readUIntBE - arr.readUInt8 = BP.readUInt8 - arr.readUInt16LE = BP.readUInt16LE - arr.readUInt16BE = BP.readUInt16BE - arr.readUInt32LE = BP.readUInt32LE - arr.readUInt32BE = BP.readUInt32BE - arr.readIntLE = BP.readIntLE - arr.readIntBE = BP.readIntBE - arr.readInt8 = BP.readInt8 - arr.readInt16LE = BP.readInt16LE - arr.readInt16BE = BP.readInt16BE - arr.readInt32LE = BP.readInt32LE - arr.readInt32BE = BP.readInt32BE - arr.readFloatLE = BP.readFloatLE - arr.readFloatBE = BP.readFloatBE - arr.readDoubleLE = BP.readDoubleLE - arr.readDoubleBE = BP.readDoubleBE - arr.writeUInt8 = BP.writeUInt8 - arr.writeUIntLE = BP.writeUIntLE - arr.writeUIntBE = BP.writeUIntBE - arr.writeUInt16LE = BP.writeUInt16LE - arr.writeUInt16BE = BP.writeUInt16BE - arr.writeUInt32LE = BP.writeUInt32LE - arr.writeUInt32BE = BP.writeUInt32BE - arr.writeIntLE = BP.writeIntLE - arr.writeIntBE = BP.writeIntBE - arr.writeInt8 = BP.writeInt8 - arr.writeInt16LE = BP.writeInt16LE - arr.writeInt16BE = BP.writeInt16BE - arr.writeInt32LE = BP.writeInt32LE - arr.writeInt32BE = BP.writeInt32BE - arr.writeFloatLE = BP.writeFloatLE - arr.writeFloatBE = BP.writeFloatBE - arr.writeDoubleLE = BP.writeDoubleLE - arr.writeDoubleBE = BP.writeDoubleBE - arr.fill = BP.fill - arr.inspect = BP.inspect - arr.toArrayBuffer = BP.toArrayBuffer - - return arr -} +var Util = require('../MVTUtil'); +module.exports = StaticLabel; -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g +function StaticLabel(mvtFeature, ctx, latLng, style) { + var self = this; + this.mvtFeature = mvtFeature; + this.map = mvtFeature.map; + this.zoom = ctx.zoom; + this.latLng = latLng; + this.selected = false; -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, '') - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '=' + if (mvtFeature.linkedFeature) { + var linkedFeature = mvtFeature.linkedFeature(); + if (linkedFeature && linkedFeature.selected) { + self.selected = true; + } } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) + init(self, mvtFeature, ctx, latLng, style) } -function utf8ToBytes (string, units) { - units = units || Infinity - var codePoint - var length = string.length - var leadSurrogate = null - var bytes = [] - - for (var i = 0; i < length; i++) { - codePoint = string.charCodeAt(i) - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - continue - } - - // valid lead - leadSurrogate = codePoint - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - leadSurrogate = codePoint - continue - } - - // valid surrogate pair - codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000 - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - } - - leadSurrogate = null - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint) - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ) - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ) - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ) - } else { - throw new Error('Invalid code point') - } - } +function init(self, mvtFeature, ctx, latLng, style) { + var ajaxData = mvtFeature.ajaxData; + var sty = self.style = style.staticLabel(mvtFeature, ajaxData); + var icon = self.icon = L.divIcon({ + className: sty.cssClass || 'label-icon-text', + html: sty.html, + iconSize: sty.iconSize || [50,50] + }); - return bytes -} + self.marker = L.marker(latLng, {icon: icon}).addTo(self.map); -function asciiToBytes (str) { - var byteArray = [] - for (var i = 0; i < str.length; i++) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF) + if (self.selected) { + self.marker._icon.classList.add(self.style.cssSelectedClass || 'label-icon-text-selected'); } - return byteArray -} -function utf16leToBytes (str, units) { - var c, hi, lo - var byteArray = [] - for (var i = 0; i < str.length; i++) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i) - hi = c >> 8 - lo = c % 256 - byteArray.push(lo) - byteArray.push(hi) - } + self.marker.on('click', function(e) { + self.toggle(); + }); - return byteArray + self.map.on('zoomend', function(e) { + var newZoom = e.target.getZoom(); + if (self.zoom !== newZoom) { + self.map.removeLayer(self.marker); + } + }); } -function base64ToBytes (str) { - return base64.toByteArray(base64clean(str)) -} -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; i++) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i] +StaticLabel.prototype.toggle = function() { + if (this.selected) { + this.deselect(); + } else { + this.select(); } - return i -} - -}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) - -},{"base64-js":15,"ieee754":16,"is-array":17}],15:[function(require,module,exports){ -var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - -;(function (exports) { - 'use strict'; - - var Arr = (typeof Uint8Array !== 'undefined') - ? Uint8Array - : Array - - var PLUS = '+'.charCodeAt(0) - var SLASH = '/'.charCodeAt(0) - var NUMBER = '0'.charCodeAt(0) - var LOWER = 'a'.charCodeAt(0) - var UPPER = 'A'.charCodeAt(0) - var PLUS_URL_SAFE = '-'.charCodeAt(0) - var SLASH_URL_SAFE = '_'.charCodeAt(0) - - function decode (elt) { - var code = elt.charCodeAt(0) - if (code === PLUS || - code === PLUS_URL_SAFE) - return 62 // '+' - if (code === SLASH || - code === SLASH_URL_SAFE) - return 63 // '/' - if (code < NUMBER) - return -1 //no match - if (code < NUMBER + 10) - return code - NUMBER + 26 + 26 - if (code < UPPER + 26) - return code - UPPER - if (code < LOWER + 26) - return code - LOWER + 26 - } - - function b64ToByteArray (b64) { - var i, j, l, tmp, placeHolders, arr - - if (b64.length % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - var len = b64.length - placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0 - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(b64.length * 3 / 4 - placeHolders) - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? b64.length - 4 : b64.length - - var L = 0 - - function push (v) { - arr[L++] = v - } - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) - push((tmp & 0xFF0000) >> 16) - push((tmp & 0xFF00) >> 8) - push(tmp & 0xFF) - } - - if (placeHolders === 2) { - tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) - push(tmp & 0xFF) - } else if (placeHolders === 1) { - tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) - push((tmp >> 8) & 0xFF) - push(tmp & 0xFF) - } - - return arr - } - - function uint8ToBase64 (uint8) { - var i, - extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes - output = "", - temp, length - - function encode (num) { - return lookup.charAt(num) - } - - function tripletToBase64 (num) { - return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) - } - - // go through the array every three bytes, we'll deal with trailing stuff later - for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { - temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) - output += tripletToBase64(temp) - } - - // pad the end with zeros, but make sure to not forget the extra bytes - switch (extraBytes) { - case 1: - temp = uint8[uint8.length - 1] - output += encode(temp >> 2) - output += encode((temp << 4) & 0x3F) - output += '==' - break - case 2: - temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) - output += encode(temp >> 10) - output += encode((temp >> 4) & 0x3F) - output += encode((temp << 2) & 0x3F) - output += '=' - break - } - - return output - } - - exports.toByteArray = b64ToByteArray - exports.fromByteArray = uint8ToBase64 -}(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) - -},{}],16:[function(require,module,exports){ -arguments[4][2][0].apply(exports,arguments) -},{"dup":2}],17:[function(require,module,exports){ - -/** - * isArray - */ +}; -var isArray = Array.isArray; +StaticLabel.prototype.select = function() { + this.selected = true; + this.marker._icon.classList.add(this.style.cssSelectedClass || 'label-icon-text-selected'); + var linkedFeature = this.mvtFeature.linkedFeature(); + if (!linkedFeature.selected) linkedFeature.select(); +}; -/** - * toString - */ +StaticLabel.prototype.deselect = function() { + this.selected = false; + this.marker._icon.classList.remove(this.style.cssSelectedClass || 'label-icon-text-selected'); + var linkedFeature = this.mvtFeature.linkedFeature(); + if (linkedFeature.selected) linkedFeature.deselect(); +}; -var str = Object.prototype.toString; +StaticLabel.prototype.remove = function() { + if (!this.map || !this.marker) return; + this.map.removeLayer(this.marker); +}; +},{"../MVTUtil":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTUtil.js"}],"/Users/wil/Code/Leaflet.MapboxVectorTile/src/index.js":[function(require,module,exports){ /** - * Whether or not the given `val` - * is an array. - * - * example: + * Copyright (c) 2014, Spatial Development International + * All rights reserved. * - * isArray([]); - * // > true - * isArray(arguments); - * // > false - * isArray(''); - * // > false + * Source code can be found at: + * https://github.com/SpatialServer/Leaflet.MapboxVectorTile * - * @param {mixed} val - * @return {bool} + * @license ISC */ -module.exports = isArray || function (val) { - return !! val && '[object Array]' == str.call(val); -}; +module.exports = require('./MVTSource'); -},{}]},{},[13]) -//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../usr/local/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/pbf/index.js","node_modules/pbf/node_modules/ieee754/index.js","node_modules/point-geometry/index.js","node_modules/vector-tile/index.js","node_modules/vector-tile/lib/vectortile.js","node_modules/vector-tile/lib/vectortilefeature.js","node_modules/vector-tile/lib/vectortilelayer.js","src/MVTFeature.js","src/MVTLayer.js","src/MVTSource.js","src/MVTUtil.js","src/StaticLabel/StaticLabel.js","src/index.js","../../../../usr/local/lib/node_modules/browserify/node_modules/buffer/index.js","../../../../usr/local/lib/node_modules/browserify/node_modules/buffer/node_modules/base64-js/lib/b64.js","../../../../usr/local/lib/node_modules/browserify/node_modules/buffer/node_modules/is-array/index.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACxgDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC5HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nvar ieee754 = require('ieee754');\n\nmodule.exports = Protobuf;\nfunction Protobuf(buf) {\n    this.buf = buf;\n    this.pos = 0;\n}\n\nProtobuf.prototype = {\n    get length() { return this.buf.length; }\n};\n\nProtobuf.Varint = 0;\nProtobuf.Int64 = 1;\nProtobuf.Message = 2;\nProtobuf.String = 2;\nProtobuf.Packed = 2;\nProtobuf.Int32 = 5;\n\nProtobuf.prototype.destroy = function() {\n    this.buf = null;\n};\n\n// === READING =================================================================\n\nProtobuf.prototype.readUInt32 = function() {\n    var val = this.buf.readUInt32LE(this.pos);\n    this.pos += 4;\n    return val;\n};\n\nProtobuf.prototype.readUInt64 = function() {\n    var val = this.buf.readUInt64LE(this.pos);\n    this.pos += 8;\n    return val;\n};\n\nProtobuf.prototype.readDouble = function() {\n    var val = ieee754.read(this.buf, this.pos, true, 52, 8);\n    this.pos += 8;\n    return val;\n};\n\nProtobuf.prototype.readVarint = function() {\n    // TODO: bounds checking\n    var pos = this.pos;\n    if (this.buf[pos] <= 0x7f) {\n        this.pos++;\n        return this.buf[pos];\n    } else if (this.buf[pos + 1] <= 0x7f) {\n        this.pos += 2;\n        return (this.buf[pos] & 0x7f) | (this.buf[pos + 1] << 7);\n    } else if (this.buf[pos + 2] <= 0x7f) {\n        this.pos += 3;\n        return (this.buf[pos] & 0x7f) | (this.buf[pos + 1] & 0x7f) << 7 | (this.buf[pos + 2]) << 14;\n    } else if (this.buf[pos + 3] <= 0x7f) {\n        this.pos += 4;\n        return (this.buf[pos] & 0x7f) | (this.buf[pos + 1] & 0x7f) << 7 | (this.buf[pos + 2] & 0x7f) << 14 | (this.buf[pos + 3]) << 21;\n    } else if (this.buf[pos + 4] <= 0x7f) {\n        this.pos += 5;\n        return ((this.buf[pos] & 0x7f) | (this.buf[pos + 1] & 0x7f) << 7 | (this.buf[pos + 2] & 0x7f) << 14 | (this.buf[pos + 3]) << 21) + (this.buf[pos + 4] * 268435456);\n    } else {\n        this.skip(Protobuf.Varint);\n        return 0;\n        // throw new Error(\"TODO: Handle 6+ byte varints\");\n    }\n};\n\nProtobuf.prototype.readSVarint = function() {\n    var num = this.readVarint();\n    if (num > 2147483647) throw new Error('TODO: Handle numbers >= 2^30');\n    // zigzag encoding\n    return ((num >> 1) ^ -(num & 1));\n};\n\nProtobuf.prototype.readString = function() {\n    var bytes = this.readVarint();\n    // TODO: bounds checking\n    var chr = String.fromCharCode;\n    var b = this.buf;\n    var p = this.pos;\n    var end = this.pos + bytes;\n    var str = '';\n    while (p < end) {\n        if (b[p] <= 0x7F) str += chr(b[p++]);\n        else if (b[p] <= 0xBF) throw new Error('Invalid UTF-8 codepoint: ' + b[p]);\n        else if (b[p] <= 0xDF) str += chr((b[p++] & 0x1F) << 6 | (b[p++] & 0x3F));\n        else if (b[p] <= 0xEF) str += chr((b[p++] & 0x1F) << 12 | (b[p++] & 0x3F) << 6 | (b[p++] & 0x3F));\n        else if (b[p] <= 0xF7) p += 4; // We can't handle these codepoints in JS, so skip.\n        else if (b[p] <= 0xFB) p += 5;\n        else if (b[p] <= 0xFD) p += 6;\n        else throw new Error('Invalid UTF-8 codepoint: ' + b[p]);\n    }\n    this.pos += bytes;\n    return str;\n};\n\nProtobuf.prototype.readBuffer = function() {\n    var bytes = this.readVarint();\n    var buffer = this.buf.subarray(this.pos, this.pos + bytes);\n    this.pos += bytes;\n    return buffer;\n};\n\nProtobuf.prototype.readPacked = function(type) {\n    // TODO: bounds checking\n    var bytes = this.readVarint();\n    var end = this.pos + bytes;\n    var array = [];\n    while (this.pos < end) {\n        array.push(this['read' + type]());\n    }\n    return array;\n};\n\nProtobuf.prototype.skip = function(val) {\n    // TODO: bounds checking\n    var type = val & 0x7;\n    switch (type) {\n        /* varint */ case Protobuf.Varint: while (this.buf[this.pos++] > 0x7f); break;\n        /* 64 bit */ case Protobuf.Int64: this.pos += 8; break;\n        /* length */ case Protobuf.Message: var bytes = this.readVarint(); this.pos += bytes; break;\n        /* 32 bit */ case Protobuf.Int32: this.pos += 4; break;\n        default: throw new Error('Unimplemented type: ' + type);\n    }\n};\n\n// === WRITING =================================================================\n\nProtobuf.prototype.writeTag = function(tag, type) {\n    this.writeVarint((tag << 3) | type);\n};\n\nProtobuf.prototype.realloc = function(min) {\n    var length = this.buf.length;\n    while (length < this.pos + min) length *= 2;\n    if (length != this.buf.length) {\n        var buf = new Buffer(length);\n        this.buf.copy(buf);\n        this.buf = buf;\n    }\n};\n\nProtobuf.prototype.finish = function() {\n    return this.buf.slice(0, this.pos);\n};\n\nProtobuf.prototype.writePacked = function(type, tag, items) {\n    if (!items.length) return;\n\n    var message = new Protobuf();\n    for (var i = 0; i < items.length; i++) {\n        message['write' + type](items[i]);\n    }\n    var data = message.finish();\n\n    this.writeTag(tag, Protobuf.Packed);\n    this.writeBuffer(data);\n};\n\nProtobuf.prototype.writeUInt32 = function(val) {\n    this.realloc(4);\n    this.buf.writeUInt32LE(val, this.pos);\n    this.pos += 4;\n};\n\nProtobuf.prototype.writeTaggedUInt32 = function(tag, val) {\n    this.writeTag(tag, Protobuf.Int32);\n    this.writeUInt32(val);\n};\n\nProtobuf.prototype.writeVarint = function(val) {\n    val = Number(val);\n    if (isNaN(val)) {\n        val = 0;\n    }\n\n    if (val <= 0x7f) {\n        this.realloc(1);\n        this.buf[this.pos++] = val;\n    } else if (val <= 0x3fff) {\n        this.realloc(2);\n        this.buf[this.pos++] = 0x80 | ((val >>> 0) & 0x7f);\n        this.buf[this.pos++] = 0x00 | ((val >>> 7) & 0x7f);\n    } else if (val <= 0x1ffffff) {\n        this.realloc(3);\n        this.buf[this.pos++] = 0x80 | ((val >>> 0) & 0x7f);\n        this.buf[this.pos++] = 0x80 | ((val >>> 7) & 0x7f);\n        this.buf[this.pos++] = 0x00 | ((val >>> 14) & 0x7f);\n    } else if (val <= 0xfffffff) {\n        this.realloc(4);\n        this.buf[this.pos++] = 0x80 | ((val >>> 0) & 0x7f);\n        this.buf[this.pos++] = 0x80 | ((val >>> 7) & 0x7f);\n        this.buf[this.pos++] = 0x80 | ((val >>> 14) & 0x7f);\n        this.buf[this.pos++] = 0x00 | ((val >>> 21) & 0x7f);\n    } else {\n        while (val > 0) {\n            var b = val & 0x7f;\n            val = Math.floor(val / 128);\n            if (val > 0) b |= 0x80\n            this.realloc(1);\n            this.buf[this.pos++] = b;\n        }\n    }\n};\n\nProtobuf.prototype.writeTaggedVarint = function(tag, val) {\n    this.writeTag(tag, Protobuf.Varint);\n    this.writeVarint(val);\n};\n\nProtobuf.prototype.writeSVarint = function(val) {\n    if (val >= 0) {\n        this.writeVarint(val * 2);\n    } else {\n        this.writeVarint(val * -2 - 1);\n    }\n};\n\nProtobuf.prototype.writeTaggedSVarint = function(tag, val) {\n    this.writeTag(tag, Protobuf.Varint);\n    this.writeSVarint(val);\n};\n\nProtobuf.prototype.writeBoolean = function(val) {\n    this.writeVarint(Boolean(val));\n};\n\nProtobuf.prototype.writeTaggedBoolean = function(tag, val) {\n    this.writeTaggedVarint(tag, Boolean(val));\n};\n\nProtobuf.prototype.writeString = function(str) {\n    str = String(str);\n    var bytes = Buffer.byteLength(str);\n    this.writeVarint(bytes);\n    this.realloc(bytes);\n    this.buf.write(str, this.pos);\n    this.pos += bytes;\n};\n\nProtobuf.prototype.writeTaggedString = function(tag, str) {\n    this.writeTag(tag, Protobuf.String);\n    this.writeString(str);\n};\n\nProtobuf.prototype.writeFloat = function(val) {\n    this.realloc(4);\n    this.buf.writeFloatLE(val, this.pos);\n    this.pos += 4;\n};\n\nProtobuf.prototype.writeTaggedFloat = function(tag, val) {\n    this.writeTag(tag, Protobuf.Int32);\n    this.writeFloat(val);\n};\n\nProtobuf.prototype.writeDouble = function(val) {\n    this.realloc(8);\n    this.buf.writeDoubleLE(val, this.pos);\n    this.pos += 8;\n};\n\nProtobuf.prototype.writeTaggedDouble = function(tag, val) {\n    this.writeTag(tag, Protobuf.Int64);\n    this.writeDouble(val);\n};\n\nProtobuf.prototype.writeBuffer = function(buffer) {\n    var bytes = buffer.length;\n    this.writeVarint(bytes);\n    this.realloc(bytes);\n    buffer.copy(this.buf, this.pos);\n    this.pos += bytes;\n};\n\nProtobuf.prototype.writeTaggedBuffer = function(tag, buffer) {\n    this.writeTag(tag, Protobuf.String);\n    this.writeBuffer(buffer);\n};\n\nProtobuf.prototype.writeMessage = function(tag, protobuf) {\n    var buffer = protobuf.finish();\n    this.writeTag(tag, Protobuf.Message);\n    this.writeBuffer(buffer);\n};\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","'use strict';\n\nmodule.exports = Point;\n\nfunction Point(x, y) {\n    this.x = x;\n    this.y = y;\n}\n\nPoint.prototype = {\n    clone: function() { return new Point(this.x, this.y); },\n\n    add:     function(p) { return this.clone()._add(p);     },\n    sub:     function(p) { return this.clone()._sub(p);     },\n    mult:    function(k) { return this.clone()._mult(k);    },\n    div:     function(k) { return this.clone()._div(k);     },\n    rotate:  function(a) { return this.clone()._rotate(a);  },\n    matMult: function(m) { return this.clone()._matMult(m); },\n    unit:    function() { return this.clone()._unit(); },\n    perp:    function() { return this.clone()._perp(); },\n    round:   function() { return this.clone()._round(); },\n\n    mag: function() {\n        return Math.sqrt(this.x * this.x + this.y * this.y);\n    },\n\n    equals: function(p) {\n        return this.x === p.x &&\n               this.y === p.y;\n    },\n\n    dist: function(p) {\n        return Math.sqrt(this.distSqr(p));\n    },\n\n    distSqr: function(p) {\n        var dx = p.x - this.x,\n            dy = p.y - this.y;\n        return dx * dx + dy * dy;\n    },\n\n    angle: function() {\n        return Math.atan2(this.y, this.x);\n    },\n\n    angleTo: function(b) {\n        return Math.atan2(this.y - b.y, this.x - b.x);\n    },\n\n    angleWith: function(b) {\n        return this.angleWithSep(b.x, b.y);\n    },\n\n    // Find the angle of the two vectors, solving the formula for the cross product a x b = |a||b|sin(θ) for θ.\n    angleWithSep: function(x, y) {\n        return Math.atan2(\n            this.x * y - this.y * x,\n            this.x * x + this.y * y);\n    },\n\n    _matMult: function(m) {\n        var x = m[0] * this.x + m[1] * this.y,\n            y = m[2] * this.x + m[3] * this.y;\n        this.x = x;\n        this.y = y;\n        return this;\n    },\n\n    _add: function(p) {\n        this.x += p.x;\n        this.y += p.y;\n        return this;\n    },\n\n    _sub: function(p) {\n        this.x -= p.x;\n        this.y -= p.y;\n        return this;\n    },\n\n    _mult: function(k) {\n        this.x *= k;\n        this.y *= k;\n        return this;\n    },\n\n    _div: function(k) {\n        this.x /= k;\n        this.y /= k;\n        return this;\n    },\n\n    _unit: function() {\n        this._div(this.mag());\n        return this;\n    },\n\n    _perp: function() {\n        var y = this.y;\n        this.y = this.x;\n        this.x = -y;\n        return this;\n    },\n\n    _rotate: function(angle) {\n        var cos = Math.cos(angle),\n            sin = Math.sin(angle),\n            x = cos * this.x - sin * this.y,\n            y = sin * this.x + cos * this.y;\n        this.x = x;\n        this.y = y;\n        return this;\n    },\n\n    _round: function() {\n        this.x = Math.round(this.x);\n        this.y = Math.round(this.y);\n        return this;\n    }\n};\n\n// constructs Point from an array if necessary\nPoint.convert = function (a) {\n    if (a instanceof Point) {\n        return a;\n    }\n    if (Array.isArray(a)) {\n        return new Point(a[0], a[1]);\n    }\n    return a;\n};\n","module.exports.VectorTile = require('./lib/vectortile.js');\nmodule.exports.VectorTileFeature = require('./lib/vectortilefeature.js');\nmodule.exports.VectorTileLayer = require('./lib/vectortilelayer.js');\n","'use strict';\n\nvar VectorTileLayer = require('./vectortilelayer');\n\nmodule.exports = VectorTile;\n\nfunction VectorTile(buffer, end) {\n\n    this.layers = {};\n    this._buffer = buffer;\n\n    end = end || buffer.length;\n\n    while (buffer.pos < end) {\n        var val = buffer.readVarint(),\n            tag = val >> 3;\n\n        if (tag == 3) {\n            var layer = this.readLayer();\n            if (layer.length) this.layers[layer.name] = layer;\n        } else {\n            buffer.skip(val);\n        }\n    }\n}\n\nVectorTile.prototype.readLayer = function() {\n    var buffer = this._buffer,\n        bytes = buffer.readVarint(),\n        end = buffer.pos + bytes,\n        layer = new VectorTileLayer(buffer, end);\n\n    buffer.pos = end;\n\n    return layer;\n};\n","'use strict';\n\nvar Point = require('point-geometry');\n\nmodule.exports = VectorTileFeature;\n\nfunction VectorTileFeature(buffer, end, extent, keys, values) {\n\n    this.properties = {};\n\n    // Public\n    this.extent = extent;\n    this.type = 0;\n\n    // Private\n    this._buffer = buffer;\n    this._geometry = -1;\n\n    end = end || buffer.length;\n\n    while (buffer.pos < end) {\n        var val = buffer.readVarint(),\n            tag = val >> 3;\n\n        if (tag == 1) {\n            this._id = buffer.readVarint();\n\n        } else if (tag == 2) {\n            var tagLen = buffer.readVarint(),\n                tagEnd = buffer.pos + tagLen;\n\n            while (buffer.pos < tagEnd) {\n                var key = keys[buffer.readVarint()];\n                var value = values[buffer.readVarint()];\n                this.properties[key] = value;\n            }\n\n        } else if (tag == 3) {\n            this.type = buffer.readVarint();\n\n        } else if (tag == 4) {\n            this._geometry = buffer.pos;\n            buffer.skip(val);\n\n        } else {\n            buffer.skip(val);\n        }\n    }\n}\n\nVectorTileFeature.types = ['Unknown', 'Point', 'LineString', 'Polygon'];\n\nVectorTileFeature.prototype.loadGeometry = function() {\n    var buffer = this._buffer;\n    buffer.pos = this._geometry;\n\n    var bytes = buffer.readVarint(),\n        end = buffer.pos + bytes,\n        cmd = 1,\n        length = 0,\n        x = 0,\n        y = 0,\n        lines = [],\n        line;\n\n    while (buffer.pos < end) {\n        if (!length) {\n            var cmd_length = buffer.readVarint();\n            cmd = cmd_length & 0x7;\n            length = cmd_length >> 3;\n        }\n\n        length--;\n\n        if (cmd === 1 || cmd === 2) {\n            x += buffer.readSVarint();\n            y += buffer.readSVarint();\n\n            if (cmd === 1) {\n                // moveTo\n                if (line) {\n                    lines.push(line);\n                }\n                line = [];\n            }\n\n            line.push(new Point(x, y));\n        } else if (cmd === 7) {\n            // closePolygon\n            line.push(line[0].clone());\n        } else {\n            throw new Error('unknown command ' + cmd);\n        }\n    }\n\n    if (line) lines.push(line);\n\n    return lines;\n};\n\nVectorTileFeature.prototype.bbox = function() {\n    var buffer = this._buffer;\n    buffer.pos = this._geometry;\n\n    var bytes = buffer.readVarint(),\n        end = buffer.pos + bytes,\n\n        cmd = 1,\n        length = 0,\n        x = 0,\n        y = 0,\n        x1 = Infinity,\n        x2 = -Infinity,\n        y1 = Infinity,\n        y2 = -Infinity;\n\n    while (buffer.pos < end) {\n        if (!length) {\n            var cmd_length = buffer.readVarint();\n            cmd = cmd_length & 0x7;\n            length = cmd_length >> 3;\n        }\n\n        length--;\n\n        if (cmd === 1 || cmd === 2) {\n            x += buffer.readSVarint();\n            y += buffer.readSVarint();\n            if (x < x1) x1 = x;\n            if (x > x2) x2 = x;\n            if (y < y1) y1 = y;\n            if (y > y2) y2 = y;\n\n        } else if (cmd !== 7) {\n            throw new Error('unknown command ' + cmd);\n        }\n    }\n\n    return [x1, y1, x2, y2];\n};\n","'use strict';\n\nvar VectorTileFeature = require('./vectortilefeature.js');\n\nmodule.exports = VectorTileLayer;\nfunction VectorTileLayer(buffer, end) {\n    // Public\n    this.version = 1;\n    this.name = null;\n    this.extent = 4096;\n    this.length = 0;\n\n    // Private\n    this._buffer = buffer;\n    this._keys = [];\n    this._values = [];\n    this._features = [];\n\n    var val, tag;\n\n    end = end || buffer.length;\n\n    while (buffer.pos < end) {\n        val = buffer.readVarint();\n        tag = val >> 3;\n\n        if (tag === 15) {\n            this.version = buffer.readVarint();\n        } else if (tag === 1) {\n            this.name = buffer.readString();\n        } else if (tag === 5) {\n            this.extent = buffer.readVarint();\n        } else if (tag === 2) {\n            this.length++;\n            this._features.push(buffer.pos);\n            buffer.skip(val);\n\n        } else if (tag === 3) {\n            this._keys.push(buffer.readString());\n        } else if (tag === 4) {\n            this._values.push(this.readFeatureValue());\n        } else {\n            buffer.skip(val);\n        }\n    }\n}\n\nVectorTileLayer.prototype.readFeatureValue = function() {\n    var buffer = this._buffer,\n        value = null,\n        bytes = buffer.readVarint(),\n        end = buffer.pos + bytes,\n        val, tag;\n\n    while (buffer.pos < end) {\n        val = buffer.readVarint();\n        tag = val >> 3;\n\n        if (tag == 1) {\n            value = buffer.readString();\n        } else if (tag == 2) {\n            throw new Error('read float');\n        } else if (tag == 3) {\n            value = buffer.readDouble();\n        } else if (tag == 4) {\n            value = buffer.readVarint();\n        } else if (tag == 5) {\n            throw new Error('read uint');\n        } else if (tag == 6) {\n            value = buffer.readSVarint();\n        } else if (tag == 7) {\n            value = Boolean(buffer.readVarint());\n        } else {\n            buffer.skip(val);\n        }\n    }\n\n    return value;\n};\n\n// return feature `i` from this layer as a `VectorTileFeature`\nVectorTileLayer.prototype.feature = function(i) {\n    if (i < 0 || i >= this._features.length) throw new Error('feature index out of bounds');\n\n    this._buffer.pos = this._features[i];\n    var end = this._buffer.readVarint() + this._buffer.pos;\n\n    return new VectorTileFeature(this._buffer, end, this.extent, this._keys, this._values);\n};\n","/**\n * Created by Ryan Whitley, Daniel Duarte, and Nicholas Hallahan\n *    on 6/03/14.\n */\nvar Util = require('./MVTUtil');\nvar StaticLabel = require('./StaticLabel/StaticLabel.js');\n\nmodule.exports = MVTFeature;\n\nfunction MVTFeature(mvtLayer, vtf, ctx, id, style) {\n  if (!vtf) return null;\n\n  // Apply all of the properties of vtf to this object.\n  for (var key in vtf) {\n    this[key] = vtf[key];\n  }\n\n  this.mvtLayer = mvtLayer;\n  this.mvtSource = mvtLayer.mvtSource;\n  this.map = mvtLayer.mvtSource.map;\n\n  this.id = id;\n\n  this.layerLink = this.mvtSource.layerLink;\n  this.toggleEnabled = true;\n  this.selected = false;\n\n  // how much we divide the coordinate from the vector tile\n  this.divisor = vtf.extent / ctx.tileSize;\n  this.extent = vtf.extent;\n  this.tileSize = ctx.tileSize;\n\n  //An object to store the paths and contexts for this feature\n  this.tiles = {};\n\n  this.style = style;\n\n  //Add to the collection\n  this.addTileFeature(vtf, ctx);\n\n  var self = this;\n  this.map.on('zoomend', function() {\n    self.staticLabel = null;\n  });\n\n  if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') {\n    this.dynamicLabel = this.mvtSource.dynamicLabel.createFeature(this);\n  }\n\n  ajax(self);\n}\n\n\nfunction ajax(self) {\n  var style = self.style;\n  if (style && style.ajaxSource && typeof style.ajaxSource === 'function') {\n    var ajaxEndpoint = style.ajaxSource(self);\n    if (ajaxEndpoint) {\n      Util.getJSON(ajaxEndpoint, function(error, response, body) {\n        if (error) {\n          throw ['ajaxSource AJAX Error', error];\n        } else {\n          ajaxCallback(self, response);\n          return true;\n        }\n      });\n    }\n  }\n  return false;\n}\n\nfunction ajaxCallback(self, response) {\n  self.ajaxData = response;\n\n  /**\n   * You can attach a callback function to a feature in your app\n   * that will get called whenever new ajaxData comes in. This\n   * can be used to update UI that looks at data from within a feature.\n   *\n   * setStyle may possibly have a style with a different ajaxData source,\n   * and you would potentially get new contextual data for your feature.\n   *\n   * TODO: This needs to be documented.\n   */\n  if (typeof self.ajaxDataReceived === 'function') {\n    self.ajaxDataReceived(self, response);\n  }\n\n  self._setStyle(self.mvtLayer.style);\n  redrawTiles(self);\n}\n\nMVTFeature.prototype._setStyle = function(styleFn) {\n  this.style = styleFn(this, this.ajaxData);\n\n  // The label gets removed, and the (re)draw,\n  // that is initiated by the MVTLayer creates a new label.\n  this.removeLabel();\n};\n\nMVTFeature.prototype.setStyle = function(styleFn) {\n  this.ajaxData = null;\n  this.style = styleFn(this, null);\n  var hasAjaxSource = ajax(this);\n  if (!hasAjaxSource) {\n    // The label gets removed, and the (re)draw,\n    // that is initiated by the MVTLayer creates a new label.\n    this.removeLabel();\n  }\n};\n\nMVTFeature.prototype.draw = function(canvasID) {\n  //Get the info from the tiles list\n  var tileInfo =  this.tiles[canvasID];\n\n  var vtf = tileInfo.vtf;\n  var ctx = tileInfo.ctx;\n\n  //Get the actual canvas from the parent layer's _tiles object.\n  var xy = canvasID.split(\":\").slice(1, 3).join(\":\");\n  ctx.canvas = this.mvtLayer._tiles[xy];\n\n//  This could be used to directly compute the style function from the layer on every draw.\n//  This is much less efficient...\n//  this.style = this.mvtLayer.style(this);\n\n  if (this.selected) {\n    var style = this.style.selected || this.style;\n  } else {\n    var style = this.style;\n  }\n\n  switch (vtf.type) {\n    case 1: //Point\n      this._drawPoint(ctx, vtf.coordinates, style);\n      if (!this.staticLabel && typeof this.style.staticLabel === 'function') {\n        if (this.style.ajaxSource && !this.ajaxData) {\n          break;\n        }\n        this._drawStaticLabel(ctx, vtf.coordinates, style);\n      }\n      break;\n\n    case 2: //LineString\n      this._drawLineString(ctx, vtf.coordinates, style);\n      break;\n\n    case 3: //Polygon\n      this._drawPolygon(ctx, vtf.coordinates, style);\n      break;\n\n    default:\n      throw new Error('Unmanaged type: ' + vtf.type);\n  }\n\n};\n\nMVTFeature.prototype.getPathsForTile = function(canvasID) {\n  //Get the info from the parts list\n  return this.tiles[canvasID].paths;\n};\n\nMVTFeature.prototype.addTileFeature = function(vtf, ctx) {\n  //Store the important items in the tiles list\n\n  //We only want to store info for tiles for the current map zoom.  If it is tile info for another zoom level, ignore it\n  //Also, if there are existing tiles in the list for other zoom levels, expunge them.\n  var zoom = this.map.getZoom();\n\n  if(ctx.zoom != zoom) return;\n\n  this.clearTileFeatures(zoom); //TODO: This iterates thru all tiles every time a new tile is added.  Figure out a better way to do this.\n\n  this.tiles[ctx.id] = {\n    ctx: ctx,\n    vtf: vtf,\n    paths: []\n  };\n\n};\n\n\n/**\n * Clear the inner list of tile features if they don't match the given zoom.\n *\n * @param zoom\n */\nMVTFeature.prototype.clearTileFeatures = function(zoom) {\n  //If stored tiles exist for other zoom levels, expunge them from the list.\n  for (var key in this.tiles) {\n     if(key.split(\":\")[0] != zoom) delete this.tiles[key];\n  }\n};\n\n/**\n * Redraws all of the tiles associated with a feature. Useful for\n * style change and toggling.\n *\n * @param self\n */\nfunction redrawTiles(self) {\n  //Redraw the whole tile, not just this vtf\n  var tiles = self.tiles;\n  var mvtLayer = self.mvtLayer;\n\n  for (var id in tiles) {\n    var tileZoom = parseInt(id.split(':')[0]);\n    var mapZoom = self.map.getZoom();\n    if (tileZoom === mapZoom) {\n      //Redraw the tile\n      mvtLayer.redrawTile(id);\n    }\n  }\n}\n\nMVTFeature.prototype.toggle = function() {\n  if (this.selected) {\n    this.deselect();\n  } else {\n    this.select();\n  }\n};\n\nMVTFeature.prototype.select = function() {\n  this.selected = true;\n  this.mvtSource.featureSelected(this);\n  redrawTiles(this);\n  var linkedFeature = this.linkedFeature();\n  if (linkedFeature && linkedFeature.staticLabel && !linkedFeature.staticLabel.selected) {\n    linkedFeature.staticLabel.select();\n  }\n};\n\nMVTFeature.prototype.deselect = function() {\n  this.selected = false;\n  this.mvtSource.featureDeselected(this);\n  redrawTiles(this);\n  var linkedFeature = this.linkedFeature();\n  if (linkedFeature && linkedFeature.staticLabel && linkedFeature.staticLabel.selected) {\n    linkedFeature.staticLabel.deselect();\n  }\n};\n\nMVTFeature.prototype.on = function(eventType, callback) {\n  this._eventHandlers[eventType] = callback;\n};\n\nMVTFeature.prototype._drawPoint = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx || !ctx.canvas) return;\n\n  var tile = this.tiles[ctx.id];\n\n  //Get radius\n  var radius = 1;\n  if (typeof style.radius === 'function') {\n    radius = style.radius(ctx.zoom); //Allows for scale dependent rednering\n  }\n  else{\n    radius = style.radius;\n  }\n\n  var p = this._tilePoint(coordsArray[0][0]);\n  var c = ctx.canvas;\n  var ctx2d;\n  try{\n    ctx2d = c.getContext('2d');\n  }\n  catch(e){\n    console.log(\"_drawPoint error: \" + e);\n    return;\n  }\n\n  ctx2d.beginPath();\n  ctx2d.fillStyle = style.color;\n  ctx2d.arc(p.x, p.y, radius, 0, Math.PI * 2);\n  ctx2d.closePath();\n  ctx2d.fill();\n\n  if(style.lineWidth && style.strokeStyle){\n    ctx2d.lineWidth = style.lineWidth;\n    ctx2d.strokeStyle = style.strokeStyle;\n    ctx2d.stroke();\n  }\n\n  ctx2d.restore();\n  tile.paths.push([p]);\n};\n\nMVTFeature.prototype._drawLineString = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx || !ctx.canvas) return;\n\n  var ctx2d = ctx.canvas.getContext('2d');\n  ctx2d.strokeStyle = style.color;\n  ctx2d.lineWidth = style.size;\n  ctx2d.beginPath();\n\n  var projCoords = [];\n  var tile = this.tiles[ctx.id];\n\n  for (var gidx in coordsArray) {\n    var coords = coordsArray[gidx];\n\n    for (i = 0; i < coords.length; i++) {\n      var method = (i === 0 ? 'move' : 'line') + 'To';\n      var proj = this._tilePoint(coords[i]);\n      projCoords.push(proj);\n      ctx2d[method](proj.x, proj.y);\n    }\n  }\n\n  ctx2d.stroke();\n  ctx2d.restore();\n\n  tile.paths.push(projCoords);\n};\n\nMVTFeature.prototype._drawPolygon = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx || !ctx.canvas) return;\n\n  var ctx2d = ctx.canvas.getContext('2d');\n  var outline = style.outline;\n\n  // color may be defined via function to make choropleth work right\n  if (typeof style.color === 'function') {\n    ctx2d.fillStyle = style.color(ctx2d);\n  } else {\n    ctx2d.fillStyle = style.color;\n  }\n\n  if (outline) {\n    ctx2d.strokeStyle = outline.color;\n    ctx2d.lineWidth = outline.size;\n  }\n  ctx2d.beginPath();\n\n  var projCoords = [];\n  var tile = this.tiles[ctx.id];\n\n  var featureLabel = this.dynamicLabel;\n  if (featureLabel) {\n    featureLabel.addTilePolys(ctx, coordsArray);\n  }\n\n  for (var gidx = 0, len = coordsArray.length; gidx < len; gidx++) {\n    var coords = coordsArray[gidx];\n\n    for (var i = 0; i < coords.length; i++) {\n      var coord = coords[i];\n      var method = (i === 0 ? 'move' : 'line') + 'To';\n      var proj = this._tilePoint(coords[i]);\n      projCoords.push(proj);\n      ctx2d[method](proj.x, proj.y);\n    }\n  }\n\n  ctx2d.closePath();\n  ctx2d.fill();\n  if (outline) {\n    ctx2d.stroke();\n  }\n\n  tile.paths.push(projCoords);\n\n};\n\nMVTFeature.prototype._drawStaticLabel = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx) return;\n\n  // If the corresponding layer is not on the map, \n  // we dont want to put on a label.\n  if (!this.mvtLayer._map) return;\n\n  var vecPt = this._tilePoint(coordsArray[0][0]);\n\n  // We're making a standard Leaflet Marker for this label.\n  var p = this._project(vecPt, ctx.tile.x, ctx.tile.y, this.extent, this.tileSize); //vectile pt to merc pt\n  var mercPt = L.point(p.x, p.y); // make into leaflet obj\n  var latLng = this.map.unproject(mercPt); // merc pt to latlng\n\n  this.staticLabel = new StaticLabel(this, ctx, latLng, style);\n  this.mvtLayer.featureWithLabelAdded(this);\n};\n\nMVTFeature.prototype.removeLabel = function() {\n  if (!this.staticLabel) return;\n  this.staticLabel.remove();\n  this.staticLabel = null;\n};\n\n/**\n * Projects a vector tile point to the Spherical Mercator pixel space for a given zoom level.\n *\n * @param vecPt\n * @param tileX\n * @param tileY\n * @param extent\n * @param tileSize\n */\nMVTFeature.prototype._project = function(vecPt, tileX, tileY, extent, tileSize) {\n  var xOffset = tileX * tileSize;\n  var yOffset = tileY * tileSize;\n  return {\n    x: Math.floor(vecPt.x + xOffset),\n    y: Math.floor(vecPt.y + yOffset)\n  };\n};\n\n/**\n * Takes a coordinate from a vector tile and turns it into a Leaflet Point.\n *\n * @param ctx\n * @param coords\n * @returns {eGeomType.Point}\n * @private\n */\nMVTFeature.prototype._tilePoint = function(coords) {\n  return new L.Point(coords.x / this.divisor, coords.y / this.divisor);\n};\n\nMVTFeature.prototype.linkedFeature = function() {\n  var linkedLayer = this.mvtLayer.linkedLayer();\n  if(linkedLayer){\n    var linkedFeature = linkedLayer.features[this.id];\n    return linkedFeature;\n  }else{\n    return null;\n  }\n};\n\n","/**\n * Created by Ryan Whitley on 5/17/14.\n */\n/** Forked from https://gist.github.com/DGuidi/1716010 **/\nvar MVTFeature = require('./MVTFeature');\nvar Util = require('./MVTUtil');\n\nmodule.exports = L.TileLayer.Canvas.extend({\n\n  options: {\n    debug: false,\n    isHiddenLayer: false,\n    getIDForLayerFeature: function() {},\n    tileSize: 256,\n    lineClickTolerance: 2\n  },\n\n  _featureIsClicked: {},\n\n  _isPointInPoly: function(pt, poly) {\n    if(poly && poly.length) {\n      for (var c = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i)\n        ((poly[i].y <= pt.y && pt.y < poly[j].y) || (poly[j].y <= pt.y && pt.y < poly[i].y))\n        && (pt.x < (poly[j].x - poly[i].x) * (pt.y - poly[i].y) / (poly[j].y - poly[i].y) + poly[i].x)\n        && (c = !c);\n      return c;\n    }\n  },\n\n  _getDistanceFromLine: function(pt, pts) {\n    var min = Number.POSITIVE_INFINITY;\n    if (pts && pts.length > 1) {\n      pt = L.point(pt.x, pt.y);\n      for (var i = 0, l = pts.length - 1; i < l; i++) {\n        var test = this._projectPointOnLineSegment(pt, pts[i], pts[i + 1]);\n        if (test.distance <= min) {\n          min = test.distance;\n        }\n      }\n    }\n    return min;\n  },\n\n  _projectPointOnLineSegment: function(p, r0, r1) {\n    var lineLength = r0.distanceTo(r1);\n    if (lineLength < 1) {\n        return {distance: p.distanceTo(r0), coordinate: r0};\n    }\n    var u = ((p.x - r0.x) * (r1.x - r0.x) + (p.y - r0.y) * (r1.y - r0.y)) / Math.pow(lineLength, 2);\n    if (u < 0.0000001) {\n        return {distance: p.distanceTo(r0), coordinate: r0};\n    }\n    if (u > 0.9999999) {\n        return {distance: p.distanceTo(r1), coordinate: r1};\n    }\n    var a = L.point(r0.x + u * (r1.x - r0.x), r0.y + u * (r1.y - r0.y));\n    return {distance: p.distanceTo(a), point: a};\n  },\n\n  initialize: function(mvtSource, options) {\n    var self = this;\n    self.mvtSource = mvtSource;\n    L.Util.setOptions(this, options);\n\n    this.style = options.style;\n    this.name = options.name;\n    this._canvasIDToFeatures = {};\n    this.features = {};\n    this.featuresWithLabels = [];\n    this._highestCount = 0;\n  },\n\n  onAdd: function(map) {\n    var self = this;\n    self.map = map;\n    L.TileLayer.Canvas.prototype.onAdd.call(this, map);\n    map.on('layerremove', function(e) {\n      // we only want to do stuff when the layerremove event is on this layer\n      if (e.layer._leaflet_id === self._leaflet_id) {\n        removeLabels(self);\n      }\n    });\n  },\n\n  drawTile: function(canvas, tilePoint, zoom) {\n\n    var ctx = {\n      canvas: canvas,\n      tile: tilePoint,\n      zoom: zoom,\n      tileSize: this.options.tileSize\n    };\n\n    ctx.id = Util.getContextID(ctx);\n\n    if (!this._canvasIDToFeatures[ctx.id]) {\n      this._initializeFeaturesHash(ctx);\n    }\n    if (!this.features) {\n      this.features = {};\n    }\n\n  },\n\n  _initializeFeaturesHash: function(ctx){\n    this._canvasIDToFeatures[ctx.id] = {};\n    this._canvasIDToFeatures[ctx.id].features = [];\n    this._canvasIDToFeatures[ctx.id].canvas = ctx.canvas;\n  },\n\n  _draw: function(ctx) {\n    //Draw is handled by the parent MVTSource object\n  },\n  getCanvas: function(parentCtx){\n    //This gets called if a vector tile feature has already been parsed.\n    //We've already got the geom, just get on with the drawing.\n    //Need a way to pluck a canvas element from this layer given the parent layer's id.\n    //Wait for it to get loaded before proceeding.\n    var tilePoint = parentCtx.tile;\n    var ctx = this._tiles[tilePoint.x + \":\" + tilePoint.y];\n\n    if(ctx){\n      parentCtx.canvas = ctx;\n      this.redrawTile(parentCtx.id);\n      return;\n    }\n\n    var self = this;\n\n    //This is a timer that will wait for a criterion to return true.\n    //If not true within the timeout duration, it will move on.\n    waitFor(function () {\n        ctx = self._tiles[tilePoint.x + \":\" + tilePoint.y];\n        if(ctx) {\n          return true;\n        }\n      },\n      function(){\n        //When it finishes, do this.\n        ctx = self._tiles[tilePoint.x + \":\" + tilePoint.y];\n        parentCtx.canvas = ctx;\n        self.redrawTile(parentCtx.id);\n\n      }, //when done, go to next flow\n      2000); //The Timeout milliseconds.  After this, give up and move on\n\n  },\n\n  parseVectorTileLayer: function(vtl, ctx) {\n    var self = this;\n    var tilePoint = ctx.tile;\n    var layerCtx  = { canvas: null, id: ctx.id, tile: ctx.tile, zoom: ctx.zoom, tileSize: ctx.tileSize};\n\n    //See if we can pluck the child tile from this PBF tile layer based on the master layer's tile id.\n    layerCtx.canvas = self._tiles[tilePoint.x + \":\" + tilePoint.y];\n\n\n\n    //Initialize this tile's feature storage hash, if it hasn't already been created.  Used for when filters are updated, and features are cleared to prepare for a fresh redraw.\n    if (!this._canvasIDToFeatures[layerCtx.id]) {\n      this._initializeFeaturesHash(layerCtx);\n    }else{\n      //Clear this tile's previously saved features.\n      this.clearTileFeatureHash(layerCtx.id);\n    }\n\n    var features = vtl.parsedFeatures;\n    for (var i = 0, len = features.length; i < len; i++) {\n      var vtf = features[i]; //vector tile feature\n      vtf.layer = vtl;\n\n      /**\n       * Apply filter on feature if there is one. Defined in the options object\n       * of TileLayer.MVTSource.js\n       */\n      var filter = self.options.filter;\n      if (typeof filter === 'function') {\n        if ( filter(vtf, layerCtx) === false ) continue;\n      }\n\n      var getIDForLayerFeature;\n      if (typeof self.options.getIDForLayerFeature === 'function') {\n        getIDForLayerFeature = self.options.getIDForLayerFeature;\n      } else {\n        getIDForLayerFeature = Util.getIDForLayerFeature;\n      }\n      var uniqueID = self.options.getIDForLayerFeature(vtf) || i;\n      var mvtFeature = self.features[uniqueID];\n\n      /**\n       * Use layerOrdering function to apply a zIndex property to each vtf.  This is defined in\n       * TileLayer.MVTSource.js.  Used below to sort features.npm\n       */\n      var layerOrdering = self.options.layerOrdering;\n      if (typeof layerOrdering === 'function') {\n        layerOrdering(vtf, layerCtx); //Applies a custom property to the feature, which is used after we're thru iterating to sort\n      }\n\n      //Create a new MVTFeature if one doesn't already exist for this feature.\n      if (!mvtFeature) {\n        //Get a style for the feature - set it just once for each new MVTFeature\n        var style = self.style(vtf);\n\n        //create a new feature\n        self.features[uniqueID] = mvtFeature = new MVTFeature(self, vtf, layerCtx, uniqueID, style);\n        if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') {\n          self.featuresWithLabels.push(mvtFeature);\n        }\n      } else {\n        //Add the new part to the existing feature\n        mvtFeature.addTileFeature(vtf, layerCtx);\n      }\n\n      //Associate & Save this feature with this tile for later\n      if(layerCtx && layerCtx.id) self._canvasIDToFeatures[layerCtx.id]['features'].push(mvtFeature);\n\n    }\n\n    /**\n     * Apply sorting (zIndex) on feature if there is a function defined in the options object\n     * of TileLayer.MVTSource.js\n     */\n    var layerOrdering = self.options.layerOrdering;\n    if (layerOrdering) {\n      //We've assigned the custom zIndex property when iterating above.  Now just sort.\n      self._canvasIDToFeatures[layerCtx.id].features = self._canvasIDToFeatures[layerCtx.id].features.sort(function(a, b) {\n        return -(b.properties.zIndex - a.properties.zIndex)\n      });\n    }\n\n    self.redrawTile(layerCtx.id);\n  },\n\n  setStyle: function(styleFn) {\n    // refresh the number for the highest count value\n    // this is used only for choropleth\n    this._highestCount = 0;\n\n    // lowest count should not be 0, since we want to figure out the lowest\n    this._lowestCount = null;\n\n    this.style = styleFn;\n    for (var key in this.features) {\n      var feat = this.features[key];\n      feat.setStyle(styleFn);\n    }\n    var z = this.map.getZoom();\n    for (var key in this._tiles) {\n      var id = z + ':' + key;\n      this.redrawTile(id);\n    }\n  },\n\n  /**\n   * As counts for choropleths come in with the ajax data,\n   * we want to keep track of which value is the highest\n   * to create the color ramp for the fills of polygons.\n   * @param count\n   */\n  setHighestCount: function(count) {\n    if (count > this._highestCount) {\n      this._highestCount = count;\n    }\n  },\n\n  /**\n   * Returns the highest number of all of the counts that have come in\n   * from setHighestCount. This is assumed to be set via ajax callbacks.\n   * @returns {number}\n   */\n  getHighestCount: function() {\n    return this._highestCount;\n  },\n\n  setLowestCount: function(count) {\n    if (!this._lowestCount || count < this._lowestCount) {\n      this._lowestCount = count;\n    }\n  },\n\n  getLowestCount: function() {\n    return this._lowestCount;\n  },\n\n  setCountRange: function(count) {\n    this.setHighestCount(count);\n    this.setLowestCount(count);\n  },\n\n  //This is the old way.  It works, but is slow for mouseover events.  Fine for click events.\n  handleClickEvent: function(evt, cb) {\n    //Click happened on the GroupLayer (Manager) and passed it here\n    var tileID = evt.tileID.split(\":\").slice(1, 3).join(\":\");\n    var zoom = evt.tileID.split(\":\")[0];\n    var canvas = this._tiles[tileID];\n    if(!canvas) (cb(evt)); //break out\n    var x = evt.layerPoint.x - canvas._leaflet_pos.x;\n    var y = evt.layerPoint.y - canvas._leaflet_pos.y;\n\n    var tilePoint = {x: x, y: y};\n    var features = this._canvasIDToFeatures[evt.tileID].features;\n\n    var minDistance = Number.POSITIVE_INFINITY;\n    var nearest = null;\n    var j, paths, distance;\n\n    for (var i = 0; i < features.length; i++) {\n      var feature = features[i];\n      switch (feature.type) {\n\n        case 1: //Point - currently rendered as circular paths.  Intersect with that.\n\n          //Find the radius of the point.\n          var radius = 3;\n          if (typeof feature.style.radius === 'function') {\n            radius = feature.style.radius(zoom); //Allows for scale dependent rednering\n          }\n          else{\n            radius = feature.style.radius;\n          }\n\n          paths = feature.getPathsForTile(evt.tileID);\n          for (j = 0; j < paths.length; j++) {\n            //Builds a circle of radius feature.style.radius (assuming circular point symbology).\n            if(in_circle(paths[j][0].x, paths[j][0].y, radius, x, y)){\n              nearest = feature;\n              minDistance = 0;\n            }\n          }\n          break;\n\n        case 2: //LineString\n          paths = feature.getPathsForTile(evt.tileID);\n          for (j = 0; j < paths.length; j++) {\n            if (feature.style) {\n              var distance = this._getDistanceFromLine(tilePoint, paths[j]);\n              var thickness = (feature.selected && feature.style.selected ? feature.style.selected.size : feature.style.size);\n              if (distance < thickness / 2 + this.options.lineClickTolerance && distance < minDistance) {\n                nearest = feature;\n                minDistance = distance;\n              }\n            }\n          }\n          break;\n\n        case 3: //Polygon\n          paths = feature.getPathsForTile(evt.tileID);\n          for (j = 0; j < paths.length; j++) {\n            if (this._isPointInPoly(tilePoint, paths[j])) {\n              nearest = feature;\n              minDistance = 0; // point is inside the polygon, so distance is zero\n            }\n          }\n          break;\n      }\n      if (minDistance == 0) break;\n    }\n\n    if (nearest && nearest.toggleEnabled) {\n        nearest.toggle();\n    }\n    evt.feature = nearest;\n    cb(evt);\n  },\n\n  clearTile: function(id) {\n    //id is the entire zoom:x:y.  we just want x:y.\n    var ca = id.split(\":\");\n    var canvasId = ca[1] + \":\" + ca[2];\n    if (typeof this._tiles[canvasId] === 'undefined') {\n      console.error(\"typeof this._tiles[canvasId] === 'undefined'\");\n      return;\n    }\n    var canvas = this._tiles[canvasId];\n\n    var context = canvas.getContext('2d');\n    context.clearRect(0, 0, canvas.width, canvas.height);\n  },\n\n  clearTileFeatureHash: function(canvasID){\n    this._canvasIDToFeatures[canvasID] = { features: []}; //Get rid of all saved features\n  },\n\n  clearLayerFeatureHash: function(){\n    this.features = {};\n  },\n\n  redrawTile: function(canvasID) {\n    //First, clear the canvas\n    this.clearTile(canvasID);\n\n    // If the features are not in the tile, then there is nothing to redraw.\n    // This may happen if you call redraw before features have loaded and initially\n    // drawn the tile.\n    var featfeats = this._canvasIDToFeatures[canvasID];\n    if (!featfeats) {\n      return;\n    }\n\n    //Get the features for this tile, and redraw them.\n    var features = featfeats.features;\n\n    // we want to skip drawing the selected features and draw them last\n    var selectedFeatures = [];\n\n    // drawing all of the non-selected features\n    for (var i = 0; i < features.length; i++) {\n      var feature = features[i];\n      if (feature.selected) {\n        selectedFeatures.push(feature);\n      } else {\n        feature.draw(canvasID);\n      }\n    }\n\n    // drawing the selected features last\n    for (var j = 0, len2 = selectedFeatures.length; j < len2; j++) {\n      var selFeat = selectedFeatures[j];\n      selFeat.draw(canvasID);\n    }\n  },\n\n  _resetCanvasIDToFeatures: function(canvasID, canvas) {\n\n    this._canvasIDToFeatures[canvasID] = {};\n    this._canvasIDToFeatures[canvasID].features = [];\n    this._canvasIDToFeatures[canvasID].canvas = canvas;\n\n  },\n\n  linkedLayer: function() {\n    if(this.mvtSource.layerLink) {\n      var linkName = this.mvtSource.layerLink(this.name);\n      return this.mvtSource.layers[linkName];\n    }\n    else{\n      return null;\n    }\n  },\n\n  featureWithLabelAdded: function(feature) {\n    this.featuresWithLabels.push(feature);\n  }\n\n});\n\n\nfunction removeLabels(self) {\n  var features = self.featuresWithLabels;\n  for (var i = 0, len = features.length; i < len; i++) {\n    var feat = features[i];\n    feat.removeLabel();\n  }\n  self.featuresWithLabels = [];\n}\n\nfunction in_circle(center_x, center_y, radius, x, y) {\n  var square_dist = Math.pow((center_x - x), 2) + Math.pow((center_y - y), 2);\n  return square_dist <= Math.pow(radius, 2);\n}\n/**\n * See https://github.com/ariya/phantomjs/blob/master/examples/waitfor.js\n *\n * Wait until the test condition is true or a timeout occurs. Useful for waiting\n * on a server response or for a ui change (fadeIn, etc.) to occur.\n *\n * @param testFx javascript condition that evaluates to a boolean,\n * it can be passed in as a string (e.g.: \"1 == 1\" or \"$('#bar').is(':visible')\" or\n * as a callback function.\n * @param onReady what to do when testFx condition is fulfilled,\n * it can be passed in as a string (e.g.: \"1 == 1\" or \"$('#bar').is(':visible')\" or\n * as a callback function.\n * @param timeOutMillis the max amount of time to wait. If not specified, 3 sec is used.\n */\nfunction waitFor(testFx, onReady, timeOutMillis) {\n  var maxtimeOutMillis = timeOutMillis ? timeOutMillis : 3000, //< Default Max Timout is 3s\n    start = new Date().getTime(),\n    condition = (typeof (testFx) === \"string\" ? eval(testFx) : testFx()), //< defensive code\n    interval = setInterval(function () {\n      if ((new Date().getTime() - start < maxtimeOutMillis) && !condition) {\n        // If not time-out yet and condition not yet fulfilled\n        condition = (typeof (testFx) === \"string\" ? eval(testFx) : testFx()); //< defensive code\n      } else {\n        if (!condition) {\n          // If condition still not fulfilled (timeout but condition is 'false')\n          console.log(\"'waitFor()' timeout\");\n          clearInterval(interval); //< Stop this interval\n          typeof (onReady) === \"string\" ? eval(onReady) : onReady('timeout'); //< Do what it's supposed to do once the condition is fulfilled\n        } else {\n          // Condition fulfilled (timeout and/or condition is 'true')\n          console.log(\"'waitFor()' finished in \" + (new Date().getTime() - start) + \"ms.\");\n          clearInterval(interval); //< Stop this interval\n          typeof (onReady) === \"string\" ? eval(onReady) : onReady('success'); //< Do what it's supposed to do once the condition is fulfilled\n        }\n      }\n    }, 50); //< repeat check every 50ms\n};","var VectorTile = require('vector-tile').VectorTile;\nvar Protobuf = require('pbf');\nvar Point = require('point-geometry');\nvar Util = require('./MVTUtil');\nvar MVTLayer = require('./MVTLayer');\n\n\nmodule.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({\n\n  options: {\n    debug: false,\n    url: \"\", //URL TO Vector Tile Source,\n    getIDForLayerFeature: function() {},\n    tileSize: 256,\n    visibleLayers: [],\n    xhrHeaders: {}\n  },\n  layers: {}, //Keep a list of the layers contained in the PBFs\n  processedTiles: {}, //Keep a list of tiles that have been processed already\n  _eventHandlers: {},\n  _triggerOnTilesLoadedEvent: true, //whether or not to fire the onTilesLoaded event when all of the tiles finish loading.\n  _url: \"\", //internal URL property\n\n  style: function(feature) {\n    var style = {};\n\n    var type = feature.type;\n    switch (type) {\n      case 1: //'Point'\n        style.color = 'rgba(49,79,79,1)';\n        style.radius = 5;\n        style.selected = {\n          color: 'rgba(255,255,0,0.5)',\n          radius: 6\n        };\n        break;\n      case 2: //'LineString'\n        style.color = 'rgba(161,217,155,0.8)';\n        style.size = 3;\n        style.selected = {\n          color: 'rgba(255,25,0,0.5)',\n          size: 4\n        };\n        break;\n      case 3: //'Polygon'\n        style.color = 'rgba(49,79,79,1)';\n        style.outline = {\n          color: 'rgba(161,217,155,0.8)',\n          size: 1\n        };\n        style.selected = {\n          color: 'rgba(255,140,0,0.3)',\n          outline: {\n            color: 'rgba(255,140,0,1)',\n            size: 2\n          }\n        };\n        break;\n    }\n    return style;\n  },\n\n\n  initialize: function(options) {\n    L.Util.setOptions(this, options);\n\n    //a list of the layers contained in the PBFs\n    this.layers = {};\n\n    // tiles currently in the viewport\n    this.activeTiles = {};\n\n    // thats that have been loaded and drawn\n    this.loadedTiles = {};\n\n    this._url = this.options.url;\n\n    /**\n     * For some reason, Leaflet has some code that resets the\n     * z index in the options object. I'm having trouble tracking\n     * down exactly what does this and why, so for now, we should\n     * just copy the value to this.zIndex so we can have the right\n     * number when we make the subsequent MVTLayers.\n     */\n    this.zIndex = options.zIndex;\n\n    if (typeof options.style === 'function') {\n      this.style = options.style;\n    }\n\n    if (typeof options.ajaxSource === 'function') {\n      this.ajaxSource = options.ajaxSource;\n    }\n\n    this.layerLink = options.layerLink;\n\n    this._eventHandlers = {};\n\n    this._tilesToProcess = 0; //store the max number of tiles to be loaded.  Later, we can use this count to count down PBF loading.\n  },\n\n  redraw: function(triggerOnTilesLoadedEvent){\n    //Only set to false if it actually is passed in as 'false'\n    if (triggerOnTilesLoadedEvent === false) {\n      this._triggerOnTilesLoadedEvent = false;\n    }\n\n    L.TileLayer.Canvas.prototype.redraw.call(this);\n  },\n\n  onAdd: function(map) {\n    var self = this;\n    self.map = map;\n    L.TileLayer.Canvas.prototype.onAdd.call(this, map);\n\n    var mapOnClickCallback = function(e) {\n      self._onClick(e);\n    };\n\n    map.on('click', mapOnClickCallback);\n\n    map.on(\"layerremove\", function(e) {\n      // check to see if the layer removed is this one\n      // call a method to remove the child layers (the ones that actually have something drawn on them).\n      if (e.layer._leaflet_id === self._leaflet_id && e.layer.removeChildLayers) {\n        e.layer.removeChildLayers(map);\n        map.off('click', mapOnClickCallback);\n      }\n    });\n\n    self.addChildLayers(map);\n\n    if (typeof DynamicLabel === 'function' ) {\n      this.dynamicLabel = new DynamicLabel(map, this, {});\n    }\n\n  },\n\n  drawTile: function(canvas, tilePoint, zoom) {\n    var ctx = {\n      id: [zoom, tilePoint.x, tilePoint.y].join(\":\"),\n      canvas: canvas,\n      tile: tilePoint,\n      zoom: zoom,\n      tileSize: this.options.tileSize\n    };\n\n    //Capture the max number of the tiles to load here. this._tilesToProcess is an internal number we use to know when we've finished requesting PBFs.\n    if(this._tilesToProcess < this._tilesToLoad) this._tilesToProcess = this._tilesToLoad;\n\n    var id = ctx.id = Util.getContextID(ctx);\n    this.activeTiles[id] = ctx;\n\n    if(!this.processedTiles[ctx.zoom]) this.processedTiles[ctx.zoom] = {};\n\n    if (this.options.debug) {\n      this._drawDebugInfo(ctx);\n    }\n    this._draw(ctx);\n  },\n\n  setOpacity:function(opacity) {\n    this._setVisibleLayersStyle('opacity',opacity);\n  },\n\n  setZIndex:function(zIndex) {\n    this._setVisibleLayersStyle('zIndex',zIndex);\n  },\n\n  _setVisibleLayersStyle:function(style, value) {\n    for(var key in this.layers) {\n      this.layers[key]._tileContainer.style[style] = value;\n    }\n  },\n\n  _drawDebugInfo: function(ctx) {\n    var max = this.options.tileSize;\n    var g = ctx.canvas.getContext('2d');\n    g.strokeStyle = '#000000';\n    g.fillStyle = '#FFFF00';\n    g.strokeRect(0, 0, max, max);\n    g.font = \"12px Arial\";\n    g.fillRect(0, 0, 5, 5);\n    g.fillRect(0, max - 5, 5, 5);\n    g.fillRect(max - 5, 0, 5, 5);\n    g.fillRect(max - 5, max - 5, 5, 5);\n    g.fillRect(max / 2 - 5, max / 2 - 5, 10, 10);\n    g.strokeText(ctx.zoom + ' ' + ctx.tile.x + ' ' + ctx.tile.y, max / 2 - 30, max / 2 - 10);\n  },\n\n  _draw: function(ctx) {\n    var self = this;\n\n//    //This works to skip fetching and processing tiles if they've already been processed.\n//    var vectorTile = this.processedTiles[ctx.zoom][ctx.id];\n//    //if we've already parsed it, don't get it again.\n//    if(vectorTile){\n//      console.log(\"Skipping fetching \" + ctx.id);\n//      self.checkVectorTileLayers(parseVT(vectorTile), ctx, true);\n//      self.reduceTilesToProcessCount();\n//      return;\n//    }\n\n    if (!this._url) return;\n    var src = this.getTileUrl({ x: ctx.tile.x, y: ctx.tile.y, z: ctx.zoom });\n\n    var xhr = new XMLHttpRequest();\n    xhr.onload = function() {\n      if (xhr.status == \"200\") {\n\n        if(!xhr.response) return;\n\n        var arrayBuffer = new Uint8Array(xhr.response);\n        var buf = new Protobuf(arrayBuffer);\n        var vt = new VectorTile(buf);\n        //Check the current map layer zoom.  If fast zooming is occurring, then short circuit tiles that are for a different zoom level than we're currently on.\n        if(self.map && self.map.getZoom() != ctx.zoom) {\n          console.log(\"Fetched tile for zoom level \" + ctx.zoom + \". Map is at zoom level \" + self._map.getZoom());\n          return;\n        }\n        self.checkVectorTileLayers(parseVT(vt), ctx);\n        tileLoaded(self, ctx);\n      }\n\n      //either way, reduce the count of tilesToProcess tiles here\n      self.reduceTilesToProcessCount();\n    };\n\n    xhr.onerror = function() {\n      console.log(\"xhr error: \" + xhr.status)\n    };\n\n    xhr.open('GET', src, true); //async is true\n    var headers = self.options.xhrHeaders;\n    for (var header in headers) {\n      xhr.setRequestHeader(header, headers[header])\n    }\n    xhr.responseType = 'arraybuffer';\n    xhr.send();\n  },\n\n  reduceTilesToProcessCount: function(){\n    this._tilesToProcess--;\n    if(!this._tilesToProcess){\n      //Trigger event letting us know that all PBFs have been loaded and processed (or 404'd).\n      if(this._eventHandlers[\"PBFLoad\"]) this._eventHandlers[\"PBFLoad\"]();\n      this._pbfLoaded();\n    }\n  },\n\n  checkVectorTileLayers: function(vt, ctx, parsed) {\n    var self = this;\n\n    //Check if there are specified visible layers\n    if(self.options.visibleLayers && self.options.visibleLayers.length > 0){\n      //only let thru the layers listed in the visibleLayers array\n      for(var i=0; i < self.options.visibleLayers.length; i++){\n        var layerName = self.options.visibleLayers[i];\n        if(vt.layers[layerName]){\n           //Proceed with parsing\n          self.prepareMVTLayers(vt.layers[layerName], layerName, ctx, parsed);\n        }\n      }\n    }else{\n      //Parse all vt.layers\n      for (var key in vt.layers) {\n        self.prepareMVTLayers(vt.layers[key], key, ctx, parsed);\n      }\n    }\n  },\n\n  prepareMVTLayers: function(lyr ,key, ctx, parsed) {\n    var self = this;\n\n    if (!self.layers[key]) {\n      //Create MVTLayer or MVTPointLayer for user\n      self.layers[key] = self.createMVTLayer(key, lyr.parsedFeatures[0].type || null);\n    }\n\n    if (parsed) {\n      //We've already parsed it.  Go get canvas and draw.\n      self.layers[key].getCanvas(ctx, lyr);\n    } else {\n      self.layers[key].parseVectorTileLayer(lyr, ctx);\n    }\n\n  },\n\n  createMVTLayer: function(key, type) {\n    var self = this;\n\n    var getIDForLayerFeature;\n    if (typeof self.options.getIDForLayerFeature === 'function') {\n      getIDForLayerFeature = self.options.getIDForLayerFeature;\n    } else {\n      getIDForLayerFeature = Util.getIDForLayerFeature;\n    }\n\n    var options = {\n      getIDForLayerFeature: getIDForLayerFeature,\n      filter: self.options.filter,\n      layerOrdering: self.options.layerOrdering,\n      style: self.style,\n      name: key,\n      asynch: true\n    };\n\n    if (self.options.zIndex) {\n      options.zIndex = self.zIndex;\n    }\n\n    //Take the layer and create a new MVTLayer or MVTPointLayer if one doesn't exist.\n    var layer = new MVTLayer(self, options).addTo(self.map);\n\n    return layer;\n  },\n\n  getLayers: function() {\n    return this.layers;\n  },\n\n  hideLayer: function(id) {\n    if (this.layers[id]) {\n      this._map.removeLayer(this.layers[id]);\n      if(this.options.visibleLayers.indexOf(\"id\") > -1){\n        this.visibleLayers.splice(this.options.visibleLayers.indexOf(\"id\"), 1);\n      }\n    }\n  },\n\n  showLayer: function(id) {\n    if (this.layers[id]) {\n      this._map.addLayer(this.layers[id]);\n      if(this.options.visibleLayers.indexOf(\"id\") == -1){\n        this.visibleLayers.push(id);\n      }\n    }\n    //Make sure manager layer is always in front\n    this.bringToFront();\n  },\n\n  removeChildLayers: function(map){\n    //Remove child layers of this group layer\n    for (var key in this.layers) {\n      var layer = this.layers[key];\n      map.removeLayer(layer);\n    }\n  },\n\n  addChildLayers: function(map) {\n    var self = this;\n    if(self.options.visibleLayers.length > 0){\n      //only let thru the layers listed in the visibleLayers array\n      for(var i=0; i < self.options.visibleLayers.length; i++){\n        var layerName = self.options.visibleLayers[i];\n        var layer = this.layers[layerName];\n        if(layer){\n          //Proceed with parsing\n          map.addLayer(layer);\n        }\n      }\n    }else{\n      //Add all layers\n      for (var key in this.layers) {\n        var layer = this.layers[key];\n        // layer is set to visible and is not already on map\n        if (!layer._map) {\n          map.addLayer(layer);\n        }\n      }\n    }\n  },\n\n  bind: function(eventType, callback) {\n    this._eventHandlers[eventType] = callback;\n  },\n\n  _onClick: function(evt) {\n    //Here, pass the event on to the child MVTLayer and have it do the hit test and handle the result.\n    var self = this;\n    var onClick = self.options.onClick;\n    var clickableLayers = self.options.clickableLayers;\n    var layers = self.layers;\n\n    evt.tileID =  getTileURL(evt.latlng.lat, evt.latlng.lng, this.map.getZoom());\n\n    // We must have an array of clickable layers, otherwise, we just pass\n    // the event to the public onClick callback in options.\n\n    if(!clickableLayers){\n      clickableLayers = Object.keys(self.layers);\n    }\n\n    if (clickableLayers && clickableLayers.length > 0) {\n      for (var i = 0, len = clickableLayers.length; i < len; i++) {\n        var key = clickableLayers[i];\n        var layer = layers[key];\n        if (layer) {\n          layer.handleClickEvent(evt, function(evt) {\n            if (typeof onClick === 'function') {\n              onClick(evt);\n            }\n          });\n        }\n      }\n    } else {\n      if (typeof onClick === 'function') {\n        onClick(evt);\n      }\n    }\n\n  },\n\n  setFilter: function(filterFunction, layerName) {\n    //take in a new filter function.\n    //Propagate to child layers.\n\n    //Add filter to all child layers if no layer is specified.\n    for (var key in this.layers) {\n      var layer = this.layers[key];\n\n      if (layerName){\n        if(key.toLowerCase() == layerName.toLowerCase()){\n          layer.options.filter = filterFunction; //Assign filter to child layer, only if name matches\n          //After filter is set, the old feature hashes are invalid.  Clear them for next draw.\n          layer.clearLayerFeatureHash();\n          //layer.clearTileFeatureHash();\n        }\n      }\n      else{\n        layer.options.filter = filterFunction; //Assign filter to child layer\n        //After filter is set, the old feature hashes are invalid.  Clear them for next draw.\n        layer.clearLayerFeatureHash();\n        //layer.clearTileFeatureHash();\n      }\n    }\n  },\n\n  /**\n   * Take in a new style function and propogate to child layers.\n   * If you do not set a layer name, it resets the style for all of the layers.\n   * @param styleFunction\n   * @param layerName\n   */\n  setStyle: function(styleFn, layerName) {\n    for (var key in this.layers) {\n      var layer = this.layers[key];\n      if (layerName) {\n        if(key.toLowerCase() == layerName.toLowerCase()) {\n          layer.setStyle(styleFn);\n        }\n      } else {\n        layer.setStyle(styleFn);\n      }\n    }\n  },\n\n  featureSelected: function(mvtFeature) {\n    if (this.options.mutexToggle) {\n      if (this._selectedFeature) {\n        this._selectedFeature.deselect();\n      }\n      this._selectedFeature = mvtFeature;\n    }\n    if (this.options.onSelect) {\n      this.options.onSelect(mvtFeature);\n    }\n  },\n\n  featureDeselected: function(mvtFeature) {\n    if (this.options.mutexToggle && this._selectedFeature) {\n      this._selectedFeature = null;\n    }\n    if (this.options.onDeselect) {\n      this.options.onDeselect(mvtFeature);\n    }\n  },\n\n  _pbfLoaded: function() {\n    //Fires when all tiles from this layer have been loaded and drawn (or 404'd).\n\n    //Make sure manager layer is always in front\n    this.bringToFront();\n\n    //See if there is an event to execute\n    var self = this;\n    var onTilesLoaded = self.options.onTilesLoaded;\n\n    if (onTilesLoaded && typeof onTilesLoaded === 'function' && this._triggerOnTilesLoadedEvent === true) {\n      onTilesLoaded(this);\n    }\n    self._triggerOnTilesLoadedEvent = true; //reset - if redraw() is called with the optinal 'false' parameter to temporarily disable the onTilesLoaded event from firing.  This resets it back to true after a single time of firing as 'false'.\n  }\n\n});\n\n\nif (typeof(Number.prototype.toRad) === \"undefined\") {\n  Number.prototype.toRad = function() {\n    return this * Math.PI / 180;\n  }\n}\n\nfunction getTileURL(lat, lon, zoom) {\n  var xtile = parseInt(Math.floor( (lon + 180) / 360 * (1<<zoom) ));\n  var ytile = parseInt(Math.floor( (1 - Math.log(Math.tan(lat.toRad()) + 1 / Math.cos(lat.toRad())) / Math.PI) / 2 * (1<<zoom) ));\n  return \"\" + zoom + \":\" + xtile + \":\" + ytile;\n}\n\nfunction tileLoaded(pbfSource, ctx) {\n  pbfSource.loadedTiles[ctx.id] = ctx;\n}\n\nfunction parseVT(vt){\n  for (var key in vt.layers) {\n    var lyr = vt.layers[key];\n    parseVTFeatures(lyr);\n  }\n  return vt;\n}\n\nfunction parseVTFeatures(vtl){\n  vtl.parsedFeatures = [];\n  var features = vtl._features;\n  for (var i = 0, len = features.length; i < len; i++) {\n    var vtf = vtl.feature(i);\n    vtf.coordinates = vtf.loadGeometry();\n    vtl.parsedFeatures.push(vtf);\n  }\n  return vtl;\n}\n","/**\n * Created by Nicholas Hallahan <nhallahan@spatialdev.com>\n *       on 8/15/14.\n */\nvar Util = module.exports = {};\n\nUtil.getContextID = function(ctx) {\n  return [ctx.zoom, ctx.tile.x, ctx.tile.y].join(\":\");\n};\n\n/**\n * Default function that gets the id for a layer feature.\n * Sometimes this needs to be done in a different way and\n * can be specified by the user in the options for L.TileLayer.MVTSource.\n *\n * @param feature\n * @returns {ctx.id|*|id|string|jsts.index.chain.MonotoneChain.id|number}\n */\nUtil.getIDForLayerFeature = function(feature) {\n  return feature.properties.id;\n};\n\nUtil.getJSON = function(url, callback) {\n  var xmlhttp = typeof XMLHttpRequest !== 'undefined' ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');\n  xmlhttp.onreadystatechange = function() {\n    var status = xmlhttp.status;\n    if (xmlhttp.readyState === 4 && status >= 200 && status < 300) {\n      var json = JSON.parse(xmlhttp.responseText);\n      callback(null, json);\n    } else {\n      callback( { error: true, status: status } );\n    }\n  };\n  xmlhttp.open(\"GET\", url, true);\n  xmlhttp.send();\n};\n","/**\n * Created by Nicholas Hallahan <nhallahan@spatialdev.com>\n *       on 7/31/14.\n */\nvar Util = require('../MVTUtil');\nmodule.exports = StaticLabel;\n\nfunction StaticLabel(mvtFeature, ctx, latLng, style) {\n  var self = this;\n  this.mvtFeature = mvtFeature;\n  this.map = mvtFeature.map;\n  this.zoom = ctx.zoom;\n  this.latLng = latLng;\n  this.selected = false;\n\n  if (mvtFeature.linkedFeature) {\n    var linkedFeature = mvtFeature.linkedFeature();\n    if (linkedFeature && linkedFeature.selected) {\n      self.selected = true;\n    }\n  }\n\n  init(self, mvtFeature, ctx, latLng, style)\n}\n\nfunction init(self, mvtFeature, ctx, latLng, style) {\n  var ajaxData = mvtFeature.ajaxData;\n  var sty = self.style = style.staticLabel(mvtFeature, ajaxData);\n  var icon = self.icon = L.divIcon({\n    className: sty.cssClass || 'label-icon-text',\n    html: sty.html,\n    iconSize: sty.iconSize || [50,50]\n  });\n\n  self.marker = L.marker(latLng, {icon: icon}).addTo(self.map);\n\n  if (self.selected) {\n    self.marker._icon.classList.add(self.style.cssSelectedClass || 'label-icon-text-selected');\n  }\n\n  self.marker.on('click', function(e) {\n    self.toggle();\n  });\n\n  self.map.on('zoomend', function(e) {\n    var newZoom = e.target.getZoom();\n    if (self.zoom !== newZoom) {\n      self.map.removeLayer(self.marker);\n    }\n  });\n}\n\n\nStaticLabel.prototype.toggle = function() {\n  if (this.selected) {\n    this.deselect();\n  } else {\n    this.select();\n  }\n};\n\nStaticLabel.prototype.select = function() {\n  this.selected = true;\n  this.marker._icon.classList.add(this.style.cssSelectedClass || 'label-icon-text-selected');\n  var linkedFeature = this.mvtFeature.linkedFeature();\n  if (!linkedFeature.selected) linkedFeature.select();\n};\n\nStaticLabel.prototype.deselect = function() {\n  this.selected = false;\n  this.marker._icon.classList.remove(this.style.cssSelectedClass || 'label-icon-text-selected');\n  var linkedFeature = this.mvtFeature.linkedFeature();\n  if (linkedFeature.selected) linkedFeature.deselect();\n};\n\nStaticLabel.prototype.remove = function() {\n  if (!this.map || !this.marker) return;\n  this.map.removeLayer(this.marker);\n};\n","/**\n * Copyright (c) 2014, Spatial Development International\n * All rights reserved.\n *\n * Source code can be found at:\n * https://github.com/SpatialServer/Leaflet.MapboxVectorTile\n *\n * @license ISC\n */\n\nmodule.exports = require('./MVTSource');\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('is-array')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\nBuffer.poolSize = 8192 // not used by this implementation\n\nvar rootParent = {}\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property\n *     on objects.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\nfunction typedArraySupport () {\n  function Bar () {}\n  try {\n    var arr = new Uint8Array(1)\n    arr.foo = function () { return 42 }\n    arr.constructor = Bar\n    return arr.foo() === 42 && // typed array instances can be augmented\n        arr.constructor === Bar && // constructor can be set\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\n/**\n * Class: Buffer\n * =============\n *\n * The Buffer constructor returns instances of `Uint8Array` that are augmented\n * with function properties for all the node `Buffer` API functions. We use\n * `Uint8Array` so that square bracket notation works as expected -- it returns\n * a single octet.\n *\n * By augmenting the instances, we can avoid modifying the `Uint8Array`\n * prototype.\n */\nfunction Buffer (arg) {\n  if (!(this instanceof Buffer)) {\n    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.\n    if (arguments.length > 1) return new Buffer(arg, arguments[1])\n    return new Buffer(arg)\n  }\n\n  this.length = 0\n  this.parent = undefined\n\n  // Common case.\n  if (typeof arg === 'number') {\n    return fromNumber(this, arg)\n  }\n\n  // Slightly less common case.\n  if (typeof arg === 'string') {\n    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')\n  }\n\n  // Unusual.\n  return fromObject(this, arg)\n}\n\nfunction fromNumber (that, length) {\n  that = allocate(that, length < 0 ? 0 : checked(length) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < length; i++) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'\n\n  // Assumption: byteLength() return value is always < kMaxLength.\n  var length = byteLength(string, encoding) | 0\n  that = allocate(that, length)\n\n  that.write(string, encoding)\n  return that\n}\n\nfunction fromObject (that, object) {\n  if (Buffer.isBuffer(object)) return fromBuffer(that, object)\n\n  if (isArray(object)) return fromArray(that, object)\n\n  if (object == null) {\n    throw new TypeError('must start with number, buffer, array or string')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined') {\n    if (object.buffer instanceof ArrayBuffer) {\n      return fromTypedArray(that, object)\n    }\n    if (object instanceof ArrayBuffer) {\n      return fromArrayBuffer(that, object)\n    }\n  }\n\n  if (object.length) return fromArrayLike(that, object)\n\n  return fromJsonObject(that, object)\n}\n\nfunction fromBuffer (that, buffer) {\n  var length = checked(buffer.length) | 0\n  that = allocate(that, length)\n  buffer.copy(that, 0, 0, length)\n  return that\n}\n\nfunction fromArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Duplicate of fromArray() to keep fromArray() monomorphic.\nfunction fromTypedArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  // Truncating the elements is probably not what people expect from typed\n  // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior\n  // of the old Buffer constructor.\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    array.byteLength\n    that = Buffer._augment(new Uint8Array(array))\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromTypedArray(that, new Uint8Array(array))\n  }\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.\n// Returns a zero-length buffer for inputs that don't conform to the spec.\nfunction fromJsonObject (that, object) {\n  var array\n  var length = 0\n\n  if (object.type === 'Buffer' && isArray(object.data)) {\n    array = object.data\n    length = checked(array.length) | 0\n  }\n  that = allocate(that, length)\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n}\n\nfunction allocate (that, length) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = Buffer._augment(new Uint8Array(length))\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that.length = length\n    that._isBuffer = true\n  }\n\n  var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1\n  if (fromPool) that.parent = rootParent\n\n  return that\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (subject, encoding) {\n  if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)\n\n  var buf = new Buffer(subject, encoding)\n  delete buf.parent\n  return buf\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  var i = 0\n  var len = Math.min(x, y)\n  while (i < len) {\n    if (a[i] !== b[i]) break\n\n    ++i\n  }\n\n  if (i !== len) {\n    x = a[i]\n    y = b[i]\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'binary':\n    case 'base64':\n    case 'raw':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')\n\n  if (list.length === 0) {\n    return new Buffer(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; i++) {\n      length += list[i].length\n    }\n  }\n\n  var buf = new Buffer(length)\n  var pos = 0\n  for (i = 0; i < list.length; i++) {\n    var item = list[i]\n    item.copy(buf, pos)\n    pos += item.length\n  }\n  return buf\n}\n\nfunction byteLength (string, encoding) {\n  if (typeof string !== 'string') string = '' + string\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'binary':\n      // Deprecated\n      case 'raw':\n      case 'raws':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\n// pre-set for values that may exist in the future\nBuffer.prototype.length = undefined\nBuffer.prototype.parent = undefined\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  start = start | 0\n  end = end === undefined || end === Infinity ? this.length : end | 0\n\n  if (!encoding) encoding = 'utf8'\n  if (start < 0) start = 0\n  if (end > this.length) end = this.length\n  if (end <= start) return ''\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'binary':\n        return binarySlice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return 0\n  return Buffer.compare(this, b)\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset) {\n  if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff\n  else if (byteOffset < -0x80000000) byteOffset = -0x80000000\n  byteOffset >>= 0\n\n  if (this.length === 0) return -1\n  if (byteOffset >= this.length) return -1\n\n  // Negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)\n\n  if (typeof val === 'string') {\n    if (val.length === 0) return -1 // special case: looking for empty string always fails\n    return String.prototype.indexOf.call(this, val, byteOffset)\n  }\n  if (Buffer.isBuffer(val)) {\n    return arrayIndexOf(this, val, byteOffset)\n  }\n  if (typeof val === 'number') {\n    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {\n      return Uint8Array.prototype.indexOf.call(this, val, byteOffset)\n    }\n    return arrayIndexOf(this, [ val ], byteOffset)\n  }\n\n  function arrayIndexOf (arr, val, byteOffset) {\n    var foundIndex = -1\n    for (var i = 0; byteOffset + i < arr.length; i++) {\n      if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex\n      } else {\n        foundIndex = -1\n      }\n    }\n    return -1\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\n// `get` is deprecated\nBuffer.prototype.get = function get (offset) {\n  console.log('.get() is deprecated. Access using array indexes instead.')\n  return this.readUInt8(offset)\n}\n\n// `set` is deprecated\nBuffer.prototype.set = function set (v, offset) {\n  console.log('.set() is deprecated. Access using array indexes instead.')\n  return this.writeUInt8(v, offset)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new Error('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; i++) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) throw new Error('Invalid hex string')\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction binaryWrite (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    var swap = encoding\n    encoding = offset\n    offset = length | 0\n    length = swap\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'binary':\n        return binaryWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction binarySlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; i++) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = Buffer._augment(this.subarray(start, end))\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; i++) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  if (newBuf.length) newBuf.parent = this.parent || this\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n  if (offset < 0) throw new RangeError('index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; i--) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; i++) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    target._set(this.subarray(start, start + len), targetStart)\n  }\n\n  return len\n}\n\n// fill(value, start=0, end=buffer.length)\nBuffer.prototype.fill = function fill (value, start, end) {\n  if (!value) value = 0\n  if (!start) start = 0\n  if (!end) end = this.length\n\n  if (end < start) throw new RangeError('end < start')\n\n  // Fill 0 bytes; we're done\n  if (end === start) return\n  if (this.length === 0) return\n\n  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')\n  if (end < 0 || end > this.length) throw new RangeError('end out of bounds')\n\n  var i\n  if (typeof value === 'number') {\n    for (i = start; i < end; i++) {\n      this[i] = value\n    }\n  } else {\n    var bytes = utf8ToBytes(value.toString())\n    var len = bytes.length\n    for (i = start; i < end; i++) {\n      this[i] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n/**\n * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.\n * Added in Node 0.12. Only available in browsers that support ArrayBuffer.\n */\nBuffer.prototype.toArrayBuffer = function toArrayBuffer () {\n  if (typeof Uint8Array !== 'undefined') {\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n      return (new Buffer(this)).buffer\n    } else {\n      var buf = new Uint8Array(this.length)\n      for (var i = 0, len = buf.length; i < len; i += 1) {\n        buf[i] = this[i]\n      }\n      return buf.buffer\n    }\n  } else {\n    throw new TypeError('Buffer.toArrayBuffer not supported in this browser')\n  }\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar BP = Buffer.prototype\n\n/**\n * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods\n */\nBuffer._augment = function _augment (arr) {\n  arr.constructor = Buffer\n  arr._isBuffer = true\n\n  // save reference to original Uint8Array set method before overwriting\n  arr._set = arr.set\n\n  // deprecated\n  arr.get = BP.get\n  arr.set = BP.set\n\n  arr.write = BP.write\n  arr.toString = BP.toString\n  arr.toLocaleString = BP.toString\n  arr.toJSON = BP.toJSON\n  arr.equals = BP.equals\n  arr.compare = BP.compare\n  arr.indexOf = BP.indexOf\n  arr.copy = BP.copy\n  arr.slice = BP.slice\n  arr.readUIntLE = BP.readUIntLE\n  arr.readUIntBE = BP.readUIntBE\n  arr.readUInt8 = BP.readUInt8\n  arr.readUInt16LE = BP.readUInt16LE\n  arr.readUInt16BE = BP.readUInt16BE\n  arr.readUInt32LE = BP.readUInt32LE\n  arr.readUInt32BE = BP.readUInt32BE\n  arr.readIntLE = BP.readIntLE\n  arr.readIntBE = BP.readIntBE\n  arr.readInt8 = BP.readInt8\n  arr.readInt16LE = BP.readInt16LE\n  arr.readInt16BE = BP.readInt16BE\n  arr.readInt32LE = BP.readInt32LE\n  arr.readInt32BE = BP.readInt32BE\n  arr.readFloatLE = BP.readFloatLE\n  arr.readFloatBE = BP.readFloatBE\n  arr.readDoubleLE = BP.readDoubleLE\n  arr.readDoubleBE = BP.readDoubleBE\n  arr.writeUInt8 = BP.writeUInt8\n  arr.writeUIntLE = BP.writeUIntLE\n  arr.writeUIntBE = BP.writeUIntBE\n  arr.writeUInt16LE = BP.writeUInt16LE\n  arr.writeUInt16BE = BP.writeUInt16BE\n  arr.writeUInt32LE = BP.writeUInt32LE\n  arr.writeUInt32BE = BP.writeUInt32BE\n  arr.writeIntLE = BP.writeIntLE\n  arr.writeIntBE = BP.writeIntBE\n  arr.writeInt8 = BP.writeInt8\n  arr.writeInt16LE = BP.writeInt16LE\n  arr.writeInt16BE = BP.writeInt16BE\n  arr.writeInt32LE = BP.writeInt32LE\n  arr.writeInt32BE = BP.writeInt32BE\n  arr.writeFloatLE = BP.writeFloatLE\n  arr.writeFloatBE = BP.writeFloatBE\n  arr.writeDoubleLE = BP.writeDoubleLE\n  arr.writeDoubleBE = BP.writeDoubleBE\n  arr.fill = BP.fill\n  arr.inspect = BP.inspect\n  arr.toArrayBuffer = BP.toArrayBuffer\n\n  return arr\n}\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; i++) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; i++) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n","var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n;(function (exports) {\n\t'use strict';\n\n  var Arr = (typeof Uint8Array !== 'undefined')\n    ? Uint8Array\n    : Array\n\n\tvar PLUS   = '+'.charCodeAt(0)\n\tvar SLASH  = '/'.charCodeAt(0)\n\tvar NUMBER = '0'.charCodeAt(0)\n\tvar LOWER  = 'a'.charCodeAt(0)\n\tvar UPPER  = 'A'.charCodeAt(0)\n\tvar PLUS_URL_SAFE = '-'.charCodeAt(0)\n\tvar SLASH_URL_SAFE = '_'.charCodeAt(0)\n\n\tfunction decode (elt) {\n\t\tvar code = elt.charCodeAt(0)\n\t\tif (code === PLUS ||\n\t\t    code === PLUS_URL_SAFE)\n\t\t\treturn 62 // '+'\n\t\tif (code === SLASH ||\n\t\t    code === SLASH_URL_SAFE)\n\t\t\treturn 63 // '/'\n\t\tif (code < NUMBER)\n\t\t\treturn -1 //no match\n\t\tif (code < NUMBER + 10)\n\t\t\treturn code - NUMBER + 26 + 26\n\t\tif (code < UPPER + 26)\n\t\t\treturn code - UPPER\n\t\tif (code < LOWER + 26)\n\t\t\treturn code - LOWER + 26\n\t}\n\n\tfunction b64ToByteArray (b64) {\n\t\tvar i, j, l, tmp, placeHolders, arr\n\n\t\tif (b64.length % 4 > 0) {\n\t\t\tthrow new Error('Invalid string. Length must be a multiple of 4')\n\t\t}\n\n\t\t// the number of equal signs (place holders)\n\t\t// if there are two placeholders, than the two characters before it\n\t\t// represent one byte\n\t\t// if there is only one, then the three characters before it represent 2 bytes\n\t\t// this is just a cheap hack to not do indexOf twice\n\t\tvar len = b64.length\n\t\tplaceHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0\n\n\t\t// base64 is 4/3 + up to two characters of the original data\n\t\tarr = new Arr(b64.length * 3 / 4 - placeHolders)\n\n\t\t// if there are placeholders, only get up to the last complete 4 chars\n\t\tl = placeHolders > 0 ? b64.length - 4 : b64.length\n\n\t\tvar L = 0\n\n\t\tfunction push (v) {\n\t\t\tarr[L++] = v\n\t\t}\n\n\t\tfor (i = 0, j = 0; i < l; i += 4, j += 3) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))\n\t\t\tpush((tmp & 0xFF0000) >> 16)\n\t\t\tpush((tmp & 0xFF00) >> 8)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\tif (placeHolders === 2) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)\n\t\t\tpush(tmp & 0xFF)\n\t\t} else if (placeHolders === 1) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)\n\t\t\tpush((tmp >> 8) & 0xFF)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\treturn arr\n\t}\n\n\tfunction uint8ToBase64 (uint8) {\n\t\tvar i,\n\t\t\textraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes\n\t\t\toutput = \"\",\n\t\t\ttemp, length\n\n\t\tfunction encode (num) {\n\t\t\treturn lookup.charAt(num)\n\t\t}\n\n\t\tfunction tripletToBase64 (num) {\n\t\t\treturn encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)\n\t\t}\n\n\t\t// go through the array every three bytes, we'll deal with trailing stuff later\n\t\tfor (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {\n\t\t\ttemp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n\t\t\toutput += tripletToBase64(temp)\n\t\t}\n\n\t\t// pad the end with zeros, but make sure to not forget the extra bytes\n\t\tswitch (extraBytes) {\n\t\t\tcase 1:\n\t\t\t\ttemp = uint8[uint8.length - 1]\n\t\t\t\toutput += encode(temp >> 2)\n\t\t\t\toutput += encode((temp << 4) & 0x3F)\n\t\t\t\toutput += '=='\n\t\t\t\tbreak\n\t\t\tcase 2:\n\t\t\t\ttemp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])\n\t\t\t\toutput += encode(temp >> 10)\n\t\t\t\toutput += encode((temp >> 4) & 0x3F)\n\t\t\t\toutput += encode((temp << 2) & 0x3F)\n\t\t\t\toutput += '='\n\t\t\t\tbreak\n\t\t}\n\n\t\treturn output\n\t}\n\n\texports.toByteArray = b64ToByteArray\n\texports.fromByteArray = uint8ToBase64\n}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))\n","\n/**\n * isArray\n */\n\nvar isArray = Array.isArray;\n\n/**\n * toString\n */\n\nvar str = Object.prototype.toString;\n\n/**\n * Whether or not the given `val`\n * is an array.\n *\n * example:\n *\n *        isArray([]);\n *        // > true\n *        isArray(arguments);\n *        // > false\n *        isArray('');\n *        // > false\n *\n * @param {mixed} val\n * @return {bool}\n */\n\nmodule.exports = isArray || function (val) {\n  return !! val && '[object Array]' == str.call(val);\n};\n"]} +},{"./MVTSource":"/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTSource.js"}]},{},["/Users/wil/Code/Leaflet.MapboxVectorTile/src/index.js"]) +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/clip.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/convert.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/index.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/simplify.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/tile.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/transform.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/geojson-vt/src/wrap.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/buffer.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/index.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/pbf/node_modules/ieee754/index.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/point-geometry/index.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/index.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortile.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilefeature.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vector-tile/lib/vectortilelayer.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/index.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/lib/geojson_wrapper.js","/Users/wil/Code/Leaflet.MapboxVectorTile/node_modules/vt-pbf/vector-tile-pb.js","/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTFeature.js","/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTLayer.js","/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTSource.js","/Users/wil/Code/Leaflet.MapboxVectorTile/src/MVTUtil.js","/Users/wil/Code/Leaflet.MapboxVectorTile/src/StaticLabel/StaticLabel.js","/Users/wil/Code/Leaflet.MapboxVectorTile/src/index.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACz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aA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nmodule.exports = clip;\n\n/* clip features between two axis-parallel lines:\n *     |        |\n *  ___|___     |     /\n * /   |   \\____|____/\n *     |        |\n */\n\nfunction clip(features, scale, k1, k2, axis, intersect, minAll, maxAll) {\n\n    k1 /= scale;\n    k2 /= scale;\n\n    if (minAll >= k1 && maxAll <= k2) return features; // trivial accept\n    else if (minAll > k2 || maxAll < k1) return null; // trivial reject\n\n    var clipped = [];\n\n    for (var i = 0; i < features.length; i++) {\n\n        var feature = features[i],\n            geometry = feature.geometry,\n            type = feature.type,\n            min, max;\n\n        min = feature.min[axis];\n        max = feature.max[axis];\n\n        if (min >= k1 && max <= k2) { // trivial accept\n            clipped.push(feature);\n            continue;\n        } else if (min > k2 || max < k1) continue; // trivial reject\n\n        var slices = type === 1 ?\n                clipPoints(geometry, k1, k2, axis) :\n                clipGeometry(geometry, k1, k2, axis, intersect, type === 3);\n\n        if (slices.length) {\n            // if a feature got clipped, it will likely get clipped on the next zoom level as well,\n            // so there's no need to recalculate bboxes\n            clipped.push({\n                geometry: slices,\n                type: type,\n                tags: features[i].tags || null,\n                min: feature.min,\n                max: feature.max\n            });\n        }\n    }\n\n    return clipped.length ? clipped : null;\n}\n\nfunction clipPoints(geometry, k1, k2, axis) {\n    var slice = [];\n\n    for (var i = 0; i < geometry.length; i++) {\n        var a = geometry[i],\n            ak = a[axis];\n\n        if (ak >= k1 && ak <= k2) slice.push(a);\n    }\n    return slice;\n}\n\nfunction clipGeometry(geometry, k1, k2, axis, intersect, closed) {\n\n    var slices = [];\n\n    for (var i = 0; i < geometry.length; i++) {\n\n        var ak = 0,\n            bk = 0,\n            b = null,\n            points = geometry[i],\n            area = points.area,\n            dist = points.dist,\n            len = points.length,\n            a, j, last;\n\n        var slice = [];\n\n        for (j = 0; j < len - 1; j++) {\n            a = b || points[j];\n            b = points[j + 1];\n            ak = bk || a[axis];\n            bk = b[axis];\n\n            if (ak < k1) {\n\n                if ((bk > k2)) { // ---|-----|-->\n                    slice.push(intersect(a, b, k1), intersect(a, b, k2));\n                    if (!closed) slice = newSlice(slices, slice, area, dist);\n\n                } else if (bk >= k1) slice.push(intersect(a, b, k1)); // ---|-->  |\n\n            } else if (ak > k2) {\n\n                if ((bk < k1)) { // <--|-----|---\n                    slice.push(intersect(a, b, k2), intersect(a, b, k1));\n                    if (!closed) slice = newSlice(slices, slice, area, dist);\n\n                } else if (bk <= k2) slice.push(intersect(a, b, k2)); // |  <--|---\n\n            } else {\n\n                slice.push(a);\n\n                if (bk < k1) { // <--|---  |\n                    slice.push(intersect(a, b, k1));\n                    if (!closed) slice = newSlice(slices, slice, area, dist);\n\n                } else if (bk > k2) { // |  ---|-->\n                    slice.push(intersect(a, b, k2));\n                    if (!closed) slice = newSlice(slices, slice, area, dist);\n                }\n                // | --> |\n            }\n        }\n\n        // add the last point\n        a = points[len - 1];\n        ak = a[axis];\n        if (ak >= k1 && ak <= k2) slice.push(a);\n\n        // close the polygon if its endpoints are not the same after clipping\n\n        last = slice[slice.length - 1];\n        if (closed && last && (slice[0][0] !== last[0] || slice[0][1] !== last[1])) slice.push(slice[0]);\n\n        // add the final slice\n        newSlice(slices, slice, area, dist);\n    }\n\n    return slices;\n}\n\nfunction newSlice(slices, slice, area, dist) {\n    if (slice.length) {\n        // we don't recalculate the area/length of the unclipped geometry because the case where it goes\n        // below the visibility threshold as a result of clipping is rare, so we avoid doing unnecessary work\n        slice.area = area;\n        slice.dist = dist;\n\n        slices.push(slice);\n    }\n    return [];\n}\n","'use strict';\n\nmodule.exports = convert;\n\nvar simplify = require('./simplify');\n\n// converts GeoJSON feature into an intermediate projected JSON vector format with simplification data\n\nfunction convert(data, tolerance) {\n    var features = [];\n\n    if (data.type === 'FeatureCollection') {\n        for (var i = 0; i < data.features.length; i++) {\n            convertFeature(features, data.features[i], tolerance);\n        }\n    } else if (data.type === 'Feature') {\n        convertFeature(features, data, tolerance);\n\n    } else {\n        // single geometry or a geometry collection\n        convertFeature(features, {geometry: data}, tolerance);\n    }\n    return features;\n}\n\nfunction convertFeature(features, feature, tolerance) {\n    var geom = feature.geometry,\n        type = geom.type,\n        coords = geom.coordinates,\n        tags = feature.properties,\n        i, j, rings;\n\n    if (type === 'Point') {\n        features.push(create(tags, 1, [projectPoint(coords)]));\n\n    } else if (type === 'MultiPoint') {\n        features.push(create(tags, 1, project(coords)));\n\n    } else if (type === 'LineString') {\n        features.push(create(tags, 2, [project(coords, tolerance)]));\n\n    } else if (type === 'MultiLineString' || type === 'Polygon') {\n        rings = [];\n        for (i = 0; i < coords.length; i++) {\n            rings.push(project(coords[i], tolerance));\n        }\n        features.push(create(tags, type === 'Polygon' ? 3 : 2, rings));\n\n    } else if (type === 'MultiPolygon') {\n        rings = [];\n        for (i = 0; i < coords.length; i++) {\n            for (j = 0; j < coords[i].length; j++) {\n                rings.push(project(coords[i][j], tolerance));\n            }\n        }\n        features.push(create(tags, 3, rings));\n\n    } else if (type === 'GeometryCollection') {\n        for (i = 0; i < geom.geometries.length; i++) {\n            convertFeature(features, {\n                geometry: geom.geometries[i],\n                properties: tags\n            }, tolerance);\n        }\n\n    } else {\n        throw new Error('Input data is not a valid GeoJSON object.');\n    }\n}\n\nfunction create(tags, type, geometry) {\n    var feature = {\n        geometry: geometry,\n        type: type,\n        tags: tags || null,\n        min: [2, 1], // initial bbox values;\n        max: [-1, 0]  // note that coords are usually in [0..1] range\n    };\n    calcBBox(feature);\n    return feature;\n}\n\nfunction project(lonlats, tolerance) {\n    var projected = [];\n    for (var i = 0; i < lonlats.length; i++) {\n        projected.push(projectPoint(lonlats[i]));\n    }\n    if (tolerance) {\n        simplify(projected, tolerance);\n        calcSize(projected);\n    }\n    return projected;\n}\n\nfunction projectPoint(p) {\n    var sin = Math.sin(p[1] * Math.PI / 180),\n        x = (p[0] / 360 + 0.5),\n        y = (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);\n\n    y = y < -1 ? -1 :\n        y > 1 ? 1 : y;\n\n    return [x, y, 0];\n}\n\n// calculate area and length of the poly\nfunction calcSize(points) {\n    var area = 0,\n        dist = 0;\n\n    for (var i = 0, a, b; i < points.length - 1; i++) {\n        a = b || points[i];\n        b = points[i + 1];\n\n        area += a[0] * b[1] - b[0] * a[1];\n\n        // use Manhattan distance instead of Euclidian one to avoid expensive square root computation\n        dist += Math.abs(b[0] - a[0]) + Math.abs(b[1] - a[1]);\n    }\n    points.area = Math.abs(area / 2);\n    points.dist = dist;\n}\n\n// calculate the feature bounding box for faster clipping later\nfunction calcBBox(feature) {\n    var geometry = feature.geometry,\n        min = feature.min,\n        max = feature.max;\n\n    if (feature.type === 1) calcRingBBox(min, max, geometry);\n    else for (var i = 0; i < geometry.length; i++) calcRingBBox(min, max, geometry[i]);\n\n    return feature;\n}\n\nfunction calcRingBBox(min, max, points) {\n    for (var i = 0, p; i < points.length; i++) {\n        p = points[i];\n        min[0] = Math.min(p[0], min[0]);\n        max[0] = Math.max(p[0], max[0]);\n        min[1] = Math.min(p[1], min[1]);\n        max[1] = Math.max(p[1], max[1]);\n    }\n}\n","'use strict';\n\nmodule.exports = geojsonvt;\n\nvar convert = require('./convert'),     // GeoJSON conversion and preprocessing\n    transform = require('./transform'), // coordinate transformation\n    clip = require('./clip'),           // stripe clipping algorithm\n    wrap = require('./wrap'),           // date line processing\n    createTile = require('./tile');     // final simplified tile generation\n\n\nfunction geojsonvt(data, options) {\n    return new GeoJSONVT(data, options);\n}\n\nfunction GeoJSONVT(data, options) {\n    options = this.options = extend(Object.create(this.options), options);\n\n    var debug = options.debug;\n\n    if (debug) console.time('preprocess data');\n\n    var z2 = 1 << options.maxZoom, // 2^z\n        features = convert(data, options.tolerance / (z2 * options.extent));\n\n    this.tiles = {};\n    this.tileCoords = [];\n\n    if (debug) {\n        console.timeEnd('preprocess data');\n        console.log('index: maxZoom: %d, maxPoints: %d', options.indexMaxZoom, options.indexMaxPoints);\n        console.time('generate tiles');\n        this.stats = {};\n        this.total = 0;\n    }\n\n    features = wrap(features, options.buffer / options.extent, intersectX);\n\n    // start slicing from the top tile down\n    if (features.length) this.splitTile(features, 0, 0, 0);\n\n    if (debug) {\n        if (features.length) console.log('features: %d, points: %d', this.tiles[0].numFeatures, this.tiles[0].numPoints);\n        console.timeEnd('generate tiles');\n        console.log('tiles generated:', this.total, JSON.stringify(this.stats));\n    }\n}\n\nGeoJSONVT.prototype.options = {\n    maxZoom: 14,            // max zoom to preserve detail on\n    indexMaxZoom: 5,        // max zoom in the tile index\n    indexMaxPoints: 100000, // max number of points per tile in the tile index\n    solidChildren: false,   // whether to tile solid square tiles further\n    tolerance: 3,           // simplification tolerance (higher means simpler)\n    extent: 4096,           // tile extent\n    buffer: 64,             // tile buffer on each side\n    debug: 0                // logging level (0, 1 or 2)\n};\n\nGeoJSONVT.prototype.splitTile = function (features, z, x, y, cz, cx, cy) {\n\n    var stack = [features, z, x, y],\n        options = this.options,\n        debug = options.debug,\n        solid = null;\n\n    // avoid recursion by using a processing queue\n    while (stack.length) {\n        y = stack.pop();\n        x = stack.pop();\n        z = stack.pop();\n        features = stack.pop();\n\n        var z2 = 1 << z,\n            id = toID(z, x, y),\n            tile = this.tiles[id],\n            tileTolerance = z === options.maxZoom ? 0 : options.tolerance / (z2 * options.extent);\n\n        if (!tile) {\n            if (debug > 1) console.time('creation');\n\n            tile = this.tiles[id] = createTile(features, z2, x, y, tileTolerance, z === options.maxZoom);\n            this.tileCoords.push({z: z, x: x, y: y});\n\n            if (debug) {\n                if (debug > 1) {\n                    console.log('tile z%d-%d-%d (features: %d, points: %d, simplified: %d)',\n                        z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified);\n                    console.timeEnd('creation');\n                }\n                var key = 'z' + z;\n                this.stats[key] = (this.stats[key] || 0) + 1;\n                this.total++;\n            }\n        }\n\n        // save reference to original geometry in tile so that we can drill down later if we stop now\n        tile.source = features;\n\n        // if it's the first-pass tiling\n        if (!cz) {\n            // stop tiling if we reached max zoom, or if the tile is too simple\n            if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints) continue;\n\n        // if a drilldown to a specific tile\n        } else {\n            // stop tiling if we reached base zoom or our target tile zoom\n            if (z === options.maxZoom || z === cz) continue;\n\n            // stop tiling if it's not an ancestor of the target tile\n            var m = 1 << (cz - z);\n            if (x !== Math.floor(cx / m) || y !== Math.floor(cy / m)) continue;\n        }\n\n        // stop tiling if the tile is solid clipped square\n        if (!options.solidChildren && isClippedSquare(tile, options.extent, options.buffer)) {\n            if (cz) solid = z; // and remember the zoom if we're drilling down\n            continue;\n        }\n\n        // if we slice further down, no need to keep source geometry\n        tile.source = null;\n\n        if (debug > 1) console.time('clipping');\n\n        // values we'll use for clipping\n        var k1 = 0.5 * options.buffer / options.extent,\n            k2 = 0.5 - k1,\n            k3 = 0.5 + k1,\n            k4 = 1 + k1,\n            tl, bl, tr, br, left, right;\n\n        tl = bl = tr = br = null;\n\n        left  = clip(features, z2, x - k1, x + k3, 0, intersectX, tile.min[0], tile.max[0]);\n        right = clip(features, z2, x + k2, x + k4, 0, intersectX, tile.min[0], tile.max[0]);\n\n        if (left) {\n            tl = clip(left, z2, y - k1, y + k3, 1, intersectY, tile.min[1], tile.max[1]);\n            bl = clip(left, z2, y + k2, y + k4, 1, intersectY, tile.min[1], tile.max[1]);\n        }\n\n        if (right) {\n            tr = clip(right, z2, y - k1, y + k3, 1, intersectY, tile.min[1], tile.max[1]);\n            br = clip(right, z2, y + k2, y + k4, 1, intersectY, tile.min[1], tile.max[1]);\n        }\n\n        if (debug > 1) console.timeEnd('clipping');\n\n        if (tl) stack.push(tl, z + 1, x * 2,     y * 2);\n        if (bl) stack.push(bl, z + 1, x * 2,     y * 2 + 1);\n        if (tr) stack.push(tr, z + 1, x * 2 + 1, y * 2);\n        if (br) stack.push(br, z + 1, x * 2 + 1, y * 2 + 1);\n    }\n\n    return solid;\n};\n\nGeoJSONVT.prototype.getTile = function (z, x, y) {\n    var options = this.options,\n        extent = options.extent,\n        debug = options.debug;\n\n    var z2 = 1 << z;\n    x = ((x % z2) + z2) % z2; // wrap tile x coordinate\n\n    var id = toID(z, x, y);\n    if (this.tiles[id]) return transform.tile(this.tiles[id], extent);\n\n    if (debug > 1) console.log('drilling down to z%d-%d-%d', z, x, y);\n\n    var z0 = z,\n        x0 = x,\n        y0 = y,\n        parent;\n\n    while (!parent && z0 > 0) {\n        z0--;\n        x0 = Math.floor(x0 / 2);\n        y0 = Math.floor(y0 / 2);\n        parent = this.tiles[toID(z0, x0, y0)];\n    }\n\n    if (!parent || !parent.source) return null;\n\n    // if we found a parent tile containing the original geometry, we can drill down from it\n    if (debug > 1) console.log('found parent tile z%d-%d-%d', z0, x0, y0);\n\n    // it parent tile is a solid clipped square, return it instead since it's identical\n    if (isClippedSquare(parent, extent, options.buffer)) return transform.tile(parent, extent);\n\n    if (debug > 1) console.time('drilling down');\n    var solid = this.splitTile(parent.source, z0, x0, y0, z, x, y);\n    if (debug > 1) console.timeEnd('drilling down');\n\n    // one of the parent tiles was a solid clipped square\n    if (solid !== null) {\n        var m = 1 << (z - solid);\n        id = toID(solid, Math.floor(x / m), Math.floor(y / m));\n    }\n\n    return this.tiles[id] ? transform.tile(this.tiles[id], extent) : null;\n};\n\nfunction toID(z, x, y) {\n    return (((1 << z) * y + x) * 32) + z;\n}\n\nfunction intersectX(a, b, x) {\n    return [x, (x - a[0]) * (b[1] - a[1]) / (b[0] - a[0]) + a[1], 1];\n}\nfunction intersectY(a, b, y) {\n    return [(y - a[1]) * (b[0] - a[0]) / (b[1] - a[1]) + a[0], y, 1];\n}\n\nfunction extend(dest, src) {\n    for (var i in src) dest[i] = src[i];\n    return dest;\n}\n\n// checks whether a tile is a whole-area fill after clipping; if it is, there's no sense slicing it further\nfunction isClippedSquare(tile, extent, buffer) {\n\n    var features = tile.source;\n    if (features.length !== 1) return false;\n\n    var feature = features[0];\n    if (feature.type !== 3 || feature.geometry.length > 1) return false;\n\n    var len = feature.geometry[0].length;\n    if (len !== 5) return false;\n\n    for (var i = 0; i < len; i++) {\n        var p = transform.point(feature.geometry[0][i], extent, tile.z2, tile.x, tile.y);\n        if ((p[0] !== -buffer && p[0] !== extent + buffer) ||\n            (p[1] !== -buffer && p[1] !== extent + buffer)) return false;\n    }\n\n    return true;\n}\n","'use strict';\n\nmodule.exports = simplify;\n\n// calculate simplification data using optimized Douglas-Peucker algorithm\n\nfunction simplify(points, tolerance) {\n\n    var sqTolerance = tolerance * tolerance,\n        len = points.length,\n        first = 0,\n        last = len - 1,\n        stack = [],\n        i, maxSqDist, sqDist, index;\n\n    // always retain the endpoints (1 is the max value)\n    points[first][2] = 1;\n    points[last][2] = 1;\n\n    // avoid recursion by using a stack\n    while (last) {\n\n        maxSqDist = 0;\n\n        for (i = first + 1; i < last; i++) {\n            sqDist = getSqSegDist(points[i], points[first], points[last]);\n\n            if (sqDist > maxSqDist) {\n                index = i;\n                maxSqDist = sqDist;\n            }\n        }\n\n        if (maxSqDist > sqTolerance) {\n            points[index][2] = maxSqDist; // save the point importance in squared pixels as a z coordinate\n            stack.push(first);\n            stack.push(index);\n            first = index;\n\n        } else {\n            last = stack.pop();\n            first = stack.pop();\n        }\n    }\n}\n\n// square distance from a point to a segment\nfunction getSqSegDist(p, a, b) {\n\n    var x = a[0], y = a[1],\n        bx = b[0], by = b[1],\n        px = p[0], py = p[1],\n        dx = bx - x,\n        dy = by - y;\n\n    if (dx !== 0 || dy !== 0) {\n\n        var t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);\n\n        if (t > 1) {\n            x = bx;\n            y = by;\n\n        } else if (t > 0) {\n            x += dx * t;\n            y += dy * t;\n        }\n    }\n\n    dx = px - x;\n    dy = py - y;\n\n    return dx * dx + dy * dy;\n}\n","'use strict';\n\nmodule.exports = createTile;\n\nfunction createTile(features, z2, tx, ty, tolerance, noSimplify) {\n    var tile = {\n        features: [],\n        numPoints: 0,\n        numSimplified: 0,\n        numFeatures: 0,\n        source: null,\n        x: tx,\n        y: ty,\n        z2: z2,\n        transformed: false,\n        min: [2, 1],\n        max: [-1, 0]\n    };\n    for (var i = 0; i < features.length; i++) {\n        tile.numFeatures++;\n        addFeature(tile, features[i], tolerance, noSimplify);\n\n        var min = features[i].min,\n            max = features[i].max;\n\n        if (min[0] < tile.min[0]) tile.min[0] = min[0];\n        if (min[1] < tile.min[1]) tile.min[1] = min[1];\n        if (max[0] > tile.max[0]) tile.max[0] = max[0];\n        if (max[1] > tile.max[1]) tile.max[1] = max[1];\n    }\n    return tile;\n}\n\nfunction addFeature(tile, feature, tolerance, noSimplify) {\n\n    var geom = feature.geometry,\n        type = feature.type,\n        simplified = [],\n        sqTolerance = tolerance * tolerance,\n        i, j, ring, p;\n\n    if (type === 1) {\n        for (i = 0; i < geom.length; i++) {\n            simplified.push(geom[i]);\n            tile.numPoints++;\n            tile.numSimplified++;\n        }\n\n    } else {\n\n        // simplify and transform projected coordinates for tile geometry\n        for (i = 0; i < geom.length; i++) {\n            ring = geom[i];\n\n            // filter out tiny polylines & polygons\n            if (!noSimplify && ((type === 2 && ring.dist < tolerance) ||\n                                (type === 3 && ring.area < sqTolerance))) {\n                tile.numPoints += ring.length;\n                continue;\n            }\n\n            var simplifiedRing = [];\n\n            for (j = 0; j < ring.length; j++) {\n                p = ring[j];\n                // keep points with importance > tolerance\n                if (noSimplify || p[2] > sqTolerance) {\n                    simplifiedRing.push(p);\n                    tile.numSimplified++;\n                }\n                tile.numPoints++;\n            }\n\n            simplified.push(simplifiedRing);\n        }\n    }\n\n    if (simplified.length) {\n        tile.features.push({\n            geometry: simplified,\n            type: type,\n            tags: feature.tags || null\n        });\n    }\n}\n","'use strict';\n\nexports.tile = transformTile;\nexports.point = transformPoint;\n\n// Transforms the coordinates of each feature in the given tile from\n// mercator-projected space into (extent x extent) tile space.\nfunction transformTile(tile, extent) {\n    if (tile.transformed) return tile;\n\n    var z2 = tile.z2,\n        tx = tile.x,\n        ty = tile.y,\n        i, j, k;\n\n    for (i = 0; i < tile.features.length; i++) {\n        var feature = tile.features[i],\n            geom = feature.geometry,\n            type = feature.type;\n\n        if (type === 1) {\n            for (j = 0; j < geom.length; j++) geom[j] = transformPoint(geom[j], extent, z2, tx, ty);\n\n        } else {\n            for (j = 0; j < geom.length; j++) {\n                var ring = geom[j];\n                for (k = 0; k < ring.length; k++) ring[k] = transformPoint(ring[k], extent, z2, tx, ty);\n            }\n        }\n    }\n\n    tile.transformed = true;\n\n    return tile;\n}\n\nfunction transformPoint(p, extent, z2, tx, ty) {\n    var x = Math.round(extent * (p[0] * z2 - tx)),\n        y = Math.round(extent * (p[1] * z2 - ty));\n    return [x, y];\n}\n","'use strict';\n\nvar clip = require('./clip');\n\nmodule.exports = wrap;\n\nfunction wrap(features, buffer, intersectX) {\n    var merged = features,\n        left  = clip(features, 1, -1 - buffer, buffer,     0, intersectX, -1, 2), // left world copy\n        right = clip(features, 1,  1 - buffer, 2 + buffer, 0, intersectX, -1, 2); // right world copy\n\n    if (left || right) {\n        merged = clip(features, 1, -buffer, 1 + buffer, 0, intersectX, -1, 2); // center world copy\n\n        if (left) merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center\n        if (right) merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center\n    }\n\n    return merged;\n}\n\nfunction shiftFeatureCoords(features, offset) {\n    var newFeatures = [];\n\n    for (var i = 0; i < features.length; i++) {\n        var feature = features[i],\n            type = feature.type;\n\n        var newGeometry;\n\n        if (type === 1) {\n            newGeometry = shiftCoords(feature.geometry, offset);\n        } else {\n            newGeometry = [];\n            for (var j = 0; j < feature.geometry.length; j++) {\n                newGeometry.push(shiftCoords(feature.geometry[j], offset));\n            }\n        }\n\n        newFeatures.push({\n            geometry: newGeometry,\n            type: type,\n            tags: feature.tags,\n            min: [feature.min[0] + offset, feature.min[1]],\n            max: [feature.max[0] + offset, feature.max[1]]\n        });\n    }\n\n    return newFeatures;\n}\n\nfunction shiftCoords(points, offset) {\n    var newPoints = [];\n    newPoints.area = points.area;\n    newPoints.dist = points.dist;\n\n    for (var i = 0; i < points.length; i++) {\n        newPoints.push([points[i][0] + offset, points[i][1], points[i][2]]);\n    }\n    return newPoints;\n}\n","'use strict';\n\n// lightweight Buffer shim for pbf browser build\n// based on code from github.com/feross/buffer (MIT-licensed)\n\nmodule.exports = Buffer;\n\nvar ieee754 = require('ieee754');\n\nvar BufferMethods;\n\nfunction Buffer(length) {\n    var arr;\n    if (length && length.length) {\n        arr = length;\n        length = arr.length;\n    }\n    var buf = new Uint8Array(length || 0);\n    if (arr) buf.set(arr);\n\n    buf.readUInt32LE = BufferMethods.readUInt32LE;\n    buf.writeUInt32LE = BufferMethods.writeUInt32LE;\n    buf.readInt32LE = BufferMethods.readInt32LE;\n    buf.writeInt32LE = BufferMethods.writeInt32LE;\n    buf.readFloatLE = BufferMethods.readFloatLE;\n    buf.writeFloatLE = BufferMethods.writeFloatLE;\n    buf.readDoubleLE = BufferMethods.readDoubleLE;\n    buf.writeDoubleLE = BufferMethods.writeDoubleLE;\n    buf.toString = BufferMethods.toString;\n    buf.write = BufferMethods.write;\n    buf.slice = BufferMethods.slice;\n    buf.copy = BufferMethods.copy;\n\n    buf._isBuffer = true;\n    return buf;\n}\n\nvar lastStr, lastStrEncoded;\n\nBufferMethods = {\n    readUInt32LE: function(pos) {\n        return ((this[pos]) |\n            (this[pos + 1] << 8) |\n            (this[pos + 2] << 16)) +\n            (this[pos + 3] * 0x1000000);\n    },\n\n    writeUInt32LE: function(val, pos) {\n        this[pos] = val;\n        this[pos + 1] = (val >>> 8);\n        this[pos + 2] = (val >>> 16);\n        this[pos + 3] = (val >>> 24);\n    },\n\n    readInt32LE: function(pos) {\n        return ((this[pos]) |\n            (this[pos + 1] << 8) |\n            (this[pos + 2] << 16)) +\n            (this[pos + 3] << 24);\n    },\n\n    readFloatLE:  function(pos) { return ieee754.read(this, pos, true, 23, 4); },\n    readDoubleLE: function(pos) { return ieee754.read(this, pos, true, 52, 8); },\n\n    writeFloatLE:  function(val, pos) { return ieee754.write(this, val, pos, true, 23, 4); },\n    writeDoubleLE: function(val, pos) { return ieee754.write(this, val, pos, true, 52, 8); },\n\n    toString: function(encoding, start, end) {\n        var str = '',\n            tmp = '';\n\n        start = start || 0;\n        end = Math.min(this.length, end || this.length);\n\n        for (var i = start; i < end; i++) {\n            var ch = this[i];\n            if (ch <= 0x7F) {\n                str += decodeURIComponent(tmp) + String.fromCharCode(ch);\n                tmp = '';\n            } else {\n                tmp += '%' + ch.toString(16);\n            }\n        }\n\n        str += decodeURIComponent(tmp);\n\n        return str;\n    },\n\n    write: function(str, pos) {\n        var bytes = str === lastStr ? lastStrEncoded : encodeString(str);\n        for (var i = 0; i < bytes.length; i++) {\n            this[pos + i] = bytes[i];\n        }\n    },\n\n    slice: function(start, end) {\n        return this.subarray(start, end);\n    },\n\n    copy: function(buf, pos) {\n        pos = pos || 0;\n        for (var i = 0; i < this.length; i++) {\n            buf[pos + i] = this[i];\n        }\n    }\n};\n\nBufferMethods.writeInt32LE = BufferMethods.writeUInt32LE;\n\nBuffer.byteLength = function(str) {\n    lastStr = str;\n    lastStrEncoded = encodeString(str);\n    return lastStrEncoded.length;\n};\n\nBuffer.isBuffer = function(buf) {\n    return !!(buf && buf._isBuffer);\n};\n\nfunction encodeString(str) {\n    var length = str.length,\n        bytes = [];\n\n    for (var i = 0, c, lead; i < length; i++) {\n        c = str.charCodeAt(i); // code point\n\n        if (c > 0xD7FF && c < 0xE000) {\n\n            if (lead) {\n                if (c < 0xDC00) {\n                    bytes.push(0xEF, 0xBF, 0xBD);\n                    lead = c;\n                    continue;\n\n                } else {\n                    c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;\n                    lead = null;\n                }\n\n            } else {\n                if (c > 0xDBFF || (i + 1 === length)) bytes.push(0xEF, 0xBF, 0xBD);\n                else lead = c;\n\n                continue;\n            }\n\n        } else if (lead) {\n            bytes.push(0xEF, 0xBF, 0xBD);\n            lead = null;\n        }\n\n        if (c < 0x80) bytes.push(c);\n        else if (c < 0x800) bytes.push(c >> 0x6 | 0xC0, c & 0x3F | 0x80);\n        else if (c < 0x10000) bytes.push(c >> 0xC | 0xE0, c >> 0x6 & 0x3F | 0x80, c & 0x3F | 0x80);\n        else bytes.push(c >> 0x12 | 0xF0, c >> 0xC & 0x3F | 0x80, c >> 0x6 & 0x3F | 0x80, c & 0x3F | 0x80);\n    }\n    return bytes;\n}\n","(function (global){\n'use strict';\n\nmodule.exports = Pbf;\n\nvar Buffer = global.Buffer || require('./buffer');\n\nfunction Pbf(buf) {\n    this.buf = !Buffer.isBuffer(buf) ? new Buffer(buf || 0) : buf;\n    this.pos = 0;\n    this.length = this.buf.length;\n}\n\nPbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum\nPbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64\nPbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields\nPbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32\n\nvar SHIFT_LEFT_32 = (1 << 16) * (1 << 16),\n    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32,\n    POW_2_63 = Math.pow(2, 63);\n\nPbf.prototype = {\n\n    destroy: function() {\n        this.buf = null;\n    },\n\n    // === READING =================================================================\n\n    readFields: function(readField, result, end) {\n        end = end || this.length;\n\n        while (this.pos < end) {\n            var val = this.readVarint(),\n                tag = val >> 3,\n                startPos = this.pos;\n\n            readField(tag, result, this);\n\n            if (this.pos === startPos) this.skip(val);\n        }\n        return result;\n    },\n\n    readMessage: function(readField, result) {\n        return this.readFields(readField, result, this.readVarint() + this.pos);\n    },\n\n    readFixed32: function() {\n        var val = this.buf.readUInt32LE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readSFixed32: function() {\n        var val = this.buf.readInt32LE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)\n\n    readFixed64: function() {\n        var val = this.buf.readUInt32LE(this.pos) + this.buf.readUInt32LE(this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readSFixed64: function() {\n        var val = this.buf.readUInt32LE(this.pos) + this.buf.readInt32LE(this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readFloat: function() {\n        var val = this.buf.readFloatLE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readDouble: function() {\n        var val = this.buf.readDoubleLE(this.pos);\n        this.pos += 8;\n        return val;\n    },\n\n    readVarint: function() {\n        var buf = this.buf,\n            val, b, b0, b1, b2, b3;\n\n        b0 = buf[this.pos++]; if (b0 < 0x80) return b0;                 b0 = b0 & 0x7f;\n        b1 = buf[this.pos++]; if (b1 < 0x80) return b0 | b1 << 7;       b1 = (b1 & 0x7f) << 7;\n        b2 = buf[this.pos++]; if (b2 < 0x80) return b0 | b1 | b2 << 14; b2 = (b2 & 0x7f) << 14;\n        b3 = buf[this.pos++]; if (b3 < 0x80) return b0 | b1 | b2 | b3 << 21;\n\n        val = b0 | b1 | b2 | (b3 & 0x7f) << 21;\n\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x10000000;         if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x800000000;        if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x40000000000;      if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x2000000000000;    if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x100000000000000;  if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x8000000000000000; if (b < 0x80) return val;\n\n        throw new Error('Expected varint not more than 10 bytes');\n    },\n\n    readVarint64: function() {\n        var startPos = this.pos,\n            val = this.readVarint();\n\n        if (val < POW_2_63) return val;\n\n        var pos = this.pos - 2;\n        while (this.buf[pos] === 0xff) pos--;\n        if (pos < startPos) pos = startPos;\n\n        val = 0;\n        for (var i = 0; i < pos - startPos + 1; i++) {\n            var b = ~this.buf[startPos + i] & 0x7f;\n            val += i < 4 ? b << i * 7 : b * Math.pow(2, i * 7);\n        }\n\n        return -val - 1;\n    },\n\n    readSVarint: function() {\n        var num = this.readVarint();\n        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding\n    },\n\n    readBoolean: function() {\n        return Boolean(this.readVarint());\n    },\n\n    readString: function() {\n        var end = this.readVarint() + this.pos,\n            str = this.buf.toString('utf8', this.pos, end);\n        this.pos = end;\n        return str;\n    },\n\n    readBytes: function() {\n        var end = this.readVarint() + this.pos,\n            buffer = this.buf.slice(this.pos, end);\n        this.pos = end;\n        return buffer;\n    },\n\n    // verbose for performance reasons; doesn't affect gzipped size\n\n    readPackedVarint: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readVarint());\n        return arr;\n    },\n    readPackedSVarint: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSVarint());\n        return arr;\n    },\n    readPackedBoolean: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readBoolean());\n        return arr;\n    },\n    readPackedFloat: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFloat());\n        return arr;\n    },\n    readPackedDouble: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readDouble());\n        return arr;\n    },\n    readPackedFixed32: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFixed32());\n        return arr;\n    },\n    readPackedSFixed32: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSFixed32());\n        return arr;\n    },\n    readPackedFixed64: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFixed64());\n        return arr;\n    },\n    readPackedSFixed64: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSFixed64());\n        return arr;\n    },\n\n    skip: function(val) {\n        var type = val & 0x7;\n        if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}\n        else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;\n        else if (type === Pbf.Fixed32) this.pos += 4;\n        else if (type === Pbf.Fixed64) this.pos += 8;\n        else throw new Error('Unimplemented type: ' + type);\n    },\n\n    // === WRITING =================================================================\n\n    writeTag: function(tag, type) {\n        this.writeVarint((tag << 3) | type);\n    },\n\n    realloc: function(min) {\n        var length = this.length || 16;\n\n        while (length < this.pos + min) length *= 2;\n\n        if (length !== this.length) {\n            var buf = new Buffer(length);\n            this.buf.copy(buf);\n            this.buf = buf;\n            this.length = length;\n        }\n    },\n\n    finish: function() {\n        this.length = this.pos;\n        this.pos = 0;\n        return this.buf.slice(0, this.length);\n    },\n\n    writeFixed32: function(val) {\n        this.realloc(4);\n        this.buf.writeUInt32LE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeSFixed32: function(val) {\n        this.realloc(4);\n        this.buf.writeInt32LE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeFixed64: function(val) {\n        this.realloc(8);\n        this.buf.writeInt32LE(val & -1, this.pos);\n        this.buf.writeUInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeSFixed64: function(val) {\n        this.realloc(8);\n        this.buf.writeInt32LE(val & -1, this.pos);\n        this.buf.writeInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeVarint: function(val) {\n        val = +val;\n\n        if (val <= 0x7f) {\n            this.realloc(1);\n            this.buf[this.pos++] = val;\n\n        } else if (val <= 0x3fff) {\n            this.realloc(2);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f);\n\n        } else if (val <= 0x1fffff) {\n            this.realloc(3);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 14) & 0x7f);\n\n        } else if (val <= 0xfffffff) {\n            this.realloc(4);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 14) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 21) & 0x7f);\n\n        } else {\n            var pos = this.pos;\n            while (val >= 0x80) {\n                this.realloc(1);\n                this.buf[this.pos++] = (val & 0xff) | 0x80;\n                val /= 0x80;\n            }\n            this.realloc(1);\n            this.buf[this.pos++] = val | 0;\n            if (this.pos - pos > 10) throw new Error('Given varint doesn\\'t fit into 10 bytes');\n        }\n    },\n\n    writeSVarint: function(val) {\n        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);\n    },\n\n    writeBoolean: function(val) {\n        this.writeVarint(Boolean(val));\n    },\n\n    writeString: function(str) {\n        str = String(str);\n        var bytes = Buffer.byteLength(str);\n        this.writeVarint(bytes);\n        this.realloc(bytes);\n        this.buf.write(str, this.pos);\n        this.pos += bytes;\n    },\n\n    writeFloat: function(val) {\n        this.realloc(4);\n        this.buf.writeFloatLE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeDouble: function(val) {\n        this.realloc(8);\n        this.buf.writeDoubleLE(val, this.pos);\n        this.pos += 8;\n    },\n\n    writeBytes: function(buffer) {\n        var len = buffer.length;\n        this.writeVarint(len);\n        this.realloc(len);\n        for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];\n    },\n\n    writeRawMessage: function(fn, obj) {\n        this.pos++; // reserve 1 byte for short message length\n\n        // write the message directly to the buffer and see how much was written\n        var startPos = this.pos;\n        fn(obj, this);\n        var len = this.pos - startPos;\n\n        var varintLen =\n            len <= 0x7f ? 1 :\n            len <= 0x3fff ? 2 :\n            len <= 0x1fffff ? 3 :\n            len <= 0xfffffff ? 4 : Math.ceil(Math.log(len) / (Math.LN2 * 7));\n\n        // if 1 byte isn't enough for encoding message length, shift the data to the right\n        if (varintLen > 1) {\n            this.realloc(varintLen - 1);\n            for (var i = this.pos - 1; i >= startPos; i--) this.buf[i + varintLen - 1] = this.buf[i];\n        }\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeMessage: function(tag, fn, obj) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeRawMessage(fn, obj);\n    },\n\n    writePackedVarint:   function(tag, arr) { this.writeMessage(tag, writePackedVarint, arr);   },\n    writePackedSVarint:  function(tag, arr) { this.writeMessage(tag, writePackedSVarint, arr);  },\n    writePackedBoolean:  function(tag, arr) { this.writeMessage(tag, writePackedBoolean, arr);  },\n    writePackedFloat:    function(tag, arr) { this.writeMessage(tag, writePackedFloat, arr);    },\n    writePackedDouble:   function(tag, arr) { this.writeMessage(tag, writePackedDouble, arr);   },\n    writePackedFixed32:  function(tag, arr) { this.writeMessage(tag, writePackedFixed32, arr);  },\n    writePackedSFixed32: function(tag, arr) { this.writeMessage(tag, writePackedSFixed32, arr); },\n    writePackedFixed64:  function(tag, arr) { this.writeMessage(tag, writePackedFixed64, arr);  },\n    writePackedSFixed64: function(tag, arr) { this.writeMessage(tag, writePackedSFixed64, arr); },\n\n    writeBytesField: function(tag, buffer) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeBytes(buffer);\n    },\n    writeFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFixed32(val);\n    },\n    writeSFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeSFixed32(val);\n    },\n    writeFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeFixed64(val);\n    },\n    writeSFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeSFixed64(val);\n    },\n    writeVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeVarint(val);\n    },\n    writeSVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeSVarint(val);\n    },\n    writeStringField: function(tag, str) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeString(str);\n    },\n    writeFloatField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFloat(val);\n    },\n    writeDoubleField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeDouble(val);\n    },\n    writeBooleanField: function(tag, val) {\n        this.writeVarintField(tag, Boolean(val));\n    }\n};\n\nfunction writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }\nfunction writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }\nfunction writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }\nfunction writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }\nfunction writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }\nfunction writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }\nfunction writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }\nfunction writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }\nfunction writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/pbf/index.js"],"names":[],"mappings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file":"generated.js","sourceRoot":"","sourcesContent":["'use strict';\n\nmodule.exports = Pbf;\n\nvar Buffer = global.Buffer || require('./buffer');\n\nfunction Pbf(buf) {\n    this.buf = !Buffer.isBuffer(buf) ? new Buffer(buf || 0) : buf;\n    this.pos = 0;\n    this.length = this.buf.length;\n}\n\nPbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum\nPbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64\nPbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields\nPbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32\n\nvar SHIFT_LEFT_32 = (1 << 16) * (1 << 16),\n    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32,\n    POW_2_63 = Math.pow(2, 63);\n\nPbf.prototype = {\n\n    destroy: function() {\n        this.buf = null;\n    },\n\n    // === READING =================================================================\n\n    readFields: function(readField, result, end) {\n        end = end || this.length;\n\n        while (this.pos < end) {\n            var val = this.readVarint(),\n                tag = val >> 3,\n                startPos = this.pos;\n\n            readField(tag, result, this);\n\n            if (this.pos === startPos) this.skip(val);\n        }\n        return result;\n    },\n\n    readMessage: function(readField, result) {\n        return this.readFields(readField, result, this.readVarint() + this.pos);\n    },\n\n    readFixed32: function() {\n        var val = this.buf.readUInt32LE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readSFixed32: function() {\n        var val = this.buf.readInt32LE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)\n\n    readFixed64: function() {\n        var val = this.buf.readUInt32LE(this.pos) + this.buf.readUInt32LE(this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readSFixed64: function() {\n        var val = this.buf.readUInt32LE(this.pos) + this.buf.readInt32LE(this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readFloat: function() {\n        var val = this.buf.readFloatLE(this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readDouble: function() {\n        var val = this.buf.readDoubleLE(this.pos);\n        this.pos += 8;\n        return val;\n    },\n\n    readVarint: function() {\n        var buf = this.buf,\n            val, b, b0, b1, b2, b3;\n\n        b0 = buf[this.pos++]; if (b0 < 0x80) return b0;                 b0 = b0 & 0x7f;\n        b1 = buf[this.pos++]; if (b1 < 0x80) return b0 | b1 << 7;       b1 = (b1 & 0x7f) << 7;\n        b2 = buf[this.pos++]; if (b2 < 0x80) return b0 | b1 | b2 << 14; b2 = (b2 & 0x7f) << 14;\n        b3 = buf[this.pos++]; if (b3 < 0x80) return b0 | b1 | b2 | b3 << 21;\n\n        val = b0 | b1 | b2 | (b3 & 0x7f) << 21;\n\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x10000000;         if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x800000000;        if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x40000000000;      if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x2000000000000;    if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x100000000000000;  if (b < 0x80) return val;\n        b = buf[this.pos++]; val += (b & 0x7f) * 0x8000000000000000; if (b < 0x80) return val;\n\n        throw new Error('Expected varint not more than 10 bytes');\n    },\n\n    readVarint64: function() {\n        var startPos = this.pos,\n            val = this.readVarint();\n\n        if (val < POW_2_63) return val;\n\n        var pos = this.pos - 2;\n        while (this.buf[pos] === 0xff) pos--;\n        if (pos < startPos) pos = startPos;\n\n        val = 0;\n        for (var i = 0; i < pos - startPos + 1; i++) {\n            var b = ~this.buf[startPos + i] & 0x7f;\n            val += i < 4 ? b << i * 7 : b * Math.pow(2, i * 7);\n        }\n\n        return -val - 1;\n    },\n\n    readSVarint: function() {\n        var num = this.readVarint();\n        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding\n    },\n\n    readBoolean: function() {\n        return Boolean(this.readVarint());\n    },\n\n    readString: function() {\n        var end = this.readVarint() + this.pos,\n            str = this.buf.toString('utf8', this.pos, end);\n        this.pos = end;\n        return str;\n    },\n\n    readBytes: function() {\n        var end = this.readVarint() + this.pos,\n            buffer = this.buf.slice(this.pos, end);\n        this.pos = end;\n        return buffer;\n    },\n\n    // verbose for performance reasons; doesn't affect gzipped size\n\n    readPackedVarint: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readVarint());\n        return arr;\n    },\n    readPackedSVarint: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSVarint());\n        return arr;\n    },\n    readPackedBoolean: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readBoolean());\n        return arr;\n    },\n    readPackedFloat: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFloat());\n        return arr;\n    },\n    readPackedDouble: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readDouble());\n        return arr;\n    },\n    readPackedFixed32: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFixed32());\n        return arr;\n    },\n    readPackedSFixed32: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSFixed32());\n        return arr;\n    },\n    readPackedFixed64: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readFixed64());\n        return arr;\n    },\n    readPackedSFixed64: function() {\n        var end = this.readVarint() + this.pos, arr = [];\n        while (this.pos < end) arr.push(this.readSFixed64());\n        return arr;\n    },\n\n    skip: function(val) {\n        var type = val & 0x7;\n        if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}\n        else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;\n        else if (type === Pbf.Fixed32) this.pos += 4;\n        else if (type === Pbf.Fixed64) this.pos += 8;\n        else throw new Error('Unimplemented type: ' + type);\n    },\n\n    // === WRITING =================================================================\n\n    writeTag: function(tag, type) {\n        this.writeVarint((tag << 3) | type);\n    },\n\n    realloc: function(min) {\n        var length = this.length || 16;\n\n        while (length < this.pos + min) length *= 2;\n\n        if (length !== this.length) {\n            var buf = new Buffer(length);\n            this.buf.copy(buf);\n            this.buf = buf;\n            this.length = length;\n        }\n    },\n\n    finish: function() {\n        this.length = this.pos;\n        this.pos = 0;\n        return this.buf.slice(0, this.length);\n    },\n\n    writeFixed32: function(val) {\n        this.realloc(4);\n        this.buf.writeUInt32LE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeSFixed32: function(val) {\n        this.realloc(4);\n        this.buf.writeInt32LE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeFixed64: function(val) {\n        this.realloc(8);\n        this.buf.writeInt32LE(val & -1, this.pos);\n        this.buf.writeUInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeSFixed64: function(val) {\n        this.realloc(8);\n        this.buf.writeInt32LE(val & -1, this.pos);\n        this.buf.writeInt32LE(Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeVarint: function(val) {\n        val = +val;\n\n        if (val <= 0x7f) {\n            this.realloc(1);\n            this.buf[this.pos++] = val;\n\n        } else if (val <= 0x3fff) {\n            this.realloc(2);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f);\n\n        } else if (val <= 0x1fffff) {\n            this.realloc(3);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 14) & 0x7f);\n\n        } else if (val <= 0xfffffff) {\n            this.realloc(4);\n            this.buf[this.pos++] = ((val >>> 0) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 7) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 14) & 0x7f) | 0x80;\n            this.buf[this.pos++] = ((val >>> 21) & 0x7f);\n\n        } else {\n            var pos = this.pos;\n            while (val >= 0x80) {\n                this.realloc(1);\n                this.buf[this.pos++] = (val & 0xff) | 0x80;\n                val /= 0x80;\n            }\n            this.realloc(1);\n            this.buf[this.pos++] = val | 0;\n            if (this.pos - pos > 10) throw new Error('Given varint doesn\\'t fit into 10 bytes');\n        }\n    },\n\n    writeSVarint: function(val) {\n        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);\n    },\n\n    writeBoolean: function(val) {\n        this.writeVarint(Boolean(val));\n    },\n\n    writeString: function(str) {\n        str = String(str);\n        var bytes = Buffer.byteLength(str);\n        this.writeVarint(bytes);\n        this.realloc(bytes);\n        this.buf.write(str, this.pos);\n        this.pos += bytes;\n    },\n\n    writeFloat: function(val) {\n        this.realloc(4);\n        this.buf.writeFloatLE(val, this.pos);\n        this.pos += 4;\n    },\n\n    writeDouble: function(val) {\n        this.realloc(8);\n        this.buf.writeDoubleLE(val, this.pos);\n        this.pos += 8;\n    },\n\n    writeBytes: function(buffer) {\n        var len = buffer.length;\n        this.writeVarint(len);\n        this.realloc(len);\n        for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];\n    },\n\n    writeRawMessage: function(fn, obj) {\n        this.pos++; // reserve 1 byte for short message length\n\n        // write the message directly to the buffer and see how much was written\n        var startPos = this.pos;\n        fn(obj, this);\n        var len = this.pos - startPos;\n\n        var varintLen =\n            len <= 0x7f ? 1 :\n            len <= 0x3fff ? 2 :\n            len <= 0x1fffff ? 3 :\n            len <= 0xfffffff ? 4 : Math.ceil(Math.log(len) / (Math.LN2 * 7));\n\n        // if 1 byte isn't enough for encoding message length, shift the data to the right\n        if (varintLen > 1) {\n            this.realloc(varintLen - 1);\n            for (var i = this.pos - 1; i >= startPos; i--) this.buf[i + varintLen - 1] = this.buf[i];\n        }\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeMessage: function(tag, fn, obj) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeRawMessage(fn, obj);\n    },\n\n    writePackedVarint:   function(tag, arr) { this.writeMessage(tag, writePackedVarint, arr);   },\n    writePackedSVarint:  function(tag, arr) { this.writeMessage(tag, writePackedSVarint, arr);  },\n    writePackedBoolean:  function(tag, arr) { this.writeMessage(tag, writePackedBoolean, arr);  },\n    writePackedFloat:    function(tag, arr) { this.writeMessage(tag, writePackedFloat, arr);    },\n    writePackedDouble:   function(tag, arr) { this.writeMessage(tag, writePackedDouble, arr);   },\n    writePackedFixed32:  function(tag, arr) { this.writeMessage(tag, writePackedFixed32, arr);  },\n    writePackedSFixed32: function(tag, arr) { this.writeMessage(tag, writePackedSFixed32, arr); },\n    writePackedFixed64:  function(tag, arr) { this.writeMessage(tag, writePackedFixed64, arr);  },\n    writePackedSFixed64: function(tag, arr) { this.writeMessage(tag, writePackedSFixed64, arr); },\n\n    writeBytesField: function(tag, buffer) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeBytes(buffer);\n    },\n    writeFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFixed32(val);\n    },\n    writeSFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeSFixed32(val);\n    },\n    writeFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeFixed64(val);\n    },\n    writeSFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeSFixed64(val);\n    },\n    writeVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeVarint(val);\n    },\n    writeSVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeSVarint(val);\n    },\n    writeStringField: function(tag, str) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeString(str);\n    },\n    writeFloatField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFloat(val);\n    },\n    writeDoubleField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeDouble(val);\n    },\n    writeBooleanField: function(tag, val) {\n        this.writeVarintField(tag, Boolean(val));\n    }\n};\n\nfunction writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }\nfunction writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }\nfunction writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }\nfunction writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }\nfunction writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }\nfunction writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }\nfunction writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }\nfunction writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }\nfunction writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }\n"]}","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","'use strict';\n\nmodule.exports = Point;\n\nfunction Point(x, y) {\n    this.x = x;\n    this.y = y;\n}\n\nPoint.prototype = {\n    clone: function() { return new Point(this.x, this.y); },\n\n    add:     function(p) { return this.clone()._add(p);     },\n    sub:     function(p) { return this.clone()._sub(p);     },\n    mult:    function(k) { return this.clone()._mult(k);    },\n    div:     function(k) { return this.clone()._div(k);     },\n    rotate:  function(a) { return this.clone()._rotate(a);  },\n    matMult: function(m) { return this.clone()._matMult(m); },\n    unit:    function() { return this.clone()._unit(); },\n    perp:    function() { return this.clone()._perp(); },\n    round:   function() { return this.clone()._round(); },\n\n    mag: function() {\n        return Math.sqrt(this.x * this.x + this.y * this.y);\n    },\n\n    equals: function(p) {\n        return this.x === p.x &&\n               this.y === p.y;\n    },\n\n    dist: function(p) {\n        return Math.sqrt(this.distSqr(p));\n    },\n\n    distSqr: function(p) {\n        var dx = p.x - this.x,\n            dy = p.y - this.y;\n        return dx * dx + dy * dy;\n    },\n\n    angle: function() {\n        return Math.atan2(this.y, this.x);\n    },\n\n    angleTo: function(b) {\n        return Math.atan2(this.y - b.y, this.x - b.x);\n    },\n\n    angleWith: function(b) {\n        return this.angleWithSep(b.x, b.y);\n    },\n\n    // Find the angle of the two vectors, solving the formula for the cross product a x b = |a||b|sin(θ) for θ.\n    angleWithSep: function(x, y) {\n        return Math.atan2(\n            this.x * y - this.y * x,\n            this.x * x + this.y * y);\n    },\n\n    _matMult: function(m) {\n        var x = m[0] * this.x + m[1] * this.y,\n            y = m[2] * this.x + m[3] * this.y;\n        this.x = x;\n        this.y = y;\n        return this;\n    },\n\n    _add: function(p) {\n        this.x += p.x;\n        this.y += p.y;\n        return this;\n    },\n\n    _sub: function(p) {\n        this.x -= p.x;\n        this.y -= p.y;\n        return this;\n    },\n\n    _mult: function(k) {\n        this.x *= k;\n        this.y *= k;\n        return this;\n    },\n\n    _div: function(k) {\n        this.x /= k;\n        this.y /= k;\n        return this;\n    },\n\n    _unit: function() {\n        this._div(this.mag());\n        return this;\n    },\n\n    _perp: function() {\n        var y = this.y;\n        this.y = this.x;\n        this.x = -y;\n        return this;\n    },\n\n    _rotate: function(angle) {\n        var cos = Math.cos(angle),\n            sin = Math.sin(angle),\n            x = cos * this.x - sin * this.y,\n            y = sin * this.x + cos * this.y;\n        this.x = x;\n        this.y = y;\n        return this;\n    },\n\n    _round: function() {\n        this.x = Math.round(this.x);\n        this.y = Math.round(this.y);\n        return this;\n    }\n};\n\n// constructs Point from an array if necessary\nPoint.convert = function (a) {\n    if (a instanceof Point) {\n        return a;\n    }\n    if (Array.isArray(a)) {\n        return new Point(a[0], a[1]);\n    }\n    return a;\n};\n","module.exports.VectorTile = require('./lib/vectortile.js');\nmodule.exports.VectorTileFeature = require('./lib/vectortilefeature.js');\nmodule.exports.VectorTileLayer = require('./lib/vectortilelayer.js');\n","'use strict';\n\nvar VectorTileLayer = require('./vectortilelayer');\n\nmodule.exports = VectorTile;\n\nfunction VectorTile(pbf, end) {\n    this.layers = pbf.readFields(readTile, {}, end);\n}\n\nfunction readTile(tag, layers, pbf) {\n    if (tag === 3) {\n        var layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);\n        if (layer.length) layers[layer.name] = layer;\n    }\n}\n\n","'use strict';\n\nvar Point = require('point-geometry');\n\nmodule.exports = VectorTileFeature;\n\nfunction VectorTileFeature(pbf, end, extent, keys, values) {\n    // Public\n    this.properties = {};\n    this.extent = extent;\n    this.type = 0;\n\n    // Private\n    this._pbf = pbf;\n    this._geometry = -1;\n    this._keys = keys;\n    this._values = values;\n\n    pbf.readFields(readFeature, this, end);\n}\n\nfunction readFeature(tag, feature, pbf) {\n    if (tag == 1) feature._id = pbf.readVarint();\n    else if (tag == 2) readTag(pbf, feature);\n    else if (tag == 3) feature.type = pbf.readVarint();\n    else if (tag == 4) feature._geometry = pbf.pos;\n}\n\nfunction readTag(pbf, feature) {\n    var end = pbf.readVarint() + pbf.pos;\n\n    while (pbf.pos < end) {\n        var key = feature._keys[pbf.readVarint()],\n            value = feature._values[pbf.readVarint()];\n        feature.properties[key] = value;\n    }\n}\n\nVectorTileFeature.types = ['Unknown', 'Point', 'LineString', 'Polygon'];\n\nVectorTileFeature.prototype.loadGeometry = function() {\n    var pbf = this._pbf;\n    pbf.pos = this._geometry;\n\n    var end = pbf.readVarint() + pbf.pos,\n        cmd = 1,\n        length = 0,\n        x = 0,\n        y = 0,\n        lines = [],\n        line;\n\n    while (pbf.pos < end) {\n        if (!length) {\n            var cmdLen = pbf.readVarint();\n            cmd = cmdLen & 0x7;\n            length = cmdLen >> 3;\n        }\n\n        length--;\n\n        if (cmd === 1 || cmd === 2) {\n            x += pbf.readSVarint();\n            y += pbf.readSVarint();\n\n            if (cmd === 1) { // moveTo\n                if (line) lines.push(line);\n                line = [];\n            }\n\n            line.push(new Point(x, y));\n\n        } else if (cmd === 7) {\n\n            // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90\n            if (line) {\n                line.push(line[0].clone()); // closePolygon\n            }\n\n        } else {\n            throw new Error('unknown command ' + cmd);\n        }\n    }\n\n    if (line) lines.push(line);\n\n    return lines;\n};\n\nVectorTileFeature.prototype.bbox = function() {\n    var pbf = this._pbf;\n    pbf.pos = this._geometry;\n\n    var end = pbf.readVarint() + pbf.pos,\n        cmd = 1,\n        length = 0,\n        x = 0,\n        y = 0,\n        x1 = Infinity,\n        x2 = -Infinity,\n        y1 = Infinity,\n        y2 = -Infinity;\n\n    while (pbf.pos < end) {\n        if (!length) {\n            var cmdLen = pbf.readVarint();\n            cmd = cmdLen & 0x7;\n            length = cmdLen >> 3;\n        }\n\n        length--;\n\n        if (cmd === 1 || cmd === 2) {\n            x += pbf.readSVarint();\n            y += pbf.readSVarint();\n            if (x < x1) x1 = x;\n            if (x > x2) x2 = x;\n            if (y < y1) y1 = y;\n            if (y > y2) y2 = y;\n\n        } else if (cmd !== 7) {\n            throw new Error('unknown command ' + cmd);\n        }\n    }\n\n    return [x1, y1, x2, y2];\n};\n\nVectorTileFeature.prototype.toGeoJSON = function(x, y, z) {\n    var size = this.extent * Math.pow(2, z),\n        x0 = this.extent * x,\n        y0 = this.extent * y,\n        coords = this.loadGeometry(),\n        type = VectorTileFeature.types[this.type];\n\n    for (var i = 0; i < coords.length; i++) {\n        var line = coords[i];\n        for (var j = 0; j < line.length; j++) {\n            var p = line[j], y2 = 180 - (p.y + y0) * 360 / size;\n            line[j] = [\n                (p.x + x0) * 360 / size - 180,\n                360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90\n            ];\n        }\n    }\n\n    if (type === 'Point' && coords.length === 1) {\n        coords = coords[0][0];\n    } else if (type === 'Point') {\n        coords = coords[0];\n        type = 'MultiPoint';\n    } else if (type === 'LineString' && coords.length === 1) {\n        coords = coords[0];\n    } else if (type === 'LineString') {\n        type = 'MultiLineString';\n    }\n\n    return {\n        type: \"Feature\",\n        geometry: {\n            type: type,\n            coordinates: coords\n        },\n        properties: this.properties\n    };\n};\n","'use strict';\n\nvar VectorTileFeature = require('./vectortilefeature.js');\n\nmodule.exports = VectorTileLayer;\n\nfunction VectorTileLayer(pbf, end) {\n    // Public\n    this.version = 1;\n    this.name = null;\n    this.extent = 4096;\n    this.length = 0;\n\n    // Private\n    this._pbf = pbf;\n    this._keys = [];\n    this._values = [];\n    this._features = [];\n\n    pbf.readFields(readLayer, this, end);\n\n    this.length = this._features.length;\n}\n\nfunction readLayer(tag, layer, pbf) {\n    if (tag === 15) layer.version = pbf.readVarint();\n    else if (tag === 1) layer.name = pbf.readString();\n    else if (tag === 5) layer.extent = pbf.readVarint();\n    else if (tag === 2) layer._features.push(pbf.pos);\n    else if (tag === 3) layer._keys.push(pbf.readString());\n    else if (tag === 4) layer._values.push(readValueMessage(pbf));\n}\n\nfunction readValueMessage(pbf) {\n    var value = null,\n        end = pbf.readVarint() + pbf.pos;\n\n    while (pbf.pos < end) {\n        var tag = pbf.readVarint() >> 3;\n\n        value = tag === 1 ? pbf.readString() :\n            tag === 2 ? pbf.readFloat() :\n            tag === 3 ? pbf.readDouble() :\n            tag === 4 ? pbf.readVarint64() :\n            tag === 5 ? pbf.readVarint() :\n            tag === 6 ? pbf.readSVarint() :\n            tag === 7 ? pbf.readBoolean() : null;\n    }\n\n    return value;\n}\n\n// return feature `i` from this layer as a `VectorTileFeature`\nVectorTileLayer.prototype.feature = function(i) {\n    if (i < 0 || i >= this._features.length) throw new Error('feature index out of bounds');\n\n    this._pbf.pos = this._features[i];\n\n    var end = this._pbf.readVarint() + this._pbf.pos;\n    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);\n};\n","var Pbf = require('pbf')\nvar vtpb = require('./vector-tile-pb')\nvar GeoJSONWrapper = require('./lib/geojson_wrapper')\n\nmodule.exports = fromVectorTileJs\nmodule.exports.fromVectorTileJs = fromVectorTileJs\nmodule.exports.fromGeojsonVt = fromGeojsonVt\nmodule.exports.GeoJSONWrapper = GeoJSONWrapper\n\n/**\n * Serialize a vector-tile-js-created tile to pbf\n *\n * @param {Object} tile\n * @return {Buffer} uncompressed, pbf-serialized tile data\n */\nfunction fromVectorTileJs (tile) {\n  var layers = []\n  for (var l in tile.layers) {\n    layers.push(prepareLayer(tile.layers[l]))\n  }\n\n  var out = new Pbf()\n  vtpb.tile.write({ layers: layers }, out)\n  return out.finish()\n}\n\n/**\n * Serialized a geojson-vt-created tile to pbf.\n *\n * @param {Object} layers - An object mapping layer names to geojson-vt-created vector tile objects\n * @return {Buffer} uncompressed, pbf-serialized tile data\n */\nfunction fromGeojsonVt (layers) {\n  var l = {}\n  for (var k in layers) {\n    l[k] = new GeoJSONWrapper(layers[k].features)\n    l[k].name = k\n  }\n  return fromVectorTileJs({layers: l})\n}\n\n/**\n * Prepare the given layer to be serialized by the auto-generated pbf\n * serializer by encoding the feature geometry and properties.\n */\nfunction prepareLayer (layer) {\n  var preparedLayer = {\n    name: layer.name || '',\n    version: layer.version || 1,\n    extent: layer.extent || 4096,\n    keys: [],\n    values: [],\n    features: []\n  }\n\n  var keycache = {}\n  var valuecache = {}\n\n  for (var i = 0; i < layer.length; i++) {\n    var feature = layer.feature(i)\n    feature.geometry = encodeGeometry(feature.loadGeometry())\n\n    var tags = []\n    for (var key in feature.properties) {\n      var keyIndex = keycache[key]\n      if (typeof keyIndex === 'undefined') {\n        preparedLayer.keys.push(key)\n        keyIndex = preparedLayer.keys.length - 1\n        keycache[key] = keyIndex\n      }\n      var value = wrapValue(feature.properties[key])\n      var valueIndex = valuecache[value.key]\n      if (typeof valueIndex === 'undefined') {\n        preparedLayer.values.push(value)\n        valueIndex = preparedLayer.values.length - 1\n        valuecache[value.key] = valueIndex\n      }\n      tags.push(keyIndex)\n      tags.push(valueIndex)\n    }\n\n    feature.tags = tags\n    preparedLayer.features.push(feature)\n  }\n\n  return preparedLayer\n}\n\nfunction command (cmd, length) {\n  return (length << 3) + (cmd & 0x7)\n}\n\nfunction zigzag (num) {\n  return (num << 1) ^ (num >> 31)\n}\n\n/**\n * Encode a polygon's geometry into an array ready to be serialized\n * to mapbox vector tile specified geometry data.\n *\n * @param {Array} Rings, each being an array of [x, y] tile-space coordinates\n * @return {Array} encoded geometry\n */\nfunction encodeGeometry (geometry) {\n  var encoded = []\n  var x = 0\n  var y = 0\n  var rings = geometry.length\n  for (var r = 0; r < rings; r++) {\n    var ring = geometry[r]\n    encoded.push(command(1, 1)) // moveto\n    for (var i = 0; i < ring.length; i++) {\n      if (i === 1) {\n        encoded.push(command(2, ring.length - 1)) // lineto\n      }\n      var dx = ring[i].x - x\n      var dy = ring[i].y - y\n      encoded.push(zigzag(dx), zigzag(dy))\n      x += dx\n      y += dy\n    }\n  }\n\n  return encoded\n}\n\n/**\n * Wrap a property value according to its type. The returned object\n * is of the form { xxxx_value: primitiveValue }, which is what the generated\n * protobuf serializer expects.\n */\nfunction wrapValue (value) {\n  var result\n  var type = typeof value\n  if (type === 'string') {\n    result = { string_value: value }\n  } else if (type === 'boolean') {\n    result = { bool_value: value }\n  } else if (type === 'number') {\n    if (value !== (value | 0)) {\n      result = { float_value: value }\n    } else if (value < 0) {\n      result = { sint_value: value }\n    } else {\n      result = { uint_value: value }\n    }\n  } else {\n    result = { string_value: '' + value }\n  }\n\n  result.key = type + ':' + value\n  return result\n}\n","'use strict'\n\nvar Point = require('point-geometry')\nvar VectorTileFeature = require('vector-tile').VectorTileFeature\n\nmodule.exports = GeoJSONWrapper\n\n// conform to vectortile api\nfunction GeoJSONWrapper (features) {\n  this.features = features\n  this.length = features.length\n}\n\nGeoJSONWrapper.prototype.feature = function (i) {\n  return new FeatureWrapper(this.features[i])\n}\n\nfunction FeatureWrapper (feature) {\n  this.type = feature.type\n  this.rawGeometry = feature.type === 1 ? [feature.geometry] : feature.geometry\n  this.properties = feature.tags\n  this.extent = 4096\n}\n\nFeatureWrapper.prototype.loadGeometry = function () {\n  var rings = this.rawGeometry\n  this.geometry = []\n\n  for (var i = 0; i < rings.length; i++) {\n    var ring = rings[i]\n    var newRing = []\n    for (var j = 0; j < ring.length; j++) {\n      newRing.push(new Point(ring[j][0], ring[j][1]))\n    }\n    this.geometry.push(newRing)\n  }\n  return this.geometry\n}\n\nFeatureWrapper.prototype.bbox = function () {\n  if (!this.geometry) this.loadGeometry()\n\n  var rings = this.geometry\n  var x1 = Infinity\n  var x2 = -Infinity\n  var y1 = Infinity\n  var y2 = -Infinity\n\n  for (var i = 0; i < rings.length; i++) {\n    var ring = rings[i]\n\n    for (var j = 0; j < ring.length; j++) {\n      var coord = ring[j]\n\n      x1 = Math.min(x1, coord.x)\n      x2 = Math.max(x2, coord.x)\n      y1 = Math.min(y1, coord.y)\n      y2 = Math.max(y2, coord.y)\n    }\n  }\n\n  return [x1, y1, x2, y2]\n}\n\nFeatureWrapper.prototype.toGeoJSON = VectorTileFeature.prototype.toGeoJSON\n","'use strict';\n\n// tile ========================================\n\nvar tile = exports.tile = {read: readTile, write: writeTile};\n\ntile.GeomType = {\n    \"Unknown\": 0,\n    \"Point\": 1,\n    \"LineString\": 2,\n    \"Polygon\": 3\n};\n\nfunction readTile(pbf, end) {\n    return pbf.readFields(readTileField, {\"layers\": []}, end);\n}\n\nfunction readTileField(tag, tile, pbf) {\n    if (tag === 3) tile.layers.push(readLayer(pbf, pbf.readVarint() + pbf.pos));\n}\n\nfunction writeTile(tile, pbf) {\n    var i;\n    if (tile.layers !== undefined) for (i = 0; i < tile.layers.length; i++) pbf.writeMessage(3, writeLayer, tile.layers[i]);\n}\n\n// value ========================================\n\ntile.value = {read: readValue, write: writeValue};\n\nfunction readValue(pbf, end) {\n    return pbf.readFields(readValueField, {}, end);\n}\n\nfunction readValueField(tag, value, pbf) {\n    if (tag === 1) value.string_value = pbf.readString();\n    else if (tag === 2) value.float_value = pbf.readFloat();\n    else if (tag === 3) value.double_value = pbf.readDouble();\n    else if (tag === 4) value.int_value = pbf.readVarint();\n    else if (tag === 5) value.uint_value = pbf.readVarint();\n    else if (tag === 6) value.sint_value = pbf.readSVarint();\n    else if (tag === 7) value.bool_value = pbf.readBoolean();\n}\n\nfunction writeValue(value, pbf) {\n    if (value.string_value !== undefined) pbf.writeStringField(1, value.string_value);\n    if (value.float_value !== undefined) pbf.writeFloatField(2, value.float_value);\n    if (value.double_value !== undefined) pbf.writeDoubleField(3, value.double_value);\n    if (value.int_value !== undefined) pbf.writeVarintField(4, value.int_value);\n    if (value.uint_value !== undefined) pbf.writeVarintField(5, value.uint_value);\n    if (value.sint_value !== undefined) pbf.writeSVarintField(6, value.sint_value);\n    if (value.bool_value !== undefined) pbf.writeBooleanField(7, value.bool_value);\n}\n\n// feature ========================================\n\ntile.feature = {read: readFeature, write: writeFeature};\n\nfunction readFeature(pbf, end) {\n    var feature = pbf.readFields(readFeatureField, {}, end);\n    if (feature.type === undefined) feature.type = \"Unknown\";\n    return feature;\n}\n\nfunction readFeatureField(tag, feature, pbf) {\n    if (tag === 1) feature.id = pbf.readVarint();\n    else if (tag === 2) feature.tags = pbf.readPackedVarint();\n    else if (tag === 3) feature.type = pbf.readVarint();\n    else if (tag === 4) feature.geometry = pbf.readPackedVarint();\n}\n\nfunction writeFeature(feature, pbf) {\n    if (feature.id !== undefined) pbf.writeVarintField(1, feature.id);\n    if (feature.tags !== undefined) pbf.writePackedVarint(2, feature.tags);\n    if (feature.type !== undefined) pbf.writeVarintField(3, feature.type);\n    if (feature.geometry !== undefined) pbf.writePackedVarint(4, feature.geometry);\n}\n\n// layer ========================================\n\ntile.layer = {read: readLayer, write: writeLayer};\n\nfunction readLayer(pbf, end) {\n    return pbf.readFields(readLayerField, {\"features\": [], \"keys\": [], \"values\": []}, end);\n}\n\nfunction readLayerField(tag, layer, pbf) {\n    if (tag === 15) layer.version = pbf.readVarint();\n    else if (tag === 1) layer.name = pbf.readString();\n    else if (tag === 2) layer.features.push(readFeature(pbf, pbf.readVarint() + pbf.pos));\n    else if (tag === 3) layer.keys.push(pbf.readString());\n    else if (tag === 4) layer.values.push(readValue(pbf, pbf.readVarint() + pbf.pos));\n    else if (tag === 5) layer.extent = pbf.readVarint();\n}\n\nfunction writeLayer(layer, pbf) {\n    if (layer.version !== undefined) pbf.writeVarintField(15, layer.version);\n    if (layer.name !== undefined) pbf.writeStringField(1, layer.name);\n    var i;\n    if (layer.features !== undefined) for (i = 0; i < layer.features.length; i++) pbf.writeMessage(2, writeFeature, layer.features[i]);\n    if (layer.keys !== undefined) for (i = 0; i < layer.keys.length; i++) pbf.writeStringField(3, layer.keys[i]);\n    if (layer.values !== undefined) for (i = 0; i < layer.values.length; i++) pbf.writeMessage(4, writeValue, layer.values[i]);\n    if (layer.extent !== undefined) pbf.writeVarintField(5, layer.extent);\n}\n","/**\n * Created by Ryan Whitley, Daniel Duarte, and Nicholas Hallahan\n *    on 6/03/14.\n */\nvar Util = require('./MVTUtil');\nvar StaticLabel = require('./StaticLabel/StaticLabel.js');\n\nmodule.exports = MVTFeature;\n\nfunction MVTFeature(mvtLayer, vtf, ctx, id, style) {\n  if (!vtf) return null;\n\n  // Apply all of the properties of vtf to this object.\n  for (var key in vtf) {\n    this[key] = vtf[key];\n  }\n\n  this.mvtLayer = mvtLayer;\n  this.mvtSource = mvtLayer.mvtSource;\n  this.map = mvtLayer.mvtSource.map;\n\n  this.id = id;\n\n  this.layerLink = this.mvtSource.layerLink;\n  this.toggleEnabled = true;\n  this.selected = false;\n\n  // how much we divide the coordinate from the vector tile\n  this.divisor = vtf.extent / ctx.tileSize;\n  this.extent = vtf.extent;\n  this.tileSize = ctx.tileSize;\n\n  //An object to store the paths and contexts for this feature\n  this.tiles = {};\n\n  this.style = style;\n\n  //Add to the collection\n  this.addTileFeature(vtf, ctx);\n\n  var self = this;\n  this.map.on('zoomend', function() {\n    self.staticLabel = null;\n  });\n\n  if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') {\n    this.dynamicLabel = this.mvtSource.dynamicLabel.createFeature(this);\n  }\n\n  ajax(self);\n}\n\n\nfunction ajax(self) {\n  var style = self.style;\n  if (style && style.ajaxSource && typeof style.ajaxSource === 'function') {\n    var ajaxEndpoint = style.ajaxSource(self);\n    if (ajaxEndpoint) {\n      Util.getJSON(ajaxEndpoint, function(error, response, body) {\n        if (error) {\n          throw ['ajaxSource AJAX Error', error];\n        } else {\n          ajaxCallback(self, response);\n          return true;\n        }\n      });\n    }\n  }\n  return false;\n}\n\nfunction ajaxCallback(self, response) {\n  self.ajaxData = response;\n\n  /**\n   * You can attach a callback function to a feature in your app\n   * that will get called whenever new ajaxData comes in. This\n   * can be used to update UI that looks at data from within a feature.\n   *\n   * setStyle may possibly have a style with a different ajaxData source,\n   * and you would potentially get new contextual data for your feature.\n   *\n   * TODO: This needs to be documented.\n   */\n  if (typeof self.ajaxDataReceived === 'function') {\n    self.ajaxDataReceived(self, response);\n  }\n\n  self._setStyle(self.mvtLayer.style);\n  redrawTiles(self);\n}\n\nMVTFeature.prototype._setStyle = function(styleFn) {\n  this.style = styleFn(this, this.ajaxData);\n\n  // The label gets removed, and the (re)draw,\n  // that is initiated by the MVTLayer creates a new label.\n  this.removeLabel();\n};\n\nMVTFeature.prototype.setStyle = function(styleFn) {\n  this.ajaxData = null;\n  this.style = styleFn(this, null);\n  var hasAjaxSource = ajax(this);\n  if (!hasAjaxSource) {\n    // The label gets removed, and the (re)draw,\n    // that is initiated by the MVTLayer creates a new label.\n    this.removeLabel();\n  }\n};\n\nMVTFeature.prototype.draw = function(canvasID) {\n  //Get the info from the tiles list\n  var tileInfo =  this.tiles[canvasID];\n\n  var vtf = tileInfo.vtf;\n  var ctx = tileInfo.ctx;\n\n  //Get the actual canvas from the parent layer's _tiles object.\n  var xy = canvasID.split(\":\").slice(1, 3).join(\":\");\n  ctx.canvas = this.mvtLayer._tiles[xy];\n\n//  This could be used to directly compute the style function from the layer on every draw.\n//  This is much less efficient...\n//  this.style = this.mvtLayer.style(this);\n\n  if (this.selected) {\n    var style = this.style.selected || this.style;\n  } else {\n    var style = this.style;\n  }\n\n  switch (vtf.type) {\n    case 1: //Point\n      this._drawPoint(ctx, vtf.coordinates, style);\n      if (!this.staticLabel && typeof this.style.staticLabel === 'function') {\n        if (this.style.ajaxSource && !this.ajaxData) {\n          break;\n        }\n        this._drawStaticLabel(ctx, vtf.coordinates, style);\n      }\n      break;\n\n    case 2: //LineString\n      this._drawLineString(ctx, vtf.coordinates, style);\n      break;\n\n    case 3: //Polygon\n      this._drawPolygon(ctx, vtf.coordinates, style);\n      break;\n\n    default:\n      throw new Error('Unmanaged type: ' + vtf.type);\n  }\n\n};\n\nMVTFeature.prototype.getPathsForTile = function(canvasID) {\n  //Get the info from the parts list\n  return this.tiles[canvasID].paths;\n};\n\nMVTFeature.prototype.addTileFeature = function(vtf, ctx) {\n  //Store the important items in the tiles list\n\n  //We only want to store info for tiles for the current map zoom.  If it is tile info for another zoom level, ignore it\n  //Also, if there are existing tiles in the list for other zoom levels, expunge them.\n  var zoom = this.map.getZoom();\n\n  if(ctx.zoom != zoom) return;\n\n  this.clearTileFeatures(zoom); //TODO: This iterates thru all tiles every time a new tile is added.  Figure out a better way to do this.\n\n  this.tiles[ctx.id] = {\n    ctx: ctx,\n    vtf: vtf,\n    paths: []\n  };\n\n};\n\n\n/**\n * Clear the inner list of tile features if they don't match the given zoom.\n *\n * @param zoom\n */\nMVTFeature.prototype.clearTileFeatures = function(zoom) {\n  //If stored tiles exist for other zoom levels, expunge them from the list.\n  for (var key in this.tiles) {\n     if(key.split(\":\")[0] != zoom) delete this.tiles[key];\n  }\n};\n\n/**\n * Redraws all of the tiles associated with a feature. Useful for\n * style change and toggling.\n *\n * @param self\n */\nfunction redrawTiles(self) {\n  //Redraw the whole tile, not just this vtf\n  var tiles = self.tiles;\n  var mvtLayer = self.mvtLayer;\n\n  for (var id in tiles) {\n    var tileZoom = parseInt(id.split(':')[0]);\n    var mapZoom = self.map.getZoom();\n    if (tileZoom === mapZoom) {\n      //Redraw the tile\n      mvtLayer.redrawTile(id);\n    }\n  }\n}\n\nMVTFeature.prototype.toggle = function() {\n  if (this.selected) {\n    this.deselect();\n  } else {\n    this.select();\n  }\n};\n\nMVTFeature.prototype.select = function() {\n  this.selected = true;\n  this.mvtSource.featureSelected(this);\n  redrawTiles(this);\n  var linkedFeature = this.linkedFeature();\n  if (linkedFeature && linkedFeature.staticLabel && !linkedFeature.staticLabel.selected) {\n    linkedFeature.staticLabel.select();\n  }\n};\n\nMVTFeature.prototype.deselect = function() {\n  this.selected = false;\n  this.mvtSource.featureDeselected(this);\n  redrawTiles(this);\n  var linkedFeature = this.linkedFeature();\n  if (linkedFeature && linkedFeature.staticLabel && linkedFeature.staticLabel.selected) {\n    linkedFeature.staticLabel.deselect();\n  }\n};\n\nMVTFeature.prototype.on = function(eventType, callback) {\n  this._eventHandlers[eventType] = callback;\n};\n\nMVTFeature.prototype._drawPoint = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx || !ctx.canvas) return;\n\n  var tile = this.tiles[ctx.id];\n\n  //Get radius\n  var radius = 1;\n  if (typeof style.radius === 'function') {\n    radius = style.radius(ctx.zoom); //Allows for scale dependent rednering\n  }\n  else{\n    radius = style.radius;\n  }\n\n  var p = this._tilePoint(coordsArray[0][0]);\n  var c = ctx.canvas;\n  var ctx2d;\n  try{\n    ctx2d = c.getContext('2d');\n  }\n  catch(e){\n    console.log(\"_drawPoint error: \" + e);\n    return;\n  }\n\n  ctx2d.beginPath();\n  ctx2d.fillStyle = style.color;\n  ctx2d.arc(p.x, p.y, radius, 0, Math.PI * 2);\n  ctx2d.closePath();\n  ctx2d.fill();\n\n  if(style.lineWidth && style.strokeStyle){\n    ctx2d.lineWidth = style.lineWidth;\n    ctx2d.strokeStyle = style.strokeStyle;\n    ctx2d.stroke();\n  }\n\n  ctx2d.restore();\n  tile.paths.push([p]);\n};\n\nMVTFeature.prototype._drawLineString = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx || !ctx.canvas) return;\n\n  var ctx2d = ctx.canvas.getContext('2d');\n  ctx2d.strokeStyle = style.color;\n  ctx2d.lineWidth = style.size;\n  ctx2d.beginPath();\n\n  var projCoords = [];\n  var tile = this.tiles[ctx.id];\n\n  for (var gidx in coordsArray) {\n    var coords = coordsArray[gidx];\n\n    for (i = 0; i < coords.length; i++) {\n      var method = (i === 0 ? 'move' : 'line') + 'To';\n      var proj = this._tilePoint(coords[i]);\n      projCoords.push(proj);\n      ctx2d[method](proj.x, proj.y);\n    }\n  }\n\n  ctx2d.stroke();\n  ctx2d.restore();\n\n  tile.paths.push(projCoords);\n};\n\nMVTFeature.prototype._drawPolygon = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx || !ctx.canvas) return;\n\n  var ctx2d = ctx.canvas.getContext('2d');\n  var outline = style.outline;\n\n  // color may be defined via function to make choropleth work right\n  if (typeof style.color === 'function') {\n    ctx2d.fillStyle = style.color(ctx2d);\n  } else {\n    ctx2d.fillStyle = style.color;\n  }\n\n  if (outline) {\n    ctx2d.strokeStyle = outline.color;\n    ctx2d.lineWidth = outline.size;\n  }\n  ctx2d.beginPath();\n\n  var projCoords = [];\n  var tile = this.tiles[ctx.id];\n\n  var featureLabel = this.dynamicLabel;\n  if (featureLabel) {\n    featureLabel.addTilePolys(ctx, coordsArray);\n  }\n\n  for (var gidx = 0, len = coordsArray.length; gidx < len; gidx++) {\n    var coords = coordsArray[gidx];\n\n    for (var i = 0; i < coords.length; i++) {\n      var coord = coords[i];\n      var method = (i === 0 ? 'move' : 'line') + 'To';\n      var proj = this._tilePoint(coords[i]);\n      projCoords.push(proj);\n      ctx2d[method](proj.x, proj.y);\n    }\n  }\n\n  ctx2d.closePath();\n  ctx2d.fill();\n  if (outline) {\n    ctx2d.stroke();\n  }\n\n  tile.paths.push(projCoords);\n\n};\n\nMVTFeature.prototype._drawStaticLabel = function(ctx, coordsArray, style) {\n  if (!style) return;\n  if (!ctx) return;\n\n  // If the corresponding layer is not on the map, \n  // we dont want to put on a label.\n  if (!this.mvtLayer._map) return;\n\n  var vecPt = this._tilePoint(coordsArray[0][0]);\n\n  // We're making a standard Leaflet Marker for this label.\n  var p = this._project(vecPt, ctx.tile.x, ctx.tile.y, this.extent, this.tileSize); //vectile pt to merc pt\n  var mercPt = L.point(p.x, p.y); // make into leaflet obj\n  var latLng = this.map.unproject(mercPt); // merc pt to latlng\n\n  this.staticLabel = new StaticLabel(this, ctx, latLng, style);\n  this.mvtLayer.featureWithLabelAdded(this);\n};\n\nMVTFeature.prototype.removeLabel = function() {\n  if (!this.staticLabel) return;\n  this.staticLabel.remove();\n  this.staticLabel = null;\n};\n\n/**\n * Projects a vector tile point to the Spherical Mercator pixel space for a given zoom level.\n *\n * @param vecPt\n * @param tileX\n * @param tileY\n * @param extent\n * @param tileSize\n */\nMVTFeature.prototype._project = function(vecPt, tileX, tileY, extent, tileSize) {\n  var xOffset = tileX * tileSize;\n  var yOffset = tileY * tileSize;\n  return {\n    x: Math.floor(vecPt.x + xOffset),\n    y: Math.floor(vecPt.y + yOffset)\n  };\n};\n\n/**\n * Takes a coordinate from a vector tile and turns it into a Leaflet Point.\n *\n * @param ctx\n * @param coords\n * @returns {eGeomType.Point}\n * @private\n */\nMVTFeature.prototype._tilePoint = function(coords) {\n  return new L.Point(coords.x / this.divisor, coords.y / this.divisor);\n};\n\nMVTFeature.prototype.linkedFeature = function() {\n  var linkedLayer = this.mvtLayer.linkedLayer();\n  if(linkedLayer){\n    var linkedFeature = linkedLayer.features[this.id];\n    return linkedFeature;\n  }else{\n    return null;\n  }\n};\n\n","/**\n * Created by Ryan Whitley on 5/17/14.\n */\n/** Forked from https://gist.github.com/DGuidi/1716010 **/\nvar MVTFeature = require('./MVTFeature');\nvar Util = require('./MVTUtil');\n\nmodule.exports = L.TileLayer.Canvas.extend({\n\n  options: {\n    debug: false,\n    isHiddenLayer: false,\n    getIDForLayerFeature: function() {},\n    tileSize: 256,\n    lineClickTolerance: 2\n  },\n\n  _featureIsClicked: {},\n\n  _isPointInPoly: function(pt, poly) {\n    if(poly && poly.length) {\n      for (var c = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i)\n        ((poly[i].y <= pt.y && pt.y < poly[j].y) || (poly[j].y <= pt.y && pt.y < poly[i].y))\n        && (pt.x < (poly[j].x - poly[i].x) * (pt.y - poly[i].y) / (poly[j].y - poly[i].y) + poly[i].x)\n        && (c = !c);\n      return c;\n    }\n  },\n\n  _getDistanceFromLine: function(pt, pts) {\n    var min = Number.POSITIVE_INFINITY;\n    if (pts && pts.length > 1) {\n      pt = L.point(pt.x, pt.y);\n      for (var i = 0, l = pts.length - 1; i < l; i++) {\n        var test = this._projectPointOnLineSegment(pt, pts[i], pts[i + 1]);\n        if (test.distance <= min) {\n          min = test.distance;\n        }\n      }\n    }\n    return min;\n  },\n\n  _projectPointOnLineSegment: function(p, r0, r1) {\n    var lineLength = r0.distanceTo(r1);\n    if (lineLength < 1) {\n        return {distance: p.distanceTo(r0), coordinate: r0};\n    }\n    var u = ((p.x - r0.x) * (r1.x - r0.x) + (p.y - r0.y) * (r1.y - r0.y)) / Math.pow(lineLength, 2);\n    if (u < 0.0000001) {\n        return {distance: p.distanceTo(r0), coordinate: r0};\n    }\n    if (u > 0.9999999) {\n        return {distance: p.distanceTo(r1), coordinate: r1};\n    }\n    var a = L.point(r0.x + u * (r1.x - r0.x), r0.y + u * (r1.y - r0.y));\n    return {distance: p.distanceTo(a), point: a};\n  },\n\n  initialize: function(mvtSource, options) {\n    var self = this;\n    self.mvtSource = mvtSource;\n    L.Util.setOptions(this, options);\n\n    this.style = options.style;\n    this.name = options.name;\n    this._canvasIDToFeatures = {};\n    this.features = {};\n    this.featuresWithLabels = [];\n    this._highestCount = 0;\n  },\n\n  onAdd: function(map) {\n    var self = this;\n    self.map = map;\n    L.TileLayer.Canvas.prototype.onAdd.call(this, map);\n    map.on('layerremove', function(e) {\n      // we only want to do stuff when the layerremove event is on this layer\n      if (e.layer._leaflet_id === self._leaflet_id) {\n        removeLabels(self);\n      }\n    });\n  },\n\n  drawTile: function(canvas, tilePoint, zoom) {\n\n    var ctx = {\n      canvas: canvas,\n      tile: tilePoint,\n      zoom: zoom,\n      tileSize: this.options.tileSize\n    };\n\n    ctx.id = Util.getContextID(ctx);\n\n    if (!this._canvasIDToFeatures[ctx.id]) {\n      this._initializeFeaturesHash(ctx);\n    }\n    if (!this.features) {\n      this.features = {};\n    }\n\n  },\n\n  _initializeFeaturesHash: function(ctx){\n    this._canvasIDToFeatures[ctx.id] = {};\n    this._canvasIDToFeatures[ctx.id].features = [];\n    this._canvasIDToFeatures[ctx.id].canvas = ctx.canvas;\n  },\n\n  _draw: function(ctx) {\n    //Draw is handled by the parent MVTSource object\n  },\n  getCanvas: function(parentCtx){\n    //This gets called if a vector tile feature has already been parsed.\n    //We've already got the geom, just get on with the drawing.\n    //Need a way to pluck a canvas element from this layer given the parent layer's id.\n    //Wait for it to get loaded before proceeding.\n    var tilePoint = parentCtx.tile;\n    var ctx = this._tiles[tilePoint.x + \":\" + tilePoint.y];\n\n    if(ctx){\n      parentCtx.canvas = ctx;\n      this.redrawTile(parentCtx.id);\n      return;\n    }\n\n    var self = this;\n\n    //This is a timer that will wait for a criterion to return true.\n    //If not true within the timeout duration, it will move on.\n    waitFor(function () {\n        ctx = self._tiles[tilePoint.x + \":\" + tilePoint.y];\n        if(ctx) {\n          return true;\n        }\n      },\n      function(){\n        //When it finishes, do this.\n        ctx = self._tiles[tilePoint.x + \":\" + tilePoint.y];\n        parentCtx.canvas = ctx;\n        self.redrawTile(parentCtx.id);\n\n      }, //when done, go to next flow\n      2000); //The Timeout milliseconds.  After this, give up and move on\n\n  },\n\n  parseVectorTileLayer: function(vtl, ctx) {\n    var self = this;\n    var tilePoint = ctx.tile;\n    var layerCtx  = { canvas: null, id: ctx.id, tile: ctx.tile, zoom: ctx.zoom, tileSize: ctx.tileSize};\n\n    //See if we can pluck the child tile from this PBF tile layer based on the master layer's tile id.\n    layerCtx.canvas = self._tiles[tilePoint.x + \":\" + tilePoint.y];\n\n\n\n    //Initialize this tile's feature storage hash, if it hasn't already been created.  Used for when filters are updated, and features are cleared to prepare for a fresh redraw.\n    if (!this._canvasIDToFeatures[layerCtx.id]) {\n      this._initializeFeaturesHash(layerCtx);\n    }else{\n      //Clear this tile's previously saved features.\n      this.clearTileFeatureHash(layerCtx.id);\n    }\n\n    var features = vtl.parsedFeatures;\n    for (var i = 0, len = features.length; i < len; i++) {\n      var vtf = features[i]; //vector tile feature\n      vtf.layer = vtl;\n\n      /**\n       * Apply filter on feature if there is one. Defined in the options object\n       * of TileLayer.MVTSource.js\n       */\n      var filter = self.options.filter;\n      if (typeof filter === 'function') {\n        if ( filter(vtf, layerCtx) === false ) continue;\n      }\n\n      var getIDForLayerFeature;\n      if (typeof self.options.getIDForLayerFeature === 'function') {\n        getIDForLayerFeature = self.options.getIDForLayerFeature;\n      } else {\n        getIDForLayerFeature = Util.getIDForLayerFeature;\n      }\n      var uniqueID = self.options.getIDForLayerFeature(vtf) || i;\n      var mvtFeature = self.features[uniqueID];\n\n      /**\n       * Use layerOrdering function to apply a zIndex property to each vtf.  This is defined in\n       * TileLayer.MVTSource.js.  Used below to sort features.npm\n       */\n      var layerOrdering = self.options.layerOrdering;\n      if (typeof layerOrdering === 'function') {\n        layerOrdering(vtf, layerCtx); //Applies a custom property to the feature, which is used after we're thru iterating to sort\n      }\n\n      //Create a new MVTFeature if one doesn't already exist for this feature.\n      if (!mvtFeature) {\n        //Get a style for the feature - set it just once for each new MVTFeature\n        var style = self.style(vtf);\n\n        //create a new feature\n        self.features[uniqueID] = mvtFeature = new MVTFeature(self, vtf, layerCtx, uniqueID, style);\n        if (style && style.dynamicLabel && typeof style.dynamicLabel === 'function') {\n          self.featuresWithLabels.push(mvtFeature);\n        }\n      } else {\n        //Add the new part to the existing feature\n        mvtFeature.addTileFeature(vtf, layerCtx);\n      }\n\n      //Associate & Save this feature with this tile for later\n      if(layerCtx && layerCtx.id) self._canvasIDToFeatures[layerCtx.id]['features'].push(mvtFeature);\n\n    }\n\n    /**\n     * Apply sorting (zIndex) on feature if there is a function defined in the options object\n     * of TileLayer.MVTSource.js\n     */\n    var layerOrdering = self.options.layerOrdering;\n    if (layerOrdering) {\n      //We've assigned the custom zIndex property when iterating above.  Now just sort.\n      self._canvasIDToFeatures[layerCtx.id].features = self._canvasIDToFeatures[layerCtx.id].features.sort(function(a, b) {\n        return -(b.properties.zIndex - a.properties.zIndex)\n      });\n    }\n\n    self.redrawTile(layerCtx.id);\n  },\n\n  setStyle: function(styleFn) {\n    // refresh the number for the highest count value\n    // this is used only for choropleth\n    this._highestCount = 0;\n\n    // lowest count should not be 0, since we want to figure out the lowest\n    this._lowestCount = null;\n\n    this.style = styleFn;\n    for (var key in this.features) {\n      var feat = this.features[key];\n      feat.setStyle(styleFn);\n    }\n    var z = this.map.getZoom();\n    for (var key in this._tiles) {\n      var id = z + ':' + key;\n      this.redrawTile(id);\n    }\n  },\n\n  /**\n   * As counts for choropleths come in with the ajax data,\n   * we want to keep track of which value is the highest\n   * to create the color ramp for the fills of polygons.\n   * @param count\n   */\n  setHighestCount: function(count) {\n    if (count > this._highestCount) {\n      this._highestCount = count;\n    }\n  },\n\n  /**\n   * Returns the highest number of all of the counts that have come in\n   * from setHighestCount. This is assumed to be set via ajax callbacks.\n   * @returns {number}\n   */\n  getHighestCount: function() {\n    return this._highestCount;\n  },\n\n  setLowestCount: function(count) {\n    if (!this._lowestCount || count < this._lowestCount) {\n      this._lowestCount = count;\n    }\n  },\n\n  getLowestCount: function() {\n    return this._lowestCount;\n  },\n\n  setCountRange: function(count) {\n    this.setHighestCount(count);\n    this.setLowestCount(count);\n  },\n\n  //This is the old way.  It works, but is slow for mouseover events.  Fine for click events.\n  handleClickEvent: function(evt, cb) {\n    //Click happened on the GroupLayer (Manager) and passed it here\n    var tileID = evt.tileID.split(\":\").slice(1, 3).join(\":\");\n    var zoom = evt.tileID.split(\":\")[0];\n    var canvas = this._tiles[tileID];\n    if(!canvas) (cb(evt)); //break out\n    var x = evt.layerPoint.x - canvas._leaflet_pos.x;\n    var y = evt.layerPoint.y - canvas._leaflet_pos.y;\n\n    var tilePoint = {x: x, y: y};\n    var features = this._canvasIDToFeatures[evt.tileID].features;\n\n    var minDistance = Number.POSITIVE_INFINITY;\n    var nearest = null;\n    var j, paths, distance;\n\n    for (var i = 0; i < features.length; i++) {\n      var feature = features[i];\n      switch (feature.type) {\n\n        case 1: //Point - currently rendered as circular paths.  Intersect with that.\n\n          //Find the radius of the point.\n          var radius = 3;\n          if (typeof feature.style.radius === 'function') {\n            radius = feature.style.radius(zoom); //Allows for scale dependent rednering\n          }\n          else{\n            radius = feature.style.radius;\n          }\n\n          paths = feature.getPathsForTile(evt.tileID);\n          for (j = 0; j < paths.length; j++) {\n            //Builds a circle of radius feature.style.radius (assuming circular point symbology).\n            if(in_circle(paths[j][0].x, paths[j][0].y, radius, x, y)){\n              nearest = feature;\n              minDistance = 0;\n            }\n          }\n          break;\n\n        case 2: //LineString\n          paths = feature.getPathsForTile(evt.tileID);\n          for (j = 0; j < paths.length; j++) {\n            if (feature.style) {\n              var distance = this._getDistanceFromLine(tilePoint, paths[j]);\n              var thickness = (feature.selected && feature.style.selected ? feature.style.selected.size : feature.style.size);\n              if (distance < thickness / 2 + this.options.lineClickTolerance && distance < minDistance) {\n                nearest = feature;\n                minDistance = distance;\n              }\n            }\n          }\n          break;\n\n        case 3: //Polygon\n          paths = feature.getPathsForTile(evt.tileID);\n          for (j = 0; j < paths.length; j++) {\n            if (this._isPointInPoly(tilePoint, paths[j])) {\n              nearest = feature;\n              minDistance = 0; // point is inside the polygon, so distance is zero\n            }\n          }\n          break;\n      }\n      if (minDistance == 0) break;\n    }\n\n    if (nearest && nearest.toggleEnabled) {\n        nearest.toggle();\n    }\n    evt.feature = nearest;\n    cb(evt);\n  },\n\n  clearTile: function(id) {\n    //id is the entire zoom:x:y.  we just want x:y.\n    var ca = id.split(\":\");\n    var canvasId = ca[1] + \":\" + ca[2];\n    if (typeof this._tiles[canvasId] === 'undefined') {\n      console.error(\"typeof this._tiles[canvasId] === 'undefined'\");\n      return;\n    }\n    var canvas = this._tiles[canvasId];\n\n    var context = canvas.getContext('2d');\n    context.clearRect(0, 0, canvas.width, canvas.height);\n  },\n\n  clearTileFeatureHash: function(canvasID){\n    this._canvasIDToFeatures[canvasID] = { features: []}; //Get rid of all saved features\n  },\n\n  clearLayerFeatureHash: function(){\n    this.features = {};\n  },\n\n  redrawTile: function(canvasID) {\n    //First, clear the canvas\n    this.clearTile(canvasID);\n\n    // If the features are not in the tile, then there is nothing to redraw.\n    // This may happen if you call redraw before features have loaded and initially\n    // drawn the tile.\n    var featfeats = this._canvasIDToFeatures[canvasID];\n    if (!featfeats) {\n      return;\n    }\n\n    //Get the features for this tile, and redraw them.\n    var features = featfeats.features;\n\n    // we want to skip drawing the selected features and draw them last\n    var selectedFeatures = [];\n\n    // drawing all of the non-selected features\n    for (var i = 0; i < features.length; i++) {\n      var feature = features[i];\n      if (feature.selected) {\n        selectedFeatures.push(feature);\n      } else {\n        feature.draw(canvasID);\n      }\n    }\n\n    // drawing the selected features last\n    for (var j = 0, len2 = selectedFeatures.length; j < len2; j++) {\n      var selFeat = selectedFeatures[j];\n      selFeat.draw(canvasID);\n    }\n  },\n\n  _resetCanvasIDToFeatures: function(canvasID, canvas) {\n\n    this._canvasIDToFeatures[canvasID] = {};\n    this._canvasIDToFeatures[canvasID].features = [];\n    this._canvasIDToFeatures[canvasID].canvas = canvas;\n\n  },\n\n  linkedLayer: function() {\n    if(this.mvtSource.layerLink) {\n      var linkName = this.mvtSource.layerLink(this.name);\n      return this.mvtSource.layers[linkName];\n    }\n    else{\n      return null;\n    }\n  },\n\n  featureWithLabelAdded: function(feature) {\n    this.featuresWithLabels.push(feature);\n  }\n\n});\n\n\nfunction removeLabels(self) {\n  var features = self.featuresWithLabels;\n  for (var i = 0, len = features.length; i < len; i++) {\n    var feat = features[i];\n    feat.removeLabel();\n  }\n  self.featuresWithLabels = [];\n}\n\nfunction in_circle(center_x, center_y, radius, x, y) {\n  var square_dist = Math.pow((center_x - x), 2) + Math.pow((center_y - y), 2);\n  return square_dist <= Math.pow(radius, 2);\n}\n/**\n * See https://github.com/ariya/phantomjs/blob/master/examples/waitfor.js\n *\n * Wait until the test condition is true or a timeout occurs. Useful for waiting\n * on a server response or for a ui change (fadeIn, etc.) to occur.\n *\n * @param testFx javascript condition that evaluates to a boolean,\n * it can be passed in as a string (e.g.: \"1 == 1\" or \"$('#bar').is(':visible')\" or\n * as a callback function.\n * @param onReady what to do when testFx condition is fulfilled,\n * it can be passed in as a string (e.g.: \"1 == 1\" or \"$('#bar').is(':visible')\" or\n * as a callback function.\n * @param timeOutMillis the max amount of time to wait. If not specified, 3 sec is used.\n */\nfunction waitFor(testFx, onReady, timeOutMillis) {\n  var maxtimeOutMillis = timeOutMillis ? timeOutMillis : 3000, //< Default Max Timout is 3s\n    start = new Date().getTime(),\n    condition = (typeof (testFx) === \"string\" ? eval(testFx) : testFx()), //< defensive code\n    interval = setInterval(function () {\n      if ((new Date().getTime() - start < maxtimeOutMillis) && !condition) {\n        // If not time-out yet and condition not yet fulfilled\n        condition = (typeof (testFx) === \"string\" ? eval(testFx) : testFx()); //< defensive code\n      } else {\n        if (!condition) {\n          // If condition still not fulfilled (timeout but condition is 'false')\n          console.log(\"'waitFor()' timeout\");\n          clearInterval(interval); //< Stop this interval\n          typeof (onReady) === \"string\" ? eval(onReady) : onReady('timeout'); //< Do what it's supposed to do once the condition is fulfilled\n        } else {\n          // Condition fulfilled (timeout and/or condition is 'true')\n          console.log(\"'waitFor()' finished in \" + (new Date().getTime() - start) + \"ms.\");\n          clearInterval(interval); //< Stop this interval\n          typeof (onReady) === \"string\" ? eval(onReady) : onReady('success'); //< Do what it's supposed to do once the condition is fulfilled\n        }\n      }\n    }, 50); //< repeat check every 50ms\n};","var VectorTile = require('vector-tile').VectorTile;\nvar Protobuf = require('pbf');\nvar Point = require('point-geometry');\nvar Util = require('./MVTUtil');\nvar MVTLayer = require('./MVTLayer');\nvar geojsonvt = require('geojson-vt');\nvar vtpbf = require('vt-pbf');\n\nmodule.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({\n\n  options: {\n    debug: false,\n    url: \"\", //URL TO Vector Tile Source,\n    getIDForLayerFeature: function() {},\n    tileSize: 256,\n    visibleLayers: [],\n    xhrHeaders: {}\n  },\n  layers: {}, //Keep a list of the layers contained in the PBFs\n  processedTiles: {}, //Keep a list of tiles that have been processed already\n  _eventHandlers: {},\n  _triggerOnTilesLoadedEvent: true, //whether or not to fire the onTilesLoaded event when all of the tiles finish loading.\n  _url: \"\", //internal URL property\n\n  style: function(feature) {\n    var style = {};\n\n    var type = feature.type;\n    switch (type) {\n      case 1: //'Point'\n        style.color = 'rgba(49,79,79,1)';\n        style.radius = 5;\n        style.selected = {\n          color: 'rgba(255,255,0,0.5)',\n          radius: 6\n        };\n        break;\n      case 2: //'LineString'\n        style.color = 'rgba(161,217,155,0.8)';\n        style.size = 3;\n        style.selected = {\n          color: 'rgba(255,25,0,0.5)',\n          size: 4\n        };\n        break;\n      case 3: //'Polygon'\n        style.color = 'rgba(49,79,79,1)';\n        style.outline = {\n          color: 'rgba(161,217,155,0.8)',\n          size: 1\n        };\n        style.selected = {\n          color: 'rgba(255,140,0,0.3)',\n          outline: {\n            color: 'rgba(255,140,0,1)',\n            size: 2\n          }\n        };\n        break;\n    }\n    return style;\n  },\n\n\n  initialize: function(options) {\n    L.Util.setOptions(this, options);\n\n    //a list of the layers contained in the PBFs\n    this.layers = {};\n\n    // tiles currently in the viewport\n    this.activeTiles = {};\n\n    // thats that have been loaded and drawn\n    this.loadedTiles = {};\n\n    this._url = this.options.url;\n\n    /**\n     * For some reason, Leaflet has some code that resets the\n     * z index in the options object. I'm having trouble tracking\n     * down exactly what does this and why, so for now, we should\n     * just copy the value to this.zIndex so we can have the right\n     * number when we make the subsequent MVTLayers.\n     */\n    this.zIndex = options.zIndex;\n\n    if (typeof options.style === 'function') {\n      this.style = options.style;\n    }\n\n    if (typeof options.ajaxSource === 'function') {\n      this.ajaxSource = options.ajaxSource;\n    }\n\n    this.layerLink = options.layerLink;\n\n    this._eventHandlers = {};\n\n    this._tilesToProcess = 0; //store the max number of tiles to be loaded.  Later, we can use this count to count down PBF loading.\n  },\n\n  redraw: function(triggerOnTilesLoadedEvent){\n    //Only set to false if it actually is passed in as 'false'\n    if (triggerOnTilesLoadedEvent === false) {\n      this._triggerOnTilesLoadedEvent = false;\n    }\n\n    L.TileLayer.Canvas.prototype.redraw.call(this);\n  },\n\n  onAdd: function(map) {\n    var self = this;\n    self.map = map;\n    L.TileLayer.Canvas.prototype.onAdd.call(this, map);\n\n    var mapOnClickCallback = function(e) {\n      self._onClick(e);\n    };\n\n    map.on('click', mapOnClickCallback);\n\n    map.on(\"layerremove\", function(e) {\n      // check to see if the layer removed is this one\n      // call a method to remove the child layers (the ones that actually have something drawn on them).\n      if (e.layer._leaflet_id === self._leaflet_id && e.layer.removeChildLayers) {\n        e.layer.removeChildLayers(map);\n        map.off('click', mapOnClickCallback);\n      }\n    });\n\n    self.addChildLayers(map);\n\n    if (typeof DynamicLabel === 'function' ) {\n      this.dynamicLabel = new DynamicLabel(map, this, {});\n    }\n\n  },\n\n  drawTile: function(canvas, tilePoint, zoom) {\n    var ctx = {\n      id: [zoom, tilePoint.x, tilePoint.y].join(\":\"),\n      canvas: canvas,\n      tile: tilePoint,\n      zoom: zoom,\n      tileSize: this.options.tileSize\n    };\n\n    //Capture the max number of the tiles to load here. this._tilesToProcess is an internal number we use to know when we've finished requesting PBFs.\n    if(this._tilesToProcess < this._tilesToLoad) this._tilesToProcess = this._tilesToLoad;\n\n    var id = ctx.id = Util.getContextID(ctx);\n    this.activeTiles[id] = ctx;\n\n    if(!this.processedTiles[ctx.zoom]) this.processedTiles[ctx.zoom] = {};\n\n    if (this.options.debug) {\n      this._drawDebugInfo(ctx);\n    }\n    this._draw(ctx);\n  },\n\n  setOpacity:function(opacity) {\n    this._setVisibleLayersStyle('opacity',opacity);\n  },\n\n  setZIndex:function(zIndex) {\n    this._setVisibleLayersStyle('zIndex',zIndex);\n  },\n\n  _setVisibleLayersStyle:function(style, value) {\n    for(var key in this.layers) {\n      this.layers[key]._tileContainer.style[style] = value;\n    }\n  },\n\n  _drawDebugInfo: function(ctx) {\n    var max = this.options.tileSize;\n    var g = ctx.canvas.getContext('2d');\n    g.strokeStyle = '#000000';\n    g.fillStyle = '#FFFF00';\n    g.strokeRect(0, 0, max, max);\n    g.font = \"12px Arial\";\n    g.fillRect(0, 0, 5, 5);\n    g.fillRect(0, max - 5, 5, 5);\n    g.fillRect(max - 5, 0, 5, 5);\n    g.fillRect(max - 5, max - 5, 5, 5);\n    g.fillRect(max / 2 - 5, max / 2 - 5, 10, 10);\n    g.strokeText(ctx.zoom + ' ' + ctx.tile.x + ' ' + ctx.tile.y, max / 2 - 30, max / 2 - 10);\n  },\n\n  _draw: function(ctx) {\n    if (this.options.geoJson) {\n      this._fetchVectorTileGeojsonVt(ctx);\n    } else {\n      this._fetchVectorTileXHR(ctx);\n    }\n  },\n\n  _vectorTileLoaded: function(ctx, vt) {\n    this.checkVectorTileLayers(parseVT(vt), ctx);\n    tileLoaded(this, ctx);\n  },\n\n  _fetchVectorTileGeojsonVt: function(ctx) {\n    var self = this;\n    if (!self._geojsonvtTileIndex) {\n      self._geojsonvtTileIndex = geojsonvt(self.options.geoJson);\n    }\n    // TODO: Timeout is neccessary because other operations depend on this being asynchronous\n    // 0ms timeout does not quite solve the problem, for reasons unknown.\n    window.setTimeout(function(){\n      var vectorTileJson = self._geojsonvtTileIndex.getTile(ctx.zoom, ctx.tile.x, ctx.tile.y);\n      if (vectorTileJson) {\n        var reformatted = vtpbf.fromGeojsonVt({ 'geojsonLayer': vectorTileJson });\n        self._vectorTileLoaded(ctx, new VectorTile(new Protobuf(reformatted)));\n        self.reduceTilesToProcessCount();\n      }\n    }, 5);\n  },\n\n  _fetchVectorTileXHR: function(ctx) {\n    var self = this;\n\n//    //This works to skip fetching and processing tiles if they've already been processed.\n//    var vectorTile = this.processedTiles[ctx.zoom][ctx.id];\n//    //if we've already parsed it, don't get it again.\n//    if(vectorTile){\n//      console.log(\"Skipping fetching \" + ctx.id);\n//      self.checkVectorTileLayers(parseVT(vectorTile), ctx, true);\n//      self.reduceTilesToProcessCount();\n//      return;\n//    }\n\n    if (!this._url) return;\n    var src = this.getTileUrl({ x: ctx.tile.x, y: ctx.tile.y, z: ctx.zoom });\n\n    var xhr = new XMLHttpRequest();\n    xhr.onload = function() {\n      if (xhr.status == \"200\") {\n\n        if(!xhr.response) return;\n\n        var arrayBuffer = new Uint8Array(xhr.response);\n        var buf = new Protobuf(arrayBuffer);\n        var vt = new VectorTile(buf);\n        //Check the current map layer zoom.  If fast zooming is occurring, then short circuit tiles that are for a different zoom level than we're currently on.\n        if(self.map && self.map.getZoom() != ctx.zoom) {\n          console.log(\"Fetched tile for zoom level \" + ctx.zoom + \". Map is at zoom level \" + self._map.getZoom());\n          return;\n        }\n        self._vectorTileLoaded(ctx, vt);\n      }\n\n      //either way, reduce the count of tilesToProcess tiles here\n      self.reduceTilesToProcessCount();\n    };\n\n    xhr.onerror = function() {\n      console.log(\"xhr error: \" + xhr.status)\n    };\n\n    xhr.open('GET', src, true); //async is true\n    var headers = self.options.xhrHeaders;\n    for (var header in headers) {\n      xhr.setRequestHeader(header, headers[header])\n    }\n    xhr.responseType = 'arraybuffer';\n    xhr.send();\n  },\n\n  reduceTilesToProcessCount: function(){\n    this._tilesToProcess--;\n    if(!this._tilesToProcess){\n      //Trigger event letting us know that all PBFs have been loaded and processed (or 404'd).\n      if(this._eventHandlers[\"PBFLoad\"]) this._eventHandlers[\"PBFLoad\"]();\n      this._pbfLoaded();\n    }\n  },\n\n  checkVectorTileLayers: function(vt, ctx, parsed) {\n    var self = this;\n\n    //Check if there are specified visible layers\n    if(self.options.visibleLayers && self.options.visibleLayers.length > 0){\n      //only let thru the layers listed in the visibleLayers array\n      for(var i=0; i < self.options.visibleLayers.length; i++){\n        var layerName = self.options.visibleLayers[i];\n        if(vt.layers[layerName]){\n           //Proceed with parsing\n          self.prepareMVTLayers(vt.layers[layerName], layerName, ctx, parsed);\n        }\n      }\n    }else{\n      //Parse all vt.layers\n      for (var key in vt.layers) {\n        self.prepareMVTLayers(vt.layers[key], key, ctx, parsed);\n      }\n    }\n  },\n\n  prepareMVTLayers: function(lyr ,key, ctx, parsed) {\n    var self = this;\n\n    if (!self.layers[key]) {\n      //Create MVTLayer or MVTPointLayer for user\n      self.layers[key] = self.createMVTLayer(key, lyr.parsedFeatures[0].type || null);\n    }\n\n    if (parsed) {\n      //We've already parsed it.  Go get canvas and draw.\n      self.layers[key].getCanvas(ctx, lyr);\n    } else {\n      self.layers[key].parseVectorTileLayer(lyr, ctx);\n    }\n\n  },\n\n  createMVTLayer: function(key, type) {\n    var self = this;\n\n    var getIDForLayerFeature;\n    if (typeof self.options.getIDForLayerFeature === 'function') {\n      getIDForLayerFeature = self.options.getIDForLayerFeature;\n    } else {\n      getIDForLayerFeature = Util.getIDForLayerFeature;\n    }\n\n    var options = {\n      getIDForLayerFeature: getIDForLayerFeature,\n      filter: self.options.filter,\n      layerOrdering: self.options.layerOrdering,\n      style: self.style,\n      name: key,\n      asynch: true\n    };\n\n    if (self.options.zIndex) {\n      options.zIndex = self.zIndex;\n    }\n\n    //Take the layer and create a new MVTLayer or MVTPointLayer if one doesn't exist.\n    var layer = new MVTLayer(self, options).addTo(self.map);\n\n    return layer;\n  },\n\n  getLayers: function() {\n    return this.layers;\n  },\n\n  hideLayer: function(id) {\n    if (this.layers[id]) {\n      this._map.removeLayer(this.layers[id]);\n      if(this.options.visibleLayers.indexOf(\"id\") > -1){\n        this.visibleLayers.splice(this.options.visibleLayers.indexOf(\"id\"), 1);\n      }\n    }\n  },\n\n  showLayer: function(id) {\n    if (this.layers[id]) {\n      this._map.addLayer(this.layers[id]);\n      if(this.options.visibleLayers.indexOf(\"id\") == -1){\n        this.visibleLayers.push(id);\n      }\n    }\n    //Make sure manager layer is always in front\n    this.bringToFront();\n  },\n\n  removeChildLayers: function(map){\n    //Remove child layers of this group layer\n    for (var key in this.layers) {\n      var layer = this.layers[key];\n      map.removeLayer(layer);\n    }\n  },\n\n  addChildLayers: function(map) {\n    var self = this;\n    if(self.options.visibleLayers.length > 0){\n      //only let thru the layers listed in the visibleLayers array\n      for(var i=0; i < self.options.visibleLayers.length; i++){\n        var layerName = self.options.visibleLayers[i];\n        var layer = this.layers[layerName];\n        if(layer){\n          //Proceed with parsing\n          map.addLayer(layer);\n        }\n      }\n    }else{\n      //Add all layers\n      for (var key in this.layers) {\n        var layer = this.layers[key];\n        // layer is set to visible and is not already on map\n        if (!layer._map) {\n          map.addLayer(layer);\n        }\n      }\n    }\n  },\n\n  bind: function(eventType, callback) {\n    this._eventHandlers[eventType] = callback;\n  },\n\n  _onClick: function(evt) {\n    //Here, pass the event on to the child MVTLayer and have it do the hit test and handle the result.\n    var self = this;\n    var onClick = self.options.onClick;\n    var clickableLayers = self.options.clickableLayers;\n    var layers = self.layers;\n\n    evt.tileID =  getTileURL(evt.latlng.lat, evt.latlng.lng, this.map.getZoom());\n\n    // We must have an array of clickable layers, otherwise, we just pass\n    // the event to the public onClick callback in options.\n\n    if(!clickableLayers){\n      clickableLayers = Object.keys(self.layers);\n    }\n\n    if (clickableLayers && clickableLayers.length > 0) {\n      for (var i = 0, len = clickableLayers.length; i < len; i++) {\n        var key = clickableLayers[i];\n        var layer = layers[key];\n        if (layer) {\n          layer.handleClickEvent(evt, function(evt) {\n            if (typeof onClick === 'function') {\n              onClick(evt);\n            }\n          });\n        }\n      }\n    } else {\n      if (typeof onClick === 'function') {\n        onClick(evt);\n      }\n    }\n\n  },\n\n  setFilter: function(filterFunction, layerName) {\n    //take in a new filter function.\n    //Propagate to child layers.\n\n    //Add filter to all child layers if no layer is specified.\n    for (var key in this.layers) {\n      var layer = this.layers[key];\n\n      if (layerName){\n        if(key.toLowerCase() == layerName.toLowerCase()){\n          layer.options.filter = filterFunction; //Assign filter to child layer, only if name matches\n          //After filter is set, the old feature hashes are invalid.  Clear them for next draw.\n          layer.clearLayerFeatureHash();\n          //layer.clearTileFeatureHash();\n        }\n      }\n      else{\n        layer.options.filter = filterFunction; //Assign filter to child layer\n        //After filter is set, the old feature hashes are invalid.  Clear them for next draw.\n        layer.clearLayerFeatureHash();\n        //layer.clearTileFeatureHash();\n      }\n    }\n  },\n\n  /**\n   * Take in a new style function and propogate to child layers.\n   * If you do not set a layer name, it resets the style for all of the layers.\n   * @param styleFunction\n   * @param layerName\n   */\n  setStyle: function(styleFn, layerName) {\n    for (var key in this.layers) {\n      var layer = this.layers[key];\n      if (layerName) {\n        if(key.toLowerCase() == layerName.toLowerCase()) {\n          layer.setStyle(styleFn);\n        }\n      } else {\n        layer.setStyle(styleFn);\n      }\n    }\n  },\n\n  featureSelected: function(mvtFeature) {\n    if (this.options.mutexToggle) {\n      if (this._selectedFeature) {\n        this._selectedFeature.deselect();\n      }\n      this._selectedFeature = mvtFeature;\n    }\n    if (this.options.onSelect) {\n      this.options.onSelect(mvtFeature);\n    }\n  },\n\n  featureDeselected: function(mvtFeature) {\n    if (this.options.mutexToggle && this._selectedFeature) {\n      this._selectedFeature = null;\n    }\n    if (this.options.onDeselect) {\n      this.options.onDeselect(mvtFeature);\n    }\n  },\n\n  _pbfLoaded: function() {\n    //Fires when all tiles from this layer have been loaded and drawn (or 404'd).\n\n    //Make sure manager layer is always in front\n    this.bringToFront();\n\n    //See if there is an event to execute\n    var self = this;\n    var onTilesLoaded = self.options.onTilesLoaded;\n\n    if (onTilesLoaded && typeof onTilesLoaded === 'function' && this._triggerOnTilesLoadedEvent === true) {\n      onTilesLoaded(this);\n    }\n    self._triggerOnTilesLoadedEvent = true; //reset - if redraw() is called with the optinal 'false' parameter to temporarily disable the onTilesLoaded event from firing.  This resets it back to true after a single time of firing as 'false'.\n  }\n\n});\n\n\nif (typeof(Number.prototype.toRad) === \"undefined\") {\n  Number.prototype.toRad = function() {\n    return this * Math.PI / 180;\n  }\n}\n\nfunction getTileURL(lat, lon, zoom) {\n  var xtile = parseInt(Math.floor( (lon + 180) / 360 * (1<<zoom) ));\n  var ytile = parseInt(Math.floor( (1 - Math.log(Math.tan(lat.toRad()) + 1 / Math.cos(lat.toRad())) / Math.PI) / 2 * (1<<zoom) ));\n  return \"\" + zoom + \":\" + xtile + \":\" + ytile;\n}\n\nfunction tileLoaded(pbfSource, ctx) {\n  pbfSource.loadedTiles[ctx.id] = ctx;\n}\n\nfunction parseVT(vt){\n  for (var key in vt.layers) {\n    var lyr = vt.layers[key];\n    parseVTFeatures(lyr);\n  }\n  return vt;\n}\n\nfunction parseVTFeatures(vtl){\n  vtl.parsedFeatures = [];\n  var features = vtl._features;\n  for (var i = 0, len = features.length; i < len; i++) {\n    var vtf = vtl.feature(i);\n    vtf.coordinates = vtf.loadGeometry();\n    vtl.parsedFeatures.push(vtf);\n  }\n  return vtl;\n}\n","/**\n * Created by Nicholas Hallahan <nhallahan@spatialdev.com>\n *       on 8/15/14.\n */\nvar Util = module.exports = {};\n\nUtil.getContextID = function(ctx) {\n  return [ctx.zoom, ctx.tile.x, ctx.tile.y].join(\":\");\n};\n\n/**\n * Default function that gets the id for a layer feature.\n * Sometimes this needs to be done in a different way and\n * can be specified by the user in the options for L.TileLayer.MVTSource.\n *\n * @param feature\n * @returns {ctx.id|*|id|string|jsts.index.chain.MonotoneChain.id|number}\n */\nUtil.getIDForLayerFeature = function(feature) {\n  return feature.properties.id;\n};\n\nUtil.getJSON = function(url, callback) {\n  var xmlhttp = typeof XMLHttpRequest !== 'undefined' ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');\n  xmlhttp.onreadystatechange = function() {\n    var status = xmlhttp.status;\n    if (xmlhttp.readyState === 4 && status >= 200 && status < 300) {\n      var json = JSON.parse(xmlhttp.responseText);\n      callback(null, json);\n    } else {\n      callback( { error: true, status: status } );\n    }\n  };\n  xmlhttp.open(\"GET\", url, true);\n  xmlhttp.send();\n};\n","/**\n * Created by Nicholas Hallahan <nhallahan@spatialdev.com>\n *       on 7/31/14.\n */\nvar Util = require('../MVTUtil');\nmodule.exports = StaticLabel;\n\nfunction StaticLabel(mvtFeature, ctx, latLng, style) {\n  var self = this;\n  this.mvtFeature = mvtFeature;\n  this.map = mvtFeature.map;\n  this.zoom = ctx.zoom;\n  this.latLng = latLng;\n  this.selected = false;\n\n  if (mvtFeature.linkedFeature) {\n    var linkedFeature = mvtFeature.linkedFeature();\n    if (linkedFeature && linkedFeature.selected) {\n      self.selected = true;\n    }\n  }\n\n  init(self, mvtFeature, ctx, latLng, style)\n}\n\nfunction init(self, mvtFeature, ctx, latLng, style) {\n  var ajaxData = mvtFeature.ajaxData;\n  var sty = self.style = style.staticLabel(mvtFeature, ajaxData);\n  var icon = self.icon = L.divIcon({\n    className: sty.cssClass || 'label-icon-text',\n    html: sty.html,\n    iconSize: sty.iconSize || [50,50]\n  });\n\n  self.marker = L.marker(latLng, {icon: icon}).addTo(self.map);\n\n  if (self.selected) {\n    self.marker._icon.classList.add(self.style.cssSelectedClass || 'label-icon-text-selected');\n  }\n\n  self.marker.on('click', function(e) {\n    self.toggle();\n  });\n\n  self.map.on('zoomend', function(e) {\n    var newZoom = e.target.getZoom();\n    if (self.zoom !== newZoom) {\n      self.map.removeLayer(self.marker);\n    }\n  });\n}\n\n\nStaticLabel.prototype.toggle = function() {\n  if (this.selected) {\n    this.deselect();\n  } else {\n    this.select();\n  }\n};\n\nStaticLabel.prototype.select = function() {\n  this.selected = true;\n  this.marker._icon.classList.add(this.style.cssSelectedClass || 'label-icon-text-selected');\n  var linkedFeature = this.mvtFeature.linkedFeature();\n  if (!linkedFeature.selected) linkedFeature.select();\n};\n\nStaticLabel.prototype.deselect = function() {\n  this.selected = false;\n  this.marker._icon.classList.remove(this.style.cssSelectedClass || 'label-icon-text-selected');\n  var linkedFeature = this.mvtFeature.linkedFeature();\n  if (linkedFeature.selected) linkedFeature.deselect();\n};\n\nStaticLabel.prototype.remove = function() {\n  if (!this.map || !this.marker) return;\n  this.map.removeLayer(this.marker);\n};\n","/**\n * Copyright (c) 2014, Spatial Development International\n * All rights reserved.\n *\n * Source code can be found at:\n * https://github.com/SpatialServer/Leaflet.MapboxVectorTile\n *\n * @license ISC\n */\n\nmodule.exports = require('./MVTSource');\n"]} diff --git a/examples/geojson.html b/examples/geojson.html new file mode 100644 index 0000000..77e8ce0 --- /dev/null +++ b/examples/geojson.html @@ -0,0 +1,23 @@ + + + GEojson + + + + + + +
+ + + + + + diff --git a/examples/geojson.js b/examples/geojson.js new file mode 100644 index 0000000..dea9e1e --- /dev/null +++ b/examples/geojson.js @@ -0,0 +1,41 @@ +var debug = {}; + +var map = L.map('map').setView([-5, 27.4], 5); // africa + +L.tileLayer('http://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', { + maxZoom: 18, + id: 'examples.map-i86knfo3' +}).addTo(map); + +var geojsonUrl = "https://cdn.rawgit.com/johan/world.geo.json/master/countries.geo.json" + +var xmlhttp = new XMLHttpRequest(); +xmlhttp.onreadystatechange = function() { + if (xmlhttp.readyState == 4 && xmlhttp.status == 200) { + var json = JSON.parse(xmlhttp.responseText); + geoJsonLoaded(json); + } +}; +xmlhttp.open("GET", geojsonUrl, true); +xmlhttp.send(); + +function geoJsonLoaded(geojson) { + + var mvtSource = new L.TileLayer.MVTSource({ + // url: "http://spatialserver.spatialdev.com/services/vector-tiles/GAUL_FSP/{z}/{x}/{y}.pbf", + geoJson: geojson, + debug: true, + getIDForLayerFeature: function(feature) { + return feature.properties.name; + }, + }); + + debug.mvtSource = mvtSource; + + //Globals that we can change later. + var fillColor = 'rgba(149,139,255,0.4)'; + var strokeColor = 'rgb(20,20,20)'; + + //Add layer + map.addLayer(mvtSource); +} diff --git a/package.json b/package.json index 9450950..7c52afc 100644 --- a/package.json +++ b/package.json @@ -24,7 +24,9 @@ "vector-tile": "1.1.3", "pbf": "1.3.5", "point-geometry": "0.0.0", - "request": "~2.44.0" + "request": "~2.44.0", + "geojson-vt": "2.1.8", + "vt-pbf": "2.0.2" }, "devDependencies": { "browserify": "~5.9.1", diff --git a/src/MVTSource.js b/src/MVTSource.js index 58d9927..d86f54c 100644 --- a/src/MVTSource.js +++ b/src/MVTSource.js @@ -3,7 +3,8 @@ var Protobuf = require('pbf'); var Point = require('point-geometry'); var Util = require('./MVTUtil'); var MVTLayer = require('./MVTLayer'); - +var geojsonvt = require('geojson-vt'); +var vtpbf = require('vt-pbf'); module.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({ @@ -189,13 +190,34 @@ module.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({ }, _draw: function(ctx) { - _fetchVectorTileXHR(ctx); + if (this.options.geoJson) { + this._fetchVectorTileGeojsonVt(ctx); + } else { + this._fetchVectorTileXHR(ctx); + } }, _vectorTileLoaded: function(ctx, vt) { this.checkVectorTileLayers(parseVT(vt), ctx); tileLoaded(this, ctx); - } + }, + + _fetchVectorTileGeojsonVt: function(ctx) { + var self = this; + if (!self._geojsonvtTileIndex) { + self._geojsonvtTileIndex = geojsonvt(self.options.geoJson); + } + // TODO: Timeout is neccessary because other operations depend on this being asynchronous + // 0ms timeout does not quite solve the problem, for reasons unknown. + window.setTimeout(function(){ + var vectorTileJson = self._geojsonvtTileIndex.getTile(ctx.zoom, ctx.tile.x, ctx.tile.y); + if (vectorTileJson) { + var reformatted = vtpbf.fromGeojsonVt({ 'geojsonLayer': vectorTileJson }); + self._vectorTileLoaded(ctx, new VectorTile(new Protobuf(reformatted))); + self.reduceTilesToProcessCount(); + } + }, 5); + }, _fetchVectorTileXHR: function(ctx) { var self = this; @@ -227,7 +249,7 @@ module.exports = L.TileLayer.MVTSource = L.TileLayer.Canvas.extend({ console.log("Fetched tile for zoom level " + ctx.zoom + ". Map is at zoom level " + self._map.getZoom()); return; } - _vectorTileLoaded(vt, ctx); + self._vectorTileLoaded(ctx, vt); } //either way, reduce the count of tilesToProcess tiles here