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

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"
   };
@@ -8952,624 +9429,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     };
   }
 
-  // ../../node_modules/@luma.gl/constants/dist/esm/index.js
-  var esm_default = {
-    DEPTH_BUFFER_BIT: 256,
-    STENCIL_BUFFER_BIT: 1024,
-    COLOR_BUFFER_BIT: 16384,
-    POINTS: 0,
-    LINES: 1,
-    LINE_LOOP: 2,
-    LINE_STRIP: 3,
-    TRIANGLES: 4,
-    TRIANGLE_STRIP: 5,
-    TRIANGLE_FAN: 6,
-    ZERO: 0,
-    ONE: 1,
-    SRC_COLOR: 768,
-    ONE_MINUS_SRC_COLOR: 769,
-    SRC_ALPHA: 770,
-    ONE_MINUS_SRC_ALPHA: 771,
-    DST_ALPHA: 772,
-    ONE_MINUS_DST_ALPHA: 773,
-    DST_COLOR: 774,
-    ONE_MINUS_DST_COLOR: 775,
-    SRC_ALPHA_SATURATE: 776,
-    CONSTANT_COLOR: 32769,
-    ONE_MINUS_CONSTANT_COLOR: 32770,
-    CONSTANT_ALPHA: 32771,
-    ONE_MINUS_CONSTANT_ALPHA: 32772,
-    FUNC_ADD: 32774,
-    FUNC_SUBTRACT: 32778,
-    FUNC_REVERSE_SUBTRACT: 32779,
-    BLEND_EQUATION: 32777,
-    BLEND_EQUATION_RGB: 32777,
-    BLEND_EQUATION_ALPHA: 34877,
-    BLEND_DST_RGB: 32968,
-    BLEND_SRC_RGB: 32969,
-    BLEND_DST_ALPHA: 32970,
-    BLEND_SRC_ALPHA: 32971,
-    BLEND_COLOR: 32773,
-    ARRAY_BUFFER_BINDING: 34964,
-    ELEMENT_ARRAY_BUFFER_BINDING: 34965,
-    LINE_WIDTH: 2849,
-    ALIASED_POINT_SIZE_RANGE: 33901,
-    ALIASED_LINE_WIDTH_RANGE: 33902,
-    CULL_FACE_MODE: 2885,
-    FRONT_FACE: 2886,
-    DEPTH_RANGE: 2928,
-    DEPTH_WRITEMASK: 2930,
-    DEPTH_CLEAR_VALUE: 2931,
-    DEPTH_FUNC: 2932,
-    STENCIL_CLEAR_VALUE: 2961,
-    STENCIL_FUNC: 2962,
-    STENCIL_FAIL: 2964,
-    STENCIL_PASS_DEPTH_FAIL: 2965,
-    STENCIL_PASS_DEPTH_PASS: 2966,
-    STENCIL_REF: 2967,
-    STENCIL_VALUE_MASK: 2963,
-    STENCIL_WRITEMASK: 2968,
-    STENCIL_BACK_FUNC: 34816,
-    STENCIL_BACK_FAIL: 34817,
-    STENCIL_BACK_PASS_DEPTH_FAIL: 34818,
-    STENCIL_BACK_PASS_DEPTH_PASS: 34819,
-    STENCIL_BACK_REF: 36003,
-    STENCIL_BACK_VALUE_MASK: 36004,
-    STENCIL_BACK_WRITEMASK: 36005,
-    VIEWPORT: 2978,
-    SCISSOR_BOX: 3088,
-    COLOR_CLEAR_VALUE: 3106,
-    COLOR_WRITEMASK: 3107,
-    UNPACK_ALIGNMENT: 3317,
-    PACK_ALIGNMENT: 3333,
-    MAX_TEXTURE_SIZE: 3379,
-    MAX_VIEWPORT_DIMS: 3386,
-    SUBPIXEL_BITS: 3408,
-    RED_BITS: 3410,
-    GREEN_BITS: 3411,
-    BLUE_BITS: 3412,
-    ALPHA_BITS: 3413,
-    DEPTH_BITS: 3414,
-    STENCIL_BITS: 3415,
-    POLYGON_OFFSET_UNITS: 10752,
-    POLYGON_OFFSET_FACTOR: 32824,
-    TEXTURE_BINDING_2D: 32873,
-    SAMPLE_BUFFERS: 32936,
-    SAMPLES: 32937,
-    SAMPLE_COVERAGE_VALUE: 32938,
-    SAMPLE_COVERAGE_INVERT: 32939,
-    COMPRESSED_TEXTURE_FORMATS: 34467,
-    VENDOR: 7936,
-    RENDERER: 7937,
-    VERSION: 7938,
-    IMPLEMENTATION_COLOR_READ_TYPE: 35738,
-    IMPLEMENTATION_COLOR_READ_FORMAT: 35739,
-    BROWSER_DEFAULT_WEBGL: 37444,
-    STATIC_DRAW: 35044,
-    STREAM_DRAW: 35040,
-    DYNAMIC_DRAW: 35048,
-    ARRAY_BUFFER: 34962,
-    ELEMENT_ARRAY_BUFFER: 34963,
-    BUFFER_SIZE: 34660,
-    BUFFER_USAGE: 34661,
-    CURRENT_VERTEX_ATTRIB: 34342,
-    VERTEX_ATTRIB_ARRAY_ENABLED: 34338,
-    VERTEX_ATTRIB_ARRAY_SIZE: 34339,
-    VERTEX_ATTRIB_ARRAY_STRIDE: 34340,
-    VERTEX_ATTRIB_ARRAY_TYPE: 34341,
-    VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922,
-    VERTEX_ATTRIB_ARRAY_POINTER: 34373,
-    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975,
-    CULL_FACE: 2884,
-    FRONT: 1028,
-    BACK: 1029,
-    FRONT_AND_BACK: 1032,
-    BLEND: 3042,
-    DEPTH_TEST: 2929,
-    DITHER: 3024,
-    POLYGON_OFFSET_FILL: 32823,
-    SAMPLE_ALPHA_TO_COVERAGE: 32926,
-    SAMPLE_COVERAGE: 32928,
-    SCISSOR_TEST: 3089,
-    STENCIL_TEST: 2960,
-    NO_ERROR: 0,
-    INVALID_ENUM: 1280,
-    INVALID_VALUE: 1281,
-    INVALID_OPERATION: 1282,
-    OUT_OF_MEMORY: 1285,
-    CONTEXT_LOST_WEBGL: 37442,
-    CW: 2304,
-    CCW: 2305,
-    DONT_CARE: 4352,
-    FASTEST: 4353,
-    NICEST: 4354,
-    GENERATE_MIPMAP_HINT: 33170,
-    BYTE: 5120,
-    UNSIGNED_BYTE: 5121,
-    SHORT: 5122,
-    UNSIGNED_SHORT: 5123,
-    INT: 5124,
-    UNSIGNED_INT: 5125,
-    FLOAT: 5126,
-    DOUBLE: 5130,
-    DEPTH_COMPONENT: 6402,
-    ALPHA: 6406,
-    RGB: 6407,
-    RGBA: 6408,
-    LUMINANCE: 6409,
-    LUMINANCE_ALPHA: 6410,
-    UNSIGNED_SHORT_4_4_4_4: 32819,
-    UNSIGNED_SHORT_5_5_5_1: 32820,
-    UNSIGNED_SHORT_5_6_5: 33635,
-    FRAGMENT_SHADER: 35632,
-    VERTEX_SHADER: 35633,
-    COMPILE_STATUS: 35713,
-    DELETE_STATUS: 35712,
-    LINK_STATUS: 35714,
-    VALIDATE_STATUS: 35715,
-    ATTACHED_SHADERS: 35717,
-    ACTIVE_ATTRIBUTES: 35721,
-    ACTIVE_UNIFORMS: 35718,
-    MAX_VERTEX_ATTRIBS: 34921,
-    MAX_VERTEX_UNIFORM_VECTORS: 36347,
-    MAX_VARYING_VECTORS: 36348,
-    MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661,
-    MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660,
-    MAX_TEXTURE_IMAGE_UNITS: 34930,
-    MAX_FRAGMENT_UNIFORM_VECTORS: 36349,
-    SHADER_TYPE: 35663,
-    SHADING_LANGUAGE_VERSION: 35724,
-    CURRENT_PROGRAM: 35725,
-    NEVER: 512,
-    ALWAYS: 519,
-    LESS: 513,
-    EQUAL: 514,
-    LEQUAL: 515,
-    GREATER: 516,
-    GEQUAL: 518,
-    NOTEQUAL: 517,
-    KEEP: 7680,
-    REPLACE: 7681,
-    INCR: 7682,
-    DECR: 7683,
-    INVERT: 5386,
-    INCR_WRAP: 34055,
-    DECR_WRAP: 34056,
-    NEAREST: 9728,
-    LINEAR: 9729,
-    NEAREST_MIPMAP_NEAREST: 9984,
-    LINEAR_MIPMAP_NEAREST: 9985,
-    NEAREST_MIPMAP_LINEAR: 9986,
-    LINEAR_MIPMAP_LINEAR: 9987,
-    TEXTURE_MAG_FILTER: 10240,
-    TEXTURE_MIN_FILTER: 10241,
-    TEXTURE_WRAP_S: 10242,
-    TEXTURE_WRAP_T: 10243,
-    TEXTURE_2D: 3553,
-    TEXTURE: 5890,
-    TEXTURE_CUBE_MAP: 34067,
-    TEXTURE_BINDING_CUBE_MAP: 34068,
-    TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
-    TEXTURE_CUBE_MAP_NEGATIVE_X: 34070,
-    TEXTURE_CUBE_MAP_POSITIVE_Y: 34071,
-    TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072,
-    TEXTURE_CUBE_MAP_POSITIVE_Z: 34073,
-    TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074,
-    MAX_CUBE_MAP_TEXTURE_SIZE: 34076,
-    TEXTURE0: 33984,
-    ACTIVE_TEXTURE: 34016,
-    REPEAT: 10497,
-    CLAMP_TO_EDGE: 33071,
-    MIRRORED_REPEAT: 33648,
-    TEXTURE_WIDTH: 4096,
-    TEXTURE_HEIGHT: 4097,
-    FLOAT_VEC2: 35664,
-    FLOAT_VEC3: 35665,
-    FLOAT_VEC4: 35666,
-    INT_VEC2: 35667,
-    INT_VEC3: 35668,
-    INT_VEC4: 35669,
-    BOOL: 35670,
-    BOOL_VEC2: 35671,
-    BOOL_VEC3: 35672,
-    BOOL_VEC4: 35673,
-    FLOAT_MAT2: 35674,
-    FLOAT_MAT3: 35675,
-    FLOAT_MAT4: 35676,
-    SAMPLER_2D: 35678,
-    SAMPLER_CUBE: 35680,
-    LOW_FLOAT: 36336,
-    MEDIUM_FLOAT: 36337,
-    HIGH_FLOAT: 36338,
-    LOW_INT: 36339,
-    MEDIUM_INT: 36340,
-    HIGH_INT: 36341,
-    FRAMEBUFFER: 36160,
-    RENDERBUFFER: 36161,
-    RGBA4: 32854,
-    RGB5_A1: 32855,
-    RGB565: 36194,
-    DEPTH_COMPONENT16: 33189,
-    STENCIL_INDEX: 6401,
-    STENCIL_INDEX8: 36168,
-    DEPTH_STENCIL: 34041,
-    RENDERBUFFER_WIDTH: 36162,
-    RENDERBUFFER_HEIGHT: 36163,
-    RENDERBUFFER_INTERNAL_FORMAT: 36164,
-    RENDERBUFFER_RED_SIZE: 36176,
-    RENDERBUFFER_GREEN_SIZE: 36177,
-    RENDERBUFFER_BLUE_SIZE: 36178,
-    RENDERBUFFER_ALPHA_SIZE: 36179,
-    RENDERBUFFER_DEPTH_SIZE: 36180,
-    RENDERBUFFER_STENCIL_SIZE: 36181,
-    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048,
-    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049,
-    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050,
-    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051,
-    COLOR_ATTACHMENT0: 36064,
-    DEPTH_ATTACHMENT: 36096,
-    STENCIL_ATTACHMENT: 36128,
-    DEPTH_STENCIL_ATTACHMENT: 33306,
-    NONE: 0,
-    FRAMEBUFFER_COMPLETE: 36053,
-    FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054,
-    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055,
-    FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057,
-    FRAMEBUFFER_UNSUPPORTED: 36061,
-    FRAMEBUFFER_BINDING: 36006,
-    RENDERBUFFER_BINDING: 36007,
-    READ_FRAMEBUFFER: 36008,
-    DRAW_FRAMEBUFFER: 36009,
-    MAX_RENDERBUFFER_SIZE: 34024,
-    INVALID_FRAMEBUFFER_OPERATION: 1286,
-    UNPACK_FLIP_Y_WEBGL: 37440,
-    UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441,
-    UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443,
-    READ_BUFFER: 3074,
-    UNPACK_ROW_LENGTH: 3314,
-    UNPACK_SKIP_ROWS: 3315,
-    UNPACK_SKIP_PIXELS: 3316,
-    PACK_ROW_LENGTH: 3330,
-    PACK_SKIP_ROWS: 3331,
-    PACK_SKIP_PIXELS: 3332,
-    TEXTURE_BINDING_3D: 32874,
-    UNPACK_SKIP_IMAGES: 32877,
-    UNPACK_IMAGE_HEIGHT: 32878,
-    MAX_3D_TEXTURE_SIZE: 32883,
-    MAX_ELEMENTS_VERTICES: 33e3,
-    MAX_ELEMENTS_INDICES: 33001,
-    MAX_TEXTURE_LOD_BIAS: 34045,
-    MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657,
-    MAX_VERTEX_UNIFORM_COMPONENTS: 35658,
-    MAX_ARRAY_TEXTURE_LAYERS: 35071,
-    MIN_PROGRAM_TEXEL_OFFSET: 35076,
-    MAX_PROGRAM_TEXEL_OFFSET: 35077,
-    MAX_VARYING_COMPONENTS: 35659,
-    FRAGMENT_SHADER_DERIVATIVE_HINT: 35723,
-    RASTERIZER_DISCARD: 35977,
-    VERTEX_ARRAY_BINDING: 34229,
-    MAX_VERTEX_OUTPUT_COMPONENTS: 37154,
-    MAX_FRAGMENT_INPUT_COMPONENTS: 37157,
-    MAX_SERVER_WAIT_TIMEOUT: 37137,
-    MAX_ELEMENT_INDEX: 36203,
-    RED: 6403,
-    RGB8: 32849,
-    RGBA8: 32856,
-    RGB10_A2: 32857,
-    TEXTURE_3D: 32879,
-    TEXTURE_WRAP_R: 32882,
-    TEXTURE_MIN_LOD: 33082,
-    TEXTURE_MAX_LOD: 33083,
-    TEXTURE_BASE_LEVEL: 33084,
-    TEXTURE_MAX_LEVEL: 33085,
-    TEXTURE_COMPARE_MODE: 34892,
-    TEXTURE_COMPARE_FUNC: 34893,
-    SRGB: 35904,
-    SRGB8: 35905,
-    SRGB8_ALPHA8: 35907,
-    COMPARE_REF_TO_TEXTURE: 34894,
-    RGBA32F: 34836,
-    RGB32F: 34837,
-    RGBA16F: 34842,
-    RGB16F: 34843,
-    TEXTURE_2D_ARRAY: 35866,
-    TEXTURE_BINDING_2D_ARRAY: 35869,
-    R11F_G11F_B10F: 35898,
-    RGB9_E5: 35901,
-    RGBA32UI: 36208,
-    RGB32UI: 36209,
-    RGBA16UI: 36214,
-    RGB16UI: 36215,
-    RGBA8UI: 36220,
-    RGB8UI: 36221,
-    RGBA32I: 36226,
-    RGB32I: 36227,
-    RGBA16I: 36232,
-    RGB16I: 36233,
-    RGBA8I: 36238,
-    RGB8I: 36239,
-    RED_INTEGER: 36244,
-    RGB_INTEGER: 36248,
-    RGBA_INTEGER: 36249,
-    R8: 33321,
-    RG8: 33323,
-    R16F: 33325,
-    R32F: 33326,
-    RG16F: 33327,
-    RG32F: 33328,
-    R8I: 33329,
-    R8UI: 33330,
-    R16I: 33331,
-    R16UI: 33332,
-    R32I: 33333,
-    R32UI: 33334,
-    RG8I: 33335,
-    RG8UI: 33336,
-    RG16I: 33337,
-    RG16UI: 33338,
-    RG32I: 33339,
-    RG32UI: 33340,
-    R8_SNORM: 36756,
-    RG8_SNORM: 36757,
-    RGB8_SNORM: 36758,
-    RGBA8_SNORM: 36759,
-    RGB10_A2UI: 36975,
-    TEXTURE_IMMUTABLE_FORMAT: 37167,
-    TEXTURE_IMMUTABLE_LEVELS: 33503,
-    UNSIGNED_INT_2_10_10_10_REV: 33640,
-    UNSIGNED_INT_10F_11F_11F_REV: 35899,
-    UNSIGNED_INT_5_9_9_9_REV: 35902,
-    FLOAT_32_UNSIGNED_INT_24_8_REV: 36269,
-    UNSIGNED_INT_24_8: 34042,
-    HALF_FLOAT: 5131,
-    RG: 33319,
-    RG_INTEGER: 33320,
-    INT_2_10_10_10_REV: 36255,
-    CURRENT_QUERY: 34917,
-    QUERY_RESULT: 34918,
-    QUERY_RESULT_AVAILABLE: 34919,
-    ANY_SAMPLES_PASSED: 35887,
-    ANY_SAMPLES_PASSED_CONSERVATIVE: 36202,
-    MAX_DRAW_BUFFERS: 34852,
-    DRAW_BUFFER0: 34853,
-    DRAW_BUFFER1: 34854,
-    DRAW_BUFFER2: 34855,
-    DRAW_BUFFER3: 34856,
-    DRAW_BUFFER4: 34857,
-    DRAW_BUFFER5: 34858,
-    DRAW_BUFFER6: 34859,
-    DRAW_BUFFER7: 34860,
-    DRAW_BUFFER8: 34861,
-    DRAW_BUFFER9: 34862,
-    DRAW_BUFFER10: 34863,
-    DRAW_BUFFER11: 34864,
-    DRAW_BUFFER12: 34865,
-    DRAW_BUFFER13: 34866,
-    DRAW_BUFFER14: 34867,
-    DRAW_BUFFER15: 34868,
-    MAX_COLOR_ATTACHMENTS: 36063,
-    COLOR_ATTACHMENT1: 36065,
-    COLOR_ATTACHMENT2: 36066,
-    COLOR_ATTACHMENT3: 36067,
-    COLOR_ATTACHMENT4: 36068,
-    COLOR_ATTACHMENT5: 36069,
-    COLOR_ATTACHMENT6: 36070,
-    COLOR_ATTACHMENT7: 36071,
-    COLOR_ATTACHMENT8: 36072,
-    COLOR_ATTACHMENT9: 36073,
-    COLOR_ATTACHMENT10: 36074,
-    COLOR_ATTACHMENT11: 36075,
-    COLOR_ATTACHMENT12: 36076,
-    COLOR_ATTACHMENT13: 36077,
-    COLOR_ATTACHMENT14: 36078,
-    COLOR_ATTACHMENT15: 36079,
-    SAMPLER_3D: 35679,
-    SAMPLER_2D_SHADOW: 35682,
-    SAMPLER_2D_ARRAY: 36289,
-    SAMPLER_2D_ARRAY_SHADOW: 36292,
-    SAMPLER_CUBE_SHADOW: 36293,
-    INT_SAMPLER_2D: 36298,
-    INT_SAMPLER_3D: 36299,
-    INT_SAMPLER_CUBE: 36300,
-    INT_SAMPLER_2D_ARRAY: 36303,
-    UNSIGNED_INT_SAMPLER_2D: 36306,
-    UNSIGNED_INT_SAMPLER_3D: 36307,
-    UNSIGNED_INT_SAMPLER_CUBE: 36308,
-    UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311,
-    MAX_SAMPLES: 36183,
-    SAMPLER_BINDING: 35097,
-    PIXEL_PACK_BUFFER: 35051,
-    PIXEL_UNPACK_BUFFER: 35052,
-    PIXEL_PACK_BUFFER_BINDING: 35053,
-    PIXEL_UNPACK_BUFFER_BINDING: 35055,
-    COPY_READ_BUFFER: 36662,
-    COPY_WRITE_BUFFER: 36663,
-    COPY_READ_BUFFER_BINDING: 36662,
-    COPY_WRITE_BUFFER_BINDING: 36663,
-    FLOAT_MAT2x3: 35685,
-    FLOAT_MAT2x4: 35686,
-    FLOAT_MAT3x2: 35687,
-    FLOAT_MAT3x4: 35688,
-    FLOAT_MAT4x2: 35689,
-    FLOAT_MAT4x3: 35690,
-    UNSIGNED_INT_VEC2: 36294,
-    UNSIGNED_INT_VEC3: 36295,
-    UNSIGNED_INT_VEC4: 36296,
-    UNSIGNED_NORMALIZED: 35863,
-    SIGNED_NORMALIZED: 36764,
-    VERTEX_ATTRIB_ARRAY_INTEGER: 35069,
-    VERTEX_ATTRIB_ARRAY_DIVISOR: 35070,
-    TRANSFORM_FEEDBACK_BUFFER_MODE: 35967,
-    MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968,
-    TRANSFORM_FEEDBACK_VARYINGS: 35971,
-    TRANSFORM_FEEDBACK_BUFFER_START: 35972,
-    TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973,
-    TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976,
-    MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978,
-    MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979,
-    INTERLEAVED_ATTRIBS: 35980,
-    SEPARATE_ATTRIBS: 35981,
-    TRANSFORM_FEEDBACK_BUFFER: 35982,
-    TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983,
-    TRANSFORM_FEEDBACK: 36386,
-    TRANSFORM_FEEDBACK_PAUSED: 36387,
-    TRANSFORM_FEEDBACK_ACTIVE: 36388,
-    TRANSFORM_FEEDBACK_BINDING: 36389,
-    FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296,
-    FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297,
-    FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298,
-    FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299,
-    FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300,
-    FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301,
-    FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302,
-    FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303,
-    FRAMEBUFFER_DEFAULT: 33304,
-    DEPTH24_STENCIL8: 35056,
-    DRAW_FRAMEBUFFER_BINDING: 36006,
-    READ_FRAMEBUFFER_BINDING: 36010,
-    RENDERBUFFER_SAMPLES: 36011,
-    FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052,
-    FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182,
-    UNIFORM_BUFFER: 35345,
-    UNIFORM_BUFFER_BINDING: 35368,
-    UNIFORM_BUFFER_START: 35369,
-    UNIFORM_BUFFER_SIZE: 35370,
-    MAX_VERTEX_UNIFORM_BLOCKS: 35371,
-    MAX_FRAGMENT_UNIFORM_BLOCKS: 35373,
-    MAX_COMBINED_UNIFORM_BLOCKS: 35374,
-    MAX_UNIFORM_BUFFER_BINDINGS: 35375,
-    MAX_UNIFORM_BLOCK_SIZE: 35376,
-    MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377,
-    MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379,
-    UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380,
-    ACTIVE_UNIFORM_BLOCKS: 35382,
-    UNIFORM_TYPE: 35383,
-    UNIFORM_SIZE: 35384,
-    UNIFORM_BLOCK_INDEX: 35386,
-    UNIFORM_OFFSET: 35387,
-    UNIFORM_ARRAY_STRIDE: 35388,
-    UNIFORM_MATRIX_STRIDE: 35389,
-    UNIFORM_IS_ROW_MAJOR: 35390,
-    UNIFORM_BLOCK_BINDING: 35391,
-    UNIFORM_BLOCK_DATA_SIZE: 35392,
-    UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394,
-    UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395,
-    UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396,
-    UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398,
-    OBJECT_TYPE: 37138,
-    SYNC_CONDITION: 37139,
-    SYNC_STATUS: 37140,
-    SYNC_FLAGS: 37141,
-    SYNC_FENCE: 37142,
-    SYNC_GPU_COMMANDS_COMPLETE: 37143,
-    UNSIGNALED: 37144,
-    SIGNALED: 37145,
-    ALREADY_SIGNALED: 37146,
-    TIMEOUT_EXPIRED: 37147,
-    CONDITION_SATISFIED: 37148,
-    WAIT_FAILED: 37149,
-    SYNC_FLUSH_COMMANDS_BIT: 1,
-    COLOR: 6144,
-    DEPTH: 6145,
-    STENCIL: 6146,
-    MIN: 32775,
-    MAX: 32776,
-    DEPTH_COMPONENT24: 33190,
-    STREAM_READ: 35041,
-    STREAM_COPY: 35042,
-    STATIC_READ: 35045,
-    STATIC_COPY: 35046,
-    DYNAMIC_READ: 35049,
-    DYNAMIC_COPY: 35050,
-    DEPTH_COMPONENT32F: 36012,
-    DEPTH32F_STENCIL8: 36013,
-    INVALID_INDEX: 4294967295,
-    TIMEOUT_IGNORED: -1,
-    MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 37447,
-    VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 35070,
-    UNMASKED_VENDOR_WEBGL: 37445,
-    UNMASKED_RENDERER_WEBGL: 37446,
-    MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047,
-    TEXTURE_MAX_ANISOTROPY_EXT: 34046,
-    COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
-    COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
-    COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
-    COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
-    COMPRESSED_R11_EAC: 37488,
-    COMPRESSED_SIGNED_R11_EAC: 37489,
-    COMPRESSED_RG11_EAC: 37490,
-    COMPRESSED_SIGNED_RG11_EAC: 37491,
-    COMPRESSED_RGB8_ETC2: 37492,
-    COMPRESSED_RGBA8_ETC2_EAC: 37493,
-    COMPRESSED_SRGB8_ETC2: 37494,
-    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
-    COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
-    COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
-    COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
-    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
-    COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
-    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
-    COMPRESSED_RGB_ETC1_WEBGL: 36196,
-    COMPRESSED_RGB_ATC_WEBGL: 35986,
-    COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35986,
-    COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
-    UNSIGNED_INT_24_8_WEBGL: 34042,
-    HALF_FLOAT_OES: 36193,
-    RGBA32F_EXT: 34836,
-    RGB32F_EXT: 34837,
-    FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: 33297,
-    UNSIGNED_NORMALIZED_EXT: 35863,
-    MIN_EXT: 32775,
-    MAX_EXT: 32776,
-    SRGB_EXT: 35904,
-    SRGB_ALPHA_EXT: 35906,
-    SRGB8_ALPHA8_EXT: 35907,
-    FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: 33296,
-    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 35723,
-    COLOR_ATTACHMENT0_WEBGL: 36064,
-    COLOR_ATTACHMENT1_WEBGL: 36065,
-    COLOR_ATTACHMENT2_WEBGL: 36066,
-    COLOR_ATTACHMENT3_WEBGL: 36067,
-    COLOR_ATTACHMENT4_WEBGL: 36068,
-    COLOR_ATTACHMENT5_WEBGL: 36069,
-    COLOR_ATTACHMENT6_WEBGL: 36070,
-    COLOR_ATTACHMENT7_WEBGL: 36071,
-    COLOR_ATTACHMENT8_WEBGL: 36072,
-    COLOR_ATTACHMENT9_WEBGL: 36073,
-    COLOR_ATTACHMENT10_WEBGL: 36074,
-    COLOR_ATTACHMENT11_WEBGL: 36075,
-    COLOR_ATTACHMENT12_WEBGL: 36076,
-    COLOR_ATTACHMENT13_WEBGL: 36077,
-    COLOR_ATTACHMENT14_WEBGL: 36078,
-    COLOR_ATTACHMENT15_WEBGL: 36079,
-    DRAW_BUFFER0_WEBGL: 34853,
-    DRAW_BUFFER1_WEBGL: 34854,
-    DRAW_BUFFER2_WEBGL: 34855,
-    DRAW_BUFFER3_WEBGL: 34856,
-    DRAW_BUFFER4_WEBGL: 34857,
-    DRAW_BUFFER5_WEBGL: 34858,
-    DRAW_BUFFER6_WEBGL: 34859,
-    DRAW_BUFFER7_WEBGL: 34860,
-    DRAW_BUFFER8_WEBGL: 34861,
-    DRAW_BUFFER9_WEBGL: 34862,
-    DRAW_BUFFER10_WEBGL: 34863,
-    DRAW_BUFFER11_WEBGL: 34864,
-    DRAW_BUFFER12_WEBGL: 34865,
-    DRAW_BUFFER13_WEBGL: 34866,
-    DRAW_BUFFER14_WEBGL: 34867,
-    DRAW_BUFFER15_WEBGL: 34868,
-    MAX_COLOR_ATTACHMENTS_WEBGL: 36063,
-    MAX_DRAW_BUFFERS_WEBGL: 34852,
-    VERTEX_ARRAY_BINDING_OES: 34229,
-    QUERY_COUNTER_BITS_EXT: 34916,
-    CURRENT_QUERY_EXT: 34917,
-    QUERY_RESULT_EXT: 34918,
-    QUERY_RESULT_AVAILABLE_EXT: 34919,
-    TIME_ELAPSED_EXT: 35007,
-    TIMESTAMP_EXT: 36392,
-    GPU_DISJOINT_EXT: 36795
-  };
-
   // ../../node_modules/d3-array/src/ascending.js
   function ascending(a, b) {
     return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
@@ -11466,8 +11325,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,25 +11446,162 @@ ${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);
-    }
+        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 = true ? "8.10.0-alpha.5" : "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 {
@@ -11677,9 +11783,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,1044 +11801,530 @@ ${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 tileToCell(tile) {
+    if (tile.z < 0 || tile.z > 26) {
+      throw new Error("Wrong zoom");
     }
-  }
-  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);
+    const z = BigInt(tile.z);
+    let x = BigInt(tile.x) << 32n - z;
+    let y = BigInt(tile.y) << 32n - z;
+    for (let i = 0; i < 5; i++) {
+      const s = S[5 - i];
+      const b = B[4 - i];
+      x = (x | x << s) & b;
+      y = (y | y << s) & b;
     }
