@deck.gl/carto 8.9.6 → 8.9.8

package/dist/dist.dev.js

@@ -6105,6 +6105,332 @@ var __exports__ = (() => {
     }
   });
 
+  // ../../node_modules/tilebelt/index.js
+  var require_tilebelt = __commonJS({
+    "../../node_modules/tilebelt/index.js"(exports, module) {
+      var d2r = Math.PI / 180;
+      var r2d = 180 / Math.PI;
+      function tileToBBOX(tile) {
+        var e = tile2lon(tile[0] + 1, tile[2]);
+        var w = tile2lon(tile[0], tile[2]);
+        var s = tile2lat(tile[1] + 1, tile[2]);
+        var n = tile2lat(tile[1], tile[2]);
+        return [w, s, e, n];
+      }
+      function tileToGeoJSON(tile) {
+        var bbox = tileToBBOX(tile);
+        var poly = {
+          type: "Polygon",
+          coordinates: [
+            [
+              [bbox[0], bbox[1]],
+              [bbox[0], bbox[3]],
+              [bbox[2], bbox[3]],
+              [bbox[2], bbox[1]],
+              [bbox[0], bbox[1]]
+            ]
+          ]
+        };
+        return poly;
+      }
+      function tile2lon(x, z) {
+        return x / Math.pow(2, z) * 360 - 180;
+      }
+      function tile2lat(y, z) {
+        var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+        return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+      }
+      function pointToTile(lon, lat, z) {
+        var tile = pointToTileFraction(lon, lat, z);
+        tile[0] = Math.floor(tile[0]);
+        tile[1] = Math.floor(tile[1]);
+        return tile;
+      }
+      function getChildren(tile) {
+        return [
+          [tile[0] * 2, tile[1] * 2, tile[2] + 1],
+          [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1],
+          [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1],
+          [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1]
+        ];
+      }
+      function getParent(tile) {
+        if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+          return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
+        } else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
+          return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
+        } else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+          return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
+        } else {
+          return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
+        }
+      }
+      function getSiblings(tile) {
+        return getChildren(getParent(tile));
+      }
+      function hasSiblings(tile, tiles2) {
+        var siblings = getSiblings(tile);
+        for (var i = 0; i < siblings.length; i++) {
+          if (!hasTile(tiles2, siblings[i]))
+            return false;
+        }
+        return true;
+      }
+      function hasTile(tiles2, tile) {
+        for (var i = 0; i < tiles2.length; i++) {
+          if (tilesEqual(tiles2[i], tile))
+            return true;
+        }
+        return false;
+      }
+      function tilesEqual(tile1, tile2) {
+        return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
+      }
+      function tileToQuadkey(tile) {
+        var index = "";
+        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;
+          index += b.toString();
+        }
+        return index;
+      }
+      function quadkeyToTile(quadkey) {
+        var x = 0;
+        var y = 0;
+        var z = quadkey.length;
+        for (var i = z; i > 0; i--) {
+          var mask = 1 << i - 1;
+          switch (quadkey[z - i]) {
+            case "0":
+              break;
+            case "1":
+              x |= mask;
+              break;
+            case "2":
+              y |= mask;
+              break;
+            case "3":
+              x |= mask;
+              y |= mask;
+              break;
+          }
+        }
+        return [x, y, z];
+      }
+      function bboxToTile(bboxCoords) {
+        var min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
+        var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
+        var bbox = [min2[0], min2[1], max2[0], max2[1]];
+        var z = getBboxZoom(bbox);
+        if (z === 0)
+          return [0, 0, 0];
+        var x = bbox[0] >>> 32 - z;
+        var y = bbox[1] >>> 32 - z;
+        return [x, y, z];
+      }
+      function getBboxZoom(bbox) {
+        var MAX_ZOOM = 28;
+        for (var z = 0; z < MAX_ZOOM; z++) {
+          var mask = 1 << 32 - (z + 1);
+          if ((bbox[0] & mask) != (bbox[2] & mask) || (bbox[1] & mask) != (bbox[3] & mask)) {
+            return z;
+          }
+        }
+        return MAX_ZOOM;
+      }
+      function pointToTileFraction(lon, lat, z) {
+        var sin = Math.sin(lat * d2r), z2 = Math.pow(2, z), x = z2 * (lon / 360 + 0.5), y = z2 * (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);
+        return [x, y, z];
+      }
+      module.exports = {
+        tileToGeoJSON,
+        tileToBBOX,
+        getChildren,
+        getParent,
+        getSiblings,
+        hasTile,
+        hasSiblings,
+        tilesEqual,
+        tileToQuadkey,
+        quadkeyToTile,
+        pointToTile,
+        bboxToTile,
+        pointToTileFraction
+      };
+    }
+  });
+
+  // ../../node_modules/@mapbox/tile-cover/index.js
+  var require_tile_cover = __commonJS({
+    "../../node_modules/@mapbox/tile-cover/index.js"(exports) {
+      var tilebelt = require_tilebelt();
+      exports.geojson = function(geom, limits) {
+        return {
+          type: "FeatureCollection",
+          features: getTiles(geom, limits).map(tileToFeature)
+        };
+      };
+      function tileToFeature(t) {
+        return {
+          type: "Feature",
+          geometry: tilebelt.tileToGeoJSON(t),
+          properties: {}
+        };
+      }
+      exports.tiles = getTiles;
+      exports.indexes = function(geom, limits) {
+        return getTiles(geom, limits).map(tilebelt.tileToQuadkey);
+      };
+      function getTiles(geom, limits) {
+        var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles2 = [];
+        if (geom.type === "Point") {
+          return [tilebelt.pointToTile(coords[0], coords[1], maxZoom)];
+        } else if (geom.type === "MultiPoint") {
+          for (i = 0; i < coords.length; i++) {
+            tile = tilebelt.pointToTile(coords[i][0], coords[i][1], maxZoom);
+            tileHash[toID(tile[0], tile[1], tile[2])] = true;
+          }
+        } else if (geom.type === "LineString") {
+          lineCover(tileHash, coords, maxZoom);
+        } else if (geom.type === "MultiLineString") {
+          for (i = 0; i < coords.length; i++) {
+            lineCover(tileHash, coords[i], maxZoom);
+          }
+        } else if (geom.type === "Polygon") {
+          polygonCover(tileHash, tiles2, coords, maxZoom);
+        } else if (geom.type === "MultiPolygon") {
+          for (i = 0; i < coords.length; i++) {
+            polygonCover(tileHash, tiles2, coords[i], maxZoom);
+          }
+        } else {
+          throw new Error("Geometry type not implemented");
+        }
+        if (limits.min_zoom !== maxZoom) {
+          var len = tiles2.length;
+          appendHashTiles(tileHash, tiles2);
+          for (i = 0; i < len; i++) {
+            var t = tiles2[i];
+            tileHash[toID(t[0], t[1], t[2])] = true;
+          }
+          return mergeTiles(tileHash, tiles2, limits);
+        }
+        appendHashTiles(tileHash, tiles2);
+        return tiles2;
+      }
+      function mergeTiles(tileHash, tiles2, limits) {
+        var mergedTiles = [];
+        for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
+          var parentTileHash = {};
+          var parentTiles = [];
+          for (var i = 0; i < tiles2.length; i++) {
+            var t = tiles2[i];
+            if (t[0] % 2 === 0 && t[1] % 2 === 0) {
+              var id2 = toID(t[0] + 1, t[1], z), id3 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
+              if (tileHash[id2] && tileHash[id3] && tileHash[id4]) {
+                tileHash[toID(t[0], t[1], t[2])] = false;
+                tileHash[id2] = false;
+                tileHash[id3] = false;
+                tileHash[id4] = false;
+                var parentTile = [t[0] / 2, t[1] / 2, z - 1];
+                if (z - 1 === limits.min_zoom)
+                  mergedTiles.push(parentTile);
+                else {
+                  parentTileHash[toID(t[0] / 2, t[1] / 2, z - 1)] = true;
+                  parentTiles.push(parentTile);
+                }
+              }
+            }
+          }
+          for (i = 0; i < tiles2.length; i++) {
+            t = tiles2[i];
+            if (tileHash[toID(t[0], t[1], t[2])])
+              mergedTiles.push(t);
+          }
+          tileHash = parentTileHash;
+          tiles2 = parentTiles;
+        }
+        return mergedTiles;
+      }
+      function polygonCover(tileHash, tileArray, geom, zoom) {
+        var intersections = [];
+        for (var i = 0; i < geom.length; i++) {
+          var ring = [];
+          lineCover(tileHash, geom[i], zoom, ring);
+          for (var j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
+            var m = (j + 1) % len;
+            var y = ring[j][1];
+            if ((y > ring[k][1] || y > ring[m][1]) && (y < ring[k][1] || y < ring[m][1]) && y !== ring[m][1])
+              intersections.push(ring[j]);
+          }
+        }
+        intersections.sort(compareTiles);
+        for (i = 0; i < intersections.length; i += 2) {
+          y = intersections[i][1];
+          for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
+            var id = toID(x, y, zoom);
+            if (!tileHash[id]) {
+              tileArray.push([x, y, zoom]);
+            }
+          }
+        }
+      }
+      function compareTiles(a, b) {
+        return a[1] - b[1] || a[0] - b[0];
+      }
+      function lineCover(tileHash, coords, maxZoom, ring) {
+        var prevX, prevY;
+        for (var i = 0; i < coords.length - 1; i++) {
+          var start = tilebelt.pointToTileFraction(coords[i][0], coords[i][1], maxZoom), stop = tilebelt.pointToTileFraction(coords[i + 1][0], coords[i + 1][1], maxZoom), x0 = start[0], y0 = start[1], x1 = stop[0], y1 = stop[1], dx = x1 - x0, dy = y1 - y0;
+          if (dy === 0 && dx === 0)
+            continue;
+          var sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1, x = Math.floor(x0), y = Math.floor(y0), tMaxX = dx === 0 ? Infinity : Math.abs(((dx > 0 ? 1 : 0) + x - x0) / dx), tMaxY = dy === 0 ? Infinity : Math.abs(((dy > 0 ? 1 : 0) + y - y0) / dy), tdx = Math.abs(sx / dx), tdy = Math.abs(sy / dy);
+          if (x !== prevX || y !== prevY) {
+            tileHash[toID(x, y, maxZoom)] = true;
+            if (ring && y !== prevY)
+              ring.push([x, y]);
+            prevX = x;
+            prevY = y;
+          }
+          while (tMaxX < 1 || tMaxY < 1) {
+            if (tMaxX < tMaxY) {
+              tMaxX += tdx;
+              x += sx;
+            } else {
+              tMaxY += tdy;
+              y += sy;
+            }
+            tileHash[toID(x, y, maxZoom)] = true;
+            if (ring && y !== prevY)
+              ring.push([x, y]);
+            prevX = x;
+            prevY = y;
+          }
+        }
+        if (ring && y === ring[0][1])
+          ring.pop();
+      }
+      function appendHashTiles(hash, tiles2) {
+        var keys = Object.keys(hash);
+        for (var i = 0; i < keys.length; i++) {
+          tiles2.push(fromID(+keys[i]));
+        }
+      }
+      function toID(x, y, z) {
+        var dim = 2 * (1 << z);
+        return (dim * y + x) * 32 + z;
+      }
+      function fromID(id) {
+        var z = id % 32, dim = 2 * (1 << z), xy = (id - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
+        return [x, y, z];
+      }
+    }
+  });
+
   // ../../node_modules/colorbrewer/colorbrewer.js
   var require_colorbrewer = __commonJS({
     "../../node_modules/colorbrewer/colorbrewer.js"(exports, module) {
@@ -8332,6 +8658,7 @@ var __exports__ = (() => {
     _H3TileLayer: () => H3TileLayer,
     _PointLabelLayer: () => PointLabelLayer,
     _QuadbinTileLayer: () => QuadbinTileLayer,
+    _RasterTileLayer: () => RasterTileLayer,
     _getDataV2: () => getDataV2,
     _mapInstantiation: () => mapInstantiation,
     colorBins: () => colorBins,
@@ -8358,7 +8685,8 @@ var __exports__ = (() => {
   var MAP_TYPES = {
     QUERY: "query",
     TABLE: "table",
-    TILESET: "tileset"
+    TILESET: "tileset",
+    RASTER: "raster"
   };
   var COLUMNS_SUPPORT = [MAP_TYPES.TABLE];
   var GEO_COLUMN_SUPPORT = [MAP_TYPES.QUERY, MAP_TYPES.TABLE];
@@ -8450,7 +8778,7 @@ var __exports__ = (() => {
   }
 
   // src/layers/carto-layer.ts
-  var import_core9 = __toESM(require_core());
+  var import_core11 = __toESM(require_core());
   var import_geo_layers8 = __toESM(require_geo_layers());
 
   // src/api/carto-api-error.ts
@@ -11135,22 +11463,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/api/layer-map.ts
   var import_moment_timezone = __toESM(require_moment_timezone2());
   var import_aggregation_layers = __toESM(require_aggregation_layers());
-  var import_layers2 = __toESM(require_layers());
+  var import_layers3 = __toESM(require_layers());
   var import_geo_layers7 = __toESM(require_geo_layers());
 
   // src/layers/carto-tile-layer.ts
   var import_core = __toESM(require_core2());
 
   // src/layers/schema/fast-pbf.ts
-  function readPackedDouble(pbf, obj) {
-    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
-    obj.value = new Float64Array(pbf.buf.buffer.slice(pbf.pos, end));
-    pbf.pos = end;
-    return obj.value;
-  }
-  function readPackedFixed64(pbf, obj) {
+  function readPackedTypedArray(TypedArray, pbf, obj) {
     const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
-    obj.value = new BigUint64Array(pbf.buf.buffer.slice(pbf.pos, end));
+    obj.value = new TypedArray(pbf.buf.buffer.slice(pbf.pos, end));
     pbf.pos = end;
     return obj.value;
   }
@@ -11200,7 +11522,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        readPackedDouble(pbf, obj);
+        readPackedTypedArray(Float64Array, pbf, obj);
       else if (tag === 2)
         obj.size = pbf.readVarint(true);
     }
@@ -11245,7 +11567,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        readPackedDouble(pbf, obj);
+        readPackedTypedArray(Float64Array, pbf, obj);
     }
   };
   var NumericPropKeyValueReader = class {
@@ -11375,9 +11697,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/layers/schema/tile-loader-utils.ts
   var import_pbf = __toESM(require_pbf());
-  function parsePbf(buffer, TileReader3) {
+  function parsePbf(buffer, TileReader4) {
     const pbf = new import_pbf.default(buffer);
-    const tile = TileReader3.read(pbf);
+    const tile = TileReader4.read(pbf);
     return tile;
   }
 
@@ -11809,6 +12131,102 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/layers/spatial-index-tile-layer.ts
   var import_core2 = __toESM(require_core2());
 
+  // src/layers/schema/carto-raster-tile.ts
+  var ARRAY_TYPES = {
+    uint8: Uint8Array,
+    uint16: Uint16Array,
+    uint32: Uint32Array,
+    uint64: BigUint64Array,
+    int8: Int8Array,
+    int16: Int16Array,
+    int32: Int32Array,
+    int64: BigInt64Array,
+    float32: Float32Array,
+    float64: Float64Array
+  };
+  var BandReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(BandReader._readField, {
+        name: "",
+        type: "",
+        data: null
+      }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.name = pbf.readString();
+      else if (tag === 2)
+        obj.type = pbf.readString();
+      else if (tag === 3) {
+        const TypedArray = ARRAY_TYPES[obj.type];
+        if (!TypedArray) {
+          throw Error(`Invalid data type: ${obj.type}`);
+        }
+        obj.data = {};
+        readPackedTypedArray(TypedArray, pbf, obj.data);
+      }
+    }
+  };
+  var TileReader2 = class {
+    static read(pbf, end) {
+      return pbf.readFields(TileReader2._readField, {
+        blockWidth: 0,
+        blockHeight: 0,
+        bands: []
+      }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.blockWidth = pbf.readVarint();
+      else if (tag === 2)
+        obj.blockHeight = pbf.readVarint();
+      else if (tag === 3)
+        obj.bands.push(BandReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+  };
+
+  // src/layers/schema/carto-raster-tile-loader.ts
+  var CartoRasterTileLoader = {
+    name: "CARTO Raster Tile",
+    version: "1",
+    id: "cartoRasterTile",
+    module: "carto",
+    extensions: ["pbf"],
+    mimeTypes: ["application/vnd.carto-raster-tile"],
+    category: "geometry",
+    worker: false,
+    parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
+    parseSync: parseCartoRasterTile,
+    options: {}
+  };
+  function parseCartoRasterTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+      return null;
+    const tile = parsePbf(arrayBuffer, TileReader2);
+    const {
+      bands,
+      blockHeight,
+      blockWidth
+    } = tile;
+    const numericProps = {};
+    for (let i = 0; i < bands.length; i++) {
+      const {
+        name,
+        data
+      } = bands[i];
+      numericProps[name] = data;
+    }
+    return {
+      blockWidth,
+      blockHeight,
+      cells: {
+        numericProps,
+        properties: []
+      }
+    };
+  }
+  var carto_raster_tile_loader_default = CartoRasterTileLoader;
+
   // src/layers/schema/carto-spatial-tile.ts
   var IndicesReader = class {
     static read(pbf, end) {
@@ -11818,7 +12236,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        readPackedFixed64(pbf, obj);
+        readPackedTypedArray(BigUint64Array, pbf, obj);
     }
   };
   var CellsReader = class {
@@ -11840,9 +12258,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       }
     }
   };
-  var TileReader2 = class {
+  var TileReader3 = class {
     static read(pbf, end) {
-      return pbf.readFields(TileReader2._readField, {
+      return pbf.readFields(TileReader3._readField, {
         scheme: 0,
         cells: null
       }, end);
@@ -11856,6 +12274,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
 
   // ../../node_modules/quadbin/dist/esm/index.js
+  var import_tile_cover = __toESM(require_tile_cover());
   var B = [
     0x5555555555555555n,
     0x3333333333333333n,
@@ -11961,7 +12380,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   function parseCartoSpatialTile(arrayBuffer, options) {
     if (!arrayBuffer)
       return null;
-    const tile = parsePbf(arrayBuffer, TileReader2);
+    const tile = parsePbf(arrayBuffer, TileReader3);
     const {
       cells
     } = tile;
@@ -11976,7 +12395,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/layers/spatial-index-tile-layer.ts
   var import_geo_layers3 = __toESM(require_geo_layers());
-  (0, import_core2.registerLoaders)([carto_spatial_tile_loader_default]);
+  (0, import_core2.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
   function isFeatureIdDefined(value) {
     return value !== void 0 && value !== null && value !== "";
   }
@@ -11984,39 +12403,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     aggregationResLevel: 4
   };
   var SpatialIndexTileLayer = class extends import_geo_layers3.TileLayer {
-    getTileData(tile) {
-      const {
-        data,
-        getTileData,
-        fetch: fetch2
-      } = this.props;
-      const {
-        signal
-      } = tile;
-      tile.url = typeof data === "string" || Array.isArray(data) ? (0, import_geo_layers3._getURLFromTemplate)(data, tile) : null;
-      if (!tile.url) {
-        return Promise.reject("Invalid URL");
-      }
-      if (getTileData) {
-        return getTileData(tile);
-      }
-      let loadOptions = this.getLoadOptions();
-      const {
-        formatTiles
-      } = this.props;
-      if (formatTiles === TILE_FORMATS.BINARY) {
-        loadOptions = {
-          ...loadOptions,
-          mimeType: "application/vnd.carto-spatial-tile"
-        };
-      }
-      return fetch2(tile.url, {
-        propName: "data",
-        layer: this,
-        loadOptions,
-        signal
-      });
-    }
     updateState(params) {
       const {
         props,
@@ -12161,7 +12547,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           ...this.getLoadOptions(),
           cartoSpatialTile: {
             scheme: "h3"
-          }
+          },
+          mimeType: "application/vnd.carto-spatial-tile"
         }
       })];
     }
@@ -12193,15 +12580,18 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/layers/quadbin-utils.ts
   var TILE_SIZE2 = 512;
-  function quadbinToWorldBounds(quadbin, coverage) {
+  function quadbinToOffset(quadbin) {
     const {
       x,
       y,
       z
     } = cellToTile(quadbin);
-    const mask = 1 << z;
-    const scale = mask / TILE_SIZE2;
-    return [[x / scale, TILE_SIZE2 - y / scale], [(x + coverage) / scale, TILE_SIZE2 - (y + coverage) / scale]];
+    const scale = TILE_SIZE2 / (1 << z);
+    return [x * scale, TILE_SIZE2 - y * scale, scale];
+  }
+  function quadbinToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
+    return [[xOffset, yOffset], [xOffset + coverage * scale, yOffset - coverage * scale]];
   }
   function getQuadbinPolygon(quadbin, coverage = 1) {
     const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
@@ -12323,7 +12713,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           ...this.getLoadOptions(),
           cartoSpatialTile: {
             scheme: "quadbin"
-          }
+          },
+          mimeType: "application/vnd.carto-spatial-tile"
         }
       })];
     }
@@ -12331,11 +12722,284 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   __publicField(QuadbinTileLayer, "layerName", "QuadbinTileLayer");
   __publicField(QuadbinTileLayer, "defaultProps", defaultProps5);
 
+  // src/layers/raster-tile-layer.ts
+  var import_core7 = __toESM(require_core());
+
+  // src/layers/raster-layer.ts
+  var import_core6 = __toESM(require_core());
+  var import_layers2 = __toESM(require_layers());
+
+  // src/layers/raster-layer-vertex.glsl.ts
+  var raster_layer_vertex_glsl_default = `#version 300 es
+#define SHADER_NAME raster-layer-vertex-shader
+
+in vec3 positions;
+in vec3 normals;
+
+in float instanceElevations;
+in vec4 instanceFillColors;
+in vec4 instanceLineColors;
+
+in vec3 instancePickingColors;
+
+// Custom uniforms
+uniform float opacity;
+uniform bool extruded;
+uniform bool stroked;
+uniform bool isStroke;
+uniform float coverage;
+uniform float elevationScale;
+uniform float widthScale;
+uniform vec3 offset;
+
+// Result
+out vec4 vColor;
+#ifdef FLAT_SHADING
+out vec4 position_commonspace;
+#endif
+
+void main(void) {
+  // Rather than positioning using attribute, layout pixel grid using gl_InstanceID
+  vec2 common_position = offset.xy;
+  float scale = offset.z;
+
+  int yIndex = - (gl_InstanceID / 256);
+  int xIndex = gl_InstanceID + (yIndex * 256);
+  common_position += scale * vec2(float(xIndex), float(yIndex));
+
+  vec4 color = isStroke ? instanceLineColors : instanceFillColors;
+
+  // if alpha == 0.0 or z < 0.0, do not render element
+  float shouldRender = float(color.a > 0.0 && instanceElevations >= 0.0);
+  float cellWidth = coverage * scale;
+
+  // Get position directly from quadbin, rather than projecting
+  // Important to set geometry.position before using project_ methods below
+  // as geometry.worldPosition is not set (we don't know our lat/long)
+  geometry.position = vec4(common_position, 0.0, 1.0);
+  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+    geometry.position.xyz -= project_uCommonOrigin;
+  }
+
+  // calculate elevation, if 3d not enabled set to 0
+  // cylindar geometry height are between -1.0 to 1.0, transform it to between 0, 1
+  float elevation = 0.0;
+  // calculate stroke offset
+  float strokeOffsetRatio = 1.0;
+
+  if (extruded) {
+    elevation = instanceElevations * (positions.z + 1.0) / 2.0 * elevationScale;
+  } else if (stroked) {
+    float halfOffset = project_pixel_size(widthScale) / cellWidth;
+    if (isStroke) {
+      strokeOffsetRatio -= sign(positions.z) * halfOffset;
+    } else {
+      strokeOffsetRatio -= halfOffset;
+    }
+  }
+
+  geometry.pickingColor = instancePickingColors;
+
+  // project center of column
+  vec2 offset = (vec2(0.5) + positions.xy * strokeOffsetRatio) * cellWidth * shouldRender;
+  vec3 pos = vec3(offset, project_size(elevation));
+  DECKGL_FILTER_SIZE(pos, geometry);
+
+  geometry.position.xyz += pos;
+  gl_Position = project_common_position_to_clipspace(geometry.position);
+
+  geometry.normal = project_normal(normals);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  // Light calculations
+  if (extruded && !isStroke) {
+#ifdef FLAT_SHADING
+    position_commonspace = geometry.position;
+    vColor = vec4(color.rgb, color.a * opacity);
+#else
+    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);
+    vColor = vec4(lightColor, color.a * opacity);
+#endif
+  } else {
+    vColor = vec4(color.rgb, color.a * opacity);
+  }
+
+  DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;
+
   // src/utils.ts
   var import_core5 = __toESM(require_core());
   function assert2(condition, message) {
     import_core5.log.assert(condition, message);
   }
+  function createBinaryProxy(data, index) {
+    const {
+      properties,
+      numericProps
+    } = data;
+    return new Proxy(properties[index] || {}, {
+      get(target, property, receiver) {
+        if (property in numericProps) {
+          return numericProps[property].value[index];
+        }
+        return target[property];
+      },
+      has(target, property) {
+        return property in numericProps || property in target;
+      }
+    });
+  }
+
+  // src/layers/raster-layer.ts
+  var defaultProps6 = {
+    ...import_layers2.ColumnLayer.defaultProps,
+    extruded: false,
+    diskResolution: 4,
+    vertices: [[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]]
+  };
+  var RasterColumnLayer = class extends import_layers2.ColumnLayer {
+    getShaders() {
+      const shaders = super.getShaders();
+      return {
+        ...shaders,
+        vs: raster_layer_vertex_glsl_default
+      };
+    }
+    initializeState() {
+      const attributeManager = this.getAttributeManager();
+      attributeManager.addInstanced({
+        instanceElevations: {
+          size: 1,
+          transition: true,
+          accessor: "getElevation"
+        },
+        instanceFillColors: {
+          size: this.props.colorFormat.length,
+          type: esm_default.UNSIGNED_BYTE,
+          normalized: true,
+          transition: true,
+          accessor: "getFillColor",
+          defaultValue: [0, 0, 0, 255]
+        },
+        instanceLineColors: {
+          size: this.props.colorFormat.length,
+          type: esm_default.UNSIGNED_BYTE,
+          normalized: true,
+          transition: true,
+          accessor: "getLineColor",
+          defaultValue: [255, 255, 255, 255]
+        }
+      });
+    }
+  };
+  __publicField(RasterColumnLayer, "layerName", "RasterColumnLayer");
+  var RasterLayer = class extends import_core6.CompositeLayer {
+    renderLayers() {
+      const {
+        data,
+        getElevation,
+        getFillColor,
+        getLineColor,
+        getLineWidth,
+        tileIndex,
+        updateTriggers
+      } = this.props;
+      if (!data || !tileIndex)
+        return null;
+      const {
+        blockWidth,
+        blockHeight
+      } = data;
+      assert2(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
+      const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
+      const offset = [xOffset, yOffset, scale / blockWidth];
+      const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
+      return new CellLayer(this.props, this.getSubLayerProps({
+        id: "cell",
+        updateTriggers,
+        getElevation: this.getSubLayerAccessor(getElevation),
+        getFillColor: this.getSubLayerAccessor(getFillColor),
+        getLineColor: this.getSubLayerAccessor(getLineColor),
+        getLineWidth: this.getSubLayerAccessor(getLineWidth)
+      }), {
+        data: {
+          data,
+          length: blockWidth * blockHeight
+        },
+        offset
+      });
+    }
+    getSubLayerAccessor(accessor) {
+      if (typeof accessor !== "function") {
+        return super.getSubLayerAccessor(accessor);
+      }
+      return (object, info) => {
+        const {
+          data,
+          index
+        } = info;
+        const binaryData = data.data;
+        const proxy = createBinaryProxy(binaryData.cells, index);
+        return accessor({
+          properties: proxy
+        }, info);
+      };
+    }
+  };
+  __publicField(RasterLayer, "layerName", "RasterLayer");
+  __publicField(RasterLayer, "defaultProps", defaultProps6);
+
+  // src/layers/raster-tile-layer.ts
+  var renderSubLayers3 = (props) => {
+    const tileIndex = props.tile?.index?.q;
+    if (!tileIndex)
+      return null;
+    return new RasterLayer(props, {
+      tileIndex
+    });
+  };
+  var RasterTileLayer = class extends import_core7.CompositeLayer {
+    initializeState() {
+      this.setState({
+        data: null,
+        tileJSON: null
+      });
+    }
+    updateState({
+      changeFlags
+    }) {
+      if (changeFlags.dataChanged) {
+        let {
+          data
+        } = this.props;
+        const tileJSON = data;
+        data = tileJSON.tiles;
+        this.setState({
+          data,
+          tileJSON
+        });
+      }
+    }
+    renderLayers() {
+      const {
+        data,
+        tileJSON
+      } = this.state;
+      const minZoom = parseInt(tileJSON?.minzoom);
+      const maxZoom = parseInt(tileJSON?.maxzoom);
+      return [new SpatialIndexTileLayer(this.props, {
+        id: `raster-tile-layer-${this.props.id}`,
+        data,
+        TilesetClass: QuadbinTileset2D,
+        renderSubLayers: renderSubLayers3,
+        minZoom,
+        maxZoom
+      })];
+    }
+  };
+  __publicField(RasterTileLayer, "layerName", "RasterTileLayer");
+  __publicField(RasterTileLayer, "defaultProps", {});
 
   // src/api/layer-map.ts
   var SCALE_FUNCS = {
@@ -12417,7 +13081,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
     percentile: ["lowerPercentile", "upperPercentile"]
   };
-  var defaultProps6 = {
+  var defaultProps7 = {
     lineMiterLimit: 2,
     lineWidthUnits: "pixels",
     pointRadiusUnits: "pixels",
@@ -12447,7 +13111,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const hexagonId = config.columns?.hex_id;
     const layerTypeDefs = {
       point: {
-        Layer: import_layers2.GeoJsonLayer,
+        Layer: import_layers3.GeoJsonLayer,
         propMap: {
           columns: {
             altitude: (x) => ({
@@ -12462,7 +13126,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         }
       },
       geojson: {
-        Layer: import_layers2.GeoJsonLayer
+        Layer: import_layers3.GeoJsonLayer
       },
       grid: {
         Layer: import_aggregation_layers.CPUGridLayer,
@@ -12523,19 +13187,22 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       ...layer,
       propMap: mergePropMaps(basePropMap, layer.propMap),
       defaultProps: {
-        ...defaultProps6,
+        ...defaultProps7,
         ...layer.defaultProps
       }
     };
   }
-  function layerFromTileDataset(formatTiles = TILE_FORMATS.MVT, scheme) {
+  function layerFromTileDataset(formatTiles = TILE_FORMATS.MVT, scheme, type) {
+    if (type === "raster") {
+      return RasterTileLayer;
+    }
     if (scheme === "h3") {
       return H3TileLayer;
     }
     if (scheme === "quadbin") {
       return QuadbinTileLayer;
     }
-    if (formatTiles === TILE_FORMATS.MVT) {
+    if (formatTiles === "mvt") {
       return import_geo_layers7.MVTLayer;
     }
     return CartoTileLayer;
@@ -12554,7 +13221,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       Layer: layerFromTileDataset(formatTiles, scheme),
       propMap: basePropMap,
       defaultProps: {
-        ...defaultProps6,
+        ...defaultProps7,
         ...aggregationExp && {
           aggregationExp
         },
@@ -12620,21 +13287,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           data: data2,
           index
         } = info;
-        const {
-          properties,
-          numericProps
-        } = data2;
-        const proxy = new Proxy(properties[index] || {}, {
-          get(target, property, receiver) {
-            if (property in numericProps) {
-              return numericProps[property].value[index];
-            }
-            return target[property];
-          },
-          has(target, property) {
-            return property in numericProps || property in target;
-          }
-        });
+        const proxy = createBinaryProxy(data2, index);
         return accessor(proxy);
       };
     }
@@ -12798,10 +13451,10 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/point-label-layer.ts
-  var import_core6 = __toESM(require_core());
-  var import_layers3 = __toESM(require_layers());
+  var import_core8 = __toESM(require_core());
+  var import_layers4 = __toESM(require_layers());
   var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
-  var EnhancedTextBackgroundLayer = class extends import_layers3._TextBackgroundLayer {
+  var EnhancedTextBackgroundLayer = class extends import_layers4._TextBackgroundLayer {
     getShaders() {
       const shaders = super.getShaders();
       let vs = shaders.vs;
@@ -12814,7 +13467,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(EnhancedTextBackgroundLayer, "layerName", "EnhancedTextBackgroundLayer");
-  var EnhancedTextLayer = class extends import_layers3.TextLayer {
+  var EnhancedTextLayer = class extends import_layers4.TextLayer {
     filterSubLayer({
       layer,
       renderPass
@@ -12827,8 +13480,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(EnhancedTextLayer, "layerName", "EnhancedTextLayer");
-  var defaultProps7 = {
-    ...import_layers3.TextLayer.defaultProps,
+  var defaultProps8 = {
+    ...import_layers4.TextLayer.defaultProps,
     getRadius: {
       type: "accessor",
       value: 1
@@ -12839,7 +13492,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       value: 1
     }
   };
-  var PointLabelLayer = class extends import_core6.CompositeLayer {
+  var PointLabelLayer = class extends import_core8.CompositeLayer {
     calculatePixelOffset(secondary) {
       const {
         getTextAnchor: anchor,
@@ -12979,10 +13632,10 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(PointLabelLayer, "layerName", "PointLabelLayer");
-  __publicField(PointLabelLayer, "defaultProps", defaultProps7);
+  __publicField(PointLabelLayer, "defaultProps", defaultProps8);
 
   // src/api/parseMap.ts
-  var import_core7 = __toESM(require_core());
+  var import_core9 = __toESM(require_core());
   var import_extensions2 = __toESM(require_extensions());
   var collisionFilterExtension = new import_extensions2.CollisionFilterExtension();
   function parseMap(json) {
@@ -13029,13 +13682,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           const {
             Layer,
             propMap,
-            defaultProps: defaultProps9
+            defaultProps: defaultProps10
           } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
           return new Layer({
             id,
             data,
-            ...defaultProps9,
+            ...defaultProps10,
             ...createInteractionProps(interactionConfig),
             ...styleProps,
             ...createChannelProps(id, type, config, visualChannels, data),
@@ -13043,7 +13696,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
             ...createLoadOptions(token)
           });
         } catch (e) {
-          import_core7.log.error(e.message)();
+          import_core9.log.error(e.message)();
           return void 0;
         }
       })
@@ -13202,7 +13855,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         data
       );
     }
-    if (heightField) {
+    if (heightField && visConfig.enable3d) {
       result.getElevation = getSizeAccessor(
         heightField,
         heightScale,
@@ -13316,7 +13969,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/api/maps-v3-client.ts
-  var import_core8 = __toESM(require_core());
+  var import_core10 = __toESM(require_core());
   var MAX_GET_LENGTH = 8192;
   var DEFAULT_CLIENT = "deck-gl-carto";
   var V3_MINOR_VERSION = "3.1";
@@ -13364,7 +14017,14 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       body,
       errorContext
     });
-    const json = await response.json();
+    let json;
+    try {
+      json = await response.json();
+    } catch (error) {
+      json = {
+        error: ""
+      };
+    }
     if (!response.ok) {
       throw new CartoAPIError(json.error, errorContext, response);
     }
@@ -13643,7 +14303,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       assert2(url && mapFormat, "Unsupported data formats received from backend.");
     }
     if (format2 === FORMATS.TILEJSON && formatTiles) {
-      import_core8.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
+      import_core10.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
       url += `&${encodeParameter("formatTiles", formatTiles)}`;
     }
     const {
@@ -13873,7 +14533,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/carto-layer.ts
-  var defaultProps8 = {
+  var defaultProps9 = {
     data: null,
     type: null,
     onDataLoad: {
@@ -13906,7 +14566,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     aggregationResLevel: null,
     queryParameters: null
   };
-  var CartoLayer = class extends import_core9.CompositeLayer {
+  var CartoLayer = class extends import_core11.CompositeLayer {
     initializeState() {
       this.state = {
         data: null,
@@ -13931,23 +14591,23 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       const {
         apiVersion
       } = localCreds;
-      import_core9.log.assert(Object.values(API_VERSIONS).includes(apiVersion), `Invalid apiVersion ${apiVersion}. Use API_VERSIONS enum.`);
+      import_core11.log.assert(Object.values(API_VERSIONS).includes(apiVersion), `Invalid apiVersion ${apiVersion}. Use API_VERSIONS enum.`);
       if (apiVersion === API_VERSIONS.V1 || apiVersion === API_VERSIONS.V2) {
-        import_core9.log.assert(type === MAP_TYPES.QUERY || type === MAP_TYPES.TILESET, `Invalid type ${type}. Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ${apiVersion}`);
-        import_core9.log.assert(!connection, `Connection prop is not supported for apiVersion ${apiVersion}`);
-        import_core9.log.assert(!geoColumn, `geoColumn prop is not supported for apiVersion ${apiVersion}`);
-        import_core9.log.assert(!columns, `columns prop is not supported for apiVersion ${apiVersion}`);
+        import_core11.log.assert(type === MAP_TYPES.QUERY || type === MAP_TYPES.TILESET, `Invalid type ${type}. Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ${apiVersion}`);
+        import_core11.log.assert(!connection, `Connection prop is not supported for apiVersion ${apiVersion}`);
+        import_core11.log.assert(!geoColumn, `geoColumn prop is not supported for apiVersion ${apiVersion}`);
+        import_core11.log.assert(!columns, `columns prop is not supported for apiVersion ${apiVersion}`);
       } else if (apiVersion === API_VERSIONS.V3) {
-        import_core9.log.assert(connection, "Missing mandatory connection parameter");
-        import_core9.log.assert(Object.values(MAP_TYPES).includes(type), `Invalid type ${type}. Use MAP_TYPES enum.`);
+        import_core11.log.assert(connection, "Missing mandatory connection parameter");
+        import_core11.log.assert(Object.values(MAP_TYPES).includes(type), `Invalid type ${type}. Use MAP_TYPES enum.`);
         if (!COLUMNS_SUPPORT.includes(type)) {
-          import_core9.log.assert(!columns, `columns prop is only supported for types: ${COLUMNS_SUPPORT.join()}`);
+          import_core11.log.assert(!columns, `columns prop is only supported for types: ${COLUMNS_SUPPORT.join()}`);
         }
         if (!GEO_COLUMN_SUPPORT.includes(type)) {
-          import_core9.log.assert(!geoColumn, `geoColumn prop is only supported for types: ${GEO_COLUMN_SUPPORT.join()}`);
+          import_core11.log.assert(!geoColumn, `geoColumn prop is only supported for types: ${GEO_COLUMN_SUPPORT.join()}`);
         }
         if (columns) {
-          import_core9.log.assert(Array.isArray(columns), "columns prop must be an Array");
+          import_core11.log.assert(Array.isArray(columns), "columns prop must be an Array");
         }
       }
     }
@@ -14025,7 +14685,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       } = this.state;
       const {
         uniqueIdProperty
-      } = defaultProps8;
+      } = defaultProps9;
       const {
         data: _notUsed,
         ...propsNoData
@@ -14039,7 +14699,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       }
       const tileUrl = new URL(data.tiles[0]);
       props.formatTiles = props.formatTiles || tileUrl.searchParams.get("formatTiles");
-      return [layerFromTileDataset(props.formatTiles, data.scheme), props];
+      return [layerFromTileDataset(props.formatTiles, data.scheme, props.type), props];
     }
     renderLayers() {
       assert2(this.state);
@@ -14078,7 +14738,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(CartoLayer, "layerName", "CartoLayer");
-  __publicField(CartoLayer, "defaultProps", defaultProps8);
+  __publicField(CartoLayer, "defaultProps", defaultProps9);
 
   // src/basemap.ts
   var baseUrl = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
@@ -14204,9 +14864,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // ../layers/bundle/peer-dependency.ts
   var peer_dependency_exports = {};
-  var import_layers4 = __toESM(require_layers());
+  var import_layers5 = __toESM(require_layers());
   __reExport(peer_dependency_exports, __toESM(require_layers()));
-  if (!import_layers4.GeoJsonLayer) {
+  if (!import_layers5.GeoJsonLayer) {
     throw new Error("@deck.gl/layers is not found");
   }