@deck.gl/carto 8.7.0-beta.3 → 8.7.0-beta.4

package/dist/dist.dev.js

@@ -27662,6 +27662,101 @@ var forEach = function () {
   };
 }();
 
+/***/ }),
+
+/***/ "../../node_modules/ieee754/index.js":
+/*!****************************************************************!*\
+  !*** /Users/alasarr/dev/deck.gl/node_modules/ieee754/index.js ***!
+  \****************************************************************/
+/*! no static exports found */
+/***/ (function(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]
+
+  i += d
+
+  e = s & ((1 << (-nBits)) - 1)
+  s >>= (-nBits)
+  nBits += eLen
+  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+  m = e & ((1 << (-nBits)) - 1)
+  e >>= (-nBits)
+  nBits += mLen
+  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+  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)
+}
+
+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
+    }
+
+    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
+    }
+  }
+
+  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+  e = (e << mLen) | m
+  eLen += mLen
+  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+  buffer[offset + i - d] |= s * 128
+}
+
+
 /***/ }),
 
 /***/ "../../node_modules/internmap/src/index.js":
@@ -50078,6 +50173,660 @@ webpackContext.id = "../../node_modules/moment/locale sync recursive ^\\.\\/.*$"
 
 /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/module.js */ "../../node_modules/webpack/buildin/module.js")(module)))
 