-    return features;
+    const quadbin = 0x4000000000000000n | 1n << 59n | z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
+    return quadbin;
   }
-  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));
+  function cellToTile(quadbin) {
+    const mode = quadbin >> 59n & 7n;
+    const modeDep = quadbin >> 57n & 3n;
+    const z = quadbin >> 52n & 0x1fn;
+    const q = (quadbin & 0xfffffffffffffn) << 12n;
+    if (mode !== 1n && modeDep !== 0n) {
+      throw new Error("Wrong mode");
     }
-    return 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];
+    let x = q;
+    let y = q >> 1n;
+    for (let i = 0; i < 6; i++) {
+      const s = S[i];
+      const b = B[i];
+      x = (x | x >> s) & b;
+      y = (y | y >> s) & b;
     }
-    return properties;
+    x = x >> 32n - z;
+    y = y >> 32n - z;
+    return { z: Number(z), x: Number(x), y: Number(y) };
   }
-  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 getResolution2(quadbin) {
+    return quadbin >> 52n & 0x1fn;
   }
-  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 cellToParent2(quadbin) {
+    const zparent = getResolution2(quadbin) - 1n;
+    const parent = quadbin & ~(0x1fn << 52n) | zparent << 52n | 0xfffffffffffffn >> zparent * 2n;
+    return parent;
   }
