@deck.gl/carto 9.3.0-beta.1 → 9.3.0

package/dist/dist.dev.js

@@ -66,334 +66,6 @@ var __exports__ = (() => {
     }
   });
 
-  // ../../node_modules/tilebelt/index.js
-  var require_tilebelt = __commonJS({
-    "../../node_modules/tilebelt/index.js"(exports, module) {
-      var d2r2 = Math.PI / 180;
-      var r2d2 = 180 / Math.PI;
-      function tileToBBOX2(tile) {
-        var e = tile2lon2(tile[0] + 1, tile[2]);
-        var w = tile2lon2(tile[0], tile[2]);
-        var s = tile2lat2(tile[1] + 1, tile[2]);
-        var n = tile2lat2(tile[1], tile[2]);
-        return [w, s, e, n];
-      }
-      function tileToGeoJSON2(tile) {
-        var bbox2 = tileToBBOX2(tile);
-        var poly = {
-          type: "Polygon",
-          coordinates: [
-            [
-              [bbox2[0], bbox2[1]],
-              [bbox2[0], bbox2[3]],
-              [bbox2[2], bbox2[3]],
-              [bbox2[2], bbox2[1]],
-              [bbox2[0], bbox2[1]]
-            ]
-          ]
-        };
-        return poly;
-      }
-      function tile2lon2(x, z) {
-        return x / Math.pow(2, z) * 360 - 180;
-      }
-      function tile2lat2(y, z) {
-        var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
-        return r2d2 * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
-      }
-      function pointToTile2(lon, lat, z) {
-        var tile = pointToTileFraction2(lon, lat, z);
-        tile[0] = Math.floor(tile[0]);
-        tile[1] = Math.floor(tile[1]);
-        return tile;
-      }
-      function getChildren2(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 getParent2(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 getSiblings2(tile) {
-        return getChildren2(getParent2(tile));
-      }
-      function hasSiblings2(tile, tiles3) {
-        var siblings = getSiblings2(tile);
-        for (var i = 0; i < siblings.length; i++) {
-          if (!hasTile2(tiles3, siblings[i]))
-            return false;
-        }
-        return true;
-      }
-      function hasTile2(tiles3, tile) {
-        for (var i = 0; i < tiles3.length; i++) {
-          if (tilesEqual2(tiles3[i], tile))
-            return true;
-        }
-        return false;
-      }
-      function tilesEqual2(tile1, tile2) {
-        return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
-      }
-      function tileToQuadkey2(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 quadkeyToTile2(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 bboxToTile2(bboxCoords) {
-        var min2 = pointToTile2(bboxCoords[0], bboxCoords[1], 32);
-        var max2 = pointToTile2(bboxCoords[2], bboxCoords[3], 32);
-        var bbox2 = [min2[0], min2[1], max2[0], max2[1]];
-        var z = getBboxZoom2(bbox2);
-        if (z === 0)
-          return [0, 0, 0];
-        var x = bbox2[0] >>> 32 - z;
-        var y = bbox2[1] >>> 32 - z;
-        return [x, y, z];
-      }
-      function getBboxZoom2(bbox2) {
-        var MAX_ZOOM = 28;
-        for (var z = 0; z < MAX_ZOOM; z++) {
-          var mask = 1 << 32 - (z + 1);
-          if ((bbox2[0] & mask) != (bbox2[2] & mask) || (bbox2[1] & mask) != (bbox2[3] & mask)) {
-            return z;
-          }
-        }
-        return MAX_ZOOM;
-      }
-      function pointToTileFraction2(lon, lat, z) {
-        var sin = Math.sin(lat * d2r2), 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: tileToGeoJSON2,
-        tileToBBOX: tileToBBOX2,
-        getChildren: getChildren2,
-        getParent: getParent2,
-        getSiblings: getSiblings2,
-        hasTile: hasTile2,
-        hasSiblings: hasSiblings2,
-        tilesEqual: tilesEqual2,
-        tileToQuadkey: tileToQuadkey2,
-        quadkeyToTile: quadkeyToTile2,
-        pointToTile: pointToTile2,
-        bboxToTile: bboxToTile2,
-        pointToTileFraction: pointToTileFraction2
-      };
-    }
-  });
-
-  // ../../node_modules/@mapbox/tile-cover/index.js
-  var require_tile_cover = __commonJS({
-    "../../node_modules/@mapbox/tile-cover/index.js"(exports) {
-      var tilebelt2 = require_tilebelt();
-      exports.geojson = function(geom, limits) {
-        return {
-          type: "FeatureCollection",
-          features: getTiles2(geom, limits).map(tileToFeature)
-        };
-      };
-      function tileToFeature(t) {
-        return {
-          type: "Feature",
-          geometry: tilebelt2.tileToGeoJSON(t),
-          properties: {}
-        };
-      }
-      exports.tiles = getTiles2;
-      exports.indexes = function(geom, limits) {
-        return getTiles2(geom, limits).map(tilebelt2.tileToQuadkey);
-      };
-      function getTiles2(geom, limits) {
-        var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles3 = [];
-        if (geom.type === "Point") {
-          return [tilebelt2.pointToTile(coords[0], coords[1], maxZoom)];
-        } else if (geom.type === "MultiPoint") {
-          for (i = 0; i < coords.length; i++) {
-            tile = tilebelt2.pointToTile(coords[i][0], coords[i][1], maxZoom);
-            tileHash[toID2(tile[0], tile[1], tile[2])] = true;
-          }
-        } else if (geom.type === "LineString") {
-          lineCover2(tileHash, coords, maxZoom);
-        } else if (geom.type === "MultiLineString") {
-          for (i = 0; i < coords.length; i++) {
-            lineCover2(tileHash, coords[i], maxZoom);
-          }
-        } else if (geom.type === "Polygon") {
-          polygonCover2(tileHash, tiles3, coords, maxZoom);
-        } else if (geom.type === "MultiPolygon") {
-          for (i = 0; i < coords.length; i++) {
-            polygonCover2(tileHash, tiles3, coords[i], maxZoom);
-          }
-        } else {
-          throw new Error("Geometry type not implemented");
-        }
-        if (limits.min_zoom !== maxZoom) {
-          var len = tiles3.length;
-          appendHashTiles2(tileHash, tiles3);
-          for (i = 0; i < len; i++) {
-            var t = tiles3[i];
-            tileHash[toID2(t[0], t[1], t[2])] = true;
-          }
-          return mergeTiles2(tileHash, tiles3, limits);
-        }
-        appendHashTiles2(tileHash, tiles3);
-        return tiles3;
-      }
-      function mergeTiles2(tileHash, tiles3, limits) {
-        var mergedTiles = [];
-        for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
-          var parentTileHash = {};
-          var parentTiles = [];
-          for (var i = 0; i < tiles3.length; i++) {
-            var t = tiles3[i];
-            if (t[0] % 2 === 0 && t[1] % 2 === 0) {
-              var id22 = toID2(t[0] + 1, t[1], z), id32 = toID2(t[0], t[1] + 1, z), id42 = toID2(t[0] + 1, t[1] + 1, z);
-              if (tileHash[id22] && tileHash[id32] && tileHash[id42]) {
-                tileHash[toID2(t[0], t[1], t[2])] = false;
-                tileHash[id22] = false;
-                tileHash[id32] = false;
-                tileHash[id42] = false;
-                var parentTile = [t[0] / 2, t[1] / 2, z - 1];
-                if (z - 1 === limits.min_zoom)
-                  mergedTiles.push(parentTile);
-                else {
-                  parentTileHash[toID2(t[0] / 2, t[1] / 2, z - 1)] = true;
-                  parentTiles.push(parentTile);
-                }
-              }
-            }
-          }
-          for (i = 0; i < tiles3.length; i++) {
-            t = tiles3[i];
-            if (tileHash[toID2(t[0], t[1], t[2])])
-              mergedTiles.push(t);
-          }
-          tileHash = parentTileHash;
-          tiles3 = parentTiles;
-        }
-        return mergedTiles;
-      }
-      function polygonCover2(tileHash, tileArray, geom, zoom) {
-        var intersections = [];
-        for (var i = 0; i < geom.length; i++) {
-          var ring = [];
-          lineCover2(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]) && // not local minimum
-            (y < ring[k][1] || y < ring[m][1]) && // not local maximum
-            y !== ring[m][1])
-              intersections.push(ring[j]);
-          }
-        }
-        intersections.sort(compareTiles2);
-        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 id5 = toID2(x, y, zoom);
-            if (!tileHash[id5]) {
-              tileArray.push([x, y, zoom]);
-            }
-          }
-        }
-      }
-      function compareTiles2(a, b) {
-        return a[1] - b[1] || a[0] - b[0];
-      }
-      function lineCover2(tileHash, coords, maxZoom, ring) {
-        var prevX, prevY;
-        for (var i = 0; i < coords.length - 1; i++) {
-          var start = tilebelt2.pointToTileFraction(coords[i][0], coords[i][1], maxZoom), stop = tilebelt2.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[toID2(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[toID2(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 appendHashTiles2(hash, tiles3) {
-        var keys = Object.keys(hash);
-        for (var i = 0; i < keys.length; i++) {
-          tiles3.push(fromID2(+keys[i]));
-        }
-      }
-      function toID2(x, y, z) {
-        var dim = 2 * (1 << z);
-        return (dim * y + x) * 32 + z;
-      }
-      function fromID2(id5) {
-        var z = id5 % 32, dim = 2 * (1 << z), xy = (id5 - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
-        return [x, y, z];
-      }
-    }
-  });
-
   // external-global-plugin:h3-js
   var require_h3_js = __commonJS({
     "external-global-plugin:h3-js"(exports, module) {
@@ -6044,9 +5716,6 @@ var __exports__ = (() => {
   // src/layers/cluster-tile-layer.ts
   var import_core6 = __toESM(require_core2(), 1);
 
-  // ../../node_modules/quadbin/dist/index.esm.js
-  var import_tile_cover = __toESM(require_tile_cover(), 1);
-
   // ../../node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
   var PI = Math.PI;
   var PI_4 = PI / 4;
@@ -6064,811 +5733,1149 @@ var __exports__ = (() => {
   var DEGREES_TO_RADIANS2 = Math.PI / 180;
 
   // ../../node_modules/quadbin/dist/index.esm.js
-  var B = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
-  var S = [0n, 1n, 2n, 4n, 8n, 16n];
-  function hexToBigInt(hex3) {
-    return BigInt(`0x${hex3}`);
+  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 bigIntToHex(index2) {
-    return index2.toString(16);
+  function tileToGeoJSON(tile) {
+    var bbox2 = tileToBBOX(tile);
+    var poly = {
+      type: "Polygon",
+      coordinates: [
+        [
+          [bbox2[0], bbox2[1]],
+          [bbox2[0], bbox2[3]],
+          [bbox2[2], bbox2[3]],
+          [bbox2[2], bbox2[1]],
+          [bbox2[0], bbox2[1]]
+        ]
+      ]
+    };
+    return poly;
   }
-  function tileToCell(tile) {
-    if (tile.z < 0 || tile.z > 26) {
-      throw new Error("Wrong zoom");
-    }
-    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;
-    }
-    const quadbin = 0x4000000000000000n | 1n << 59n | // | (mode << 59) | (mode_dep << 57)
-    z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
-    return quadbin;
+  function tile2lon(x, z) {
+    return x / Math.pow(2, z) * 360 - 180;
   }
-  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");
-    }
-    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;
-    }
-    x = x >> 32n - z;
-    y = y >> 32n - z;
-    return {
-      z: Number(z),
-      x: Number(x),
-      y: Number(y)
-    };
+  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 getResolution(quadbin) {
-    return quadbin >> 52n & 0x1fn;
+  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 cellToParent(quadbin) {
-    const zparent = getResolution(quadbin) - 1n;
-    const parent = quadbin & ~(0x1fn << 52n) | zparent << 52n | 0xfffffffffffffn >> zparent * 2n;
-    return parent;
+  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]
+    ];
   }
-
-  // src/layers/cluster-utils.ts
-  var import_h3_js = __toESM(require_h3_js(), 1);
-  var import_core2 = __toESM(require_core2(), 1);
-
-  // src/utils.ts
-  var import_core = __toESM(require_core2(), 1);
-  function assert2(condition, message) {
-    import_core.log.assert(condition, message);
+  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 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 getSiblings(tile) {
+    return getChildren(getParent(tile));
   }
-  function getWorkerUrl(id5, version) {
-    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id5}-worker.js`;
+  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;
   }
-  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 createEmptyBinary() {
-    return {
-      shape: "binary-feature-collection",
-      points: {
-        type: "Point",
-        ...EMPTY_BINARY_PROPS
-      },
-      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
-      }
-    };
+  function hasTile(tiles2, tile) {
+    for (var i = 0; i < tiles2.length; i++) {
+      if (tilesEqual(tiles2[i], tile))
+        return true;
+    }
+    return false;
   }
-  function createBinaryPointFeature(positions, featureIds, globalFeatureIds, numericProps, properties, size = 2) {
-    return {
-      type: "Point",
-      positions: { value: new Float32Array(positions), size },
-      featureIds: { value: new Uint16Array(featureIds), size: 1 },
-      globalFeatureIds: { value: new Uint32Array(globalFeatureIds), size: 1 },
-      numericProps,
-      properties
-    };
+  function tilesEqual(tile1, tile2) {
+    return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
   }
-  function initializeNumericProps(numPoints, sourceProps) {
-    const numericProps = {};
-    if (sourceProps) {
-      Object.keys(sourceProps).forEach((prop) => {
-        numericProps[prop] = { value: new Float32Array(numPoints), size: 1 };
-      });
+  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 numericProps;
+    return index2;
   }
-  function copyNumericProps(sourceProps, targetProps, sourceIndex, targetIndex) {
-    Object.keys(sourceProps).forEach((prop) => {
-      targetProps[prop].value[targetIndex] = sourceProps[prop].value[sourceIndex];
-    });
+  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];
   }
-
-  // src/layers/cluster-utils.ts
-  function aggregateTile(tile, tileAggregationCache, aggregationLevels, properties = [], getPosition, getWeight, scheme = "quadbin") {
-    if (!tile.content)
-      return false;
-    if (!tile.userData)
-      tile.userData = {};
-    const cell0 = tileAggregationCache.get(aggregationLevels)?.[0];
-    if (cell0) {
-      if (properties.every((property) => property.name in cell0)) {
-        return false;
+  function bboxToTile(bboxCoords) {
+    var min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
+    var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
+    var bbox2 = [min2[0], min2[1], max2[0], max2[1]];
+    var z = getBboxZoom(bbox2);
+    if (z === 0)
+      return [0, 0, 0];
+    var x = bbox2[0] >>> 32 - z;
+    var y = bbox2[1] >>> 32 - z;
+    return [x, y, z];
+  }
+  function getBboxZoom(bbox2) {
+    var MAX_ZOOM = 28;
+    for (var z = 0; z < MAX_ZOOM; z++) {
+      var mask = 1 << 32 - (z + 1);
+      if ((bbox2[0] & mask) != (bbox2[2] & mask) || (bbox2[1] & mask) != (bbox2[3] & mask)) {
+        return z;
       }
-      tileAggregationCache.clear();
     }
-    const out = {};
-    for (const cell of tile.content) {
-      let id5 = cell.id;
-      const position = typeof getPosition === "function" ? getPosition(cell, {}) : getPosition;
-      for (let i = 0; i < aggregationLevels - 1; i++) {
-        if (scheme === "h3") {
-          const currentResolution = (0, import_h3_js.getResolution)(id5);
-          id5 = (0, import_h3_js.cellToParent)(id5, Math.max(0, currentResolution - 1));
-        } else {
-          id5 = cellToParent(id5);
-        }
+    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];
+  }
+  var tilebelt = {
+    tileToGeoJSON,
+    tileToBBOX,
+    getChildren,
+    getParent,
+    getSiblings,
+    hasTile,
+    hasSiblings,
+    tilesEqual,
+    tileToQuadkey,
+    quadkeyToTile,
+    pointToTile,
+    bboxToTile,
+    pointToTileFraction
+  };
+  var tiles = getTiles;
+  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;
       }
-      const parentId = String(id5);
-      if (!(parentId in out)) {
-        out[parentId] = { id: id5, 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;
+    } 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), id42 = toID(t[0] + 1, t[1] + 1, z);
+          if (tileHash[id22] && tileHash[id32] && tileHash[id42]) {
+            tileHash[toID(t[0], t[1], t[2])] = false;
+            tileHash[id22] = false;
+            tileHash[id32] = false;
+            tileHash[id42] = 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);
+            }
           }
         }
       }
-      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);
-        }
+      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;
     }
-    tileAggregationCache.set(aggregationLevels, Object.values(out));
-    return true;
+    return mergedTiles;
   }
-  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)) {
-        import_core2.log.warn(`No valid aggregation present in ${name} property`)();
-        aggregation = "any";
+  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]) && // not local minimum
+        (y < ring[k][1] || y < ring[m][1]) && // not local maximum
+        y !== ring[m][1])
+          intersections.push(ring[j]);
       }
-      properties.push({ name, aggregation });
     }
-    return properties;
-  }
-  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]);
+    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 id5 = toID(x, y, zoom);
+        if (!tileHash[id5]) {
+          tileArray.push([x, y, zoom]);
         }
       }
     }
-    return stats;
   }
-  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 {
-      ...createEmptyBinary(),
-      points: createBinaryPointFeature(positions, featureIds, featureIds, {}, data)
-    };
+  function compareTiles(a, b) {
+    return a[1] - b[1] || a[0] - b[0];
   }
-
-  // src/constants.ts
-  var DEFAULT_TILE_SIZE = 512;
-
-  // src/layers/quadbin-tileset-2d.ts
-  var import_geo_layers = __toESM(require_geo_layers(), 1);
-  var QuadbinTileset2D = class extends import_geo_layers._Tileset2D {
-    // @ts-expect-error for spatial indices, TileSet2d should be parametrized by TileIndexT
-    getTileIndices(opts) {
-      return super.getTileIndices(opts).map(tileToCell).map((q) => ({ q, i: bigIntToHex(q) }));
-    }
-    // @ts-expect-error TileIndex must be generic
-    getTileId({ q, i }) {
-      return i || bigIntToHex(q);
-    }
-    // @ts-expect-error TileIndex must be generic
-    getTileMetadata({ q }) {
-      return super.getTileMetadata(cellToTile(q));
-    }
-    // @ts-expect-error TileIndex must be generic
-    getTileZoom({ q }) {
-      return Number(getResolution(q));
-    }
-    // @ts-expect-error TileIndex must be generic
-    getParentIndex({ q }) {
-      return { q: cellToParent(q) };
+  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;
+      }
     }
-  };
-
-  // src/layers/h3-tileset-2d.ts
-  var import_geo_layers2 = __toESM(require_geo_layers(), 1);
-  var import_h3_js2 = __toESM(require_h3_js(), 1);
-  var MAX_LATITUDE2 = 85.051128;
-  function padBoundingBox({ west, north, east, south }, resolution, scale = 1) {
-    const corners = [
-      [north, east],
-      [south, east],
-      [south, west],
-      [north, west]
-    ];
-    const cornerCells = corners.map((c) => (0, import_h3_js2.latLngToCell)(c[0], c[1], resolution));
-    const cornerEdgeLengths = cornerCells.map(
-      (c) => Math.max(...(0, import_h3_js2.originToDirectedEdges)(c).map((e) => (0, import_h3_js2.edgeLength)(e, import_h3_js2.UNITS.rads))) * 180 / Math.PI
-    );
-    const bufferLat = Math.max(...cornerEdgeLengths) * scale;
-    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
-    };
+    if (ring && y === ring[0][1])
+      ring.pop();
   }
-  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)];
+  function appendHashTiles(hash, tiles2) {
+    var keys = Object.keys(hash);
+    for (var i = 0; i < keys.length; i++) {
+      tiles2.push(fromID(+keys[i]));
     }
-    const polygon2 = [
-      [north, east],
-      [south, east],
-      [south, west],
-      [north, west],
-      [north, east]
-    ];
-    return (0, import_h3_js2.polygonToCells)(polygon2, resolution);
   }
-  function tileToBoundingBox(index2) {
-    const coordinates = (0, import_h3_js2.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);
-    const bbox2 = { west, south, east, north };
-    return padBoundingBox(bbox2, (0, import_h3_js2.getResolution)(index2), 0.12);
+  function toID(x, y, z) {
+    var dim = 2 * (1 << z);
+    return (dim * y + x) * 32 + z;
   }
-  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 fromID(id5) {
+    var z = id5 % 32, dim = 2 * (1 << z), xy = (id5 - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
+    return [x, y, z];
   }
-  var H3Tileset2D = class extends import_geo_layers2._Tileset2D {
-    /**
-     * Returns all tile indices in the current viewport. If the current zoom level is smaller
-     * than minZoom, return an empty array. If the current zoom level is greater than maxZoom,
-     * return tiles that are on maxZoom.
-     */
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    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_js2.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
-        indices = (0, import_h3_js2.gridDisk)(center, 1);
-      } else {
-        const paddedBounds = padBoundingBox({ west, north, east, south }, z);
-        indices = getHexagonsInBoundingBox(paddedBounds, z);
-      }
-      return indices.map((i) => ({ i }));
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileId({ i }) {
-      return i;
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileMetadata({ i }) {
-      return { bbox: tileToBoundingBox(i) };
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileZoom({ i }) {
-      return (0, import_h3_js2.getResolution)(i);
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getParentIndex(index2) {
-      const resolution = (0, import_h3_js2.getResolution)(index2.i);
-      const i = (0, import_h3_js2.cellToParent)(index2.i, resolution - 1);
-      return { i };
-    }
-  };
-
-  // src/layers/quadbin-utils.ts
+  var B = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
+  var S = [0n, 1n, 2n, 4n, 8n, 16n];
   var TILE_SIZE2 = 512;
-  function quadbinToOffset(quadbin) {
-    const { x, y, z } = cellToTile(quadbin);
+  function cellToOffset(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 cellToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale] = cellToOffset(quadbin);
+    return [[xOffset, yOffset], [xOffset + coverage * scale, yOffset - coverage * scale]];
   }
-  function getQuadbinPolygon(quadbin, coverage = 1) {
-    const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
+  function getCellPolygon(quadbin, coverage = 1) {
+    const [topLeft, bottomRight] = cellToWorldBounds(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/cluster-tile-layer.ts
-  var import_h3_js3 = __toESM(require_h3_js(), 1);
-
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js
-  var globals = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_ = globals.self || globals.window || globals.global || {};
-  var window_ = globals.window || globals.self || globals.global || {};
-  var global_ = globals.global || globals.self || globals.window || {};
-  var document_ = globals.document || {};
-  var isBrowser = (
-    // @ts-ignore process does not exist on browser
-    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
-  );
-  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion = matches && parseFloat(matches[1]) || 0;
-
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/javascript-utils/is-type.js
-  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
-
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/module-utils/js-module-utils.js
-  function registerJSModules(modules) {
-    globalThis.loaders ||= {};
-    globalThis.loaders.modules ||= {};
-    Object.assign(globalThis.loaders.modules, modules);
+  function hexToBigInt(hex3) {
+    return BigInt(`0x${hex3}`);
   }
-
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/array-buffer-utils.js
-  function concatenateArrayBuffers(...sources) {
-    return concatenateArrayBuffersFromArray(sources);
+  function bigIntToHex(index2) {
+    return index2.toString(16);
   }
-  function concatenateArrayBuffersFromArray(sources) {
-    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
-    const byteLength = sourceArrays.reduce((length2, typedArray) => length2 + typedArray.byteLength, 0);
-    const result = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const sourceArray of sourceArrays) {
-      result.set(sourceArray, offset);
-      offset += sourceArray.byteLength;
+  function tileToCell(tile) {
+    if (tile.z < 0 || tile.z > 26) {
+      throw new Error("Wrong zoom");
     }
-    return result.buffer;
-  }
-
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/iterators/async-iteration.js
-  async function concatenateArrayBuffersAsync(asyncIterator) {
-    const arrayBuffers = [];
-    for await (const chunk of asyncIterator) {
-      arrayBuffers.push(copyToArrayBuffer(chunk));
+    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;
     }
-    return concatenateArrayBuffers(...arrayBuffers);
+    const quadbin = 0x4000000000000000n | 1n << 59n | // | (mode << 59) | (mode_dep << 57)
+    z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
+    return quadbin;
   }
-  function copyToArrayBuffer(chunk) {
-    if (chunk instanceof ArrayBuffer) {
-      return chunk;
-    }
-    if (ArrayBuffer.isView(chunk)) {
-      const { buffer, byteOffset, byteLength } = chunk;
-      return copyFromBuffer(buffer, byteOffset, byteLength);
+  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");
     }
-    return copyFromBuffer(chunk);
+    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;
+    }
+    x = x >> 32n - z;
+    y = y >> 32n - z;
+    return {
+      z: Number(z),
+      x: Number(x),
+      y: Number(y)
+    };
   }
-  function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
-    const view = new Uint8Array(buffer, byteOffset, byteLength);
-    const copy3 = new Uint8Array(view.length);
-    copy3.set(view);
-    return copy3.buffer;
+  function getResolution(quadbin) {
+    return quadbin >> 52n & 0x1fn;
   }
-
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/node/buffer.browser.js
-  function toArrayBuffer(buffer) {
-    return buffer;
+  function cellToParent(quadbin) {
+    const zparent = getResolution(quadbin) - 1n;
+    const parent = quadbin & ~(0x1fn << 52n) | zparent << 52n | 0xfffffffffffffn >> zparent * 2n;
+    return parent;
+  }
+  function geometryToCells(geometry, resolution) {
+    const zoom = Number(resolution);
+    return tiles(geometry, {
+      min_zoom: zoom,
+      max_zoom: zoom
+    }).map(([x, y, z]) => tileToCell({
+      x,
+      y,
+      z
+    }));
+  }
+  function cellToBoundary(cell) {
+    const bbox2 = getCellPolygon(cell);
+    const boundary = [[bbox2[0], bbox2[1]], [bbox2[2], bbox2[3]], [bbox2[4], bbox2[5]], [bbox2[6], bbox2[7]], [bbox2[0], bbox2[1]]];
+    return {
+      type: "Polygon",
+      coordinates: [boundary]
+    };
   }
 
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/memory-conversion-utils.js
-  function isBuffer(value) {
-    return value && typeof value === "object" && value.isBuffer;
+  // src/layers/cluster-utils.ts
+  var import_h3_js = __toESM(require_h3_js(), 1);
+  var import_core2 = __toESM(require_core2(), 1);
+
+  // src/utils.ts
+  var import_core = __toESM(require_core2(), 1);
+  function assert2(condition, message) {
+    import_core.log.assert(condition, message);
   }
-  function toArrayBuffer2(data) {
-    if (isBuffer(data)) {
-      return toArrayBuffer(data);
-    }
-    if (data instanceof ArrayBuffer) {
-      return data;
+  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(id5, version) {
+    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id5}-worker.js`;
+  }
+  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 createEmptyBinary() {
+    return {
+      shape: "binary-feature-collection",
+      points: {
+        type: "Point",
+        ...EMPTY_BINARY_PROPS
+      },
+      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
+      }
+    };
+  }
+  function createBinaryPointFeature(positions, featureIds, globalFeatureIds, numericProps, properties, size = 2) {
+    return {
+      type: "Point",
+      positions: { value: new Float32Array(positions), size },
+      featureIds: { value: new Uint16Array(featureIds), size: 1 },
+      globalFeatureIds: { value: new Uint32Array(globalFeatureIds), size: 1 },
+      numericProps,
+      properties
+    };
+  }
+  function initializeNumericProps(numPoints, sourceProps) {
+    const numericProps = {};
+    if (sourceProps) {
+      Object.keys(sourceProps).forEach((prop) => {
+        numericProps[prop] = { value: new Float32Array(numPoints), size: 1 };
+      });
     }
-    if (isSharedArrayBuffer(data)) {
-      return copyToArrayBuffer2(data);
+    return numericProps;
+  }
+  function copyNumericProps(sourceProps, targetProps, sourceIndex, targetIndex) {
+    Object.keys(sourceProps).forEach((prop) => {
+      targetProps[prop].value[targetIndex] = sourceProps[prop].value[sourceIndex];
+    });
+  }
+
+  // src/layers/cluster-utils.ts
+  function aggregateTile(tile, tileAggregationCache, aggregationLevels, properties = [], getPosition, getWeight, scheme = "quadbin") {
+    if (!tile.content)
+      return false;
+    if (!tile.userData)
+      tile.userData = {};
+    const cell0 = tileAggregationCache.get(aggregationLevels)?.[0];
+    if (cell0) {
+      if (properties.every((property) => property.name in cell0)) {
+        return false;
+      }
+      tileAggregationCache.clear();
     }
-    if (ArrayBuffer.isView(data)) {
-      const buffer = data.buffer;
-      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return buffer;
+    const out = {};
+    for (const cell of tile.content) {
+      let id5 = cell.id;
+      const position = typeof getPosition === "function" ? getPosition(cell, {}) : getPosition;
+      for (let i = 0; i < aggregationLevels - 1; i++) {
+        if (scheme === "h3") {
+          const currentResolution = (0, import_h3_js.getResolution)(id5);
+          id5 = (0, import_h3_js.cellToParent)(id5, Math.max(0, currentResolution - 1));
+        } else {
+          id5 = cellToParent(id5);
+        }
+      }
+      const parentId = String(id5);
+      if (!(parentId in out)) {
+        out[parentId] = { id: id5, 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;
+          }
+        }
+      }
+      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);
+        }
       }
-      return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
     }
-    if (typeof data === "string") {
-      const text = data;
-      const uint8Array = new TextEncoder().encode(text);
-      return uint8Array.buffer;
+    tileAggregationCache.set(aggregationLevels, Object.values(out));
+    return true;
+  }
+  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)) {
+        import_core2.log.warn(`No valid aggregation present in ${name} property`)();
+        aggregation = "any";
+      }
+      properties.push({ name, aggregation });
     }
-    if (data && typeof data === "object" && data._toArrayBuffer) {
-      return data._toArrayBuffer();
+    return properties;
+  }
+  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]);
+        }
+      }
     }
-    throw new Error("toArrayBuffer");
+    return stats;
   }
