@deck.gl/carto 9.0.23 → 9.0.25

package/dist/dist.dev.js

@@ -41,9 +41,9 @@ var __exports__ = (() => {
   ));
   var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
-  // external-global-plugin:@deck.gl/core
-  var require_core = __commonJS({
-    "external-global-plugin:@deck.gl/core"(exports, module) {
+  // external-global-plugin:@deck.gl/layers
+  var require_layers = __commonJS({
+    "external-global-plugin:@deck.gl/layers"(exports, module) {
       module.exports = globalThis.deck;
     }
   });
@@ -55,116 +55,442 @@ var __exports__ = (() => {
     }
   });
 
-  // external-global-plugin:h3-js
-  var require_h3_js = __commonJS({
-    "external-global-plugin:h3-js"(exports, module) {
-      module.exports = globalThis.h3 || {};
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
     }
   });
 
-  // external-global-plugin:@loaders.gl/core
+  // external-global-plugin:@deck.gl/core
   var require_core2 = __commonJS({
-    "external-global-plugin:@loaders.gl/core"(exports, module) {
-      module.exports = globalThis.loaders;
+    "external-global-plugin:@deck.gl/core"(exports, module) {
+      module.exports = globalThis.deck;
     }
   });
 
-  // ../../node_modules/ieee754/index.js
-  var require_ieee754 = __commonJS({
-    "../../node_modules/ieee754/index.js"(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) {
+  // ../../node_modules/tilebelt/index.js
+  var require_tilebelt = __commonJS({
+    "../../node_modules/tilebelt/index.js"(exports, module) {
+      var d2r = Math.PI / 180;
+      var r2d = 180 / Math.PI;
+      function tileToBBOX(tile) {
+        var e = tile2lon(tile[0] + 1, tile[2]);
+        var w = tile2lon(tile[0], tile[2]);
+        var s = tile2lat(tile[1] + 1, tile[2]);
+        var n = tile2lat(tile[1], tile[2]);
+        return [w, s, e, n];
+      }
+      function tileToGeoJSON(tile) {
+        var bbox = tileToBBOX(tile);
+        var poly = {
+          type: "Polygon",
+          coordinates: [
+            [
+              [bbox[0], bbox[1]],
+              [bbox[0], bbox[3]],
+              [bbox[2], bbox[3]],
+              [bbox[2], bbox[1]],
+              [bbox[0], bbox[1]]
+            ]
+          ]
+        };
+        return poly;
+      }
+      function tile2lon(x, z) {
+        return x / Math.pow(2, z) * 360 - 180;
+      }
+      function tile2lat(y, z) {
+        var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+        return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+      }
+      function pointToTile(lon, lat, z) {
+        var tile = pointToTileFraction(lon, lat, z);
+        tile[0] = Math.floor(tile[0]);
+        tile[1] = Math.floor(tile[1]);
+        return tile;
+      }
+      function getChildren(tile) {
+        return [
+          [tile[0] * 2, tile[1] * 2, tile[2] + 1],
+          [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1],
+          [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1],
+          [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1]
+        ];
+      }
+      function getParent(tile) {
+        if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+          return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
+        } else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
+          return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
+        } else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+          return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
+        } else {
+          return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
         }
-        m = e & (1 << -nBits) - 1;
-        e >>= -nBits;
-        nBits += mLen;
-        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      }
+      function getSiblings(tile) {
+        return getChildren(getParent(tile));
+      }
+      function hasSiblings(tile, tiles2) {
+        var siblings = getSiblings(tile);
+        for (var i = 0; i < siblings.length; i++) {
+          if (!hasTile(tiles2, siblings[i]))
+            return false;
         }
-        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 true;
+      }
+      function hasTile(tiles2, tile) {
+        for (var i = 0; i < tiles2.length; i++) {
+          if (tilesEqual(tiles2[i], tile))
+            return true;
         }
-        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;
-          }
+        return false;
+      }
+      function tilesEqual(tile1, tile2) {
+        return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
+      }
+      function tileToQuadkey(tile) {
+        var index2 = "";
+        for (var z = tile[2]; z > 0; z--) {
+          var b = 0;
+          var mask = 1 << z - 1;
+          if ((tile[0] & mask) !== 0)
+            b++;
+          if ((tile[1] & mask) !== 0)
+            b += 2;
+          index2 += b.toString();
         }
-        for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+        return index2;
+      }
+      function quadkeyToTile(quadkey) {
+        var x = 0;
+        var y = 0;
+        var z = quadkey.length;
+        for (var i = z; i > 0; i--) {
+          var mask = 1 << i - 1;
+          switch (quadkey[z - i]) {
+            case "0":
+              break;
+            case "1":
+              x |= mask;
+              break;
+            case "2":
+              y |= mask;
+              break;
+            case "3":
+              x |= mask;
+              y |= mask;
+              break;
+          }
         }
-        e = e << mLen | m;
-        eLen += mLen;
-        for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+        return [x, y, z];
+      }
+      function bboxToTile(bboxCoords) {
+        var min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
+        var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
+        var bbox = [min2[0], min2[1], max2[0], max2[1]];
+        var z = getBboxZoom(bbox);
+        if (z === 0)
+          return [0, 0, 0];
+        var x = bbox[0] >>> 32 - z;
+        var y = bbox[1] >>> 32 - z;
+        return [x, y, z];
+      }
+      function getBboxZoom(bbox) {
+        var MAX_ZOOM = 28;
+        for (var z = 0; z < MAX_ZOOM; z++) {
+          var mask = 1 << 32 - (z + 1);
+          if ((bbox[0] & mask) != (bbox[2] & mask) || (bbox[1] & mask) != (bbox[3] & mask)) {
+            return z;
+          }
         }
-        buffer[offset + i - d] |= s * 128;
+        return MAX_ZOOM;
+      }
+      function pointToTileFraction(lon, lat, z) {
+        var sin = Math.sin(lat * d2r), z2 = Math.pow(2, z), x = z2 * (lon / 360 + 0.5), y = z2 * (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);
+        return [x, y, z];
+      }
+      module.exports = {
+        tileToGeoJSON,
+        tileToBBOX,
+        getChildren,
+        getParent,
+        getSiblings,
+        hasTile,
+        hasSiblings,
+        tilesEqual,
+        tileToQuadkey,
+        quadkeyToTile,
+        pointToTile,
+        bboxToTile,
+        pointToTileFraction
       };
     }
   });
 
-  // ../../node_modules/pbf/index.js
-  var require_pbf = __commonJS({
-    "../../node_modules/pbf/index.js"(exports, module) {
-      "use strict";
-      module.exports = Pbf;
-      var ieee754 = require_ieee754();
-      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;
+  // ../../node_modules/@mapbox/tile-cover/index.js
+  var require_tile_cover = __commonJS({
+    "../../node_modules/@mapbox/tile-cover/index.js"(exports) {
+      var tilebelt = require_tilebelt();
+      exports.geojson = function(geom, limits) {
+        return {
+          type: "FeatureCollection",
+          features: getTiles(geom, limits).map(tileToFeature)
+        };
+      };
+      function tileToFeature(t) {
+        return {
+          type: "Feature",
+          geometry: tilebelt.tileToGeoJSON(t),
+          properties: {}
+        };
+      }
+      exports.tiles = getTiles;
+      exports.indexes = function(geom, limits) {
+        return getTiles(geom, limits).map(tilebelt.tileToQuadkey);
+      };
+      function getTiles(geom, limits) {
+        var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles2 = [];
+        if (geom.type === "Point") {
+          return [tilebelt.pointToTile(coords[0], coords[1], maxZoom)];
+        } else if (geom.type === "MultiPoint") {
+          for (i = 0; i < coords.length; i++) {
+            tile = tilebelt.pointToTile(coords[i][0], coords[i][1], maxZoom);
+            tileHash[toID(tile[0], tile[1], tile[2])] = true;
+          }
+        } else if (geom.type === "LineString") {
+          lineCover(tileHash, coords, maxZoom);
+        } else if (geom.type === "MultiLineString") {
+          for (i = 0; i < coords.length; i++) {
+            lineCover(tileHash, coords[i], maxZoom);
+          }
+        } else if (geom.type === "Polygon") {
+          polygonCover(tileHash, tiles2, coords, maxZoom);
+        } else if (geom.type === "MultiPolygon") {
+          for (i = 0; i < coords.length; i++) {
+            polygonCover(tileHash, tiles2, coords[i], maxZoom);
+          }
+        } else {
+          throw new Error("Geometry type not implemented");
+        }
+        if (limits.min_zoom !== maxZoom) {
+          var len = tiles2.length;
+          appendHashTiles(tileHash, tiles2);
+          for (i = 0; i < len; i++) {
+            var t = tiles2[i];
+            tileHash[toID(t[0], t[1], t[2])] = true;
+          }
+          return mergeTiles(tileHash, tiles2, limits);
+        }
+        appendHashTiles(tileHash, tiles2);
+        return tiles2;
+      }
+      function mergeTiles(tileHash, tiles2, limits) {
+        var mergedTiles = [];
+        for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
+          var parentTileHash = {};
+          var parentTiles = [];
+          for (var i = 0; i < tiles2.length; i++) {
+            var t = tiles2[i];
+            if (t[0] % 2 === 0 && t[1] % 2 === 0) {
+              var id22 = toID(t[0] + 1, t[1], z), id32 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
+              if (tileHash[id22] && tileHash[id32] && tileHash[id4]) {
+                tileHash[toID(t[0], t[1], t[2])] = false;
+                tileHash[id22] = false;
+                tileHash[id32] = false;
+                tileHash[id4] = false;
+                var parentTile = [t[0] / 2, t[1] / 2, z - 1];
+                if (z - 1 === limits.min_zoom)
+                  mergedTiles.push(parentTile);
+                else {
+                  parentTileHash[toID(t[0] / 2, t[1] / 2, z - 1)] = true;
+                  parentTiles.push(parentTile);
+                }
+              }
+            }
+          }
+          for (i = 0; i < tiles2.length; i++) {
+            t = tiles2[i];
+            if (tileHash[toID(t[0], t[1], t[2])])
+              mergedTiles.push(t);
+          }
+          tileHash = parentTileHash;
+          tiles2 = parentTiles;
+        }
+        return mergedTiles;
+      }
+      function polygonCover(tileHash, tileArray, geom, zoom) {
+        var intersections = [];
+        for (var i = 0; i < geom.length; i++) {
+          var ring = [];
+          lineCover(tileHash, geom[i], zoom, ring);
+          for (var j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
+            var m = (j + 1) % len;
+            var y = ring[j][1];
+            if ((y > ring[k][1] || y > ring[m][1]) && (y < ring[k][1] || y < ring[m][1]) && y !== ring[m][1])
+              intersections.push(ring[j]);
+          }
+        }
+        intersections.sort(compareTiles);
+        for (i = 0; i < intersections.length; i += 2) {
+          y = intersections[i][1];
+          for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
+            var id4 = toID(x, y, zoom);
+            if (!tileHash[id4]) {
+              tileArray.push([x, y, zoom]);
+            }
+          }
+        }
+      }
+      function compareTiles(a, b) {
+        return a[1] - b[1] || a[0] - b[0];
+      }
+      function lineCover(tileHash, coords, maxZoom, ring) {
+        var prevX, prevY;
+        for (var i = 0; i < coords.length - 1; i++) {
+          var start = tilebelt.pointToTileFraction(coords[i][0], coords[i][1], maxZoom), stop = tilebelt.pointToTileFraction(coords[i + 1][0], coords[i + 1][1], maxZoom), x0 = start[0], y0 = start[1], x1 = stop[0], y1 = stop[1], dx = x1 - x0, dy = y1 - y0;
+          if (dy === 0 && dx === 0)
+            continue;
+          var sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1, x = Math.floor(x0), y = Math.floor(y0), tMaxX = dx === 0 ? Infinity : Math.abs(((dx > 0 ? 1 : 0) + x - x0) / dx), tMaxY = dy === 0 ? Infinity : Math.abs(((dy > 0 ? 1 : 0) + y - y0) / dy), tdx = Math.abs(sx / dx), tdy = Math.abs(sy / dy);
+          if (x !== prevX || y !== prevY) {
+            tileHash[toID(x, y, maxZoom)] = true;
+            if (ring && y !== prevY)
+              ring.push([x, y]);
+            prevX = x;
+            prevY = y;
+          }
+          while (tMaxX < 1 || tMaxY < 1) {
+            if (tMaxX < tMaxY) {
+              tMaxX += tdx;
+              x += sx;
+            } else {
+              tMaxY += tdy;
+              y += sy;
+            }
+            tileHash[toID(x, y, maxZoom)] = true;
+            if (ring && y !== prevY)
+              ring.push([x, y]);
+            prevX = x;
+            prevY = y;
+          }
+        }
+        if (ring && y === ring[0][1])
+          ring.pop();
+      }
+      function appendHashTiles(hash, tiles2) {
+        var keys = Object.keys(hash);
+        for (var i = 0; i < keys.length; i++) {
+          tiles2.push(fromID(+keys[i]));
+        }
+      }
+      function toID(x, y, z) {
+        var dim = 2 * (1 << z);
+        return (dim * y + x) * 32 + z;
+      }
+      function fromID(id4) {
+        var z = id4 % 32, dim = 2 * (1 << z), xy = (id4 - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
+        return [x, y, z];
+      }
+    }
+  });
+
+  // ../../node_modules/ieee754/index.js
+  var require_ieee754 = __commonJS({
+    "../../node_modules/ieee754/index.js"(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 & 255, i += d, m /= 256, mLen -= 8) {
+        }
+        e = e << mLen | m;
+        eLen += mLen;
+        for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+        }
+        buffer[offset + i - d] |= s * 128;
+      };
+    }
+  });
+
+  // ../../node_modules/pbf/index.js
+  var require_pbf = __commonJS({
+    "../../node_modules/pbf/index.js"(exports, module) {
+      "use strict";
+      module.exports = Pbf;
+      var ieee754 = require_ieee754();
+      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;
       Pbf.Fixed64 = 1;
       Pbf.Bytes = 2;
       Pbf.Fixed32 = 5;
@@ -592,549 +918,223 @@ var __exports__ = (() => {
         var low, high;
         if (val >= 0) {
           low = val % 4294967296 | 0;
-          high = val / 4294967296 | 0;
-        } else {
-          low = ~(-val % 4294967296);
-          high = ~(-val / 4294967296);
-          if (low ^ 4294967295) {
-            low = low + 1 | 0;
-          } else {
-            low = 0;
-            high = high + 1 | 0;
-          }
-        }
-        if (val >= 18446744073709552e3 || val < -18446744073709552e3) {
-          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 & 127 | 128;
-        low >>>= 7;
-        pbf.buf[pbf.pos++] = low & 127 | 128;
-        low >>>= 7;
-        pbf.buf[pbf.pos++] = low & 127 | 128;
-        low >>>= 7;
-        pbf.buf[pbf.pos++] = low & 127 | 128;
-        low >>>= 7;
-        pbf.buf[pbf.pos] = low & 127;
-      }
-      function writeBigVarintHigh(high, pbf) {
-        var lsb = (high & 7) << 4;
-        pbf.buf[pbf.pos++] |= lsb | ((high >>>= 3) ? 128 : 0);
-        if (!high)
-          return;
-        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
-        if (!high)
-          return;
-        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
-        if (!high)
-          return;
-        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
-        if (!high)
-          return;
-        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
-        if (!high)
-          return;
-        pbf.buf[pbf.pos++] = high & 127;
-      }
-      function makeRoomForExtraLength(startPos, len, pbf) {
-        var extraLen = len <= 16383 ? 1 : len <= 2097151 ? 2 : len <= 268435455 ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
-        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]);
-      }
-      function readUInt32(buf, pos) {
-        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + buf[pos + 3] * 16777216;
-      }
-      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;
-          var bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
-          if (i + bytesPerSequence > end)
-            break;
-          var b1, b2, b3;
-          if (bytesPerSequence === 1) {
-            if (b0 < 128) {
-              c = b0;
-            }
-          } else if (bytesPerSequence === 2) {
-            b1 = buf[i + 1];
-            if ((b1 & 192) === 128) {
-              c = (b0 & 31) << 6 | b1 & 63;
-              if (c <= 127) {
-                c = null;
-              }
-            }
-          } else if (bytesPerSequence === 3) {
-            b1 = buf[i + 1];
-            b2 = buf[i + 2];
-            if ((b1 & 192) === 128 && (b2 & 192) === 128) {
-              c = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
-              if (c <= 2047 || c >= 55296 && c <= 57343) {
-                c = null;
-              }
-            }
-          } else if (bytesPerSequence === 4) {
-            b1 = buf[i + 1];
-            b2 = buf[i + 2];
-            b3 = buf[i + 3];
-            if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
-              c = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
-              if (c <= 65535 || c >= 1114112) {
-                c = null;
-              }
-            }
-          }
-          if (c === null) {
-            c = 65533;
-            bytesPerSequence = 1;
-          } else if (c > 65535) {
-            c -= 65536;
-            str += String.fromCharCode(c >>> 10 & 1023 | 55296);
-            c = 56320 | c & 1023;
-          }
-          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);
-          if (c > 55295 && c < 57344) {
-            if (lead) {
-              if (c < 56320) {
-                buf[pos++] = 239;
-                buf[pos++] = 191;
-                buf[pos++] = 189;
-                lead = c;
-                continue;
-              } else {
-                c = lead - 55296 << 10 | c - 56320 | 65536;
-                lead = null;
-              }
-            } else {
-              if (c > 56319 || i + 1 === str.length) {
-                buf[pos++] = 239;
-                buf[pos++] = 191;
-                buf[pos++] = 189;
-              } else {
-                lead = c;
-              }
-              continue;
-            }
-          } else if (lead) {
-            buf[pos++] = 239;
-            buf[pos++] = 191;
-            buf[pos++] = 189;
-            lead = null;
-          }
-          if (c < 128) {
-            buf[pos++] = c;
-          } else {
-            if (c < 2048) {
-              buf[pos++] = c >> 6 | 192;
-            } else {
-              if (c < 65536) {
-                buf[pos++] = c >> 12 | 224;
-              } else {
-                buf[pos++] = c >> 18 | 240;
-                buf[pos++] = c >> 12 & 63 | 128;
-              }
-              buf[pos++] = c >> 6 & 63 | 128;
-            }
-            buf[pos++] = c & 63 | 128;
-          }
-        }
-        return pos;
-      }
-    }
-  });
-
-  // ../../node_modules/tilebelt/index.js
-  var require_tilebelt = __commonJS({
-    "../../node_modules/tilebelt/index.js"(exports, module) {
-      var d2r = Math.PI / 180;
-      var r2d = 180 / Math.PI;
-      function tileToBBOX(tile) {
-        var e = tile2lon(tile[0] + 1, tile[2]);
-        var w = tile2lon(tile[0], tile[2]);
-        var s = tile2lat(tile[1] + 1, tile[2]);
-        var n = tile2lat(tile[1], tile[2]);
-        return [w, s, e, n];
-      }
-      function tileToGeoJSON(tile) {
-        var bbox = tileToBBOX(tile);
-        var poly = {
-          type: "Polygon",
-          coordinates: [
-            [
-              [bbox[0], bbox[1]],
-              [bbox[0], bbox[3]],
-              [bbox[2], bbox[3]],
-              [bbox[2], bbox[1]],
-              [bbox[0], bbox[1]]
-            ]
-          ]
-        };
-        return poly;
-      }
-      function tile2lon(x, z) {
-        return x / Math.pow(2, z) * 360 - 180;
+          high = val / 4294967296 | 0;
+        } else {
+          low = ~(-val % 4294967296);
+          high = ~(-val / 4294967296);
+          if (low ^ 4294967295) {
+            low = low + 1 | 0;
+          } else {
+            low = 0;
+            high = high + 1 | 0;
+          }
+        }
+        if (val >= 18446744073709552e3 || val < -18446744073709552e3) {
+          throw new Error("Given varint doesn't fit into 10 bytes");
+        }
+        pbf.realloc(10);
+        writeBigVarintLow(low, high, pbf);
+        writeBigVarintHigh(high, pbf);
       }
-      function tile2lat(y, z) {
-        var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
-        return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+      function writeBigVarintLow(low, high, pbf) {
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos] = low & 127;
       }
-      function pointToTile(lon, lat, z) {
-        var tile = pointToTileFraction(lon, lat, z);
-        tile[0] = Math.floor(tile[0]);
-        tile[1] = Math.floor(tile[1]);
-        return tile;
+      function writeBigVarintHigh(high, pbf) {
+        var lsb = (high & 7) << 4;
+        pbf.buf[pbf.pos++] |= lsb | ((high >>>= 3) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127;
       }
-      function getChildren(tile) {
-        return [
-          [tile[0] * 2, tile[1] * 2, tile[2] + 1],
-          [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1],
-          [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1],
-          [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1]
-        ];
+      function makeRoomForExtraLength(startPos, len, pbf) {
+        var extraLen = len <= 16383 ? 1 : len <= 2097151 ? 2 : len <= 268435455 ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
+        pbf.realloc(extraLen);
+        for (var i = pbf.pos - 1; i >= startPos; i--)
+          pbf.buf[i + extraLen] = pbf.buf[i];
       }
-      function getParent(tile) {
-        if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-          return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
-        } else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
-          return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
-        } else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-          return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
-        } else {
-          return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
-        }
+      function writePackedVarint(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeVarint(arr[i]);
       }
-      function getSiblings(tile) {
-        return getChildren(getParent(tile));
+      function writePackedSVarint(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSVarint(arr[i]);
       }
-      function hasSiblings(tile, tiles2) {
-        var siblings = getSiblings(tile);
-        for (var i = 0; i < siblings.length; i++) {
-          if (!hasTile(tiles2, siblings[i]))
-            return false;
-        }
-        return true;
+      function writePackedFloat(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFloat(arr[i]);
       }
-      function hasTile(tiles2, tile) {
-        for (var i = 0; i < tiles2.length; i++) {
-          if (tilesEqual(tiles2[i], tile))
-            return true;
-        }
-        return false;
+      function writePackedDouble(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeDouble(arr[i]);
       }
-      function tilesEqual(tile1, tile2) {
-        return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
+      function writePackedBoolean(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeBoolean(arr[i]);
       }
-      function tileToQuadkey(tile) {
-        var index2 = "";
-        for (var z = tile[2]; z > 0; z--) {
-          var b = 0;
-          var mask = 1 << z - 1;
-          if ((tile[0] & mask) !== 0)
-            b++;
-          if ((tile[1] & mask) !== 0)
-            b += 2;
-          index2 += b.toString();
-        }
-        return index2;
+      function writePackedFixed32(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFixed32(arr[i]);
       }
-      function quadkeyToTile(quadkey) {
-        var x = 0;
-        var y = 0;
-        var z = quadkey.length;
-        for (var i = z; i > 0; i--) {
-          var mask = 1 << i - 1;
-          switch (quadkey[z - i]) {
-            case "0":
-              break;
-            case "1":
-              x |= mask;
-              break;
-            case "2":
-              y |= mask;
-              break;
-            case "3":
-              x |= mask;
-              y |= mask;
-              break;
-          }
-        }
-        return [x, y, z];
+      function writePackedSFixed32(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSFixed32(arr[i]);
       }
-      function bboxToTile(bboxCoords) {
-        var min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
-        var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
-        var bbox = [min2[0], min2[1], max2[0], max2[1]];
-        var z = getBboxZoom(bbox);
-        if (z === 0)
-          return [0, 0, 0];
-        var x = bbox[0] >>> 32 - z;
-        var y = bbox[1] >>> 32 - z;
-        return [x, y, z];
+      function writePackedFixed64(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFixed64(arr[i]);
       }
-      function getBboxZoom(bbox) {
-        var MAX_ZOOM = 28;
-        for (var z = 0; z < MAX_ZOOM; z++) {
-          var mask = 1 << 32 - (z + 1);
-          if ((bbox[0] & mask) != (bbox[2] & mask) || (bbox[1] & mask) != (bbox[3] & mask)) {
-            return z;
-          }
-        }
-        return MAX_ZOOM;
+      function writePackedSFixed64(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSFixed64(arr[i]);
       }
-      function pointToTileFraction(lon, lat, z) {
-        var sin = Math.sin(lat * d2r), z2 = Math.pow(2, z), x = z2 * (lon / 360 + 0.5), y = z2 * (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);
-        return [x, y, z];
+      function readUInt32(buf, pos) {
+        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + buf[pos + 3] * 16777216;
       }
-      module.exports = {
-        tileToGeoJSON,
-        tileToBBOX,
-        getChildren,
-        getParent,
-        getSiblings,
-        hasTile,
-        hasSiblings,
-        tilesEqual,
-        tileToQuadkey,
-        quadkeyToTile,
-        pointToTile,
-        bboxToTile,
-        pointToTileFraction
-      };
-    }
-  });
-
-  // ../../node_modules/@mapbox/tile-cover/index.js
-  var require_tile_cover = __commonJS({
-    "../../node_modules/@mapbox/tile-cover/index.js"(exports) {
-      var tilebelt = require_tilebelt();
-      exports.geojson = function(geom, limits) {
-        return {
-          type: "FeatureCollection",
-          features: getTiles(geom, limits).map(tileToFeature)
-        };
-      };
-      function tileToFeature(t) {
-        return {
-          type: "Feature",
-          geometry: tilebelt.tileToGeoJSON(t),
-          properties: {}
-        };
+      function writeInt32(buf, val, pos) {
+        buf[pos] = val;
+        buf[pos + 1] = val >>> 8;
+        buf[pos + 2] = val >>> 16;
+        buf[pos + 3] = val >>> 24;
       }
-      exports.tiles = getTiles;
-      exports.indexes = function(geom, limits) {
-        return getTiles(geom, limits).map(tilebelt.tileToQuadkey);
-      };
-      function getTiles(geom, limits) {
-        var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles2 = [];
-        if (geom.type === "Point") {
-          return [tilebelt.pointToTile(coords[0], coords[1], maxZoom)];
-        } else if (geom.type === "MultiPoint") {
-          for (i = 0; i < coords.length; i++) {
-            tile = tilebelt.pointToTile(coords[i][0], coords[i][1], maxZoom);
-            tileHash[toID(tile[0], tile[1], tile[2])] = true;
-          }
-        } else if (geom.type === "LineString") {
-          lineCover(tileHash, coords, maxZoom);
-        } else if (geom.type === "MultiLineString") {
-          for (i = 0; i < coords.length; i++) {
-            lineCover(tileHash, coords[i], maxZoom);
-          }
-        } else if (geom.type === "Polygon") {
-          polygonCover(tileHash, tiles2, coords, maxZoom);
-        } else if (geom.type === "MultiPolygon") {
-          for (i = 0; i < coords.length; i++) {
-            polygonCover(tileHash, tiles2, coords[i], maxZoom);
-          }
-        } else {
-          throw new Error("Geometry type not implemented");
-        }
-        if (limits.min_zoom !== maxZoom) {
-          var len = tiles2.length;
-          appendHashTiles(tileHash, tiles2);
-          for (i = 0; i < len; i++) {
-            var t = tiles2[i];
-            tileHash[toID(t[0], t[1], t[2])] = true;
-          }
-          return mergeTiles(tileHash, tiles2, limits);
-        }
-        appendHashTiles(tileHash, tiles2);
-        return tiles2;
+      function readInt32(buf, pos) {
+        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + (buf[pos + 3] << 24);
       }
-      function mergeTiles(tileHash, tiles2, limits) {
-        var mergedTiles = [];
-        for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
-          var parentTileHash = {};
-          var parentTiles = [];
-          for (var i = 0; i < tiles2.length; i++) {
-            var t = tiles2[i];
-            if (t[0] % 2 === 0 && t[1] % 2 === 0) {
-              var id22 = toID(t[0] + 1, t[1], z), id32 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
-              if (tileHash[id22] && tileHash[id32] && tileHash[id4]) {
-                tileHash[toID(t[0], t[1], t[2])] = false;
-                tileHash[id22] = false;
-                tileHash[id32] = false;
-                tileHash[id4] = false;
-                var parentTile = [t[0] / 2, t[1] / 2, z - 1];
-                if (z - 1 === limits.min_zoom)
-                  mergedTiles.push(parentTile);
-                else {
-                  parentTileHash[toID(t[0] / 2, t[1] / 2, z - 1)] = true;
-                  parentTiles.push(parentTile);
-                }
+      function readUtf8(buf, pos, end) {
+        var str = "";
+        var i = pos;
+        while (i < end) {
+          var b0 = buf[i];
+          var c = null;
+          var bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
+          if (i + bytesPerSequence > end)
+            break;
+          var b1, b2, b3;
+          if (bytesPerSequence === 1) {
+            if (b0 < 128) {
+              c = b0;
+            }
+          } else if (bytesPerSequence === 2) {
+            b1 = buf[i + 1];
+            if ((b1 & 192) === 128) {
+              c = (b0 & 31) << 6 | b1 & 63;
+              if (c <= 127) {
+                c = null;
               }
             }
-          }
-          for (i = 0; i < tiles2.length; i++) {
-            t = tiles2[i];
-            if (tileHash[toID(t[0], t[1], t[2])])
-              mergedTiles.push(t);
-          }
-          tileHash = parentTileHash;
-          tiles2 = parentTiles;
-        }
-        return mergedTiles;
-      }
-      function polygonCover(tileHash, tileArray, geom, zoom) {
-        var intersections = [];
-        for (var i = 0; i < geom.length; i++) {
-          var ring = [];
-          lineCover(tileHash, geom[i], zoom, ring);
-          for (var j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
-            var m = (j + 1) % len;
-            var y = ring[j][1];
-            if ((y > ring[k][1] || y > ring[m][1]) && (y < ring[k][1] || y < ring[m][1]) && y !== ring[m][1])
-              intersections.push(ring[j]);
-          }
-        }
-        intersections.sort(compareTiles);
-        for (i = 0; i < intersections.length; i += 2) {
-          y = intersections[i][1];
-          for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
-            var id4 = toID(x, y, zoom);
-            if (!tileHash[id4]) {
-              tileArray.push([x, y, zoom]);
+          } else if (bytesPerSequence === 3) {
+            b1 = buf[i + 1];
+            b2 = buf[i + 2];
+            if ((b1 & 192) === 128 && (b2 & 192) === 128) {
+              c = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
+              if (c <= 2047 || c >= 55296 && c <= 57343) {
+                c = null;
+              }
             }
+          } else if (bytesPerSequence === 4) {
+            b1 = buf[i + 1];
+            b2 = buf[i + 2];
+            b3 = buf[i + 3];
+            if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
+              c = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
+              if (c <= 65535 || c >= 1114112) {
+                c = null;
+              }
+            }
+          }
+          if (c === null) {
+            c = 65533;
+            bytesPerSequence = 1;
+          } else if (c > 65535) {
+            c -= 65536;
+            str += String.fromCharCode(c >>> 10 & 1023 | 55296);
+            c = 56320 | c & 1023;
           }
+          str += String.fromCharCode(c);
+          i += bytesPerSequence;
         }
+        return str;
       }
-      function compareTiles(a, b) {
-        return a[1] - b[1] || a[0] - b[0];
+      function readUtf8TextDecoder(buf, pos, end) {
+        return utf8TextDecoder.decode(buf.subarray(pos, end));
       }
-      function lineCover(tileHash, coords, maxZoom, ring) {
-        var prevX, prevY;
-        for (var i = 0; i < coords.length - 1; i++) {
-          var start = tilebelt.pointToTileFraction(coords[i][0], coords[i][1], maxZoom), stop = tilebelt.pointToTileFraction(coords[i + 1][0], coords[i + 1][1], maxZoom), x0 = start[0], y0 = start[1], x1 = stop[0], y1 = stop[1], dx = x1 - x0, dy = y1 - y0;
-          if (dy === 0 && dx === 0)
-            continue;
-          var sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1, x = Math.floor(x0), y = Math.floor(y0), tMaxX = dx === 0 ? Infinity : Math.abs(((dx > 0 ? 1 : 0) + x - x0) / dx), tMaxY = dy === 0 ? Infinity : Math.abs(((dy > 0 ? 1 : 0) + y - y0) / dy), tdx = Math.abs(sx / dx), tdy = Math.abs(sy / dy);
-          if (x !== prevX || y !== prevY) {
-            tileHash[toID(x, y, maxZoom)] = true;
-            if (ring && y !== prevY)
-              ring.push([x, y]);
-            prevX = x;
-            prevY = y;
+      function writeUtf8(buf, str, pos) {
+        for (var i = 0, c, lead; i < str.length; i++) {
+          c = str.charCodeAt(i);
+          if (c > 55295 && c < 57344) {
+            if (lead) {
+              if (c < 56320) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+                lead = c;
+                continue;
+              } else {
+                c = lead - 55296 << 10 | c - 56320 | 65536;
+                lead = null;
+              }
+            } else {
+              if (c > 56319 || i + 1 === str.length) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+              } else {
+                lead = c;
+              }
+              continue;
+            }
+          } else if (lead) {
+            buf[pos++] = 239;
+            buf[pos++] = 191;
+            buf[pos++] = 189;
+            lead = null;
           }
-          while (tMaxX < 1 || tMaxY < 1) {
-            if (tMaxX < tMaxY) {
-              tMaxX += tdx;
-              x += sx;
+          if (c < 128) {
+            buf[pos++] = c;
+          } else {
+            if (c < 2048) {
+              buf[pos++] = c >> 6 | 192;
             } else {
-              tMaxY += tdy;
-              y += sy;
+              if (c < 65536) {
+                buf[pos++] = c >> 12 | 224;
+              } else {
+                buf[pos++] = c >> 18 | 240;
+                buf[pos++] = c >> 12 & 63 | 128;
+              }
+              buf[pos++] = c >> 6 & 63 | 128;
             }
-            tileHash[toID(x, y, maxZoom)] = true;
-            if (ring && y !== prevY)
-              ring.push([x, y]);
-            prevX = x;
-            prevY = y;
+            buf[pos++] = c & 63 | 128;
           }
         }
-        if (ring && y === ring[0][1])
-          ring.pop();
-      }
-      function appendHashTiles(hash, tiles2) {
-        var keys = Object.keys(hash);
-        for (var i = 0; i < keys.length; i++) {
-          tiles2.push(fromID(+keys[i]));
-        }
-      }
-      function toID(x, y, z) {
-        var dim = 2 * (1 << z);
-        return (dim * y + x) * 32 + z;
-      }
-      function fromID(id4) {
-        var z = id4 % 32, dim = 2 * (1 << z), xy = (id4 - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
-        return [x, y, z];
+        return pos;
       }
     }
   });
 
-  // external-global-plugin:@deck.gl/layers
-  var require_layers = __commonJS({
-    "external-global-plugin:@deck.gl/layers"(exports, module) {
-      module.exports = globalThis.deck;
+  // external-global-plugin:h3-js
+  var require_h3_js = __commonJS({
+    "external-global-plugin:h3-js"(exports, module) {
+      module.exports = globalThis.h3 || {};
     }
   });
 
@@ -6992,6 +6992,7 @@ var __exports__ = (() => {
     CARTO_LAYERS: () => CARTO_LAYERS,
     CARTO_SOURCES: () => CARTO_SOURCES,
     CartoAPIError: () => CartoAPIError,
+    ClusterTileLayer: () => ClusterTileLayer,
     H3TileLayer: () => H3TileLayer,
     HeatmapTileLayer: () => heatmap_tile_layer_default,
     QuadbinTileLayer: () => QuadbinTileLayer,
@@ -7024,252 +7025,420 @@ var __exports__ = (() => {
     vectorTilesetSource: () => vectorTilesetSource
   });
 
-  // src/layers/h3-tile-layer.ts
-  var import_core5 = __toESM(require_core(), 1);
-  var import_geo_layers3 = __toESM(require_geo_layers(), 1);
+  // src/layers/cluster-tile-layer.ts
+  var import_layers = __toESM(require_layers(), 1);
+  var import_geo_layers2 = __toESM(require_geo_layers(), 1);
+  var import_core4 = __toESM(require_core(), 1);
 
-  // src/layers/h3-tileset-2d.ts
-  var import_geo_layers = __toESM(require_geo_layers(), 1);
-  var import_h3_js = __toESM(require_h3_js(), 1);
-  var MAX_LATITUDE = 85.051128;
-  function padBoundingBox({ west, north, east, south }, resolution) {
-    const corners = [
-      [north, east],
-      [south, east],
-      [south, west],
-      [north, west]
-    ];
-    const cornerCells = corners.map((c) => (0, import_h3_js.latLngToCell)(c[0], c[1], resolution));
-    const cornerEdgeLengths = cornerCells.map(
-      (c) => Math.max(...(0, import_h3_js.originToDirectedEdges)(c).map((e) => (0, import_h3_js.edgeLength)(e, import_h3_js.UNITS.rads))) * 180 / Math.PI
-    );
-    const bufferLat = Math.max(...cornerEdgeLengths);
-    const bufferLon = Math.min(180, bufferLat / Math.cos((north + south) / 2 * Math.PI / 180));
-    return {
-      north: Math.min(north + bufferLat, MAX_LATITUDE),
-      east: east + bufferLon,
-      south: Math.max(south - bufferLat, -MAX_LATITUDE),
-      west: west - bufferLon
-    };
-  }
-  function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
-    const longitudeSpan = Math.abs(east - west);
-    if (longitudeSpan > 180) {
-      const nSegments = Math.ceil(longitudeSpan / 180);
-      let h3Indices = [];
-      for (let s = 0; s < nSegments; s++) {
-        const segmentWest = west + s * 180;
-        const segmentEast = Math.min(segmentWest + 179.9999999, east);
-        h3Indices = h3Indices.concat(
-          getHexagonsInBoundingBox({ west: segmentWest, north, east: segmentEast, south }, resolution)
-        );
+  // ../../node_modules/@loaders.gl/gis/dist/lib/binary-features/binary-to-geojson.js
+  function binaryToGeojson(data, options) {
+    const globalFeatureId = options?.globalFeatureId;
+    if (globalFeatureId !== void 0) {
+      return getSingleFeature(data, globalFeatureId);
+    }
+    return parseFeatures(data, options?.type);
+  }
+  function getSingleFeature(data, globalFeatureId) {
+    const dataArray = normalizeInput(data);
+    for (const data2 of dataArray) {
+      let lastIndex = 0;
+      let lastValue = data2.featureIds.value[0];
+      for (let i = 0; i < data2.featureIds.value.length; i++) {
+        const currValue = data2.featureIds.value[i];
+        if (currValue === lastValue) {
+          continue;
+        }
+        if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+          return parseFeature(data2, lastIndex, i);
+        }
+        lastIndex = i;
+        lastValue = currValue;
+      }
+      if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+        return parseFeature(data2, lastIndex, data2.featureIds.value.length);
       }
-      return [...new Set(h3Indices)];
     }
-    const polygon = [
-      [north, east],
-      [south, east],
-      [south, west],
-      [north, west],
-      [north, east]
-    ];
-    return (0, import_h3_js.polygonToCells)(polygon, resolution);
+    throw new Error(`featureId:${globalFeatureId} not found`);
   }
-  function tileToBoundingBox(index2) {
-    const coordinates = (0, import_h3_js.cellToBoundary)(index2);
-    const latitudes = coordinates.map((c) => c[0]);
-    const longitudes = coordinates.map((c) => c[1]);
-    const west = Math.min(...longitudes);
-    const south = Math.min(...latitudes);
-    const east = Math.max(...longitudes);
-    const north = Math.max(...latitudes);
-    return { west, south, east, north };
+  function parseFeatures(data, type) {
+    const dataArray = normalizeInput(data, type);
+    return parseFeatureCollection(dataArray);
   }
-  var BIAS = 2;
-  function getHexagonResolution(viewport, tileSize) {
-    const zoomOffset = Math.log2(tileSize / 512);
-    const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
-    const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
-    return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
+  function binaryToGeometry(data, startIndex, endIndex) {
+    switch (data.type) {
+      case "Point":
+        return pointToGeoJson(data, startIndex, endIndex);
+      case "LineString":
+        return lineStringToGeoJson(data, startIndex, endIndex);
+      case "Polygon":
+        return polygonToGeoJson(data, startIndex, endIndex);
+      default:
+        const unexpectedInput = data;
+        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
+    }
   }
-  var H3Tileset2D = class extends import_geo_layers._Tileset2D {
-    getTileIndices({ viewport, minZoom, maxZoom }) {
-      if (viewport.latitude === void 0)
-        return [];
-      const [west, south, east, north] = viewport.getBounds();
-      const { tileSize } = this.opts;
-      let z = getHexagonResolution(viewport, tileSize);
-      let indices;
-      if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
-        return [];
+  function normalizeInput(data, type) {
+    const features = [];
+    if (data.points) {
+      data.points.type = "Point";
+      features.push(data.points);
+    }
+    if (data.lines) {
+      data.lines.type = "LineString";
+      features.push(data.lines);
+    }
+    if (data.polygons) {
+      data.polygons.type = "Polygon";
+      features.push(data.polygons);
+    }
+    return features;
+  }
+  function parseFeatureCollection(dataArray) {
+    const features = [];
+    for (const data of dataArray) {
+      if (data.featureIds.value.length === 0) {
+        continue;
       }
-      if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
-        z = maxZoom;
-        const center = (0, import_h3_js.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
-        indices = (0, import_h3_js.gridDisk)(center, 1);
-      } else {
-        const paddedBounds = padBoundingBox({ west, north, east, south }, z);
-        indices = getHexagonsInBoundingBox(paddedBounds, z);
+      let lastIndex = 0;
+      let lastValue = data.featureIds.value[0];
+      for (let i = 0; i < data.featureIds.value.length; i++) {
+        const currValue = data.featureIds.value[i];
+        if (currValue === lastValue) {
+          continue;
+        }
+        features.push(parseFeature(data, lastIndex, i));
+        lastIndex = i;
+        lastValue = currValue;
       }
-      return indices.map((i) => ({ i }));
+      features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
     }
-    getTileId({ i }) {
-      return i;
+    return features;
+  }
+  function parseFeature(data, startIndex, endIndex) {
+    const geometry = binaryToGeometry(data, startIndex, endIndex);
+    const properties = parseProperties(data, startIndex, endIndex);
+    const fields = parseFields(data, startIndex, endIndex);
+    return { type: "Feature", geometry, properties, ...fields };
+  }
+  function parseFields(data, startIndex = 0, endIndex) {
+    return data.fields && data.fields[data.featureIds.value[startIndex]];
+  }
+  function parseProperties(data, startIndex = 0, endIndex) {
+    const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
+    for (const key in data.numericProps) {
+      properties[key] = data.numericProps[key].value[startIndex];
     }
-    getTileMetadata({ i }) {
-      return { bbox: tileToBoundingBox(i) };
+    return properties;
+  }
+  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const { positions } = data;
+    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = polygonIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = [];
+      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+        const startRingIndex = primitivePolygonIndices[i];
+        const endRingIndex = primitivePolygonIndices[i + 1];
+        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+        coordinates2.push(ringCoordinates);
+      }
+      return { type: "Polygon", coordinates: coordinates2 };
     }
-    getTileZoom({ i }) {
-      return (0, import_h3_js.getResolution)(i);
+    const coordinates = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startPolygonIndex = polygonIndices[i];
+      const endPolygonIndex = polygonIndices[i + 1];
+      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+      coordinates.push(polygonCoordinates);
     }
-    getParentIndex(index2) {
-      const resolution = (0, import_h3_js.getResolution)(index2.i);
-      const i = (0, import_h3_js.cellToParent)(index2.i, resolution - 1);
-      return { i };
+    return { type: "MultiPolygon", coordinates };
+  }
+  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const { positions } = data;
+    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = pathIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+      return { type: "LineString", coordinates: coordinates2 };
     }
-  };
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
+    }
+    return { type: "MultiLineString", coordinates };
+  }
+  function pointToGeoJson(data, startIndex, endIndex) {
+    const { positions } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+      return { type: "MultiPoint", coordinates };
+    }
+    return { type: "Point", coordinates: coordinates[0] };
+  }
+  function ringToGeoJson(positions, startIndex, endIndex) {
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+      const coord = Array();
+      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+        coord.push(Number(positions.value[k]));
+      }
+      ringCoordinates.push(coord);
+    }
+    return ringCoordinates;
+  }
 
-  // src/layers/spatial-index-tile-layer.ts
-  var import_core2 = __toESM(require_core2(), 1);
+  // src/layers/cluster-tile-layer.ts
+  var import_core5 = __toESM(require_core2(), 1);
 
-  // src/layers/schema/fast-pbf.ts
-  function readPackedTypedArray(TypedArray, pbf, obj) {
-    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
-    obj.value = new TypedArray(pbf.buf.buffer.slice(pbf.pos, end));
-    pbf.pos = end;
-    return obj.value;
+  // ../../node_modules/quadbin/dist/esm/index.js
+  var import_tile_cover = __toESM(require_tile_cover(), 1);
+  var B = [
+    0x5555555555555555n,
+    0x3333333333333333n,
+    0x0f0f0f0f0f0f0f0fn,
+    0x00ff00ff00ff00ffn,
+    0x0000ffff0000ffffn,
+    0x00000000ffffffffn
+  ];
+  var S = [0n, 1n, 2n, 4n, 8n, 16n];
+  function hexToBigInt(hex2) {
+    return BigInt(`0x${hex2}`);
   }
-
-  // src/layers/schema/carto-raster-tile.ts
-  var ARRAY_TYPES = {
-    uint8: Uint8Array,
-    uint16: Uint16Array,
-    uint32: Uint32Array,
-    uint64: BigUint64Array,
-    int8: Int8Array,
-    int16: Int16Array,
-    int32: Int32Array,
-    int64: BigInt64Array,
-    float32: Float32Array,
-    float64: Float64Array
-  };
-  var BandReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(BandReader._readField, { name: "", type: "", data: null }, end);
+  function bigIntToHex(index2) {
+    return index2.toString(16);
+  }
+  function tileToCell(tile) {
+    if (tile.z < 0 || tile.z > 26) {
+      throw new Error("Wrong zoom");
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.name = pbf.readString();
-      else if (tag === 2)
-        obj.type = pbf.readString();
-      else if (tag === 3) {
-        const TypedArray = ARRAY_TYPES[obj.type];
-        if (!TypedArray) {
-          throw Error(`Invalid data type: ${obj.type}`);
-        }
-        obj.data = {};
-        readPackedTypedArray(TypedArray, pbf, obj.data);
-      }
+    const z = BigInt(tile.z);
+    let x = BigInt(tile.x) << 32n - z;
+    let y = BigInt(tile.y) << 32n - z;
+    for (let i = 0; i < 5; i++) {
+      const s = S[5 - i];
+      const b = B[4 - i];
+      x = (x | x << s) & b;
+      y = (y | y << s) & b;
     }
-  };
-  var TileReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(TileReader._readField, { blockSize: 0, bands: [] }, end);
+    const quadbin = 0x4000000000000000n | 1n << 59n | z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
+    return quadbin;
+  }
+  function cellToTile(quadbin) {
+    const mode = quadbin >> 59n & 7n;
+    const modeDep = quadbin >> 57n & 3n;
+    const z = quadbin >> 52n & 0x1fn;
+    const q = (quadbin & 0xfffffffffffffn) << 12n;
+    if (mode !== 1n && modeDep !== 0n) {
+      throw new Error("Wrong mode");
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.blockSize = pbf.readVarint();
-      else if (tag === 2)
-        obj.bands.push(BandReader.read(pbf, pbf.readVarint() + pbf.pos));
+    let x = q;
+    let y = q >> 1n;
+    for (let i = 0; i < 6; i++) {
+      const s = S[i];
+      const b = B[i];
+      x = (x | x >> s) & b;
+      y = (y | y >> s) & b;
     }
-  };
-
-  // src/layers/schema/tile-loader-utils.ts
-  var import_pbf = __toESM(require_pbf(), 1);
-  function parsePbf(buffer, TileReader5) {
-    const pbf = new import_pbf.default(buffer);
-    const tile = TileReader5.read(pbf);
-    return tile;
+    x = x >> 32n - z;
+    y = y >> 32n - z;
+    return { z: Number(z), x: Number(x), y: Number(y) };
   }
-
-  // src/utils.ts
-  var import_core = __toESM(require_core(), 1);
-  function assert(condition, message) {
-    import_core.log.assert(condition, message);
+  function getResolution(quadbin) {
+    return quadbin >> 52n & 0x1fn;
   }
-  function createBinaryProxy(data, index2) {
-    const { properties, numericProps } = data;
-    return new Proxy(properties[index2] || {}, {
-      get(target, property) {
-        if (property in numericProps) {
-          return numericProps[property].value[index2];
+  function cellToParent(quadbin) {
+    const zparent = getResolution(quadbin) - 1n;
+    const parent = quadbin & ~(0x1fn << 52n) | zparent << 52n | 0xfffffffffffffn >> zparent * 2n;
+    return parent;
+  }
+
+  // src/layers/cluster-utils.ts
+  function aggregateTile(tile, aggregationLevels, properties = [], getPosition, getWeight) {
+    if (!tile.content)
+      return;
+    if (!tile.userData)
+      tile.userData = {};
+    if (tile.userData[aggregationLevels])
+      return;
+    const out = {};
+    for (const cell of tile.content) {
+      let id4 = cell.id;
+      const position = typeof getPosition === "function" ? getPosition(cell, {}) : getPosition;
+      for (let i = 0; i < aggregationLevels - 1; i++) {
+        id4 = cellToParent(id4);
+      }
+      const parentId = Number(id4);
+      if (!(parentId in out)) {
+        out[parentId] = { id: id4, count: 0, position: [0, 0] };
+        for (const { name, aggregation } of properties) {
+          if (aggregation === "any") {
+            out[parentId][name] = cell.properties[name];
+          } else {
+            out[parentId][name] = 0;
+          }
         }
-        return target[property];
-      },
-      has(target, property) {
-        return property in numericProps || property in target;
       }
-    });
+      const prevTotalW = out[parentId].count;
+      out[parentId].count += typeof getWeight === "function" ? getWeight(cell, {}) : getWeight;
+      const totalW = out[parentId].count;
+      const W = totalW - prevTotalW;
+      out[parentId].position[0] = (prevTotalW * out[parentId].position[0] + W * position[0]) / totalW;
+      out[parentId].position[1] = (prevTotalW * out[parentId].position[1] + W * position[1]) / totalW;
+      for (const { name, aggregation } of properties) {
+        const prevValue = out[parentId][name];
+        const value = cell.properties[name];
+        if (aggregation === "average") {
+          out[parentId][name] = (prevTotalW * prevValue + W * value) / totalW;
+        } else if (aggregation === "count" || aggregation === "sum") {
+          out[parentId][name] = prevValue + value;
+        } else if (aggregation === "max") {
+          out[parentId][name] = Math.max(prevValue, value);
+        } else if (aggregation === "min") {
+          out[parentId][name] = Math.min(prevValue, value);
+        }
+      }
+    }
+    tile.userData[aggregationLevels] = Object.values(out);
   }
-  function getWorkerUrl(id4, version) {
-    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id4}-worker.js`;
+  function extractAggregationProperties(tile) {
+    const properties = [];
+    const validAggregations = ["any", "average", "count", "min", "max", "sum"];
+    for (const name of Object.keys(tile.content[0].properties)) {
+      let aggregation = name.split("_").pop().toLowerCase();
+      if (!validAggregations.includes(aggregation)) {
+        aggregation = "any";
+      }
+      properties.push({ name, aggregation });
+    }
+    return properties;
   }
-  function scaleIdentity() {
-    let unknown;
-    function scale(x) {
-      return x === null ? unknown : x;
+  function computeAggregationStats(data, properties) {
+    const stats = {};
+    for (const { name, aggregation } of properties) {
+      stats[name] = { min: Infinity, max: -Infinity };
+      if (aggregation !== "any") {
+        for (const d of data) {
+          stats[name].min = Math.min(stats[name].min, d[name]);
+          stats[name].max = Math.max(stats[name].max, d[name]);
+        }
+      }
     }
-    scale.invert = scale;
-    scale.domain = scale.range = (d) => d;
-    scale.unknown = (u) => {
-      if (u) {
-        unknown = u;
+    return stats;
+  }
+  var EMPTY_UINT16ARRAY = new Uint16Array();
+  var EMPTY_BINARY_PROPS = {
+    positions: { value: new Float32Array(), size: 2 },
+    properties: [],
+    numericProps: {},
+    featureIds: { value: EMPTY_UINT16ARRAY, size: 1 },
+    globalFeatureIds: { value: EMPTY_UINT16ARRAY, size: 1 }
+  };
+  function clustersToBinary(data) {
+    const positions = new Float32Array(data.length * 2);
+    const featureIds = new Uint16Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+      positions.set(data[i].position, 2 * i);
+      featureIds[i] = i;
+    }
+    return {
+      shape: "binary-feature-collection",
+      points: {
+        type: "Point",
+        positions: { value: positions, size: 2 },
+        properties: data,
+        numericProps: {},
+        featureIds: { value: featureIds, size: 1 },
+        globalFeatureIds: { value: featureIds, size: 1 }
+      },
+      lines: {
+        type: "LineString",
+        pathIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+        ...EMPTY_BINARY_PROPS
+      },
+      polygons: {
+        type: "Polygon",
+        polygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+        primitivePolygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+        ...EMPTY_BINARY_PROPS
       }
-      return unknown;
-    };
-    scale.copy = () => {
-      const scaleCopy = scaleIdentity();
-      scaleCopy.unknown(unknown);
-      return scaleCopy;
     };
-    return scale;
   }
-  var isObject = (x) => x !== null && typeof x === "object";
-  var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
 
-  // src/layers/schema/carto-raster-tile-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var id = "cartoRasterTile";
-  var DEFAULT_OPTIONS = {
-    cartoRasterTile: {
-      workerUrl: getWorkerUrl(id, VERSION)
-    }
-  };
-  var CartoRasterTileLoader = {
-    name: "CARTO Raster Tile",
-    version: VERSION,
-    id,
-    module: "carto",
-    extensions: ["pbf"],
-    mimeTypes: ["application/vnd.carto-raster-tile"],
-    category: "geometry",
-    parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
-    parseSync: parseCartoRasterTile,
-    worker: true,
-    options: DEFAULT_OPTIONS
-  };
-  function parseCartoRasterTile(arrayBuffer, options) {
-    if (!arrayBuffer)
-      return null;
-    const { bands, blockSize } = parsePbf(arrayBuffer, TileReader);
-    const numericProps = {};
-    for (let i = 0; i < bands.length; i++) {
-      const { name, data } = bands[i];
-      numericProps[name] = data;
-    }
-    return { blockSize, cells: { numericProps, properties: [] } };
+  // src/constants.ts
+  var DEFAULT_TILE_SIZE = 512;
+  var DEFAULT_TILE_RESOLUTION = 0.5;
+  var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+  var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+  // src/layers/quadbin-tileset-2d.ts
+  var import_geo_layers = __toESM(require_geo_layers(), 1);
+  var QuadbinTileset2D = class extends import_geo_layers._Tileset2D {
+    getTileIndices(opts) {
+      return super.getTileIndices(opts).map(tileToCell).map((q) => ({ q, i: bigIntToHex(q) }));
+    }
+    getTileId({ q, i }) {
+      return i || bigIntToHex(q);
+    }
+    getTileMetadata({ q }) {
+      return super.getTileMetadata(cellToTile(q));
+    }
+    getTileZoom({ q }) {
+      return Number(getResolution(q));
+    }
+    getParentIndex({ q }) {
+      return { q: cellToParent(q) };
+    }
+  };
+
+  // ../../node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
+  var PI = Math.PI;
+  var PI_4 = PI / 4;
+  var DEGREES_TO_RADIANS = PI / 180;
+  var RADIANS_TO_DEGREES = 180 / PI;
+  var TILE_SIZE = 512;
+  function worldToLngLat(xy) {
+    const [x, y] = xy;
+    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+    return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
+  }
+
+  // ../../node_modules/@math.gl/web-mercator/dist/get-bounds.js
+  var DEGREES_TO_RADIANS2 = Math.PI / 180;
+
+  // src/layers/quadbin-utils.ts
+  var TILE_SIZE2 = 512;
+  function quadbinToOffset(quadbin) {
+    const { x, y, z } = cellToTile(quadbin);
+    const scale = TILE_SIZE2 / (1 << z);
+    return [x * scale, TILE_SIZE2 - y * scale, scale];
+  }
+  function quadbinToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
+    return [
+      [xOffset, yOffset],
+      [xOffset + coverage * scale, yOffset - coverage * scale]
+    ];
+  }
+  function getQuadbinPolygon(quadbin, coverage = 1) {
+    const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
+    const [w, n] = worldToLngLat(topLeft);
+    const [e, s] = worldToLngLat(bottomRight);
+    return [e, n, e, s, w, s, w, n, e, n];
+  }
+
+  // src/layers/schema/fast-pbf.ts
+  function readPackedTypedArray(TypedArray, pbf, obj) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    obj.value = new TypedArray(pbf.buf.buffer.slice(pbf.pos, end));
+    pbf.pos = end;
+    return obj.value;
   }
-  var carto_raster_tile_loader_default = CartoRasterTileLoader;
 
   // src/layers/schema/carto-tile.ts
   var KeyValueObjectReader = class {
@@ -7452,9 +7621,9 @@ var __exports__ = (() => {
         obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
     }
   };
-  var TileReader2 = class {
+  var TileReader = class {
     static read(pbf, end) {
-      return pbf.readFields(TileReader2._readField, { points: null, lines: null, polygons: null }, end);
+      return pbf.readFields(TileReader._readField, { points: null, lines: null, polygons: null }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -7466,176 +7635,519 @@ var __exports__ = (() => {
     }
   };
 
-  // src/layers/schema/carto-spatial-tile.ts
-  var IndicesReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(IndicesReader._readField, { value: [] }, end);
-    }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        readPackedTypedArray(BigUint64Array, pbf, obj);
-    }
+  // src/layers/schema/carto-spatial-tile.ts
+  var IndicesReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(IndicesReader._readField, { value: [] }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        readPackedTypedArray(BigUint64Array, pbf, obj);
+    }
+  };
+  var CellsReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(
+        CellsReader._readField,
+        { indices: null, properties: [], numericProps: {} },
+        end
+      );
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.indices = IndicesReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 2)
+        obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+      else if (tag === 3) {
+        const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj.numericProps[entry.key] = entry.value;
+      }
+    }
+  };
+  var TileReader2 = class {
+    static read(pbf, end) {
+      return pbf.readFields(TileReader2._readField, { scheme: 0, cells: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.scheme = pbf.readVarint();
+      else if (tag === 2)
+        obj.cells = CellsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    }
+  };
+
+  // src/layers/schema/tile-loader-utils.ts
+  var import_pbf = __toESM(require_pbf(), 1);
+  function parsePbf(buffer, TileReader5) {
+    const pbf = new import_pbf.default(buffer);
+    const tile = TileReader5.read(pbf);
+    return tile;
+  }
+
+  // src/utils.ts
+  var import_core = __toESM(require_core2(), 1);
+  function assert2(condition, message) {
+    import_core.log.assert(condition, message);
+  }
+  function createBinaryProxy(data, index2) {
+    const { properties, numericProps } = data;
+    return new Proxy(properties[index2] || {}, {
+      get(target, property) {
+        if (property in numericProps) {
+          return numericProps[property].value[index2];
+        }
+        return target[property];
+      },
+      has(target, property) {
+        return property in numericProps || property in target;
+      },
+      ownKeys(target) {
+        return [...Object.keys(numericProps), ...Reflect.ownKeys(target)];
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return { enumerable: true, configurable: true };
+      }
+    });
+  }
+  function getWorkerUrl(id4, version) {
+    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id4}-worker.js`;
+  }
+  function scaleIdentity() {
+    let unknown;
+    function scale(x) {
+      return x === null ? unknown : x;
+    }
+    scale.invert = scale;
+    scale.domain = scale.range = (d) => d;
+    scale.unknown = (u) => {
+      if (u) {
+        unknown = u;
+      }
+      return unknown;
+    };
+    scale.copy = () => {
+      const scaleCopy = scaleIdentity();
+      scaleCopy.unknown(unknown);
+      return scaleCopy;
+    };
+    return scale;
+  }
+  var isObject = (x) => x !== null && typeof x === "object";
+  var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
+
+  // src/layers/schema/spatialjson-utils.ts
+  function binaryToSpatialjson(binary) {
+    const { cells, scheme } = binary;
+    const count = cells.indices.value.length;
+    const spatial = [];
+    for (let i = 0; i < count; i++) {
+      const id4 = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
+      const properties = { ...cells.properties[i] };
+      for (const key of Object.keys(cells.numericProps)) {
+        properties[key] = cells.numericProps[key].value[i];
+      }
+      spatial.push({ id: id4, properties });
+    }
+    return spatial;
+  }
+
+  // src/layers/schema/carto-spatial-tile-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id = "cartoSpatialTile";
+  var DEFAULT_OPTIONS = {
+    cartoSpatialTile: {
+      scheme: "quadbin",
+      workerUrl: getWorkerUrl(id, VERSION)
+    }
+  };
+  var CartoSpatialTileLoader = {
+    name: "CARTO Spatial Tile",
+    version: VERSION,
+    id,
+    module: "carto",
+    extensions: ["pbf"],
+    mimeTypes: ["application/vnd.carto-spatial-tile"],
+    category: "geometry",
+    parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
+    parseSync: parseCartoSpatialTile,
+    worker: true,
+    options: DEFAULT_OPTIONS
+  };
+  function parseCartoSpatialTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+      return null;
+    const tile = parsePbf(arrayBuffer, TileReader2);
+    const { cells } = tile;
+    const scheme = options?.cartoSpatialTile?.scheme;
+    const data = { cells, scheme };
+    return binaryToSpatialjson(data);
+  }
+  var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
+
+  // src/layers/utils.ts
+  var import_core2 = __toESM(require_core2(), 1);
+  var import_core3 = __toESM(require_core2(), 1);
+  function injectAccessToken(loadOptions, accessToken) {
+    if (!loadOptions?.fetch?.headers?.Authorization) {
+      loadOptions.fetch = {
+        ...loadOptions.fetch,
+        headers: { ...loadOptions.fetch?.headers, Authorization: `Bearer ${accessToken}` }
+      };
+    }
+  }
+  function mergeBoundaryData(geometry, properties) {
+    const mapping = {};
+    for (const { geoid, ...rest } of properties.properties) {
+      if (geoid in mapping) {
+        import_core2.log.warn("Duplicate geoid key in boundary mapping, using first occurance")();
+      } else {
+        mapping[geoid] = rest;
+      }
+    }
+    for (const type of ["points", "lines", "polygons"]) {
+      const geom = geometry[type];
+      if (geom.positions.value.length === 0) {
+        continue;
+      }
+      geom.properties = geom.properties.map(({ geoid }) => mapping[geoid]);
+      const { positions, globalFeatureIds } = geom;
+      let indices = null;
+      if (type === "lines")
+        indices = geom.pathIndices.value;
+      if (type === "polygons")
+        indices = geom.polygonIndices.value;
+      const length = positions.value.length / positions.size;
+      for (const key in properties.numericProps) {
+        const sourceProp = properties.numericProps[key].value;
+        const TypedArray = sourceProp.constructor;
+        const destProp = new TypedArray(length);
+        geom.numericProps[key] = { value: destProp, size: 1 };
+        if (!indices) {
+          for (let i = 0; i < length; i++) {
+            const featureId = globalFeatureIds.value[i];
+            destProp[i] = sourceProp[featureId];
+          }
+        } else {
+          for (let i = 0; i < indices.length - 1; i++) {
+            const startIndex = indices[i];
+            const endIndex = indices[i + 1];
+            const featureId = globalFeatureIds.value[startIndex];
+            destProp.fill(sourceProp[featureId], startIndex, endIndex);
+          }
+        }
+      }
+    }
+    return geometry;
+  }
+  var TilejsonPropType = {
+    type: "object",
+    value: null,
+    validate: (value, propType) => propType.optional && value === null || typeof value === "object" && Array.isArray(value.tiles) && value.tiles.every((url) => typeof url === "string"),
+    equal: (value1, value2) => {
+      return (0, import_core3._deepEqual)(value1, value2, 2);
+    },
+    async: true
+  };
+
+  // src/layers/cluster-tile-layer.ts
+  (0, import_core4.registerLoaders)([carto_spatial_tile_loader_default]);
+  var defaultProps = {
+    data: TilejsonPropType,
+    clusterLevel: { type: "number", value: 5, min: 1 },
+    getPosition: {
+      type: "accessor",
+      value: ({ id: id4 }) => getQuadbinPolygon(id4, 0.5).slice(2, 4)
+    },
+    getWeight: { type: "accessor", value: 1 },
+    refinementStrategy: "no-overlap",
+    tileSize: DEFAULT_TILE_SIZE
   };
-  var CellsReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(
-        CellsReader._readField,
-        { indices: null, properties: [], numericProps: {} },
-        end
-      );
+  var ClusterGeoJsonLayer = class extends import_geo_layers2.TileLayer {
+    renderLayers() {
+      const visibleTiles = this.state.tileset?.tiles.filter((tile) => {
+        return tile.isLoaded && tile.content && this.state.tileset.isTileVisible(tile);
+      });
+      if (!visibleTiles?.length) {
+        return null;
+      }
+      visibleTiles.sort((a, b) => b.zoom - a.zoom);
+      const { zoom } = this.context.viewport;
+      const { clusterLevel, getPosition, getWeight } = this.props;
+      const properties = extractAggregationProperties(visibleTiles[0]);
+      const data = [];
+      for (const tile of visibleTiles) {
+        const overZoom = Math.round(zoom - tile.zoom);
+        const aggregationLevels = Math.round(clusterLevel) - overZoom;
+        aggregateTile(tile, aggregationLevels, properties, getPosition, getWeight);
+        data.push(...tile.userData[aggregationLevels]);
+      }
+      data.sort((a, b) => Number(b.count - a.count));
+      const clusterIds = data?.map((tile) => tile.id);
+      const needsUpdate = !(0, import_core5._deepEqual)(clusterIds, this.state.clusterIds, 1);
+      this.setState({ clusterIds });
+      if (needsUpdate) {
+        const stats = computeAggregationStats(data, properties);
+        for (const d of data) {
+          d.stats = stats;
+        }
+        this.setState({ data: clustersToBinary(data) });
+      }
+      const props = {
+        ...this.props,
+        id: "clusters",
+        data: this.state.data,
+        dataComparator: (data2, oldData) => {
+          const newIds = data2?.points?.properties?.map((tile) => tile.id);
+          const oldIds = oldData?.points?.properties?.map((tile) => tile.id);
+          return (0, import_core5._deepEqual)(newIds, oldIds, 1);
+        }
+      };
+      return new import_layers.GeoJsonLayer(this.getSubLayerProps(props));
+    }
+    getPickingInfo(params) {
+      const info = params.info;
+      if (info.index !== -1) {
+        const { data } = params.sourceLayer.props;
+        info.object = binaryToGeojson(data, {
+          globalFeatureId: info.index
+        });
+      }
+      return info;
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.indices = IndicesReader.read(pbf, pbf.readVarint() + pbf.pos);
-      else if (tag === 2)
-        obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
-      else if (tag === 3) {
-        const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
-        obj.numericProps[entry.key] = entry.value;
+    _updateAutoHighlight(info) {
+      for (const layer of this.getSubLayers()) {
+        layer.updateAutoHighlight(info);
       }
     }
+    filterSubLayer() {
+      return true;
+    }
   };
-  var TileReader3 = class {
-    static read(pbf, end) {
-      return pbf.readFields(TileReader3._readField, { scheme: 0, cells: null }, end);
+  ClusterGeoJsonLayer.layerName = "ClusterGeoJsonLayer";
+  ClusterGeoJsonLayer.defaultProps = defaultProps;
+  var ClusterTileLayer = class extends import_core5.CompositeLayer {
+    getLoadOptions() {
+      const loadOptions = super.getLoadOptions() || {};
+      const tileJSON = this.props.data;
+      injectAccessToken(loadOptions, tileJSON.accessToken);
+      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "quadbin" };
+      return loadOptions;
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.scheme = pbf.readVarint();
-      else if (tag === 2)
-        obj.cells = CellsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    renderLayers() {
+      const tileJSON = this.props.data;
+      if (!tileJSON)
+        return null;
+      const { tiles: data, maxresolution: maxZoom } = tileJSON;
+      return [
+        new ClusterGeoJsonLayer(this.props, {
+          id: `cluster-geojson-layer-${this.props.id}`,
+          data,
+          TilesetClass: QuadbinTileset2D,
+          maxZoom,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
     }
   };
+  ClusterTileLayer.layerName = "ClusterTileLayer";
+  ClusterTileLayer.defaultProps = defaultProps;
 
-  // ../../node_modules/quadbin/dist/esm/index.js
-  var import_tile_cover = __toESM(require_tile_cover(), 1);
-  var B = [
-    0x5555555555555555n,
-    0x3333333333333333n,
-    0x0f0f0f0f0f0f0f0fn,
-    0x00ff00ff00ff00ffn,
-    0x0000ffff0000ffffn,
-    0x00000000ffffffffn
-  ];
-  var S = [0n, 1n, 2n, 4n, 8n, 16n];
-  function hexToBigInt(hex2) {
-    return BigInt(`0x${hex2}`);
+  // src/layers/h3-tile-layer.ts
+  var import_core7 = __toESM(require_core2(), 1);
+  var import_geo_layers5 = __toESM(require_geo_layers(), 1);
+
+  // src/layers/h3-tileset-2d.ts
+  var import_geo_layers3 = __toESM(require_geo_layers(), 1);
+  var import_h3_js = __toESM(require_h3_js(), 1);
+  var MAX_LATITUDE2 = 85.051128;
+  function padBoundingBox({ west, north, east, south }, resolution) {
+    const corners = [
+      [north, east],
+      [south, east],
+      [south, west],
+      [north, west]
+    ];
+    const cornerCells = corners.map((c) => (0, import_h3_js.latLngToCell)(c[0], c[1], resolution));
+    const cornerEdgeLengths = cornerCells.map(
+      (c) => Math.max(...(0, import_h3_js.originToDirectedEdges)(c).map((e) => (0, import_h3_js.edgeLength)(e, import_h3_js.UNITS.rads))) * 180 / Math.PI
+    );
+    const bufferLat = Math.max(...cornerEdgeLengths);
+    const bufferLon = Math.min(180, bufferLat / Math.cos((north + south) / 2 * Math.PI / 180));
+    return {
+      north: Math.min(north + bufferLat, MAX_LATITUDE2),
+      east: east + bufferLon,
+      south: Math.max(south - bufferLat, -MAX_LATITUDE2),
+      west: west - bufferLon
+    };
   }
-  function bigIntToHex(index2) {
-    return index2.toString(16);
+  function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
+    const longitudeSpan = Math.abs(east - west);
+    if (longitudeSpan > 180) {
+      const nSegments = Math.ceil(longitudeSpan / 180);
+      let h3Indices = [];
+      for (let s = 0; s < nSegments; s++) {
+        const segmentWest = west + s * 180;
+        const segmentEast = Math.min(segmentWest + 179.9999999, east);
+        h3Indices = h3Indices.concat(
+          getHexagonsInBoundingBox({ west: segmentWest, north, east: segmentEast, south }, resolution)
+        );
+      }
+      return [...new Set(h3Indices)];
+    }
+    const polygon = [
+      [north, east],
+      [south, east],
+      [south, west],
+      [north, west],
+      [north, east]
+    ];
+    return (0, import_h3_js.polygonToCells)(polygon, resolution);
   }
-  function tileToCell(tile) {
-    if (tile.z < 0 || tile.z > 26) {
-      throw new Error("Wrong zoom");
+  function tileToBoundingBox(index2) {
+    const coordinates = (0, import_h3_js.cellToBoundary)(index2);
+    const latitudes = coordinates.map((c) => c[0]);
+    const longitudes = coordinates.map((c) => c[1]);
+    const west = Math.min(...longitudes);
+    const south = Math.min(...latitudes);
+    const east = Math.max(...longitudes);
+    const north = Math.max(...latitudes);
+    return { west, south, east, north };
+  }
+  var BIAS = 2;
+  function getHexagonResolution(viewport, tileSize) {
+    const zoomOffset = Math.log2(tileSize / 512);
+    const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
+    const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
+    return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
+  }
+  var H3Tileset2D = class extends import_geo_layers3._Tileset2D {
+    getTileIndices({ viewport, minZoom, maxZoom }) {
+      if (viewport.latitude === void 0)
+        return [];
+      const [west, south, east, north] = viewport.getBounds();
+      const { tileSize } = this.opts;
+      let z = getHexagonResolution(viewport, tileSize);
+      let indices;
+      if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
+        return [];
+      }
+      if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
+        z = maxZoom;
+        const center = (0, import_h3_js.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
+        indices = (0, import_h3_js.gridDisk)(center, 1);
+      } else {
+        const paddedBounds = padBoundingBox({ west, north, east, south }, z);
+        indices = getHexagonsInBoundingBox(paddedBounds, z);
+      }
+      return indices.map((i) => ({ i }));
     }
-    const z = BigInt(tile.z);
-    let x = BigInt(tile.x) << 32n - z;
-    let y = BigInt(tile.y) << 32n - z;
-    for (let i = 0; i < 5; i++) {
-      const s = S[5 - i];
-      const b = B[4 - i];
-      x = (x | x << s) & b;
-      y = (y | y << s) & b;
+    getTileId({ i }) {
+      return i;
     }
-    const quadbin = 0x4000000000000000n | 1n << 59n | z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
-    return quadbin;
-  }
-  function cellToTile(quadbin) {
-    const mode = quadbin >> 59n & 7n;
-    const modeDep = quadbin >> 57n & 3n;
-    const z = quadbin >> 52n & 0x1fn;
-    const q = (quadbin & 0xfffffffffffffn) << 12n;
-    if (mode !== 1n && modeDep !== 0n) {
-      throw new Error("Wrong mode");
+    getTileMetadata({ i }) {
+      return { bbox: tileToBoundingBox(i) };
     }
-    let x = q;
-    let y = q >> 1n;
-    for (let i = 0; i < 6; i++) {
-      const s = S[i];
-      const b = B[i];
-      x = (x | x >> s) & b;
-      y = (y | y >> s) & b;
+    getTileZoom({ i }) {
+      return (0, import_h3_js.getResolution)(i);
     }
-    x = x >> 32n - z;
-    y = y >> 32n - z;
-    return { z: Number(z), x: Number(x), y: Number(y) };
-  }
-  function getResolution2(quadbin) {
-    return quadbin >> 52n & 0x1fn;
-  }
-  function cellToParent2(quadbin) {
-    const zparent = getResolution2(quadbin) - 1n;
-    const parent = quadbin & ~(0x1fn << 52n) | zparent << 52n | 0xfffffffffffffn >> zparent * 2n;
-    return parent;
-  }
+    getParentIndex(index2) {
+      const resolution = (0, import_h3_js.getResolution)(index2.i);
+      const i = (0, import_h3_js.cellToParent)(index2.i, resolution - 1);
+      return { i };
+    }
+  };
 
-  // src/layers/schema/spatialjson-utils.ts
-  function binaryToSpatialjson(binary) {
-    const { cells, scheme } = binary;
-    const count = cells.indices.value.length;
-    const spatial = [];
-    for (let i = 0; i < count; i++) {
-      const id4 = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
-      const properties = { ...cells.properties[i] };
-      for (const key of Object.keys(cells.numericProps)) {
-        properties[key] = cells.numericProps[key].value[i];
+  // src/layers/spatial-index-tile-layer.ts
+  var import_core6 = __toESM(require_core(), 1);
+
+  // src/layers/schema/carto-raster-tile.ts
+  var ARRAY_TYPES = {
+    uint8: Uint8Array,
+    uint16: Uint16Array,
+    uint32: Uint32Array,
+    uint64: BigUint64Array,
+    int8: Int8Array,
+    int16: Int16Array,
+    int32: Int32Array,
+    int64: BigInt64Array,
+    float32: Float32Array,
+    float64: Float64Array
+  };
+  var BandReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(BandReader._readField, { name: "", type: "", data: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.name = pbf.readString();
+      else if (tag === 2)
+        obj.type = pbf.readString();
+      else if (tag === 3) {
+        const TypedArray = ARRAY_TYPES[obj.type];
+        if (!TypedArray) {
+          throw Error(`Invalid data type: ${obj.type}`);
+        }
+        obj.data = {};
+        readPackedTypedArray(TypedArray, pbf, obj.data);
       }
-      spatial.push({ id: id4, properties });
     }
-    return spatial;
-  }
+  };
+  var TileReader3 = class {
+    static read(pbf, end) {
+      return pbf.readFields(TileReader3._readField, { blockSize: 0, bands: [] }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.blockSize = pbf.readVarint();
+      else if (tag === 2)
+        obj.bands.push(BandReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+  };
 
-  // src/layers/schema/carto-spatial-tile-loader.ts
+  // src/layers/schema/carto-raster-tile-loader.ts
   var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var id2 = "cartoSpatialTile";
+  var id2 = "cartoRasterTile";
   var DEFAULT_OPTIONS2 = {
-    cartoSpatialTile: {
-      scheme: "quadbin",
+    cartoRasterTile: {
       workerUrl: getWorkerUrl(id2, VERSION2)
     }
   };
-  var CartoSpatialTileLoader = {
-    name: "CARTO Spatial Tile",
+  var CartoRasterTileLoader = {
+    name: "CARTO Raster Tile",
     version: VERSION2,
     id: id2,
     module: "carto",
     extensions: ["pbf"],
-    mimeTypes: ["application/vnd.carto-spatial-tile"],
+    mimeTypes: ["application/vnd.carto-raster-tile"],
     category: "geometry",
-    parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
-    parseSync: parseCartoSpatialTile,
+    parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
+    parseSync: parseCartoRasterTile,
     worker: true,
     options: DEFAULT_OPTIONS2
   };
-  function parseCartoSpatialTile(arrayBuffer, options) {
+  function parseCartoRasterTile(arrayBuffer, options) {
     if (!arrayBuffer)
       return null;
-    const tile = parsePbf(arrayBuffer, TileReader3);
-    const { cells } = tile;
-    const scheme = options?.cartoSpatialTile?.scheme;
-    const data = { cells, scheme };
-    return binaryToSpatialjson(data);
+    const { bands, blockSize } = parsePbf(arrayBuffer, TileReader3);
+    const numericProps = {};
+    for (let i = 0; i < bands.length; i++) {
+      const { name, data } = bands[i];
+      numericProps[name] = data;
+    }
+    return { blockSize, cells: { numericProps, properties: [] } };
   }
-  var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
-
-  // src/layers/spatial-index-tile-layer.ts
-  var import_geo_layers2 = __toESM(require_geo_layers(), 1);
-
-  // src/constants.ts
-  var DEFAULT_TILE_SIZE = 512;
-  var DEFAULT_TILE_RESOLUTION = 0.5;
-  var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-  var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+  var carto_raster_tile_loader_default = CartoRasterTileLoader;
 
   // src/layers/spatial-index-tile-layer.ts
-  (0, import_core2.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
+  var import_geo_layers4 = __toESM(require_geo_layers(), 1);
+  (0, import_core6.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
   function isFeatureIdDefined(value) {
     return value !== void 0 && value !== null && value !== "";
   }
-  var defaultProps = {
+  var defaultProps2 = {
     tileSize: DEFAULT_TILE_SIZE
   };
-  var SpatialIndexTileLayer = class extends import_geo_layers2.TileLayer {
+  var SpatialIndexTileLayer = class extends import_geo_layers4.TileLayer {
     _updateAutoHighlight(info) {
       const { hoveredFeatureId } = this.state;
       const hoveredFeature = info.object;
@@ -7683,72 +8195,7 @@ var __exports__ = (() => {
     }
   };
   SpatialIndexTileLayer.layerName = "SpatialIndexTileLayer";
-  SpatialIndexTileLayer.defaultProps = defaultProps;
-
-  // src/layers/utils.ts
-  var import_core3 = __toESM(require_core(), 1);
-  var import_core4 = __toESM(require_core(), 1);
-  function injectAccessToken(loadOptions, accessToken) {
-    if (!loadOptions?.fetch?.headers?.Authorization) {
-      loadOptions.fetch = {
-        ...loadOptions.fetch,
-        headers: { ...loadOptions.fetch?.headers, Authorization: `Bearer ${accessToken}` }
-      };
-    }
-  }
-  function mergeBoundaryData(geometry, properties) {
-    const mapping = {};
-    for (const { geoid, ...rest } of properties.properties) {
-      if (geoid in mapping) {
-        import_core3.log.warn("Duplicate geoid key in boundary mapping, using first occurance")();
-      } else {
-        mapping[geoid] = rest;
-      }
-    }
-    for (const type of ["points", "lines", "polygons"]) {
-      const geom = geometry[type];
-      if (geom.positions.value.length === 0) {
-        continue;
-      }
-      geom.properties = geom.properties.map(({ geoid }) => mapping[geoid]);
-      const { positions, globalFeatureIds } = geom;
-      let indices = null;
-      if (type === "lines")
-        indices = geom.pathIndices.value;
-      if (type === "polygons")
-        indices = geom.polygonIndices.value;
-      const length = positions.value.length / positions.size;
-      for (const key in properties.numericProps) {
-        const sourceProp = properties.numericProps[key].value;
-        const TypedArray = sourceProp.constructor;
-        const destProp = new TypedArray(length);
-        geom.numericProps[key] = { value: destProp, size: 1 };
-        if (!indices) {
-          for (let i = 0; i < length; i++) {
-            const featureId = globalFeatureIds.value[i];
-            destProp[i] = sourceProp[featureId];
-          }
-        } else {
-          for (let i = 0; i < indices.length - 1; i++) {
-            const startIndex = indices[i];
-            const endIndex = indices[i + 1];
-            const featureId = globalFeatureIds.value[startIndex];
-            destProp.fill(sourceProp[featureId], startIndex, endIndex);
-          }
-        }
-      }
-    }
-    return geometry;
-  }
-  var TilejsonPropType = {
-    type: "object",
-    value: null,
-    validate: (value, propType) => propType.optional && value === null || typeof value === "object" && Array.isArray(value.tiles) && value.tiles.every((url) => typeof url === "string"),
-    equal: (value1, value2) => {
-      return (0, import_core4._deepEqual)(value1, value2, 2);
-    },
-    async: true
-  };
+  SpatialIndexTileLayer.defaultProps = defaultProps2;
 
   // src/layers/h3-tile-layer.ts
   var renderSubLayers = (props) => {
@@ -7756,19 +8203,19 @@ var __exports__ = (() => {
     const { index: index2 } = props.tile;
     if (!data || !data.length)
       return null;
-    return new import_geo_layers3.H3HexagonLayer(props, {
+    return new import_geo_layers5.H3HexagonLayer(props, {
       getHexagon: (d) => d.id,
       centerHexagon: index2,
       highPrecision: true
     });
   };
-  var defaultProps2 = {
+  var defaultProps3 = {
     data: TilejsonPropType,
     tileSize: DEFAULT_TILE_SIZE
   };
-  var H3TileLayer = class extends import_core5.CompositeLayer {
+  var H3TileLayer = class extends import_core7.CompositeLayer {
     initializeState() {
-      import_geo_layers3.H3HexagonLayer._checkH3Lib();
+      import_geo_layers5.H3HexagonLayer._checkH3Lib();
     }
     getLoadOptions() {
       const loadOptions = super.getLoadOptions() || {};
@@ -7809,11 +8256,11 @@ var __exports__ = (() => {
     }
   };
   H3TileLayer.layerName = "H3TileLayer";
-  H3TileLayer.defaultProps = defaultProps2;
+  H3TileLayer.defaultProps = defaultProps3;
 
   // src/layers/heatmap-tile-layer.ts
-  var import_core8 = __toESM(require_core(), 1);
-  var import_layers = __toESM(require_layers(), 1);
+  var import_core10 = __toESM(require_core2(), 1);
+  var import_layers2 = __toESM(require_layers(), 1);
 
   // src/layers/heatmap.ts
   var glsl = (s) => `${s}`;
@@ -7990,7 +8437,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   };
 
   // src/layers/post-process-utils.ts
-  var import_core6 = __toESM(require_core(), 1);
+  var import_core8 = __toESM(require_core2(), 1);
   var TEXTURE_PROPS = {
     format: "rgba8unorm",
     mipmaps: false,
@@ -8007,7 +8454,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     }
     return layer;
   }
-  var DrawCallbackLayer = class extends import_core6.Layer {
+  var DrawCallbackLayer = class extends import_core8.Layer {
     initializeState() {
       this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;
     }
@@ -8039,7 +8486,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       initializeState(context) {
         super.initializeState(context);
         this._createTextures();
-        this.internalState.postProcess = new import_core6.PostProcessEffect(effect, this.props);
+        this.internalState.postProcess = new import_core8.PostProcessEffect(effect, this.props);
         this.internalState.postProcess.setup(context);
       }
       updateState(params) {
@@ -8104,53 +8551,14 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   }
 
   // src/layers/quadbin-tile-layer.ts
-  var import_core7 = __toESM(require_core(), 1);
-
-  // src/layers/quadbin-layer.ts
-  var import_geo_layers4 = __toESM(require_geo_layers(), 1);
-
-  // ../../node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
-  var PI = Math.PI;
-  var PI_4 = PI / 4;
-  var DEGREES_TO_RADIANS = PI / 180;
-  var RADIANS_TO_DEGREES = 180 / PI;
-  var TILE_SIZE = 512;
-  function worldToLngLat(xy) {
-    const [x, y] = xy;
-    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
-    return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
-  }
-
-  // ../../node_modules/@math.gl/web-mercator/dist/get-bounds.js
-  var DEGREES_TO_RADIANS2 = Math.PI / 180;
-
-  // src/layers/quadbin-utils.ts
-  var TILE_SIZE2 = 512;
-  function quadbinToOffset(quadbin) {
-    const { x, y, z } = cellToTile(quadbin);
-    const scale = TILE_SIZE2 / (1 << z);
-    return [x * scale, TILE_SIZE2 - y * scale, scale];
-  }
-  function quadbinToWorldBounds(quadbin, coverage) {
-    const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
-    return [
-      [xOffset, yOffset],
-      [xOffset + coverage * scale, yOffset - coverage * scale]
-    ];
-  }
-  function getQuadbinPolygon(quadbin, coverage = 1) {
-    const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
-    const [w, n] = worldToLngLat(topLeft);
-    const [e, s] = worldToLngLat(bottomRight);
-    return [e, n, e, s, w, s, w, n, e, n];
-  }
+  var import_core9 = __toESM(require_core2(), 1);
 
   // src/layers/quadbin-layer.ts
-  var defaultProps3 = {
+  var import_geo_layers6 = __toESM(require_geo_layers(), 1);
+  var defaultProps4 = {
     getQuadbin: { type: "accessor", value: (d) => d.quadbin }
   };
-  var QuadbinLayer = class extends import_geo_layers4._GeoCellLayer {
+  var QuadbinLayer = class extends import_geo_layers6._GeoCellLayer {
     indexToBounds() {
       const { data, extruded, getQuadbin } = this.props;
       const coverage = extruded ? 0.99 : 1;
@@ -8164,27 +8572,7 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     }
   };
   QuadbinLayer.layerName = "QuadbinLayer";
-  QuadbinLayer.defaultProps = defaultProps3;
-
-  // src/layers/quadbin-tileset-2d.ts
-  var import_geo_layers5 = __toESM(require_geo_layers(), 1);
-  var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
-    getTileIndices(opts) {
-      return super.getTileIndices(opts).map(tileToCell).map((q) => ({ q, i: bigIntToHex(q) }));
-    }
-    getTileId({ q, i }) {
-      return i || bigIntToHex(q);
-    }
-    getTileMetadata({ q }) {
-      return super.getTileMetadata(cellToTile(q));
-    }
-    getTileZoom({ q }) {
-      return Number(getResolution2(q));
-    }
-    getParentIndex({ q }) {
-      return { q: cellToParent2(q) };
-    }
-  };
+  QuadbinLayer.defaultProps = defaultProps4;
 
   // src/layers/quadbin-tile-layer.ts
   var renderSubLayers2 = (props) => {
@@ -8196,11 +8584,11 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       getQuadbin: isBigInt ? (d) => d.id : (d) => hexToBigInt(d.id)
     });
   };
-  var defaultProps4 = {
+  var defaultProps5 = {
     data: TilejsonPropType,
     tileSize: DEFAULT_TILE_SIZE
   };
-  var QuadbinTileLayer = class extends import_core7.CompositeLayer {
+  var QuadbinTileLayer = class extends import_core9.CompositeLayer {
     getLoadOptions() {
       const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
@@ -8226,14 +8614,14 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     }
   };
   QuadbinTileLayer.layerName = "QuadbinTileLayer";
-  QuadbinTileLayer.defaultProps = defaultProps4;
+  QuadbinTileLayer.defaultProps = defaultProps5;
 
   // src/layers/heatmap-tile-layer.ts
   function unitDensityForCell(cell) {
-    const cellResolution = Number(getResolution2(cell));
+    const cellResolution = Number(getResolution(cell));
     return Math.pow(4, cellResolution);
   }
-  var RTTSolidPolygonLayer = class extends RTTModifier(import_layers.SolidPolygonLayer) {
+  var RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
     getShaders(type) {
       const shaders = super.getShaders(type);
       shaders.inject = {
@@ -8273,7 +8661,7 @@ uniform float densityFactor;
   };
   RTTSolidPolygonLayer.layerName = "RTTSolidPolygonLayer";
   var PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
-  var defaultProps5 = {
+  var defaultProps6 = {
     data: TilejsonPropType,
     getWeight: { type: "accessor", value: 1 },
     onMaxDensityChange: { type: "function", optional: true, value: null },
@@ -8281,7 +8669,7 @@ uniform float densityFactor;
     intensity: { type: "number", value: 1 },
     radiusPixels: { type: "number", min: 0, max: 100, value: 20 }
   };
-  var HeatmapTileLayer = class extends import_core8.CompositeLayer {
+  var HeatmapTileLayer = class extends import_core10.CompositeLayer {
     initializeState() {
       this.state = {
         isLoaded: false,
@@ -8390,14 +8778,14 @@ uniform float densityFactor;
     }
   };
   HeatmapTileLayer.layerName = "HeatmapTileLayer";
-  HeatmapTileLayer.defaultProps = defaultProps5;
+  HeatmapTileLayer.defaultProps = defaultProps6;
   var heatmap_tile_layer_default = HeatmapTileLayer;
 
   // src/layers/point-label-layer.ts
-  var import_core9 = __toESM(require_core(), 1);
-  var import_layers2 = __toESM(require_layers(), 1);
+  var import_core11 = __toESM(require_core2(), 1);
+  var import_layers3 = __toESM(require_layers(), 1);
   var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
-  var EnhancedTextBackgroundLayer = class extends import_layers2._TextBackgroundLayer {
+  var EnhancedTextBackgroundLayer = class extends import_layers3._TextBackgroundLayer {
     getShaders() {
       const shaders = super.getShaders();
       let vs = shaders.vs;
@@ -8410,7 +8798,7 @@ uniform float densityFactor;
     }
   };
   EnhancedTextBackgroundLayer.layerName = "EnhancedTextBackgroundLayer";
-  var EnhancedTextLayer = class extends import_layers2.TextLayer {
+  var EnhancedTextLayer = class extends import_layers3.TextLayer {
     filterSubLayer({ layer, renderPass }) {
       const background = layer.id.includes("primary-background");
       if (renderPass === "collision") {
@@ -8420,12 +8808,12 @@ uniform float densityFactor;
     }
   };
   EnhancedTextLayer.layerName = "EnhancedTextLayer";
-  var defaultProps6 = {
-    ...import_layers2.TextLayer.defaultProps,
+  var defaultProps7 = {
+    ...import_layers3.TextLayer.defaultProps,
     getRadius: { type: "accessor", value: 1 },
     radiusScale: { type: "number", min: 0, value: 1 }
   };
-  var PointLabelLayer = class extends import_core9.CompositeLayer {
+  var PointLabelLayer = class extends import_core11.CompositeLayer {
     calculatePixelOffset(secondary) {
       const {
         getTextAnchor: anchor,
@@ -8561,14 +8949,14 @@ uniform float densityFactor;
     }
   };
   PointLabelLayer.layerName = "PointLabelLayer";
-  PointLabelLayer.defaultProps = defaultProps6;
+  PointLabelLayer.defaultProps = defaultProps7;
 
   // src/layers/raster-tile-layer.ts
-  var import_core11 = __toESM(require_core(), 1);
+  var import_core13 = __toESM(require_core2(), 1);
 
   // src/layers/raster-layer.ts
-  var import_core10 = __toESM(require_core(), 1);
-  var import_layers3 = __toESM(require_layers(), 1);
+  var import_core12 = __toESM(require_core2(), 1);
+  var import_layers4 = __toESM(require_layers(), 1);
 
   // src/layers/raster-layer-vertex.glsl.ts
   var raster_layer_vertex_glsl_default = `#version 300 es
@@ -8670,8 +9058,8 @@ void main(void) {
 `;
 
   // src/layers/raster-layer.ts
-  var defaultProps7 = {
-    ...import_layers3.ColumnLayer.defaultProps,
+  var defaultProps8 = {
+    ...import_layers4.ColumnLayer.defaultProps,
     extruded: false,
     diskResolution: 4,
     vertices: [
@@ -8681,7 +9069,7 @@ void main(void) {
       [-0.5, 0.5]
     ]
   };
-  var RasterColumnLayer = class extends import_layers3.ColumnLayer {
+  var RasterColumnLayer = class extends import_layers4.ColumnLayer {
     getShaders() {
       const shaders = super.getShaders();
       const data = this.props.data;
@@ -8714,7 +9102,7 @@ void main(void) {
     }
   };
   RasterColumnLayer.layerName = "RasterColumnLayer";
-  var RasterLayer = class extends import_core10.CompositeLayer {
+  var RasterLayer = class extends import_core12.CompositeLayer {
     renderLayers() {
       const {
         data,
@@ -8731,6 +9119,7 @@ void main(void) {
       const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
       const offset = [xOffset, yOffset, scale / blockSize];
       const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
+      const { highlightedObjectIndex, highlightColor } = this.state;
       return new CellLayer(
         this.props,
         this.getSubLayerProps({
@@ -8746,7 +9135,9 @@ void main(void) {
             data,
             length: blockSize * blockSize
           },
-          offset
+          offset,
+          highlightedObjectIndex,
+          highlightColor
         }
       );
     }
@@ -8761,22 +9152,50 @@ void main(void) {
         return accessor({ properties: proxy }, info);
       };
     }
+    getPickingInfo(params) {
+      const info = super.getPickingInfo(params);
+      if (info.index !== -1) {
+        info.object = this.getSubLayerAccessor((x) => x)(void 0, {
+          data: this.props,
+          index: info.index
+        });
+      }
+      return info;
+    }
+    _updateAutoHighlight(info) {
+      const { highlightedObjectIndex } = this.state;
+      let newHighlightedObjectIndex = -1;
+      if (info.index !== -1) {
+        newHighlightedObjectIndex = info.index;
+      }
+      if (highlightedObjectIndex !== newHighlightedObjectIndex) {
+        let { highlightColor } = this.props;
+        if (typeof highlightColor === "function") {
+          highlightColor = highlightColor(info);
+        }
+        this.setState({
+          highlightColor,
+          highlightedObjectIndex: newHighlightedObjectIndex
+        });
+      }
+    }
   };
   RasterLayer.layerName = "RasterLayer";
-  RasterLayer.defaultProps = defaultProps7;
+  RasterLayer.defaultProps = defaultProps8;
 
   // src/layers/raster-tile-layer.ts
+  var import_geo_layers7 = __toESM(require_geo_layers(), 1);
   var renderSubLayers3 = (props) => {
     const tileIndex = props.tile?.index?.q;
     if (!tileIndex)
       return null;
     return new RasterLayer(props, { tileIndex });
   };
-  var defaultProps8 = {
+  var defaultProps9 = {
     data: TilejsonPropType,
     tileSize: DEFAULT_TILE_SIZE
   };
-  var RasterTileLayer = class extends import_core11.CompositeLayer {
+  var RasterTileLayer = class extends import_core13.CompositeLayer {
     getLoadOptions() {
       const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
@@ -8789,7 +9208,7 @@ void main(void) {
         return null;
       const { tiles: data, minzoom: minZoom, maxzoom: maxZoom } = tileJSON;
       return [
-        new SpatialIndexTileLayer(this.props, {
+        new import_geo_layers7.TileLayer(this.props, {
           id: `raster-tile-layer-${this.props.id}`,
           data,
           TilesetClass: QuadbinTileset2D,
@@ -8802,10 +9221,10 @@ void main(void) {
     }
   };
   RasterTileLayer.layerName = "RasterTileLayer";
-  RasterTileLayer.defaultProps = defaultProps8;
+  RasterTileLayer.defaultProps = defaultProps9;
 
   // src/layers/vector-tile-layer.ts
-  var import_core12 = __toESM(require_core2(), 1);
+  var import_core14 = __toESM(require_core(), 1);
 
   // src/layers/schema/carto-properties-tile.ts
   var TileReader4 = class {
@@ -8897,7 +9316,7 @@ void main(void) {
   function parseCartoVectorTile(arrayBuffer, options) {
     if (!arrayBuffer)
       return null;
-    const tile = parsePbf(arrayBuffer, TileReader2);
+    const tile = parsePbf(arrayBuffer, TileReader);
     if (tile.polygons && !tile.polygons.triangles) {
       triangulate(tile.polygons);
     }
@@ -8907,16 +9326,16 @@ void main(void) {
 
   // src/layers/vector-tile-layer.ts
   var import_extensions = __toESM(require_extensions(), 1);
-  var import_geo_layers6 = __toESM(require_geo_layers(), 1);
-  var import_layers4 = __toESM(require_layers(), 1);
-  (0, import_core12.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
-  var defaultProps9 = {
-    ...import_geo_layers6.MVTLayer.defaultProps,
+  var import_geo_layers8 = __toESM(require_geo_layers(), 1);
+  var import_layers5 = __toESM(require_layers(), 1);
+  (0, import_core14.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
+  var defaultProps10 = {
+    ...import_geo_layers8.MVTLayer.defaultProps,
     data: TilejsonPropType,
     dataComparator: TilejsonPropType.equal,
     tileSize: DEFAULT_TILE_SIZE
   };
-  var VectorTileLayer = class extends import_geo_layers6.MVTLayer {
+  var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
     constructor(...propObjects) {
       super(...propObjects);
     }
@@ -8943,7 +9362,7 @@ void main(void) {
     async getTileData(tile) {
       const tileJSON = this.props.data;
       const { tiles: tiles2, properties_tiles } = tileJSON;
-      const url = (0, import_geo_layers6._getURLFromTemplate)(tiles2, tile);
+      const url = (0, import_geo_layers8._getURLFromTemplate)(tiles2, tile);
       if (!url) {
         return Promise.reject("Invalid URL");
       }
@@ -8954,7 +9373,7 @@ void main(void) {
       if (!properties_tiles) {
         return await geometryFetch;
       }
-      const propertiesUrl = (0, import_geo_layers6._getURLFromTemplate)(properties_tiles, tile);
+      const propertiesUrl = (0, import_geo_layers8._getURLFromTemplate)(properties_tiles, tile);
       if (!propertiesUrl) {
         return Promise.reject("Invalid properties URL");
       }
@@ -8978,13 +9397,20 @@ void main(void) {
       }
       const tileBbox = props.tile.bbox;
       const { west, south, east, north } = tileBbox;
+      const clipProps = {
+        extensions: [new import_extensions.ClipExtension(), ...props.extensions || []],
+        clipBounds: [west, south, east, north]
+      };
       const subLayerProps = {
         ...props,
         autoHighlight: false,
-        extensions: [new import_extensions.ClipExtension(), ...props.extensions || []],
-        clipBounds: [west, south, east, north]
+        _subLayerProps: {
+          "polygons-fill": clipProps,
+          "polygons-stroke": clipProps,
+          linestrings: clipProps
+        }
       };
-      const subLayer = new import_layers4.GeoJsonLayer(subLayerProps);
+      const subLayer = new import_layers5.GeoJsonLayer(subLayerProps);
       return subLayer;
     }
     _isWGS84() {
@@ -8994,7 +9420,7 @@ void main(void) {
     }
   };
   VectorTileLayer.layerName = "VectorTileLayer";
-  VectorTileLayer.defaultProps = defaultProps9;
+  VectorTileLayer.defaultProps = defaultProps10;
 
   // src/api/carto-api-error.ts
   var CartoAPIError = class extends Error {
@@ -10893,9 +11319,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     };
     return scale;
   }
-  function log3() {
+  function log4() {
     const scale = loggish(transformer()).domain([1, 10]);
-    scale.copy = () => copy(scale, log3()).base(scale.base());
+    scale.copy = () => copy(scale, log4()).base(scale.base());
     initRange.apply(scale, arguments);
     return scale;
   }
@@ -12435,7 +12861,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   function getPalette(name, numCategories) {
     const palette = cartocolor_exports[name];
     let paletteIndex = numCategories;
-    assert(palette, `Palette "${name}" not found. Expected a CARTOColors string`);
+    assert2(palette, `Palette "${name}" not found. Expected a CARTOColors string`);
     const palettesColorVariants = Object.keys(palette).filter((p) => p !== "tags").map(Number);
     const longestPaletteIndex = Math.max(...palettesColorVariants);
     const smallestPaletteIndex = Math.min(...palettesColorVariants);
@@ -12474,7 +12900,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), 255];
     }
     result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex2);
-    assert(result, `Hexadecimal color "${hex2}" was not parsed correctly`);
+    assert2(result, `Hexadecimal color "${hex2}" was not parsed correctly`);
     return [
       parseInt(result[1], 16),
       parseInt(result[2], 16),
@@ -12486,8 +12912,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/style/utils.ts
   var ALLOWED_ATTR_TYPES = Object.freeze(["function", "string"]);
   function getAttrValue(attr, d) {
-    assert(typeof d === "object", 'Expected "data" to be an object');
-    assert(ALLOWED_ATTR_TYPES.includes(typeof attr), 'Expected "attr" to be a function or string');
+    assert2(typeof d === "object", 'Expected "data" to be an object');
+    assert2(ALLOWED_ATTR_TYPES.includes(typeof attr), 'Expected "attr" to be a function or string');
     if (typeof attr === "function") {
       return attr(d);
     }
@@ -12501,7 +12927,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     colors = DEFAULT_PALETTE,
     nullColor = NULL_COLOR
   }) {
-    assert(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
+    assert2(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
     const palette = typeof colors === "string" ? getPalette(colors, domain.length + 1) : colors;
     const color2 = threshold().domain(domain).range(palette);
     return (d) => {
@@ -12518,7 +12944,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     nullColor = NULL_COLOR,
     othersColor = OTHERS_COLOR
   }) {
-    assert(Array.isArray(domain), 'Expected "domain" to be an array of numbers or strings');
+    assert2(Array.isArray(domain), 'Expected "domain" to be an array of numbers or strings');
     const colorsByCategory = {};
     const palette = typeof colors === "string" ? getPalette(colors, domain.length) : colors;
     for (const [i, c] of domain.entries()) {
@@ -12537,7 +12963,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     colors = DEFAULT_PALETTE,
     nullColor = NULL_COLOR
   }) {
-    assert(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
+    assert2(Array.isArray(domain), 'Expected "domain" to be an array of numbers');
     const palette = typeof colors === "string" ? getPalette(colors, domain.length) : colors;
     const color2 = linear2().domain(domain).range(palette);
     return (d) => {
@@ -12592,10 +13018,10 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/api/request-with-parameters.ts
-  var import_core13 = __toESM(require_core(), 1);
+  var import_core15 = __toESM(require_core2(), 1);
   var DEFAULT_PARAMETERS = {
     v: V3_MINOR_VERSION,
-    deckglVersion: import_core13.VERSION
+    deckglVersion: import_core15.VERSION
   };
   var DEFAULT_HEADERS = {
     Accept: "application/json",
@@ -12757,7 +13183,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
       sqlQuery,
       spatialDataColumn = "h3",
-      queryParameters
+      queryParameters,
+      filters
     } = options;
     const urlParameters = {
       aggregationExp,
@@ -12771,6 +13198,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (queryParameters) {
       urlParameters.queryParameters = queryParameters;
     }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
     return baseSource("query", options, urlParameters);
   };
 
@@ -12780,7 +13210,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       aggregationExp,
       aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
       spatialDataColumn = "h3",
-      tableName
+      tableName,
+      filters
     } = options;
     const urlParameters = {
       aggregationExp,
@@ -12791,6 +13222,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (aggregationResLevel) {
       urlParameters.aggregationResLevel = String(aggregationResLevel);
     }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
     return baseSource("table", options, urlParameters);
   };
 
@@ -12818,7 +13252,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
       sqlQuery,
       spatialDataColumn = "quadbin",
-      queryParameters
+      queryParameters,
+      filters
     } = options;
     const urlParameters = {
       aggregationExp,
@@ -12832,6 +13267,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (queryParameters) {
       urlParameters.queryParameters = queryParameters;
     }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
     return baseSource("query", options, urlParameters);
   };
 
@@ -12841,7 +13279,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       aggregationExp,
       aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
       spatialDataColumn = "quadbin",
-      tableName
+      tableName,
+      filters
     } = options;
     const urlParameters = {
       aggregationExp,
@@ -12852,6 +13291,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (aggregationResLevel) {
       urlParameters.aggregationResLevel = String(aggregationResLevel);
     }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
     return baseSource("table", options, urlParameters);
   };
 
@@ -12922,17 +13364,17 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
 
   // src/api/parse-map.ts
-  var import_core14 = __toESM(require_core(), 1);
+  var import_core16 = __toESM(require_core2(), 1);
 
   // src/api/layer-map.ts
   var import_moment_timezone = __toESM(require_moment_timezone2(), 1);
   var import_aggregation_layers = __toESM(require_aggregation_layers(), 1);
-  var import_layers5 = __toESM(require_layers(), 1);
-  var import_geo_layers7 = __toESM(require_geo_layers(), 1);
+  var import_layers6 = __toESM(require_layers(), 1);
+  var import_geo_layers9 = __toESM(require_geo_layers(), 1);
   var SCALE_FUNCS = {
     linear: linear2,
     ordinal,
-    log: log3,
+    log: log4,
     point,
     quantile: quantile2,
     quantize,
@@ -12962,6 +13404,15 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     stddev: deviation,
     variance
   };
+  var TILE_LAYER_TYPE_TO_LAYER = {
+    clusterTile: ClusterTileLayer,
+    h3: H3TileLayer,
+    heatmapTile: heatmap_tile_layer_default,
+    mvt: VectorTileLayer,
+    quadbin: QuadbinTileLayer,
+    raster: RasterTileLayer,
+    tileset: VectorTileLayer
+  };
   var hexToRGBA = (c) => {
     const { r, g, b, opacity } = rgb(c);
     return [r, g, b, 255 * opacity];
@@ -13000,7 +13451,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
     percentile: ["lowerPercentile", "upperPercentile"]
   };
-  var defaultProps10 = {
+  var defaultProps11 = {
     lineMiterLimit: 2,
     lineWidthUnits: "pixels",
     pointRadiusUnits: "pixels",
@@ -13015,15 +13466,15 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (config.visConfig?.customMarkers) {
       basePropMap = mergePropMaps(sharedPropMap, customMarkersPropsMap);
     }
-    if (type === "mvt" || type === "tileset" || type === "h3" || type === "quadbin") {
-      return getTileLayer(dataset, basePropMap);
+    if (TILE_LAYER_TYPE_TO_LAYER[type]) {
+      return getTileLayer(dataset, basePropMap, type);
     }
     const geoColumn = dataset?.geoColumn;
     const getPosition = (d) => d[geoColumn].coordinates;
     const hexagonId = config.columns?.hex_id;
     const layerTypeDefs = {
       point: {
-        Layer: import_layers5.GeoJsonLayer,
+        Layer: import_layers6.GeoJsonLayer,
         propMap: {
           columns: {
             altitude: (x) => ({ parameters: { depthTest: Boolean(x) } })
@@ -13032,7 +13483,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         }
       },
       geojson: {
-        Layer: import_layers5.GeoJsonLayer
+        Layer: import_layers6.GeoJsonLayer
       },
       grid: {
         Layer: import_aggregation_layers.CPUGridLayer,
@@ -13050,42 +13501,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         defaultProps: { getPosition }
       },
       hexagonId: {
-        Layer: import_geo_layers7.H3HexagonLayer,
+        Layer: import_geo_layers9.H3HexagonLayer,
         propMap: { visConfig: { coverage: "coverage" } },
         defaultProps: { getHexagon: (d) => d[hexagonId], stroked: false }
       }
     };
     const layer = layerTypeDefs[type];
-    assert(layer, `Unsupported layer type: ${type}`);
+    assert2(layer, `Unsupported layer type: ${type}`);
     return {
       ...layer,
       propMap: mergePropMaps(basePropMap, layer.propMap),
-      defaultProps: { ...defaultProps10, ...layer.defaultProps }
+      defaultProps: { ...defaultProps11, ...layer.defaultProps }
     };
   }
-  function layerFromTileDataset(scheme, type) {
-    if (type === "raster") {
-      return RasterTileLayer;
-    }
-    if (scheme === "h3") {
-      return H3TileLayer;
-    }
-    if (scheme === "quadbin") {
-      return QuadbinTileLayer;
-    }
-    return VectorTileLayer;
-  }
-  function getTileLayer(dataset, basePropMap) {
-    const {
-      aggregationExp,
-      aggregationResLevel,
-      data: { scheme }
-    } = dataset;
+  function getTileLayer(dataset, basePropMap, type) {
+    const { aggregationExp, aggregationResLevel } = dataset;
     return {
-      Layer: layerFromTileDataset(scheme),
+      Layer: TILE_LAYER_TYPE_TO_LAYER[type] || VectorTileLayer,
       propMap: basePropMap,
       defaultProps: {
-        ...defaultProps10,
+        ...defaultProps11,
         ...aggregationExp && { aggregationExp },
         ...aggregationResLevel && { aggregationResLevel },
         uniqueIdProperty: "geoid"
@@ -13284,7 +13719,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var collisionFilterExtension = new import_extensions2.CollisionFilterExtension();
   function parseMap(json) {
     const { keplerMapConfig, datasets, token } = json;
-    assert(keplerMapConfig.version === "v1", "Only support Kepler v1");
+    assert2(keplerMapConfig.version === "v1", "Only support Kepler v1");
     const { mapState, mapStyle } = keplerMapConfig.config;
     const { layers, layerBlending, interactionConfig } = keplerMapConfig.config.visState;
     return {
@@ -13300,15 +13735,15 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         try {
           const { dataId } = config;
           const dataset = datasets.find((d) => d.id === dataId);
-          assert(dataset, `No dataset matching dataId: ${dataId}`);
+          assert2(dataset, `No dataset matching dataId: ${dataId}`);
           const { data } = dataset;
-          assert(data, `No data loaded for dataId: ${dataId}`);
-          const { Layer: Layer9, propMap, defaultProps: defaultProps11 } = getLayer(type, config, dataset);
+          assert2(data, `No data loaded for dataId: ${dataId}`);
+          const { Layer: Layer10, propMap, defaultProps: defaultProps12 } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
-          return new Layer9({
+          return new Layer10({
             id: id4,
             data,
-            ...defaultProps11,
+            ...defaultProps12,
             ...createInteractionProps(interactionConfig),
             ...styleProps,
             ...createChannelProps(id4, type, config, visualChannels, data),
@@ -13316,7 +13751,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
             ...createLoadOptions(token)
           });
         } catch (e) {
-          import_core14.log.error(e.message)();
+          import_core16.log.error(e.message)();
           return void 0;
         }
       })
@@ -13759,12 +14194,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     autoRefresh,
     onNewData
   }) {
-    assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
-    assert(apiBaseUrl, "Must define apiBaseUrl");
+    assert2(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
+    assert2(apiBaseUrl, "Must define apiBaseUrl");
     if (autoRefresh || onNewData) {
-      assert(onNewData, "Must define `onNewData` when using autoRefresh");
-      assert(typeof onNewData === "function", "`onNewData` must be a function");
-      assert(
+      assert2(onNewData, "Must define `onNewData` when using autoRefresh");
+      assert2(typeof onNewData === "function", "`onNewData` must be a function");
+      assert2(
         typeof autoRefresh === "number" && autoRefresh > 0,
         "`autoRefresh` must be a positive number"
       );
@@ -13852,6 +14287,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/index.ts
   var CARTO_LAYERS = {
+    ClusterTileLayer,
     H3TileLayer,
     HeatmapTileLayer: heatmap_tile_layer_default,
     _PointLabelLayer: PointLabelLayer,
@@ -13876,9 +14312,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // ../layers/bundle/peer-dependency.ts
   var peer_dependency_exports = {};
-  var import_layers6 = __toESM(require_layers(), 1);
+  var import_layers7 = __toESM(require_layers(), 1);
   __reExport(peer_dependency_exports, __toESM(require_layers(), 1));
-  if (!import_layers6.GeoJsonLayer) {
+  if (!import_layers7.GeoJsonLayer) {
     throw new Error("@deck.gl/layers is not found");
   }