-  function pointToGeoJson(data, startIndex, endIndex) {
+
+  // src/layers/schema/spatialjson-utils.ts
+  function binaryToSpatialjson(binary) {
     const {
-      positions
-    } = data;
-    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-    const multi = coordinates.length > 1;
-    if (multi) {
-      return {
-        type: "MultiPoint",
-        coordinates
+      cells,
+      scheme
+    } = binary;
+    const count = cells.indices.value.length;
+    const spatial = [];
+    for (let i = 0; i < count; i++) {
+      const id4 = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
+      const properties = {
+        ...cells.properties[i]
       };
-    }
-    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]));
+      for (const key of Object.keys(cells.numericProps)) {
+        properties[key] = cells.numericProps[key].value[i];
       }
-      ringCoordinates.push(coord);
+      spatial.push({
+        id: id4,
+        properties
+      });
     }
-    return ringCoordinates;
+    return spatial;
   }
-  function parseType(data) {
-    if (data.pathIndices) {
-      return "LineString";
-    }
-    if (data.polygonIndices) {
-      return "Polygon";
+
+  // src/layers/schema/carto-spatial-tile-loader.ts
+  var VERSION2 = true ? "8.10.0-alpha.5" : "latest";
+  var id2 = "cartoSpatialTile";
+  var DEFAULT_OPTIONS2 = {
+    cartoSpatialTile: {
+      scheme: "quadbin",
+      workerUrl: getWorkerUrl(id2, VERSION2)
     }
-    return "Point";
+  };
+  var CartoSpatialTileLoader = {
+    name: "CARTO Spatial Tile",
+    version: VERSION2,
+    id: id2,
+    module: "carto",
+    extensions: ["pbf"],
+    mimeTypes: ["application/vnd.carto-spatial-tile"],
+    category: "geometry",
+    parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
+    parseSync: parseCartoSpatialTile,
+    worker: true,
+    options: DEFAULT_OPTIONS2
+  };
+  function parseCartoSpatialTile(arrayBuffer, options) {
+    if (!arrayBuffer)
+      return null;
+    const tile = parsePbf(arrayBuffer, TileReader3);
+    const {
+      cells
+    } = tile;
+    const scheme = options?.cartoSpatialTile?.scheme;
+    const data = {
+      cells,
+      scheme
+    };
+    return binaryToSpatialjson(data);
   }
+  var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
 
-  // src/layers/carto-tile-layer.ts
-  (0, import_core.registerLoaders)([carto_vector_tile_loader_default]);
-  var defaultTileFormat = TILE_FORMATS.BINARY;
+  // src/layers/spatial-index-tile-layer.ts
+  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 defaultProps = {
-    ...import_geo_layers.MVTLayer.defaultProps,
-    formatTiles: defaultTileFormat
+    aggregationResLevel: 4
   };
-  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;
+  var SpatialIndexTileLayer = class extends import_geo_layers2.TileLayer {
+    updateState(params) {
       const {
-        signal
-      } = tile;
-      if (formatTiles === TILE_FORMATS.BINARY) {
-        loadOptions = {
-          ...loadOptions,
-          mimeType: "application/vnd.carto-vector-tile"
-        };
+        props,
+        oldProps
+      } = params;
+      if (props.aggregationResLevel !== oldProps.aggregationResLevel) {
+        this.setState({
+          tileset: null
+        });
       }
-      return fetch2(url, {
-        propName: "data",
-        layer: this,
-        loadOptions,
-        signal
-      });
+      super.updateState(params);
     }
-    renderSubLayers(props) {
-      if (props.data === null) {
-        return null;
-      }
-      const tileBbox = props.tile.bbox;
+    _updateAutoHighlight(info) {
       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 [];
+        hoveredFeatureId
+      } = this.state;
+      const hoveredFeature = info.object;
+      let newHoveredFeatureId;
+      if (hoveredFeature) {
+        newHoveredFeatureId = hoveredFeature.id;
       }
-      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);
+      if (hoveredFeatureId !== newHoveredFeatureId) {
+        let {
+          highlightColor
+        } = this.props;
+        if (typeof highlightColor === "function") {
+          highlightColor = highlightColor(info);
+        }
+        this.setState({
+          highlightColor,
+          hoveredFeatureId: newHoveredFeatureId
+        });
       }
-      return indices.map((i) => ({
-        i
-      }));
-    }
-    getTileId({
-      i
-    }) {
-      return i;
     }
-    getTileMetadata({
-      i
-    }) {
+    getSubLayerPropsByTile(tile) {
       return {
-        bbox: tileToBoundingBox(i)
+        highlightedObjectIndex: this.getHighlightedObjectIndex(tile),
+        highlightColor: this.state.highlightColor
       };
     }
-    getTileZoom({
-      i
-    }) {
-      return (0, import_h3_js.getResolution)(i);
+    getHighlightedObjectIndex(tile) {
+      const {
+        hoveredFeatureId
+      } = this.state;
+      const data = tile.content;
+      const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
+      if (!isFeatureIdPresent || !Array.isArray(data) || !this._featureInTile(tile, hoveredFeatureId)) {
+        return -1;
+      }
+      return data.findIndex((feature) => feature.id === hoveredFeatureId);
     }
-    getParentIndex(index) {
-      const resolution = (0, import_h3_js.getResolution)(index.i);
-      const i = (0, import_h3_js.cellToParent)(index.i, resolution - 1);
-      return {
-        i
+    _featureInTile(tile, featureId) {
+      const {
+        getTileZoom,
+        getParentIndex
+      } = this.state.tileset;
+      const tileZoom = getTileZoom(tile.index);
+      const KEY = tile.index.q ? "q" : "i";
+      let featureIndex = {
+        [KEY]: featureId
       };
+      let featureZoom = getTileZoom(featureIndex);
+      while (!(featureZoom <= tileZoom)) {
+        featureIndex = getParentIndex(featureIndex);
+        featureZoom = getTileZoom(featureIndex);
+      }
+      return featureIndex[KEY] === tile.index[KEY];
     }
   };
-
-  // src/layers/spatial-index-tile-layer.ts
-  var import_core2 = __toESM(require_core2());
-
-  // src/layers/schema/carto-raster-tile.ts
-  var ARRAY_TYPES = {
-    uint8: Uint8Array,
-    uint16: Uint16Array,
-    uint32: Uint32Array,
-    uint64: BigUint64Array,
-    int8: Int8Array,
-    int16: Int16Array,
-    int32: Int32Array,
-    int64: BigInt64Array,
-    float32: Float32Array,
-    float64: Float64Array
+  __publicField(SpatialIndexTileLayer, "layerName", "SpatialIndexTileLayer");
+  __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 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}`);
+  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}`
         }
-        obj.data = {};
-        readPackedTypedArray(TypedArray, pbf, obj.data);
-      }
+      };
     }
+  }
+
+  // src/layers/h3-tile-layer.ts
+  var renderSubLayers = (props) => {
+    const {
+      data
+    } = props;
+    const {
+      index
+    } = props.tile;
+    if (!data || !data.length)
+      return null;
+    return new import_geo_layers3.H3HexagonLayer(props, {
+      getHexagon: (d) => d.id,
+      centerHexagon: index,
+      highPrecision: true
+    });
   };
