@deck.gl/carto 9.0.23 → 9.0.24

package/dist/index.cjs

@@ -30,6 +30,7 @@ __export(dist_exports, {
   CARTO_LAYERS: () => CARTO_LAYERS,
   CARTO_SOURCES: () => CARTO_SOURCES,
   CartoAPIError: () => CartoAPIError,
+  ClusterTileLayer: () => ClusterTileLayer,
   H3TileLayer: () => H3TileLayer,
   HeatmapTileLayer: () => heatmap_tile_layer_default,
   QuadbinTileLayer: () => QuadbinTileLayer,
@@ -63,109 +64,175 @@ __export(dist_exports, {
 });
 module.exports = __toCommonJS(dist_exports);
 
-// dist/layers/h3-tile-layer.js
+// dist/layers/cluster-tile-layer.js
+var import_layers = require("@deck.gl/layers");
+var import_geo_layers2 = require("@deck.gl/geo-layers");
+var import_core4 = require("@loaders.gl/core");
+var import_gis = require("@loaders.gl/gis");
 var import_core5 = require("@deck.gl/core");
-var import_geo_layers3 = require("@deck.gl/geo-layers");
 
-// dist/layers/h3-tileset-2d.js
-var import_geo_layers = require("@deck.gl/geo-layers");
-var import_h3_js = require("h3-js");
-var MAX_LATITUDE = 85.051128;
-function padBoundingBox({ west, north, east, south }, resolution) {
-  const corners = [
-    [north, east],
-    [south, east],
-    [south, west],
-    [north, west]
-  ];
-  const cornerCells = corners.map((c) => (0, import_h3_js.latLngToCell)(c[0], c[1], resolution));
-  const cornerEdgeLengths = cornerCells.map((c) => Math.max(...(0, import_h3_js.originToDirectedEdges)(c).map((e) => (0, import_h3_js.edgeLength)(e, import_h3_js.UNITS.rads))) * 180 / Math.PI);
-  const bufferLat = Math.max(...cornerEdgeLengths);
-  const bufferLon = Math.min(180, bufferLat / Math.cos((north + south) / 2 * Math.PI / 180));
-  return {
-    north: Math.min(north + bufferLat, MAX_LATITUDE),
-    east: east + bufferLon,
-    south: Math.max(south - bufferLat, -MAX_LATITUDE),
-    west: west - bufferLon
-  };
-}
-function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
-  const longitudeSpan = Math.abs(east - west);
-  if (longitudeSpan > 180) {
-    const nSegments = Math.ceil(longitudeSpan / 180);
-    let h3Indices = [];
-    for (let s = 0; s < nSegments; s++) {
-      const segmentWest = west + s * 180;
-      const segmentEast = Math.min(segmentWest + 179.9999999, east);
-      h3Indices = h3Indices.concat(getHexagonsInBoundingBox({ west: segmentWest, north, east: segmentEast, south }, resolution));
+// dist/layers/cluster-utils.js
+var import_quadbin = require("quadbin");
+function aggregateTile(tile, aggregationLevels, properties = [], getPosition, getWeight) {
+  if (!tile.content)
+    return;
+  if (!tile.userData)
+    tile.userData = {};
+  if (tile.userData[aggregationLevels])
+    return;
+  const out = {};
+  for (const cell of tile.content) {
+    let id4 = cell.id;
+    const position = typeof getPosition === "function" ? getPosition(cell, {}) : getPosition;
+    for (let i = 0; i < aggregationLevels - 1; i++) {
+      id4 = (0, import_quadbin.cellToParent)(id4);
+    }
+    const parentId = Number(id4);
+    if (!(parentId in out)) {
+      out[parentId] = { id: id4, count: 0, position: [0, 0] };
+      for (const { name, aggregation } of properties) {
+        if (aggregation === "any") {
+          out[parentId][name] = cell.properties[name];
+        } else {
+          out[parentId][name] = 0;
+        }
+      }
+    }
+    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 [...new Set(h3Indices)];
   }
-  const polygon = [
-    [north, east],
-    [south, east],
-    [south, west],
-    [north, west],
-    [north, east]
-  ];
-  return (0, import_h3_js.polygonToCells)(polygon, resolution);
-}
-function tileToBoundingBox(index) {
-  const coordinates = (0, import_h3_js.cellToBoundary)(index);
-  const latitudes = coordinates.map((c) => c[0]);
-  const longitudes = coordinates.map((c) => c[1]);
-  const west = Math.min(...longitudes);
-  const south = Math.min(...latitudes);
-  const east = Math.max(...longitudes);
-  const north = Math.max(...latitudes);
-  return { west, south, east, north };
+  tile.userData[aggregationLevels] = Object.values(out);
 }
-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 extractAggregationProperties(tile) {
+  const properties = [];
+  const validAggregations = ["any", "average", "count", "min", "max", "sum"];
+  for (const name of Object.keys(tile.content[0].properties)) {
+    let aggregation = name.split("_").pop().toLowerCase();
+    if (!validAggregations.includes(aggregation)) {
+      aggregation = "any";
+    }
+    properties.push({ name, aggregation });
+  }
+  return properties;
 }
-var H3Tileset2D = class extends import_geo_layers._Tileset2D {
-  getTileIndices({ viewport, minZoom, maxZoom }) {
-    if (viewport.latitude === void 0)
-      return [];
-    const [west, south, east, north] = viewport.getBounds();
-    const { tileSize } = this.opts;
-    let z = getHexagonResolution(viewport, tileSize);
-    let indices;
-    if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
-      return [];
+function 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]);
+      }
     }
-    if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
-      z = maxZoom;
-      const center = (0, import_h3_js.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
-      indices = (0, import_h3_js.gridDisk)(center, 1);
-    } else {
-      const paddedBounds = padBoundingBox({ west, north, east, south }, z);
-      indices = getHexagonsInBoundingBox(paddedBounds, z);
+  }
+  return stats;
+}
+var EMPTY_UINT16ARRAY = new Uint16Array();
+var EMPTY_BINARY_PROPS = {
+  positions: { value: new Float32Array(), size: 2 },
+  properties: [],
+  numericProps: {},
+  featureIds: { value: EMPTY_UINT16ARRAY, size: 1 },
+  globalFeatureIds: { value: EMPTY_UINT16ARRAY, size: 1 }
+};
+function clustersToBinary(data) {
+  const positions = new Float32Array(data.length * 2);
+  const featureIds = new Uint16Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    positions.set(data[i].position, 2 * i);
+    featureIds[i] = i;
+  }
+  return {
+    shape: "binary-feature-collection",
+    points: {
+      type: "Point",
+      positions: { value: positions, size: 2 },
+      properties: data,
+      numericProps: {},
+      featureIds: { value: featureIds, size: 1 },
+      globalFeatureIds: { value: featureIds, size: 1 }
+    },
+    lines: {
+      type: "LineString",
+      pathIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+      ...EMPTY_BINARY_PROPS
+    },
+    polygons: {
+      type: "Polygon",
+      polygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+      primitivePolygonIndices: { value: EMPTY_UINT16ARRAY, size: 1 },
+      ...EMPTY_BINARY_PROPS
     }
-    return indices.map((i) => ({ i }));
+  };
+}
+
+// dist/constants.js
+var DEFAULT_TILE_SIZE = 512;
+var DEFAULT_TILE_RESOLUTION = 0.5;
+var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+// dist/layers/quadbin-tileset-2d.js
+var import_geo_layers = require("@deck.gl/geo-layers");
+var import_quadbin2 = require("quadbin");
+var QuadbinTileset2D = class extends import_geo_layers._Tileset2D {
+  getTileIndices(opts) {
+    return super.getTileIndices(opts).map(import_quadbin2.tileToCell).map((q) => ({ q, i: (0, import_quadbin2.bigIntToHex)(q) }));
   }
-  getTileId({ i }) {
-    return i;
+  getTileId({ q, i }) {
+    return i || (0, import_quadbin2.bigIntToHex)(q);
   }
-  getTileMetadata({ i }) {
-    return { bbox: tileToBoundingBox(i) };
+  getTileMetadata({ q }) {
+    return super.getTileMetadata((0, import_quadbin2.cellToTile)(q));
   }
-  getTileZoom({ i }) {
-    return (0, import_h3_js.getResolution)(i);
+  getTileZoom({ q }) {
+    return Number((0, import_quadbin2.getResolution)(q));
   }
-  getParentIndex(index) {
-    const resolution = (0, import_h3_js.getResolution)(index.i);
-    const i = (0, import_h3_js.cellToParent)(index.i, resolution - 1);
-    return { i };
+  getParentIndex({ q }) {
+    return { q: (0, import_quadbin2.cellToParent)(q) };
   }
 };
 
-// dist/layers/spatial-index-tile-layer.js
-var import_core2 = require("@loaders.gl/core");
+// dist/layers/quadbin-utils.js
+var import_web_mercator = require("@math.gl/web-mercator");
+var import_quadbin3 = require("quadbin");
+var TILE_SIZE = 512;
+function quadbinToOffset(quadbin) {
+  const { x, y, z } = (0, import_quadbin3.cellToTile)(quadbin);
+  const scale = TILE_SIZE / (1 << z);
+  return [x * scale, TILE_SIZE - 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] = (0, import_web_mercator.worldToLngLat)(topLeft);
+  const [e, s] = (0, import_web_mercator.worldToLngLat)(bottomRight);
+  return [e, n, e, s, w, s, w, n, e, n];
+}
 
 // dist/layers/schema/fast-pbf.js
 function readPackedTypedArray(TypedArray, pbf, obj) {
@@ -175,182 +242,51 @@ function readPackedTypedArray(TypedArray, pbf, obj) {
   return obj.value;
 }
 
-// dist/layers/schema/carto-raster-tile.js
-var ARRAY_TYPES = {
-  uint8: Uint8Array,
-  uint16: Uint16Array,
-  uint32: Uint32Array,
-  uint64: BigUint64Array,
-  int8: Int8Array,
-  int16: Int16Array,
-  int32: Int32Array,
-  int64: BigInt64Array,
-  float32: Float32Array,
-  float64: Float64Array
-};
-var BandReader = class {
+// dist/layers/schema/carto-tile.js
+var KeyValueObjectReader = class {
   static read(pbf, end) {
-    return pbf.readFields(BandReader._readField, { name: "", type: "", data: null }, end);
+    return pbf.readFields(KeyValueObjectReader._readField, { key: "", value: null }, end);
   }
   static _readField(tag, obj, pbf) {
     if (tag === 1)
-      obj.name = pbf.readString();
+      obj.key = pbf.readString();
     else if (tag === 2)
-      obj.type = pbf.readString();
-    else if (tag === 3) {
-      const TypedArray = ARRAY_TYPES[obj.type];
-      if (!TypedArray) {
-        throw Error(`Invalid data type: ${obj.type}`);
-      }
-      obj.data = {};
-      readPackedTypedArray(TypedArray, pbf, obj.data);
+      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 TileReader = class {
+var DoublesReader = class {
   static read(pbf, end) {
-    return pbf.readFields(TileReader._readField, { blockSize: 0, bands: [] }, end);
+    const { value, size } = pbf.readFields(DoublesReader._readField, { value: [], size: 0 }, end);
+    return { value, size };
   }
   static _readField(tag, obj, pbf) {
     if (tag === 1)
-      obj.blockSize = pbf.readVarint();
+      readPackedTypedArray(Float64Array, pbf, obj);
     else if (tag === 2)
-      obj.bands.push(BandReader.read(pbf, pbf.readVarint() + pbf.pos));
+      obj.size = pbf.readVarint(true);
   }
 };
-
-// dist/layers/schema/tile-loader-utils.js
-var import_pbf = __toESM(require("pbf"), 1);
-function parsePbf(buffer, TileReader5) {
-  const pbf = new import_pbf.default(buffer);
-  const tile = TileReader5.read(pbf);
-  return tile;
-}
-
-// dist/utils.js
-var import_core = require("@deck.gl/core");
-function assert(condition, message) {
-  import_core.log.assert(condition, message);
-}
-function createBinaryProxy(data, index) {
-  const { properties, numericProps } = data;
-  return new Proxy(properties[index] || {}, {
-    get(target, property) {
-      if (property in numericProps) {
-        return numericProps[property].value[index];
-      }
-      return target[property];
-    },
-    has(target, property) {
-      return property in numericProps || property in target;
-    }
-  });
-}
-function getWorkerUrl(id4, version) {
-  return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id4}-worker.js`;
-}
-function scaleIdentity() {
-  let unknown;
-  function scale(x) {
-    return x === null ? unknown : x;
+var IntsReader = class {
+  static read(pbf, end) {
+    const { value, size } = pbf.readFields(IntsReader._readField, { value: [], size: 0 }, end);
+    return { value: new Uint32Array(value), size };
   }
-  scale.invert = scale;
-  scale.domain = scale.range = (d) => d;
-  scale.unknown = (u) => {
-    if (u) {
-      unknown = u;
-    }
-    return unknown;
-  };
-  scale.copy = () => {
-    const scaleCopy = scaleIdentity();
-    scaleCopy.unknown(unknown);
-    return scaleCopy;
-  };
-  return scale;
-}
-var isObject = (x) => x !== null && typeof x === "object";
-var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
-
-// dist/layers/schema/carto-raster-tile-loader.js
-var VERSION = true ? "9.0.23" : "latest";
-var id = "cartoRasterTile";
-var DEFAULT_OPTIONS = {
-  cartoRasterTile: {
-    workerUrl: getWorkerUrl(id, VERSION)
-  }
-};
-var CartoRasterTileLoader = {
-  name: "CARTO Raster Tile",
-  version: VERSION,
-  id,
-  module: "carto",
-  extensions: ["pbf"],
-  mimeTypes: ["application/vnd.carto-raster-tile"],
-  category: "geometry",
-  parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
-  parseSync: parseCartoRasterTile,
-  worker: true,
-  options: DEFAULT_OPTIONS
-};
-function parseCartoRasterTile(arrayBuffer, options) {
-  if (!arrayBuffer)
-    return null;
-  const { bands, blockSize } = parsePbf(arrayBuffer, TileReader);
-  const numericProps = {};
-  for (let i = 0; i < bands.length; i++) {
-    const { name, data } = bands[i];
-    numericProps[name] = data;
-  }
-  return { blockSize, cells: { numericProps, properties: [] } };
-}
-var carto_raster_tile_loader_default = CartoRasterTileLoader;
-
-// dist/layers/schema/carto-tile.js
-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);
+  static _readField(tag, obj, pbf) {
+    if (tag === 1)
+      pbf.readPackedVarint(obj.value);
+    else if (tag === 2)
+      obj.size = pbf.readVarint(true);
   }
 };
 var FieldsReader = class {
@@ -475,9 +411,9 @@ var PolygonsReader = class {
       obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
   }
 };
-var TileReader2 = class {
+var TileReader = class {
   static read(pbf, end) {
-    return pbf.readFields(TileReader2._readField, { points: null, lines: null, polygons: null }, end);
+    return pbf.readFields(TileReader._readField, { points: null, lines: null, polygons: null }, end);
   }
   static _readField(tag, obj, pbf) {
     if (tag === 1)
@@ -489,112 +425,520 @@ var TileReader2 = class {
   }
 };
 
-// dist/layers/schema/carto-spatial-tile.js
-var IndicesReader = class {
-  static read(pbf, end) {
-    return pbf.readFields(IndicesReader._readField, { value: [] }, end);
-  }
-  static _readField(tag, obj, pbf) {
-    if (tag === 1)
-      readPackedTypedArray(BigUint64Array, pbf, obj);
-  }
+// dist/layers/schema/carto-spatial-tile.js
+var IndicesReader = class {
+  static read(pbf, end) {
+    return pbf.readFields(IndicesReader._readField, { value: [] }, end);
+  }
+  static _readField(tag, obj, pbf) {
+    if (tag === 1)
+      readPackedTypedArray(BigUint64Array, pbf, obj);
+  }
+};
+var CellsReader = class {
+  static read(pbf, end) {
+    return pbf.readFields(CellsReader._readField, { indices: null, properties: [], numericProps: {} }, end);
+  }
+  static _readField(tag, obj, pbf) {
+    if (tag === 1)
+      obj.indices = IndicesReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 2)
+      obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+    else if (tag === 3) {
+      const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+      obj.numericProps[entry.key] = entry.value;
+    }
+  }
+};
+var TileReader2 = class {
+  static read(pbf, end) {
+    return pbf.readFields(TileReader2._readField, { scheme: 0, cells: null }, end);
+  }
+  static _readField(tag, obj, pbf) {
+    if (tag === 1)
+      obj.scheme = pbf.readVarint();
+    else if (tag === 2)
+      obj.cells = CellsReader.read(pbf, pbf.readVarint() + pbf.pos);
+  }
+};
+
+// dist/layers/schema/tile-loader-utils.js
+var import_pbf = __toESM(require("pbf"), 1);
+function parsePbf(buffer, TileReader5) {
+  const pbf = new import_pbf.default(buffer);
+  const tile = TileReader5.read(pbf);
+  return tile;
+}
+
+// dist/utils.js
+var import_core = require("@deck.gl/core");
+function assert(condition, message) {
+  import_core.log.assert(condition, message);
+}
+function createBinaryProxy(data, index) {
+  const { properties, numericProps } = data;
+  return new Proxy(properties[index] || {}, {
+    get(target, property) {
+      if (property in numericProps) {
+        return numericProps[property].value[index];
+      }
+      return target[property];
+    },
+    has(target, property) {
+      return property in numericProps || property in target;
+    }
+  });
+}
+function getWorkerUrl(id4, version) {
+  return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id4}-worker.js`;
+}
+function scaleIdentity() {
+  let unknown;
+  function scale(x) {
+    return x === null ? unknown : x;
+  }
+  scale.invert = scale;
+  scale.domain = scale.range = (d) => d;
+  scale.unknown = (u) => {
+    if (u) {
+      unknown = u;
+    }
+    return unknown;
+  };
+  scale.copy = () => {
+    const scaleCopy = scaleIdentity();
+    scaleCopy.unknown(unknown);
+    return scaleCopy;
+  };
+  return scale;
+}
+var isObject = (x) => x !== null && typeof x === "object";
+var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
+
+// dist/layers/schema/spatialjson-utils.js
+var import_quadbin4 = require("quadbin");
+function binaryToSpatialjson(binary) {
+  const { cells, scheme } = binary;
+  const count = cells.indices.value.length;
+  const spatial = [];
+  for (let i = 0; i < count; i++) {
+    const id4 = scheme === "h3" ? (0, import_quadbin4.bigIntToHex)(cells.indices.value[i]) : cells.indices.value[i];
+    const properties = { ...cells.properties[i] };
+    for (const key of Object.keys(cells.numericProps)) {
+      properties[key] = cells.numericProps[key].value[i];
+    }
+    spatial.push({ id: id4, properties });
+  }
+  return spatial;
+}
+
+// dist/layers/schema/carto-spatial-tile-loader.js
+var VERSION = true ? "9.0.24" : "latest";
+var id = "cartoSpatialTile";
+var DEFAULT_OPTIONS = {
+  cartoSpatialTile: {
+    scheme: "quadbin",
+    workerUrl: getWorkerUrl(id, VERSION)
+  }
+};
+var CartoSpatialTileLoader = {
+  name: "CARTO Spatial Tile",
+  version: VERSION,
+  id,
+  module: "carto",
+  extensions: ["pbf"],
+  mimeTypes: ["application/vnd.carto-spatial-tile"],
+  category: "geometry",
+  parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
+  parseSync: parseCartoSpatialTile,
+  worker: true,
+  options: DEFAULT_OPTIONS
+};
+function parseCartoSpatialTile(arrayBuffer, options) {
+  var _a;
+  if (!arrayBuffer)
+    return null;
+  const tile = parsePbf(arrayBuffer, TileReader2);
+  const { cells } = tile;
+  const scheme = (_a = options == null ? void 0 : options.cartoSpatialTile) == null ? void 0 : _a.scheme;
+  const data = { cells, scheme };
+  return binaryToSpatialjson(data);
+}
+var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
+
+// dist/layers/utils.js
+var import_core2 = require("@deck.gl/core");
+var import_core3 = require("@deck.gl/core");
+function injectAccessToken(loadOptions, accessToken) {
+  var _a, _b, _c;
+  if (!((_b = (_a = loadOptions == null ? void 0 : loadOptions.fetch) == null ? void 0 : _a.headers) == null ? void 0 : _b.Authorization)) {
+    loadOptions.fetch = {
+      ...loadOptions.fetch,
+      headers: { ...(_c = loadOptions.fetch) == null ? void 0 : _c.headers, Authorization: `Bearer ${accessToken}` }
+    };
+  }
+}
+function mergeBoundaryData(geometry, properties) {
+  const mapping = {};
+  for (const { geoid, ...rest } of properties.properties) {
+    if (geoid in mapping) {
+      import_core2.log.warn("Duplicate geoid key in boundary mapping, using first occurance")();
+    } else {
+      mapping[geoid] = rest;
+    }
+  }
+  for (const type of ["points", "lines", "polygons"]) {
+    const geom = geometry[type];
+    if (geom.positions.value.length === 0) {
+      continue;
+    }
+    geom.properties = geom.properties.map(({ geoid }) => mapping[geoid]);
+    const { positions, globalFeatureIds } = geom;
+    let indices = null;
+    if (type === "lines")
+      indices = geom.pathIndices.value;
+    if (type === "polygons")
+      indices = geom.polygonIndices.value;
+    const length = positions.value.length / positions.size;
+    for (const key in properties.numericProps) {
+      const sourceProp = properties.numericProps[key].value;
+      const TypedArray = sourceProp.constructor;
+      const destProp = new TypedArray(length);
+      geom.numericProps[key] = { value: destProp, size: 1 };
+      if (!indices) {
+        for (let i = 0; i < length; i++) {
+          const featureId = globalFeatureIds.value[i];
+          destProp[i] = sourceProp[featureId];
+        }
+      } else {
+        for (let i = 0; i < indices.length - 1; i++) {
+          const startIndex = indices[i];
+          const endIndex = indices[i + 1];
+          const featureId = globalFeatureIds.value[startIndex];
+          destProp.fill(sourceProp[featureId], startIndex, endIndex);
+        }
+      }
+    }
+  }
+  return geometry;
+}
+var TilejsonPropType = {
+  type: "object",
+  value: null,
+  validate: (value, propType) => propType.optional && value === null || typeof value === "object" && Array.isArray(value.tiles) && value.tiles.every((url) => typeof url === "string"),
+  equal: (value1, value2) => {
+    return (0, import_core3._deepEqual)(value1, value2, 2);
+  },
+  async: true
+};
+
+// dist/layers/cluster-tile-layer.js
+(0, import_core4.registerLoaders)([carto_spatial_tile_loader_default]);
+var defaultProps = {
+  data: TilejsonPropType,
+  clusterLevel: { type: "number", value: 5, min: 1 },
+  getPosition: {
+    type: "accessor",
+    value: ({ id: id4 }) => getQuadbinPolygon(id4, 0.5).slice(2, 4)
+  },
+  getWeight: { type: "accessor", value: 1 },
+  refinementStrategy: "no-overlap",
+  tileSize: DEFAULT_TILE_SIZE
+};
+var _ClusterGeoJsonLayer = class extends import_geo_layers2.TileLayer {
+  renderLayers() {
+    var _a;
+    const visibleTiles = (_a = this.state.tileset) == null ? void 0 : _a.tiles.filter((tile) => {
+      return tile.isLoaded && tile.content && this.state.tileset.isTileVisible(tile);
+    });
+    if (!(visibleTiles == null ? void 0 : visibleTiles.length)) {
+      return null;
+    }
+    visibleTiles.sort((a, b) => b.zoom - a.zoom);
+    const { zoom } = this.context.viewport;
+    const { clusterLevel, getPosition, getWeight } = this.props;
+    const properties = extractAggregationProperties(visibleTiles[0]);
+    const data = [];
+    for (const tile of visibleTiles) {
+      const overZoom = Math.round(zoom - tile.zoom);
+      const aggregationLevels = Math.round(clusterLevel) - overZoom;
+      aggregateTile(tile, aggregationLevels, properties, getPosition, getWeight);
+      data.push(...tile.userData[aggregationLevels]);
+    }
+    data.sort((a, b) => Number(b.count - a.count));
+    const clusterIds = data == null ? void 0 : data.map((tile) => tile.id);
+    const needsUpdate = !(0, import_core5._deepEqual)(clusterIds, this.state.clusterIds, 1);
+    this.setState({ clusterIds });
+    if (needsUpdate) {
+      const stats = computeAggregationStats(data, properties);
+      for (const d of data) {
+        d.stats = stats;
+      }
+      this.setState({ data: clustersToBinary(data) });
+    }
+    const props = {
+      ...this.props,
+      id: "clusters",
+      data: this.state.data,
+      dataComparator: (data2, oldData) => {
+        var _a2, _b, _c, _d;
+        const newIds = (_b = (_a2 = data2 == null ? void 0 : data2.points) == null ? void 0 : _a2.properties) == null ? void 0 : _b.map((tile) => tile.id);
+        const oldIds = (_d = (_c = oldData == null ? void 0 : oldData.points) == null ? void 0 : _c.properties) == null ? void 0 : _d.map((tile) => tile.id);
+        return (0, import_core5._deepEqual)(newIds, oldIds, 1);
+      }
+    };
+    return new import_layers.GeoJsonLayer(this.getSubLayerProps(props));
+  }
+  getPickingInfo(params) {
+    const info = params.info;
+    if (info.index !== -1) {
+      const { data } = params.sourceLayer.props;
+      info.object = (0, import_gis.binaryToGeojson)(data, {
+        globalFeatureId: info.index
+      });
+    }
+    return info;
+  }
+  _updateAutoHighlight(info) {
+    for (const layer of this.getSubLayers()) {
+      layer.updateAutoHighlight(info);
+    }
+  }
+  filterSubLayer() {
+    return true;
+  }
+};
+var ClusterGeoJsonLayer = _ClusterGeoJsonLayer;
+(() => {
+  _ClusterGeoJsonLayer.layerName = "ClusterGeoJsonLayer";
+})();
+(() => {
+  _ClusterGeoJsonLayer.defaultProps = defaultProps;
+})();
+var _ClusterTileLayer = class extends import_core5.CompositeLayer {
+  getLoadOptions() {
+    const loadOptions = super.getLoadOptions() || {};
+    const tileJSON = this.props.data;
+    injectAccessToken(loadOptions, tileJSON.accessToken);
+    loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "quadbin" };
+    return loadOptions;
+  }
+  renderLayers() {
+    const tileJSON = this.props.data;
+    if (!tileJSON)
+      return null;
+    const { tiles: data, maxresolution: maxZoom } = tileJSON;
+    return [
+      new ClusterGeoJsonLayer(this.props, {
+        id: `cluster-geojson-layer-${this.props.id}`,
+        data,
+        TilesetClass: QuadbinTileset2D,
+        maxZoom,
+        loadOptions: this.getLoadOptions()
+      })
+    ];
+  }
+};
+var ClusterTileLayer = _ClusterTileLayer;
+(() => {
+  _ClusterTileLayer.layerName = "ClusterTileLayer";
+})();
+(() => {
+  _ClusterTileLayer.defaultProps = defaultProps;
+})();
+
+// dist/layers/h3-tile-layer.js
+var import_core7 = require("@deck.gl/core");
+var import_geo_layers5 = require("@deck.gl/geo-layers");
+
+// dist/layers/h3-tileset-2d.js
+var import_geo_layers3 = require("@deck.gl/geo-layers");
+var import_h3_js = require("h3-js");
+var MAX_LATITUDE = 85.051128;
+function padBoundingBox({ west, north, east, south }, resolution) {
+  const corners = [
+    [north, east],
+    [south, east],
+    [south, west],
+    [north, west]
+  ];
+  const cornerCells = corners.map((c) => (0, import_h3_js.latLngToCell)(c[0], c[1], resolution));
+  const cornerEdgeLengths = cornerCells.map((c) => Math.max(...(0, import_h3_js.originToDirectedEdges)(c).map((e) => (0, import_h3_js.edgeLength)(e, import_h3_js.UNITS.rads))) * 180 / Math.PI);
+  const bufferLat = Math.max(...cornerEdgeLengths);
+  const bufferLon = Math.min(180, bufferLat / Math.cos((north + south) / 2 * Math.PI / 180));
+  return {
+    north: Math.min(north + bufferLat, MAX_LATITUDE),
+    east: east + bufferLon,
+    south: Math.max(south - bufferLat, -MAX_LATITUDE),
+    west: west - bufferLon
+  };
+}
+function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
+  const longitudeSpan = Math.abs(east - west);
+  if (longitudeSpan > 180) {
+    const nSegments = Math.ceil(longitudeSpan / 180);
+    let h3Indices = [];
+    for (let s = 0; s < nSegments; s++) {
+      const segmentWest = west + s * 180;
+      const segmentEast = Math.min(segmentWest + 179.9999999, east);
+      h3Indices = h3Indices.concat(getHexagonsInBoundingBox({ west: segmentWest, north, east: segmentEast, south }, resolution));
+    }
+    return [...new Set(h3Indices)];
+  }
+  const polygon = [
+    [north, east],
+    [south, east],
+    [south, west],
+    [north, west],
+    [north, east]
+  ];
+  return (0, import_h3_js.polygonToCells)(polygon, resolution);
+}
+function tileToBoundingBox(index) {
+  const coordinates = (0, import_h3_js.cellToBoundary)(index);
+  const latitudes = coordinates.map((c) => c[0]);
+  const longitudes = coordinates.map((c) => c[1]);
+  const west = Math.min(...longitudes);
+  const south = Math.min(...latitudes);
+  const east = Math.max(...longitudes);
+  const north = Math.max(...latitudes);
+  return { west, south, east, north };
+}
+var BIAS = 2;
+function getHexagonResolution(viewport, tileSize) {
+  const zoomOffset = Math.log2(tileSize / 512);
+  const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
+  const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
+  return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
+}
+var H3Tileset2D = class extends import_geo_layers3._Tileset2D {
+  getTileIndices({ viewport, minZoom, maxZoom }) {
+    if (viewport.latitude === void 0)
+      return [];
+    const [west, south, east, north] = viewport.getBounds();
+    const { tileSize } = this.opts;
+    let z = getHexagonResolution(viewport, tileSize);
+    let indices;
+    if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
+      return [];
+    }
+    if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
+      z = maxZoom;
+      const center = (0, import_h3_js.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
+      indices = (0, import_h3_js.gridDisk)(center, 1);
+    } else {
+      const paddedBounds = padBoundingBox({ west, north, east, south }, z);
+      indices = getHexagonsInBoundingBox(paddedBounds, z);
+    }
+    return indices.map((i) => ({ i }));
+  }
+  getTileId({ i }) {
+    return i;
+  }
+  getTileMetadata({ i }) {
+    return { bbox: tileToBoundingBox(i) };
+  }
+  getTileZoom({ i }) {
+    return (0, import_h3_js.getResolution)(i);
+  }
+  getParentIndex(index) {
+    const resolution = (0, import_h3_js.getResolution)(index.i);
+    const i = (0, import_h3_js.cellToParent)(index.i, resolution - 1);
+    return { i };
+  }
+};
+
+// dist/layers/spatial-index-tile-layer.js
+var import_core6 = require("@loaders.gl/core");
+
+// dist/layers/schema/carto-raster-tile.js
+var ARRAY_TYPES = {
+  uint8: Uint8Array,
+  uint16: Uint16Array,
+  uint32: Uint32Array,
+  uint64: BigUint64Array,
+  int8: Int8Array,
+  int16: Int16Array,
+  int32: Int32Array,
+  int64: BigInt64Array,
+  float32: Float32Array,
+  float64: Float64Array
 };
-var CellsReader = class {
+var BandReader = class {
   static read(pbf, end) {
-    return pbf.readFields(CellsReader._readField, { indices: null, properties: [], numericProps: {} }, end);
+    return pbf.readFields(BandReader._readField, { name: "", type: "", data: null }, end);
   }
   static _readField(tag, obj, pbf) {
     if (tag === 1)
-      obj.indices = IndicesReader.read(pbf, pbf.readVarint() + pbf.pos);
+      obj.name = pbf.readString();
     else if (tag === 2)
-      obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+      obj.type = pbf.readString();
     else if (tag === 3) {
-      const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
-      obj.numericProps[entry.key] = entry.value;
+      const TypedArray = ARRAY_TYPES[obj.type];
+      if (!TypedArray) {
+        throw Error(`Invalid data type: ${obj.type}`);
+      }
+      obj.data = {};
+      readPackedTypedArray(TypedArray, pbf, obj.data);
     }
   }
 };
 var TileReader3 = class {
   static read(pbf, end) {
-    return pbf.readFields(TileReader3._readField, { scheme: 0, cells: null }, end);
+    return pbf.readFields(TileReader3._readField, { blockSize: 0, bands: [] }, end);
   }
   static _readField(tag, obj, pbf) {
     if (tag === 1)
-      obj.scheme = pbf.readVarint();
+      obj.blockSize = pbf.readVarint();
     else if (tag === 2)
-      obj.cells = CellsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      obj.bands.push(BandReader.read(pbf, pbf.readVarint() + pbf.pos));
   }
 };
 
-// dist/layers/schema/spatialjson-utils.js
-var import_quadbin = require("quadbin");
-function binaryToSpatialjson(binary) {
-  const { cells, scheme } = binary;
-  const count = cells.indices.value.length;
-  const spatial = [];
-  for (let i = 0; i < count; i++) {
-    const id4 = scheme === "h3" ? (0, import_quadbin.bigIntToHex)(cells.indices.value[i]) : cells.indices.value[i];
-    const properties = { ...cells.properties[i] };
-    for (const key of Object.keys(cells.numericProps)) {
-      properties[key] = cells.numericProps[key].value[i];
-    }
-    spatial.push({ id: id4, properties });
-  }
-  return spatial;
-}
-
-// dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION2 = true ? "9.0.23" : "latest";
-var id2 = "cartoSpatialTile";
+// dist/layers/schema/carto-raster-tile-loader.js
+var VERSION2 = true ? "9.0.24" : "latest";
+var id2 = "cartoRasterTile";
 var DEFAULT_OPTIONS2 = {
-  cartoSpatialTile: {
-    scheme: "quadbin",
+  cartoRasterTile: {
     workerUrl: getWorkerUrl(id2, VERSION2)
   }
 };
-var CartoSpatialTileLoader = {
-  name: "CARTO Spatial Tile",
+var CartoRasterTileLoader = {
+  name: "CARTO Raster Tile",
   version: VERSION2,
   id: id2,
   module: "carto",
   extensions: ["pbf"],
-  mimeTypes: ["application/vnd.carto-spatial-tile"],
+  mimeTypes: ["application/vnd.carto-raster-tile"],
   category: "geometry",
-  parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
-  parseSync: parseCartoSpatialTile,
+  parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
+  parseSync: parseCartoRasterTile,
   worker: true,
   options: DEFAULT_OPTIONS2
 };
-function parseCartoSpatialTile(arrayBuffer, options) {
-  var _a;
+function parseCartoRasterTile(arrayBuffer, options) {
   if (!arrayBuffer)
     return null;
-  const tile = parsePbf(arrayBuffer, TileReader3);
-  const { cells } = tile;
-  const scheme = (_a = options == null ? void 0 : options.cartoSpatialTile) == null ? void 0 : _a.scheme;
-  const data = { cells, scheme };
-  return binaryToSpatialjson(data);
+  const { bands, blockSize } = parsePbf(arrayBuffer, TileReader3);
+  const numericProps = {};
+  for (let i = 0; i < bands.length; i++) {
+    const { name, data } = bands[i];
+    numericProps[name] = data;
+  }
+  return { blockSize, cells: { numericProps, properties: [] } };
 }
-var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
-
-// dist/layers/spatial-index-tile-layer.js
-var import_geo_layers2 = require("@deck.gl/geo-layers");
-
-// dist/constants.js
-var DEFAULT_TILE_SIZE = 512;
-var DEFAULT_TILE_RESOLUTION = 0.5;
-var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+var carto_raster_tile_loader_default = CartoRasterTileLoader;
 
 // dist/layers/spatial-index-tile-layer.js
-(0, import_core2.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
+var import_geo_layers4 = require("@deck.gl/geo-layers");
+(0, import_core6.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
 function isFeatureIdDefined(value) {
   return value !== void 0 && value !== null && value !== "";
 }
-var defaultProps = {
+var defaultProps2 = {
   tileSize: DEFAULT_TILE_SIZE
 };
-var _SpatialIndexTileLayer = class extends import_geo_layers2.TileLayer {
+var _SpatialIndexTileLayer = class extends import_geo_layers4.TileLayer {
   _updateAutoHighlight(info) {
     const { hoveredFeatureId } = this.state;
     const hoveredFeature = info.object;
@@ -646,94 +990,28 @@ var SpatialIndexTileLayer = _SpatialIndexTileLayer;
   _SpatialIndexTileLayer.layerName = "SpatialIndexTileLayer";
 })();
 (() => {
-  _SpatialIndexTileLayer.defaultProps = defaultProps;
+  _SpatialIndexTileLayer.defaultProps = defaultProps2;
 })();
 
-// dist/layers/utils.js
-var import_core3 = require("@deck.gl/core");
-var import_core4 = require("@deck.gl/core");
-function injectAccessToken(loadOptions, accessToken) {
-  var _a, _b, _c;
-  if (!((_b = (_a = loadOptions == null ? void 0 : loadOptions.fetch) == null ? void 0 : _a.headers) == null ? void 0 : _b.Authorization)) {
-    loadOptions.fetch = {
-      ...loadOptions.fetch,
-      headers: { ...(_c = loadOptions.fetch) == null ? void 0 : _c.headers, Authorization: `Bearer ${accessToken}` }
-    };
-  }
-}
-function mergeBoundaryData(geometry, properties) {
-  const mapping = {};
-  for (const { geoid, ...rest } of properties.properties) {
-    if (geoid in mapping) {
-      import_core3.log.warn("Duplicate geoid key in boundary mapping, using first occurance")();
-    } else {
-      mapping[geoid] = rest;
-    }
-  }
-  for (const type of ["points", "lines", "polygons"]) {
-    const geom = geometry[type];
-    if (geom.positions.value.length === 0) {
-      continue;
-    }
-    geom.properties = geom.properties.map(({ geoid }) => mapping[geoid]);
-    const { positions, globalFeatureIds } = geom;
-    let indices = null;
-    if (type === "lines")
-      indices = geom.pathIndices.value;
-    if (type === "polygons")
-      indices = geom.polygonIndices.value;
-    const length = positions.value.length / positions.size;
-    for (const key in properties.numericProps) {
-      const sourceProp = properties.numericProps[key].value;
-      const TypedArray = sourceProp.constructor;
-      const destProp = new TypedArray(length);
-      geom.numericProps[key] = { value: destProp, size: 1 };
-      if (!indices) {
-        for (let i = 0; i < length; i++) {
-          const featureId = globalFeatureIds.value[i];
-          destProp[i] = sourceProp[featureId];
-        }
-      } else {
-        for (let i = 0; i < indices.length - 1; i++) {
-          const startIndex = indices[i];
-          const endIndex = indices[i + 1];
-          const featureId = globalFeatureIds.value[startIndex];
-          destProp.fill(sourceProp[featureId], startIndex, endIndex);
-        }
-      }
-    }
-  }
-  return geometry;
-}
-var TilejsonPropType = {
-  type: "object",
-  value: null,
-  validate: (value, propType) => propType.optional && value === null || typeof value === "object" && Array.isArray(value.tiles) && value.tiles.every((url) => typeof url === "string"),
-  equal: (value1, value2) => {
-    return (0, import_core4._deepEqual)(value1, value2, 2);
-  },
-  async: true
-};
-
 // dist/layers/h3-tile-layer.js
 var renderSubLayers = (props) => {
   const { data } = props;
   const { index } = props.tile;
   if (!data || !data.length)
     return null;
-  return new import_geo_layers3.H3HexagonLayer(props, {
+  return new import_geo_layers5.H3HexagonLayer(props, {
     getHexagon: (d) => d.id,
     centerHexagon: index,
     highPrecision: true
   });
 };
-var defaultProps2 = {
+var defaultProps3 = {
   data: TilejsonPropType,
   tileSize: DEFAULT_TILE_SIZE
 };
-var _H3TileLayer = class extends import_core5.CompositeLayer {
+var _H3TileLayer = class extends import_core7.CompositeLayer {
   initializeState() {
-    import_geo_layers3.H3HexagonLayer._checkH3Lib();
+    import_geo_layers5.H3HexagonLayer._checkH3Lib();
   }
   getLoadOptions() {
     const loadOptions = super.getLoadOptions() || {};
@@ -772,13 +1050,13 @@ var H3TileLayer = _H3TileLayer;
   _H3TileLayer.layerName = "H3TileLayer";
 })();
 (() => {
-  _H3TileLayer.defaultProps = defaultProps2;
+  _H3TileLayer.defaultProps = defaultProps3;
 })();
 
 // dist/layers/heatmap-tile-layer.js
-var import_quadbin5 = require("quadbin");
-var import_core8 = require("@deck.gl/core");
-var import_layers = require("@deck.gl/layers");
+var import_quadbin6 = require("quadbin");
+var import_core10 = require("@deck.gl/core");
+var import_layers2 = require("@deck.gl/layers");
 
 // dist/layers/heatmap.js
 var fs = `uniform heatmapUniforms {
@@ -917,7 +1195,7 @@ var heatmap = {
 };
 
 // dist/layers/post-process-utils.js
-var import_core6 = require("@deck.gl/core");
+var import_core8 = require("@deck.gl/core");
 var TEXTURE_PROPS = {
   format: "rgba8unorm",
   mipmaps: false,
@@ -934,7 +1212,7 @@ function getPostProcessLayer(layer) {
   }
   return layer;
 }
-var _DrawCallbackLayer = class extends import_core6.Layer {
+var _DrawCallbackLayer = class extends import_core8.Layer {
   initializeState() {
     this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;
   }
@@ -971,7 +1249,7 @@ function PostProcessModifier(BaseLayer, effect) {
     initializeState(context) {
       super.initializeState(context);
       this._createTextures();
-      this.internalState.postProcess = new import_core6.PostProcessEffect(effect, this.props);
+      this.internalState.postProcess = new import_core8.PostProcessEffect(effect, this.props);
       this.internalState.postProcess.setup(context);
     }
     updateState(params) {
@@ -1038,39 +1316,14 @@ function PostProcessModifier(BaseLayer, effect) {
 }
 
 // dist/layers/quadbin-tile-layer.js
-var import_core7 = require("@deck.gl/core");
-
-// dist/layers/quadbin-layer.js
-var import_geo_layers4 = require("@deck.gl/geo-layers");
-
-// dist/layers/quadbin-utils.js
-var import_web_mercator = require("@math.gl/web-mercator");
-var import_quadbin2 = require("quadbin");
-var TILE_SIZE = 512;
-function quadbinToOffset(quadbin) {
-  const { x, y, z } = (0, import_quadbin2.cellToTile)(quadbin);
-  const scale = TILE_SIZE / (1 << z);
-  return [x * scale, TILE_SIZE - 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] = (0, import_web_mercator.worldToLngLat)(topLeft);
-  const [e, s] = (0, import_web_mercator.worldToLngLat)(bottomRight);
-  return [e, n, e, s, w, s, w, n, e, n];
-}
+var import_core9 = require("@deck.gl/core");
 
 // dist/layers/quadbin-layer.js
-var defaultProps3 = {
+var import_geo_layers6 = require("@deck.gl/geo-layers");
+var defaultProps4 = {
   getQuadbin: { type: "accessor", value: (d) => d.quadbin }
 };
-var _QuadbinLayer = class extends import_geo_layers4._GeoCellLayer {
+var _QuadbinLayer = class extends import_geo_layers6._GeoCellLayer {
   indexToBounds() {
     const { data, extruded, getQuadbin } = this.props;
     const coverage = extruded ? 0.99 : 1;
@@ -1088,46 +1341,25 @@ var QuadbinLayer = _QuadbinLayer;
   _QuadbinLayer.layerName = "QuadbinLayer";
 })();
 (() => {
-  _QuadbinLayer.defaultProps = defaultProps3;
+  _QuadbinLayer.defaultProps = defaultProps4;
 })();
 
-// dist/layers/quadbin-tileset-2d.js
-var import_geo_layers5 = require("@deck.gl/geo-layers");
-var import_quadbin3 = require("quadbin");
-var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
-  getTileIndices(opts) {
-    return super.getTileIndices(opts).map(import_quadbin3.tileToCell).map((q) => ({ q, i: (0, import_quadbin3.bigIntToHex)(q) }));
-  }
-  getTileId({ q, i }) {
-    return i || (0, import_quadbin3.bigIntToHex)(q);
-  }
-  getTileMetadata({ q }) {
-    return super.getTileMetadata((0, import_quadbin3.cellToTile)(q));
-  }
-  getTileZoom({ q }) {
-    return Number((0, import_quadbin3.getResolution)(q));
-  }
-  getParentIndex({ q }) {
-    return { q: (0, import_quadbin3.cellToParent)(q) };
-  }
-};
-
 // dist/layers/quadbin-tile-layer.js
-var import_quadbin4 = require("quadbin");
+var import_quadbin5 = require("quadbin");
 var renderSubLayers2 = (props) => {
   const { data } = props;
   if (!data || !data.length)
     return null;
   const isBigInt = typeof data[0].id === "bigint";
   return new QuadbinLayer(props, {
-    getQuadbin: isBigInt ? (d) => d.id : (d) => (0, import_quadbin4.hexToBigInt)(d.id)
+    getQuadbin: isBigInt ? (d) => d.id : (d) => (0, import_quadbin5.hexToBigInt)(d.id)
   });
 };
-var defaultProps4 = {
+var defaultProps5 = {
   data: TilejsonPropType,
   tileSize: DEFAULT_TILE_SIZE
 };
-var _QuadbinTileLayer = class extends import_core7.CompositeLayer {
+var _QuadbinTileLayer = class extends import_core9.CompositeLayer {
   getLoadOptions() {
     const loadOptions = super.getLoadOptions() || {};
     const tileJSON = this.props.data;
@@ -1157,15 +1389,15 @@ var QuadbinTileLayer = _QuadbinTileLayer;
   _QuadbinTileLayer.layerName = "QuadbinTileLayer";
 })();
 (() => {
-  _QuadbinTileLayer.defaultProps = defaultProps4;
+  _QuadbinTileLayer.defaultProps = defaultProps5;
 })();
 
 // dist/layers/heatmap-tile-layer.js
 function unitDensityForCell(cell) {
-  const cellResolution = Number((0, import_quadbin5.getResolution)(cell));
+  const cellResolution = Number((0, import_quadbin6.getResolution)(cell));
   return Math.pow(4, cellResolution);
 }
-var _RTTSolidPolygonLayer = class extends RTTModifier(import_layers.SolidPolygonLayer) {
+var _RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
   getShaders(type) {
     const shaders = super.getShaders(type);
     shaders.inject = {
@@ -1208,7 +1440,7 @@ var RTTSolidPolygonLayer = _RTTSolidPolygonLayer;
   _RTTSolidPolygonLayer.layerName = "RTTSolidPolygonLayer";
 })();
 var PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
-var defaultProps5 = {
+var defaultProps6 = {
   data: TilejsonPropType,
   getWeight: { type: "accessor", value: 1 },
   onMaxDensityChange: { type: "function", optional: true, value: null },
@@ -1216,7 +1448,7 @@ var defaultProps5 = {
   intensity: { type: "number", value: 1 },
   radiusPixels: { type: "number", min: 0, max: 100, value: 20 }
 };
-var _HeatmapTileLayer = class extends import_core8.CompositeLayer {
+var _HeatmapTileLayer = class extends import_core10.CompositeLayer {
   initializeState() {
     this.state = {
       isLoaded: false,
@@ -1313,15 +1545,15 @@ var HeatmapTileLayer = _HeatmapTileLayer;
   _HeatmapTileLayer.layerName = "HeatmapTileLayer";
 })();
 (() => {
-  _HeatmapTileLayer.defaultProps = defaultProps5;
+  _HeatmapTileLayer.defaultProps = defaultProps6;
 })();
 var heatmap_tile_layer_default = HeatmapTileLayer;
 
 // dist/layers/point-label-layer.js
-var import_core9 = require("@deck.gl/core");
-var import_layers2 = require("@deck.gl/layers");
+var import_core11 = require("@deck.gl/core");
+var import_layers3 = require("@deck.gl/layers");
 var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
-var _EnhancedTextBackgroundLayer = class extends import_layers2._TextBackgroundLayer {
+var _EnhancedTextBackgroundLayer = class extends import_layers3._TextBackgroundLayer {
   getShaders() {
     const shaders = super.getShaders();
     let vs = shaders.vs;
@@ -1334,7 +1566,7 @@ var EnhancedTextBackgroundLayer = _EnhancedTextBackgroundLayer;
 (() => {
   _EnhancedTextBackgroundLayer.layerName = "EnhancedTextBackgroundLayer";
 })();
-var _EnhancedTextLayer = class extends import_layers2.TextLayer {
+var _EnhancedTextLayer = class extends import_layers3.TextLayer {
   filterSubLayer({ layer, renderPass }) {
     const background = layer.id.includes("primary-background");
     if (renderPass === "collision") {
@@ -1347,12 +1579,12 @@ var EnhancedTextLayer = _EnhancedTextLayer;
 (() => {
   _EnhancedTextLayer.layerName = "EnhancedTextLayer";
 })();
-var defaultProps6 = {
-  ...import_layers2.TextLayer.defaultProps,
+var defaultProps7 = {
+  ...import_layers3.TextLayer.defaultProps,
   getRadius: { type: "accessor", value: 1 },
   radiusScale: { type: "number", min: 0, value: 1 }
 };
-var _PointLabelLayer = class extends import_core9.CompositeLayer {
+var _PointLabelLayer = class extends import_core11.CompositeLayer {
   calculatePixelOffset(secondary) {
     const { getTextAnchor: anchor, getAlignmentBaseline: alignment, getRadius, getSecondaryText, radiusScale, secondarySizeScale, sizeScale } = this.props;
     const xMult = anchor === "middle" ? 0 : anchor === "start" ? 1 : -1;
@@ -1458,15 +1690,15 @@ var PointLabelLayer = _PointLabelLayer;
   _PointLabelLayer.layerName = "PointLabelLayer";
 })();
 (() => {
-  _PointLabelLayer.defaultProps = defaultProps6;
+  _PointLabelLayer.defaultProps = defaultProps7;
 })();
 
 // dist/layers/raster-tile-layer.js
-var import_core11 = require("@deck.gl/core");
+var import_core13 = require("@deck.gl/core");
 
 // dist/layers/raster-layer.js
-var import_core10 = require("@deck.gl/core");
-var import_layers3 = require("@deck.gl/layers");
+var import_core12 = require("@deck.gl/core");
+var import_layers4 = require("@deck.gl/layers");
 
 // dist/layers/raster-layer-vertex.glsl.js
 var raster_layer_vertex_glsl_default = `#version 300 es
@@ -1538,8 +1770,8 @@ DECKGL_FILTER_COLOR(vColor, geometry);
 `;
 
 // dist/layers/raster-layer.js
-var defaultProps7 = {
-  ...import_layers3.ColumnLayer.defaultProps,
+var defaultProps8 = {
+  ...import_layers4.ColumnLayer.defaultProps,
   extruded: false,
   diskResolution: 4,
   vertices: [
@@ -1549,7 +1781,7 @@ var defaultProps7 = {
     [-0.5, 0.5]
   ]
 };
-var _RasterColumnLayer = class extends import_layers3.ColumnLayer {
+var _RasterColumnLayer = class extends import_layers4.ColumnLayer {
   getShaders() {
     const shaders = super.getShaders();
     const data = this.props.data;
@@ -1585,7 +1817,7 @@ var RasterColumnLayer = _RasterColumnLayer;
 (() => {
   _RasterColumnLayer.layerName = "RasterColumnLayer";
 })();
-var _RasterLayer = class extends import_core10.CompositeLayer {
+var _RasterLayer = class extends import_core12.CompositeLayer {
   renderLayers() {
     const { data, getElevation, getFillColor, getLineColor, getLineWidth, tileIndex, updateTriggers } = this.props;
     if (!data || !tileIndex)
@@ -1626,7 +1858,7 @@ var RasterLayer = _RasterLayer;
   _RasterLayer.layerName = "RasterLayer";
 })();
 (() => {
-  _RasterLayer.defaultProps = defaultProps7;
+  _RasterLayer.defaultProps = defaultProps8;
 })();
 
 // dist/layers/raster-tile-layer.js
@@ -1637,11 +1869,11 @@ var renderSubLayers3 = (props) => {
     return null;
   return new RasterLayer(props, { tileIndex });
 };
-var defaultProps8 = {
+var defaultProps9 = {
   data: TilejsonPropType,
   tileSize: DEFAULT_TILE_SIZE
 };
-var _RasterTileLayer = class extends import_core11.CompositeLayer {
+var _RasterTileLayer = class extends import_core13.CompositeLayer {
   getLoadOptions() {
     const loadOptions = super.getLoadOptions() || {};
     const tileJSON = this.props.data;
@@ -1671,11 +1903,11 @@ var RasterTileLayer = _RasterTileLayer;
   _RasterTileLayer.layerName = "RasterTileLayer";
 })();
 (() => {
-  _RasterTileLayer.defaultProps = defaultProps8;
+  _RasterTileLayer.defaultProps = defaultProps9;
 })();
 
 // dist/layers/vector-tile-layer.js
-var import_core12 = require("@loaders.gl/core");
+var import_core14 = require("@loaders.gl/core");
 
 // dist/layers/schema/carto-properties-tile.js
 var TileReader4 = class {
@@ -1715,7 +1947,7 @@ var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
 // dist/layers/schema/carto-vector-tile-loader.js
 var import_earcut = __toESM(require("earcut"), 1);
-var VERSION3 = true ? "9.0.23" : "latest";
+var VERSION3 = true ? "9.0.24" : "latest";
 var id3 = "cartoVectorTile";
 var DEFAULT_OPTIONS3 = {
   cartoVectorTile: {
@@ -1763,7 +1995,7 @@ function triangulate(polygons) {
 function parseCartoVectorTile(arrayBuffer, options) {
   if (!arrayBuffer)
     return null;
-  const tile = parsePbf(arrayBuffer, TileReader2);
+  const tile = parsePbf(arrayBuffer, TileReader);
   if (tile.polygons && !tile.polygons.triangles) {
     triangulate(tile.polygons);
   }
@@ -1773,16 +2005,16 @@ var carto_vector_tile_loader_default = CartoVectorTileLoader;
 
 // dist/layers/vector-tile-layer.js
 var import_extensions = require("@deck.gl/extensions");
-var import_geo_layers6 = require("@deck.gl/geo-layers");
-var import_layers4 = require("@deck.gl/layers");
-(0, import_core12.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
-var defaultProps9 = {
-  ...import_geo_layers6.MVTLayer.defaultProps,
+var import_geo_layers7 = require("@deck.gl/geo-layers");
+var import_layers5 = require("@deck.gl/layers");
+(0, import_core14.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
+var defaultProps10 = {
+  ...import_geo_layers7.MVTLayer.defaultProps,
   data: TilejsonPropType,
   dataComparator: TilejsonPropType.equal,
   tileSize: DEFAULT_TILE_SIZE
 };
-var _VectorTileLayer = class extends import_geo_layers6.MVTLayer {
+var _VectorTileLayer = class extends import_geo_layers7.MVTLayer {
   constructor(...propObjects) {
     super(...propObjects);
   }
@@ -1809,7 +2041,7 @@ var _VectorTileLayer = class extends import_geo_layers6.MVTLayer {
   async getTileData(tile) {
     const tileJSON = this.props.data;
     const { tiles, properties_tiles } = tileJSON;
-    const url = (0, import_geo_layers6._getURLFromTemplate)(tiles, tile);
+    const url = (0, import_geo_layers7._getURLFromTemplate)(tiles, tile);
     if (!url) {
       return Promise.reject("Invalid URL");
     }
@@ -1820,7 +2052,7 @@ var _VectorTileLayer = class extends import_geo_layers6.MVTLayer {
     if (!properties_tiles) {
       return await geometryFetch;
     }
-    const propertiesUrl = (0, import_geo_layers6._getURLFromTemplate)(properties_tiles, tile);
+    const propertiesUrl = (0, import_geo_layers7._getURLFromTemplate)(properties_tiles, tile);
     if (!propertiesUrl) {
       return Promise.reject("Invalid properties URL");
     }
@@ -1850,7 +2082,7 @@ var _VectorTileLayer = class extends import_geo_layers6.MVTLayer {
       extensions: [new import_extensions.ClipExtension(), ...props.extensions || []],
       clipBounds: [west, south, east, north]
     };
-    const subLayer = new import_layers4.GeoJsonLayer(subLayerProps);
+    const subLayer = new import_layers5.GeoJsonLayer(subLayerProps);
     return subLayer;
   }
   _isWGS84() {
@@ -1864,7 +2096,7 @@ var VectorTileLayer = _VectorTileLayer;
   _VectorTileLayer.layerName = "VectorTileLayer";
 })();
 (() => {
-  _VectorTileLayer.defaultProps = defaultProps9;
+  _VectorTileLayer.defaultProps = defaultProps10;
 })();
 
 // dist/api/carto-api-error.js
@@ -2142,10 +2374,10 @@ function buildQueryUrl({ apiBaseUrl, connectionName }) {
 }
 
 // dist/api/request-with-parameters.js
-var import_core13 = require("@deck.gl/core");
+var import_core15 = require("@deck.gl/core");
 var DEFAULT_PARAMETERS = {
   v: V3_MINOR_VERSION,
-  deckglVersion: import_core13.VERSION
+  deckglVersion: import_core15.VERSION
 };
 var DEFAULT_HEADERS = {
   Accept: "application/json",
@@ -2432,7 +2664,7 @@ var vectorTilesetSource = async function(options) {
 };
 
 // dist/api/parse-map.js
-var import_core14 = require("@deck.gl/core");
+var import_core16 = require("@deck.gl/core");
 
 // dist/api/layer-map.js
 var import_d3_array = require("d3-array");
@@ -2441,8 +2673,8 @@ var import_d3_scale3 = require("d3-scale");
 var import_d3_format = require("d3-format");
 var import_moment_timezone = __toESM(require("moment-timezone"), 1);
 var import_aggregation_layers = require("@deck.gl/aggregation-layers");
-var import_layers5 = require("@deck.gl/layers");
-var import_geo_layers7 = require("@deck.gl/geo-layers");
+var import_layers6 = require("@deck.gl/layers");
+var import_geo_layers8 = require("@deck.gl/geo-layers");
 var SCALE_FUNCS = {
   linear: import_d3_scale3.scaleLinear,
   ordinal: import_d3_scale3.scaleOrdinal,
@@ -2476,6 +2708,15 @@ var AGGREGATION_FUNC = {
   stddev: import_d3_array.deviation,
   variance: import_d3_array.variance
 };
+var TILE_LAYER_TYPE_TO_LAYER = {
+  clusterTile: ClusterTileLayer,
+  h3: H3TileLayer,
+  heatmapTile: heatmap_tile_layer_default,
+  mvt: VectorTileLayer,
+  quadbin: QuadbinTileLayer,
+  raster: RasterTileLayer,
+  tileset: VectorTileLayer
+};
 var hexToRGBA = (c) => {
   const { r, g, b, opacity } = (0, import_d3_color.rgb)(c);
   return [r, g, b, 255 * opacity];
@@ -2514,7 +2755,7 @@ var aggregationVisConfig = {
   elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
   percentile: ["lowerPercentile", "upperPercentile"]
 };
-var defaultProps10 = {
+var defaultProps11 = {
   lineMiterLimit: 2,
   lineWidthUnits: "pixels",
   pointRadiusUnits: "pixels",
@@ -2530,15 +2771,15 @@ function getLayer(type, config, dataset) {
   if ((_a = config.visConfig) == null ? void 0 : _a.customMarkers) {
     basePropMap = mergePropMaps(sharedPropMap, customMarkersPropsMap);
   }
-  if (type === "mvt" || type === "tileset" || type === "h3" || type === "quadbin") {
-    return getTileLayer(dataset, basePropMap);
+  if (TILE_LAYER_TYPE_TO_LAYER[type]) {
+    return getTileLayer(dataset, basePropMap, type);
   }
   const geoColumn = dataset == null ? void 0 : dataset.geoColumn;
   const getPosition = (d) => d[geoColumn].coordinates;
   const hexagonId = (_b = config.columns) == null ? void 0 : _b.hex_id;
   const layerTypeDefs = {
     point: {
-      Layer: import_layers5.GeoJsonLayer,
+      Layer: import_layers6.GeoJsonLayer,
       propMap: {
         columns: {
           altitude: (x) => ({ parameters: { depthTest: Boolean(x) } })
@@ -2547,7 +2788,7 @@ function getLayer(type, config, dataset) {
       }
     },
     geojson: {
-      Layer: import_layers5.GeoJsonLayer
+      Layer: import_layers6.GeoJsonLayer
     },
     grid: {
       Layer: import_aggregation_layers.CPUGridLayer,
@@ -2565,7 +2806,7 @@ function getLayer(type, config, dataset) {
       defaultProps: { getPosition }
     },
     hexagonId: {
-      Layer: import_geo_layers7.H3HexagonLayer,
+      Layer: import_geo_layers8.H3HexagonLayer,
       propMap: { visConfig: { coverage: "coverage" } },
       defaultProps: { getHexagon: (d) => d[hexagonId], stroked: false }
     }
@@ -2575,28 +2816,16 @@ function getLayer(type, config, dataset) {
   return {
     ...layer,
     propMap: mergePropMaps(basePropMap, layer.propMap),
-    defaultProps: { ...defaultProps10, ...layer.defaultProps }
+    defaultProps: { ...defaultProps11, ...layer.defaultProps }
   };
 }
-function layerFromTileDataset(scheme, type) {
-  if (type === "raster") {
-    return RasterTileLayer;
-  }
-  if (scheme === "h3") {
-    return H3TileLayer;
-  }
-  if (scheme === "quadbin") {
-    return QuadbinTileLayer;
-  }
-  return VectorTileLayer;
-}
-function getTileLayer(dataset, basePropMap) {
-  const { aggregationExp, aggregationResLevel, data: { scheme } } = dataset;
+function getTileLayer(dataset, basePropMap, type) {
+  const { aggregationExp, aggregationResLevel } = dataset;
   return {
-    Layer: layerFromTileDataset(scheme),
+    Layer: TILE_LAYER_TYPE_TO_LAYER[type] || VectorTileLayer,
     propMap: basePropMap,
     defaultProps: {
-      ...defaultProps10,
+      ...defaultProps11,
       ...aggregationExp && { aggregationExp },
       ...aggregationResLevel && { aggregationResLevel },
       uniqueIdProperty: "geoid"
@@ -2810,12 +3039,12 @@ function parseMap(json) {
         assert(dataset, `No dataset matching dataId: ${dataId}`);
         const { data } = dataset;
         assert(data, `No data loaded for dataId: ${dataId}`);
-        const { Layer: Layer2, propMap, defaultProps: defaultProps11 } = getLayer(type, config, dataset);
+        const { Layer: Layer2, propMap, defaultProps: defaultProps12 } = getLayer(type, config, dataset);
         const styleProps = createStyleProps(config, propMap);
         return new Layer2({
           id: id4,
           data,
-          ...defaultProps11,
+          ...defaultProps12,
           ...createInteractionProps(interactionConfig),
           ...styleProps,
           ...createChannelProps(id4, type, config, visualChannels, data),
@@ -2823,7 +3052,7 @@ function parseMap(json) {
           ...createLoadOptions(token)
         });
       } catch (e) {
-        import_core14.log.error(e.message)();
+        import_core16.log.error(e.message)();
         return void 0;
       }
     })
@@ -3300,6 +3529,7 @@ var query = async function(options) {
 
 // dist/index.js
 var CARTO_LAYERS = {
+  ClusterTileLayer,
   H3TileLayer,
   HeatmapTileLayer: heatmap_tile_layer_default,
   _PointLabelLayer: PointLabelLayer,