@loaders.gl/mvt 4.2.0 → 4.3.0-alpha.1

package/dist/mvt-worker.js

@@ -6,6 +6,7 @@
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -25,6 +26,10 @@
     isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
     mod
   ));
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
 
   // ../../node_modules/ieee754/index.js
   var require_ieee754 = __commonJS({
@@ -35,19 +40,19 @@
         var eMax = (1 << eLen) - 1;
         var eBias = eMax >> 1;
         var nBits = -7;
-        var i2 = isLE ? nBytes - 1 : 0;
+        var i = isLE ? nBytes - 1 : 0;
         var d = isLE ? -1 : 1;
-        var s = buffer[offset + i2];
-        i2 += d;
+        var s = buffer[offset + i];
+        i += d;
         e = s & (1 << -nBits) - 1;
         s >>= -nBits;
         nBits += eLen;
-        for (; nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8) {
+        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 + i2], i2 += d, nBits -= 8) {
+        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
         }
         if (e === 0) {
           e = 1 - eBias;
@@ -65,7 +70,7 @@
         var eMax = (1 << eLen) - 1;
         var eBias = eMax >> 1;
         var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-        var i2 = isLE ? 0 : nBytes - 1;
+        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);
@@ -98,13 +103,13 @@
             e = 0;
           }
         }
-        for (; mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) {
+        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 + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) {
+        for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
         }
-        buffer[offset + i2 - d] |= s * 128;
+        buffer[offset + i - d] |= s * 128;
       };
     }
   });
@@ -326,14 +331,14 @@
           this.writeVarint(tag << 3 | type);
         },
         realloc: function(min) {
-          var length2 = this.length || 16;
-          while (length2 < this.pos + min)
-            length2 *= 2;
-          if (length2 !== this.length) {
-            var buf = new Uint8Array(length2);
+          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 = length2;
+            this.length = length;
           }
         },
         finish: function() {
@@ -414,8 +419,8 @@
           var len = buffer.length;
           this.writeVarint(len);
           this.realloc(len);
-          for (var i2 = 0; i2 < len; i2++)
-            this.buf[this.pos++] = buffer[i2];
+          for (var i = 0; i < len; i++)
+            this.buf[this.pos++] = buffer[i];
         },
         writeRawMessage: function(fn, obj) {
           this.pos++;
@@ -604,44 +609,44 @@
       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 i2 = pbf.pos - 1; i2 >= startPos; i2--)