-  var TileReader2 = class {
-    static read(pbf, end) {
-      return pbf.readFields(TileReader2._readField, {
-        blockWidth: 0,
-        blockHeight: 0,
-        bands: []
-      }, end);
+  var defaultProps2 = {
+    aggregationResLevel: 4,
+    data: TilejsonPropType
+  };
+  var H3TileLayer = class extends import_core3.CompositeLayer {
+    initializeState() {
+      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;
     }
-    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));
+    renderLayers() {
+      const tileJSON = this.props.data;
+      if (!tileJSON)
+        return null;
+      const {
+        tiles: data
+      } = tileJSON;
+      let {
+        minresolution,
+        maxresolution
+      } = tileJSON;
+      if (this.props.minZoom) {
+        minresolution = Math.max(minresolution, getHexagonResolution({
+          zoom: this.props.minZoom,
+          latitude: 0
+        }));
+      }
+      if (this.props.maxZoom) {
+        maxresolution = Math.min(maxresolution, getHexagonResolution({
+          zoom: this.props.maxZoom,
+          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()
+      })];
     }
   };
+  __publicField(H3TileLayer, "layerName", "H3TileLayer");
+  __publicField(H3TileLayer, "defaultProps", defaultProps2);
 
-  // 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);
+  // src/layers/quadbin-tile-layer.ts
+  var import_core4 = __toESM(require_core());
+
+  // src/layers/quadbin-layer.ts
+  var import_geo_layers4 = __toESM(require_geo_layers());
+
+  // ../../node_modules/@math.gl/web-mercator/dist/esm/web-mercator-utils.js
+  var PI = Math.PI;
+  var PI_4 = PI / 4;
+  var DEGREES_TO_RADIANS = PI / 180;
+  var RADIANS_TO_DEGREES = 180 / PI;
+  var TILE_SIZE = 512;
+  function worldToLngLat(xy) {
+    const [x, y] = xy;
+    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+    return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
+  }
+
+  // ../../node_modules/@math.gl/web-mercator/dist/esm/get-bounds.js
+  var DEGREES_TO_RADIANS2 = Math.PI / 180;
+
+  // src/layers/quadbin-utils.ts
+  var TILE_SIZE2 = 512;
+  function quadbinToOffset(quadbin) {
     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: []
-      }
-    };
+      x,
+      y,
+      z
+    } = cellToTile(quadbin);
+    const scale = TILE_SIZE2 / (1 << z);
+    return [x * scale, TILE_SIZE2 - y * scale, scale];
+  }
+  function quadbinToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
+    return [[xOffset, yOffset], [xOffset + coverage * scale, yOffset - coverage * scale]];
+  }
+  function getQuadbinPolygon(quadbin, coverage = 1) {
+    const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
+    const [w, n] = worldToLngLat(topLeft);
+    const [e, s] = worldToLngLat(bottomRight);
+    return [e, n, e, s, w, s, w, n, e, n];
   }