+/***/ }),
+
+/***/ "../../node_modules/pbf/index.js":
+/*!************************************************************!*\
+  !*** /Users/alasarr/dev/deck.gl/node_modules/pbf/index.js ***!
+  \************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = Pbf;
+
+var ieee754 = __webpack_require__(/*! ieee754 */ "../../node_modules/ieee754/index.js");
+
+function Pbf(buf) {
+    this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
+    this.pos = 0;
+    this.type = 0;
+    this.length = this.buf.length;
+}
+
+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 SHIFT_LEFT_32 = (1 << 16) * (1 << 16),
+    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
+
+// Threshold chosen based on both benchmarking and knowledge about browser string
+// data structures (which currently switch structure types at 12 bytes or more)
+var TEXT_DECODER_MIN_LENGTH = 12;
+var utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf8');
+
+Pbf.prototype = {
+
+    destroy: function() {
+        this.buf = null;
+    },
+
+    // === READING =================================================================
+
+    readFields: function(readField, result, end) {
+        end = end || this.length;
+
+        while (this.pos < end) {
+            var val = this.readVarint(),
+                tag = val >> 3,
+                startPos = this.pos;
+
+            this.type = val & 0x7;
+            readField(tag, result, this);
+
+            if (this.pos === startPos) this.skip(val);
+        }
+        return result;
+    },
+
+    readMessage: function(readField, result) {
+        return this.readFields(readField, result, this.readVarint() + this.pos);
+    },
+
+    readFixed32: function() {
+        var val = readUInt32(this.buf, this.pos);
+        this.pos += 4;
+        return val;
+    },
+
+    readSFixed32: function() {
+        var val = readInt32(this.buf, this.pos);
+        this.pos += 4;
+        return val;
+    },
+
+    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)
+
+    readFixed64: function() {
+        var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+        this.pos += 8;
+        return val;
+    },
+
+    readSFixed64: function() {
+        var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+        this.pos += 8;
+        return val;
+    },
+
+    readFloat: function() {
+        var val = ieee754.read(this.buf, this.pos, true, 23, 4);
+        this.pos += 4;
+        return val;
+    },
+
+    readDouble: function() {
+        var val = ieee754.read(this.buf, this.pos, true, 52, 8);
+        this.pos += 8;
+        return val;
+    },
+
+    readVarint: function(isSigned) {
+        var buf = this.buf,
+            val, b;
+
+        b = buf[this.pos++]; val  =  b & 0x7f;        if (b < 0x80) return val;
+        b = buf[this.pos++]; val |= (b & 0x7f) << 7;  if (b < 0x80) return val;
+        b = buf[this.pos++]; val |= (b & 0x7f) << 14; if (b < 0x80) return val;
+        b = buf[this.pos++]; val |= (b & 0x7f) << 21; if (b < 0x80) return val;
+        b = buf[this.pos];   val |= (b & 0x0f) << 28;
+
+        return readVarintRemainder(val, isSigned, this);
+    },
+
+    readVarint64: function() { // for compatibility with v2.0.1
+        return this.readVarint(true);
+    },
+
+    readSVarint: function() {
+        var num = this.readVarint();
+        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
+    },
+
+    readBoolean: function() {
+        return Boolean(this.readVarint());
+    },
+
+    readString: function() {
+        var end = this.readVarint() + this.pos;
+        var pos = this.pos;
+        this.pos = end;
+
+        if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
+            // longer strings are fast with the built-in browser TextDecoder API
+            return readUtf8TextDecoder(this.buf, pos, end);
+        }
+        // short strings are fast with our custom implementation
+        return readUtf8(this.buf, pos, end);
+    },
+
+    readBytes: function() {
+        var end = this.readVarint() + this.pos,
+            buffer = this.buf.subarray(this.pos, end);
+        this.pos = end;
+        return buffer;
+    },
+
+    // verbose for performance reasons; doesn't affect gzipped size
+
+    readPackedVarint: function(arr, isSigned) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readVarint(isSigned));
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readVarint(isSigned));
+        return arr;
+    },
+    readPackedSVarint: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readSVarint());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readSVarint());
+        return arr;
+    },
+    readPackedBoolean: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readBoolean());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readBoolean());
+        return arr;
+    },
+    readPackedFloat: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readFloat());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readFloat());
+        return arr;
+    },
+    readPackedDouble: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readDouble());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readDouble());
+        return arr;
+    },
+    readPackedFixed32: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed32());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readFixed32());
+        return arr;
+    },
+    readPackedSFixed32: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed32());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readSFixed32());
+        return arr;
+    },
+    readPackedFixed64: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed64());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readFixed64());
+        return arr;
+    },
+    readPackedSFixed64: function(arr) {
+        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed64());
+        var end = readPackedEnd(this);
+        arr = arr || [];
+        while (this.pos < end) arr.push(this.readSFixed64());
+        return arr;
+    },
+
+    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);
+    },
+
+    // === WRITING =================================================================
+
+    writeTag: function(tag, type) {
+        this.writeVarint((tag << 3) | type);
+    },
+
+    realloc: function(min) {
+        var length = this.length || 16;
+
+        while (length < this.pos + min) length *= 2;
+
+        if (length !== this.length) {
+            var buf = new Uint8Array(length);
+            buf.set(this.buf);
+            this.buf = buf;
+            this.length = length;
+        }
+    },
+
+    finish: function() {
+        this.length = this.pos;
+        this.pos = 0;
+        return this.buf.subarray(0, this.length);
+    },
+
+    writeFixed32: function(val) {
+        this.realloc(4);
+        writeInt32(this.buf, val, this.pos);
+        this.pos += 4;
+    },
+
+    writeSFixed32: function(val) {
+        this.realloc(4);
+        writeInt32(this.buf, val, this.pos);
+        this.pos += 4;
+    },
+
+    writeFixed64: function(val) {
+        this.realloc(8);
+        writeInt32(this.buf, val & -1, this.pos);
+        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+        this.pos += 8;
+    },
+
+    writeSFixed64: function(val) {
+        this.realloc(8);
+        writeInt32(this.buf, val & -1, this.pos);
+        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+        this.pos += 8;
+    },
+
+    writeVarint: function(val) {
+        val = +val || 0;
+
+        if (val > 0xfffffff || val < 0) {
+            writeBigVarint(val, this);
+            return;
+        }
+
+        this.realloc(4);
+
+        this.buf[this.pos++] =           val & 0x7f  | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
+        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
+        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
+        this.buf[this.pos++] =   (val >>> 7) & 0x7f;
+    },
+
+    writeSVarint: function(val) {
+        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
+    },
+
+    writeBoolean: function(val) {
+        this.writeVarint(Boolean(val));
+    },
+
+    writeString: function(str) {
+        str = String(str);
+        this.realloc(str.length * 4);
+
+        this.pos++; // reserve 1 byte for short string length
+
+        var startPos = this.pos;
+        // write the string directly to the buffer and see how much was written
+        this.pos = writeUtf8(this.buf, str, this.pos);
+        var len = this.pos - startPos;
+
+        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);
+
+        // finally, write the message length in the reserved place and restore the position
+        this.pos = startPos - 1;
+        this.writeVarint(len);
+        this.pos += len;
+    },
+
+    writeFloat: function(val) {
+        this.realloc(4);
+        ieee754.write(this.buf, val, this.pos, true, 23, 4);
+        this.pos += 4;
+    },
+
+    writeDouble: function(val) {
+        this.realloc(8);
+        ieee754.write(this.buf, val, this.pos, true, 52, 8);
+        this.pos += 8;
+    },
+
+    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];
+    },
+
+    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;
+
+        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);
+
+        // 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);
+    },
+
+    writePackedVarint:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedVarint, arr);   },
+    writePackedSVarint:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSVarint, arr);  },
+    writePackedBoolean:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedBoolean, arr);  },
+    writePackedFloat:    function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFloat, arr);    },
+    writePackedDouble:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedDouble, arr);   },
+    writePackedFixed32:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed32, arr);  },
+    writePackedSFixed32: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed32, arr); },
+    writePackedFixed64:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed64, arr);  },
+    writePackedSFixed64: function(tag, arr) { if (arr.length) 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));
+    }
+};
+
+function readVarintRemainder(l, s, p) {
+    var buf = p.buf,
+        h, b;
+
+    b = buf[p.pos++]; h  = (b & 0x70) >> 4;  if (b < 0x80) return toNum(l, h, s);
+    b = buf[p.pos++]; h |= (b & 0x7f) << 3;  if (b < 0x80) return toNum(l, h, s);
+    b = buf[p.pos++]; h |= (b & 0x7f) << 10; if (b < 0x80) return toNum(l, h, s);
+    b = buf[p.pos++]; h |= (b & 0x7f) << 17; if (b < 0x80) return toNum(l, h, s);
+    b = buf[p.pos++]; h |= (b & 0x7f) << 24; if (b < 0x80) return toNum(l, h, s);
+    b = buf[p.pos++]; h |= (b & 0x01) << 31; if (b < 0x80) return toNum(l, h, s);
+
+    throw new Error('Expected varint not more than 10 bytes');
+}
+
+function readPackedEnd(pbf) {
+    return pbf.type === Pbf.Bytes ?
+        pbf.readVarint() + pbf.pos : pbf.pos + 1;
+}
+
+function toNum(low, high, isSigned) {
+    if (isSigned) {
+        return high * 0x100000000 + (low >>> 0);
+    }
+
+    return ((high >>> 0) * 0x100000000) + (low >>> 0);
+}
+
+function writeBigVarint(val, pbf) {
+    var low, high;
+
+    if (val >= 0) {
+        low  = (val % 0x100000000) | 0;
+        high = (val / 0x100000000) | 0;
+    } else {
+        low  = ~(-val % 0x100000000);
+        high = ~(-val / 0x100000000);
+
+        if (low ^ 0xffffffff) {
+            low = (low + 1) | 0;
+        } else {
+            low = 0;
+            high = (high + 1) | 0;
+        }
+    }
+
+    if (val >= 0x10000000000000000 || val < -0x10000000000000000) {
+        throw new Error('Given varint doesn\'t fit into 10 bytes');
+    }
+
+    pbf.realloc(10);
+
+    writeBigVarintLow(low, high, pbf);
+    writeBigVarintHigh(high, pbf);
+}
+
+function writeBigVarintLow(low, high, pbf) {
+    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    pbf.buf[pbf.pos]   = low & 0x7f;
+}
+
+function writeBigVarintHigh(high, pbf) {
+    var lsb = (high & 0x07) << 4;
+
+    pbf.buf[pbf.pos++] |= lsb         | ((high >>>= 3) ? 0x80 : 0); if (!high) return;
+    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    pbf.buf[pbf.pos++]  = high & 0x7f;
+}
+
+function makeRoomForExtraLength(startPos, len, pbf) {
+    var extraLen =
+        len <= 0x3fff ? 1 :
+        len <= 0x1fffff ? 2 :
+        len <= 0xfffffff ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
+
+    // if 1 byte isn't enough for encoding message length, shift the data to the right
+    pbf.realloc(extraLen);
+    for (var i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];
+}
+
+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]); }
+
+// Buffer code below from https://github.com/feross/buffer, MIT-licensed
+
+function readUInt32(buf, pos) {
+    return ((buf[pos]) |
+        (buf[pos + 1] << 8) |
+        (buf[pos + 2] << 16)) +
+        (buf[pos + 3] * 0x1000000);
+}
+
+function writeInt32(buf, val, pos) {
+    buf[pos] = val;
+    buf[pos + 1] = (val >>> 8);
+    buf[pos + 2] = (val >>> 16);
+    buf[pos + 3] = (val >>> 24);
+}
+
+function readInt32(buf, pos) {
+    return ((buf[pos]) |
+        (buf[pos + 1] << 8) |
+        (buf[pos + 2] << 16)) +
+        (buf[pos + 3] << 24);
+}
+
+function readUtf8(buf, pos, end) {
+    var str = '';
+    var i = pos;
+
+    while (i < end) {
+        var b0 = buf[i];
+        var c = null; // codepoint
+        var bytesPerSequence =
+            b0 > 0xEF ? 4 :
+            b0 > 0xDF ? 3 :
+            b0 > 0xBF ? 2 : 1;
+
+        if (i + bytesPerSequence > end) break;
+
+        var b1, b2, b3;
+
+        if (bytesPerSequence === 1) {
+            if (b0 < 0x80) {
+                c = b0;
+            }
+        } else if (bytesPerSequence === 2) {
+            b1 = buf[i + 1];
+            if ((b1 & 0xC0) === 0x80) {
+                c = (b0 & 0x1F) << 0x6 | (b1 & 0x3F);
+                if (c <= 0x7F) {
+                    c = null;
+                }
+            }
+        } else if (bytesPerSequence === 3) {
+            b1 = buf[i + 1];
+            b2 = buf[i + 2];
+            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80) {
+                c = (b0 & 0xF) << 0xC | (b1 & 0x3F) << 0x6 | (b2 & 0x3F);
+                if (c <= 0x7FF || (c >= 0xD800 && c <= 0xDFFF)) {
+                    c = null;
+                }
+            }
+        } else if (bytesPerSequence === 4) {
+            b1 = buf[i + 1];
+            b2 = buf[i + 2];
+            b3 = buf[i + 3];
+            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {
+                c = (b0 & 0xF) << 0x12 | (b1 & 0x3F) << 0xC | (b2 & 0x3F) << 0x6 | (b3 & 0x3F);
+                if (c <= 0xFFFF || c >= 0x110000) {
+                    c = null;
+                }
+            }
+        }
+
+        if (c === null) {
+            c = 0xFFFD;
+            bytesPerSequence = 1;
+
+        } else if (c > 0xFFFF) {
+            c -= 0x10000;
+            str += String.fromCharCode(c >>> 10 & 0x3FF | 0xD800);
+            c = 0xDC00 | c & 0x3FF;
+        }
+
+        str += String.fromCharCode(c);
+        i += bytesPerSequence;
+    }
+
+    return str;
+}
+
+function readUtf8TextDecoder(buf, pos, end) {
+    return utf8TextDecoder.decode(buf.subarray(pos, end));
+}
+
+function writeUtf8(buf, str, pos) {
+    for (var i = 0, c, lead; i < str.length; i++) {
+        c = str.charCodeAt(i); // code point
+
+        if (c > 0xD7FF && c < 0xE000) {
+            if (lead) {
+                if (c < 0xDC00) {
+                    buf[pos++] = 0xEF;
+                    buf[pos++] = 0xBF;
+                    buf[pos++] = 0xBD;
+                    lead = c;
+                    continue;
+                } else {
+                    c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;
+                    lead = null;
+                }
+            } else {
+                if (c > 0xDBFF || (i + 1 === str.length)) {
+                    buf[pos++] = 0xEF;
+                    buf[pos++] = 0xBF;
+                    buf[pos++] = 0xBD;
+                } else {
+                    lead = c;
+                }
+                continue;
+            }
+        } else if (lead) {
+            buf[pos++] = 0xEF;
+            buf[pos++] = 0xBF;
+            buf[pos++] = 0xBD;
+            lead = null;
+        }
+
+        if (c < 0x80) {
+            buf[pos++] = c;
+        } else {
+            if (c < 0x800) {
+                buf[pos++] = c >> 0x6 | 0xC0;
+            } else {
+                if (c < 0x10000) {
+                    buf[pos++] = c >> 0xC | 0xE0;
+                } else {
+                    buf[pos++] = c >> 0x12 | 0xF0;
+                    buf[pos++] = c >> 0xC & 0x3F | 0x80;
+                }
+                buf[pos++] = c >> 0x6 & 0x3F | 0x80;
+            }
+            buf[pos++] = c & 0x3F | 0x80;
+        }
+    }
+    return pos;
+}
+
+
 /***/ }),
 
 /***/ "../../node_modules/webpack/buildin/module.js":
