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

package/dist/cartoVectorTile-worker.js

@@ -0,0 +1,1727 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // ../../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) {
+      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+        var e, m;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var nBits = -7;
+        var i = isLE ? nBytes - 1 : 0;
+        var d = isLE ? -1 : 1;
+        var s = buffer[offset + i];
+        i += d;
+        e = s & (1 << -nBits) - 1;
+        s >>= -nBits;
+        nBits += eLen;
+        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+        }
+        m = e & (1 << -nBits) - 1;
+        e >>= -nBits;
+        nBits += mLen;
+        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+        }
+        if (e === 0) {
+          e = 1 - eBias;
+        } else if (e === eMax) {
+          return m ? NaN : (s ? -1 : 1) * Infinity;
+        } else {
+          m = m + Math.pow(2, mLen);
+          e = e - eBias;
+        }
+        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+      };
+      exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+        var e, m, c;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+        var i = isLE ? 0 : nBytes - 1;
+        var d = isLE ? 1 : -1;
+        var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+        value = Math.abs(value);
+        if (isNaN(value) || value === Infinity) {
+          m = isNaN(value) ? 1 : 0;
+          e = eMax;
+        } else {
+          e = Math.floor(Math.log(value) / Math.LN2);
+          if (value * (c = Math.pow(2, -e)) < 1) {
+            e--;
+            c *= 2;
+          }
+          if (e + eBias >= 1) {
+            value += rt / c;
+          } else {
+            value += rt * Math.pow(2, 1 - eBias);
+          }
+          if (value * c >= 2) {
+            e++;
+            c /= 2;
+          }
+          if (e + eBias >= eMax) {
+            m = 0;
+            e = eMax;
+          } else if (e + eBias >= 1) {
+            m = (value * c - 1) * Math.pow(2, mLen);
+            e = e + eBias;
+          } else {
+            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+            e = 0;
+          }
+        }
+        for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+        }
+        e = e << mLen | m;
+        eLen += mLen;
+        for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+        }
+        buffer[offset + i - d] |= s * 128;
+      };
+    }
+  });
+
+  // ../../node_modules/pbf/index.js
+  var require_pbf = __commonJS({
+    "../../node_modules/pbf/index.js"(exports, module) {
+      "use strict";
+      module.exports = Pbf;
+      var ieee754 = require_ieee754();
+      function Pbf(buf) {
+        this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
+        this.pos = 0;
+        this.type = 0;
+        this.length = this.buf.length;
+      }
+      Pbf.Varint = 0;
+      Pbf.Fixed64 = 1;
+      Pbf.Bytes = 2;
+      Pbf.Fixed32 = 5;
+      var SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
+      var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
+      var TEXT_DECODER_MIN_LENGTH = 12;
+      var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf8");
+      Pbf.prototype = {
+        destroy: function() {
+          this.buf = null;
+        },
+        readFields: function(readField, result, end) {
+          end = end || this.length;
+          while (this.pos < end) {
+            var val = this.readVarint(), tag = val >> 3, startPos = this.pos;
+            this.type = val & 7;
+            readField(tag, result, this);
+            if (this.pos === startPos)
+              this.skip(val);
+          }
+          return result;
+        },
+        readMessage: function(readField, result) {
+          return this.readFields(readField, result, this.readVarint() + this.pos);
+        },
+        readFixed32: function() {
+          var val = readUInt32(this.buf, this.pos);
+          this.pos += 4;
+          return val;
+        },
+        readSFixed32: function() {
+          var val = readInt32(this.buf, this.pos);
+          this.pos += 4;
+          return val;
+        },
+        readFixed64: function() {
+          var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+          this.pos += 8;
+          return val;
+        },
+        readSFixed64: function() {
+          var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+          this.pos += 8;
+          return val;
+        },
+        readFloat: function() {
+          var val = ieee754.read(this.buf, this.pos, true, 23, 4);
+          this.pos += 4;
+          return val;
+        },
+        readDouble: function() {
+          var val = ieee754.read(this.buf, this.pos, true, 52, 8);
+          this.pos += 8;
+          return val;
+        },
+        readVarint: function(isSigned) {
+          var buf = this.buf, val, b;
+          b = buf[this.pos++];
+          val = b & 127;
+          if (b < 128)
+            return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 7;
+          if (b < 128)
+            return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 14;
+          if (b < 128)
+            return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 21;
+          if (b < 128)
+            return val;
+          b = buf[this.pos];
+          val |= (b & 15) << 28;
+          return readVarintRemainder(val, isSigned, this);
+        },
+        readVarint64: function() {
+          return this.readVarint(true);
+        },
+        readSVarint: function() {
+          var num = this.readVarint();
+          return num % 2 === 1 ? (num + 1) / -2 : num / 2;
+        },
+        readBoolean: function() {
+          return Boolean(this.readVarint());
+        },
+        readString: function() {
+          var end = this.readVarint() + this.pos;
+          var pos = this.pos;
+          this.pos = end;
+          if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
+            return readUtf8TextDecoder(this.buf, pos, end);
+          }
+          return readUtf8(this.buf, pos, end);
+        },
+        readBytes: function() {
+          var end = this.readVarint() + this.pos, buffer = this.buf.subarray(this.pos, end);
+          this.pos = end;
+          return buffer;
+        },
+        readPackedVarint: function(arr, isSigned) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readVarint(isSigned));
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readVarint(isSigned));
+          return arr;
+        },
+        readPackedSVarint: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readSVarint());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readSVarint());
+          return arr;
+        },
+        readPackedBoolean: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readBoolean());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readBoolean());
+          return arr;
+        },
+        readPackedFloat: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readFloat());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readFloat());
+          return arr;
+        },
+        readPackedDouble: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readDouble());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readDouble());
+          return arr;
+        },
+        readPackedFixed32: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readFixed32());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readFixed32());
+          return arr;
+        },
+        readPackedSFixed32: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readSFixed32());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readSFixed32());
+          return arr;
+        },
+        readPackedFixed64: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readFixed64());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readFixed64());
+          return arr;
+        },
+        readPackedSFixed64: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readSFixed64());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readSFixed64());
+          return arr;
+        },
+        skip: function(val) {
+          var type = val & 7;
+          if (type === Pbf.Varint)
+            while (this.buf[this.pos++] > 127) {
+            }
+          else if (type === Pbf.Bytes)
+            this.pos = this.readVarint() + this.pos;
+          else if (type === Pbf.Fixed32)
+            this.pos += 4;
+          else if (type === Pbf.Fixed64)
+            this.pos += 8;
+          else
+            throw new Error("Unimplemented type: " + type);
+        },
+        writeTag: function(tag, type) {
+          this.writeVarint(tag << 3 | type);
+        },
+        realloc: function(min) {
+          var length = this.length || 16;
+          while (length < this.pos + min)
+            length *= 2;
+          if (length !== this.length) {
+            var buf = new Uint8Array(length);
+            buf.set(this.buf);
+            this.buf = buf;
+            this.length = length;
+          }
+        },
+        finish: function() {
+          this.length = this.pos;
+          this.pos = 0;
+          return this.buf.subarray(0, this.length);
+        },
+        writeFixed32: function(val) {
+          this.realloc(4);
+          writeInt32(this.buf, val, this.pos);
+          this.pos += 4;
+        },
+        writeSFixed32: function(val) {
+          this.realloc(4);
+          writeInt32(this.buf, val, this.pos);
+          this.pos += 4;
+        },
+        writeFixed64: function(val) {
+          this.realloc(8);
+          writeInt32(this.buf, val & -1, this.pos);
+          writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+          this.pos += 8;
+        },
+        writeSFixed64: function(val) {
+          this.realloc(8);
+          writeInt32(this.buf, val & -1, this.pos);
+          writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+          this.pos += 8;
+        },
+        writeVarint: function(val) {
+          val = +val || 0;
+          if (val > 268435455 || val < 0) {
+            writeBigVarint(val, this);
+            return;
+          }
+          this.realloc(4);
+          this.buf[this.pos++] = val & 127 | (val > 127 ? 128 : 0);
+          if (val <= 127)
+            return;
+          this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
+          if (val <= 127)
+            return;
+          this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
+          if (val <= 127)
+            return;
+          this.buf[this.pos++] = val >>> 7 & 127;
+        },
+        writeSVarint: function(val) {
+          this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
+        },
+        writeBoolean: function(val) {
+          this.writeVarint(Boolean(val));
+        },
+        writeString: function(str) {
+          str = String(str);
+          this.realloc(str.length * 4);
+          this.pos++;
+          var startPos = this.pos;
+          this.pos = writeUtf8(this.buf, str, this.pos);
+          var len = this.pos - startPos;
+          if (len >= 128)
+            makeRoomForExtraLength(startPos, len, this);
+          this.pos = startPos - 1;
+          this.writeVarint(len);
+          this.pos += len;
+        },
+        writeFloat: function(val) {
+          this.realloc(4);
+          ieee754.write(this.buf, val, this.pos, true, 23, 4);
+          this.pos += 4;
+        },
+        writeDouble: function(val) {
+          this.realloc(8);
+          ieee754.write(this.buf, val, this.pos, true, 52, 8);
+          this.pos += 8;
+        },
+        writeBytes: function(buffer) {
+          var len = buffer.length;
+          this.writeVarint(len);
+          this.realloc(len);
+          for (var i = 0; i < len; i++)
+            this.buf[this.pos++] = buffer[i];
+        },
+        writeRawMessage: function(fn, obj) {
+          this.pos++;
+          var startPos = this.pos;
+          fn(obj, this);
+          var len = this.pos - startPos;
+          if (len >= 128)
+            makeRoomForExtraLength(startPos, len, this);
+          this.pos = startPos - 1;
+          this.writeVarint(len);
+          this.pos += len;
+        },
+        writeMessage: function(tag, fn, obj) {
+          this.writeTag(tag, Pbf.Bytes);
+          this.writeRawMessage(fn, obj);
+        },
+        writePackedVarint: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedVarint, arr);
+        },
+        writePackedSVarint: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedSVarint, arr);
+        },
+        writePackedBoolean: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedBoolean, arr);
+        },
+        writePackedFloat: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedFloat, arr);
+        },
+        writePackedDouble: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedDouble, arr);
+        },
+        writePackedFixed32: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedFixed32, arr);
+        },
+        writePackedSFixed32: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedSFixed32, arr);
+        },
+        writePackedFixed64: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedFixed64, arr);
+        },
+        writePackedSFixed64: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedSFixed64, arr);
+        },
+        writeBytesField: function(tag, buffer) {
+          this.writeTag(tag, Pbf.Bytes);
+          this.writeBytes(buffer);
+        },
+        writeFixed32Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed32);
+          this.writeFixed32(val);
+        },
+        writeSFixed32Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed32);
+          this.writeSFixed32(val);
+        },
+        writeFixed64Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed64);
+          this.writeFixed64(val);
+        },
+        writeSFixed64Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed64);
+          this.writeSFixed64(val);
+        },
+        writeVarintField: function(tag, val) {
+          this.writeTag(tag, Pbf.Varint);
+          this.writeVarint(val);
+        },
+        writeSVarintField: function(tag, val) {
+          this.writeTag(tag, Pbf.Varint);
+          this.writeSVarint(val);
+        },
+        writeStringField: function(tag, str) {
+          this.writeTag(tag, Pbf.Bytes);
+          this.writeString(str);
+        },
+        writeFloatField: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed32);
+          this.writeFloat(val);
+        },
+        writeDoubleField: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed64);
+          this.writeDouble(val);
+        },
+        writeBooleanField: function(tag, val) {
+          this.writeVarintField(tag, Boolean(val));
+        }
+      };
+      function readVarintRemainder(l, s, p) {
+        var buf = p.buf, h, b;
+        b = buf[p.pos++];
+        h = (b & 112) >> 4;
+        if (b < 128)
+          return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 3;
+        if (b < 128)
+          return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 10;
+        if (b < 128)
+          return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 17;
+        if (b < 128)
+          return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 24;
+        if (b < 128)
+          return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 1) << 31;
+        if (b < 128)
+          return toNum(l, h, s);
+        throw new Error("Expected varint not more than 10 bytes");
+      }
+      function readPackedEnd(pbf) {
+        return pbf.type === Pbf.Bytes ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+      }
+      function toNum(low, high, isSigned) {
+        if (isSigned) {
+          return high * 4294967296 + (low >>> 0);
+        }
+        return (high >>> 0) * 4294967296 + (low >>> 0);
+      }
+      function writeBigVarint(val, pbf) {
+        var low, high;
+        if (val >= 0) {
+          low = val % 4294967296 | 0;
+          high = val / 4294967296 | 0;
+        } else {
+          low = ~(-val % 4294967296);
+          high = ~(-val / 4294967296);
+          if (low ^ 4294967295) {
+            low = low + 1 | 0;
+          } else {
+            low = 0;
+            high = high + 1 | 0;
+          }
+        }
+        if (val >= 18446744073709552e3 || val < -18446744073709552e3) {
+          throw new Error("Given varint doesn't fit into 10 bytes");
+        }
+        pbf.realloc(10);
+        writeBigVarintLow(low, high, pbf);
+        writeBigVarintHigh(high, pbf);
+      }
+      function writeBigVarintLow(low, high, pbf) {
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos] = low & 127;
+      }
+      function writeBigVarintHigh(high, pbf) {
+        var lsb = (high & 7) << 4;
+        pbf.buf[pbf.pos++] |= lsb | ((high >>>= 3) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127;
+      }
+      function makeRoomForExtraLength(startPos, len, pbf) {
+        var extraLen = len <= 16383 ? 1 : len <= 2097151 ? 2 : len <= 268435455 ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
+        pbf.realloc(extraLen);
+        for (var i = pbf.pos - 1; i >= startPos; i--)
+          pbf.buf[i + extraLen] = pbf.buf[i];
+      }
+      function writePackedVarint(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeVarint(arr[i]);
+      }
+      function writePackedSVarint(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSVarint(arr[i]);
+      }
+      function writePackedFloat(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFloat(arr[i]);
+      }
+      function writePackedDouble(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeDouble(arr[i]);
+      }
+      function writePackedBoolean(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeBoolean(arr[i]);
+      }
+      function writePackedFixed32(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFixed32(arr[i]);
+      }
+      function writePackedSFixed32(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSFixed32(arr[i]);
+      }
+      function writePackedFixed64(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFixed64(arr[i]);
+      }
+      function writePackedSFixed64(arr, pbf) {
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSFixed64(arr[i]);
+      }
+      function readUInt32(buf, pos) {
+        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + buf[pos + 3] * 16777216;
+      }
+      function writeInt32(buf, val, pos) {
+        buf[pos] = val;
+        buf[pos + 1] = val >>> 8;
+        buf[pos + 2] = val >>> 16;
+        buf[pos + 3] = val >>> 24;
+      }
+      function readInt32(buf, pos) {
+        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + (buf[pos + 3] << 24);
+      }
+      function readUtf8(buf, pos, end) {
+        var str = "";
+        var i = pos;
+        while (i < end) {
+          var b0 = buf[i];
+          var c = null;
+          var bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
+          if (i + bytesPerSequence > end)
+            break;
+          var b1, b2, b3;
+          if (bytesPerSequence === 1) {
+            if (b0 < 128) {
+              c = b0;
+            }
+          } else if (bytesPerSequence === 2) {
+            b1 = buf[i + 1];
+            if ((b1 & 192) === 128) {
+              c = (b0 & 31) << 6 | b1 & 63;
+              if (c <= 127) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 3) {
+            b1 = buf[i + 1];
+            b2 = buf[i + 2];
+            if ((b1 & 192) === 128 && (b2 & 192) === 128) {
+              c = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
+              if (c <= 2047 || c >= 55296 && c <= 57343) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 4) {
+            b1 = buf[i + 1];
+            b2 = buf[i + 2];
+            b3 = buf[i + 3];
+            if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
+              c = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
+              if (c <= 65535 || c >= 1114112) {
+                c = null;
+              }
+            }
+          }
+          if (c === null) {
+            c = 65533;
+            bytesPerSequence = 1;
+          } else if (c > 65535) {
+            c -= 65536;
+            str += String.fromCharCode(c >>> 10 & 1023 | 55296);
+            c = 56320 | c & 1023;
+          }
+          str += String.fromCharCode(c);
+          i += bytesPerSequence;
+        }
+        return str;
+      }
+      function readUtf8TextDecoder(buf, pos, end) {
+        return utf8TextDecoder.decode(buf.subarray(pos, end));
+      }
+      function writeUtf8(buf, str, pos) {
+        for (var i = 0, c, lead; i < str.length; i++) {
+          c = str.charCodeAt(i);
+          if (c > 55295 && c < 57344) {
+            if (lead) {
+              if (c < 56320) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+                lead = c;
+                continue;
+              } else {
+                c = lead - 55296 << 10 | c - 56320 | 65536;
+                lead = null;
+              }
+            } else {
+              if (c > 56319 || i + 1 === str.length) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+              } else {
+                lead = c;
+              }
+              continue;
+            }
+          } else if (lead) {
+            buf[pos++] = 239;
+            buf[pos++] = 191;
+            buf[pos++] = 189;
+            lead = null;
+          }
+          if (c < 128) {
+            buf[pos++] = c;
+          } else {
+            if (c < 2048) {
+              buf[pos++] = c >> 6 | 192;
+            } else {
+              if (c < 65536) {
+                buf[pos++] = c >> 12 | 224;
+              } else {
+                buf[pos++] = c >> 18 | 240;
+                buf[pos++] = c >> 12 & 63 | 128;
+              }
+              buf[pos++] = c >> 6 & 63 | 128;
+            }
+            buf[pos++] = c & 63 | 128;
+          }
+        }
+        return pos;
+      }
+    }
+  });
+
+  // ../../node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-utils/get-transfer-list.js
+  function getTransferList(object) {
+    let recursive = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+    let transfers = arguments.length > 2 ? arguments[2] : void 0;
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../../node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-body.js
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
+  var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
+    static set onmessage(onMessage) {
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const {
+          type,
+          payload
+        } = parentPort3 ? message : message.data;
+        onMessage(type, payload);
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
+    }
+    static addEventListener(onMessage) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      if (!onMessageWrapper) {
+        onMessageWrapper = (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const parentPort3 = getParentPort();
+          const {
+            type,
+            payload
+          } = parentPort3 ? message : message.data;
+          onMessage(type, payload);
+        };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
+    }
+    static removeEventListener(onMessage) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
+    }
+    static postMessage(type, payload) {
+      const data = {
+        source: "loaders.gl",
+        type,
+        payload
+      };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
+      }
+    }
+  };
+  function isKnownMessage(message) {
+    const {
+      type,
+      data
+    } = message;
+    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
+  }
+
+  // ../../node_modules/@loaders.gl/loader-utils/dist/esm/lib/worker-loader-utils/create-loader-worker.js
+  var requestId = 0;
+  function createLoaderWorker(loader) {
+    if (!WorkerBody.inWorkerThread()) {
+      return;
+    }
+    WorkerBody.onmessage = async (type, payload) => {
+      switch (type) {
+        case "process":
+          try {
+            const {
+              input,
+              options = {},
+              context = {}
+            } = payload;
+            const result = await parseData({
+              loader,
+              arrayBuffer: input,
+              options,
+              context: {
+                ...context,
+                parse: parseOnMainThread
+              }
+            });
+            WorkerBody.postMessage("done", {
+              result
+            });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            WorkerBody.postMessage("error", {
+              error: message
+            });
+          }
+          break;
+        default:
+      }
+    };
+  }
+  function parseOnMainThread(arrayBuffer, options) {
+    return new Promise((resolve, reject) => {
+      const id2 = requestId++;
+      const onMessage = (type, payload2) => {
+        if (payload2.id !== id2) {
+          return;
+        }
+        switch (type) {
+          case "done":
+            WorkerBody.removeEventListener(onMessage);
+            resolve(payload2.result);
+            break;
+          case "error":
+            WorkerBody.removeEventListener(onMessage);
+            reject(payload2.error);
+            break;
+          default:
+        }
+      };
+      WorkerBody.addEventListener(onMessage);
+      const payload = {
+        id: id2,
+        input: arrayBuffer,
+        options
+      };
+      WorkerBody.postMessage("process", payload);
+    });
+  }
+  async function parseData(_ref) {
+    let {
+      loader,
+      arrayBuffer,
+      options,
+      context
+    } = _ref;
+    let data;
+    let parser;
+    if (loader.parseSync || loader.parse) {
+      data = arrayBuffer;
+      parser = loader.parseSync || loader.parse;
+    } else if (loader.parseTextSync) {
+      const textDecoder = new TextDecoder();
+      data = textDecoder.decode(arrayBuffer);
+      parser = loader.parseTextSync;
+    } else {
+      throw new Error("Could not load data with ".concat(loader.name, " loader"));
+    }
+    options = {
+      ...options,
+      modules: loader && loader.options && loader.options.modules || {},
+      worker: false
+    };
+    return await parser(data, {
+      ...options
+    }, context, loader);
+  }
+
+  // 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) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    obj.value = new TypedArray(pbf.buf.buffer.slice(pbf.pos, end));
+    pbf.pos = end;
+    return obj.value;
+  }
+
+  // src/layers/schema/carto-tile.ts
+  var KeyValueObjectReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(KeyValueObjectReader._readField, { key: "", value: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.key = pbf.readString();
+      else if (tag === 2)
+        obj.value = pbf.readString();
+    }
+  };
+  var PropertiesReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(PropertiesReader._readField, {}, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1) {
+        const { key, value } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj[key] = value;
+      }
+    }
+  };
+  var DoublesReader = class {
+    static read(pbf, end) {
+      const { value, size } = pbf.readFields(DoublesReader._readField, { value: [], size: 0 }, end);
+      return { value: new Float32Array(value), size };
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        readPackedTypedArray(Float64Array, pbf, obj);
+      else if (tag === 2)
+        obj.size = pbf.readVarint(true);
+    }
+  };
+  var IntsReader = class {
+    static read(pbf, end) {
+      const { value, size } = pbf.readFields(IntsReader._readField, { value: [], size: 0 }, end);
+      return { value: new Uint32Array(value), size };
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        pbf.readPackedVarint(obj.value);
+      else if (tag === 2)
+        obj.size = pbf.readVarint(true);
+    }
+  };
+  var FieldsReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(FieldsReader._readField, { id: 0 }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.id = pbf.readVarint();
+    }
+  };
+  var NumericPropReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(NumericPropReader._readField, { value: [] }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        readPackedTypedArray(Float64Array, pbf, obj);
+    }
+  };
+  var NumericPropKeyValueReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(NumericPropKeyValueReader._readField, { key: "", value: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.key = pbf.readString();
+      else if (tag === 2)
+        obj.value = NumericPropReader.read(pbf, pbf.readVarint() + pbf.pos);
+    }
+  };
+  var PointsReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(
+        PointsReader._readField,
+        {
+          positions: null,
+          globalFeatureIds: null,
+          featureIds: null,
+          properties: [],
+          numericProps: {},
+          fields: []
+        },
+        end
+      );
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 2)
+        obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 3)
+        obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 4)
+        obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+      else if (tag === 5) {
+        const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj.numericProps[entry.key] = entry.value;
+      } else if (tag === 6)
+        obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+  };
+  var LinesReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(
+        LinesReader._readField,
+        {
+          positions: null,
+          pathIndices: null,
+          globalFeatureIds: null,
+          featureIds: null,
+          properties: [],
+          numericProps: {},
+          fields: []
+        },
+        end
+      );
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 2)
+        obj.pathIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 3)
+        obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 4)
+        obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 5)
+        obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+      else if (tag === 6) {
+        const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj.numericProps[entry.key] = entry.value;
+      } else if (tag === 7)
+        obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+  };
+  var PolygonsReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(
+        PolygonsReader._readField,
+        {
+          positions: null,
+          polygonIndices: null,
+          globalFeatureIds: null,
+          featureIds: null,
+          primitivePolygonIndices: null,
+          triangles: null,
+          properties: [],
+          numericProps: {},
+          fields: []
+        },
+        end
+      );
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 2)
+        obj.polygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 3)
+        obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 4)
+        obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 5)
+        obj.primitivePolygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 6)
+        obj.triangles = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 7)
+        obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+      else if (tag === 8) {
+        const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj.numericProps[entry.key] = entry.value;
+      } else if (tag === 9)
+        obj.fields.push(FieldsReader.read(pbf, pbf.readVarint() + pbf.pos));
+    }
+  };
+  var TileReader = class {
+    static read(pbf, end) {
+      return pbf.readFields(TileReader._readField, { points: null, lines: null, polygons: null }, end);
+    }
+    static _readField(tag, obj, pbf) {
+      if (tag === 1)
+        obj.points = PointsReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 2)
+        obj.lines = LinesReader.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 3)
+        obj.polygons = PolygonsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    }
+  };
+
+  // src/layers/schema/tile-loader-utils.ts
+  var import_pbf = __toESM(require_pbf());
+  function parsePbf(buffer, TileReader2) {
+    const pbf = new import_pbf.default(buffer);
+    const tile = TileReader2.read(pbf);
+    return tile;
+  }
+
+  // src/utils.ts
+  function getWorkerUrl(id2, version) {
+    return `https://unpkg.com/@deck.gl/carto@${version}/dist/${id2}-worker.js`;
+  }
+
+  // src/layers/schema/carto-vector-tile-loader.ts
+  var VERSION = true ? "8.10.0-alpha.4" : "latest";
+  var id = "cartoVectorTile";
+  var DEFAULT_OPTIONS = {
+    cartoVectorTile: {
+      workerUrl: getWorkerUrl(id, VERSION)
+    }
+  };
+  var CartoVectorTileLoader = {
+    name: "CARTO Vector Tile",
+    version: VERSION,
+    id,
+    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_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;
+
+  // src/workers/cartoVectorTile.ts
+  createLoaderWorker(carto_vector_tile_loader_default);
+})();