-  var 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);
+  // src/layers/quadbin-layer.ts
+  var defaultProps3 = {
+    getQuadbin: {
+      type: "accessor",
+      value: (d) => d.quadbin
     }
-    static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        readPackedTypedArray(BigUint64Array, pbf, obj);
+  };
+  var QuadbinLayer = class extends import_geo_layers4._GeoCellLayer {
+    indexToBounds() {
+      const {
+        data,
+        extruded,
+        getQuadbin
+      } = this.props;
+      const coverage = extruded ? 0.99 : 1;
+      return {
+        data,
+        _normalize: false,
+        positionFormat: "XY",
+        getPolygon: (x, objectInfo) => getQuadbinPolygon(getQuadbin(x, objectInfo), coverage),
+        updateTriggers: {
+          getPolygon: coverage
+        }
+      };
     }
   };
-  var CellsReader = class {
-    static read(pbf, end) {
-      return pbf.readFields(CellsReader._readField, {
-        indices: null,
-        properties: [],
-        numericProps: {}
-      }, end);
+  __publicField(QuadbinLayer, "layerName", "QuadbinLayer");
+  __publicField(QuadbinLayer, "defaultProps", defaultProps3);
+
+  // src/layers/quadbin-tileset-2d.ts
+  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,
+        i: bigIntToHex(q)
+      }));
     }
-    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;
-      }
+    getTileId({
+      q,
+      i
+    }) {
+      return i || bigIntToHex(q);
     }
-  };
-  var TileReader3 = class {
-    static read(pbf, end) {
-      return pbf.readFields(TileReader3._readField, {
-        scheme: 0,
-        cells: null
-      }, end);
+    getTileMetadata({
+      q
+    }) {
+      return super.getTileMetadata(cellToTile(q));
     }
-    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);
+    getTileZoom({
+      q
+    }) {
+      return Number(getResolution2(q));
+    }
+    getParentIndex({
+      q
+    }) {
+      return {
+        q: cellToParent2(q)
+      };
     }
   };
 