-          pbf.buf[i2 + extraLen] = pbf.buf[i2];
+        for (var i = pbf.pos - 1; i >= startPos; i--)
+          pbf.buf[i + extraLen] = pbf.buf[i];
       }
       function writePackedVarint(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeVarint(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeVarint(arr[i]);
       }
       function writePackedSVarint(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeSVarint(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSVarint(arr[i]);
       }
       function writePackedFloat(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeFloat(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFloat(arr[i]);
       }
       function writePackedDouble(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeDouble(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeDouble(arr[i]);
       }
       function writePackedBoolean(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeBoolean(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeBoolean(arr[i]);
       }
       function writePackedFixed32(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeFixed32(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFixed32(arr[i]);
       }
       function writePackedSFixed32(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeSFixed32(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeSFixed32(arr[i]);
       }
       function writePackedFixed64(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeFixed64(arr[i2]);
+        for (var i = 0; i < arr.length; i++)
+          pbf.writeFixed64(arr[i]);
       }
       function writePackedSFixed64(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeSFixed64(arr[i2]);
+        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;
@@ -657,12 +662,12 @@
       }
       function readUtf8(buf, pos, end) {
         var str = "";
-        var i2 = pos;
-        while (i2 < end) {
-          var b0 = buf[i2];
+        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 (i2 + bytesPerSequence > end)
+          if (i + bytesPerSequence > end)
             break;
           var b1, b2, b3;
           if (bytesPerSequence === 1) {
@@ -670,7 +675,7 @@
               c = b0;
             }
           } else if (bytesPerSequence === 2) {
-            b1 = buf[i2 + 1];
+            b1 = buf[i + 1];
             if ((b1 & 192) === 128) {
               c = (b0 & 31) << 6 | b1 & 63;
               if (c <= 127) {
@@ -678,8 +683,8 @@
               }
             }
           } else if (bytesPerSequence === 3) {
-            b1 = buf[i2 + 1];
-            b2 = buf[i2 + 2];
+            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) {
@@ -687,9 +692,9 @@
               }
             }
           } else if (bytesPerSequence === 4) {
-            b1 = buf[i2 + 1];
-            b2 = buf[i2 + 2];
-            b3 = buf[i2 + 3];
+            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) {
@@ -706,7 +711,7 @@
             c = 56320 | c & 1023;
           }
           str += String.fromCharCode(c);
-          i2 += bytesPerSequence;
+          i += bytesPerSequence;
         }
         return str;
       }
@@ -714,8 +719,8 @@
         return utf8TextDecoder.decode(buf.subarray(pos, end));
       }
       function writeUtf8(buf, str, pos) {
-        for (var i2 = 0, c, lead; i2 < str.length; i2++) {
-          c = str.charCodeAt(i2);
+        for (var i = 0, c, lead; i < str.length; i++) {
+          c = str.charCodeAt(i);
           if (c > 55295 && c < 57344) {
             if (lead) {
               if (c < 56320) {
@@ -729,7 +734,7 @@
                 lead = null;
               }
             } else {
-              if (c > 56319 || i2 + 1 === str.length) {
+              if (c > 56319 || i + 1 === str.length) {
                 buf[pos++] = 239;
                 buf[pos++] = 191;
                 buf[pos++] = 189;
@@ -828,9 +833,9 @@
     let area2 = 0;
     const i0 = DimIndex[plane[0]];
     const i1 = DimIndex[plane[1]];
-    for (let i2 = start, j = end - dim; i2 < end; i2 += dim) {
-      area2 += (points[i2 + i0] - points[j + i0]) * (points[i2 + i1] + points[j + i1]);
-      j = i2;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      area2 += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
+      j = i;
     }
     return area2 / 2;
   }
@@ -848,24 +853,24 @@
     let maxY;
     let minX;
     let minY;
-    let x2;
-    let y2;
+    let x;
+    let y;
     if (hasHoles)
       outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
     if (positions.length > 80 * dim) {
       minX = maxX = positions[0];
       minY = maxY = positions[1];
-      for (let i2 = dim; i2 < outerLen; i2 += dim) {
-        x2 = positions[i2];
-        y2 = positions[i2 + 1];
-        if (x2 < minX)
-          minX = x2;
-        if (y2 < minY)
-          minY = y2;
-        if (x2 > maxX)
-          maxX = x2;
-        if (y2 > maxY)
-          maxY = y2;
+      for (let i = dim; i < outerLen; i += dim) {
+        x = positions[i];
+        y = positions[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 ? 32767 / invSize : 0;
@@ -874,7 +879,7 @@
     return triangles;
   }
   function linkedList(data, start, end, dim, clockwise, area2, plane) {
-    let i2;
+    let i;
     let last;
     if (area2 === void 0) {
       area2 = getPolygonSignedArea(data, {
@@ -887,11 +892,11 @@
     let i0 = DimIndex[plane[0]];
     let i1 = DimIndex[plane[1]];
     if (clockwise === area2 < 0) {
-      for (i2 = start; i2 < end; i2 += dim)
-        last = insertNode(i2, data[i2 + i0], data[i2 + i1], last);
+      for (i = start; i < end; i += dim)
+        last = insertNode(i, data[i + i0], data[i + i1], last);
     } else {
-      for (i2 = end - dim; i2 >= start; i2 -= dim)
-        last = insertNode(i2, data[i2 + i0], data[i2 + i1], last);
+      for (i = end - dim; i >= start; i -= dim)
+        last = insertNode(i, data[i + i0], data[i + i1], last);
     }
     if (last && equals(last, last.next)) {
       removeNode(last);
@@ -1055,22 +1060,22 @@
   }
   function eliminateHoles(data, holeIndices, outerNode, dim, areas, plane) {
     const queue = [];
-    let i2;
+    let i;
     let len;
     let start;
     let end;
     let list;
-    for (i2 = 0, len = holeIndices.length; i2 < len; i2++) {
-      start = holeIndices[i2] * dim;
-      end = i2 < len - 1 ? holeIndices[i2 + 1] * dim : data.length;
-      list = linkedList(data, start, end, dim, false, areas && areas[i2 + 1], plane);
+    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, areas && areas[i + 1], plane);
       if (list === list.next)
         list.steiner = true;
       queue.push(getLeftmost(list));
     }
     queue.sort(compareX);
-    for (i2 = 0; i2 < queue.length; i2++) {
-      outerNode = eliminateHole(queue[i2], outerNode);
+    for (i = 0; i < queue.length; i++) {
+      outerNode = eliminateHole(queue[i], outerNode);
     }
     return outerNode;
   }
@@ -1094,11 +1099,11 @@
     let m;
     do {
       if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-        const x2 = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-        if (x2 <= hx && x2 > qx) {
-          qx = x2;
+        const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x <= hx && x > qx) {
+          qx = x;
           m = p.x < p.next.x ? p : p.next;
-          if (x2 === hx)
+          if (x === hx)
             return m;
         }
       }
@@ -1142,7 +1147,7 @@
   }
   function sortLinked(list) {
     let e;
-    let i2;
+    let i;
     let inSize = 1;
     let numMerges;
     let p;
@@ -1159,7 +1164,7 @@
         numMerges++;
         q = p;
         pSize = 0;
-        for (i2 = 0; i2 < inSize; i2++) {
+        for (i = 0; i < inSize; i++) {
           pSize++;
           q = q.nextZ;
           if (!q)
@@ -1190,18 +1195,18 @@
     } while (numMerges > 1);
     return list;
   }
-  function zOrder(x2, y2, minX, minY, invSize) {
-    x2 = (x2 - minX) * invSize | 0;
-    y2 = (y2 - minY) * invSize | 0;
-    x2 = (x2 | x2 << 8) & 16711935;
-    x2 = (x2 | x2 << 4) & 252645135;
-    x2 = (x2 | x2 << 2) & 858993459;
-    x2 = (x2 | x2 << 1) & 1431655765;
-    y2 = (y2 | y2 << 8) & 16711935;
-    y2 = (y2 | y2 << 4) & 252645135;
-    y2 = (y2 | y2 << 2) & 858993459;
-    y2 = (y2 | y2 << 1) & 1431655765;
-    return x2 | y2 << 1;
+  function zOrder(x, y, minX, minY, invSize) {
+    x = (x - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
+    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) {
     let p = start;
@@ -1287,8 +1292,8 @@
     b2.prev = bp;
     return b2;
   }
-  function insertNode(i2, x2, y2, last) {
-    const p = new Vertex(i2, x2, y2);
+  function insertNode(i, x, y, last) {
+    const p = new Vertex(i, x, y);
     if (!last) {
       p.prev = p;
       p.next = p;
@@ -1309,7 +1314,7 @@
       p.nextZ.prevZ = p.prevZ;
   }
   var Vertex = class {
-    constructor(i2, x2, y2) {
+    constructor(i, x, y) {
       _defineProperty(this, "i", void 0);
       _defineProperty(this, "x", void 0);
       _defineProperty(this, "y", void 0);
@@ -1319,9 +1324,9 @@
       _defineProperty(this, "prevZ", null);
       _defineProperty(this, "nextZ", null);
       _defineProperty(this, "steiner", false);
-      this.i = i2;
-      this.x = x2;
-      this.y = y2;
+      this.i = i;
+      this.x = x;
+      this.y = y;
     }
   };
 
@@ -1490,9 +1495,9 @@
       indexMap.linePosition,
       indexMap.linePosition + nPositions
     );
-    for (let i2 = 0, il = geometry.indices.length; i2 < il; ++i2) {
-      const start = geometry.indices[i2];
-      const end = i2 === il - 1 ? geometry.data.length : geometry.indices[i2 + 1];
+    for (let i = 0, il = geometry.indices.length; i < il; ++i) {
+      const start = geometry.indices[i];
+      const end = i === il - 1 ? geometry.data.length : geometry.indices[i + 1];
       lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
       indexMap.linePosition += (end - start) / coordLength;
     }
@@ -1517,12 +1522,12 @@
       const areas = geometry.areas[l];
       const indices = geometry.indices[l];
       const nextIndices = geometry.indices[l + 1];
-      for (let i2 = 0, il = indices.length; i2 < il; ++i2) {
-        const start = indices[i2];
-        const end = i2 === il - 1 ? (
+      for (let i = 0, il = indices.length; i < il; ++i) {
+        const start = indices[i];
+        const end = i === il - 1 ? (
           // last line, so either read to:
           nextIndices === void 0 ? geometry.data.length : nextIndices[0]
-        ) : indices[i2 + 1];
+        ) : indices[i + 1];
         polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
         indexMap.polygonPosition += (end - start) / coordLength;
       }
@@ -1589,11 +1594,11 @@
     }
     return binaryFeatures;
   }
-  function fillNumericProperties(object, properties, index, length2) {
+  function fillNumericProperties(object, properties, index, length) {
     for (const numericPropName in object.numericProps) {
       if (numericPropName in properties) {
         const value = properties[numericPropName];
-        object.numericProps[numericPropName].fill(value, index, index + length2);
+        object.numericProps[numericPropName].fill(value, index, index + length);
       }
     }
   }
@@ -1606,405 +1611,845 @@
     }
     return props;
   }
-  function deduceArrayType(x2, constructor) {
-    if (constructor === Array || !Number.isFinite(x2)) {
+  function deduceArrayType(x, constructor) {
+    if (constructor === Array || !Number.isFinite(x)) {
       return Array;
     }
-    return constructor === Float64Array || Math.fround(x2) !== x2 ? Float64Array : Float32Array;
+    return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
   }
 
-  // src/lib/parse-mvt.ts
-  var import_pbf = __toESM(require_pbf(), 1);
-
-  // src/helpers/mapbox-util-functions.ts
-  function classifyRings(rings) {
-    const len = rings.length;
-    if (len <= 1)
-      return [rings];
-    const polygons = [];
-    let polygon;
-    let ccw;
-    for (let i2 = 0; i2 < len; i2++) {
-      const area2 = signedArea(rings[i2]);
-      if (area2 === 0)
-        continue;
-      if (ccw === void 0)
-        ccw = area2 < 0;
-      if (ccw === area2 < 0) {
-        if (polygon)
-          polygons.push(polygon);
-        polygon = [rings[i2]];
-      } else if (polygon)
-        polygon.push(rings[i2]);
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
+  function isElectron(mockUserAgent) {
+    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+      return true;
     }
-    if (polygon)
-      polygons.push(polygon);
-    return polygons;
-  }
-  function signedArea(ring) {
-    let sum = 0;
-    for (let i2 = 0, j = ring.length - 1, p1, p2; i2 < ring.length; j = i2++) {
-      p1 = ring[i2];
-      p2 = ring[j];
-      sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+      return true;
     }
-    return sum;
-  }
-  function readFeature(tag, feature, pbf) {
-    if (feature && pbf) {
-      if (tag === 1)
-        feature.id = pbf.readVarint();
-      else if (tag === 2)
-        readTag(pbf, feature);
-      else if (tag === 3)
-        feature.type = pbf.readVarint();
-      else if (tag === 4)
-        feature._geometry = pbf.pos;
+    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    if (userAgent && userAgent.indexOf("Electron") >= 0) {
+      return true;
     }
+    return false;
   }
-  function readTag(pbf, feature) {
-    const end = pbf.readVarint() + pbf.pos;
-    while (pbf.pos < end) {
-      const key = feature._keys[pbf.readVarint()];
-      const value = feature._values[pbf.readVarint()];
-      feature.properties[key] = value;
-    }
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
+  function isBrowser() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron();
   }
 
-  // src/lib/mapbox-vector-tile/vector-tile-feature.ts
-  var VectorTileFeature = class {
-    properties;
-    extent;
-    type;
-    id;
-    _pbf;
-    _geometry;
-    _keys;
-    _values;
-    static get types() {
-      return ["Unknown", "Point", "LineString", "Polygon"];
-    }
-    constructor(pbf, end, extent, keys, values) {
-      this.properties = {};
-      this.extent = extent;
-      this.type = 0;
-      this.id = null;
-      this._pbf = pbf;
-      this._geometry = -1;
-      this._keys = keys;
-      this._values = values;
-      pbf.readFields(readFeature, this, end);
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_ = globalThis.self || globalThis.window || globalThis.global;
+  var window_ = globalThis.window || globalThis.self || globalThis.global;
+  var document_ = globalThis.document || {};
+  var process_ = globalThis.process || {};
+  var console_ = globalThis.console;
+  var navigator_ = globalThis.navigator || {};
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
+  var VERSION = true ? "4.2.0" : "untranspiled source";
+  var isBrowser2 = isBrowser();
+
+  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
+  function getStorage(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e) {
+      return null;
     }
-    // eslint-disable-next-line complexity, max-statements
-    loadGeometry() {
-      const pbf = this._pbf;
-      pbf.pos = this._geometry;
-      const end = pbf.readVarint() + pbf.pos;
-      let cmd2 = 1;
-      let length2 = 0;
-      let x2 = 0;
-      let y2 = 0;
-      const lines = [];
-      let line;
-      while (pbf.pos < end) {
-        if (length2 <= 0) {
-          const cmdLen2 = pbf.readVarint();
-          cmd2 = cmdLen2 & 7;
-          length2 = cmdLen2 >> 3;
-        }
-        length2--;
-        if (cmd2 === 1 || cmd2 === 2) {
-          x2 += pbf.readSVarint();
-          y2 += pbf.readSVarint();
-          if (cmd2 === 1) {
-            if (line)
-              lines.push(line);
-            line = [];
-          }
-          if (line)
-            line.push([x2, y2]);
-        } else if (cmd2 === 7) {
-          if (line) {
-            line.push(line[0].slice());
-          }
-        } else {
-          throw new Error(`unknown command ${cmd2}`);
-        }
-      }
-      if (line)
-        lines.push(line);
-      return lines;
+  }
+  var LocalStorage = class {
+    constructor(id, defaultConfig) {
+      let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
+      _defineProperty(this, "storage", void 0);
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "config", void 0);
+      this.storage = getStorage(type);
+      this.id = id;
+      this.config = defaultConfig;
+      this._loadConfiguration();
     }
-    // eslint-disable-next-line max-statements
-    bbox() {
-      const pbf = this._pbf;
-      pbf.pos = this._geometry;
-      const end = pbf.readVarint() + pbf.pos;
-      let cmd2 = 1;
-      let length2 = 0;
-      let x2 = 0;
-      let y2 = 0;
-      let x1 = Infinity;
-      let x22 = -Infinity;
-      let y1 = Infinity;
-      let y22 = -Infinity;
-      while (pbf.pos < end) {
-        if (length2 <= 0) {
-          const cmdLen2 = pbf.readVarint();
-          cmd2 = cmdLen2 & 7;
-          length2 = cmdLen2 >> 3;
-        }
-        length2--;
-        if (cmd2 === 1 || cmd2 === 2) {
-          x2 += pbf.readSVarint();
-          y2 += pbf.readSVarint();
-          if (x2 < x1)
-            x1 = x2;
-          if (x2 > x22)
-            x22 = x2;
-          if (y2 < y1)
-            y1 = y2;
-          if (y2 > y22)
-            y22 = y2;
-        } else if (cmd2 !== 7) {
-          throw new Error(`unknown command ${cmd2}`);
-        }
-      }
-      return [x1, y1, x22, y22];
+    getConfiguration() {
+      return this.config;
     }
-    _toGeoJSON(transform) {
-      let coords = this.loadGeometry();
-      let type = VectorTileFeature.types[this.type];
-      let i2;
-      let j;
-      switch (this.type) {
-        case 1:
-          const points = [];
-          for (i2 = 0; i2 < coords.length; i2++) {
-            points[i2] = coords[i2][0];
-          }
-          coords = points;
-          transform(coords, this);
-          break;
-        case 2:
-          for (i2 = 0; i2 < coords.length; i2++) {
-            transform(coords[i2], this);
-          }
-          break;
-        case 3:
-          coords = classifyRings(coords);
-          for (i2 = 0; i2 < coords.length; i2++) {
-            for (j = 0; j < coords[i2].length; j++) {
-              transform(coords[i2][j], this);
-            }
-          }
-          break;
-      }
-      if (coords.length === 1) {
-        coords = coords[0];
-      } else {
-        type = `Multi${type}`;
-      }
-      const result = {
-        type: "Feature",
-        geometry: {
-          type,
-          coordinates: coords
-        },
-        properties: this.properties
-      };
-      if (this.id !== null) {
-        result.id = this.id;
+    setConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
       }
-      return result;
     }
-    toGeoJSON(options) {
-      if (typeof options === "function") {
-        return this._toGeoJSON(options);
-      }
-      const { x: x2, y: y2, z } = options;
-      const size = this.extent * Math.pow(2, z);
-      const x0 = this.extent * x2;
-      const y0 = this.extent * y2;
-      function project2(line) {
-        for (let j = 0; j < line.length; j++) {
-          const p = line[j];
-          p[0] = (p[0] + x0) * 360 / size - 180;
-          const y22 = 180 - (p[1] + y0) * 360 / size;
-          p[1] = 360 / Math.PI * Math.atan(Math.exp(y22 * Math.PI / 180)) - 90;
-        }
+    _loadConfiguration() {
+      let configuration = {};
+      if (this.storage) {
+        const serializedConfiguration = this.storage.getItem(this.id);
+        configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
       }
-      return this._toGeoJSON(project2);
+      Object.assign(this.config, configuration);
+      return this;
     }
   };
 
-  // src/lib/mapbox-vector-tile/vector-tile-layer.ts
-  var VectorTileLayer = class {
-    version;
-    name;
-    extent;
-    length;
-    _pbf;
-    _keys;
-    _values;
-    _features;
-    constructor(pbf, end) {
-      this.version = 1;
-      this.name = "";
-      this.extent = 4096;
-      this.length = 0;
-      this._pbf = pbf;
-      this._keys = [];
-      this._values = [];
-      this._features = [];
-      pbf.readFields(readLayer, this, end);
-      this.length = this._features.length;
-    }
-    /**
-     * return feature `i` from this layer as a `VectorTileFeature`
-     * @param index
-     * @returns feature
-     */
-    feature(i2) {
-      if (i2 < 0 || i2 >= this._features.length) {
-        throw new Error("feature index out of bounds");
-      }
-      this._pbf.pos = this._features[i2];
-      const end = this._pbf.readVarint() + this._pbf.pos;
-      return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
-    }
-  };
-  function readLayer(tag, layer, pbf) {
-    if (layer && pbf) {
-      if (tag === 15)
-        layer.version = pbf.readVarint();
-      else if (tag === 1)
-        layer.name = pbf.readString();
-      else if (tag === 5)
-        layer.extent = pbf.readVarint();
-      else if (tag === 2)
-        layer._features.push(pbf.pos);
-      else if (tag === 3)
-        layer._keys.push(pbf.readString());
-      else if (tag === 4)
-        layer._values.push(readValueMessage(pbf));
+  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
+  function formatTime(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = "".concat(ms.toFixed(2), "ms");
+    } else if (ms < 100) {
+      formatted = "".concat(ms.toFixed(1), "ms");
+    } else if (ms < 1e3) {
+      formatted = "".concat(ms.toFixed(0), "ms");
+    } else {
+      formatted = "".concat((ms / 1e3).toFixed(2), "s");
     }
+    return formatted;
   }
-  function readValueMessage(pbf) {
-    let value = null;
-    const end = pbf.readVarint() + pbf.pos;
-    while (pbf.pos < end) {
-      const tag = pbf.readVarint() >> 3;
-      value = tag === 1 ? pbf.readString() : tag === 2 ? pbf.readFloat() : tag === 3 ? pbf.readDouble() : tag === 4 ? pbf.readVarint64() : tag === 5 ? pbf.readVarint() : tag === 6 ? pbf.readSVarint() : tag === 7 ? pbf.readBoolean() : null;
+  function leftPad(string) {
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
+    const padLength = Math.max(length - string.length, 0);
+    return "".concat(" ".repeat(padLength)).concat(string);
+  }
+  function formatImage(image, message, scale) {
+    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
+    const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
+    if (image.width > maxWidth) {
+      scale = Math.min(scale, maxWidth / image.width);
     }
-    return value;
+    const width = image.width * scale;
+    const height = image.height * scale;
+    const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join("");
+    return ["".concat(message, " %c+"), style];
   }
 
-  // src/lib/mapbox-vector-tile/vector-tile.ts
-  var VectorTile = class {
-    layers;
-    constructor(pbf, end) {
-      this.layers = pbf.readFields(readTile, {}, end);
-    }
-  };
-  function readTile(tag, layers, pbf) {
-    if (tag === 3) {
-      if (pbf) {
-        const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
-        if (layer.length && layers) {
-          layers[layer.name] = layer;
+  // ../../node_modules/@probe.gl/log/dist/utils/color.js
+  var COLOR;
+  (function(COLOR2) {
+    COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+    COLOR2[COLOR2["RED"] = 31] = "RED";
+    COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+    COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+    COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+    COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+    COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+    COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+    COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+    COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+    COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+    COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+    COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+    COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+    COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+    COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+  })(COLOR || (COLOR = {}));
+  var BACKGROUND_INCREMENT = 10;
+  function getColor(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor(color);
+        string = "\x1B[".concat(colorCode, "m").concat(string, "\x1B[39m");
+      }
+      if (background) {
+        const colorCode = getColor(background);
+        string = "\x1B[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "\x1B[49m");
+      }
+    }
+    return string;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name) => key === name)) {
+          object[key] = value.bind(obj);
         }
       }
     }
   }
 
-  // src/helpers/binary-util-functions.ts
-  function classifyRings2(geom) {
-    const len = geom.indices.length;
-    const type = "Polygon";
-    if (len <= 1) {
-      return {
-        type,
-        data: geom.data,
-        areas: [[getPolygonSignedArea(geom.data)]],
-        indices: [geom.indices]
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
+    let timestamp;
+    if (isBrowser() && window_.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_ === null || window_ === void 0 ? void 0 : (_window$performance = window_.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+    } else if ("hrtime" in process_) {
+      var _process$hrtime;
+      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/log.js
+  var originalConsole = {
+    debug: isBrowser() ? console.debug || console.log : console.log,
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  var DEFAULT_LOG_CONFIGURATION = {
+    enabled: true,
+    level: 0
+  };
+  function noop() {
+  }
+  var cache = {};
+  var ONCE = {
+    once: true
+  };
+  var Log = class {
+    constructor() {
+      let {
+        id
+      } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        id: ""
       };
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "VERSION", VERSION);
+      _defineProperty(this, "_startTs", getHiResTimestamp());
+      _defineProperty(this, "_deltaTs", getHiResTimestamp());
+      _defineProperty(this, "_storage", void 0);
+      _defineProperty(this, "userData", {});
+      _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
+      this.id = id;
+      this.userData = {};
+      this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
+      this.timeStamp("".concat(this.id, " started"));
+      autobind(this);
+      Object.seal(this);
+    }
+    set level(newLevel) {
+      this.setLevel(newLevel);
+    }
+    get level() {
+      return this.getLevel();
+    }
+    isEnabled() {
+      return this._storage.config.enabled;
+    }
+    getLevel() {
+      return this._storage.config.level;
+    }
+    getTotal() {
+      return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
+    }
+    getDelta() {
+      return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
+    }
+    set priority(newPriority) {
+      this.level = newPriority;
+    }
+    get priority() {
+      return this.level;
+    }
+    getPriority() {
+      return this.level;
+    }
+    enable() {
+      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      this._storage.setConfiguration({
+        enabled
+      });
+      return this;
     }
-    const areas = [];
-    const polygons = [];
-    let ringAreas = [];
-    let polygon = [];
-    let ccw;
-    let offset = 0;
-    for (let endIndex, i2 = 0, startIndex; i2 < len; i2++) {
-      startIndex = geom.indices[i2] - offset;
-      endIndex = geom.indices[i2 + 1] - offset || geom.data.length;
-      const shape = geom.data.slice(startIndex, endIndex);
-      const area2 = getPolygonSignedArea(shape);
-      if (area2 === 0) {
-        const before = geom.data.slice(0, startIndex);
-        const after = geom.data.slice(endIndex);
-        geom.data = before.concat(after);
-        offset += endIndex - startIndex;
-        continue;
-      }
-      if (ccw === void 0)
-        ccw = area2 < 0;
-      if (ccw === area2 < 0) {
-        if (polygon.length) {
-          areas.push(ringAreas);
-          polygons.push(polygon);
-        }
-        polygon = [startIndex];
-        ringAreas = [area2];
+    setLevel(level) {
+      this._storage.setConfiguration({
+        level
+      });
+      return this;
+    }
+    get(setting) {
+      return this._storage.config[setting];
+    }
+    set(setting, value) {
+      this._storage.setConfiguration({
+        [setting]: value
+      });
+    }
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
       } else {
-        ringAreas.push(area2);
-        polygon.push(startIndex);
+        console.log(this._storage.config);
       }
     }
-    if (ringAreas)
-      areas.push(ringAreas);
-    if (polygon.length)
-      polygons.push(polygon);
-    return { type, areas, indices: polygons, data: geom.data };
+    assert(condition, message) {
+      assert(condition, message);
+    }
+    warn(message) {
+      return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
+    }
+    error(message) {
+      return this._getLogFunction(0, message, originalConsole.error, arguments);
+    }
+    deprecated(oldUsage, newUsage) {
+      return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
+    }
+    removed(oldUsage, newUsage) {
+      return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
+    }
+    probe(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
+        time: true,
+        once: true
+      });
+    }
+    log(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
+    }
+    info(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.info, arguments);
+    }
+    once(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
+    }
+    table(logLevel, table, columns) {
+      if (table) {
+        return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
+          tag: getTableHeader(table)
+        });
+      }
+      return noop;
+    }
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop;
+      }
+      return isBrowser() ? logImageInBrowser({
+        image,
+        message,
+        scale
+      }) : logImageInNode({
+        image,
+        message,
+        scale
+      });
+    }
+    time(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+    }
+    timeEnd(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+    }
+    timeStamp(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeStamp || noop);
+    }
+    group(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+        collapsed: false
+      };
+      const options = normalizeArguments({
+        logLevel,
+        message,
+        opts
+      });
+      const {
+        collapsed
+      } = opts;
+      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._getLogFunction(options);
+    }
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      return this.group(logLevel, message, Object.assign({}, opts, {
+        collapsed: true
+      }));
+    }
+    groupEnd(logLevel) {
+      return this._getLogFunction(logLevel, "", console.groupEnd || noop);
+    }
+    withGroup(logLevel, message, func) {
+      this.group(logLevel, message)();
+      try {
+        func();
+      } finally {
+        this.groupEnd(logLevel)();
+      }
+    }
+    trace() {
+      if (console.trace) {
+        console.trace();
+      }
+    }
+    _shouldLog(logLevel) {
+      return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+    }
+    _getLogFunction(logLevel, message, method, args, opts) {
+      if (this._shouldLog(logLevel)) {
+        opts = normalizeArguments({
+          logLevel,
+          message,
+          args,
+          opts
+        });
+        method = method || opts.method;
+        assert(method);
+        opts.total = this.getTotal();
+        opts.delta = this.getDelta();
+        this._deltaTs = getHiResTimestamp();
+        const tag = opts.tag || opts.message;
+        if (opts.once && tag) {
+          if (!cache[tag]) {
+            cache[tag] = getHiResTimestamp();
+          } else {
+            return noop;
+          }
+        }
+        message = decorateMessage(this.id, opts.message, opts);
+        return method.bind(console, message, ...opts.args);
+      }
+      return noop;
+    }
+  };
+  _defineProperty(Log, "VERSION", VERSION);
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
+  }
+  function normalizeArguments(opts) {
+    const {
+      logLevel,
+      message
+    } = opts;
+    opts.logLevel = normalizeLogLevel(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
+    }
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert(messageType === "string" || messageType === "object");
+    return Object.assign(opts, {
+      args
+    }, opts.opts);
+  }
+  function decorateMessage(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+      message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
+      message = addColor(message, opts.color, opts.background);
+    }
+    return message;
+  }
+  function logImageInNode(_ref2) {
+    let {
+      image,
+      message = "",
+      scale = 1
+    } = _ref2;
+    console.warn("removed");
+    return noop;
+  }
+  function logImageInBrowser(_ref3) {
+    let {
+      image,
+      message = "",
+      scale = 1
+    } = _ref3;
+    if (typeof image === "string") {
+      const img = new Image();
+      img.onload = () => {
+        const args = formatImage(img, message, scale);
+        console.log(...args);
+      };
+      img.src = image;
+      return noop;
+    }
+    const element = image.nodeName || "";
+    if (element.toLowerCase() === "img") {
+      console.log(...formatImage(image, message, scale));
+      return noop;
+    }
+    if (element.toLowerCase() === "canvas") {
+      const img = new Image();
+      img.onload = () => console.log(...formatImage(img, message, scale));
+      img.src = image.toDataURL();
+      return noop;
+    }
+    return noop;
+  }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default = new Log({
+    id: "@probe.gl/log"
+  });
+
+  // ../loader-utils/src/lib/log-utils/log.ts
+  var VERSION2 = true ? "4.2.0" : "latest";
+  var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
+  var log = new Log({ id: `loaders.gl ${version}` });
+
+  // ../worker-utils/src/lib/node/worker_threads-browser.ts
+  var parentPort = null;
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    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;
+  }
+
+  // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  async function getParentPort() {
+    return parentPort;
+  }
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
+  var WorkerBody = class {
+    /** Check that we are actually in a worker thread */
+    static async inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(await getParentPort());
+    }
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
+    static set onmessage(onMessage) {
+      async function handleMessage(message) {
+        const parentPort2 = await getParentPort();
+        const { type, payload } = parentPort2 ? message : message.data;
+        onMessage(type, payload);
+      }
+      getParentPort().then((parentPort2) => {
+        if (parentPort2) {
+          parentPort2.on("message", (message) => {
+            handleMessage(message);
+          });
+          parentPort2.on("exit", () => console.debug("Node worker closing"));
+        } else {
+          globalThis.onmessage = handleMessage;
+        }
+      });
+    }
+    static async addEventListener(onMessage) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      if (!onMessageWrapper) {
+        onMessageWrapper = async (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const parentPort3 = await getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
+          onMessage(type, payload);
+        };
+      }
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
+    }
+    static async removeEventListener(onMessage) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
+    }
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
+    static async postMessage(type, payload) {
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = await 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");
+  }
+
+  // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
+  var requestId = 0;
+  async function createLoaderWorker(loader) {
+    if (!await 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,
+              // @ts-expect-error fetch missing
+              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, loader, options, context) {
+    return new Promise((resolve, reject) => {
+      const id = requestId++;
+      const onMessage = (type, payload2) => {
+        if (payload2.id !== id) {
+          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, input: arrayBuffer, options };
+      WorkerBody.postMessage("process", payload);
+    });
   }
-  function project(data, x0, y0, size) {
+  async function parseData({
+    loader,
+    arrayBuffer,
+    options,
+    context
+  }) {
+    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 ${loader.name} loader`);
+    }
+    options = {
+      ...options,
+      modules: loader && loader.options && loader.options.modules || {},
+      worker: false
+    };
+    return await parser(data, { ...options }, context, loader);
+  }
+
+  // src/lib/parse-mvt.ts
+  var import_pbf = __toESM(require_pbf(), 1);
+
+  // src/lib/utils/geometry-utils.ts
+  function signedArea(ring) {
+    let sum = 0;
+    for (let i = 0, j = ring.length - 1, p1, p2; i < ring.length; j = i++) {
+      p1 = ring[i];
+      p2 = ring[j];
+      sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+    }
+    return sum;
+  }
+  function projectToLngLatFlat(data, tileIndex, extent) {
+    const { x, y, z } = tileIndex;
+    const size = extent * Math.pow(2, z);
+    const x0 = extent * x;
+    const y0 = extent * y;
     for (let j = 0, jl = data.length; j < jl; j += 2) {
       data[j] = (data[j] + x0) * 360 / size - 180;
       const y2 = 180 - (data[j + 1] + y0) * 360 / size;
       data[j + 1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
     }
   }
-  function readFeature2(tag, feature, pbf) {
-    if (feature && pbf) {
-      if (tag === 1)
-        feature.id = pbf.readVarint();
-      else if (tag === 2)
-        readTag2(pbf, feature);
-      else if (tag === 3)
-        feature.type = pbf.readVarint();
-      else if (tag === 4)
-        feature._geometry = pbf.pos;
+  function classifyRings(rings) {
+    const len = rings.length;
+    if (len <= 1)
+      return [rings];
+    const polygons = [];
+    let polygon;
+    let ccw;
+    for (let i = 0; i < len; i++) {
+      const area2 = signedArea(rings[i]);
+      if (area2 === 0)
+        continue;
+      if (ccw === void 0)
+        ccw = area2 < 0;
+      if (ccw === area2 < 0) {
+        if (polygon)
+          polygons.push(polygon);
+        polygon = [rings[i]];
+      } else if (polygon)
+        polygon.push(rings[i]);
     }
+    if (polygon)
+      polygons.push(polygon);
+    return polygons;
   }
-  function readTag2(pbf, feature) {
-    const end = pbf.readVarint() + pbf.pos;
-    while (pbf.pos < end) {
-      const key = feature._keys[pbf.readVarint()];
-      const value = feature._values[pbf.readVarint()];
-      feature.properties[key] = value;
+  function classifyRingsFlat(geom) {
+    const len = geom.indices.length;
+    const type = "Polygon";
+    if (len <= 1) {
+      return {
+        type,
+        data: geom.data,
+        areas: [[getPolygonSignedArea(geom.data)]],
+        indices: [geom.indices]
+      };
+    }
+    const areas = [];
+    const polygons = [];
+    let ringAreas = [];
+    let polygon = [];
+    let ccw;
+    let offset = 0;
+    for (let endIndex, i = 0, startIndex; i < len; i++) {
+      startIndex = geom.indices[i] - offset;
+      endIndex = geom.indices[i + 1] - offset || geom.data.length;
+      const shape = geom.data.slice(startIndex, endIndex);
+      const area2 = getPolygonSignedArea(shape);
+      if (area2 === 0) {
+        const before = geom.data.slice(0, startIndex);
+        const after = geom.data.slice(endIndex);
+        geom.data = before.concat(after);
+        offset += endIndex - startIndex;
+        continue;
+      }
+      if (ccw === void 0)
+        ccw = area2 < 0;
+      if (ccw === area2 < 0) {
+        if (polygon.length) {
+          areas.push(ringAreas);
+          polygons.push(polygon);
+        }
+        polygon = [startIndex];
+        ringAreas = [area2];
+      } else {
+        ringAreas.push(area2);
+        polygon.push(startIndex);
+      }
     }
+    if (ringAreas)
+      areas.push(ringAreas);
+    if (polygon.length)
+      polygons.push(polygon);
+    return { type, areas, indices: polygons, data: geom.data };
   }
 
-  // src/lib/binary-vector-tile/vector-tile-feature.ts
-  var endPos;
-  var cmd;
-  var cmdLen;
-  var length;
-  var x;
-  var y;
-  var i;
-  var BinaryVectorTileFeature = class {
+  // src/lib/vector-tile/vector-tile-feature.ts
+  var VectorTileFeature = class {
     properties;
     extent;
     type;
@@ -2025,23 +2470,57 @@
       this._keys = keys;
       this._values = values;
       this._geometryInfo = geometryInfo;
-      pbf.readFields(readFeature2, this, end);
+      pbf.readFields(readFeature, this, end);
     }
-    // eslint-disable-next-line complexity, max-statements
-    loadGeometry() {
+    toGeoJSON(options) {
+      const coords = this.loadGeometry();
+      if (typeof options === "function") {
+        return _toGeoJSON(this, coords, options);
+      }
+      const { x, y, z } = options;
+      const size = this.extent * Math.pow(2, z);
+      const x0 = this.extent * x;
+      const y0 = this.extent * y;
+      function project(line) {
+        for (let j = 0; j < line.length; j++) {
+          const p = line[j];
+          p[0] = (p[0] + x0) * 360 / size - 180;
+          const y2 = 180 - (p[1] + y0) * 360 / size;
+          p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+        }
+      }
+      return _toGeoJSON(this, coords, project);
+    }
+    /**
+     *
+     * @param options
+     * @returns
+     */
+    toBinaryCoordinates(options) {
+      if (typeof options === "function") {
+        return this._toBinaryCoordinates(options);
+      }
+      const tileIndex = options;
+      return this._toBinaryCoordinates(
+        (data) => projectToLngLatFlat(data, tileIndex, this.extent)
+      );
+    }
+    // eslint-disable-next-line max-statements
+    bbox() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
-      endPos = pbf.readVarint() + pbf.pos;
-      cmd = 1;
-      length = 0;
-      x = 0;
-      y = 0;
-      i = 0;
-      const indices = [];
-      const data = [];
-      while (pbf.pos < endPos) {
+      const end = pbf.readVarint() + pbf.pos;
+      let cmd = 1;
+      let length = 0;
+      let x = 0;
+      let y = 0;
+      let x1 = Infinity;
+      let x2 = -Infinity;
+      let y1 = Infinity;
+      let y2 = -Infinity;
+      while (pbf.pos < end) {
         if (length <= 0) {
-          cmdLen = pbf.readVarint();
+          const cmdLen = pbf.readVarint();
           cmd = cmdLen & 7;
           length = cmdLen >> 3;
         }
@@ -2049,30 +2528,28 @@
         if (cmd === 1 || cmd === 2) {
           x += pbf.readSVarint();
           y += pbf.readSVarint();
-          if (cmd === 1) {
-            indices.push(i);
-          }
-          data.push(x, y);
-          i += 2;
-        } else if (cmd === 7) {
-          if (i > 0) {
-            const start = indices[indices.length - 1];
-            data.push(data[start], data[start + 1]);
-            i += 2;
-          }
-        } else {
+          if (x < x1)
+            x1 = x;
+          if (x > x2)
+            x2 = x;
+          if (y < y1)
+            y1 = y;
+          if (y > y2)
+            y2 = y;
+        } else if (cmd !== 7) {
           throw new Error(`unknown command ${cmd}`);
         }
       }
-      return { data, indices };
+      return [x1, y1, x2, y2];
     }
+    // BINARY HELPERS
     /**
      *
      * @param transform
      * @returns result
      */
     _toBinaryCoordinates(transform) {
-      const geom = this.loadGeometry();
+      const geom = this.loadFlatGeometry();
       let geometry;
       transform(geom.data, this);
       const coordLength = 2;
@@ -2089,7 +2566,7 @@
           geometry = { type: "LineString", ...geom };
           break;
         case 3:
-          geometry = classifyRings2(geom);
+          geometry = classifyRingsFlat(geom);
           this._geometryInfo.polygonFeaturesCount++;
           this._geometryInfo.polygonObjectsCount += geometry.indices.length;
           for (const indices of geometry.indices) {
@@ -2106,20 +2583,165 @@
       }
       return result;
     }
-    toBinaryCoordinates(options) {
-      if (typeof options === "function") {
-        return this._toBinaryCoordinates(options);
+    // GEOJSON HELPER
+    // eslint-disable-next-line complexity, max-statements
+    loadGeometry() {
+      const pbf = this._pbf;
+      pbf.pos = this._geometry;
+      const end = pbf.readVarint() + pbf.pos;
+      let cmd = 1;
+      let length = 0;
+      let x = 0;
+      let y = 0;
+      const lines = [];
+      let line;
+      while (pbf.pos < end) {
+        if (length <= 0) {
+          const cmdLen = pbf.readVarint();
+          cmd = cmdLen & 7;
+          length = cmdLen >> 3;
+        }
+        length--;
+        switch (cmd) {
+          case 1:
+          case 2:
+            x += pbf.readSVarint();
+            y += pbf.readSVarint();
+            if (cmd === 1) {
+              if (line)
+                lines.push(line);
+              line = [];
+            }
+            if (line)
+              line.push([x, y]);
+            break;
+          case 7:
+            if (line) {
+              line.push(line[0].slice());
+            }
+            break;
+          default:
+            throw new Error(`unknown command ${cmd}`);
+        }
       }
-      const { x: x2, y: y2, z } = options;
-      const size = this.extent * Math.pow(2, z);
-      const x0 = this.extent * x2;
-      const y0 = this.extent * y2;
-      return this._toBinaryCoordinates((data) => project(data, x0, y0, size));
+      if (line)
+        lines.push(line);
+      return lines;
+    }
+    // eslint-disable-next-line complexity, max-statements
+    loadFlatGeometry() {
+      const pbf = this._pbf;
+      pbf.pos = this._geometry;
+      const endPos = pbf.readVarint() + pbf.pos;
+      let cmd = 1;
+      let cmdLen;
+      let length = 0;
+      let x = 0;
+      let y = 0;
+      let i = 0;
+      const indices = [];
+      const data = [];
+      while (pbf.pos < endPos) {
+        if (length <= 0) {
+          cmdLen = pbf.readVarint();
+          cmd = cmdLen & 7;
+          length = cmdLen >> 3;
+        }
+        length--;
+        if (cmd === 1 || cmd === 2) {
+          x += pbf.readSVarint();
+          y += pbf.readSVarint();
+          if (cmd === 1) {
+            indices.push(i);
+          }
+          data.push(x, y);
+          i += 2;
+        } else if (cmd === 7) {
+          if (i > 0) {
+            const start = indices[indices.length - 1];
+            data.push(data[start], data[start + 1]);
+            i += 2;
+          }
+        } else {
+          throw new Error(`unknown command ${cmd}`);
+        }
+      }
+      return { data, indices };
     }
   };
+  __publicField(VectorTileFeature, "types", ["Unknown", "Point", "LineString", "Polygon"]);
+  function _toGeoJSON(vtFeature, coords, transform) {
+    let type = VectorTileFeature.types[vtFeature.type];
+    let i;
+    let j;
+    let coordinates;
+    switch (vtFeature.type) {
+      case 1:
+        const points = [];
+        for (i = 0; i < coords.length; i++) {
+          points[i] = coords[i][0];
+        }
+        coordinates = points;
+        transform(coordinates, vtFeature);
+        break;
+      case 2:
+        coordinates = coords;
+        for (i = 0; i < coordinates.length; i++) {
+          transform(coordinates[i], vtFeature);
+        }
+        break;
+      case 3:
+        coordinates = classifyRings(coords);
+        for (i = 0; i < coordinates.length; i++) {
+          for (j = 0; j < coordinates[i].length; j++) {
+            transform(coordinates[i][j], vtFeature);
+          }
+        }
+        break;
+      default:
+        throw new Error("illegal vector tile type");
+    }
+    if (coordinates.length === 1) {
+      coordinates = coordinates[0];
+    } else {
+      type = `Multi${type}`;
+    }
+    const result = {
+      type: "Feature",
+      geometry: {
+        type,
+        coordinates
+      },
+      properties: vtFeature.properties
+    };
+    if (vtFeature.id !== null) {
+      result.id = vtFeature.id;
+    }
+    return result;
+  }
+  function readFeature(tag, feature, pbf) {
+    if (feature && pbf) {
+      if (tag === 1)
+        feature.id = pbf.readVarint();
+      else if (tag === 2)
+        readTag(pbf, feature);
+      else if (tag === 3)
+        feature.type = pbf.readVarint();
+      else if (tag === 4)
+        feature._geometry = pbf.pos;
+    }
+  }
+  function readTag(pbf, feature) {
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+      const key = feature._keys[pbf.readVarint()];
+      const value = feature._values[pbf.readVarint()];
+      feature.properties[key] = value;
+    }
+  }
 
-  // src/lib/binary-vector-tile/vector-tile-layer.ts
-  var BinaryVectorTileLayer = class {
+  // src/lib/vector-tile/vector-tile-layer.ts
+  var VectorTileLayer = class {
     version;
     name;
     extent;
@@ -2137,23 +2759,36 @@
       this._keys = [];
       this._values = [];
       this._features = [];
-      pbf.readFields(readLayer2, this, end);
+      pbf.readFields(readLayer, this, end);
       this.length = this._features.length;
     }
     /**
-     * return feature `i` from this layer as a `BinaryVectorTileFeature`
+     * return feature `i` from this layer as a `VectorTileFeature`
+     * @param index
+     * @returns feature
+     */
+    getGeoJSONFeature(i) {
+      if (i < 0 || i >= this._features.length) {
+        throw new Error("feature index out of bounds");
+      }
+      this._pbf.pos = this._features[i];
+      const end = this._pbf.readVarint() + this._pbf.pos;
+      return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+    }
+    /**
+     * return binary feature `i` from this layer as a `VectorTileFeature`
      *
      * @param index
      * @param geometryInfo
-     * @returns {BinaryVectorTileFeature}
+     * @returns binary feature
      */
-    feature(i2, geometryInfo) {
-      if (i2 < 0 || i2 >= this._features.length) {
+    getBinaryFeature(i, geometryInfo) {
+      if (i < 0 || i >= this._features.length) {
         throw new Error("feature index out of bounds");
       }
-      this._pbf.pos = this._features[i2];
+      this._pbf.pos = this._features[i];
       const end = this._pbf.readVarint() + this._pbf.pos;
-      return new BinaryVectorTileFeature(
+      return new VectorTileFeature(
         this._pbf,
         end,
         this.extent,
@@ -2163,7 +2798,7 @@
       );
     }
   };
-  function readLayer2(tag, layer, pbf) {
+  function readLayer(tag, layer, pbf) {
     if (layer && pbf) {
       if (tag === 15)
         layer.version = pbf.readVarint();
@@ -2176,10 +2811,10 @@
       else if (tag === 3)
         layer._keys.push(pbf.readString());
       else if (tag === 4)
-        layer._values.push(readValueMessage2(pbf));
+        layer._values.push(readValueMessage(pbf));
     }
   }
-  function readValueMessage2(pbf) {
+  function readValueMessage(pbf) {
     let value = null;
     const end = pbf.readVarint() + pbf.pos;
     while (pbf.pos < end) {
@@ -2189,17 +2824,17 @@
     return value;
   }
 
-  // src/lib/binary-vector-tile/vector-tile.ts
-  var BinaryVectorTile = class {
+  // src/lib/vector-tile/vector-tile.ts
+  var VectorTile = class {
     layers;
     constructor(pbf, end) {
-      this.layers = pbf.readFields(readTile2, {}, end);
+      this.layers = pbf.readFields(readTile, {}, end);
     }
   };
-  function readTile2(tag, layers, pbf) {
+  function readTile(tag, layers, pbf) {
     if (tag === 3) {
       if (pbf) {
-        const layer = new BinaryVectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+        const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
         if (layer.length && layers) {
           layers[layer.name] = layer;
         }
@@ -2209,7 +2844,7 @@
 
   // src/lib/parse-mvt.ts
   function parseMVT(arrayBuffer, options) {
-    const mvtOptions = normalizeOptions(options);
+    const mvtOptions = checkOptions(options);
     const shape = options?.gis?.format || options?.mvt?.shape || options?.shape;
     switch (shape) {
       case "columnar-table":
@@ -2255,15 +2890,15 @@
     if (arrayBuffer.byteLength <= 0) {
       return [features, geometryInfo];
     }
-    const tile = new BinaryVectorTile(new import_pbf.default(arrayBuffer));
+    const tile = new VectorTile(new import_pbf.default(arrayBuffer));
     const selectedLayers = options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
     selectedLayers.forEach((layerName) => {
       const vectorTileLayer = tile.layers[layerName];
       if (!vectorTileLayer) {
         return;
       }
-      for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
-        const vectorTileFeature = vectorTileLayer.feature(i2, geometryInfo);
+      for (let i = 0; i < vectorTileLayer.length; i++) {
+        const vectorTileFeature = vectorTileLayer.getBinaryFeature(i, geometryInfo);
         const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
         features.push(decodedFeature);
       }
@@ -2282,24 +2917,24 @@
       if (!vectorTileLayer) {
         return;
       }
-      for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
-        const vectorTileFeature = vectorTileLayer.feature(i2);
+      for (let i = 0; i < vectorTileLayer.length; i++) {
+        const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(i);
         const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
         features.push(decodedFeature);
       }
     });
     return features;
   }
-  function normalizeOptions(options) {
+  function checkOptions(options) {
     if (!options?.mvt) {
       throw new Error("mvt options required");
     }
-    const wgs84Coordinates = options.mvt?.coordinates === "wgs84";
-    const { tileIndex } = options.mvt;
-    const hasTileIndex = tileIndex && Number.isFinite(tileIndex.x) && Number.isFinite(tileIndex.y) && Number.isFinite(tileIndex.z);
-    if (wgs84Coordinates && !hasTileIndex) {
+    if (options.mvt?.coordinates === "wgs84" && !options.mvt.tileIndex) {
       throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
     }
+    if (options.gis) {
+      log.warn('MVTLoader: "options.gis" is deprecated, use "options.mvt.shape" instead')();
+    }
     return options.mvt;
   }
   function getDecodedFeature(feature, options, layerName) {
@@ -2308,6 +2943,7 @@
       options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates
     );
     if (options.layerProperty) {
+      decodedFeature.properties ||= {};
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
@@ -2324,28 +2960,28 @@
   }
   function transformToLocalCoordinates(line, feature) {
     const { extent } = feature;
-    for (let i2 = 0; i2 < line.length; i2++) {
-      const p = line[i2];
+    for (let i = 0; i < line.length; i++) {
+      const p = line[i];
       p[0] /= extent;
       p[1] /= extent;
     }
   }
   function transformToLocalCoordinatesBinary(data, feature) {
     const { extent } = feature;
-    for (let i2 = 0, il = data.length; i2 < il; ++i2) {
-      data[i2] /= extent;
+    for (let i = 0, il = data.length; i < il; ++i) {
+      data[i] /= extent;
     }
   }
 
   // src/mvt-loader.ts
-  var VERSION = true ? "4.2.0-beta.2" : "latest";
+  var VERSION3 = true ? "4.2.0" : "latest";
   var MVTWorkerLoader = {
     dataType: null,
     batchType: null,
     name: "Mapbox Vector Tile",
     id: "mvt",
     module: "mvt",
-    version: VERSION,
+    version: VERSION3,
     // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
     extensions: ["mvt", "pbf"],
     mimeTypes: [
@@ -2362,7 +2998,7 @@
         coordinates: "local",
         layerProperty: "layerName",
         layers: void 0,
-        tileIndex: null
+        tileIndex: void 0
       }
     }
   };
@@ -2373,205 +3009,6 @@
     binary: true
   };
 
-  // ../worker-utils/src/lib/node/worker_threads-browser.ts
-  var parentPort = null;
-
-  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
-  function getTransferList(object, recursive = true, transfers) {
-    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;
-  }
-
-  // ../worker-utils/src/lib/worker-farm/worker-body.ts
-  async function getParentPort() {
-    return parentPort;
-  }
-  var onMessageWrapperMap = /* @__PURE__ */ new Map();
-  var WorkerBody = class {
-    /** Check that we are actually in a worker thread */
-    static async inWorkerThread() {
-      return typeof self !== "undefined" || Boolean(await getParentPort());
-    }
-    /*
-     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
-     */
-    static set onmessage(onMessage) {
-      async function handleMessage(message) {
-        const parentPort2 = await getParentPort();
-        const { type, payload } = parentPort2 ? message : message.data;
-        onMessage(type, payload);
-      }
-      getParentPort().then((parentPort2) => {
-        if (parentPort2) {
-          parentPort2.on("message", (message) => {
-            handleMessage(message);
-          });
-          parentPort2.on("exit", () => console.debug("Node worker closing"));
-        } else {
-          globalThis.onmessage = handleMessage;
-        }
-      });
-    }
-    static async addEventListener(onMessage) {
-      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
-      if (!onMessageWrapper) {
-        onMessageWrapper = async (message) => {
-          if (!isKnownMessage(message)) {
-            return;
-          }
-          const parentPort3 = await getParentPort();
-          const { type, payload } = parentPort3 ? message : message.data;
-          onMessage(type, payload);
-        };
-      }
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        console.error("not implemented");
-      } else {
-        globalThis.addEventListener("message", onMessageWrapper);
-      }
-    }
-    static async removeEventListener(onMessage) {
-      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
-      onMessageWrapperMap.delete(onMessage);
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        console.error("not implemented");
-      } else {
-        globalThis.removeEventListener("message", onMessageWrapper);
-      }
-    }
-    /**
-     * Send a message from a worker to creating thread (main thread)
-     * @param type
-     * @param payload
-     */
-    static async postMessage(type, payload) {
-      const data = { source: "loaders.gl", type, payload };
-      const transferList = getTransferList(payload);
-      const parentPort2 = await 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");
-  }
-
-  // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
-  var requestId = 0;
-  async function createLoaderWorker(loader) {
-    if (!await 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,
-              // @ts-expect-error fetch missing
-              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, loader, options, context) {
-    return new Promise((resolve, reject) => {
-      const id = requestId++;
-      const onMessage = (type, payload2) => {
-        if (payload2.id !== id) {
-          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, input: arrayBuffer, options };
-      WorkerBody.postMessage("process", payload);
-    });
-  }
-  async function parseData({
-    loader,
-    arrayBuffer,
-    options,
-    context
-  }) {
-    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 ${loader.name} loader`);
-    }
-    options = {
-      ...options,
-      modules: loader && loader.options && loader.options.modules || {},
-      worker: false
-    };
-    return await parser(data, { ...options }, context, loader);
-  }
-
   // src/workers/mvt-worker.ts
   createLoaderWorker(MVTLoader);
 })();