@deck.gl/carto 8.9.24 → 8.9.26

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;
@@ -5355,6 +5355,473 @@ var __exports__ = (() => {
     }
   });
 
+  // ../../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;
+      };
+    }
+  });
+
   // ../../node_modules/pbf/node_modules/ieee754/index.js
   var require_ieee754 = __commonJS({
     "../../node_modules/pbf/node_modules/ieee754/index.js"(exports) {
@@ -6330,11 +6797,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 +6839,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,8 +6891,8 @@ 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];
       }
     }
@@ -11467,7 +11934,10 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var import_geo_layers7 = __toESM(require_geo_layers());
 
   // src/layers/carto-tile-layer.ts
-  var import_core = __toESM(require_core2());
+  var import_core2 = __toESM(require_core2());
+
+  // src/layers/schema/carto-vector-tile-loader.ts
+  var import_earcut = __toESM(require_earcut());
 
   // src/layers/schema/fast-pbf.ts
   function readPackedTypedArray(TypedArray, pbf, obj) {
@@ -11703,24 +12173,100 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     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-vector-tile-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id = "cartoVectorTile";
+  var DEFAULT_OPTIONS = {
+    cartoVectorTile: {
+      workerUrl: getWorkerUrl(id, VERSION)
+    }
+  };
   var CartoVectorTileLoader = {
     name: "CARTO Vector Tile",
-    version: "1",
-    id: "cartoVectorTile",
+    version: VERSION,
+    id,
     module: "carto",
     extensions: ["pbf"],
     mimeTypes: ["application/vnd.carto-vector-tile"],
     category: "geometry",
-    worker: false,
     parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),
     parseSync: parseCartoVectorTile,
-    options: {}
+    worker: true,
+    options: DEFAULT_OPTIONS
   };
+  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, TileReader);
+    if (tile.polygons && !tile.polygons.triangles) {
+      triangulate(tile.polygons);
+    }
     return tile;
   }
   var carto_vector_tile_loader_default = CartoVectorTileLoader;