-  // ../../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");
+  // src/layers/quadbin-tile-layer.ts
+  var renderSubLayers2 = (props) => {
+    const {
+      data
+    } = props;
+    if (!data || !data.length)
+      return null;
+    const isBigInt = typeof data[0].id === "bigint";
+    return new QuadbinLayer(props, {
+      getQuadbin: isBigInt ? (d) => d.id : (d) => hexToBigInt(d.id)
+    });
+  };
+  var defaultProps4 = {
+    aggregationResLevel: 6,
+    data: TilejsonPropType
+  };
+  var QuadbinTileLayer = class extends import_core4.CompositeLayer {
+    getLoadOptions() {
+      const loadOptions = super.getLoadOptions() || {};
+      const tileJSON = this.props.data;
+      injectAccessToken(loadOptions, tileJSON.accessToken);
+      loadOptions.cartoSpatialTile = {
+        ...loadOptions.cartoSpatialTile,
+        scheme: "quadbin"
+      };
+      return loadOptions;
     }
-    const z = BigInt(tile.z);
-    let x = BigInt(tile.x) << 32n - z;
-    let y = BigInt(tile.y) << 32n - z;
-    for (let i = 0; i < 5; i++) {
-      const s = S[5 - i];
-      const b = B[4 - i];
-      x = (x | x << s) & b;
-      y = (y | y << s) & b;
-    }
-    const quadbin = 0x4000000000000000n | 1n << 59n | z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
-    return quadbin;
-  }
-  function cellToTile(quadbin) {
-    const mode = quadbin >> 59n & 7n;
-    const modeDep = quadbin >> 57n & 3n;
-    const z = quadbin >> 52n & 0x1fn;
-    const q = (quadbin & 0xfffffffffffffn) << 12n;
-    if (mode !== 1n && modeDep !== 0n) {
-      throw new Error("Wrong mode");
-    }
-    let x = q;
-    let y = q >> 1n;
-    for (let i = 0; i < 6; i++) {
-      const s = S[i];
-      const b = B[i];
-      x = (x | x >> s) & b;
-      y = (y | y >> s) & b;
-    }
-    x = x >> 32n - z;
-    y = y >> 32n - z;
-    return { z: Number(z), x: Number(x), y: Number(y) };
-  }
-  function getResolution2(quadbin) {
-    return quadbin >> 52n & 0x1fn;
-  }
-  function cellToParent2(quadbin) {
-    const zparent = getResolution2(quadbin) - 1n;
-    const parent = quadbin & ~(0x1fn << 52n) | zparent << 52n | 0xfffffffffffffn >> zparent * 2n;
-    return parent;
-  }
-
-  // src/layers/schema/spatialjson-utils.ts
-  function binaryToSpatialjson(binary) {
-    const {
-      cells,
-      scheme
-    } = binary;
-    const count = cells.indices.value.length;
-    const spatial = [];
-    for (let i = 0; i < count; i++) {
-      const id = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
-      const properties = {
-        ...cells.properties[i]
-      };
-      for (const key of Object.keys(cells.numericProps)) {
-        properties[key] = cells.numericProps[key].value[i];
-      }
-      spatial.push({
-        id,
-        properties
-      });
-    }
-    return spatial;
-  }
-
-  // src/layers/schema/carto-spatial-tile-loader.ts
-  var CartoSpatialTileLoader = {
-    name: "CARTO Spatial Tile",
-    version: "1",
-    id: "cartoSpatialTile",
-    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"
-      }
-    }
-  };
-  function parseCartoSpatialTile(arrayBuffer, options) {
-    if (!arrayBuffer)
-      return null;
-    const tile = parsePbf(arrayBuffer, TileReader3);
-    const {
-      cells
-    } = tile;
-    const scheme = options?.cartoSpatialTile?.scheme;
-    const data = {
-      cells,
-      scheme
-    };
-    return binaryToSpatialjson(data);
-  }
-  var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
-
-  // src/layers/spatial-index-tile-layer.ts
-  var import_geo_layers3 = __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 = {
-    aggregationResLevel: 4
-  };
-  var SpatialIndexTileLayer = class extends import_geo_layers3.TileLayer {
-    updateState(params) {
-      const {
-        props,
-        oldProps
-      } = params;
-      if (props.aggregationResLevel !== oldProps.aggregationResLevel) {
-        this.setState({
-          tileset: null
-        });
-      }
-      super.updateState(params);
-    }
-    _updateAutoHighlight(info) {
-      const {
-        hoveredFeatureId
-      } = this.state;
-      const hoveredFeature = info.object;
-      let newHoveredFeatureId;
-      if (hoveredFeature) {
-        newHoveredFeatureId = hoveredFeature.id;
-      }
-      if (hoveredFeatureId !== newHoveredFeatureId) {
-        let {
-          highlightColor
-        } = this.props;
-        if (typeof highlightColor === "function") {
-          highlightColor = highlightColor(info);
-        }
-        this.setState({
-          highlightColor,
-          hoveredFeatureId: newHoveredFeatureId
-        });
-      }
-    }
-    getSubLayerPropsByTile(tile) {
-      return {
-        highlightedObjectIndex: this.getHighlightedObjectIndex(tile),
-        highlightColor: this.state.highlightColor
-      };
-    }
-    getHighlightedObjectIndex(tile) {
-      const {
-        hoveredFeatureId
-      } = this.state;
-      const data = tile.content;
-      const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
-      if (!isFeatureIdPresent || !Array.isArray(data) || !this._featureInTile(tile, hoveredFeatureId)) {
-        return -1;
-      }
-      return data.findIndex((feature) => feature.id === hoveredFeatureId);
-    }
-    _featureInTile(tile, featureId) {
-      const {
-        getTileZoom,
-        getParentIndex
-      } = this.state.tileset;
-      const tileZoom = getTileZoom(tile.index);
-      const KEY = tile.index.q ? "q" : "i";
-      let featureIndex = {
-        [KEY]: featureId
-      };
-      let featureZoom = getTileZoom(featureIndex);
-      while (!(featureZoom <= tileZoom)) {
-        featureIndex = getParentIndex(featureIndex);
-        featureZoom = getTileZoom(featureIndex);
-      }
-      return featureIndex[KEY] === tile.index[KEY];
-    }
-  };
-  __publicField(SpatialIndexTileLayer, "layerName", "SpatialIndexTileLayer");
-  __publicField(SpatialIndexTileLayer, "defaultProps", defaultProps2);
-
-  // src/layers/h3-tile-layer.ts
-  var renderSubLayers = (props) => {
-    const {
-      data
-    } = props;
-    const {
-      index
-    } = props.tile;
-    if (!data || !data.length)
-      return null;
-    return new import_geo_layers4.H3HexagonLayer(props, {
-      getHexagon: (d) => d.id,
-      centerHexagon: index,
-      highPrecision: true
-    });
-  };
-  var defaultProps3 = {
-    aggregationResLevel: 4
-  };
-  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
-        });
-      }
-    }
-    renderLayers() {
-      const {
-        data,
-        tileJSON
-      } = this.state;
-      let minresolution = parseInt(tileJSON.minresolution);
-      let maxresolution = parseInt(tileJSON.maxresolution);
-      if (this.props.minZoom) {
-        minresolution = Math.max(minresolution, getHexagonResolution({
-          zoom: this.props.minZoom,
-          latitude: 0
-        }));
-      }
-      if (this.props.maxZoom) {
-        maxresolution = Math.min(maxresolution, getHexagonResolution({
-          zoom: this.props.maxZoom,
-          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"
-        }
-      })];
-    }
-  };
-  __publicField(H3TileLayer, "layerName", "H3TileLayer");
-  __publicField(H3TileLayer, "defaultProps", defaultProps3);
-
-  // 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());
-
-  // ../../node_modules/@math.gl/web-mercator/dist/esm/web-mercator-utils.js
-  var PI = Math.PI;
-  var PI_4 = PI / 4;
-  var DEGREES_TO_RADIANS = PI / 180;
-  var RADIANS_TO_DEGREES = 180 / PI;
-  var TILE_SIZE = 512;
-  function worldToLngLat(xy) {
-    const [x, y] = xy;
-    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
-    return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
-  }
-
-  // ../../node_modules/@math.gl/web-mercator/dist/esm/get-bounds.js
-  var DEGREES_TO_RADIANS2 = Math.PI / 180;
-
-  // src/layers/quadbin-utils.ts
-  var TILE_SIZE2 = 512;
-  function quadbinToOffset(quadbin) {
-    const {
-      x,
-      y,
-      z
-    } = cellToTile(quadbin);
-    const scale = TILE_SIZE2 / (1 << z);
-    return [x * scale, TILE_SIZE2 - y * scale, scale];
-  }
-  function quadbinToWorldBounds(quadbin, coverage) {
-    const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
-    return [[xOffset, yOffset], [xOffset + coverage * scale, yOffset - coverage * scale]];
-  }
-  function getQuadbinPolygon(quadbin, coverage = 1) {
-    const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
-    const [w, n] = worldToLngLat(topLeft);
-    const [e, s] = worldToLngLat(bottomRight);
-    return [e, n, e, s, w, s, w, n, e, n];
-  }
-
-  // src/layers/quadbin-layer.ts
-  var defaultProps4 = {
-    getQuadbin: {
-      type: "accessor",
-      value: (d) => d.quadbin
-    }
-  };
-  var QuadbinLayer = class extends import_geo_layers5._GeoCellLayer {
-    indexToBounds() {
-      const {
-        data,
-        extruded,
-        getQuadbin
-      } = this.props;
-      const coverage = extruded ? 0.99 : 1;
-      return {
-        data,
-        _normalize: false,
-        positionFormat: "XY",
-        getPolygon: (x, objectInfo) => getQuadbinPolygon(getQuadbin(x, objectInfo), coverage),
-        updateTriggers: {
-          getPolygon: coverage
-        }
-      };
-    }
-  };
-  __publicField(QuadbinLayer, "layerName", "QuadbinLayer");
-  __publicField(QuadbinLayer, "defaultProps", defaultProps4);
-
-  // src/layers/quadbin-tileset-2d.ts
-  var import_geo_layers6 = __toESM(require_geo_layers());
-  var QuadbinTileset2D = class extends import_geo_layers6._Tileset2D {
-    getTileIndices(opts) {
-      return super.getTileIndices(opts).map(tileToCell).map((q) => ({
-        q,
-        i: bigIntToHex(q)
-      }));
-    }
-    getTileId({
-      q,
-      i
-    }) {
-      return i || bigIntToHex(q);
-    }
-    getTileMetadata({
-      q
-    }) {
-      return super.getTileMetadata(cellToTile(q));
-    }
-    getTileZoom({
-      q
-    }) {
-      return Number(getResolution2(q));
-    }
-    getParentIndex({
-      q
-    }) {
-      return {
-        q: cellToParent2(q)
-      };
-    }
-  };
-
-  // src/layers/quadbin-tile-layer.ts
-  var renderSubLayers2 = (props) => {
-    const {
-      data
-    } = props;
-    if (!data || !data.length)
-      return null;
-    const isBigInt = typeof data[0].id === "bigint";
-    return new QuadbinLayer(props, {
-      getQuadbin: isBigInt ? (d) => d.id : (d) => hexToBigInt(d.id)
-    });
-  };
-  var defaultProps5 = {
-    aggregationResLevel: 6
-  };
-  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
-        });
-      }
-    }
-    renderLayers() {
-      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"
-        }
-      })];
+    renderLayers() {
+      const tileJSON = this.props.data;
+      if (!tileJSON)
+        return null;
+      const {
+        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
@@ -12802,209 +12394,567 @@ void main(void) {
       strokeOffsetRatio -= halfOffset;
     }
   }
-
-  geometry.pickingColor = instancePickingColors;
-
-  // project center of column
-  vec2 offset = (vec2(0.5) + positions.xy * strokeOffsetRatio) * cellWidth * shouldRender;
-  vec3 pos = vec3(offset, project_size(elevation));
-  DECKGL_FILTER_SIZE(pos, geometry);
-
-  geometry.position.xyz += pos;
-  gl_Position = project_common_position_to_clipspace(geometry.position);
-
-  geometry.normal = project_normal(normals);
-  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
-
-  // Light calculations
-  if (extruded && !isStroke) {
-#ifdef FLAT_SHADING
-    position_commonspace = geometry.position;
-    vColor = vec4(color.rgb, color.a * opacity);
-#else
-    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);
-    vColor = vec4(lightColor, color.a * opacity);
-#endif
-  } else {
-    vColor = vec4(color.rgb, color.a * opacity);
+
+  geometry.pickingColor = instancePickingColors;
+
+  // project center of column
+  vec2 offset = (vec2(0.5) + positions.xy * strokeOffsetRatio) * cellWidth * shouldRender;
+  vec3 pos = vec3(offset, project_size(elevation));
+  DECKGL_FILTER_SIZE(pos, geometry);
+
+  geometry.position.xyz += pos;
+  gl_Position = project_common_position_to_clipspace(geometry.position);
+
+  geometry.normal = project_normal(normals);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  // Light calculations
+  if (extruded && !isStroke) {
+#ifdef FLAT_SHADING
+    position_commonspace = geometry.position;
+    vColor = vec4(color.rgb, color.a * opacity);
+#else
+    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);
+    vColor = vec4(lightColor, color.a * opacity);
+#endif
+  } else {
+    vColor = vec4(color.rgb, color.a * opacity);
+  }
+
+  DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;
+
+  // src/layers/raster-layer.ts
+  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_layers.ColumnLayer {
+    getShaders() {
+      const shaders = super.getShaders();
+      return {
+        ...shaders,
+        vs: raster_layer_vertex_glsl_default
+      };
+    }
+    initializeState() {
+      const attributeManager = this.getAttributeManager();
+      attributeManager.addInstanced({
+        instanceElevations: {
+          size: 1,
+          transition: true,
+          accessor: "getElevation"
+        },
+        instanceFillColors: {
+          size: this.props.colorFormat.length,
+          type: 5121,
+          normalized: true,
+          transition: true,
+          accessor: "getFillColor",
+          defaultValue: [0, 0, 0, 255]
+        },
+        instanceLineColors: {
+          size: this.props.colorFormat.length,
+          type: 5121,
+          normalized: true,
+          transition: true,
+          accessor: "getLineColor",
+          defaultValue: [255, 255, 255, 255]
+        }
+      });
+    }
+  };
+  __publicField(RasterColumnLayer, "layerName", "RasterColumnLayer");
+  var RasterLayer = class extends import_core5.CompositeLayer {
+    renderLayers() {
+      const {
+        data,
+        getElevation,
+        getFillColor,
+        getLineColor,
+        getLineWidth,
+        tileIndex,
+        updateTriggers
+      } = this.props;
+      if (!data || !tileIndex)
+        return null;
+      const {
+        blockWidth,
+        blockHeight
+      } = data;
+      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);
+      return new CellLayer(this.props, this.getSubLayerProps({
+        id: "cell",
+        updateTriggers,
+        getElevation: this.getSubLayerAccessor(getElevation),
+        getFillColor: this.getSubLayerAccessor(getFillColor),
+        getLineColor: this.getSubLayerAccessor(getLineColor),
+        getLineWidth: this.getSubLayerAccessor(getLineWidth)
+      }), {
+        data: {
+          data,
+          length: blockWidth * blockHeight
+        },
+        offset
+      });
+    }
+    getSubLayerAccessor(accessor) {
+      if (typeof accessor !== "function") {
+        return super.getSubLayerAccessor(accessor);
+      }
+      return (object, info) => {
+        const {
+          data,
+          index
+        } = info;
+        const binaryData = data.data;
+        const proxy = createBinaryProxy(binaryData.cells, index);
+        return accessor({
+          properties: proxy
+        }, info);
+      };
+    }
+  };
+  __publicField(RasterLayer, "layerName", "RasterLayer");
+  __publicField(RasterLayer, "defaultProps", 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 = true ? "8.10.0-alpha.5" : "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;
   }