-  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
-    const view = new Uint8Array(buffer, byteOffset, byteLength);
-    const copy3 = new Uint8Array(view.length);
-    copy3.set(view);
-    return copy3.buffer;
+  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 {
+      ...createEmptyBinary(),
+      points: createBinaryPointFeature(positions, featureIds, featureIds, {}, data)
+    };
   }
 
-  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/node/promisify.js
-  function promisify1(fn) {
-    return (args) => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
-  }
+  // src/constants.ts
+  var DEFAULT_TILE_SIZE = 512;
 
-  // ../../node_modules/@loaders.gl/compression/dist/lib/compression.js
-  var Compression = class {
-    constructor(options) {
-      this.compressBatches = this.compressBatches.bind(this);
-      this.decompressBatches = this.decompressBatches.bind(this);
-    }
-    /** Preloads any dynamic libraries. May enable sync functions */
-    async preload(modules = {}) {
-      registerJSModules(modules);
-      return;
-    }
-    /** Asynchronously compress data */
-    async compress(input) {
-      await this.preload();
-      return this.compressSync(input);
-    }
-    /** Asynchronously decompress data */
-    async decompress(input, size) {
-      await this.preload();
-      return this.decompressSync(input, size);
-    }
-    /** Synchronously compress data */
-    compressSync(input) {
-      throw new Error(`${this.name}: sync compression not supported`);
-    }
-    /** Synchronously compress data */
-    decompressSync(input, size) {
-      throw new Error(`${this.name}: sync decompression not supported`);
+  // src/layers/quadbin-tileset-2d.ts
+  var import_geo_layers = __toESM(require_geo_layers(), 1);
+  var QuadbinTileset2D = class extends import_geo_layers._Tileset2D {
+    // @ts-expect-error for spatial indices, TileSet2d should be parametrized by TileIndexT
+    getTileIndices(opts) {
+      return super.getTileIndices(opts).map(tileToCell).map((q) => ({ q, i: bigIntToHex(q) }));
     }
-    /** Compress batches */
-    async *compressBatches(asyncIterator) {
-      const input = await this.concatenate(asyncIterator);
-      yield this.compress(input);
+    // @ts-expect-error TileIndex must be generic
+    getTileId({ q, i }) {
+      return i || bigIntToHex(q);
     }
-    /** Decompress batches */
-    async *decompressBatches(asyncIterator) {
-      const input = await this.concatenate(asyncIterator);
-      yield this.decompress(input);
+    // @ts-expect-error TileIndex must be generic
+    getTileMetadata({ q }) {
+      return super.getTileMetadata(cellToTile(q));
     }
-    // HELPERS
-    concatenate(asyncIterator) {
-      return concatenateArrayBuffersAsync(asyncIterator);
+    // @ts-expect-error TileIndex must be generic
+    getTileZoom({ q }) {
+      return Number(getResolution(q));
     }
-    improveError(error) {
-      if (!error.message.includes(this.name)) {
-        error.message = `${this.name} ${error.message}`;
-      }
-      return error;
+    // @ts-expect-error TileIndex must be generic
+    getParentIndex({ q }) {
+      return { q: cellToParent(q) };
     }
   };
 
-  // ../../node_modules/@loaders.gl/compression/dist/lib/deflate-compression.js
-  var import_pako = __toESM(require_pako(), 1);
-  var import_zlib = __toESM(require_zlib(), 1);
-  var DeflateCompression = class extends Compression {
-    name = "deflate";
-    extensions = [];
-    contentEncodings = ["deflate"];
-    isSupported = true;
-    options;
-    _chunks = [];
-    constructor(options = {}) {
-      super(options);
-      this.options = options;
-    }
-    async compress(input) {
-      if (!isBrowser && this.options.deflate?.useZlib) {
-        const buffer = this.options.deflate?.gzip ? await promisify1(import_zlib.default.gzip)(input) : await promisify1(import_zlib.default.deflate)(input);
-        return toArrayBuffer2(buffer);
-      }
-      return this.compressSync(input);
-    }
-    async decompress(input) {
-      if (!isBrowser && this.options.deflate?.useZlib) {
-        const buffer = this.options.deflate?.gzip ? await promisify1(import_zlib.default.gunzip)(input) : await promisify1(import_zlib.default.inflate)(input);
-        return toArrayBuffer2(buffer);
+  // src/layers/h3-tileset-2d.ts
+  var import_geo_layers2 = __toESM(require_geo_layers(), 1);
+  var import_h3_js2 = __toESM(require_h3_js(), 1);
+  var MAX_LATITUDE2 = 85.051128;
+  function padBoundingBox({ west, north, east, south }, resolution, scale = 1) {
+    const corners = [
+      [north, east],
+      [south, east],
+      [south, west],
+      [north, west]
+    ];
+    const cornerCells = corners.map((c) => (0, import_h3_js2.latLngToCell)(c[0], c[1], resolution));
+    const cornerEdgeLengths = cornerCells.map(
+      (c) => Math.max(...(0, import_h3_js2.originToDirectedEdges)(c).map((e) => (0, import_h3_js2.edgeLength)(e, import_h3_js2.UNITS.rads))) * 180 / Math.PI
+    );
+    const bufferLat = Math.max(...cornerEdgeLengths) * scale;
+    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 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 this.decompressSync(input);
+      return [...new Set(h3Indices)];
     }
-    compressSync(input) {
-      if (!isBrowser && this.options.deflate?.useZlib) {
-        const buffer = this.options.deflate?.gzip ? import_zlib.default.gzipSync(input) : import_zlib.default.deflateSync(input);
-        return toArrayBuffer2(buffer);
+    const polygon2 = [
+      [north, east],
+      [south, east],
+      [south, west],
+      [north, west],
+      [north, east]
+    ];
+    return (0, import_h3_js2.polygonToCells)(polygon2, resolution);
+  }
+  function tileToBoundingBox(index2) {
+    const coordinates = (0, import_h3_js2.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);
+    const bbox2 = { west, south, east, north };
+    return padBoundingBox(bbox2, (0, import_h3_js2.getResolution)(index2), 0.12);
+  }
+  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_layers2._Tileset2D {
+    /**
+     * Returns all tile indices in the current viewport. If the current zoom level is smaller
+     * than minZoom, return an empty array. If the current zoom level is greater than maxZoom,
+     * return tiles that are on maxZoom.
+     */
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    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 [];
       }
-      const pakoOptions = this.options?.deflate || {};
-      const inputArray = new Uint8Array(input);
-      const deflate = this.options?.raw ? import_pako.default.deflateRaw : import_pako.default.deflate;
-      return toArrayBuffer2(deflate(inputArray, pakoOptions).buffer);
-    }
-    decompressSync(input) {
-      if (!isBrowser && this.options.deflate?.useZlib) {
-        const buffer = this.options.deflate?.gzip ? import_zlib.default.gunzipSync(input) : import_zlib.default.inflateSync(input);
-        return toArrayBuffer2(buffer);
+      if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
+        z = maxZoom;
+        const center = (0, import_h3_js2.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
+        indices = (0, import_h3_js2.gridDisk)(center, 1);
+      } else {
+        const paddedBounds = padBoundingBox({ west, north, east, south }, z);
+        indices = getHexagonsInBoundingBox(paddedBounds, z);
       }
-      const pakoOptions = this.options?.deflate || {};
-      const inputArray = new Uint8Array(input);
-      const inflate = this.options?.raw ? import_pako.default.inflateRaw : import_pako.default.inflate;
-      return toArrayBuffer2(inflate(inputArray, pakoOptions).buffer);
-    }
-    async *compressBatches(asyncIterator) {
-      const pakoOptions = this.options?.deflate || {};
-      const pakoProcessor = new import_pako.default.Deflate(pakoOptions);
-      yield* this.transformBatches(pakoProcessor, asyncIterator);
-    }
-    async *decompressBatches(asyncIterator) {
-      const pakoOptions = this.options?.deflate || {};
-      const pakoProcessor = new import_pako.default.Inflate(pakoOptions);
-      yield* this.transformBatches(pakoProcessor, asyncIterator);
+      return indices.map((i) => ({ i }));
     }
-    async *transformBatches(pakoProcessor, asyncIterator) {
-      pakoProcessor.onData = this._onData.bind(this);
-      pakoProcessor.onEnd = this._onEnd.bind(this);
-      for await (const chunk of asyncIterator) {
-        const uint8Array = new Uint8Array(chunk);
-        const ok2 = pakoProcessor.push(uint8Array, false);
-        if (!ok2) {
-          throw new Error(`${this._getError()}write`);
-        }
-        const chunks2 = this._getChunks();
-        yield* chunks2;
-      }
-      const emptyChunk = new Uint8Array(0);
-      const ok = pakoProcessor.push(emptyChunk, true);
-      if (!ok) {
-      }
-      const chunks = this._getChunks();
-      yield* chunks;
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getTileId({ i }) {
+      return i;
     }
-    _onData(chunk) {
-      this._chunks.push(chunk);
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getTileMetadata({ i }) {
+      return { bbox: tileToBoundingBox(i) };
     }
-    _onEnd(status) {
-      if (status !== 0) {
-        throw new Error(this._getError(status) + this._chunks.length);
-      }
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getTileZoom({ i }) {
+      return (0, import_h3_js2.getResolution)(i);
     }
-    _getChunks() {
-      const chunks = this._chunks;
-      this._chunks = [];
-      return chunks;
-    }
-    // TODO - For some reason we don't get the error message from pako in _onEnd?
-    _getError(code = 0) {
-      const MESSAGES = {
-        /* Z_NEED_DICT       2  */
-        2: "need dictionary",
-        /* Z_STREAM_END      1  */
-        1: "stream end",
-        /* Z_OK              0  */
-        0: "",
-        /* Z_ERRNO         (-1) */
-        "-1": "file error",
-        /* Z_STREAM_ERROR  (-2) */
-        "-2": "stream error",
-        /* Z_DATA_ERROR    (-3) */
-        "-3": "data error",
-        /* Z_MEM_ERROR     (-4) */
-        "-4": "insufficient memory",
-        /* Z_BUF_ERROR     (-5) */
-        "-5": "buffer error",
-        /* Z_VERSION_ERROR (-6) */
-        "-6": "incompatible version"
-      };
-      return `${this.name}: ${MESSAGES[code]}`;
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getParentIndex(index2) {
+      const resolution = (0, import_h3_js2.getResolution)(index2.i);
+      const i = (0, import_h3_js2.cellToParent)(index2.i, resolution - 1);
+      return { i };
     }
   };
 
-  // ../../node_modules/@loaders.gl/compression/dist/lib/gzip-compression.js
-  var GZipCompression = class extends DeflateCompression {
-    name = "gzip";
-    extensions = ["gz", "gzip"];
-    contentEncodings = ["gzip", "x-gzip"];
-    isSupported = true;
-    constructor(options) {
-      super({ ...options, deflate: { ...options?.gzip, gzip: true } });
-    }
+  // src/layers/quadbin-utils.ts
+  var TILE_SIZE3 = 512;
+  function quadbinToOffset(quadbin) {
+    const { x, y, z } = cellToTile(quadbin);
+    const scale = TILE_SIZE3 / (1 << z);
+    return [x * scale, TILE_SIZE3 - 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/cluster-tile-layer.ts
+  var import_h3_js3 = __toESM(require_h3_js(), 1);
+
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
   };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
-  // src/layers/schema/fast-pbf.ts
-  function readPackedTypedArray(TypedArray, pbf, obj, options) {
-    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
-    const data = pbf.buf.buffer.slice(pbf.pos, end);
-    if (options?.compression === "gzip") {
-      const compression = new GZipCompression();
-      const decompressedData = compression.decompressSync(data);
-      obj.value = new TypedArray(decompressedData);
-    } else {
-      obj.value = new TypedArray(data);
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/javascript-utils/is-type.js
+  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/module-utils/js-module-utils.js
+  function registerJSModules(modules) {
+    globalThis.loaders ||= {};
+    globalThis.loaders.modules ||= {};
+    Object.assign(globalThis.loaders.modules, modules);
+  }
+
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/array-buffer-utils.js
+  function concatenateArrayBuffers(...sources) {
+    return concatenateArrayBuffersFromArray(sources);
+  }
+  function concatenateArrayBuffersFromArray(sources) {
+    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    const byteLength = sourceArrays.reduce((length2, typedArray) => length2 + typedArray.byteLength, 0);
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+      result.set(sourceArray, offset);
+      offset += sourceArray.byteLength;
     }
-    pbf.pos = end;
-    return obj.value;
+    return result.buffer;
   }
 
-  // src/layers/schema/carto-tile.ts
-  var KeyValueObjectReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(KeyValueObjectReader._readField, { key: "", value: null }, end);
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/iterators/async-iteration.js
+  async function concatenateArrayBuffersAsync(asyncIterator) {
+    const arrayBuffers = [];
+    for await (const chunk of asyncIterator) {
+      arrayBuffers.push(copyToArrayBuffer(chunk));
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.key = pbf.readString();
-      else if (tag === 2)
-        obj.value = pbf.readString();
+    return concatenateArrayBuffers(...arrayBuffers);
+  }
+  function copyToArrayBuffer(chunk) {
+    if (chunk instanceof ArrayBuffer) {
+      return chunk;
     }
-  };
-  var PropertiesReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(PropertiesReader._readField, {}, end);
+    if (ArrayBuffer.isView(chunk)) {
+      const { buffer, byteOffset, byteLength } = chunk;
+      return copyFromBuffer(buffer, byteOffset, byteLength);
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1) {
-        const { key, value } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
-        obj[key] = value;
-      }
+    return copyFromBuffer(chunk);
+  }
+  function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy3 = new Uint8Array(view.length);
+    copy3.set(view);
+    return copy3.buffer;
+  }
+
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/node/buffer.browser.js
+  function toArrayBuffer(buffer) {
+    return buffer;
+  }
+
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/binary-utils/memory-conversion-utils.js
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
+  }
+  function toArrayBuffer2(data) {
+    if (isBuffer(data)) {
+      return toArrayBuffer(data);
     }
-  };
-  var DoublesReader = class {
-    static read(pbf, end) {
-      const { value, size } = pbf.readFields(DoublesReader._readField, { value: [], size: 0 }, end);
-      return { value, size };
+    if (data instanceof ArrayBuffer) {
+      return data;
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        readPackedTypedArray(Float64Array, pbf, obj);
-      else if (tag === 2)
-        obj.size = pbf.readVarint(true);
+    if (isSharedArrayBuffer(data)) {
+      return copyToArrayBuffer2(data);
     }
-  };
-  var IntsReader = class {
-    static read(pbf, end) {
-      const { value, size } = pbf.readFields(IntsReader._readField, { value: [], size: 0 }, end);
-      return { value: new Uint32Array(value), size };
+    if (ArrayBuffer.isView(data)) {
+      const buffer = data.buffer;
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return buffer;
+      }
+      return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        pbf.readPackedVarint(obj.value);
-      else if (tag === 2)
-        obj.size = pbf.readVarint(true);
+    if (typeof data === "string") {
+      const text = data;
+      const uint8Array = new TextEncoder().encode(text);
+      return uint8Array.buffer;
     }
-  };
-  var FieldsReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(FieldsReader._readField, { id: 0 }, end);
+    if (data && typeof data === "object" && data._toArrayBuffer) {
+      return data._toArrayBuffer();
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.id = pbf.readVarint();
+    throw new Error("toArrayBuffer");
+  }
+  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy3 = new Uint8Array(view.length);
+    copy3.set(view);
+    return copy3.buffer;
+  }
+
+  // ../../node_modules/@loaders.gl/loader-utils/dist/lib/node/promisify.js
+  function promisify1(fn) {
+    return (args) => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+  }
+
+  // ../../node_modules/@loaders.gl/compression/dist/lib/compression.js
+  var Compression = class {
+    constructor(options) {
+      this.compressBatches = this.compressBatches.bind(this);
+      this.decompressBatches = this.decompressBatches.bind(this);
     }
-  };
-  var NumericPropReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(NumericPropReader._readField, { value: [] }, end);
+    /** Preloads any dynamic libraries. May enable sync functions */
+    async preload(modules = {}) {
+      registerJSModules(modules);
+      return;
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        readPackedTypedArray(Float64Array, pbf, obj);
+    /** Asynchronously compress data */
+    async compress(input) {
+      await this.preload();
+      return this.compressSync(input);
     }
-  };
-  var NumericPropKeyValueReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(NumericPropKeyValueReader._readField, { key: "", value: null }, end);
+    /** Asynchronously decompress data */
+    async decompress(input, size) {
+      await this.preload();
+      return this.decompressSync(input, size);
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.key = pbf.readString();
-      else if (tag === 2)
-        obj.value = NumericPropReader.read(pbf, pbf.readVarint() + pbf.pos);
+    /** Synchronously compress data */
+    compressSync(input) {
+      throw new Error(`${this.name}: sync compression not supported`);
     }
-  };
-  var PointsReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(
-        PointsReader._readField,
-        {
-          positions: null,
-          globalFeatureIds: null,
-          featureIds: null,
-          properties: [],
-          numericProps: {},
-          fields: []
-        },
-        end
-      );
+    /** Synchronously compress data */
+    decompressSync(input, size) {
+      throw new Error(`${this.name}: sync decompression not supported`);
+    }
+    /** Compress batches */
+    async *compressBatches(asyncIterator) {
+      const input = await this.concatenate(asyncIterator);
+      yield this.compress(input);
+    }
+    /** Decompress batches */
+    async *decompressBatches(asyncIterator) {
+      const input = await this.concatenate(asyncIterator);
+      yield this.decompress(input);
+    }
+    // HELPERS
+    concatenate(asyncIterator) {
+      return concatenateArrayBuffersAsync(asyncIterator);
+    }
+    improveError(error) {
+      if (!error.message.includes(this.name)) {
+        error.message = `${this.name} ${error.message}`;
+      }
+      return error;
+    }
+  };
+
+  // ../../node_modules/@loaders.gl/compression/dist/lib/deflate-compression.js
+  var import_pako = __toESM(require_pako(), 1);
+  var import_zlib = __toESM(require_zlib(), 1);
+  var DeflateCompression = class extends Compression {
+    name = "deflate";
+    extensions = [];
+    contentEncodings = ["deflate"];
+    isSupported = true;
+    options;
+    _chunks = [];
+    constructor(options = {}) {
+      super(options);
+      this.options = options;
+    }
+    async compress(input) {
+      if (!isBrowser && this.options.deflate?.useZlib) {
+        const buffer = this.options.deflate?.gzip ? await promisify1(import_zlib.default.gzip)(input) : await promisify1(import_zlib.default.deflate)(input);
+        return toArrayBuffer2(buffer);
+      }
+      return this.compressSync(input);
+    }
+    async decompress(input) {
+      if (!isBrowser && this.options.deflate?.useZlib) {
+        const buffer = this.options.deflate?.gzip ? await promisify1(import_zlib.default.gunzip)(input) : await promisify1(import_zlib.default.inflate)(input);
+        return toArrayBuffer2(buffer);
+      }
+      return this.decompressSync(input);
+    }
+    compressSync(input) {
+      if (!isBrowser && this.options.deflate?.useZlib) {
+        const buffer = this.options.deflate?.gzip ? import_zlib.default.gzipSync(input) : import_zlib.default.deflateSync(input);
+        return toArrayBuffer2(buffer);
+      }
+      const pakoOptions = this.options?.deflate || {};
+      const inputArray = new Uint8Array(input);
+      const deflate = this.options?.raw ? import_pako.default.deflateRaw : import_pako.default.deflate;
+      return toArrayBuffer2(deflate(inputArray, pakoOptions).buffer);
+    }
+    decompressSync(input) {
+      if (!isBrowser && this.options.deflate?.useZlib) {
+        const buffer = this.options.deflate?.gzip ? import_zlib.default.gunzipSync(input) : import_zlib.default.inflateSync(input);
+        return toArrayBuffer2(buffer);
+      }
+      const pakoOptions = this.options?.deflate || {};
+      const inputArray = new Uint8Array(input);
+      const inflate = this.options?.raw ? import_pako.default.inflateRaw : import_pako.default.inflate;
+      return toArrayBuffer2(inflate(inputArray, pakoOptions).buffer);
+    }
+    async *compressBatches(asyncIterator) {
+      const pakoOptions = this.options?.deflate || {};
+      const pakoProcessor = new import_pako.default.Deflate(pakoOptions);
+      yield* this.transformBatches(pakoProcessor, asyncIterator);
+    }
+    async *decompressBatches(asyncIterator) {
+      const pakoOptions = this.options?.deflate || {};
+      const pakoProcessor = new import_pako.default.Inflate(pakoOptions);
+      yield* this.transformBatches(pakoProcessor, asyncIterator);
+    }
+    async *transformBatches(pakoProcessor, asyncIterator) {
+      pakoProcessor.onData = this._onData.bind(this);
+      pakoProcessor.onEnd = this._onEnd.bind(this);
+      for await (const chunk of asyncIterator) {
+        const uint8Array = new Uint8Array(chunk);
+        const ok2 = pakoProcessor.push(uint8Array, false);
+        if (!ok2) {
+          throw new Error(`${this._getError()}write`);
+        }
+        const chunks2 = this._getChunks();
+        yield* chunks2;
+      }
+      const emptyChunk = new Uint8Array(0);
+      const ok = pakoProcessor.push(emptyChunk, true);
+      if (!ok) {
+      }
+      const chunks = this._getChunks();
+      yield* chunks;
+    }
+    _onData(chunk) {
+      this._chunks.push(chunk);
+    }
+    _onEnd(status) {
+      if (status !== 0) {
+        throw new Error(this._getError(status) + this._chunks.length);
+      }
+    }
+    _getChunks() {
+      const chunks = this._chunks;
+      this._chunks = [];
+      return chunks;
+    }
+    // TODO - For some reason we don't get the error message from pako in _onEnd?
+    _getError(code = 0) {
+      const MESSAGES = {
+        /* Z_NEED_DICT       2  */
+        2: "need dictionary",
+        /* Z_STREAM_END      1  */
+        1: "stream end",
+        /* Z_OK              0  */
+        0: "",
+        /* Z_ERRNO         (-1) */
+        "-1": "file error",
+        /* Z_STREAM_ERROR  (-2) */
+        "-2": "stream error",
+        /* Z_DATA_ERROR    (-3) */
+        "-3": "data error",
+        /* Z_MEM_ERROR     (-4) */
+        "-4": "insufficient memory",
+        /* Z_BUF_ERROR     (-5) */
+        "-5": "buffer error",
+        /* Z_VERSION_ERROR (-6) */
+        "-6": "incompatible version"
+      };
+      return `${this.name}: ${MESSAGES[code]}`;
+    }
+  };
+
+  // ../../node_modules/@loaders.gl/compression/dist/lib/gzip-compression.js
+  var GZipCompression = class extends DeflateCompression {
+    name = "gzip";
+    extensions = ["gz", "gzip"];
+    contentEncodings = ["gzip", "x-gzip"];
+    isSupported = true;
+    constructor(options) {
+      super({ ...options, deflate: { ...options?.gzip, gzip: true } });
+    }
+  };
+
+  // src/layers/schema/fast-pbf.ts
+  function readPackedTypedArray(TypedArray, pbf, obj, options) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    const data = pbf.buf.buffer.slice(pbf.pos, end);
+    if (options?.compression === "gzip") {
+      const compression = new GZipCompression();
+      const decompressedData = compression.decompressSync(data);
+      obj.value = new TypedArray(decompressedData);
+    } else {
+      obj.value = new TypedArray(data);
+    }
+    pbf.pos = end;
+    return obj.value;
+  }
+
+  // src/layers/schema/carto-tile.ts
+  var KeyValueObjectReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(KeyValueObjectReader._readField, { key: "", value: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.key = pbf.readString();
+      else if (tag === 2)
+        obj.value = pbf.readString();
+    }
+  };
+  var PropertiesReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(PropertiesReader._readField, {}, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1) {
+        const { key, value } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj[key] = value;
+      }
+    }
+  };
+  var DoublesReader = class {
+    static read(pbf, end) {
+      const { value, size } = pbf.readFields(DoublesReader._readField, { value: [], size: 0 }, end);
+      return { value, size };
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        readPackedTypedArray(Float64Array, pbf, obj);
+      else if (tag === 2)
+        obj.size = pbf.readVarint(true);
+    }
+  };
+  var IntsReader = class {
+    static read(pbf, end) {
+      const { value, size } = pbf.readFields(IntsReader._readField, { value: [], size: 0 }, end);
+      return { value: new Uint32Array(value), size };
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        pbf.readPackedVarint(obj.value);
+      else if (tag === 2)
+        obj.size = pbf.readVarint(true);
+    }
+  };
+  var FieldsReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(FieldsReader._readField, { id: 0 }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.id = pbf.readVarint();
+    }
+  };
+  var NumericPropReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(NumericPropReader._readField, { value: [] }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        readPackedTypedArray(Float64Array, pbf, obj);
+    }
+  };
+  var NumericPropKeyValueReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(NumericPropKeyValueReader._readField, { key: "", value: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.key = pbf.readString();
+      else if (tag === 2)
+        obj.value = NumericPropReader.read(pbf, pbf.readVarint() + pbf.pos);
+    }
+  };
+  var PointsReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(
+        PointsReader._readField,
+        {
+          positions: null,
+          globalFeatureIds: null,
+          featureIds: null,
+          properties: [],
+          numericProps: {},
+          fields: []
+        },
+        end
+      );
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -7953,8 +7960,8 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
       let maxDensity = 0;
       const loadedTiles = [...this.state.tiles].filter((t) => t.content);
       const visibleTiles = loadedTiles.filter((t) => t.isVisible);
-      const tiles3 = visibleTiles.length ? visibleTiles : loadedTiles;
-      for (const tile of tiles3) {
+      const tiles2 = visibleTiles.length ? visibleTiles : loadedTiles;
+      for (const tile of tiles2) {
         const cell = tile.content[0];
         const unitDensity = isH3 ? unitDensityForH3Cell(cell.id) : unitDensityForQuadbinCell(cell.id);
         maxDensity = Math.max(tile.userData.maxWeight * unitDensity, maxDensity);
@@ -7998,10 +8005,10 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
             getElevation: updateTriggers.getWeight
           },
           // Tile stats
-          onViewportLoad: (tiles4) => {
+          onViewportLoad: (tiles3) => {
             this.setState({ isLoaded: true });
             if (typeof onViewportLoad === "function") {
-              onViewportLoad(tiles4);
+              onViewportLoad(tiles3);
             }
           },
           onTileLoad: (tile) => {
@@ -8891,628 +8898,242 @@ void main(void) {
   function isPointInTriangle(p, v1, v2, v3) {
     const area = Math.abs((v2[0] - v1[0]) * (v3[1] - v1[1]) - (v3[0] - v1[0]) * (v2[1] - v1[1])) / 2;
     const area1 = Math.abs((v1[0] - p[0]) * (v2[1] - p[1]) - (v2[0] - p[0]) * (v1[1] - p[1])) / 2;
-    const area2 = Math.abs((v2[0] - p[0]) * (v3[1] - p[1]) - (v3[0] - p[0]) * (v2[1] - p[1])) / 2;
-    const area3 = Math.abs((v3[0] - p[0]) * (v1[1] - p[1]) - (v1[0] - p[0]) * (v3[1] - p[1])) / 2;
-    return Math.abs(area - (area1 + area2 + area3)) < 1e-10;
-  }
-  function getTriangleArea([x1, y1], [x2, y2], [x3, y3]) {
-    return Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2);
-  }
-  function getPolygonCentroid(polygons, index2) {
-    const {
-      positions: { value: positions, size }
-    } = polygons;
-    const startIndex = size * polygons.polygonIndices.value[index2];
-    const endIndex = size * polygons.polygonIndices.value[index2 + 1];
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (let i = startIndex; i < endIndex; i += size) {
-      const [x, y] = positions.subarray(i, i + 2);
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-    }
-    return [(minX + maxX) / 2, (minY + maxY) / 2];
-  }
-  function getSegmentLength(lines, index2) {
-    const {
-      positions: { value }
-    } = lines;
-    const [x1, y1, x2, y2] = value.subarray(index2, index2 + 4);
-    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
-  }
-  function getLineLength(lines, index2) {
-    const {
-      positions: { size }
-    } = lines;
-    const startIndex = size * lines.pathIndices.value[index2];
-    const endIndex = size * lines.pathIndices.value[index2 + 1];
-    let length2 = 0;
-    for (let j = startIndex; j < endIndex; j += size) {
-      length2 += getSegmentLength(lines, j);
-    }
-    return length2;
-  }
-  function getLineMidpoint(lines, index2) {
-    const {
-      positions: { value: positions },
-      pathIndices: { value: pathIndices }
-    } = lines;
-    const startIndex = pathIndices[index2] * 2;
-    const endIndex = pathIndices[index2 + 1] * 2;
-    const numPoints = (endIndex - startIndex) / 2;
-    if (numPoints === 2) {
-      const [x1, y1, x2, y2] = positions.subarray(startIndex, startIndex + 4);
-      return [(x1 + x2) / 2, (y1 + y2) / 2];
-    }
-    const midPointIndex = startIndex + Math.floor(numPoints / 2) * 2;
-    return [positions[midPointIndex], positions[midPointIndex + 1]];
-  }
-
-  // src/layers/vector-tile-layer.ts
-  (0, import_core16.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
-  var MVT_BBOX = { west: 0, east: 1, south: 0, north: 1 };
-  var defaultProps10 = {
-    ...import_geo_layers8.MVTLayer.defaultProps,
-    autoLabels: false,
-    data: TilejsonPropType,
-    dataComparator: TilejsonPropType.equal,
-    tileSize: DEFAULT_TILE_SIZE
-  };
-  var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
-    constructor(...propObjects) {
-      super(...propObjects);
-    }
-    initializeState() {
-      super.initializeState();
-      this.setState({ binary: true });
-    }
-    updateState(parameters) {
-      const { props } = parameters;
-      if (props.data) {
-        super.updateState(parameters);
-        const formatTiles = new URL(props.data.tiles[0]).searchParams.get("formatTiles");
-        const mvt = formatTiles === "mvt";
-        this.setState({ mvt });
-      }
-    }
-    getLoadOptions() {
-      const tileJSON = this.props.data;
-      return mergeLoadOptions(super.getLoadOptions(), {
-        fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } },
-        gis: { format: "binary" }
-        // Use binary for MVT loading
-      });
-    }
-    /* eslint-disable camelcase */
-    async getTileData(tile) {
-      const tileJSON = this.props.data;
-      const { tiles: tiles3, properties_tiles } = tileJSON;
-      const url = (0, import_geo_layers8._getURLFromTemplate)(tiles3, tile);
-      if (!url) {
-        return Promise.reject("Invalid URL");
-      }
-      const loadOptions = this.getLoadOptions();
-      const { fetch: fetch2 } = this.props;
-      const { signal } = tile;
-      const geometryFetch = fetch2(url, { propName: "data", layer: this, loadOptions, signal });
-      if (!properties_tiles) {
-        return await geometryFetch;
-      }
-      const propertiesUrl = (0, import_geo_layers8._getURLFromTemplate)(properties_tiles, tile);
-      if (!propertiesUrl) {
-        return Promise.reject("Invalid properties URL");
-      }
-      const attributesFetch = fetch2(propertiesUrl, {
-        propName: "data",
-        layer: this,
-        loadOptions,
-        signal
-      });
-      const [geometry, attributes] = await Promise.all([geometryFetch, attributesFetch]);
-      if (!geometry)
-        return null;
-      return attributes ? mergeBoundaryData(geometry, attributes) : geometry;
-    }
-    /* eslint-enable camelcase */
-    renderSubLayers(props) {
-      if (props.data === null) {
-        return null;
-      }
-      const tileBbox = props.tile.bbox;
-      const subLayers = [];
-      const defaultToPointLabelLayer = {
-        "points-text": {
-          type: PointLabelLayer,
-          ...props?._subLayerProps?.["points-text"],
-          extensions: [
-            new import_extensions.CollisionFilterExtension(),
-            ...props.extensions || [],
-            ...props?._subLayerProps?.["points-text"]?.extensions || []
-          ]
-        }
-      };
-      if (this.state.mvt) {
-        const subLayerProps = {
-          ...props,
-          _subLayerProps: {
-            ...props._subLayerProps,
-            ...defaultToPointLabelLayer
-          }
-        };
-        subLayers.push(super.renderSubLayers(subLayerProps));
-      } else {
-        const { west, south, east, north } = tileBbox;
-        const extensions = [new import_extensions.ClipExtension(), ...props.extensions || []];
-        const clipProps = {
-          clipBounds: [west, south, east, north]
-        };
-        const applyClipExtensionToSublayerProps = (subLayerId) => {
-          return {
-            [subLayerId]: {
-              ...clipProps,
-              ...props?._subLayerProps?.[subLayerId],
-              extensions: [...extensions, ...props?._subLayerProps?.[subLayerId]?.extensions || []]
-            }
-          };
-        };
-        const subLayerProps = {
-          ...props,
-          data: { ...props.data, tileBbox },
-          autoHighlight: false,
-          // Do not perform clipping on points (#9059)
-          _subLayerProps: {
-            ...props._subLayerProps,
-            ...defaultToPointLabelLayer,
-            ...applyClipExtensionToSublayerProps("polygons-fill"),
-            ...applyClipExtensionToSublayerProps("polygons-stroke"),
-            ...applyClipExtensionToSublayerProps("linestrings")
-          }
-        };
-        subLayers.push(new import_layers5.GeoJsonLayer(subLayerProps));
-      }
-      if (subLayers[0] && props.autoLabels) {
-        const labelData = createEmptyBinary();
-        if (props.data.lines && props.data.lines.positions.value.length > 0) {
-          labelData.points = createPointsFromLines(
-            props.data.lines,
-            typeof props.autoLabels === "object" ? props.autoLabels.uniqueIdProperty : void 0
-          );
-        }
-        if (props.data.polygons && props.data.polygons.positions.value.length > 0) {
-          labelData.points = createPointsFromPolygons(
-            props.data.polygons,
-            this.state.mvt ? MVT_BBOX : tileBbox,
-            props
-          );
-        }
-        subLayers.push(
-          subLayers[0].clone({
-            id: `${props.id}-labels`,
-            data: labelData,
-            pickable: false,
-            autoHighlight: false
-          })
-        );
-      }
-      return subLayers;
-    }
-    renderLayers() {
-      const layers = super.renderLayers();
-      if (!this.props.autoLabels) {
-        return layers;
-      }
-      const validLayers = (layers || []).flat().filter(Boolean);
-      validLayers.sort((a, b) => {
-        const aHasLabel = a.id.includes("labels");
-        const bHasLabel = b.id.includes("labels");
-        if (aHasLabel && !bHasLabel)
-          return 1;
-        if (!aHasLabel && bHasLabel)
-          return -1;
-        return 0;
-      });
-      return validLayers.map(
-        (l) => l.id.includes("labels") ? l.clone({ highlightedObjectIndex: -1 }) : l
-      );
-    }
-    _isWGS84() {
-      if (this.state.mvt)
-        return super._isWGS84();
-      return true;
-    }
-  };
-  VectorTileLayer.layerName = "VectorTileLayer";
-  VectorTileLayer.defaultProps = defaultProps10;
-
-  // ../../node_modules/@carto/api-client/node_modules/quadbin/dist/index.esm.js
-  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 bbox2 = tileToBBOX(tile);
-    var poly = {
-      type: "Polygon",
-      coordinates: [
-        [
-          [bbox2[0], bbox2[1]],
-          [bbox2[0], bbox2[3]],
-          [bbox2[2], bbox2[3]],
-          [bbox2[2], bbox2[1]],
-          [bbox2[0], bbox2[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];
-    }
-  }
-  function getSiblings(tile) {
-    return getChildren(getParent(tile));
+    const area2 = Math.abs((v2[0] - p[0]) * (v3[1] - p[1]) - (v3[0] - p[0]) * (v2[1] - p[1])) / 2;
+    const area3 = Math.abs((v3[0] - p[0]) * (v1[1] - p[1]) - (v1[0] - p[0]) * (v3[1] - p[1])) / 2;
+    return Math.abs(area - (area1 + area2 + area3)) < 1e-10;
   }
-  function hasSiblings(tile, tiles3) {
-    var siblings = getSiblings(tile);
-    for (var i = 0; i < siblings.length; i++) {
-      if (!hasTile(tiles3, siblings[i]))
-        return false;
-    }
-    return true;
+  function getTriangleArea([x1, y1], [x2, y2], [x3, y3]) {
+    return Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2);
   }
-  function hasTile(tiles3, tile) {
-    for (var i = 0; i < tiles3.length; i++) {
-      if (tilesEqual(tiles3[i], tile))
-        return true;
+  function getPolygonCentroid(polygons, index2) {
+    const {
+      positions: { value: positions, size }
+    } = polygons;
+    const startIndex = size * polygons.polygonIndices.value[index2];
+    const endIndex = size * polygons.polygonIndices.value[index2 + 1];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (let i = startIndex; i < endIndex; i += size) {
+      const [x, y] = positions.subarray(i, i + 2);
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
     }
-    return false;
+    return [(minX + maxX) / 2, (minY + maxY) / 2];
   }
-  function tilesEqual(tile1, tile2) {
-    return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
+  function getSegmentLength(lines, index2) {
+    const {
+      positions: { value }
+    } = lines;
+    const [x1, y1, x2, y2] = value.subarray(index2, index2 + 4);
+    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 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();
+  function getLineLength(lines, index2) {
+    const {
+      positions: { size }
+    } = lines;
+    const startIndex = size * lines.pathIndices.value[index2];
+    const endIndex = size * lines.pathIndices.value[index2 + 1];
+    let length2 = 0;
+    for (let j = startIndex; j < endIndex; j += size) {
+      length2 += getSegmentLength(lines, j);
     }
-    return index2;
+    return length2;
   }
-  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;
-      }
+  function getLineMidpoint(lines, index2) {
+    const {
+      positions: { value: positions },
+      pathIndices: { value: pathIndices }
+    } = lines;
+    const startIndex = pathIndices[index2] * 2;
+    const endIndex = pathIndices[index2 + 1] * 2;
+    const numPoints = (endIndex - startIndex) / 2;
+    if (numPoints === 2) {
+      const [x1, y1, x2, y2] = positions.subarray(startIndex, startIndex + 4);
+      return [(x1 + x2) / 2, (y1 + y2) / 2];
     }
-    return [x, y, z];
-  }
-  function bboxToTile(bboxCoords) {
-    var min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
-    var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
-    var bbox2 = [min2[0], min2[1], max2[0], max2[1]];
-    var z = getBboxZoom(bbox2);
-    if (z === 0)
-      return [0, 0, 0];
-    var x = bbox2[0] >>> 32 - z;
-    var y = bbox2[1] >>> 32 - z;
-    return [x, y, z];
+    const midPointIndex = startIndex + Math.floor(numPoints / 2) * 2;
+    return [positions[midPointIndex], positions[midPointIndex + 1]];
   }
-  function getBboxZoom(bbox2) {
-    var MAX_ZOOM = 28;
-    for (var z = 0; z < MAX_ZOOM; z++) {
-      var mask = 1 << 32 - (z + 1);
-      if ((bbox2[0] & mask) != (bbox2[2] & mask) || (bbox2[1] & mask) != (bbox2[3] & mask)) {
-        return z;
+
+  // src/layers/vector-tile-layer.ts
+  (0, import_core16.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
+  var MVT_BBOX = { west: 0, east: 1, south: 0, north: 1 };
+  var defaultProps10 = {
+    ...import_geo_layers8.MVTLayer.defaultProps,
+    autoLabels: false,
+    data: TilejsonPropType,
+    dataComparator: TilejsonPropType.equal,
+    tileSize: DEFAULT_TILE_SIZE
+  };
+  var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
+    constructor(...propObjects) {
+      super(...propObjects);
+    }
+    initializeState() {
+      super.initializeState();
+      this.setState({ binary: true });
+    }
+    updateState(parameters) {
+      const { props } = parameters;
+      if (props.data) {
+        super.updateState(parameters);
+        const formatTiles = new URL(props.data.tiles[0]).searchParams.get("formatTiles");
+        const mvt = formatTiles === "mvt";
+        this.setState({ mvt });
       }
     }
-    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];
-  }
-  var tilebelt = {
-    tileToGeoJSON,
-    tileToBBOX,
-    getChildren,
-    getParent,
-    getSiblings,
-    hasTile,
-    hasSiblings,
-    tilesEqual,
-    tileToQuadkey,
-    quadkeyToTile,
-    pointToTile,
-    bboxToTile,
-    pointToTileFraction
-  };
-  var tiles2 = getTiles;
-  function getTiles(geom, limits) {
-    var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles3 = [];
-    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;
+    getLoadOptions() {
+      const tileJSON = this.props.data;
+      return mergeLoadOptions(super.getLoadOptions(), {
+        fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } },
+        gis: { format: "binary" }
+        // Use binary for MVT loading
+      });
+    }
+    /* eslint-disable camelcase */
+    async getTileData(tile) {
+      const tileJSON = this.props.data;
+      const { tiles: tiles2, properties_tiles } = tileJSON;
+      const url = (0, import_geo_layers8._getURLFromTemplate)(tiles2, tile);
+      if (!url) {
+        return Promise.reject("Invalid URL");
       }
-    } 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);
+      const loadOptions = this.getLoadOptions();
+      const { fetch: fetch2 } = this.props;
+      const { signal } = tile;
+      const geometryFetch = fetch2(url, { propName: "data", layer: this, loadOptions, signal });
+      if (!properties_tiles) {
+        return await geometryFetch;
       }
-    } else if (geom.type === "Polygon") {
-      polygonCover(tileHash, tiles3, coords, maxZoom);
-    } else if (geom.type === "MultiPolygon") {
-      for (i = 0; i < coords.length; i++) {
-        polygonCover(tileHash, tiles3, coords[i], maxZoom);
+      const propertiesUrl = (0, import_geo_layers8._getURLFromTemplate)(properties_tiles, tile);
+      if (!propertiesUrl) {
+        return Promise.reject("Invalid properties URL");
       }
-    } else {
-      throw new Error("Geometry type not implemented");
+      const attributesFetch = fetch2(propertiesUrl, {
+        propName: "data",
+        layer: this,
+        loadOptions,
+        signal
+      });
+      const [geometry, attributes] = await Promise.all([geometryFetch, attributesFetch]);
+      if (!geometry)
+        return null;
+      return attributes ? mergeBoundaryData(geometry, attributes) : geometry;
     }
-    if (limits.min_zoom !== maxZoom) {
-      var len = tiles3.length;
-      appendHashTiles(tileHash, tiles3);
-      for (i = 0; i < len; i++) {
-        var t = tiles3[i];
-        tileHash[toID(t[0], t[1], t[2])] = true;
+    /* eslint-enable camelcase */
+    renderSubLayers(props) {
+      if (props.data === null) {
+        return null;
       }
-      return mergeTiles(tileHash, tiles3, limits);
-    }
-    appendHashTiles(tileHash, tiles3);
-    return tiles3;
-  }
-  function mergeTiles(tileHash, tiles3, limits) {
-    var mergedTiles = [];
-    for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
-      var parentTileHash = {};
-      var parentTiles = [];
-      for (var i = 0; i < tiles3.length; i++) {
-        var t = tiles3[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), id42 = toID(t[0] + 1, t[1] + 1, z);
-          if (tileHash[id22] && tileHash[id32] && tileHash[id42]) {
-            tileHash[toID(t[0], t[1], t[2])] = false;
-            tileHash[id22] = false;
-            tileHash[id32] = false;
-            tileHash[id42] = 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);
+      const tileBbox = props.tile.bbox;
+      const subLayers = [];
+      const defaultToPointLabelLayer = {
+        "points-text": {
+          type: PointLabelLayer,
+          ...props?._subLayerProps?.["points-text"],
+          extensions: [
+            new import_extensions.CollisionFilterExtension(),
+            ...props.extensions || [],
+            ...props?._subLayerProps?.["points-text"]?.extensions || []
+          ]
+        }
+      };
+      if (this.state.mvt) {
+        const subLayerProps = {
+          ...props,
+          _subLayerProps: {
+            ...props._subLayerProps,
+            ...defaultToPointLabelLayer
+          }
+        };
+        subLayers.push(super.renderSubLayers(subLayerProps));
+      } else {
+        const { west, south, east, north } = tileBbox;
+        const extensions = [new import_extensions.ClipExtension(), ...props.extensions || []];
+        const clipProps = {
+          clipBounds: [west, south, east, north]
+        };
+        const applyClipExtensionToSublayerProps = (subLayerId) => {
+          return {
+            [subLayerId]: {
+              ...clipProps,
+              ...props?._subLayerProps?.[subLayerId],
+              extensions: [...extensions, ...props?._subLayerProps?.[subLayerId]?.extensions || []]
             }
+          };
+        };
+        const subLayerProps = {
+          ...props,
+          data: { ...props.data, tileBbox },
+          autoHighlight: false,
+          // Do not perform clipping on points (#9059)
+          _subLayerProps: {
+            ...props._subLayerProps,
+            ...defaultToPointLabelLayer,
+            ...applyClipExtensionToSublayerProps("polygons-fill"),
+            ...applyClipExtensionToSublayerProps("polygons-stroke"),
+            ...applyClipExtensionToSublayerProps("linestrings")
           }
-        }
-      }
-      for (i = 0; i < tiles3.length; i++) {
-        t = tiles3[i];
-        if (tileHash[toID(t[0], t[1], t[2])])
-          mergedTiles.push(t);
-      }
-      tileHash = parentTileHash;
-      tiles3 = 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]) && // not local minimum
-        (y < ring[k][1] || y < ring[m][1]) && // not local maximum
-        y !== ring[m][1])
-          intersections.push(ring[j]);
+        };
+        subLayers.push(new import_layers5.GeoJsonLayer(subLayerProps));
       }
-    }
-    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 id5 = toID(x, y, zoom);
-        if (!tileHash[id5]) {
-          tileArray.push([x, y, zoom]);
+      if (subLayers[0] && props.autoLabels) {
+        const labelData = createEmptyBinary();
+        if (props.data.lines && props.data.lines.positions.value.length > 0) {
+          labelData.points = createPointsFromLines(
+            props.data.lines,
+            typeof props.autoLabels === "object" ? props.autoLabels.uniqueIdProperty : void 0
+          );
         }
-      }
-    }
-  }
-  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;
+        if (props.data.polygons && props.data.polygons.positions.value.length > 0) {
+          labelData.points = createPointsFromPolygons(
+            props.data.polygons,
+            this.state.mvt ? MVT_BBOX : tileBbox,
+            props
+          );
         }
-        tileHash[toID(x, y, maxZoom)] = true;
-        if (ring && y !== prevY)
-          ring.push([x, y]);
-        prevX = x;
-        prevY = y;
+        subLayers.push(
+          subLayers[0].clone({
+            id: `${props.id}-labels`,
+            data: labelData,
+            pickable: false,
+            autoHighlight: false
+          })
+        );
       }
+      return subLayers;
     }
-    if (ring && y === ring[0][1])
-      ring.pop();
-  }
-  function appendHashTiles(hash, tiles3) {
-    var keys = Object.keys(hash);
-    for (var i = 0; i < keys.length; i++) {
-      tiles3.push(fromID(+keys[i]));
-    }
-  }
-  function toID(x, y, z) {
-    var dim = 2 * (1 << z);
-    return (dim * y + x) * 32 + z;
-  }
-  function fromID(id5) {
-    var z = id5 % 32, dim = 2 * (1 << z), xy = (id5 - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
-    return [x, y, z];
-  }
-  var B2 = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
-  var S2 = [0n, 1n, 2n, 4n, 8n, 16n];
-  var TILE_SIZE3 = 512;
-  function cellToOffset(quadbin) {
-    const {
-      x,
-      y,
-      z
-    } = cellToTile2(quadbin);
-    const scale = TILE_SIZE3 / (1 << z);
-    return [x * scale, TILE_SIZE3 - y * scale, scale];
-  }
-  function cellToWorldBounds(quadbin, coverage) {
-    const [xOffset, yOffset, scale] = cellToOffset(quadbin);
-    return [[xOffset, yOffset], [xOffset + coverage * scale, yOffset - coverage * scale]];
-  }
-  function getCellPolygon(quadbin, coverage = 1) {
-    const [topLeft, bottomRight] = cellToWorldBounds(quadbin, coverage);
-    const [w, n] = worldToLngLat(topLeft);
-    const [e, s] = worldToLngLat(bottomRight);
-    return [e, n, e, s, w, s, w, n, e, n];
-  }
-  function tileToCell2(tile) {
-    if (tile.z < 0 || tile.z > 26) {
-      throw new Error("Wrong zoom");
-    }
-    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 = S2[5 - i];
-      const b = B2[4 - i];
-      x = (x | x << s) & b;
-      y = (y | y << s) & b;
-    }
-    const quadbin = 0x4000000000000000n | 1n << 59n | // | (mode << 59) | (mode_dep << 57)
-    z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
-    return quadbin;
-  }
-  function cellToTile2(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");
+    renderLayers() {
+      const layers = super.renderLayers();
+      if (!this.props.autoLabels) {
+        return layers;
+      }
+      const validLayers = (layers || []).flat().filter(Boolean);
+      validLayers.sort((a, b) => {
+        const aHasLabel = a.id.includes("labels");
+        const bHasLabel = b.id.includes("labels");
+        if (aHasLabel && !bHasLabel)
+          return 1;
+        if (!aHasLabel && bHasLabel)
+          return -1;
+        return 0;
+      });
+      return validLayers.map(
+        (l) => l.id.includes("labels") ? l.clone({ highlightedObjectIndex: -1 }) : l
+      );
     }
-    let x = q;
-    let y = q >> 1n;
-    for (let i = 0; i < 6; i++) {
-      const s = S2[i];
-      const b = B2[i];
-      x = (x | x >> s) & b;
-      y = (y | y >> s) & b;
+    _isWGS84() {
+      if (this.state.mvt)
+        return super._isWGS84();
+      return true;
     }
-    x = x >> 32n - z;
-    y = y >> 32n - z;
-    return {
-      z: Number(z),
-      x: Number(x),
-      y: Number(y)
-    };
-  }
-  function getResolution4(quadbin) {
-    return quadbin >> 52n & 0x1fn;
-  }
-  function geometryToCells(geometry, resolution) {
-    const zoom = Number(resolution);
-    return tiles2(geometry, {
-      min_zoom: zoom,
-      max_zoom: zoom
-    }).map(([x, y, z]) => tileToCell2({
-      x,
-      y,
-      z
-    }));
-  }
-  function cellToBoundary2(cell) {
-    const bbox2 = getCellPolygon(cell);
-    const boundary = [[bbox2[0], bbox2[1]], [bbox2[2], bbox2[3]], [bbox2[4], bbox2[5]], [bbox2[6], bbox2[7]], [bbox2[0], bbox2[1]]];
-    return {
-      type: "Polygon",
-      coordinates: [boundary]
-    };
-  }
+  };
+  VectorTileLayer.layerName = "VectorTileLayer";
+  VectorTileLayer.defaultProps = defaultProps10;
 
   // ../../node_modules/@carto/api-client/build/api-client.js
   var import_h3_js5 = __toESM(require_h3_js(), 1);
@@ -12181,6 +11802,9 @@ void main(void) {
     return ApiVersion2;
   })(ApiVersion || {});
   var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
+  var AUDIT_TAGS = {
+    mapId: "tag-mapId"
+  };
   var SpatialIndex = /* @__PURE__ */ ((SpatialIndex2) => {
     SpatialIndex2["H3"] = "h3";
     SpatialIndex2["QUADBIN"] = "quadbin";
@@ -12427,7 +12051,7 @@ void main(void) {
   var ccwerrboundA = (3 + 16 * epsilon) * epsilon;
   var ccwerrboundB = (2 + 12 * epsilon) * epsilon;
   var ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
-  var B3 = vec(4);
+  var B2 = vec(4);
   var C1 = vec(8);
   var C2 = vec(12);
   var D = vec(16);
@@ -12457,18 +12081,18 @@ void main(void) {
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    B3[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    B2[0] = s0 - (_i + bvirt) + (bvirt - t0);
     _j = s1 + _i;
     bvirt = _j - s1;
     _0 = s1 - (_j - bvirt) + (_i - bvirt);
     _i = _0 - t1;
     bvirt = _0 - _i;
-    B3[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    B2[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u32 = _j + _i;
     bvirt = u32 - _j;
-    B3[2] = _j - (u32 - bvirt) + (_i - bvirt);
-    B3[3] = u32;
-    let det = estimate(4, B3);
+    B2[2] = _j - (u32 - bvirt) + (_i - bvirt);
+    B2[3] = u32;
+    let det = estimate(4, B2);
     let errbound = ccwerrboundB * detsum;
     if (det >= errbound || -det >= errbound) {
       return det;
@@ -12517,7 +12141,7 @@ void main(void) {
     bvirt = u32 - _j;
     u[2] = _j - (u32 - bvirt) + (_i - bvirt);
     u[3] = u32;
-    const C1len = sum(4, B3, 4, u, C1);
+    const C1len = sum(4, B2, 4, u, C1);
     s1 = acx * bcytail;
     c = splitter * acx;
     ahi = c - (c - acx);
@@ -17369,7 +16993,7 @@ void main(void) {
     return intersectTileQuadbin(parent, cellResolution, spatialFilter);
   }
   function intersectTileQuadbin(parent, cellResolution, spatialFilter) {
-    const tilePolygon = cellToBoundary2(parent);
+    const tilePolygon = cellToBoundary(parent);
     if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
       return true;
     }
@@ -17406,14 +17030,14 @@ void main(void) {
   }
   var FEATURE_GEOM_PROPERTY = "__geomValue";
   function tileFeaturesGeometries({
-    tiles: tiles3,
+    tiles: tiles2,
     tileFormat,
     spatialFilter,
     uniqueIdProperty,
     options
   }) {
     const map2 = /* @__PURE__ */ new Map();
-    for (const tile of tiles3) {
+    for (const tile of tiles2) {
       if (tile.isVisible === false || !tile.data) {
         continue;
       }
@@ -17685,14 +17309,14 @@ void main(void) {
     return pointIndices;
   }
   function tileFeaturesSpatialIndex({
-    tiles: tiles3,
+    tiles: tiles2,
     spatialFilter,
     spatialDataColumn,
     spatialDataType
   }) {
     const map2 = /* @__PURE__ */ new Map();
     const spatialIndex = getSpatialIndex(spatialDataType);
-    const cellResolution = getResolution5(tiles3, spatialIndex);
+    const cellResolution = getResolution4(tiles2, spatialIndex);
     const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
     if (!cellResolution) {
       return [];
@@ -17701,7 +17325,7 @@ void main(void) {
     if (spatialIndex === "h3") {
       intersection3 = intersectTileH3(cellResolution, spatialFilter);
     }
-    for (const tile of tiles3) {
+    for (const tile of tiles2) {
       if (tile.isVisible === false || !tile.data) {
         continue;
       }
@@ -17729,13 +17353,13 @@ void main(void) {
     }
     return tile.id;
   }
-  function getResolution5(tiles3, spatialIndex) {
-    const data = tiles3.find((tile) => tile.data?.length)?.data;
+  function getResolution4(tiles2, spatialIndex) {
+    const data = tiles2.find((tile) => tile.data?.length)?.data;
     if (!data) {
       return;
     }
     if (spatialIndex === "quadbin") {
-      return Number(getResolution4(data[0].id));
+      return Number(getResolution(data[0].id));
     }
     if (spatialIndex === "h3") {
       return (0, import_h3_js6.getResolution)(data[0].id);
@@ -17761,21 +17385,21 @@ void main(void) {
   var DEFAULT_AGGREGATION_EXP_ALIAS = "__aggregationValue";
   var DEFAULT_AGGREGATION_EXP = `1 AS ${DEFAULT_AGGREGATION_EXP_ALIAS}`;
   function tileFeaturesRaster({
-    tiles: tiles3,
+    tiles: tiles2,
     ...options
   }) {
     const metadataByBand = {};
     for (const band2 of options.rasterMetadata.bands) {
       metadataByBand[band2.name] = { ...band2, nodata: Number(band2.nodata) };
     }
-    tiles3 = tiles3.filter(isRasterTileVisible);
-    if (tiles3.length === 0)
+    tiles2 = tiles2.filter(isRasterTileVisible);
+    if (tiles2.length === 0)
       return [];
-    const tileResolution = getResolution4(tiles3[0].index.q);
-    const tileBlockSize = tiles3[0].data.blockSize;
+    const tileResolution = getResolution(tiles2[0].index.q);
+    const tileBlockSize = tiles2[0].data.blockSize;
     const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
     const data = /* @__PURE__ */ new Map();
-    for (const tile of tiles3) {
+    for (const tile of tiles2) {
       const parent = tile.index.q;
       const intersection3 = intersectTileRaster(
         parent,
@@ -17813,7 +17437,7 @@ void main(void) {
     return !!(tile.isVisible && tile.data?.cells?.numericProps);
   }
   function cellToChildrenRaster(parent, resolution) {
-    const parentTile = cellToTile2(parent);
+    const parentTile = cellToTile(parent);
     const childZ = Number(resolution);
     const blockSize = 2 ** (childZ - parentTile.z);
     const childBaseX = parentTile.x * blockSize;
@@ -17822,7 +17446,7 @@ void main(void) {
     for (let i = 0, il = blockSize ** 2; i < il; i++) {
       const x = childBaseX + i % blockSize;
       const y = childBaseY + Math.floor(i / blockSize);
-      cells.push(tileToCell2({ x, y, z: childZ }));
+      cells.push(tileToCell({ x, y, z: childZ }));
     }
     return cells;
   }
@@ -17886,7 +17510,7 @@ void main(void) {
     return spatialDataType;
   }
   function tileFeatures({
-    tiles: tiles3,
+    tiles: tiles2,
     spatialFilter,
     uniqueIdProperty,
     tileFormat,
@@ -17897,17 +17521,17 @@ void main(void) {
   }) {
     if (spatialDataType === "geo") {
       return tileFeaturesGeometries({
-        tiles: tiles3,
+        tiles: tiles2,
         tileFormat,
         spatialFilter,
         uniqueIdProperty,
         options: { storeGeometry }
       });
     }
-    if (tiles3.some(isRasterTile)) {
+    if (tiles2.some(isRasterTile)) {
       assert22(rasterMetadata, "Missing raster metadata");
       return tileFeaturesRaster({
-        tiles: tiles3,
+        tiles: tiles2,
         spatialFilter,
         spatialDataColumn,
         spatialDataType,
@@ -17915,7 +17539,7 @@ void main(void) {
       });
     }
     return tileFeaturesSpatialIndex({
-      tiles: tiles3,
+      tiles: tiles2,
       spatialFilter,
       spatialDataColumn,
       spatialDataType
@@ -18481,7 +18105,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         spatialFiltersMode,
         ...params
       } = options;
-      const { columns, dataType, featureIds, z, limit, tileResolution } = params;
+      const { columns, dataType, featureIds, z, limit, tileResolution, offset } = params;
       return executeModel({
         model: "pick",
         source: {
@@ -18494,12 +18118,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           dataType,
           featureIds,
           z,
+          offset,
           limit: limit || 1e3,
           tileResolution: tileResolution || DEFAULT_TILE_RESOLUTION
         },
         opts: { signal, headers: this.props.headers }
         // Avoid `normalizeObjectKeys()`, which changes column names.
-      }).then(({ rows }) => ({ rows }));
+      }).then(({ rows, metadata }) => ({ rows, metadata }));
     }
     async getFormula(options) {
       const {
@@ -19430,8 +19055,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
      * After tiles are loaded, {@link extractTileFeatures} must be called
      * before computing statistics on the tiles.
      */
-    loadTiles(tiles3) {
-      this._tiles = tiles3;
+    loadTiles(tiles2) {
+      this._tiles = tiles2;
       this._features.length = 0;
     }
     /** Configures options used to extract features from tiles. */
@@ -19862,12 +19487,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
      * After tiles are loaded, {@link extractTileFeatures} must be called
      * before computing statistics on the tiles.
      */
-    loadTiles(tiles3) {
+    loadTiles(tiles2) {
       if (!this._workerEnabled) {
-        return this._localImpl.loadTiles(tiles3);
+        return this._localImpl.loadTiles(tiles2);
       }
       const worker = this._getWorker();
-      tiles3 = tiles3.map(
+      tiles2 = tiles2.map(
         ({ id: id5, index: index2, bbox: bbox2, isVisible, data }) => {
           const tile = {
             id: id5,
@@ -19881,7 +19506,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       );
       worker.postMessage({
         method: "loadTiles",
-        params: [tiles3]
+        params: [tiles2]
       });
     }
     /** Configures options used to extract features from tiles. */
@@ -20418,7 +20043,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     } = options;
     const urlParameters = { q: sqlQuery };
     if (queryParameters) {
-      urlParameters.queryParameters = JSON.stringify(queryParameters);
+      urlParameters.queryParameters = queryParameters;
     }
     const baseUrl = buildQueryUrl({ apiBaseUrl, connectionName });
     const headers = {
@@ -21320,10 +20945,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       if (!attribute.categories) {
         return [0, 1];
       }
-      return attribute.categories.map((c) => c.category).filter((c) => c !== void 0 && c !== null);
+      return attribute.categories.map((c) => c.category).filter((c) => c !== void 0 && c !== null).slice(0, scaleLength);
     }
     if (scaleType === "quantile" && attribute.quantiles) {
-      return "global" in attribute.quantiles ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
+      const quantiles = "global" in attribute.quantiles ? attribute.quantiles.global : attribute.quantiles;
+      if (scaleLength === 2 && !quantiles[2] && quantiles[4]?.length === 5) {
+        return [quantiles[4][0], quantiles[4][2], quantiles[4][4]];
+      }
+      if (quantiles[scaleLength]) {
+        return quantiles[scaleLength];
+      }
     }
     let { min: min2 } = attribute;
     if (scaleType === "log" && min2 === 0) {
@@ -21825,19 +21456,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (scaleType === "ordinal") {
       return colorRange.colorMap?.map(([value]) => value) || [];
     }
-    if (scaleType === "custom") {
-      if (colorRange.uiCustomScaleType === "logarithmic") {
-        return getLog10ScaleSteps({
-          min: band2.stats.min,
-          max: band2.stats.max,
-          steps: colorRange.colors.length
-        });
-      } else {
-        return colorRange.colorMap?.map(([value]) => value) || [];
-      }
-    }
-    const scaleLength = colorRange.colors.length;
     if (scaleType === "quantile") {
+      const scaleLength = colorRange.colors.length;
       const quantiles = band2.stats.quantiles?.[scaleLength];
       if (!quantiles) {
         return [0, 1];
@@ -21863,9 +21483,21 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       return {};
     }
     const domain = domainFromRasterMetadataBand(bandInfo, scaleType, colorRange);
+    let scaleDomain = domain;
+    if (scaleType === "custom") {
+      if (colorRange.uiCustomScaleType === "logarithmic") {
+        scaleDomain = getLog10ScaleSteps({
+          min: bandInfo.stats.min,
+          max: bandInfo.stats.max,
+          steps: colorRange.colors.length
+        });
+      } else {
+        scaleDomain = colorRange.colorMap?.map(([value]) => value) || [];
+      }
+    }
     const scaleFun = createColorScale(
       scaleType,
-      domain,
+      scaleDomain,
       colorRange.colors.map(hexToRGB2),
       UNKNOWN_COLOR2
     );
@@ -21880,7 +21512,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       updateTriggers: getRasterTileLayerUpdateTriggers({
         layerConfig,
         visualChannels
-      })
+      }),
+      domain,
+      scaleDomain: scaleFun.domain(),
+      range: colorRange.colors,
+      type: scaleType,
+      field: colorField
     };
   }
   function getRasterTileLayerUpdateTriggers({
@@ -22069,18 +21706,27 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
             rasterMetadata,
             visualChannels
           }),
-          scales: {}
-          // TODO
+          scales: {
+            fillColor: {
+              type: "identity"
+            }
+          }
         };
       } else {
+        const { dataTransform, updateTriggers: updateTriggers2, ...scaleProps } = getRasterTileLayerStylePropsScaledBand({
+          layerConfig: config2,
+          visualChannels,
+          rasterMetadata
+        });
         return {
-          channelProps: getRasterTileLayerStylePropsScaledBand({
-            layerConfig: config2,
-            visualChannels,
-            rasterMetadata
-          }),
+          channelProps: {
+            dataTransform,
+            updateTriggers: updateTriggers2
+          },
           scales: {
-            // TODO
+            ...scaleProps.type && {
+              fillColor: scaleProps
+            }
           }
         };
       }
@@ -22547,7 +22193,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     apiBaseUrl,
     connection,
     headers,
-    maxLengthURL
+    maxLengthURL,
+    tags
   }) {
     return {
       accessToken,
@@ -22559,7 +22206,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         localCache: {
           cacheControl: ["no-cache"]
         }
-      }
+      },
+      tags
     };
   }
   function getDynamicTileResolution(spatialIndex) {
@@ -22594,14 +22242,19 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const cache = {};
     const configuredSource = configureSource({
       dataset,
-      filters: isRemoteCalculationSupported(dataset) ? filters : void 0,
+      filters: !isEmptyObject(filters) && isRemoteCalculationSupported(dataset) ? filters : void 0,
       options: {
         ...context,
         connection: connectionName,
         headers: context.headers,
         accessToken: context.accessToken,
         apiBaseUrl: context.apiBaseUrl,
-        maxLengthURL: context.maxLengthURL
+        maxLengthURL: context.maxLengthURL,
+        ...context.mapId && {
+          tags: {
+            [AUDIT_TAGS.mapId]: context.mapId
+          }
+        }
       }
     });
     dataset.data = await configuredSource;
@@ -22634,10 +22287,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (client2) {
       parameters.client = client2;
     }
+    if (context.mapId) {
+      parameters[AUDIT_TAGS.mapId] = context.mapId;
+    }
     if (type === "query") {
       parameters.q = source;
       if (queryParameters) {
-        parameters.queryParameters = JSON.stringify(queryParameters);
+        parameters.queryParameters = queryParameters;
       }
     }
     const stats = await requestWithParameters({
@@ -22723,6 +22379,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       maxLengthURL
     });
     const context = {
+      mapId: cartoMapId,
       accessToken: map2.token || accessToken,
       apiBaseUrl,
       clientId,
@@ -22775,7 +22432,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       const pointType = layer.props?.pointType || "";
       return pointType.includes("text");
     });
-    if (textLayers.length && window.FontFace && !document.fonts.check("12px Inter")) {
+    if (textLayers.length && typeof window !== "undefined" && typeof document !== "undefined" && window.FontFace && document.fonts && !document.fonts.check("12px Inter")) {
       const font = new FontFace(
         "Inter",
         "url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)"