@deck.gl/carto 8.10.0-alpha.2 → 8.10.0-alpha.4

package/dist/dist.dev.js

@@ -3985,7 +3985,7 @@ var __exports__ = (() => {
         if (moment2.version === void 0 && moment2.default) {
           moment2 = moment2.default;
         }
-        var VERSION = "0.5.35", zones = {}, links = {}, countries = {}, names = {}, guesses = {}, cachedGuess;
+        var VERSION4 = "0.5.35", zones = {}, links = {}, countries = {}, names = {}, guesses = {}, cachedGuess;
         if (!moment2 || typeof moment2.version !== "string") {
           logError("Moment Timezone requires Moment.js. See https://momentjs.com/timezone/docs/#/use-it/browser/");
         }
@@ -4361,7 +4361,7 @@ var __exports__ = (() => {
           out.tz(name);
           return out;
         }
-        tz.version = VERSION;
+        tz.version = VERSION4;
         tz.dataVersion = "";
         tz._zones = zones;
         tz._links = links;
@@ -5348,6 +5348,13 @@ var __exports__ = (() => {
     }
   });
 
+  // external-global-plugin:h3-js
+  var require_h3_js = __commonJS({
+    "external-global-plugin:h3-js"(exports, module) {
+      module.exports = globalThis.h3 || {};
+    }
+  });
+
   // external-global-plugin:@loaders.gl/core
   var require_core2 = __commonJS({
     "external-global-plugin:@loaders.gl/core"(exports, module) {
@@ -6091,20 +6098,6 @@ var __exports__ = (() => {
     }
   });
 
-  // external-global-plugin:@deck.gl/extensions
-  var require_extensions = __commonJS({
-    "external-global-plugin:@deck.gl/extensions"(exports, module) {
-      module.exports = globalThis.deck;
-    }
-  });
-
-  // external-global-plugin:h3-js
-  var require_h3_js = __commonJS({
-    "external-global-plugin:h3-js"(exports, module) {
-      module.exports = globalThis.h3 || {};
-    }
-  });
-
   // ../../node_modules/tilebelt/index.js
   var require_tilebelt = __commonJS({
     "../../node_modules/tilebelt/index.js"(exports, module) {
@@ -6330,11 +6323,11 @@ var __exports__ = (() => {
           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]) {
+              var id22 = toID(t[0] + 1, t[1], z), id32 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
+              if (tileHash[id22] && tileHash[id32] && tileHash[id4]) {
                 tileHash[toID(t[0], t[1], t[2])] = false;
-                tileHash[id2] = false;
-                tileHash[id3] = false;
+                tileHash[id22] = false;
+                tileHash[id32] = false;
                 tileHash[id4] = false;
                 var parentTile = [t[0] / 2, t[1] / 2, z - 1];
                 if (z - 1 === limits.min_zoom)
@@ -6372,8 +6365,8 @@ var __exports__ = (() => {
         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]) {
+            var id4 = toID(x, y, zoom);
+            if (!tileHash[id4]) {
               tileArray.push([x, y, zoom]);
             }
           }
@@ -6424,13 +6417,487 @@ var __exports__ = (() => {
         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;
+      function fromID(id4) {
+        var z = id4 % 32, dim = 2 * (1 << z), xy = (id4 - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
         return [x, y, z];
       }
     }
   });
 
+  // ../../node_modules/earcut/src/earcut.js
+  var require_earcut = __commonJS({
+    "../../node_modules/earcut/src/earcut.js"(exports, module) {
+      "use strict";
+      module.exports = earcut2;
+      module.exports.default = earcut2;
+      function earcut2(data, holeIndices, dim) {
+        dim = dim || 2;
+        var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = [];
+        if (!outerNode || outerNode.next === outerNode.prev)
+          return triangles;
+        var minX, minY, maxX, maxY, x, y, invSize;
+        if (hasHoles)
+          outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+        if (data.length > 80 * dim) {
+          minX = maxX = data[0];
+          minY = maxY = data[1];
+          for (var i = dim; i < outerLen; i += dim) {
+            x = data[i];
+            y = data[i + 1];
+            if (x < minX)
+              minX = x;
+            if (y < minY)
+              minY = y;
+            if (x > maxX)
+              maxX = x;
+            if (y > maxY)
+              maxY = y;
+          }
+          invSize = Math.max(maxX - minX, maxY - minY);
+          invSize = invSize !== 0 ? 1 / invSize : 0;
+        }
+        earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+        return triangles;
+      }
+      function linkedList(data, start, end, dim, clockwise) {
+        var i, last;
+        if (clockwise === signedArea(data, start, end, dim) > 0) {
+          for (i = start; i < end; i += dim)
+            last = insertNode(i, data[i], data[i + 1], last);
+        } else {
+          for (i = end - dim; i >= start; i -= dim)
+            last = insertNode(i, data[i], data[i + 1], last);
+        }
+        if (last && equals(last, last.next)) {
+          removeNode(last);
+          last = last.next;
+        }
+        return last;
+      }
+      function filterPoints(start, end) {
+        if (!start)
+          return start;
+        if (!end)
+          end = start;
+        var p = start, again;
+        do {
+          again = false;
+          if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+            removeNode(p);
+            p = end = p.prev;
+            if (p === p.next)
+              break;
+            again = true;
+          } else {
+            p = p.next;
+          }
+        } while (again || p !== end);
+        return end;
+      }
+      function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+        if (!ear)
+          return;
+        if (!pass && invSize)
+          indexCurve(ear, minX, minY, invSize);
+        var stop = ear, prev, next;
+        while (ear.prev !== ear.next) {
+          prev = ear.prev;
+          next = ear.next;
+          if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+            triangles.push(prev.i / dim);
+            triangles.push(ear.i / dim);
+            triangles.push(next.i / dim);
+            removeNode(ear);
+            ear = next.next;
+            stop = next.next;
+            continue;
+          }
+          ear = next;
+          if (ear === stop) {
+            if (!pass) {
+              earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+            } else if (pass === 1) {
+              ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+              earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+            } else if (pass === 2) {
+              splitEarcut(ear, triangles, dim, minX, minY, invSize);
+            }
+            break;
+          }
+        }
+      }
+      function isEar(ear) {
+        var a = ear.prev, b = ear, c = ear.next;
+        if (area(a, b, c) >= 0)
+          return false;
+        var p = ear.next.next;
+        while (p !== ear.prev) {
+          if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+            return false;
+          p = p.next;
+        }
+        return true;
+      }
+      function isEarHashed(ear, minX, minY, invSize) {
+        var a = ear.prev, b = ear, c = ear.next;
+        if (area(a, b, c) >= 0)
+          return false;
+        var minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x, minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y, maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x, maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;
+        var minZ = zOrder(minTX, minTY, minX, minY, invSize), maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+        var p = ear.prevZ, n = ear.nextZ;
+        while (p && p.z >= minZ && n && n.z <= maxZ) {
+          if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+            return false;
+          p = p.prevZ;
+          if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+            return false;
+          n = n.nextZ;
+        }
+        while (p && p.z >= minZ) {
+          if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+            return false;
+          p = p.prevZ;
+        }
+        while (n && n.z <= maxZ) {
+          if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+            return false;
+          n = n.nextZ;
+        }
+        return true;
+      }
+      function cureLocalIntersections(start, triangles, dim) {
+        var p = start;
+        do {
+          var a = p.prev, b = p.next.next;
+          if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+            triangles.push(a.i / dim);
+            triangles.push(p.i / dim);
+            triangles.push(b.i / dim);
+            removeNode(p);
+            removeNode(p.next);
+            p = start = b;
+          }
+          p = p.next;
+        } while (p !== start);
+        return filterPoints(p);
+      }
+      function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+        var a = start;
+        do {
+          var b = a.next.next;
+          while (b !== a.prev) {
+            if (a.i !== b.i && isValidDiagonal(a, b)) {
+              var c = splitPolygon(a, b);
+              a = filterPoints(a, a.next);
+              c = filterPoints(c, c.next);
+              earcutLinked(a, triangles, dim, minX, minY, invSize);
+              earcutLinked(c, triangles, dim, minX, minY, invSize);
+              return;
+            }
+            b = b.next;
+          }
+          a = a.next;
+        } while (a !== start);
+      }
+      function eliminateHoles(data, holeIndices, outerNode, dim) {
+        var queue = [], i, len, start, end, list;
+        for (i = 0, len = holeIndices.length; i < len; i++) {
+          start = holeIndices[i] * dim;
+          end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+          list = linkedList(data, start, end, dim, false);
+          if (list === list.next)
+            list.steiner = true;
+          queue.push(getLeftmost(list));
+        }
+        queue.sort(compareX);
+        for (i = 0; i < queue.length; i++) {
+          eliminateHole(queue[i], outerNode);
+          outerNode = filterPoints(outerNode, outerNode.next);
+        }
+        return outerNode;
+      }
+      function compareX(a, b) {
+        return a.x - b.x;
+      }
+      function eliminateHole(hole, outerNode) {
+        outerNode = findHoleBridge(hole, outerNode);
+        if (outerNode) {
+          var b = splitPolygon(outerNode, hole);
+          filterPoints(b, b.next);
+        }
+      }
+      function findHoleBridge(hole, outerNode) {
+        var p = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m;
+        do {
+          if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+            var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+            if (x <= hx && x > qx) {
+              qx = x;
+              if (x === hx) {
+                if (hy === p.y)
+                  return p;
+                if (hy === p.next.y)
+                  return p.next;
+              }
+              m = p.x < p.next.x ? p : p.next;
+            }
+          }
+          p = p.next;
+        } while (p !== outerNode);
+        if (!m)
+          return null;
+        if (hx === qx)
+          return m;
+        var stop = m, mx = m.x, my = m.y, tanMin = Infinity, tan;
+        p = m;
+        do {
+          if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+            tan = Math.abs(hy - p.y) / (hx - p.x);
+            if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+              m = p;
+              tanMin = tan;
+            }
+          }
+          p = p.next;
+        } while (p !== stop);
+        return m;
+      }
+      function sectorContainsSector(m, p) {
+        return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+      }
+      function indexCurve(start, minX, minY, invSize) {
+        var p = start;
+        do {
+          if (p.z === null)
+            p.z = zOrder(p.x, p.y, minX, minY, invSize);
+          p.prevZ = p.prev;
+          p.nextZ = p.next;
+          p = p.next;
+        } while (p !== start);
+        p.prevZ.nextZ = null;
+        p.prevZ = null;
+        sortLinked(p);
+      }
+      function sortLinked(list) {
+        var i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+        do {
+          p = list;
+          list = null;
+          tail = null;
+          numMerges = 0;
+          while (p) {
+            numMerges++;
+            q = p;
+            pSize = 0;
+            for (i = 0; i < inSize; i++) {
+              pSize++;
+              q = q.nextZ;
+              if (!q)
+                break;
+            }
+            qSize = inSize;
+            while (pSize > 0 || qSize > 0 && q) {
+              if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+                e = p;
+                p = p.nextZ;
+                pSize--;
+              } else {
+                e = q;
+                q = q.nextZ;
+                qSize--;
+              }
+              if (tail)
+                tail.nextZ = e;
+              else
+                list = e;
+              e.prevZ = tail;
+              tail = e;
+            }
+            p = q;
+          }
+          tail.nextZ = null;
+          inSize *= 2;
+        } while (numMerges > 1);
+        return list;
+      }
+      function zOrder(x, y, minX, minY, invSize) {
+        x = 32767 * (x - minX) * invSize;
+        y = 32767 * (y - minY) * invSize;
+        x = (x | x << 8) & 16711935;
+        x = (x | x << 4) & 252645135;
+        x = (x | x << 2) & 858993459;
+        x = (x | x << 1) & 1431655765;
+        y = (y | y << 8) & 16711935;
+        y = (y | y << 4) & 252645135;
+        y = (y | y << 2) & 858993459;
+        y = (y | y << 1) & 1431655765;
+        return x | y << 1;
+      }
+      function getLeftmost(start) {
+        var p = start, leftmost = start;
+        do {
+          if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+            leftmost = p;
+          p = p.next;
+        } while (p !== start);
+        return leftmost;
+      }
+      function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+        return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+      }
+      function isValidDiagonal(a, b) {
+        return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+      }
+      function area(p, q, r) {
+        return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+      }
+      function equals(p1, p2) {
+        return p1.x === p2.x && p1.y === p2.y;
+      }
+      function intersects(p1, q1, p2, q2) {
+        var o1 = sign(area(p1, q1, p2));
+        var o2 = sign(area(p1, q1, q2));
+        var o3 = sign(area(p2, q2, p1));
+        var o4 = sign(area(p2, q2, q1));
+        if (o1 !== o2 && o3 !== o4)
+          return true;
+        if (o1 === 0 && onSegment(p1, p2, q1))
+          return true;
+        if (o2 === 0 && onSegment(p1, q2, q1))
+          return true;
+        if (o3 === 0 && onSegment(p2, p1, q2))
+          return true;
+        if (o4 === 0 && onSegment(p2, q1, q2))
+          return true;
+        return false;
+      }
+      function onSegment(p, q, r) {
+        return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+      }
+      function sign(num) {
+        return num > 0 ? 1 : num < 0 ? -1 : 0;
+      }
+      function intersectsPolygon(a, b) {
+        var p = a;
+        do {
+          if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+            return true;
+          p = p.next;
+        } while (p !== a);
+        return false;
+      }
+      function locallyInside(a, b) {
+        return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+      }
+      function middleInside(a, b) {
+        var p = a, inside = false, px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+        do {
+          if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+            inside = !inside;
+          p = p.next;
+        } while (p !== a);
+        return inside;
+      }
+      function splitPolygon(a, b) {
+        var a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
+        a.next = b;
+        b.prev = a;
+        a2.next = an;
+        an.prev = a2;
+        b2.next = a2;
+        a2.prev = b2;
+        bp.next = b2;
+        b2.prev = bp;
+        return b2;
+      }
+      function insertNode(i, x, y, last) {
+        var p = new Node(i, x, y);
+        if (!last) {
+          p.prev = p;
+          p.next = p;
+        } else {
+          p.next = last.next;
+          p.prev = last;
+          last.next.prev = p;
+          last.next = p;
+        }
+        return p;
+      }
+      function removeNode(p) {
+        p.next.prev = p.prev;
+        p.prev.next = p.next;
+        if (p.prevZ)
+          p.prevZ.nextZ = p.nextZ;
+        if (p.nextZ)
+          p.nextZ.prevZ = p.prevZ;
+      }
+      function Node(i, x, y) {
+        this.i = i;
+        this.x = x;
+        this.y = y;
+        this.prev = null;
+        this.next = null;
+        this.z = null;
+        this.prevZ = null;
+        this.nextZ = null;
+        this.steiner = false;
+      }
+      earcut2.deviation = function(data, holeIndices, dim, triangles) {
+        var hasHoles = holeIndices && holeIndices.length;
+        var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+        var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+        if (hasHoles) {
+          for (var i = 0, len = holeIndices.length; i < len; i++) {
+            var start = holeIndices[i] * dim;
+            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+            polygonArea -= Math.abs(signedArea(data, start, end, dim));
+          }
+        }
+        var trianglesArea = 0;
+        for (i = 0; i < triangles.length; i += 3) {
+          var a = triangles[i] * dim;
+          var b = triangles[i + 1] * dim;
+          var c = triangles[i + 2] * dim;
+          trianglesArea += Math.abs((data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
+        }
+        return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
+      };
+      function signedArea(data, start, end, dim) {
+        var sum = 0;
+        for (var i = start, j = end - dim; i < end; i += dim) {
+          sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+          j = i;
+        }
+        return sum;
+      }
+      earcut2.flatten = function(data) {
+        var dim = data[0][0].length, result = {
+          vertices: [],
+          holes: [],
+          dimensions: dim
+        }, holeIndex = 0;
+        for (var i = 0; i < data.length; i++) {
+          for (var j = 0; j < data[i].length; j++) {
+            for (var d = 0; d < dim; d++)
+              result.vertices.push(data[i][j][d]);
+          }
+          if (i > 0) {
+            holeIndex += data[i - 1].length;
+            result.holes.push(holeIndex);
+          }
+        }
+        return result;
+      };
+    }
+  });
+
+  // external-global-plugin:@deck.gl/extensions
+  var require_extensions = __commonJS({
+    "external-global-plugin:@deck.gl/extensions"(exports, module) {
+      module.exports = globalThis.deck;
+    }
+  });
+
   // ../../node_modules/colorbrewer/colorbrewer.js
   var require_colorbrewer = __commonJS({
     "../../node_modules/colorbrewer/colorbrewer.js"(exports, module) {
@@ -8652,15 +9119,26 @@ var __exports__ = (() => {
     CartoAPIError: () => CartoAPIError,
     CartoLayer: () => CartoLayer,
     FORMATS: () => FORMATS,
+    H3TileLayer: () => H3TileLayer,
     MAP_TYPES: () => MAP_TYPES,
+    QuadbinTileLayer: () => QuadbinTileLayer,
+    RasterTileLayer: () => RasterTileLayer,
+    SOURCE_DEFAULTS: () => SOURCE_DEFAULTS,
     TILE_FORMATS: () => TILE_FORMATS,
-    _CartoTileLayer: () => CartoTileLayer,
-    _H3TileLayer: () => H3TileLayer,
+    VectorTileLayer: () => VectorTileLayer,
     _PointLabelLayer: () => PointLabelLayer,
-    _QuadbinTileLayer: () => QuadbinTileLayer,
-    _RasterTileLayer: () => RasterTileLayer,
     _getDataV2: () => getDataV2,
     _mapInstantiation: () => mapInstantiation,
+    cartoH3QuerySource: () => cartoH3QuerySource,
+    cartoH3TableSource: () => cartoH3TableSource,
+    cartoH3TilesetSource: () => cartoH3TilesetSource,
+    cartoQuadbinQuerySource: () => cartoQuadbinQuerySource,
+    cartoQuadbinTableSource: () => cartoQuadbinTableSource,
+    cartoQuadbinTilesetSource: () => cartoQuadbinTilesetSource,
+    cartoRasterSource: () => cartoRasterSource,
+    cartoVectorQuerySource: () => cartoVectorQuerySource,
+    cartoVectorTableSource: () => cartoVectorTableSource,
+    cartoVectorTilesetSource: () => cartoVectorTilesetSource,
     colorBins: () => colorBins,
     colorCategories: () => colorCategories,
     colorContinuous: () => colorContinuous,
@@ -8692,7 +9170,6 @@ var __exports__ = (() => {
   var GEO_COLUMN_SUPPORT = [MAP_TYPES.QUERY, MAP_TYPES.TABLE];
   var FORMATS = {
     GEOJSON: "geojson",
-    NDJSON: "ndjson",
     TILEJSON: "tilejson",
     JSON: "json"
   };
@@ -11466,8 +11943,118 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   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/h3-tile-layer.ts
+  var import_core3 = __toESM(require_core());
+  var import_geo_layers3 = __toESM(require_geo_layers());
+
+  // src/layers/h3-tileset-2d.ts
+  var import_geo_layers = __toESM(require_geo_layers());
+  var import_h3_js = __toESM(require_h3_js());
+  function getHexagonsInBoundingBox({
+    west,
+    north,
+    east,
+    south
+  }, resolution) {
+    const longitudeSpan = Math.abs(east - west);
+    if (longitudeSpan > 180) {
+      const nSegments = Math.ceil(longitudeSpan / 180);
+      let h3Indices2 = [];
+      for (let s = 0; s < nSegments; s++) {
+        const segmentEast = east + s * 180;
+        const segmentWest = Math.min(segmentEast + 179.9999999, west);
+        h3Indices2 = h3Indices2.concat(getHexagonsInBoundingBox({
+          west: segmentWest,
+          north,
+          east: segmentEast,
+          south
+        }, resolution));
+      }
+      return [...new Set(h3Indices2)];
+    }
+    const oversample = 2;
+    const h3Indices = (0, import_h3_js.polygonToCells)([[[west, north], [west, south], [east, south], [east, north], [west, north]]], resolution + oversample, true);
+    return oversample ? [...new Set(h3Indices.map((i) => (0, import_h3_js.cellToParent)(i, resolution)))] : h3Indices;
+  }
+  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) {
+    const hexagonScaleFactor = 2 / 3 * viewport.zoom;
+    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_layers._Tileset2D {
+    getTileIndices({
+      viewport,
+      minZoom,
+      maxZoom
+    }) {
+      if (viewport.latitude === void 0)
+        return [];
+      const [east, south, west, north] = viewport.getBounds();
+      let z = getHexagonResolution(viewport);
+      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 {
+        indices = getHexagonsInBoundingBox({
+          west,
+          north,
+          east,
+          south
+        }, 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
+      };
+    }
+  };
+
+  // src/layers/spatial-index-tile-layer.ts
+  var import_core2 = __toESM(require_core2());
 
   // src/layers/schema/fast-pbf.ts
   function readPackedTypedArray(TypedArray, pbf, obj) {
@@ -11477,27 +12064,164 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return obj.value;
   }
 
-  // src/layers/schema/carto-tile.ts
-  var KeyValueObjectReader = class {
+  // 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(KeyValueObjectReader._readField, {
-        key: "",
-        value: ""
+      return pbf.readFields(BandReader._readField, {
+        name: "",
+        type: "",
+        data: null
       }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        obj.key = pbf.readString();
+        obj.name = 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) {
+        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 TileReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(TileReader._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/tile-loader-utils.ts
+  var import_pbf = __toESM(require_pbf());
+  function parsePbf(buffer, TileReader4) {
+    const pbf = new import_pbf.default(buffer);
+    const tile = TileReader4.read(pbf);
+    return tile;
+  }
+
+  // src/utils.ts
+  var import_core = __toESM(require_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, receiver) {
+        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`;
+  }
+
+  // src/layers/schema/carto-raster-tile-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id = "cartoRasterTile";
+  var DEFAULT_OPTIONS = {
+    cartoRasterTile: {
+      workerUrl: getWorkerUrl(id, VERSION)
+    }
+  };
+  var CartoRasterTileLoader = {
+    name: "CARTO Raster Tile",
+    version: VERSION,
+    id,
+    module: "carto",
+    extensions: ["pbf"],
+    mimeTypes: ["application/vnd.carto-raster-tile"],
+    category: "geometry",
+    parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
+    parseSync: parseCartoRasterTile,
+    worker: true,
+    options: DEFAULT_OPTIONS
+  };
+  function parseCartoRasterTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+      return null;
+    const tile = parsePbf(arrayBuffer, TileReader);
+    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-tile.ts
+  var KeyValueObjectReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(KeyValueObjectReader._readField, {
+        key: "",
+        value: null
+      }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.key = pbf.readString();
+      else if (tag === 2)
+        obj.value = pbf.readString();
+    }
+  };
+  var PropertiesReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(PropertiesReader._readField, {}, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1) {
         const {
           key,
           value
@@ -11677,9 +12401,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
     }
   };
-  var TileReader = class {
+  var TileReader2 = class {
     static read(pbf, end) {
-      return pbf.readFields(TileReader._readField, {
+      return pbf.readFields(TileReader2._readField, {
         points: null,
         lines: null,
         polygons: null
@@ -11695,606 +12419,72 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
 
-  // src/layers/schema/tile-loader-utils.ts
-  var import_pbf = __toESM(require_pbf());
-  function parsePbf(buffer, TileReader4) {
-    const pbf = new import_pbf.default(buffer);
-    const tile = TileReader4.read(pbf);
-    return tile;
-  }
-
-  // src/layers/schema/carto-vector-tile-loader.ts
-  var CartoVectorTileLoader = {
-    name: "CARTO Vector Tile",
-    version: "1",
-    id: "cartoVectorTile",
-    module: "carto",
-    extensions: ["pbf"],
-    mimeTypes: ["application/vnd.carto-vector-tile"],
-    category: "geometry",
-    worker: false,
-    parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),
-    parseSync: parseCartoVectorTile,
-    options: {}
+  // src/layers/schema/carto-spatial-tile.ts
+  var IndicesReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(IndicesReader._readField, {
+        value: []
+      }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        readPackedTypedArray(BigUint64Array, pbf, obj);
+    }
   };
-  function parseCartoVectorTile(arrayBuffer, options) {
-    if (!arrayBuffer)
-      return null;
-    const tile = parsePbf(arrayBuffer, TileReader);
-    return tile;
-  }
-  var carto_vector_tile_loader_default = CartoVectorTileLoader;
-
-  // src/layers/carto-tile-layer.ts
-  var import_extensions = __toESM(require_extensions());
-  var import_geo_layers = __toESM(require_geo_layers());
-  var import_layers = __toESM(require_layers());
-
-  // ../../node_modules/@loaders.gl/gis/dist/esm/lib/binary-to-geojson.js
-  function binaryToGeojson(data, options) {
-    const globalFeatureId = options === null || options === void 0 ? void 0 : options.globalFeatureId;
-    if (globalFeatureId !== void 0) {
-      return getSingleFeature(data, globalFeatureId);
+  var CellsReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(CellsReader._readField, {
+        indices: null,
+        properties: [],
+        numericProps: {}
+      }, end);
     }
-    return parseFeatures(data, options === null || options === void 0 ? void 0 : options.type);
-  }
-  function getSingleFeature(data, globalFeatureId) {
-    const dataArray = normalizeInput(data);
-    for (const data2 of dataArray) {
-      let lastIndex = 0;
-      let lastValue = data2.featureIds.value[0];
-      for (let i = 0; i < data2.featureIds.value.length; i++) {
-        const currValue = data2.featureIds.value[i];
-        if (currValue === lastValue) {
-          continue;
-        }
-        if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
-          return parseFeature(data2, lastIndex, i);
-        }
-        lastIndex = i;
-        lastValue = currValue;
-      }
-      if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
-        return parseFeature(data2, lastIndex, data2.featureIds.value.length);
+    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;
       }
     }
-    throw new Error("featureId:".concat(globalFeatureId, " not found"));
+  };
+  var TileReader3 = class {
+    static read(pbf, end) {
+      return pbf.readFields(TileReader3._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);
+    }
+  };
+
+  // ../../node_modules/quadbin/dist/esm/index.js
+  var import_tile_cover = __toESM(require_tile_cover());
+  var B = [
+    0x5555555555555555n,
+    0x3333333333333333n,
+    0x0f0f0f0f0f0f0f0fn,
+    0x00ff00ff00ff00ffn,
+    0x0000ffff0000ffffn,
+    0x00000000ffffffffn
+  ];
+  var S = [0n, 1n, 2n, 4n, 8n, 16n];
+  function hexToBigInt(hex2) {
+    return BigInt(`0x${hex2}`);
   }
-  function parseFeatures(data, type) {
-    const dataArray = normalizeInput(data, type);
-    return parseFeatureCollection(dataArray);
+  function bigIntToHex(index) {
+    return index.toString(16);
   }
-  function binaryToGeometry(data, startIndex, endIndex) {
-    switch (data.type) {
-      case "Point":
-        return pointToGeoJson(data, startIndex, endIndex);
-      case "LineString":
-        return lineStringToGeoJson(data, startIndex, endIndex);
-      case "Polygon":
-        return polygonToGeoJson(data, startIndex, endIndex);
-      default:
-        const unexpectedInput = data;
-        throw new Error("Unsupported geometry type: ".concat(unexpectedInput === null || unexpectedInput === void 0 ? void 0 : unexpectedInput.type));
-    }
-  }
-  function normalizeInput(data, type) {
-    const isHeterogeneousType = Boolean(data.points || data.lines || data.polygons);
-    if (!isHeterogeneousType) {
-      data.type = type || parseType(data);
-      return [data];
-    }
-    const features = [];
-    if (data.points) {
-      data.points.type = "Point";
-      features.push(data.points);
-    }
-    if (data.lines) {
-      data.lines.type = "LineString";
-      features.push(data.lines);
-    }
-    if (data.polygons) {
-      data.polygons.type = "Polygon";
-      features.push(data.polygons);
-    }
-    return features;
-  }
-  function parseFeatureCollection(dataArray) {
-    const features = [];
-    for (const data of dataArray) {
-      if (data.featureIds.value.length === 0) {
-        continue;
-      }
-      let lastIndex = 0;
-      let lastValue = data.featureIds.value[0];
-      for (let i = 0; i < data.featureIds.value.length; i++) {
-        const currValue = data.featureIds.value[i];
-        if (currValue === lastValue) {
-          continue;
-        }
-        features.push(parseFeature(data, lastIndex, i));
-        lastIndex = i;
-        lastValue = currValue;
-      }
-      features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
-    }
-    return features;
-  }
-  function parseFeature(data, startIndex, endIndex) {
-    const geometry = binaryToGeometry(data, startIndex, endIndex);
-    const properties = parseProperties(data, startIndex, endIndex);
-    const fields = parseFields(data, startIndex, endIndex);
-    return {
-      type: "Feature",
-      geometry,
-      properties,
-      ...fields
-    };
-  }
-  function parseFields(data) {
-    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
-    let endIndex = arguments.length > 2 ? arguments[2] : void 0;
-    return data.fields && data.fields[data.featureIds.value[startIndex]];
-  }
-  function parseProperties(data) {
-    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
-    let endIndex = arguments.length > 2 ? arguments[2] : void 0;
-    const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
-    for (const key in data.numericProps) {
-      properties[key] = data.numericProps[key].value[startIndex];
-    }
-    return properties;
-  }
-  function polygonToGeoJson(data) {
-    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : -Infinity;
-    let endIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Infinity;
-    const {
-      positions
-    } = data;
-    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const multi = polygonIndices.length > 2;
-    if (!multi) {
-      const coordinates2 = [];
-      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-        const startRingIndex = primitivePolygonIndices[i];
-        const endRingIndex = primitivePolygonIndices[i + 1];
-        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-        coordinates2.push(ringCoordinates);
-      }
-      return {
-        type: "Polygon",
-        coordinates: coordinates2
-      };
-    }
-    const coordinates = [];
-    for (let i = 0; i < polygonIndices.length - 1; i++) {
-      const startPolygonIndex = polygonIndices[i];
-      const endPolygonIndex = polygonIndices[i + 1];
-      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
-      coordinates.push(polygonCoordinates);
-    }
-    return {
-      type: "MultiPolygon",
-      coordinates
-    };
-  }
-  function lineStringToGeoJson(data) {
-    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : -Infinity;
-    let endIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Infinity;
-    const {
-      positions
-    } = data;
-    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const multi = pathIndices.length > 2;
-    if (!multi) {
-      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-      return {
-        type: "LineString",
-        coordinates: coordinates2
-      };
-    }
-    const coordinates = [];
-    for (let i = 0; i < pathIndices.length - 1; i++) {
-      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-      coordinates.push(ringCoordinates);
-    }
-    return {
-      type: "MultiLineString",
-      coordinates
-    };
-  }
-  function pointToGeoJson(data, startIndex, endIndex) {
-    const {
-      positions
-    } = data;
-    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-    const multi = coordinates.length > 1;
-    if (multi) {
-      return {
-        type: "MultiPoint",
-        coordinates
-      };
-    }
-    return {
-      type: "Point",
-      coordinates: coordinates[0]
-    };
-  }
-  function ringToGeoJson(positions, startIndex, endIndex) {
-    startIndex = startIndex || 0;
-    endIndex = endIndex || positions.value.length / positions.size;
-    const ringCoordinates = [];
-    for (let j = startIndex; j < endIndex; j++) {
-      const coord = Array();
-      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-        coord.push(Number(positions.value[k]));
-      }
-      ringCoordinates.push(coord);
-    }
-    return ringCoordinates;
-  }
-  function parseType(data) {
-    if (data.pathIndices) {
-      return "LineString";
-    }
-    if (data.polygonIndices) {
-      return "Polygon";
-    }
-    return "Point";
-  }
-
-  // src/layers/carto-tile-layer.ts
-  (0, import_core.registerLoaders)([carto_vector_tile_loader_default]);
-  var defaultTileFormat = TILE_FORMATS.BINARY;
-  var defaultProps = {
-    ...import_geo_layers.MVTLayer.defaultProps,
-    formatTiles: defaultTileFormat
-  };
-  var CartoTileLayer = class extends import_geo_layers.MVTLayer {
-    initializeState() {
-      super.initializeState();
-      const binary = this.props.formatTiles === TILE_FORMATS.BINARY;
-      this.setState({
-        binary
-      });
-    }
-    getTileData(tile) {
-      const url = (0, import_geo_layers._getURLFromTemplate)(this.state.data, tile);
-      if (!url) {
-        return Promise.reject("Invalid URL");
-      }
-      let loadOptions = this.getLoadOptions();
-      const {
-        fetch: fetch2,
-        formatTiles
-      } = this.props;
-      const {
-        signal
-      } = tile;
-      if (formatTiles === TILE_FORMATS.BINARY) {
-        loadOptions = {
-          ...loadOptions,
-          mimeType: "application/vnd.carto-vector-tile"
-        };
-      }
-      return fetch2(url, {
-        propName: "data",
-        layer: this,
-        loadOptions,
-        signal
-      });
-    }
-    renderSubLayers(props) {
-      if (props.data === null) {
-        return null;
-      }
-      const tileBbox = props.tile.bbox;
-      const {
-        west,
-        south,
-        east,
-        north
-      } = tileBbox;
-      const subLayerProps = {
-        ...props,
-        autoHighlight: false,
-        extensions: [new import_extensions.ClipExtension(), ...props.extensions || []],
-        clipBounds: [west, south, east, north]
-      };
-      const subLayer = new import_layers.GeoJsonLayer(subLayerProps);
-      return subLayer;
-    }
-    getPickingInfo(params) {
-      const info = super.getPickingInfo(params);
-      if (this.state.binary && info.index !== -1) {
-        const {
-          data
-        } = params.sourceLayer.props;
-        info.object = binaryToGeojson(data, {
-          globalFeatureId: info.index
-        });
-      }
-      return info;
-    }
-  };
-  __publicField(CartoTileLayer, "layerName", "CartoTileLayer");
-  __publicField(CartoTileLayer, "defaultProps", defaultProps);
-
-  // src/layers/h3-tile-layer.ts
-  var import_core3 = __toESM(require_core());
-  var import_geo_layers4 = __toESM(require_geo_layers());
-
-  // src/layers/h3-tileset-2d.ts
-  var import_geo_layers2 = __toESM(require_geo_layers());
-  var import_h3_js = __toESM(require_h3_js());
-  function getHexagonsInBoundingBox({
-    west,
-    north,
-    east,
-    south
-  }, resolution) {
-    const longitudeSpan = Math.abs(east - west);
-    if (longitudeSpan > 180) {
-      const nSegments = Math.ceil(longitudeSpan / 180);
-      let h3Indices2 = [];
-      for (let s = 0; s < nSegments; s++) {
-        const segmentEast = east + s * 180;
-        const segmentWest = Math.min(segmentEast + 179.9999999, west);
-        h3Indices2 = h3Indices2.concat(getHexagonsInBoundingBox({
-          west: segmentWest,
-          north,
-          east: segmentEast,
-          south
-        }, resolution));
-      }
-      return [...new Set(h3Indices2)];
-    }
-    const oversample = 2;
-    const h3Indices = (0, import_h3_js.polygonToCells)([[[west, north], [west, south], [east, south], [east, north], [west, north]]], resolution + oversample, true);
-    return oversample ? [...new Set(h3Indices.map((i) => (0, import_h3_js.cellToParent)(i, resolution)))] : h3Indices;
-  }
-  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) {
-    const hexagonScaleFactor = 2 / 3 * viewport.zoom;
-    const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
-    return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
-  }
-  var H3Tileset2D = class extends import_geo_layers2._Tileset2D {
-    getTileIndices({
-      viewport,
-      minZoom,
-      maxZoom
-    }) {
-      if (viewport.latitude === void 0)
-        return [];
-      const [east, south, west, north] = viewport.getBounds();
-      let z = getHexagonResolution(viewport);
-      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 {
-        indices = getHexagonsInBoundingBox({
-          west,
-          north,
-          east,
-          south
-        }, 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
-      };
-    }
-  };
-
-  // 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) {
-      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 TileReader3 = class {
-    static read(pbf, end) {
-      return pbf.readFields(TileReader3._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);
-    }
-  };
-
-  // ../../node_modules/quadbin/dist/esm/index.js
-  var import_tile_cover = __toESM(require_tile_cover());
-  var B = [
-    0x5555555555555555n,
-    0x3333333333333333n,
-    0x0f0f0f0f0f0f0f0fn,
-    0x00ff00ff00ff00ffn,
-    0x0000ffff0000ffffn,
-    0x00000000ffffffffn
-  ];
-  var S = [0n, 1n, 2n, 4n, 8n, 16n];
-  function hexToBigInt(hex2) {
-    return BigInt(`0x${hex2}`);
-  }
-  function bigIntToHex(index) {
-    return index.toString(16);
-  }
-  function tileToCell(tile) {
-    if (tile.z < 0 || tile.z > 26) {
-      throw new Error("Wrong zoom");
+  function tileToCell(tile) {
+    if (tile.z < 0 || tile.z > 26) {
+      throw new Error("Wrong zoom");
     }
     const z = BigInt(tile.z);
     let x = BigInt(tile.x) << 32n - z;
@@ -12346,7 +12536,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const count = cells.indices.value.length;
     const spatial = [];
     for (let i = 0; i < count; i++) {
-      const id = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
+      const id4 = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
       const properties = {
         ...cells.properties[i]
       };
@@ -12354,7 +12544,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         properties[key] = cells.numericProps[key].value[i];
       }
       spatial.push({
-        id,
+        id: id4,
         properties
       });
     }
@@ -12362,22 +12552,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/schema/carto-spatial-tile-loader.ts
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id2 = "cartoSpatialTile";
+  var DEFAULT_OPTIONS2 = {
+    cartoSpatialTile: {
+      scheme: "quadbin",
+      workerUrl: getWorkerUrl(id2, VERSION2)
+    }
+  };
   var CartoSpatialTileLoader = {
     name: "CARTO Spatial Tile",
-    version: "1",
-    id: "cartoSpatialTile",
+    version: VERSION2,
+    id: id2,
     module: "carto",
     extensions: ["pbf"],
     mimeTypes: ["application/vnd.carto-spatial-tile"],
     category: "geometry",
-    worker: false,
     parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
     parseSync: parseCartoSpatialTile,
-    options: {
-      cartoSpatialTile: {
-        scheme: "quadbin"
-      }
-    }
+    worker: true,
+    options: DEFAULT_OPTIONS2
   };
   function parseCartoSpatialTile(arrayBuffer, options) {
     if (!arrayBuffer)
@@ -12396,15 +12590,15 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
 
   // src/layers/spatial-index-tile-layer.ts
-  var import_geo_layers3 = __toESM(require_geo_layers());
+  var import_geo_layers2 = __toESM(require_geo_layers());
   (0, import_core2.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
   function isFeatureIdDefined(value) {
     return value !== void 0 && value !== null && value !== "";
   }
-  var defaultProps2 = {
+  var defaultProps = {
     aggregationResLevel: 4
   };
-  var SpatialIndexTileLayer = class extends import_geo_layers3.TileLayer {
+  var SpatialIndexTileLayer = class extends import_geo_layers2.TileLayer {
     updateState(params) {
       const {
         props,
@@ -12475,7 +12669,47 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(SpatialIndexTileLayer, "layerName", "SpatialIndexTileLayer");
-  __publicField(SpatialIndexTileLayer, "defaultProps", defaultProps2);
+  __publicField(SpatialIndexTileLayer, "defaultProps", defaultProps);
+
+  // src/sources/common.ts
+  var SOURCE_DEFAULTS = {
+    apiBaseUrl: "https://gcp-us-east1.api.carto.com",
+    clientId: "deck-gl-carto",
+    format: "tilejson",
+    formatTiles: "binary",
+    headers: {}
+  };
+  var DEFAULT_CLIENT = "deck-gl-carto";
+  var V3_MINOR_VERSION = "3.2";
+  var MAX_GET_LENGTH = 8192;
+  var DEFAULT_PARAMETERS = {
+    client: DEFAULT_CLIENT,
+    v: V3_MINOR_VERSION
+  };
+  var DEFAULT_HEADERS = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  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"),
+    compare: 2,
+    async: true
+  };
+
+  // src/layers/utils.ts
+  function injectAccessToken(loadOptions, accessToken) {
+    if (!loadOptions?.fetch?.headers?.Authorization) {
+      loadOptions.fetch = {
+        ...loadOptions.fetch,
+        headers: {
+          ...loadOptions.fetch?.headers,
+          Authorization: `Bearer ${accessToken}`
+        }
+      };
+    }
+  }
 
   // src/layers/h3-tile-layer.ts
   var renderSubLayers = (props) => {
@@ -12487,45 +12721,41 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     } = props.tile;
     if (!data || !data.length)
       return null;
-    return new import_geo_layers4.H3HexagonLayer(props, {
+    return new import_geo_layers3.H3HexagonLayer(props, {
       getHexagon: (d) => d.id,
       centerHexagon: index,
       highPrecision: true
     });
   };
-  var defaultProps3 = {
-    aggregationResLevel: 4
+  var defaultProps2 = {
+    aggregationResLevel: 4,
+    data: TilejsonPropType
   };
   var H3TileLayer = class extends import_core3.CompositeLayer {
     initializeState() {
-      import_geo_layers4.H3HexagonLayer._checkH3Lib();
-      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
-        });
-      }
+      import_geo_layers3.H3HexagonLayer._checkH3Lib();
+    }
+    getLoadOptions() {
+      const loadOptions = super.getLoadOptions() || {};
+      const tileJSON = this.props.data;
+      injectAccessToken(loadOptions, tileJSON.accessToken);
+      loadOptions.cartoSpatialTile = {
+        ...loadOptions.cartoSpatialTile,
+        scheme: "h3"
+      };
+      return loadOptions;
     }
     renderLayers() {
+      const tileJSON = this.props.data;
+      if (!tileJSON)
+        return null;
       const {
-        data,
-        tileJSON
-      } = this.state;
-      let minresolution = parseInt(tileJSON.minresolution);
-      let maxresolution = parseInt(tileJSON.maxresolution);
+        tiles: data
+      } = tileJSON;
+      let {
+        minresolution,
+        maxresolution
+      } = tileJSON;
       if (this.props.minZoom) {
         minresolution = Math.max(minresolution, getHexagonResolution({
           zoom: this.props.minZoom,
@@ -12538,31 +12768,27 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           latitude: 0
         }));
       }
-      return [new SpatialIndexTileLayer(this.props, {
-        id: `h3-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: H3Tileset2D,
-        renderSubLayers,
-        minZoom: minresolution,
-        maxZoom: maxresolution,
-        loadOptions: {
-          ...this.getLoadOptions(),
-          cartoSpatialTile: {
-            scheme: "h3"
-          },
-          mimeType: "application/vnd.carto-spatial-tile"
-        }
-      })];
+      return [
+        new SpatialIndexTileLayer(this.props, {
+          id: `h3-tile-layer-${this.props.id}`,
+          data,
+          TilesetClass: H3Tileset2D,
+          renderSubLayers,
+          minZoom: minresolution,
+          maxZoom: maxresolution,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
     }
   };
   __publicField(H3TileLayer, "layerName", "H3TileLayer");
-  __publicField(H3TileLayer, "defaultProps", defaultProps3);
+  __publicField(H3TileLayer, "defaultProps", defaultProps2);
 
   // src/layers/quadbin-tile-layer.ts
   var import_core4 = __toESM(require_core());
 
   // src/layers/quadbin-layer.ts
-  var import_geo_layers5 = __toESM(require_geo_layers());
+  var import_geo_layers4 = __toESM(require_geo_layers());
 
   // ../../node_modules/@math.gl/web-mercator/dist/esm/web-mercator-utils.js
   var PI = Math.PI;
@@ -12603,13 +12829,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/quadbin-layer.ts
-  var defaultProps4 = {
+  var defaultProps3 = {
     getQuadbin: {
       type: "accessor",
       value: (d) => d.quadbin
     }
   };
-  var QuadbinLayer = class extends import_geo_layers5._GeoCellLayer {
+  var QuadbinLayer = class extends import_geo_layers4._GeoCellLayer {
     indexToBounds() {
       const {
         data,
@@ -12629,11 +12855,11 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(QuadbinLayer, "layerName", "QuadbinLayer");
-  __publicField(QuadbinLayer, "defaultProps", defaultProps4);
+  __publicField(QuadbinLayer, "defaultProps", defaultProps3);
 
   // src/layers/quadbin-tileset-2d.ts
-  var import_geo_layers6 = __toESM(require_geo_layers());
-  var QuadbinTileset2D = class extends import_geo_layers6._Tileset2D {
+  var import_geo_layers5 = __toESM(require_geo_layers());
+  var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
     getTileIndices(opts) {
       return super.getTileIndices(opts).map(tileToCell).map((q) => ({
         q,
@@ -12677,62 +12903,50 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       getQuadbin: isBigInt ? (d) => d.id : (d) => hexToBigInt(d.id)
     });
   };
-  var defaultProps5 = {
-    aggregationResLevel: 6
+  var defaultProps4 = {
+    aggregationResLevel: 6,
+    data: TilejsonPropType
   };
   var QuadbinTileLayer = class extends import_core4.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
-        });
-      }
+    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 {
-        data,
-        tileJSON
-      } = this.state;
-      const maxZoom = parseInt(tileJSON?.maxresolution);
-      return [new SpatialIndexTileLayer(this.props, {
-        id: `quadbin-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: QuadbinTileset2D,
-        renderSubLayers: renderSubLayers2,
-        maxZoom,
-        loadOptions: {
-          ...this.getLoadOptions(),
-          cartoSpatialTile: {
-            scheme: "quadbin"
-          },
-          mimeType: "application/vnd.carto-spatial-tile"
-        }
-      })];
+        tiles: data,
+        maxresolution: maxZoom
+      } = tileJSON;
+      return [
+        new SpatialIndexTileLayer(this.props, {
+          id: `quadbin-tile-layer-${this.props.id}`,
+          data,
+          TilesetClass: QuadbinTileset2D,
+          renderSubLayers: renderSubLayers2,
+          maxZoom,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
     }
   };
   __publicField(QuadbinTileLayer, "layerName", "QuadbinTileLayer");
-  __publicField(QuadbinTileLayer, "defaultProps", defaultProps5);
+  __publicField(QuadbinTileLayer, "defaultProps", defaultProps4);
 
   // src/layers/raster-tile-layer.ts
-  var import_core7 = __toESM(require_core());
+  var import_core6 = __toESM(require_core());
 
   // src/layers/raster-layer.ts
-  var import_core6 = __toESM(require_core());
-  var import_layers2 = __toESM(require_layers());
+  var import_core5 = __toESM(require_core());
+  var import_layers = __toESM(require_layers());
 
   // src/layers/raster-layer-vertex.glsl.ts
   var raster_layer_vertex_glsl_default = `#version 300 es
@@ -12833,37 +13047,14 @@ void main(void) {
 }
 `;
 
-  // 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,
+  var defaultProps5 = {
+    ...import_layers.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 {
+  var RasterColumnLayer = class extends import_layers.ColumnLayer {
     getShaders() {
       const shaders = super.getShaders();
       return {
@@ -12899,7 +13090,7 @@ void main(void) {
     }
   };
   __publicField(RasterColumnLayer, "layerName", "RasterColumnLayer");
-  var RasterLayer = class extends import_core6.CompositeLayer {
+  var RasterLayer = class extends import_core5.CompositeLayer {
     renderLayers() {
       const {
         data,
@@ -12916,7 +13107,7 @@ void main(void) {
         blockWidth,
         blockHeight
       } = data;
-      assert2(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
+      assert(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);
@@ -12951,60 +13142,443 @@ void main(void) {
         }, info);
       };
     }
-  };
-  __publicField(RasterLayer, "layerName", "RasterLayer");
-  __publicField(RasterLayer, "defaultProps", defaultProps6);
+  };
+  __publicField(RasterLayer, "layerName", "RasterLayer");
+  __publicField(RasterLayer, "defaultProps", defaultProps5);
+
+  // 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 defaultProps6 = {
+    data: TilejsonPropType
+  };
+  var RasterTileLayer = class extends import_core6.CompositeLayer {
+    getLoadOptions() {
+      const loadOptions = super.getLoadOptions() || {};
+      const tileJSON = this.props.data;
+      injectAccessToken(loadOptions, tileJSON.accessToken);
+      return loadOptions;
+    }
+    renderLayers() {
+      const tileJSON = this.props.data;
+      if (!tileJSON)
+        return null;
+      const {
+        tiles: data,
+        minzoom: minZoom,
+        maxzoom: maxZoom
+      } = tileJSON;
+      return [
+        new SpatialIndexTileLayer(this.props, {
+          id: `raster-tile-layer-${this.props.id}`,
+          data,
+          TilesetClass: QuadbinTileset2D,
+          renderSubLayers: renderSubLayers3,
+          minZoom,
+          maxZoom,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
+    }
+  };
+  __publicField(RasterTileLayer, "layerName", "RasterTileLayer");
+  __publicField(RasterTileLayer, "defaultProps", defaultProps6);
+
+  // src/layers/vector-tile-layer.ts
+  var import_core7 = __toESM(require_core2());
+
+  // src/layers/schema/carto-vector-tile-loader.ts
+  var import_earcut = __toESM(require_earcut());
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id3 = "cartoVectorTile";
+  var DEFAULT_OPTIONS3 = {
+    cartoVectorTile: {
+      workerUrl: getWorkerUrl(id3, VERSION3)
+    }
+  };
+  var CartoVectorTileLoader = {
+    name: "CARTO Vector Tile",
+    version: VERSION3,
+    id: id3,
+    module: "carto",
+    extensions: ["pbf"],
+    mimeTypes: ["application/vnd.carto-vector-tile"],
+    category: "geometry",
+    parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),
+    parseSync: parseCartoVectorTile,
+    worker: true,
+    options: DEFAULT_OPTIONS3
+  };
+  function triangulatePolygon(polygons, target, {
+    startPosition,
+    endPosition,
+    indices
+  }) {
+    const coordLength = polygons.positions.size;
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    const polygonPositions = polygons.positions.value.subarray(start, end);
+    const holes = indices.slice(1).map((n) => n - startPosition);
+    const triangles = (0, import_earcut.default)(polygonPositions, holes, coordLength);
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+      target.push(startPosition + triangles[t]);
+    }
+  }
+  function triangulate(polygons) {
+    const {
+      polygonIndices,
+      positions,
+      primitivePolygonIndices
+    } = polygons;
+    const triangles = [];
+    let rangeStart = 0;
+    for (let i = 0; i < polygonIndices.value.length - 1; i++) {
+      const startPosition = polygonIndices.value[i];
+      const endPosition = polygonIndices.value[i + 1];
+      const rangeEnd = primitivePolygonIndices.value.indexOf(endPosition);
+      const indices = primitivePolygonIndices.value.subarray(rangeStart, rangeEnd);
+      rangeStart = rangeEnd;
+      triangulatePolygon(polygons, triangles, {
+        startPosition,
+        endPosition,
+        indices
+      });
+    }
+    polygons.triangles = {
+      value: new Uint32Array(triangles),
+      size: 1
+    };
+  }
+  function parseCartoVectorTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+      return null;
+    const tile = parsePbf(arrayBuffer, TileReader2);
+    if (tile.polygons && !tile.polygons.triangles) {
+      triangulate(tile.polygons);
+    }
+    return tile;
+  }
+  var carto_vector_tile_loader_default = CartoVectorTileLoader;
+
+  // src/layers/vector-tile-layer.ts
+  var import_extensions = __toESM(require_extensions());
+  var import_geo_layers6 = __toESM(require_geo_layers());
+  var import_layers2 = __toESM(require_layers());
+
+  // ../../node_modules/@loaders.gl/gis/dist/esm/lib/binary-to-geojson.js
+  function binaryToGeojson(data, options) {
+    const globalFeatureId = options === null || options === void 0 ? void 0 : options.globalFeatureId;
+    if (globalFeatureId !== void 0) {
+      return getSingleFeature(data, globalFeatureId);
+    }
+    return parseFeatures(data, options === null || options === void 0 ? void 0 : options.type);
+  }
+  function getSingleFeature(data, globalFeatureId) {
+    const dataArray = normalizeInput(data);
+    for (const data2 of dataArray) {
+      let lastIndex = 0;
+      let lastValue = data2.featureIds.value[0];
+      for (let i = 0; i < data2.featureIds.value.length; i++) {
+        const currValue = data2.featureIds.value[i];
+        if (currValue === lastValue) {
+          continue;
+        }
+        if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+          return parseFeature(data2, lastIndex, i);
+        }
+        lastIndex = i;
+        lastValue = currValue;
+      }
+      if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+        return parseFeature(data2, lastIndex, data2.featureIds.value.length);
+      }
+    }
+    throw new Error("featureId:".concat(globalFeatureId, " not found"));
+  }
+  function parseFeatures(data, type) {
+    const dataArray = normalizeInput(data, type);
+    return parseFeatureCollection(dataArray);
+  }
+  function binaryToGeometry(data, startIndex, endIndex) {
+    switch (data.type) {
+      case "Point":
+        return pointToGeoJson(data, startIndex, endIndex);
+      case "LineString":
+        return lineStringToGeoJson(data, startIndex, endIndex);
+      case "Polygon":
+        return polygonToGeoJson(data, startIndex, endIndex);
+      default:
+        const unexpectedInput = data;
+        throw new Error("Unsupported geometry type: ".concat(unexpectedInput === null || unexpectedInput === void 0 ? void 0 : unexpectedInput.type));
+    }
+  }
+  function normalizeInput(data, type) {
+    const isHeterogeneousType = Boolean(data.points || data.lines || data.polygons);
+    if (!isHeterogeneousType) {
+      data.type = type || parseType(data);
+      return [data];
+    }
+    const features = [];
+    if (data.points) {
+      data.points.type = "Point";
+      features.push(data.points);
+    }
+    if (data.lines) {
+      data.lines.type = "LineString";
+      features.push(data.lines);
+    }
+    if (data.polygons) {
+      data.polygons.type = "Polygon";
+      features.push(data.polygons);
+    }
+    return features;
+  }
+  function parseFeatureCollection(dataArray) {
+    const features = [];
+    for (const data of dataArray) {
+      if (data.featureIds.value.length === 0) {
+        continue;
+      }
+      let lastIndex = 0;
+      let lastValue = data.featureIds.value[0];
+      for (let i = 0; i < data.featureIds.value.length; i++) {
+        const currValue = data.featureIds.value[i];
+        if (currValue === lastValue) {
+          continue;
+        }
+        features.push(parseFeature(data, lastIndex, i));
+        lastIndex = i;
+        lastValue = currValue;
+      }
+      features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
+    }
+    return features;
+  }
+  function parseFeature(data, startIndex, endIndex) {
+    const geometry = binaryToGeometry(data, startIndex, endIndex);
+    const properties = parseProperties(data, startIndex, endIndex);
+    const fields = parseFields(data, startIndex, endIndex);
+    return {
+      type: "Feature",
+      geometry,
+      properties,
+      ...fields
+    };
+  }
+  function parseFields(data) {
+    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+    let endIndex = arguments.length > 2 ? arguments[2] : void 0;
+    return data.fields && data.fields[data.featureIds.value[startIndex]];
+  }
+  function parseProperties(data) {
+    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+    let endIndex = arguments.length > 2 ? arguments[2] : void 0;
+    const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
+    for (const key in data.numericProps) {
+      properties[key] = data.numericProps[key].value[startIndex];
+    }
+    return properties;
+  }
+  function polygonToGeoJson(data) {
+    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : -Infinity;
+    let endIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Infinity;
+    const {
+      positions
+    } = data;
+    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = polygonIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = [];
+      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+        const startRingIndex = primitivePolygonIndices[i];
+        const endRingIndex = primitivePolygonIndices[i + 1];
+        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+        coordinates2.push(ringCoordinates);
+      }
+      return {
+        type: "Polygon",
+        coordinates: coordinates2
+      };
+    }
+    const coordinates = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startPolygonIndex = polygonIndices[i];
+      const endPolygonIndex = polygonIndices[i + 1];
+      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+      coordinates.push(polygonCoordinates);
+    }
+    return {
+      type: "MultiPolygon",
+      coordinates
+    };
+  }
+  function lineStringToGeoJson(data) {
+    let startIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : -Infinity;
+    let endIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Infinity;
+    const {
+      positions
+    } = data;
+    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = pathIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+      return {
+        type: "LineString",
+        coordinates: coordinates2
+      };
+    }
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
+    }
+    return {
+      type: "MultiLineString",
+      coordinates
+    };
+  }
+  function pointToGeoJson(data, startIndex, endIndex) {
+    const {
+      positions
+    } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+      return {
+        type: "MultiPoint",
+        coordinates
+      };
+    }
+    return {
+      type: "Point",
+      coordinates: coordinates[0]
+    };
+  }
+  function ringToGeoJson(positions, startIndex, endIndex) {
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+      const coord = Array();
+      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+        coord.push(Number(positions.value[k]));
+      }
+      ringCoordinates.push(coord);
+    }
+    return ringCoordinates;
+  }
+  function parseType(data) {
+    if (data.pathIndices) {
+      return "LineString";
+    }
+    if (data.polygonIndices) {
+      return "Polygon";
+    }
+    return "Point";
+  }
 
-  // src/layers/raster-tile-layer.ts
-  var renderSubLayers3 = (props) => {
-    const tileIndex = props.tile?.index?.q;
-    if (!tileIndex)
-      return null;
-    return new RasterLayer(props, {
-      tileIndex
-    });
+  // src/layers/vector-tile-layer.ts
+  (0, import_core7.registerLoaders)([carto_vector_tile_loader_default]);
+  var defaultTileFormat = TILE_FORMATS.BINARY;
+  var defaultProps7 = {
+    ...import_geo_layers6.MVTLayer.defaultProps,
+    data: TilejsonPropType,
+    formatTiles: defaultTileFormat
   };
-  var RasterTileLayer = class extends import_core7.CompositeLayer {
+  var VectorTileLayer = class extends import_geo_layers6.MVTLayer {
     initializeState() {
+      super.initializeState();
+      const binary = this.props.formatTiles === TILE_FORMATS.BINARY || TILE_FORMATS.MVT;
       this.setState({
-        data: null,
-        tileJSON: null
+        binary
       });
     }
-    updateState({
-      changeFlags
-    }) {
-      if (changeFlags.dataChanged) {
-        let {
-          data
-        } = this.props;
-        const tileJSON = data;
-        data = tileJSON.tiles;
+    updateState(parameters) {
+      const {
+        props
+      } = parameters;
+      if (props.data) {
+        super.updateState(parameters);
+        const formatTiles = new URL(props.data.tiles[0]).searchParams.get("formatTiles");
+        const mvt = formatTiles === TILE_FORMATS.MVT;
         this.setState({
-          data,
-          tileJSON
+          mvt
         });
       }
     }
-    renderLayers() {
+    getLoadOptions() {
+      const loadOptions = super.getLoadOptions() || {};
+      const tileJSON = this.props.data;
+      injectAccessToken(loadOptions, tileJSON.accessToken);
+      loadOptions.gis = {
+        format: "binary"
+      };
+      return loadOptions;
+    }
+    getTileData(tile) {
+      const url = (0, import_geo_layers6._getURLFromTemplate)(this.state.data, tile);
+      if (!url) {
+        return Promise.reject("Invalid URL");
+      }
+      const loadOptions = this.getLoadOptions();
       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
-      })];
+        fetch: fetch2
+      } = this.props;
+      const {
+        signal
+      } = tile;
+      return fetch2(url, {
+        propName: "data",
+        layer: this,
+        loadOptions,
+        signal
+      });
+    }
+    renderSubLayers(props) {
+      if (props.data === null) {
+        return null;
+      }
+      if (this.state.mvt) {
+        return super.renderSubLayers(props);
+      }
+      const tileBbox = props.tile.bbox;
+      const {
+        west,
+        south,
+        east,
+        north
+      } = tileBbox;
+      const subLayerProps = {
+        ...props,
+        autoHighlight: false,
+        extensions: [new import_extensions.ClipExtension(), ...props.extensions || []],
+        clipBounds: [west, south, east, north]
+      };
+      const subLayer = new import_layers2.GeoJsonLayer(subLayerProps);
+      return subLayer;
+    }
+    getPickingInfo(params) {
+      const info = super.getPickingInfo(params);
+      if (this.state.binary && info.index !== -1) {
+        const {
+          data
+        } = params.sourceLayer.props;
+        info.object = binaryToGeojson(data, {
+          globalFeatureId: info.index
+        });
+      }
+      return info;
     }
   };
-  __publicField(RasterTileLayer, "layerName", "RasterTileLayer");
-  __publicField(RasterTileLayer, "defaultProps", {});
+  __publicField(VectorTileLayer, "layerName", "VectorTileLayer");
+  __publicField(VectorTileLayer, "defaultProps", defaultProps7);
 
   // src/api/layer-map.ts
   var SCALE_FUNCS = {
@@ -13086,7 +13660,7 @@ void main(void) {
     elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
     percentile: ["lowerPercentile", "upperPercentile"]
   };
-  var defaultProps7 = {
+  var defaultProps8 = {
     lineMiterLimit: 2,
     lineWidthUnits: "pixels",
     pointRadiusUnits: "pixels",
@@ -13187,12 +13761,12 @@ void main(void) {
       }
     };
     const layer = layerTypeDefs[type];
-    assert2(layer, `Unsupported layer type: ${type}`);
+    assert(layer, `Unsupported layer type: ${type}`);
     return {
       ...layer,
       propMap: mergePropMaps(basePropMap, layer.propMap),
       defaultProps: {
-        ...defaultProps7,
+        ...defaultProps8,
         ...layer.defaultProps
       }
     };
@@ -13207,10 +13781,7 @@ void main(void) {
     if (scheme === "quadbin") {
       return QuadbinTileLayer;
     }
-    if (formatTiles === "mvt") {
-      return import_geo_layers7.MVTLayer;
-    }
-    return CartoTileLayer;
+    return VectorTileLayer;
   }
   function getTileLayer(dataset, basePropMap) {
     const {
@@ -13226,7 +13797,7 @@ void main(void) {
       Layer: layerFromTileDataset(formatTiles, scheme),
       propMap: basePropMap,
       defaultProps: {
-        ...defaultProps7,
+        ...defaultProps8,
         ...aggregationExp && {
           aggregationExp
         },
@@ -13485,7 +14056,7 @@ void main(void) {
     }
   };
   __publicField(EnhancedTextLayer, "layerName", "EnhancedTextLayer");
-  var defaultProps8 = {
+  var defaultProps9 = {
     ...import_layers4.TextLayer.defaultProps,
     getRadius: {
       type: "accessor",
@@ -13552,7 +14123,7 @@ void main(void) {
       }
       return backgroundPadding;
     }
-    renderTextLayer(id, {
+    renderTextLayer(id4, {
       updateTriggers: updateTriggersOverride = {},
       ...props
     }) {
@@ -13573,7 +14144,7 @@ void main(void) {
         updateTriggers
       } = this.props;
       return new EnhancedTextLayer(this.getSubLayerProps({
-        id,
+        id: id4,
         data,
         characterSet,
         fontFamily,
@@ -13637,7 +14208,7 @@ void main(void) {
     }
   };
   __publicField(PointLabelLayer, "layerName", "PointLabelLayer");
-  __publicField(PointLabelLayer, "defaultProps", defaultProps8);
+  __publicField(PointLabelLayer, "defaultProps", defaultProps9);
 
   // src/api/parseMap.ts
   var import_core9 = __toESM(require_core());
@@ -13649,7 +14220,7 @@ void main(void) {
       datasets,
       token
     } = json;
-    assert2(keplerMapConfig.version === "v1", "Only support Kepler v1");
+    assert(keplerMapConfig.version === "v1", "Only support Kepler v1");
     const {
       mapState,
       mapStyle
@@ -13669,7 +14240,7 @@ void main(void) {
       mapStyle,
       token,
       layers: layers.reverse().map(({
-        id,
+        id: id4,
         type,
         config,
         visualChannels
@@ -13679,24 +14250,24 @@ void main(void) {
             dataId
           } = config;
           const dataset = datasets.find((d) => d.id === dataId);
-          assert2(dataset, `No dataset matching dataId: ${dataId}`);
+          assert(dataset, `No dataset matching dataId: ${dataId}`);
           const {
             data
           } = dataset;
-          assert2(data, `No data loaded for dataId: ${dataId}`);
+          assert(data, `No data loaded for dataId: ${dataId}`);
           const {
             Layer,
             propMap,
-            defaultProps: defaultProps10
+            defaultProps: defaultProps11
           } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
           return new Layer({
-            id,
+            id: id4,
             data,
-            ...defaultProps10,
+            ...defaultProps11,
             ...createInteractionProps(interactionConfig),
             ...styleProps,
-            ...createChannelProps(id, type, config, visualChannels, data),
+            ...createChannelProps(id4, type, config, visualChannels, data),
             ...createParametersProp(layerBlending, styleProps.parameters || {}),
             ...createLoadOptions(token)
           });
@@ -13761,7 +14332,7 @@ void main(void) {
     result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
     return result;
   }
-  function createChannelProps(id, type, config, visualChannels, data) {
+  function createChannelProps(id4, type, config, visualChannels, data) {
     const {
       colorField,
       colorScale,
@@ -13914,7 +14485,7 @@ void main(void) {
     }
     if (textLabel && textLabel.length && textLabel[0].field) {
       const [mainLabel, secondaryLabel] = textLabel;
-      const collisionGroup = id;
+      const collisionGroup = id4;
       ({
         alignment: result.getTextAlignmentBaseline,
         anchor: result.getTextAnchor,
@@ -13975,9 +14546,9 @@ void main(void) {
 
   // src/api/maps-v3-client.ts
   var import_core10 = __toESM(require_core());
-  var MAX_GET_LENGTH = 8192;
-  var DEFAULT_CLIENT = "deck-gl-carto";
-  var V3_MINOR_VERSION = "3.1";
+  var MAX_GET_LENGTH2 = 8192;
+  var DEFAULT_CLIENT2 = "deck-gl-carto";
+  var V3_MINOR_VERSION2 = "3.2";
   async function request2({
     method,
     url,
@@ -14043,15 +14614,6 @@ void main(void) {
     body,
     errorContext
   }) {
-    if (format2 === FORMATS.NDJSON) {
-      return request2({
-        method,
-        url,
-        accessToken,
-        body,
-        errorContext
-      });
-    }
     const data = await requestJson({
       method,
       url,
@@ -14072,8 +14634,8 @@ void main(void) {
     queryParameters
   }) {
     const parameters = {
-      client: clientId || DEFAULT_CLIENT,
-      v: V3_MINOR_VERSION
+      client: clientId || DEFAULT_CLIENT2,
+      v: V3_MINOR_VERSION2
     };
     const sourceName = type === MAP_TYPES.QUERY ? "q" : "name";
     parameters[sourceName] = source;
@@ -14140,7 +14702,7 @@ void main(void) {
       type,
       source
     };
-    if (url.length > MAX_GET_LENGTH && type === MAP_TYPES.QUERY) {
+    if (url.length > MAX_GET_LENGTH2 && type === MAP_TYPES.QUERY) {
       return await requestJson({
         method: "POST",
         url: baseUrl2,
@@ -14174,20 +14736,20 @@ void main(void) {
     aggregationExp,
     aggregationResLevel
   }) {
-    assert2(connection, "Must define connection");
-    assert2(type, "Must define a type");
-    assert2(source, "Must define a source");
-    assert2(credentials2.apiVersion === API_VERSIONS.V3, "Method only available for v3");
-    assert2(credentials2.apiBaseUrl, "Must define apiBaseUrl");
-    assert2(credentials2.accessToken, "Must define an accessToken");
+    assert(connection, "Must define connection");
+    assert(type, "Must define a type");
+    assert(source, "Must define a source");
+    assert(credentials2.apiVersion === API_VERSIONS.V3, "Method only available for v3");
+    assert(credentials2.apiBaseUrl, "Must define apiBaseUrl");
+    assert(credentials2.accessToken, "Must define an accessToken");
     if (columns) {
-      assert2(COLUMNS_SUPPORT.includes(type), `The columns parameter is not supported by type ${type}`);
+      assert(COLUMNS_SUPPORT.includes(type), `The columns parameter is not supported by type ${type}`);
     }
     if (geoColumn) {
-      assert2(GEO_COLUMN_SUPPORT.includes(type), `The geoColumn parameter is not supported by type ${type}`);
+      assert(GEO_COLUMN_SUPPORT.includes(type), `The geoColumn parameter is not supported by type ${type}`);
     } else {
-      assert2(!aggregationExp, "Have aggregationExp, but geoColumn parameter is missing");
-      assert2(!aggregationResLevel, "Have aggregationResLevel, but geoColumn parameter is missing");
+      assert(!aggregationExp, "Have aggregationExp, but geoColumn parameter is missing");
+      assert(!aggregationResLevel, "Have aggregationResLevel, but geoColumn parameter is missing");
     }
   }
   async function fetchLayerData({
@@ -14295,9 +14857,9 @@ void main(void) {
     if (format2) {
       mapFormat = format2;
       url = getUrlFromMetadata(metadata, format2);
-      assert2(url, `Format ${format2} not available`);
+      assert(url, `Format ${format2} not available`);
     } else {
-      const prioritizedFormats = [FORMATS.GEOJSON, FORMATS.JSON, FORMATS.NDJSON, FORMATS.TILEJSON];
+      const prioritizedFormats = [FORMATS.GEOJSON, FORMATS.JSON, FORMATS.TILEJSON];
       for (const f of prioritizedFormats) {
         url = getUrlFromMetadata(metadata, f);
         if (url) {
@@ -14305,7 +14867,7 @@ void main(void) {
           break;
         }
       }
-      assert2(url && mapFormat, "Unsupported data formats received from backend.");
+      assert(url && mapFormat, "Unsupported data formats received from backend.");
     }
     if (format2 === FORMATS.TILEJSON && formatTiles) {
       import_core10.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
@@ -14396,7 +14958,7 @@ void main(void) {
       url += `?${encodeParameter("q", source)}`;
     }
     let stats;
-    if (url.length > MAX_GET_LENGTH && type === MAP_TYPES.QUERY) {
+    if (url.length > MAX_GET_LENGTH2 && type === MAP_TYPES.QUERY) {
       stats = await requestJson({
         method: "POST",
         url: baseUrl2,
@@ -14481,16 +15043,16 @@ void main(void) {
     const {
       accessToken
     } = localCreds;
-    assert2(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
-    assert2(localCreds.apiVersion === API_VERSIONS.V3, "Method only available for v3");
-    assert2(localCreds.apiBaseUrl, "Must define apiBaseUrl");
+    assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
+    assert(localCreds.apiVersion === API_VERSIONS.V3, "Method only available for v3");
+    assert(localCreds.apiBaseUrl, "Must define apiBaseUrl");
     if (!localCreds.mapsUrl) {
       localCreds.mapsUrl = buildMapsUrlFromBase(localCreds.apiBaseUrl);
     }
     if (autoRefresh || onNewData) {
-      assert2(onNewData, "Must define `onNewData` when using autoRefresh");
-      assert2(typeof onNewData === "function", "`onNewData` must be a function");
-      assert2(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
+      assert(onNewData, "Must define `onNewData` when using autoRefresh");
+      assert(typeof onNewData === "function", "`onNewData` must be a function");
+      assert(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
     }
     const url = `${localCreds.mapsUrl}/public/${cartoMapId}`;
     const errorContext = {
@@ -14554,7 +15116,7 @@ void main(void) {
   }
 
   // src/layers/carto-layer.ts
-  var defaultProps9 = {
+  var defaultProps10 = {
     data: null,
     type: null,
     onDataLoad: {
@@ -14699,14 +15261,14 @@ void main(void) {
       }
     }
     _getSubLayerAndProps() {
-      assert2(this.state);
+      assert(this.state);
       const {
         data,
         apiVersion
       } = this.state;
       const {
         uniqueIdProperty
-      } = defaultProps9;
+      } = defaultProps10;
       const {
         data: _notUsed,
         ...propsNoData
@@ -14723,7 +15285,7 @@ void main(void) {
       return [layerFromTileDataset(props.formatTiles, data.scheme, props.type), props];
     }
     renderLayers() {
-      assert2(this.state);
+      assert(this.state);
       const {
         apiVersion,
         data
@@ -14761,7 +15323,7 @@ void main(void) {
     }
   };
   __publicField(CartoLayer, "layerName", "CartoLayer");
-  __publicField(CartoLayer, "defaultProps", defaultProps9);
+  __publicField(CartoLayer, "defaultProps", defaultProps10);
 
   // src/basemap.ts
   var baseUrl = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
@@ -14885,6 +15447,296 @@ void main(void) {
     };
   }
 
+  // src/sources/utils.ts
+  async function requestWithParameters({
+    baseUrl: baseUrl2,
+    parameters,
+    headers: customHeaders,
+    errorContext
+  }) {
+    let url = baseUrl2;
+    if (parameters) {
+      const allParameters = {
+        ...DEFAULT_PARAMETERS,
+        ...parameters
+      };
+      const encodedParameters = Object.entries(allParameters).map(([key, value]) => {
+        return encodeParameter(key, value);
+      });
+      url += `?${encodedParameters.join("&")}`;
+    }
+    const headers = {
+      ...DEFAULT_HEADERS,
+      ...customHeaders
+    };
+    try {
+      let response;
+      if (url.length > MAX_GET_LENGTH) {
+        response = await fetch(url, {
+          method: "POST",
+          body: JSON.stringify(parameters),
+          headers
+        });
+      } else {
+        response = await fetch(url, {
+          headers
+        });
+      }
+      let json;
+      try {
+        json = await response.json();
+      } catch {
+        json = {
+          error: ""
+        };
+      }
+      if (!response.ok) {
+        throw new CartoAPIError(json.error, errorContext, response);
+      }
+      return json;
+    } catch (error) {
+      throw new CartoAPIError(error, errorContext);
+    }
+  }
+  function buildApiEndpoint({
+    apiBaseUrl,
+    connectionName,
+    endpoint,
+    mapsUrl: mapsUrl2
+  }) {
+    return `${mapsUrl2 || buildMapsUrlFromBase(apiBaseUrl)}/${connectionName}/${endpoint}`;
+  }
+
+  // src/sources/base-source.ts
+  async function cartoBaseSource(endpoint, options, urlParameters) {
+    const mergedOptions = {
+      ...SOURCE_DEFAULTS,
+      ...options,
+      endpoint
+    };
+    const baseUrl2 = buildApiEndpoint(mergedOptions);
+    const {
+      accessToken,
+      format: format2
+    } = mergedOptions;
+    const headers = {
+      Authorization: `Bearer ${options.accessToken}`,
+      ...options.headers
+    };
+    const errorContext = {
+      requestType: "Map instantiation",
+      connection: options.connectionName,
+      type: endpoint,
+      source: JSON.stringify(urlParameters, void 0, 2)
+    };
+    const mapInstantiation2 = await requestWithParameters({
+      baseUrl: baseUrl2,
+      parameters: urlParameters,
+      headers,
+      errorContext
+    });
+    const dataUrl = mapInstantiation2[format2].url[0];
+    errorContext.requestType = "Map data";
+    if (format2 === "tilejson") {
+      const tilejson = await requestWithParameters({
+        baseUrl: dataUrl,
+        headers,
+        errorContext
+      });
+      return {
+        ...tilejson,
+        accessToken
+      };
+    }
+    return await requestWithParameters({
+      baseUrl: dataUrl,
+      headers,
+      errorContext
+    });
+  }
+
+  // src/sources/h3-query-source.ts
+  var cartoH3QuerySource = async function(options) {
+    const {
+      aggregationExp,
+      aggregationResLevel = 4,
+      sqlQuery,
+      spatialDataColumn = "h3:h3",
+      queryParameters
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      q: sqlQuery
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (spatialDataColumn) {
+      urlParameters.geo_column = spatialDataColumn;
+    }
+    if (queryParameters) {
+      urlParameters.queryParameters = JSON.stringify(queryParameters);
+    }
+    return cartoBaseSource("query", options, urlParameters);
+  };
+
+  // src/sources/h3-table-source.ts
+  var cartoH3TableSource = async function(options) {
+    const {
+      aggregationExp,
+      aggregationResLevel = 4,
+      columns,
+      spatialDataColumn = "h3:h3",
+      tableName
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      name: tableName
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (columns) {
+      urlParameters.columns = columns.join(",");
+    }
+    if (spatialDataColumn) {
+      urlParameters.geo_column = spatialDataColumn;
+    }
+    return cartoBaseSource("table", options, urlParameters);
+  };
+
+  // src/sources/h3-tileset-source.ts
+  var cartoH3TilesetSource = async function(options) {
+    const {
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    return cartoBaseSource("tileset", options, urlParameters);
+  };
+
+  // src/sources/raster-source.ts
+  var cartoRasterSource = async function(options) {
+    const {
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    return cartoBaseSource("raster", options, urlParameters);
+  };
+
+  // src/sources/quadbin-query-source.ts
+  var cartoQuadbinQuerySource = async function(options) {
+    const {
+      aggregationExp,
+      aggregationResLevel = 6,
+      sqlQuery,
+      spatialDataColumn = "quadbin:quadbin",
+      queryParameters
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      q: sqlQuery
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (spatialDataColumn) {
+      urlParameters.geo_column = spatialDataColumn;
+    }
+    if (queryParameters) {
+      urlParameters.queryParameters = JSON.stringify(queryParameters);
+    }
+    return cartoBaseSource("query", options, urlParameters);
+  };
+
+  // src/sources/quadbin-table-source.ts
+  var cartoQuadbinTableSource = async function(options) {
+    const {
+      aggregationExp,
+      aggregationResLevel = 6,
+      columns,
+      spatialDataColumn = "quadbin:quadbin",
+      tableName
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      name: tableName
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (columns) {
+      urlParameters.columns = columns.join(",");
+    }
+    if (spatialDataColumn) {
+      urlParameters.geo_column = spatialDataColumn;
+    }
+    return cartoBaseSource("table", options, urlParameters);
+  };
+
+  // src/sources/quadbin-tileset-source.ts
+  var cartoQuadbinTilesetSource = async function(options) {
+    const {
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    return cartoBaseSource("tileset", options, urlParameters);
+  };
+
+  // src/sources/vector-query-source.ts
+  var cartoVectorQuerySource = async function(options) {
+    const {
+      spatialDataColumn,
+      sqlQuery,
+      queryParameters
+    } = options;
+    const urlParameters = {
+      q: sqlQuery
+    };
+    if (spatialDataColumn) {
+      urlParameters.geo_column = spatialDataColumn;
+    }
+    if (queryParameters) {
+      urlParameters.queryParameters = JSON.stringify(queryParameters);
+    }
+    return cartoBaseSource("query", options, urlParameters);
+  };
+
+  // src/sources/vector-table-source.ts
+  var cartoVectorTableSource = async function(options) {
+    const {
+      columns,
+      spatialDataColumn,
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    if (columns) {
+      urlParameters.columns = columns.join(",");
+    }
+    if (spatialDataColumn) {
+      urlParameters.geo_column = spatialDataColumn;
+    }
+    return cartoBaseSource("table", options, urlParameters);
+  };
+
+  // src/sources/vector-tileset-source.ts
+  var cartoVectorTilesetSource = async function(options) {
+    const {
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    return cartoBaseSource("tileset", options, urlParameters);
+  };
+
   // ../layers/bundle/peer-dependency.ts
   var peer_dependency_exports = {};
   var import_layers5 = __toESM(require_layers());