-
-  DECKGL_FILTER_COLOR(vColor, geometry);
-}
-`;
-
-  // src/utils.ts
-  var import_core5 = __toESM(require_core());
-  function assert2(condition, message) {
-    import_core5.log.assert(condition, message);
+  function 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 createBinaryProxy(data, index) {
+  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 {
-      properties,
-      numericProps
+      positions
     } = 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;
+    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);
       }
-    });
-  }
-
-  // src/layers/raster-layer.ts
-  var defaultProps6 = {
-    ...import_layers2.ColumnLayer.defaultProps,
-    extruded: false,
-    diskResolution: 4,
-    vertices: [[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]]
-  };
-  var RasterColumnLayer = class extends import_layers2.ColumnLayer {
-    getShaders() {
-      const shaders = super.getShaders();
       return {
-        ...shaders,
-        vs: raster_layer_vertex_glsl_default
+        type: "Polygon",
+        coordinates: coordinates2
       };
     }
-    initializeState() {
-      const attributeManager = this.getAttributeManager();
-      attributeManager.addInstanced({
-        instanceElevations: {
-          size: 1,
-          transition: true,
-          accessor: "getElevation"
-        },
-        instanceFillColors: {
-          size: this.props.colorFormat.length,
-          type: esm_default.UNSIGNED_BYTE,
-          normalized: true,
-          transition: true,
-          accessor: "getFillColor",
-          defaultValue: [0, 0, 0, 255]
-        },
-        instanceLineColors: {
-          size: this.props.colorFormat.length,
-          type: esm_default.UNSIGNED_BYTE,
-          normalized: true,
-          transition: true,
-          accessor: "getLineColor",
-          defaultValue: [255, 255, 255, 255]
-        }
-      });
+    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);
     }
-  };
-  __publicField(RasterColumnLayer, "layerName", "RasterColumnLayer");
-  var RasterLayer = class extends import_core6.CompositeLayer {
-    renderLayers() {
-      const {
-        data,
-        getElevation,
-        getFillColor,
-        getLineColor,
-        getLineWidth,
-        tileIndex,
-        updateTriggers
-      } = this.props;
-      if (!data || !tileIndex)
-        return null;
-      const {
-        blockWidth,
-        blockHeight
-      } = data;
-      assert2(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
-      const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
-      const offset = [xOffset, yOffset, scale / blockWidth];
-      const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
-      return new CellLayer(this.props, this.getSubLayerProps({
-        id: "cell",
-        updateTriggers,
-        getElevation: this.getSubLayerAccessor(getElevation),
-        getFillColor: this.getSubLayerAccessor(getFillColor),
-        getLineColor: this.getSubLayerAccessor(getLineColor),
-        getLineWidth: this.getSubLayerAccessor(getLineWidth)
-      }), {
-        data: {
-          data,
-          length: blockWidth * blockHeight
-        },
-        offset
-      });
+    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
+      };
     }
-    getSubLayerAccessor(accessor) {
-      if (typeof accessor !== "function") {
-        return super.getSubLayerAccessor(accessor);
-      }
-      return (object, info) => {
-        const {
-          data,
-          index
-        } = info;
-        const binaryData = data.data;
-        const proxy = createBinaryProxy(binaryData.cells, index);
-        return accessor({
-          properties: proxy
-        }, info);
+    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
       };
     }
-  };
-  __publicField(RasterLayer, "layerName", "RasterLayer");
-  __publicField(RasterLayer, "defaultProps", defaultProps6);
+    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 +13036,7 @@ void main(void) {
     elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
     percentile: ["lowerPercentile", "upperPercentile"]
   };
-  var defaultProps7 = {
+  var defaultProps8 = {
     lineMiterLimit: 2,
     lineWidthUnits: "pixels",
     pointRadiusUnits: "pixels",
@@ -13187,12 +13137,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 +13157,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 +13173,7 @@ void main(void) {
       Layer: layerFromTileDataset(formatTiles, scheme),
       propMap: basePropMap,
       defaultProps: {
-        ...defaultProps7,
+        ...defaultProps8,
         ...aggregationExp && {
           aggregationExp
         },
@@ -13485,7 +13432,7 @@ void main(void) {
     }
   };
   __publicField(EnhancedTextLayer, "layerName", "EnhancedTextLayer");
-  var defaultProps8 = {
+  var defaultProps9 = {
     ...import_layers4.TextLayer.defaultProps,
     getRadius: {
       type: "accessor",
@@ -13552,7 +13499,7 @@ void main(void) {
       }
       return backgroundPadding;
     }
-    renderTextLayer(id, {
+    renderTextLayer(id4, {
       updateTriggers: updateTriggersOverride = {},
       ...props
     }) {
@@ -13573,7 +13520,7 @@ void main(void) {
         updateTriggers
       } = this.props;
       return new EnhancedTextLayer(this.getSubLayerProps({
-        id,
+        id: id4,
         data,
         characterSet,
         fontFamily,
@@ -13611,33 +13558,30 @@ void main(void) {
       } = this.props;
       const getPixelOffset = this.calculatePixelOffset(false);
       const backgroundPadding = this.calculateBackgroundPadding();
-      const out = [
-        this.renderTextLayer(`${updateTriggers.getText}-primary`, {
-          backgroundPadding,
-          getText,
-          getPixelOffset,
-          background: true
-        }),
-        Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
-          getText: getSecondaryText,
-          getPixelOffset: this.calculatePixelOffset(true),
-          getAlignmentBaseline: "top",
-          ...getSecondaryColor && {
-            getColor: getSecondaryColor
-          },
-          ...secondarySizeScale && {
-            sizeScale: secondarySizeScale
-          },
-          ...secondaryOutlineColor && {
-            outlineColor: secondaryOutlineColor
-          }
-        })
-      ];
+      const out = [this.renderTextLayer(`${updateTriggers.getText}-primary`, {
+        backgroundPadding,
+        getText,
+        getPixelOffset,
+        background: true
+      }), Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
+        getText: getSecondaryText,
+        getPixelOffset: this.calculatePixelOffset(true),
+        getAlignmentBaseline: "top",
+        ...getSecondaryColor && {
+          getColor: getSecondaryColor
+        },
+        ...secondarySizeScale && {
+          sizeScale: secondarySizeScale
+        },
+        ...secondaryOutlineColor && {
+          outlineColor: secondaryOutlineColor
+        }
+      })];
       return out;
     }
   };
   __publicField(PointLabelLayer, "layerName", "PointLabelLayer");
-  __publicField(PointLabelLayer, "defaultProps", defaultProps8);
+  __publicField(PointLabelLayer, "defaultProps", defaultProps9);
 
   // src/api/parseMap.ts
   var import_core9 = __toESM(require_core());
@@ -13649,7 +13593,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 +13613,7 @@ void main(void) {
       mapStyle,
       token,
       layers: layers.reverse().map(({
-        id,
+        id: id4,
         type,
         config,
         visualChannels
@@ -13679,24 +13623,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)
           });
@@ -13709,11 +13653,11 @@ void main(void) {
   }
   function createParametersProp(layerBlending, parameters) {
     if (layerBlending === "additive") {
-      parameters.blendFunc = [esm_default.SRC_ALPHA, esm_default.DST_ALPHA];
-      parameters.blendEquation = esm_default.FUNC_ADD;
+      parameters.blendFunc = [770, 772];
+      parameters.blendEquation = 32774;
     } else if (layerBlending === "subtractive") {
-      parameters.blendFunc = [esm_default.ONE, esm_default.ONE_MINUS_DST_COLOR, esm_default.SRC_ALPHA, esm_default.DST_ALPHA];
-      parameters.blendEquation = [esm_default.FUNC_SUBTRACT, esm_default.FUNC_ADD];
+      parameters.blendFunc = [1, 775, 770, 772];
+      parameters.blendEquation = [32778, 32774];
     }
     return Object.keys(parameters).length ? {
       parameters
@@ -13761,7 +13705,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,
@@ -13802,16 +13746,10 @@ void main(void) {
         colorAggregation: aggregation,
         colorRange: range2
       } = visConfig;
-      result.getFillColor = getColorAccessor(
-        colorField,
-        colorScale,
-        {
-          aggregation,
-          range: range2
-        },
-        visConfig.opacity,
-        data
-      );
+      result.getFillColor = getColorAccessor(colorField, colorScale, {
+        aggregation,
+        range: range2
+      }, visConfig.opacity, data);
     }
     if (type === "point") {
       const altitude = config.columns?.altitude;
@@ -13834,13 +13772,7 @@ void main(void) {
       }
     }
     if (radiusField || sizeField) {
-      result.getPointRadius = getSizeAccessor(
-        radiusField || sizeField,
-        radiusScale || sizeScale,
-        visConfig.sizeAggregation,
-        visConfig.radiusRange || visConfig.sizeRange,
-        data
-      );
+      result.getPointRadius = getSizeAccessor(radiusField || sizeField, radiusScale || sizeScale, visConfig.sizeAggregation, visConfig.radiusRange || visConfig.sizeRange, data);
     }
     if (strokeColorField) {
       const fallbackOpacity = type === "point" ? visConfig.opacity : 1;
@@ -13849,25 +13781,13 @@ void main(void) {
         strokeColorAggregation: aggregation,
         strokeColorRange: range2
       } = visConfig;
-      result.getLineColor = getColorAccessor(
-        strokeColorField,
-        strokeColorScale,
-        {
-          aggregation,
-          range: range2
-        },
-        opacity,
-        data
-      );
+      result.getLineColor = getColorAccessor(strokeColorField, strokeColorScale, {
+        aggregation,
+        range: range2
+      }, opacity, data);
     }
     if (heightField && visConfig.enable3d) {
-      result.getElevation = getSizeAccessor(
-        heightField,
-        heightScale,
-        visConfig.heightAggregation,
-        visConfig.heightRange || visConfig.sizeRange,
-        data
-      );
+      result.getElevation = getSizeAccessor(heightField, heightScale, visConfig.heightAggregation, visConfig.heightRange || visConfig.sizeRange, data);
     }
     if (visConfig.customMarkers) {
       const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
@@ -13914,7 +13834,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 +13895,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 +13963,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 +13983,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 +14051,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 +14085,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 +14206,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 +14216,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 +14307,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 +14392,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 +14465,7 @@ void main(void) {
   }
 
   // src/layers/carto-layer.ts
-  var defaultProps9 = {
+  var defaultProps10 = {
     data: null,
     type: null,
     onDataLoad: {
@@ -14699,14 +14610,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 +14634,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 +14672,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 +14796,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());