@@ -52139,7 +52888,7 @@ module.exports = Object.assign(deck, {
 /*!**************************!*\
   !*** ./src/api/index.js ***!
   \**************************/
-/*! exports provided: FORMATS, MAP_TYPES, API_VERSIONS, getDataV2, CONNECTIONS, fetchLayerData, fetchMap, getData, mapInstantiation */
+/*! exports provided: FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS, getDataV2, CONNECTIONS, fetchLayerData, fetchMap, getData, mapInstantiation */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -52147,6 +52896,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _maps_api_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./maps-api-common */ "./src/api/maps-api-common.js");
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "FORMATS", function() { return _maps_api_common__WEBPACK_IMPORTED_MODULE_0__["FORMATS"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TILE_FORMATS", function() { return _maps_api_common__WEBPACK_IMPORTED_MODULE_0__["TILE_FORMATS"]; });
+
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MAP_TYPES", function() { return _maps_api_common__WEBPACK_IMPORTED_MODULE_0__["MAP_TYPES"]; });
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "API_VERSIONS", function() { return _maps_api_common__WEBPACK_IMPORTED_MODULE_0__["API_VERSIONS"]; });
@@ -52472,7 +53223,8 @@ const FORMATS = {
   NDJSON: 'ndjson',
   TILEJSON: 'tilejson',
   JSON: 'json'
-};
+}; // AVAILABLE FORMATS FOR TILES
+
 const TILE_FORMATS = {
   MVT: 'mvt',
   GEOJSON: 'geojson',
@@ -53453,7 +54205,7 @@ function buildMapsUrlFromBase(apiBaseUrl) {
 /*!**********************!*\
   !*** ./src/index.js ***!
   \**********************/
-/*! exports provided: getDefaultCredentials, setDefaultCredentials, CartoLayer, _CartoDynamicTileLayer, BASEMAP, colorBins, colorCategories, colorContinuous, FORMATS, MAP_TYPES, API_VERSIONS, fetchLayerData, fetchMap, _getDataV2, getData, _mapInstantiation */
+/*! exports provided: getDefaultCredentials, setDefaultCredentials, CartoLayer, _CartoDynamicTileLayer, BASEMAP, colorBins, colorCategories, colorContinuous, FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS, fetchLayerData, fetchMap, _getDataV2, getData, _mapInstantiation */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -53484,6 +54236,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./api */ "./src/api/index.js");
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "FORMATS", function() { return _api__WEBPACK_IMPORTED_MODULE_7__["FORMATS"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TILE_FORMATS", function() { return _api__WEBPACK_IMPORTED_MODULE_7__["TILE_FORMATS"]; });
+
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MAP_TYPES", function() { return _api__WEBPACK_IMPORTED_MODULE_7__["MAP_TYPES"]; });
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "API_VERSIONS", function() { return _api__WEBPACK_IMPORTED_MODULE_7__["API_VERSIONS"]; });
@@ -53519,11 +54273,14 @@ __webpack_require__.r(__webpack_exports__);
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return CartoDynamicTileLayer; });
-/* harmony import */ var _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @deck.gl/core */ "@deck.gl/core");
-/* harmony import */ var _deck_gl_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_deck_gl_core__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _deck_gl_extensions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @deck.gl/extensions */ "../extensions/src/index.ts");
-/* harmony import */ var _loaders_gl_gis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @loaders.gl/gis */ "../../node_modules/@loaders.gl/gis/dist/esm/index.js");
-/* harmony import */ var _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../api/maps-api-common */ "./src/api/maps-api-common.js");
+/* harmony import */ var pbf__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! pbf */ "../../node_modules/pbf/index.js");
+/* harmony import */ var pbf__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(pbf__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _deck_gl_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @deck.gl/core */ "@deck.gl/core");
+/* harmony import */ var _deck_gl_core__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_deck_gl_core__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _deck_gl_extensions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @deck.gl/extensions */ "../extensions/src/index.ts");
+/* harmony import */ var _loaders_gl_gis__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @loaders.gl/gis */ "../../node_modules/@loaders.gl/gis/dist/esm/index.js");
+/* harmony import */ var _schema_carto_dynamic_tile__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./schema/carto-dynamic-tile */ "./src/layers/schema/carto-dynamic-tile.js");
+/* harmony import */ var _api_maps_api_common__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../api/maps-api-common */ "./src/api/maps-api-common.js");
 /* global TextDecoder */
 
 