@@ -11944,7 +12490,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/carto-tile-layer.ts
-  (0, import_core.registerLoaders)([carto_vector_tile_loader_default]);
+  (0, import_core2.registerLoaders)([carto_vector_tile_loader_default]);
   var defaultTileFormat = TILE_FORMATS.BINARY;
   var defaultProps = {
     ...import_geo_layers.MVTLayer.defaultProps,
@@ -11963,20 +12509,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       if (!url) {
         return Promise.reject("Invalid URL");
       }
-      let loadOptions = this.getLoadOptions();
+      const loadOptions = this.getLoadOptions();
       const {
-        fetch: fetch2,
-        formatTiles
+        fetch: fetch2
       } = this.props;
       const {
         signal
       } = tile;
-      if (formatTiles === TILE_FORMATS.BINARY) {
-        loadOptions = {
-          ...loadOptions,
-          mimeType: "application/vnd.carto-vector-tile"
-        };
-      }
       return fetch2(url, {
         propName: "data",
         layer: this,
@@ -12021,7 +12560,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   __publicField(CartoTileLayer, "defaultProps", defaultProps);
 
   // src/layers/h3-tile-layer.ts
-  var import_core3 = __toESM(require_core());
+  var import_core4 = __toESM(require_core());
   var import_geo_layers4 = __toESM(require_geo_layers());
 
   // src/layers/h3-tileset-2d.ts
@@ -12131,7 +12670,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
 
   // src/layers/spatial-index-tile-layer.ts
-  var import_core2 = __toESM(require_core2());
+  var import_core3 = __toESM(require_core2());
 
   // src/layers/schema/carto-raster-tile.ts
   var ARRAY_TYPES = {
@@ -12188,18 +12727,25 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
 
   // src/layers/schema/carto-raster-tile-loader.ts
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id2 = "cartoRasterTile";
+  var DEFAULT_OPTIONS2 = {
+    cartoRasterTile: {
+      workerUrl: getWorkerUrl(id2, VERSION2)
+    }
+  };
   var CartoRasterTileLoader = {
     name: "CARTO Raster Tile",
-    version: "1",
-    id: "cartoRasterTile",
+    version: VERSION2,
+    id: id2,
     module: "carto",
     extensions: ["pbf"],
     mimeTypes: ["application/vnd.carto-raster-tile"],
     category: "geometry",
-    worker: false,
     parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
     parseSync: parseCartoRasterTile,
-    options: {}
+    worker: true,
+    options: DEFAULT_OPTIONS2
   };
   function parseCartoRasterTile(arrayBuffer, options) {
     if (!arrayBuffer)
@@ -12346,7 +12892,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const count = cells.indices.value.length;
     const spatial = [];
     for (let i = 0; i < count; i++) {
-      const id = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
+      const id4 = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
       const properties = {
         ...cells.properties[i]
       };
@@ -12354,7 +12900,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         properties[key] = cells.numericProps[key].value[i];
       }
       spatial.push({
-        id,
+        id: id4,
         properties
       });
     }
@@ -12362,22 +12908,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/layers/schema/carto-spatial-tile-loader.ts
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var id3 = "cartoSpatialTile";
+  var DEFAULT_OPTIONS3 = {
+    cartoSpatialTile: {
+      scheme: "quadbin",
+      workerUrl: getWorkerUrl(id3, VERSION3)
+    }
+  };
   var CartoSpatialTileLoader = {
     name: "CARTO Spatial Tile",
-    version: "1",
-    id: "cartoSpatialTile",
+    version: VERSION3,
+    id: id3,
     module: "carto",
     extensions: ["pbf"],
     mimeTypes: ["application/vnd.carto-spatial-tile"],
     category: "geometry",
-    worker: false,
     parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
     parseSync: parseCartoSpatialTile,
-    options: {
-      cartoSpatialTile: {
-        scheme: "quadbin"
-      }
-    }
+    worker: true,
+    options: DEFAULT_OPTIONS3
   };
   function parseCartoSpatialTile(arrayBuffer, options) {
     if (!arrayBuffer)
@@ -12397,7 +12947,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/layers/spatial-index-tile-layer.ts
   var import_geo_layers3 = __toESM(require_geo_layers());
-  (0, import_core2.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
+  (0, import_core3.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
   function isFeatureIdDefined(value) {
     return value !== void 0 && value !== null && value !== "";
   }
@@ -12496,7 +13046,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var defaultProps3 = {
     aggregationResLevel: 4
   };
-  var H3TileLayer = class extends import_core3.CompositeLayer {
+  var H3TileLayer = class extends import_core4.CompositeLayer {
     initializeState() {
       import_geo_layers4.H3HexagonLayer._checkH3Lib();
       this.setState({
@@ -12549,8 +13099,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           ...this.getLoadOptions(),
           cartoSpatialTile: {
             scheme: "h3"
-          },
-          mimeType: "application/vnd.carto-spatial-tile"
+          }
         }
       })];
     }
@@ -12559,7 +13108,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   __publicField(H3TileLayer, "defaultProps", defaultProps3);
 
   // src/layers/quadbin-tile-layer.ts
-  var import_core4 = __toESM(require_core());
+  var import_core5 = __toESM(require_core());
 
   // src/layers/quadbin-layer.ts
   var import_geo_layers5 = __toESM(require_geo_layers());
@@ -12680,7 +13229,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var defaultProps5 = {
     aggregationResLevel: 6
   };
-  var QuadbinTileLayer = class extends import_core4.CompositeLayer {
+  var QuadbinTileLayer = class extends import_core5.CompositeLayer {
     initializeState() {
       this.setState({
         data: null,
@@ -12718,8 +13267,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           ...this.getLoadOptions(),
           cartoSpatialTile: {
             scheme: "quadbin"
-          },
-          mimeType: "application/vnd.carto-spatial-tile"
+          }
         }
       })];
     }
@@ -12833,29 +13381,6 @@ void main(void) {
 }
 `;
 
-  // src/utils.ts
-  var import_core5 = __toESM(require_core());
-  function assert2(condition, message) {
-    import_core5.log.assert(condition, message);
-  }
-  function createBinaryProxy(data, index) {
-    const {
-      properties,
-      numericProps
-    } = data;
-    return new Proxy(properties[index] || {}, {
-      get(target, property, receiver) {
-        if (property in numericProps) {
-          return numericProps[property].value[index];
-        }
-        return target[property];
-      },
-      has(target, property) {
-        return property in numericProps || property in target;
-      }
-    });
-  }
-
   // src/layers/raster-layer.ts
   var defaultProps6 = {
     ...import_layers2.ColumnLayer.defaultProps,
@@ -12916,7 +13441,7 @@ void main(void) {
         blockWidth,
         blockHeight
       } = data;
-      assert2(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
+      assert(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
       const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
       const offset = [xOffset, yOffset, scale / blockWidth];
       const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
@@ -13187,7 +13712,7 @@ 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),
@@ -13552,7 +14077,7 @@ void main(void) {
       }
       return backgroundPadding;
     }
-    renderTextLayer(id, {
+    renderTextLayer(id4, {
       updateTriggers: updateTriggersOverride = {},
       ...props
     }) {
@@ -13573,7 +14098,7 @@ void main(void) {
         updateTriggers
       } = this.props;
       return new EnhancedTextLayer(this.getSubLayerProps({
-        id,
+        id: id4,
         data,
         characterSet,
         fontFamily,
@@ -13649,7 +14174,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 +14194,7 @@ void main(void) {
       mapStyle,
       token,
       layers: layers.reverse().map(({
-        id,
+        id: id4,
         type,
         config,
         visualChannels
@@ -13679,11 +14204,11 @@ 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,
@@ -13691,12 +14216,12 @@ void main(void) {
           } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
           return new Layer({
-            id,
+            id: id4,
             data,
             ...defaultProps10,
             ...createInteractionProps(interactionConfig),
             ...styleProps,
-            ...createChannelProps(id, type, config, visualChannels, data),
+            ...createChannelProps(id4, type, config, visualChannels, data),
             ...createParametersProp(layerBlending, styleProps.parameters || {}),
             ...createLoadOptions(token)
           });
@@ -13761,7 +14286,7 @@ void main(void) {
     result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
     return result;
   }
-  function createChannelProps(id, type, config, visualChannels, data) {
+  function createChannelProps(id4, type, config, visualChannels, data) {
     const {
       colorField,
       colorScale,
@@ -13914,7 +14439,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,
@@ -13977,7 +14502,7 @@ void main(void) {
   var import_core10 = __toESM(require_core());
   var MAX_GET_LENGTH = 8192;
   var DEFAULT_CLIENT = "deck-gl-carto";
-  var V3_MINOR_VERSION = "3.1";
+  var V3_MINOR_VERSION = "3.2";
   async function request2({
     method,
     url,
@@ -14174,20 +14699,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,7 +14820,7 @@ 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];
       for (const f of prioritizedFormats) {
@@ -14305,7 +14830,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`);
@@ -14481,16 +15006,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 = {
@@ -14699,7 +15224,7 @@ void main(void) {
       }
     }
     _getSubLayerAndProps() {
-      assert2(this.state);
+      assert(this.state);
       const {
         data,
         apiVersion
@@ -14723,7 +15248,7 @@ void main(void) {
       return [layerFromTileDataset(props.formatTiles, data.scheme, props.type), props];
     }
     renderLayers() {
-      assert2(this.state);
+      assert(this.state);
       const {
         apiVersion,
         data