@@ -53532,15 +54289,57 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+
 function parseJSON(arrayBuffer) {
   return JSON.parse(new TextDecoder().decode(arrayBuffer));
 }
 
+function parsePbf(buffer) {
+  const pbf = new pbf__WEBPACK_IMPORTED_MODULE_0___default.a(buffer);
+  const tile = _schema_carto_dynamic_tile__WEBPACK_IMPORTED_MODULE_4__["Tile"].read(pbf);
+  return tile;
+}
+
+function unpackProperties(properties) {
+  if (!properties || !properties.length) {
+    return [];
+  }
+
+  return properties.map(item => {
+    const currentRecord = {};
+    item.data.forEach(({
+      key,
+      value
+    }) => {
+      currentRecord[key] = value;
+    });
+    return currentRecord;
+  });
+}
+
 function parseCartoDynamicTile(arrayBuffer, options) {
   if (!arrayBuffer) return null;
   const formatTiles = options && options.cartoDynamicTile && options.cartoDynamicTile.formatTiles;
-  if (formatTiles === 'geojson') return Object(_loaders_gl_gis__WEBPACK_IMPORTED_MODULE_2__["geojsonToBinary"])(parseJSON(arrayBuffer).features);
-  return null;
+  if (formatTiles === _api_maps_api_common__WEBPACK_IMPORTED_MODULE_5__["TILE_FORMATS"].GEOJSON) return Object(_loaders_gl_gis__WEBPACK_IMPORTED_MODULE_3__["geojsonToBinary"])(parseJSON(arrayBuffer).features);
+  const tile = parsePbf(arrayBuffer);
+  const {
+    points,
+    lines,
+    polygons
+  } = tile;
+  const data = {
+    points: { ...points,
+      properties: unpackProperties(points.properties)
+    },
+    lines: { ...lines,
+      properties: unpackProperties(lines.properties)
+    },
+    polygons: { ...polygons,
+      properties: unpackProperties(polygons.properties)
+    }
+  };
+  return data;
 }
 
 const CartoDynamicTileLoader = {
@@ -53555,13 +54354,13 @@ const CartoDynamicTileLoader = {
   parseSync: parseCartoDynamicTile,
   options: {
     cartoDynamicTile: {
-      formatTiles: 'geojson'
+      formatTiles: _api_maps_api_common__WEBPACK_IMPORTED_MODULE_5__["TILE_FORMATS"].BINARY
     }
   }
 };
-class CartoDynamicTileLayer extends _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["MVTLayer"] {
+class CartoDynamicTileLayer extends _deck_gl_core__WEBPACK_IMPORTED_MODULE_1__["MVTLayer"] {
   getTileData(tile) {
-    let url = Object(_deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["_getURLFromTemplate"])(this.state.data, tile);
+    let url = Object(_deck_gl_core__WEBPACK_IMPORTED_MODULE_1__["_getURLFromTemplate"])(this.state.data, tile);
 
     if (!url) {
       return Promise.reject('Invalid URL');
@@ -53580,9 +54379,9 @@ class CartoDynamicTileLayer extends _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["
     };
 
     if (formatTiles) {
-      _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["log"].assert(['geojson'].includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}`);
-      url += `&${Object(_api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["encodeParameter"])('formatTiles', formatTiles)}`;
-      loadOptions.cartoBinaryTile = {
+      _deck_gl_core__WEBPACK_IMPORTED_MODULE_1__["log"].assert(Object.values(_api_maps_api_common__WEBPACK_IMPORTED_MODULE_5__["TILE_FORMATS"]).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
+      url += `&${Object(_api_maps_api_common__WEBPACK_IMPORTED_MODULE_5__["encodeParameter"])('formatTiles', formatTiles)}`;
+      loadOptions.cartoDynamicTile = {
         formatTiles
       };
     }
@@ -53609,16 +54408,16 @@ class CartoDynamicTileLayer extends _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["
         north
       }
     } = props.tile;
-    props.extensions = [new _deck_gl_extensions__WEBPACK_IMPORTED_MODULE_1__["ClipExtension"]()];
+    props.extensions = [new _deck_gl_extensions__WEBPACK_IMPORTED_MODULE_2__["ClipExtension"](), ...props.extensions];
     props.clipBounds = [west, south, east, north];
-    const subLayer = new _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["GeoJsonLayer"]({ ...props
+    const subLayer = new _deck_gl_core__WEBPACK_IMPORTED_MODULE_1__["GeoJsonLayer"]({ ...props
     });
     return subLayer;
   }
 
 }
 CartoDynamicTileLayer.layerName = 'CartoDynamicTileLayer';
-CartoDynamicTileLayer.defaultProps = { ..._deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["MVTLayer"].defaultProps,
+CartoDynamicTileLayer.defaultProps = { ..._deck_gl_core__WEBPACK_IMPORTED_MODULE_1__["MVTLayer"].defaultProps,
   loaders: [CartoDynamicTileLoader]
 };
 
@@ -53676,6 +54475,9 @@ const defaultProps = {
   connection: null,
   // (String, optional): format of data
   format: null,
+  // (String, optional): format of data
+  formatTiles: _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["TILE_FORMATS"].GEOJSON,
+  // TODO: for 8.7 release switch to BINARY
   // (String, optional): clientId identifier used for internal tracing, place here a string to identify the client who is doing the request.
   clientId: null,
   // (String, optional): name of the `geo_column` in the CARTO platform. Use this override the default column ('geom'), from which the geometry information should be fetched.
@@ -53809,14 +54611,17 @@ class CartoLayer extends _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["CompositeLa
     } = this.state;
     if (!data) return null;
     const {
+      type,
       updateTriggers
     } = this.props;
     let layer;
     /* global URLSearchParams */
 
     const tilesFormat = apiVersion === _api__WEBPACK_IMPORTED_MODULE_2__["API_VERSIONS"].V3 && format === _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["FORMATS"].TILEJSON && new URLSearchParams(data.tiles[0]).get('format');
+    const nonMvtTiles = tilesFormat && tilesFormat !== _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["TILE_FORMATS"].MVT;
+    const dynamicTiles = apiVersion === _api__WEBPACK_IMPORTED_MODULE_2__["API_VERSIONS"].V3 && type === _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["MAP_TYPES"].TABLE && format === _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["FORMATS"].TILEJSON;
 
-    if (tilesFormat && tilesFormat !== _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["TILE_FORMATS"].MVT) {
+    if (nonMvtTiles || dynamicTiles) {
       layer = _carto_dynamic_tile_layer__WEBPACK_IMPORTED_MODULE_1__["default"];
     } else if (apiVersion === _api__WEBPACK_IMPORTED_MODULE_2__["API_VERSIONS"].V1 || apiVersion === _api__WEBPACK_IMPORTED_MODULE_2__["API_VERSIONS"].V2 || format === _api_maps_api_common__WEBPACK_IMPORTED_MODULE_3__["FORMATS"].TILEJSON) {
       layer = _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["MVTLayer"];
@@ -53825,9 +54630,11 @@ class CartoLayer extends _deck_gl_core__WEBPACK_IMPORTED_MODULE_0__["CompositeLa
     }
 
     const {
+      formatTiles,
       uniqueIdProperty
     } = defaultProps;
     const props = {
+      formatTiles,
       uniqueIdProperty,
       ...this.props
     };
@@ -53846,6 +54653,222 @@ CartoLayer.defaultProps = defaultProps;
 
 /***/ }),
 
+/***/ "./src/layers/schema/carto-dynamic-tile.js":
+/*!*************************************************!*\
+  !*** ./src/layers/schema/carto-dynamic-tile.js ***!
+  \*************************************************/
+/*! exports provided: Tile */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Tile", function() { return Tile; });
+// KeyValueObject ========================================
+const KeyValueObject = {};
+
+KeyValueObject.read = function (pbf, end) {
+  return pbf.readFields(KeyValueObject._readField, {
+    key: '',
+    value: ''
+  }, end);
+};
+
+KeyValueObject._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.key = pbf.readString();else if (tag === 2) obj.value = pbf.readString();
+}; // Properties ========================================
+
+
+const Properties = {};
+
+Properties.read = function (pbf, end) {
+  return pbf.readFields(Properties._readField, {
+    data: []
+  }, end);
+};
+
+Properties._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.data.push(KeyValueObject.read(pbf, pbf.readVarint() + pbf.pos));
+}; // Doubles ========================================
+
+
+const Doubles = {};
+
+Doubles.read = function (pbf, end) {
+  // TODO perhaps we can do better and directly map from the source
+  // ArrayBuffer using ArrayBuffer.slice()
+  const {
+    value,
+    size
+  } = pbf.readFields(Doubles._readField, {
+    value: [],
+    size: 0
+  }, end);
+  return {
+    value: new Float32Array(value),
+    size
+  };
+};
+
+Doubles._readField = function (tag, obj, pbf) {
+  if (tag === 1) pbf.readPackedDouble(obj.value);else if (tag === 2) obj.size = pbf.readVarint(true);
+}; // Ints ========================================
+
+
+const Ints = {};
+
+Ints.read = function (pbf, end) {
+  const {
+    value,
+    size
+  } = pbf.readFields(Ints._readField, {
+    value: [],
+    size: 0
+  }, end);
+  return {
+    value: new Uint32Array(value),
+    size
+  };
+};
+
+Ints._readField = function (tag, obj, pbf) {
+  if (tag === 1) pbf.readPackedVarint(obj.value);else if (tag === 2) obj.size = pbf.readVarint(true);
+}; // NumericProp ========================================
+
+
+const NumericProp = {};
+
+NumericProp.read = function (pbf, end) {
+  return pbf.readFields(NumericProp._readField, {
+    value: []
+  }, end);
+};
+
+NumericProp._readField = function (tag, obj, pbf) {
+  if (tag === 1) pbf.readPackedDouble(obj.value);
+}; // NumericPropKeyValue ========================================
+
+
+const NumericPropKeyValue = {};
+
+NumericPropKeyValue.read = function (pbf, end) {
+  return pbf.readFields(NumericPropKeyValue._readField, {
+    key: '',
+    value: null
+  }, end);
+};
+
+NumericPropKeyValue._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.key = pbf.readString();else if (tag === 2) obj.value = NumericProp.read(pbf, pbf.readVarint() + pbf.pos);
+}; // NumericProp._FieldEntry1 ========================================
+
+
+NumericProp._FieldEntry1 = {};
+
+NumericProp._FieldEntry1.read = function (pbf, end) {
+  return pbf.readFields(NumericProp._FieldEntry1._readField, {
+    key: '',
+    value: 0
+  }, end);
+};
+
+NumericProp._FieldEntry1._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.key = pbf.readString();else if (tag === 2) obj.value = pbf.readDouble();
+}; // StringProp ========================================
+
+
+const StringProp = {};
+
+StringProp.read = function (pbf, end) {
+  return pbf.readFields(StringProp._readField, {
+    value: []
+  }, end);
+};
+
+StringProp._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.value.push(pbf.readString());
+}; // Points ========================================
+
+
+const Points = {};
+
+Points.read = function (pbf, end) {
+  return pbf.readFields(Points._readField, {
+    positions: null,
+    globalFeatureIds: null,
+    featureIds: null,
+    properties: [],
+    numericProps: {}
+  }, end);
+};
+
+Points._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.positions = Doubles.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 2) obj.globalFeatureIds = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 3) obj.featureIds = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 4) obj.properties.push(Properties.read(pbf, pbf.readVarint() + pbf.pos));else if (tag === 5) {
+    const entry = NumericPropKeyValue.read(pbf, pbf.readVarint() + pbf.pos);
+    obj.numericProps[entry.key] = entry.value;
+  }
+}; // Lines ========================================
+
+
+const Lines = {};
+
+Lines.read = function (pbf, end) {
+  return pbf.readFields(Lines._readField, {
+    positions: null,
+    pathIndices: null,
+    globalFeatureIds: null,
+    featureIds: null,
+    properties: [],
+    numericProps: {}
+  }, end);
+};
+
+Lines._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.positions = Doubles.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 2) obj.pathIndices = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 3) obj.globalFeatureIds = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 4) obj.featureIds = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 5) obj.properties.push(Properties.read(pbf, pbf.readVarint() + pbf.pos));else if (tag === 6) {
+    const entry = NumericPropKeyValue.read(pbf, pbf.readVarint() + pbf.pos);
+    obj.numericProps[entry.key] = entry.value;
+  }
+}; // Polygons ========================================
+
+
+const Polygons = {};
+
+Polygons.read = function (pbf, end) {
+  return pbf.readFields(Polygons._readField, {
+    positions: null,
+    polygonIndices: null,
+    globalFeatureIds: null,
+    featureIds: null,
+    primitivePolygonIndices: null,
+    triangles: null,
+    properties: [],
+    numericProps: {}
+  }, end);
+};
+
+Polygons._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.positions = Doubles.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 2) obj.polygonIndices = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 3) obj.globalFeatureIds = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 4) obj.featureIds = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 5) obj.primitivePolygonIndices = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 6) obj.triangles = Ints.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 7) obj.properties.push(Properties.read(pbf, pbf.readVarint() + pbf.pos));else if (tag === 8) {
+    const entry = NumericPropKeyValue.read(pbf, pbf.readVarint() + pbf.pos);
+    obj.numericProps[entry.key] = entry.value;
+  }
+}; // Tile ========================================
+
+
+const Tile = {};
+
+Tile.read = function (pbf, end) {
+  return pbf.readFields(Tile._readField, {
+    points: null,
+    lines: null,
+    polygons: null
+  }, end);
+};
+
+Tile._readField = function (tag, obj, pbf) {
+  if (tag === 1) obj.points = Points.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 2) obj.lines = Lines.read(pbf, pbf.readVarint() + pbf.pos);else if (tag === 3) obj.polygons = Polygons.read(pbf, pbf.readVarint() + pbf.pos);
+};
+
+/***/ }),
+
 /***/ "./src/style/color-bins-style.js":
 /*!***************************************!*\
   !*** ./src/style/color-bins-style.js ***!