@loaders.gl/mvt 4.2.1 → 4.3.0-alpha.2

package/dist/dist.dev.js

@@ -12,6 +12,7 @@ var __exports__ = (() => {
   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;
   };
@@ -37,6 +38,10 @@ var __exports__ = (() => {
     mod
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
 
   // external-global-plugin:@loaders.gl/core
   var require_core = __commonJS({
@@ -54,19 +59,19 @@ var __exports__ = (() => {
         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;
@@ -84,7 +89,7 @@ var __exports__ = (() => {
         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);
@@ -117,13 +122,13 @@ var __exports__ = (() => {
             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;
       };
     }
   });
@@ -345,14 +350,14 @@ var __exports__ = (() => {
           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() {
@@ -433,8 +438,8 @@ var __exports__ = (() => {
           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++;
@@ -623,44 +628,44 @@ var __exports__ = (() => {
       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;
@@ -676,12 +681,12 @@ var __exports__ = (() => {
       }
       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) {
@@ -689,7 +694,7 @@ var __exports__ = (() => {
               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) {
@@ -697,8 +702,8 @@ var __exports__ = (() => {
               }
             }
           } 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) {
@@ -706,9 +711,9 @@ var __exports__ = (() => {
               }
             }
           } 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) {
@@ -725,7 +730,7 @@ var __exports__ = (() => {
             c = 56320 | c & 1023;
           }
           str += String.fromCharCode(c);
-          i2 += bytesPerSequence;
+          i += bytesPerSequence;
         }
         return str;
       }
@@ -733,8 +738,8 @@ var __exports__ = (() => {
         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) {
@@ -748,7 +753,7 @@ var __exports__ = (() => {
                 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;
@@ -788,14 +793,142 @@ var __exports__ = (() => {
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
-    GeoJSONTiler: () => GeoJSONTiler,
     MVTLoader: () => MVTLoader,
     MVTSource: () => MVTSource,
     MVTWorkerLoader: () => MVTWorkerLoader,
+    TableTileSource: () => TableTileSource,
     TileJSONLoader: () => TileJSONLoader
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromValue(value, defaultNumberType = "float32") {
+    if (value instanceof Date) {
+      return "date-millisecond";
+    }
+    if (value instanceof Number) {
+      return defaultNumberType;
+    }
+    if (typeof value === "string") {
+      return "utf8";
+    }
+    if (value === null || value === "undefined") {
+      return "null";
+    }
+    return "null";
+  }
+  function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== "null") {
+      return { type, nullable: false };
+    }
+    if (array.length > 0) {
+      type = getDataTypeFromValue(array[0]);
+      return { type, nullable: true };
+    }
+    return { type: "null", nullable: true };
+  }
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+
+  // ../schema/src/lib/table/simple-table/table-schema.ts
+  function deduceTableSchema(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return deduceSchemaFromRows(table.data);
+      case "geojson-table":
+        return deduceSchemaFromGeoJSON(table.features);
+      case "columnar-table":
+        return deduceSchemaFromColumns(table.data);
+      case "arrow-table":
+      default:
+        throw new Error("Deduce schema");
+    }
+  }
+  function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+      const field = deduceFieldFromColumn(column, columnName);
+      fields.push(field);
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = rowTable[0];
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromGeoJSON(features) {
+    if (!features.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = features[0].properties || {};
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+      const type = getDataTypeFromArray(column);
+      return {
+        name,
+        type: type.type || "null",
+        nullable: type.nullable
+        // metadata: {}
+      };
+    }
+    if (Array.isArray(column) && column.length > 0) {
+      const value = column[0];
+      const type = getDataTypeFromValue(value);
+      return {
+        name,
+        type,
+        nullable: true
+        // metadata: {},
+      };
+    }
+    throw new Error("empty table");
+  }
+  function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      nullable: true
+      // metadata: {}
+    };
+  }
+
   // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
   function _typeof(obj) {
     "@babel/helpers - typeof";
@@ -858,9 +991,9 @@ var __exports__ = (() => {
     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;
   }
@@ -878,24 +1011,24 @@ var __exports__ = (() => {
     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;
@@ -904,7 +1037,7 @@ var __exports__ = (() => {
     return triangles;
   }
   function linkedList(data, start, end, dim, clockwise, area2, plane) {
-    let i2;
+    let i;
     let last;
     if (area2 === void 0) {
       area2 = getPolygonSignedArea(data, {
@@ -917,11 +1050,11 @@ var __exports__ = (() => {
     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);
@@ -1085,22 +1218,22 @@ var __exports__ = (() => {
   }
   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;
   }
@@ -1124,11 +1257,11 @@ var __exports__ = (() => {
     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;
         }
       }
@@ -1172,7 +1305,7 @@ var __exports__ = (() => {
   }
   function sortLinked(list) {
     let e;
-    let i2;
+    let i;
     let inSize = 1;
     let numMerges;
     let p;
@@ -1189,7 +1322,7 @@ var __exports__ = (() => {
         numMerges++;
         q = p;
         pSize = 0;
-        for (i2 = 0; i2 < inSize; i2++) {
+        for (i = 0; i < inSize; i++) {
           pSize++;
           q = q.nextZ;
           if (!q)
@@ -1220,18 +1353,18 @@ var __exports__ = (() => {
     } 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;
@@ -1317,8 +1450,8 @@ var __exports__ = (() => {
     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;
@@ -1339,7 +1472,7 @@ var __exports__ = (() => {
       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);
@@ -1349,9 +1482,9 @@ var __exports__ = (() => {
       _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;
     }
   };
 
@@ -1520,9 +1653,9 @@ var __exports__ = (() => {
       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;
     }
@@ -1547,12 +1680,12 @@ var __exports__ = (() => {
       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;
       }
@@ -1619,11 +1752,11 @@ var __exports__ = (() => {
     }
     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);
       }
     }
   }
@@ -1636,320 +1769,723 @@ var __exports__ = (() => {
     }
     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);
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
+    }
+  }
 
-  // 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]);
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../../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;
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+      return true;
+    }
+    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 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]);
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
+  function isBrowser2() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron();
+  }
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_2 = globalThis.self || globalThis.window || globalThis.global;
+  var window_2 = globalThis.window || globalThis.self || globalThis.global;
+  var document_2 = 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 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+  var isBrowser3 = isBrowser2();
+
+  // ../../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;
     }
-    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;
+  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();
+    }
+    getConfiguration() {
+      return this.config;
+    }
+    setConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
+      }
+    }
+    _loadConfiguration() {
+      let configuration = {};
+      if (this.storage) {
+        const serializedConfiguration = this.storage.getItem(this.id);
+        configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+      }
+      Object.assign(this.config, configuration);
+      return this;
+    }
+  };
+
+  // ../../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 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;
+  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);
     }
+    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-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/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 (!isBrowser2 && 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");
+      }
     }
-    // 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}`);
+    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);
         }
       }
-      if (line)
-        lines.push(line);
-      return lines;
     }
-    // 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}`);
-        }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert2(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 (isBrowser2() && window_2.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_2 === null || window_2 === void 0 ? void 0 : (_window$performance = window_2.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: isBrowser2() ? 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;
+    }
+    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 {
+        console.log(this._storage.config);
       }
-      return [x1, y1, x22, y22];
     }
-    _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;
+    assert(condition, message) {
+      assert2(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)
+        });
       }
-      if (coords.length === 1) {
-        coords = coords[0];
-      } else {
-        type = `Multi${type}`;
+      return noop;
+    }
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop;
       }
-      const result = {
-        type: "Feature",
-        geometry: {
-          type,
-          coordinates: coords
-        },
-        properties: this.properties
+      return isBrowser2() ? 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
       };
-      if (this.id !== null) {
-        result.id = this.id;
+      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)();
       }
-      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;
+    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;
+        assert2(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 this._toGeoJSON(project2);
+      return noop;
     }
   };
-
-  // 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;
+  _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;
+    }
+    assert2(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;
+    assert2(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 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
+  function createLog() {
+    const log2 = new Log({ id: "loaders.gl" });
+    globalThis.loaders = globalThis.loaders || {};
+    globalThis.loaders.log = log2;
+    globalThis.loaders.version = version;
+    globalThis.probe = globalThis.probe || {};
+    globalThis.probe.loaders = log2;
+    return log2;
+  }
+  var log = createLog();
+
+  // ../loader-utils/src/lib/path-utils/file-aliases.ts
+  var pathPrefix = "";
+  var fileAliases = {};
+  function resolvePath(filename) {
+    for (const alias in fileAliases) {
+      if (filename.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename = filename.replace(alias, replacement);
+      }
+    }
+    if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+      filename = `${pathPrefix}${filename}`;
+    }
+    return filename;
+  }
+
+  // ../loader-utils/src/lib/sources/data-source.ts
+  var DataSource = class {
+    /** A resolved fetch function extracted from loadOptions prop */
+    fetch;
+    /** The actual load options, if calling a loaders.gl loader */
+    loadOptions;
+    _needsRefresh = true;
+    props;
+    constructor(props) {
+      this.props = { ...props };
+      this.loadOptions = { ...props.loadOptions };
+      this.fetch = getFetchFunction(this.loadOptions);
+    }
+    setProps(props) {
+      this.props = Object.assign(this.props, props);
+      this.setNeedsRefresh();
+    }
+    /** Mark this data source as needing a refresh (redraw) */
+    setNeedsRefresh() {
+      this._needsRefresh = true;
     }
     /**
-     * return feature `i` from this layer as a `VectorTileFeature`
-     * @param index
-     * @returns feature
+     * Does this data source need refreshing?
+     * @note The specifics of the refresh mechanism depends on type of data source
      */
-    feature(i2) {
-      if (i2 < 0 || i2 >= this._features.length) {
-        throw new Error("feature index out of bounds");
+    getNeedsRefresh(clear = true) {
+      const needsRefresh = this._needsRefresh;
+      if (clear) {
+        this._needsRefresh = false;
       }
-      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);
+      return needsRefresh;
     }
   };
-  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));
+  function getFetchFunction(options) {
+    const fetchFunction = options?.fetch;
+    if (fetchFunction && typeof fetchFunction === "function") {
+      return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
     }
-  }
-  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;
+    const fetchOptions = options?.fetch;
+    if (fetchOptions && typeof fetchOptions !== "function") {
+      return (url) => fetch(url, fetchOptions);
     }
-    return value;
+    return (url) => fetch(url);
   }
 
-  // src/lib/mapbox-vector-tile/vector-tile.ts
-  var VectorTile = class {
-    layers;
-    constructor(pbf, end) {
-      this.layers = pbf.readFields(readTile, {}, end);
+  // 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]);
     }
-  };
-  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;
-        }
+    return sum;
+  }
+  function convertToLocalCoordinates(coordinates, extent) {
+    if (Array.isArray(coordinates[0])) {
+      for (const subcoords of coordinates) {
+        convertToLocalCoordinates(subcoords, extent);
       }
+      return;
     }
+    const p = coordinates;
+    p[0] /= extent;
+    p[1] /= extent;
   }
-
-  // src/helpers/binary-util-functions.ts
-  function classifyRings2(geom) {
+  function convertToLocalCoordinatesFlat(data, extent) {
+    for (let i = 0, il = data.length; i < il; ++i) {
+      data[i] /= extent;
+    }
+  }
+  function projectToLngLat(line, tileIndex, extent) {
+    if (typeof line[0][0] !== "number") {
+      for (const point of line) {
+        projectToLngLat(point, tileIndex, extent);
+      }
+      return;
+    }
+    const size = extent * Math.pow(2, tileIndex.z);
+    const x0 = extent * tileIndex.x;
+    const y0 = extent * tileIndex.y;
+    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;
+    }
+  }
+  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 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 classifyRingsFlat(geom) {
     const len = geom.indices.length;
     const type = "Polygon";
     if (len <= 1) {
@@ -1966,9 +2502,9 @@ var __exports__ = (() => {
     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;
+    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) {
@@ -1998,43 +2534,9 @@ var __exports__ = (() => {
       polygons.push(polygon);
     return { type, areas, indices: polygons, data: geom.data };
   }
-  function project(data, x0, y0, size) {
-    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 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;
-    }
-  }
 
-  // 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;
@@ -2055,23 +2557,55 @@ var __exports__ = (() => {
       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() {
+    toGeoJSONFeature(coordinates, tileIndex) {
+      const coords = this.loadGeometry();
+      switch (coordinates) {
+        case "wgs84":
+          return _toGeoJSONFeature(
+            this,
+            coords,
+            (line) => projectToLngLat(line, tileIndex, this.extent)
+          );
+        default:
+          return _toGeoJSONFeature(this, coords, convertToLocalCoordinates);
+      }
+    }
+    /**
+     *
+     * @param options
+     * @returns
+     */
+    toBinaryFeature(coordinates, tileIndex) {
+      const geom = this.loadFlatGeometry();
+      switch (coordinates) {
+        case "wgs84":
+          return this._toBinaryCoordinates(
+            geom,
+            (coords) => projectToLngLatFlat(coords, tileIndex, this.extent)
+          );
+        default:
+          return this._toBinaryCoordinates(geom, convertToLocalCoordinatesFlat);
+      }
+    }
+    /** Read a bounding box from the feature */
+    // 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;
         }
@@ -2079,32 +2613,29 @@ var __exports__ = (() => {
         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();
+    _toBinaryCoordinates(geom, transform) {
       let geometry;
-      transform(geom.data, this);
+      transform(geom.data, this.extent);
       const coordLength = 2;
       switch (this.type) {
         case 1:
@@ -2119,7 +2650,7 @@ var __exports__ = (() => {
           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) {
@@ -2136,20 +2667,188 @@ var __exports__ = (() => {
       }
       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;
+    }
+    /**
+     * Expands the protobuf data to an intermediate Flat GeoJSON
+     * data format, which maps closely to the binary data buffers.
+     * It is similar to GeoJSON, but rather than storing the coordinates
+     * in multidimensional arrays, we have a 1D `data` with all the
+     * coordinates, and then index into this using the `indices`
+     * parameter, e.g.
+     *
+     * geometry: {
+     *   type: 'Point', data: [1,2], indices: [0]
+     * }
+     * geometry: {
+     *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+     * }
+     * geometry: {
+     *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+     * }
+     * Thus the indices member lets us look up the relevant range
+     * from the data array.
+     * The Multi* versions of the above types share the same data
+     * structure, just with multiple elements in the indices array
+     */
+    // 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 _toGeoJSONFeature(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.extent);
+        break;
+      case 2:
+        coordinates = coords;
+        for (i = 0; i < coordinates.length; i++) {
+          transform(coordinates[i], vtFeature.extent);
+        }
+        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.extent);
+          }
+        }
+        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.properties ||= {};
+      result.properties.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;
@@ -2167,23 +2866,36 @@ var __exports__ = (() => {
       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,
@@ -2193,7 +2905,7 @@ var __exports__ = (() => {
       );
     }
   };
-  function readLayer2(tag, layer, pbf) {
+  function readLayer(tag, layer, pbf) {
     if (layer && pbf) {
       if (tag === 15)
         layer.version = pbf.readVarint();
@@ -2206,10 +2918,10 @@ var __exports__ = (() => {
       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) {
@@ -2219,17 +2931,17 @@ var __exports__ = (() => {
     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;
         }
@@ -2239,7 +2951,7 @@ var __exports__ = (() => {
 
   // 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":
@@ -2285,15 +2997,15 @@ var __exports__ = (() => {
     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);
       }
@@ -2312,70 +3024,54 @@ var __exports__ = (() => {
       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) {
-    const decodedFeature = feature.toGeoJSON(
-      // @ts-expect-error What is going on here?
-      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates
+    const decodedFeature = feature.toGeoJSONFeature(
+      options.coordinates || "local",
+      options.tileIndex
     );
     if (options.layerProperty) {
+      decodedFeature.properties ||= {};
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
   function getDecodedFeatureBinary(feature, options, layerName) {
-    const decodedFeature = feature.toBinaryCoordinates(
-      // @ts-expect-error
-      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary
-    );
+    const decodedFeature = feature.toBinaryFeature(options.coordinates || "local", options.tileIndex);
     if (options.layerProperty && decodedFeature.properties) {
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
-  function transformToLocalCoordinates(line, feature) {
-    const { extent } = feature;
-    for (let i2 = 0; i2 < line.length; i2++) {
-      const p = line[i2];
-      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;
-    }
-  }
 
   // src/mvt-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "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: [
@@ -2392,7 +3088,7 @@ var __exports__ = (() => {
         coordinates: "local",
         layerProperty: "layerName",
         layers: void 0,
-        tileIndex: null
+        tileIndex: void 0
       }
     }
   };
@@ -2404,7 +3100,7 @@ var __exports__ = (() => {
   };
 
   // src/lib/parse-tilejson.ts
-  var isObject = (x2) => x2 !== null && typeof x2 === "object";
+  var isObject = (x) => x !== null && typeof x === "object";
   function parseTileJSON(jsonMetadata, options) {
     if (!jsonMetadata || !isObject(jsonMetadata)) {
       return null;
@@ -2608,14 +3304,14 @@ var __exports__ = (() => {
   }
 
   // src/tilejson-loader.ts
-  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TileJSONLoader = {
     dataType: null,
     batchType: null,
     name: "TileJSON",
     id: "tilejson",
     module: "pmtiles",
-    version: VERSION2,
+    version: VERSION4,
     worker: true,
     extensions: ["json"],
     mimeTypes: ["application/json"],
@@ -2638,94 +3334,8 @@ var __exports__ = (() => {
     }
   };
 
-  // ../loader-utils/src/lib/env-utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-
-  // ../loader-utils/src/lib/env-utils/globals.ts
-  var globals = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_ = globals.self || globals.window || globals.global || {};
-  var window_ = globals.window || globals.self || globals.global || {};
-  var global_ = globals.global || globals.self || globals.window || {};
-  var document_ = globals.document || {};
-  var isBrowser = (
-    // @ts-ignore process does not exist on browser
-    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
-  );
-  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion = matches && parseFloat(matches[1]) || 0;
-
-  // ../loader-utils/src/lib/path-utils/file-aliases.ts
-  var pathPrefix = "";
-  var fileAliases = {};
-  function resolvePath(filename) {
-    for (const alias in fileAliases) {
-      if (filename.startsWith(alias)) {
-        const replacement = fileAliases[alias];
-        filename = filename.replace(alias, replacement);
-      }
-    }
-    if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
-      filename = `${pathPrefix}${filename}`;
-    }
-    return filename;
-  }
-
-  // ../loader-utils/src/lib/sources/data-source.ts
-  var DataSource = class {
-    /** A resolved fetch function extracted from loadOptions prop */
-    fetch;
-    /** The actual load options, if calling a loaders.gl loader */
-    loadOptions;
-    _needsRefresh = true;
-    props;
-    constructor(props) {
-      this.props = { ...props };
-      this.loadOptions = { ...props.loadOptions };
-      this.fetch = getFetchFunction(this.loadOptions);
-    }
-    setProps(props) {
-      this.props = Object.assign(this.props, props);
-      this.setNeedsRefresh();
-    }
-    /** Mark this data source as needing a refresh (redraw) */
-    setNeedsRefresh() {
-      this._needsRefresh = true;
-    }
-    /**
-     * Does this data source need refreshing?
-     * @note The specifics of the refresh mechanism depends on type of data source
-     */
-    getNeedsRefresh(clear = true) {
-      const needsRefresh = this._needsRefresh;
-      if (clear) {
-        this._needsRefresh = false;
-      }
-      return needsRefresh;
-    }
-  };
-  function getFetchFunction(options) {
-    const fetchFunction = options?.fetch;
-    if (fetchFunction && typeof fetchFunction === "function") {
-      return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
-    }
-    const fetchOptions = options?.fetch;
-    if (fetchOptions && typeof fetchOptions !== "function") {
-      return (url) => fetch(url, fetchOptions);
-    }
-    return (url) => fetch(url);
-  }
-
   // ../images/src/lib/utils/version.ts
-  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -2925,8 +3535,8 @@ var __exports__ = (() => {
   }
   function checkString(buffer, header, offset = 0) {
     const headerBytes = stringToBytes(header);
-    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
-      if (headerBytes[i2] !== buffer[i2 + offset]) {
+    for (let i = 0; i < headerBytes.length; ++i) {
+      if (headerBytes[i] !== buffer[i + offset]) {
         return false;
       }
     }
@@ -2996,30 +3606,30 @@ var __exports__ = (() => {
       return null;
     }
     const { tableMarkers, sofMarkers } = getJpegMarkers();
-    let i2 = 2;
-    while (i2 + 9 < dataView.byteLength) {
-      const marker = dataView.getUint16(i2, BIG_ENDIAN);
+    let i = 2;
+    while (i + 9 < dataView.byteLength) {
+      const marker = dataView.getUint16(i, BIG_ENDIAN);
       if (sofMarkers.has(marker)) {
         return {
           mimeType: "image/jpeg",
-          height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+          height: dataView.getUint16(i + 5, BIG_ENDIAN),
           // Number of lines
-          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+          width: dataView.getUint16(i + 7, BIG_ENDIAN)
           // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
         return null;
       }
-      i2 += 2;
-      i2 += dataView.getUint16(i2, BIG_ENDIAN);
+      i += 2;
+      i += dataView.getUint16(i, BIG_ENDIAN);
     }
     return null;
   }
   function getJpegMarkers() {
     const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]);
-    for (let i2 = 65504; i2 < 65520; ++i2) {
-      tableMarkers.add(i2);
+    for (let i = 65504; i < 65520; ++i) {
+      tableMarkers.add(i);
     }
     const sofMarkers = /* @__PURE__ */ new Set([
       65472,
@@ -3123,7 +3733,7 @@ var __exports__ = (() => {
     id: "image",
     module: "images",
     name: "Images",
-    version: VERSION3,
+    version: VERSION5,
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
@@ -3178,9 +3788,9 @@ var __exports__ = (() => {
     getTileMIMEType() {
       return this.mimeType;
     }
-    async getTile(tileParams) {
-      const { x: x2, y: y2, zoom: z } = tileParams;
-      const tileUrl = this.getTileURL(x2, y2, z);
+    async getTile(parameters) {
+      const { x, y, z } = parameters;
+      const tileUrl = this.getTileURL(x, y, z);
       const response = await this.fetch(tileUrl);
       if (!response.ok) {
         return null;
@@ -3190,9 +3800,9 @@ var __exports__ = (() => {
     }
     // Tile Source interface implementation: deck.gl compatible API
     // TODO - currently only handles image tiles, not vector tiles
-    async getTileData(tileParams) {
-      const { x: x2, y: y2, z } = tileParams.index;
-      const arrayBuffer = await this.getTile({ x: x2, y: y2, zoom: z, layers: [] });
+    async getTileData(parameters) {
+      const { x, y, z } = parameters.index;
+      const arrayBuffer = await this.getTile({ x, y, z, layers: [] });
       if (arrayBuffer === null) {
         return null;
       }
@@ -3200,7 +3810,7 @@ var __exports__ = (() => {
       this.mimeType = this.mimeType || imageMetadata?.mimeType || "application/vnd.mapbox-vector-tile";
       switch (this.mimeType) {
         case "application/vnd.mapbox-vector-tile":
-          return await this._parseVectorTile(arrayBuffer, { x: x2, y: y2, zoom: z, layers: [] });
+          return await this._parseVectorTile(arrayBuffer, { x, y, z, layers: [] });
         default:
           return await this._parseImageTile(arrayBuffer);
       }
@@ -3223,7 +3833,7 @@ var __exports__ = (() => {
         shape: "geojson-table",
         mvt: {
           coordinates: "wgs84",
-          tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.zoom },
+          tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.z },
           ...this.loadOptions?.mvt
         },
         ...this.loadOptions
@@ -3233,14 +3843,14 @@ var __exports__ = (() => {
     getMetadataUrl() {
       return this.metadataUrl;
     }
-    getTileURL(x2, y2, z) {
+    getTileURL(x, y, z) {
       switch (this.schema) {
         case "xyz":
-          return `${this.url}/${x2}/${y2}/${z}${this.extension}`;
+          return `${this.url}/${x}/${y}/${z}${this.extension}`;
         case "tms":
-          return `${this.url}/${z}/${x2}/${y2}${this.extension}`;
+          return `${this.url}/${z}/${x}/${y}${this.extension}`;
         case "template":
-          return getURLFromTemplate(this.url, x2, y2, z, "0");
+          return getURLFromTemplate(this.url, x, y, z, "0");
         default:
           throw new Error(this.schema);
       }
@@ -3252,17 +3862,17 @@ var __exports__ = (() => {
   var xRegex = new RegExp("{x}", "g");
   var yRegex = new RegExp("{y}", "g");
   var zRegex = new RegExp("{z}", "g");
-  function getURLFromTemplate(template, x2, y2, z, id = "0") {
+  function getURLFromTemplate(template, x, y, z, id = "0") {
     if (Array.isArray(template)) {
-      const i2 = stringHash(id) % template.length;
-      template = template[i2];
+      const i = stringHash(id) % template.length;
+      template = template[i];
     }
     let url = template;
-    url = url.replace(xRegex, String(x2));
-    url = url.replace(yRegex, String(y2));
+    url = url.replace(xRegex, String(x));
+    url = url.replace(yRegex, String(y));
     url = url.replace(zRegex, String(z));
-    if (Number.isInteger(y2) && Number.isInteger(z)) {
-      url = url.replace(/\{-y\}/g, String(Math.pow(2, z) - y2 - 1));
+    if (Number.isInteger(y) && Number.isInteger(z)) {
+      url = url.replace(/\{-y\}/g, String(Math.pow(2, z) - y - 1));
     }
     return url;
   }
@@ -3270,7 +3880,200 @@ var __exports__ = (() => {
     return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
   }
 
-  // src/lib/geojson-tiler/simplify.ts
+  // node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp2() {
+    let timestamp;
+    if (typeof window !== "undefined" && window.performance) {
+      timestamp = window.performance.now();
+    } else if (typeof process !== "undefined" && process.hrtime) {
+      const timeParts = process.hrtime();
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // node_modules/@probe.gl/stats/dist/lib/stat.js
+  var Stat = class {
+    constructor(name, type) {
+      this.sampleSize = 1;
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      this.name = name;
+      this.type = type;
+      this.reset();
+    }
+    reset() {
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      return this;
+    }
+    setSampleSize(samples) {
+      this.sampleSize = samples;
+      return this;
+    }
+    /** Call to increment count (+1) */
+    incrementCount() {
+      this.addCount(1);
+      return this;
+    }
+    /** Call to decrement count (-1) */
+    decrementCount() {
+      this.subtractCount(1);
+      return this;
+    }
+    /** Increase count */
+    addCount(value) {
+      this._count += value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Decrease count */
+    subtractCount(value) {
+      this._count -= value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Add an arbitrary timing and bump the count */
+    addTime(time) {
+      this._time += time;
+      this.lastTiming = time;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Start a timer */
+    timeStart() {
+      this._startTime = getHiResTimestamp2();
+      this._timerPending = true;
+      return this;
+    }
+    /** End a timer. Adds to time and bumps the timing count. */
+    timeEnd() {
+      if (!this._timerPending) {
+        return this;
+      }
+      this.addTime(getHiResTimestamp2() - this._startTime);
+      this._timerPending = false;
+      this._checkSampling();
+      return this;
+    }
+    getSampleAverageCount() {
+      return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
+    }
+    /** Calculate average time / count for the previous window */
+    getSampleAverageTime() {
+      return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
+    }
+    /** Calculate counts per second for the previous window */
+    getSampleHz() {
+      return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
+    }
+    getAverageCount() {
+      return this.samples > 0 ? this.count / this.samples : 0;
+    }
+    /** Calculate average time / count */
+    getAverageTime() {
+      return this.samples > 0 ? this.time / this.samples : 0;
+    }
+    /** Calculate counts per second */
+    getHz() {
+      return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
+    }
+    _checkSampling() {
+      if (this._samples === this.sampleSize) {
+        this.lastSampleTime = this._time;
+        this.lastSampleCount = this._count;
+        this.count += this._count;
+        this.time += this._time;
+        this.samples += this._samples;
+        this._time = 0;
+        this._count = 0;
+        this._samples = 0;
+      }
+    }
+  };
+
+  // node_modules/@probe.gl/stats/dist/lib/stats.js
+  var Stats = class {
+    constructor(options) {
+      this.stats = {};
+      this.id = options.id;
+      this.stats = {};
+      this._initializeStats(options.stats);
+      Object.seal(this);
+    }
+    /** Acquire a stat. Create if it doesn't exist. */
+    get(name, type = "count") {
+      return this._getOrCreate({ name, type });
+    }
+    get size() {
+      return Object.keys(this.stats).length;
+    }
+    /** Reset all stats */
+    reset() {
+      for (const stat of Object.values(this.stats)) {
+        stat.reset();
+      }
+      return this;
+    }
+    forEach(fn) {
+      for (const stat of Object.values(this.stats)) {
+        fn(stat);
+      }
+    }
+    getTable() {
+      const table = {};
+      this.forEach((stat) => {
+        table[stat.name] = {
+          time: stat.time || 0,
+          count: stat.count || 0,
+          average: stat.getAverageTime() || 0,
+          hz: stat.getHz() || 0
+        };
+      });
+      return table;
+    }
+    _initializeStats(stats = []) {
+      stats.forEach((stat) => this._getOrCreate(stat));
+    }
+    _getOrCreate(stat) {
+      const { name, type } = stat;
+      let result = this.stats[name];
+      if (!result) {
+        if (stat instanceof Stat) {
+          result = stat;
+        } else {
+          result = new Stat(name, type);
+        }
+        this.stats[name] = result;
+      }
+      return result;
+    }
+  };
+
+  // src/lib/vector-tiler/simplify.ts
   function simplify(coords, first, last, sqTolerance) {
     let maxSqDist = sqTolerance;
     const mid = last - first >> 1;
@@ -3280,15 +4083,15 @@ var __exports__ = (() => {
     const ay = coords[first + 1];
     const bx = coords[last];
     const by = coords[last + 1];
-    for (let i2 = first + 3; i2 < last; i2 += 3) {
-      const d = getSqSegDist(coords[i2], coords[i2 + 1], ax, ay, bx, by);
+    for (let i = first + 3; i < last; i += 3) {
+      const d = getSqSegDist(coords[i], coords[i + 1], ax, ay, bx, by);
       if (d > maxSqDist) {
-        index = i2;
+        index = i;
         maxSqDist = d;
       } else if (d === maxSqDist) {
-        const posToMid = Math.abs(i2 - mid);
+        const posToMid = Math.abs(i - mid);
         if (posToMid < minPosToMid) {
-          index = i2;
+          index = i;
           minPosToMid = posToMid;
         }
       }
@@ -3301,25 +4104,25 @@ var __exports__ = (() => {
         simplify(coords, index, last, sqTolerance);
     }
   }
-  function getSqSegDist(px, py, x2, y2, bx, by) {
-    let dx = bx - x2;
-    let dy = by - y2;
+  function getSqSegDist(px, py, x, y, bx, by) {
+    let dx = bx - x;
+    let dy = by - y;
     if (dx !== 0 || dy !== 0) {
-      const t = ((px - x2) * dx + (py - y2) * dy) / (dx * dx + dy * dy);
+      const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
       if (t > 1) {
-        x2 = bx;
-        y2 = by;
+        x = bx;
+        y = by;
       } else if (t > 0) {
-        x2 += dx * t;
-        y2 += dy * t;
+        x += dx * t;
+        y += dy * t;
       }
     }
-    dx = px - x2;
-    dy = py - y2;
+    dx = px - x;
+    dy = py - y;
     return dx * dx + dy * dy;
   }
 
-  // src/lib/geojson-tiler/feature.ts
+  // src/lib/vector-tiler/feature.ts
   function createFeature(id, type, geom, tags) {
     const feature = {
       // eslint-disable-next-line
@@ -3348,20 +4151,20 @@ var __exports__ = (() => {
     return feature;
   }
   function calcLineBBox(feature, geom) {
-    for (let i2 = 0; i2 < geom.length; i2 += 3) {
-      feature.minX = Math.min(feature.minX, geom[i2]);
-      feature.minY = Math.min(feature.minY, geom[i2 + 1]);
-      feature.maxX = Math.max(feature.maxX, geom[i2]);
-      feature.maxY = Math.max(feature.maxY, geom[i2 + 1]);
+    for (let i = 0; i < geom.length; i += 3) {
+      feature.minX = Math.min(feature.minX, geom[i]);
+      feature.minY = Math.min(feature.minY, geom[i + 1]);
+      feature.maxX = Math.max(feature.maxX, geom[i]);
+      feature.maxY = Math.max(feature.maxY, geom[i + 1]);
     }
   }
 
-  // src/lib/geojson-tiler/convert.ts
+  // src/lib/vector-tiler/convert.ts
   function convert(data, options) {
     const features = [];
     if (data.type === "FeatureCollection") {
-      for (let i2 = 0; i2 < data.features.length; i2++) {
-        convertFeature(features, data.features[i2], options, i2);
+      for (let i = 0; i < data.features.length; i++) {
+        convertFeature(features, data.features[i], options, i);
       }
     } else if (data.type === "Feature") {
       convertFeature(features, data, options);
@@ -3437,18 +4240,18 @@ var __exports__ = (() => {
     let x0, y0;
     let size = 0;
     for (let j = 0; j < ring.length; j++) {
-      const x2 = projectX(ring[j][0]);
-      const y2 = projectY(ring[j][1]);
-      out.push(x2, y2, 0);
+      const x = projectX(ring[j][0]);
+      const y = projectY(ring[j][1]);
+      out.push(x, y, 0);
       if (j > 0) {
         if (isPolygon) {
-          size += (x0 * y2 - x2 * y0) / 2;
+          size += (x0 * y - x * y0) / 2;
         } else {
-          size += Math.sqrt(Math.pow(x2 - x0, 2) + Math.pow(y2 - y0, 2));
+          size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2));
         }
       }
-      x0 = x2;
-      y0 = y2;
+      x0 = x;
+      y0 = y;
     }
     const last = out.length - 3;
     out[2] = 1;
@@ -3459,22 +4262,22 @@ var __exports__ = (() => {
     out.end = out.size;
   }
   function convertLines(rings, out, tolerance, isPolygon) {
-    for (let i2 = 0; i2 < rings.length; i2++) {
+    for (let i = 0; i < rings.length; i++) {
       const geom = [];
-      convertLine(rings[i2], geom, tolerance, isPolygon);
+      convertLine(rings[i], geom, tolerance, isPolygon);
       out.push(geom);
     }
   }
-  function projectX(x2) {
-    return x2 / 360 + 0.5;
+  function projectX(x) {
+    return x / 360 + 0.5;
   }
-  function projectY(y2) {
-    const sin = Math.sin(y2 * Math.PI / 180);
-    const y22 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
-    return y22 < 0 ? 0 : y22 > 1 ? 1 : y22;
+  function projectY(y) {
+    const sin = Math.sin(y * Math.PI / 180);
+    const y2 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+    return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
   }
 
-  // src/lib/geojson-tiler/clip.ts
+  // src/lib/vector-tiler/clip.ts
   function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
     k1 /= scale;
     k2 /= scale;
@@ -3537,10 +4340,10 @@ var __exports__ = (() => {
     return clipped.length ? clipped : null;
   }
   function clipPoints(geom, newGeom, k1, k2, axis) {
-    for (let i2 = 0; i2 < geom.length; i2 += 3) {
-      const a = geom[i2 + axis];
+    for (let i = 0; i < geom.length; i += 3) {
+      const a = geom[i + axis];
       if (a >= k1 && a <= k2) {
-        addPoint(newGeom, geom[i2], geom[i2 + 1], geom[i2 + 2]);
+        addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
       }
     }
   }
@@ -3550,12 +4353,12 @@ var __exports__ = (() => {
     let len = geom.start;
     let segLen;
     let t;
-    for (let i2 = 0; i2 < geom.length - 3; i2 += 3) {
-      const ax2 = geom[i2];
-      const ay2 = geom[i2 + 1];
-      const az2 = geom[i2 + 2];
-      const bx = geom[i2 + 3];
-      const by = geom[i2 + 4];
+    for (let i = 0; i < geom.length - 3; i += 3) {
+      const ax2 = geom[i];
+      const ay2 = geom[i + 1];
+      const az2 = geom[i + 2];
+      const bx = geom[i + 3];
+      const by = geom[i + 4];
       const a2 = axis === 0 ? ax2 : ay2;
       const b = axis === 0 ? bx : by;
       let exited = false;
@@ -3625,21 +4428,21 @@ var __exports__ = (() => {
       clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
     }
   }
-  function addPoint(out, x2, y2, z) {
-    out.push(x2, y2, z);
+  function addPoint(out, x, y, z) {
+    out.push(x, y, z);
   }
-  function intersectX(out, ax, ay, bx, by, x2) {
-    const t = (x2 - ax) / (bx - ax);
-    addPoint(out, x2, ay + (by - ay) * t, 1);
+  function intersectX(out, ax, ay, bx, by, x) {
+    const t = (x - ax) / (bx - ax);
+    addPoint(out, x, ay + (by - ay) * t, 1);
     return t;
   }
-  function intersectY(out, ax, ay, bx, by, y2) {
-    const t = (y2 - ay) / (by - ay);
-    addPoint(out, ax + (bx - ax) * t, y2, 1);
+  function intersectY(out, ax, ay, bx, by, y) {
+    const t = (y - ay) / (by - ay);
+    addPoint(out, ax + (bx - ax) * t, y, 1);
     return t;
   }
 
-  // src/lib/geojson-tiler/wrap.ts
+  // src/lib/vector-tiler/wrap.ts
   function wrap(features, options) {
     const buffer = options.buffer / options.extent;
     let merged = features;
@@ -3658,8 +4461,8 @@ var __exports__ = (() => {
   }
   function shiftFeatureCoords(features, offset) {
     const newFeatures = [];
-    for (let i2 = 0; i2 < features.length; i2++) {
-      const feature = features[i2];
+    for (let i = 0; i < features.length; i++) {
+      const feature = features[i];
       const type = feature.type;
       let newGeometry;
       if (type === "Point" || type === "MultiPoint" || type === "LineString") {
@@ -3690,13 +4493,13 @@ var __exports__ = (() => {
       newPoints.start = points.start;
       newPoints.end = points.end;
     }
-    for (let i2 = 0; i2 < points.length; i2 += 3) {
-      newPoints.push(points[i2] + offset, points[i2 + 1], points[i2 + 2]);
+    for (let i = 0; i < points.length; i += 3) {
+      newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
     }
     return newPoints;
   }
 
-  // src/lib/geojson-tiler/transform.ts
+  // src/lib/vector-tiler/transform.ts
   function transformTile(tile, extent) {
     if (tile.transformed) {
       return tile;
@@ -3725,11 +4528,11 @@ var __exports__ = (() => {
     tile.transformed = true;
     return tile;
   }
-  function transformPoint(x2, y2, extent, z2, tx, ty) {
-    return [Math.round(extent * (x2 * z2 - tx)), Math.round(extent * (y2 * z2 - ty))];
+  function transformPoint(x, y, extent, z2, tx, ty) {
+    return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
   }
 
-  // src/lib/geojson-tiler/tile.ts
+  // src/lib/vector-tiler/tile.ts
   function createTile(features, z, tx, ty, options) {
     const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
     const tile = {
@@ -3761,22 +4564,22 @@ var __exports__ = (() => {
     tile.maxX = Math.max(tile.maxX, feature.maxX);
     tile.maxY = Math.max(tile.maxY, feature.maxY);
     if (type === "Point" || type === "MultiPoint") {
-      for (let i2 = 0; i2 < geom.length; i2 += 3) {
-        simplified.push(geom[i2], geom[i2 + 1]);
+      for (let i = 0; i < geom.length; i += 3) {
+        simplified.push(geom[i], geom[i + 1]);
         tile.numPoints++;
         tile.numSimplified++;
       }
     } else if (type === "LineString") {
       addLine(simplified, geom, tile, tolerance, false, false);
     } else if (type === "MultiLineString" || type === "Polygon") {
-      for (let i2 = 0; i2 < geom.length; i2++) {
-        addLine(simplified, geom[i2], tile, tolerance, type === "Polygon", i2 === 0);
+      for (let i = 0; i < geom.length; i++) {
+        addLine(simplified, geom[i], tile, tolerance, type === "Polygon", i === 0);
       }
     } else if (type === "MultiPolygon") {
       for (let k = 0; k < geom.length; k++) {
         const polygon = geom[k];
-        for (let i2 = 0; i2 < polygon.length; i2++) {
-          addLine(simplified, polygon[i2], tile, tolerance, true, i2 === 0);
+        for (let i = 0; i < polygon.length; i++) {
+          addLine(simplified, polygon[i], tile, tolerance, true, i === 0);
         }
       }
     }
@@ -3807,10 +4610,10 @@ var __exports__ = (() => {
       return;
     }
     const ring = [];
-    for (let i2 = 0; i2 < geom.length; i2 += 3) {
-      if (tolerance === 0 || geom[i2 + 2] > sqTolerance) {
+    for (let i = 0; i < geom.length; i += 3) {
+      if (tolerance === 0 || geom[i + 2] > sqTolerance) {
         tile.numSimplified++;
-        ring.push(geom[i2], geom[i2 + 1]);
+        ring.push(geom[i], geom[i + 1]);
       }
       tile.numPoints++;
     }
@@ -3820,110 +4623,147 @@ var __exports__ = (() => {
   }
   function rewind(ring, clockwise) {
     let area2 = 0;
-    for (let i2 = 0, j = ring.length - 2; i2 < ring.length; j = i2, i2 += 2) {
-      area2 += (ring[i2] - ring[j]) * (ring[i2 + 1] + ring[j + 1]);
+    for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
+      area2 += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
     }
     if (area2 > 0 === clockwise) {
-      for (let i2 = 0, len = ring.length; i2 < len / 2; i2 += 2) {
-        const x2 = ring[i2];
-        const y2 = ring[i2 + 1];
-        ring[i2] = ring[len - 2 - i2];
-        ring[i2 + 1] = ring[len - 1 - i2];
-        ring[len - 2 - i2] = x2;
-        ring[len - 1 - i2] = y2;
+      for (let i = 0, len = ring.length; i < len / 2; i += 2) {
+        const x = ring[i];
+        const y = ring[i + 1];
+        ring[i] = ring[len - 2 - i];
+        ring[i + 1] = ring[len - 1 - i];
+        ring[len - 2 - i] = x;
+        ring[len - 1 - i] = y;
       }
     }
   }
 
-  // src/lib/geojson-tiler/geojson-tiler.ts
-  var DEFAULT_OPTIONS = {
-    maxZoom: 14,
-    // max zoom to preserve detail on
-    indexMaxZoom: 5,
-    // max zoom in the tile index
-    indexMaxPoints: 1e5,
-    // max number of points per tile in the tile index
-    tolerance: 3,
-    // simplification tolerance (higher means simpler)
-    extent: 4096,
-    // tile extent
-    buffer: 64,
-    // tile buffer on each side
-    lineMetrics: false,
-    // whether to calculate line metrics
-    // @ts-expect-error Ensures all these required params have defaults
-    promoteId: void 0,
-    // name of a feature property to be promoted to feature.id
-    generateId: false,
-    // whether to generate feature ids. Cannot be used with promoteId
-    debug: 0
-    // logging level (0, 1 or 2)
-  };
-  var GeoJSONTiler = class {
-    options;
-    // tiles and tileCoords are part of the public API
+  // src/table-tile-source.ts
+  var _TableTileSource = class {
+    /** Stats for this TableTileSource */
+    stats = new Stats({
+      id: "table-tile-source",
+      stats: [new Stat("tiles", "count"), new Stat("features", "count")]
+    });
+    /** MIME type of the tiles emitted by this tile source */
+    mimeType = "application/vnd.mapbox-vector-tile";
+    localCoordinates = true;
+    /** The props that this tile source was created with */
+    props;
+    /* Schema of the data */
+    schema = null;
+    /** Map of generated tiles, indexed by stringified tile coordinates */
     tiles = {};
+    /** Array of tile coordinates */
     tileCoords = [];
-    stats = {};
-    total = 0;
-    constructor(data, options) {
-      this.options = { ...DEFAULT_OPTIONS, ...options };
-      options = this.options;
-      const debug = options.debug;
-      if (debug)
-        console.time("preprocess data");
-      if (this.options.maxZoom < 0 || this.options.maxZoom > 24) {
+    /** Input data has loaded, initial top-level tiling is done, sync methods can now be called */
+    ready;
+    /** Metadata for the tile source (generated TileJSON/tilestats */
+    metadata;
+    constructor(table, props) {
+      this.props = { ..._TableTileSource.defaultProps, ...props };
+      this.getTileData = this.getTileData.bind(this);
+      this.ready = this.initializeTilesAsync(table);
+      this.metadata = this.getMetadata();
+    }
+    async initializeTilesAsync(tablePromise) {
+      const table = await tablePromise;
+      this.schema = deduceTableSchema(table);
+      this.createRootTiles(table);
+    }
+    async getMetadata() {
+      await this.ready;
+      return { schema: this.schema, minZoom: 0, maxZoom: this.props.maxZoom };
+    }
+    async getSchema() {
+      await this.ready;
+      return this.schema;
+    }
+    /**
+     * Get a tile at the specified index
+     * @param tileIndex z, x, y of tile
+     * @returns
+     */
+    async getVectorTile(tileIndex) {
+      await this.ready;
+      const table = this.getTileSync(tileIndex);
+      log.info(2, "getVectorTile", tileIndex, table)();
+      return table;
+    }
+    async getTile(tileIndex) {
+      await this.ready;
+      return this.getTileSync(tileIndex);
+    }
+    async getTileData(tileParams) {
+      const { x, y, z } = tileParams.index;
+      const tile = await this.getVectorTile({ x, y, z });
+      return tile?.features || [];
+    }
+    // Implementation
+    /**
+     * Synchronously request a tile
+     * @note Application must await `source.ready` before calling sync methods.
+     */
+    getTileSync(tileIndex) {
+      const rawTile = this.getRawTile(tileIndex);
+      if (!rawTile) {
+        return null;
+      }
+      return convertToGeoJSONTable(rawTile, {
+        coordinates: this.props.coordinates,
+        tileIndex,
+        extent: this.props.extent
+      });
+    }
+    /**
+     * Create the initial tiles
+     * @note the tiles stores all the features together with additional data
+     */
+    createRootTiles(table) {
+      if (this.props.maxZoom < 0 || this.props.maxZoom > 24) {
         throw new Error("maxZoom should be in the 0-24 range");
       }
-      if (options.promoteId && this.options.generateId) {
+      if (this.props.promoteId && this.props.generateId) {
         throw new Error("promoteId and generateId cannot be used together.");
       }
-      let features = convert(data, options);
-      if (debug) {
-        console.timeEnd("preprocess data");
-        console.log(
-          "index: maxZoom: %d, maxPoints: %d",
-          options.indexMaxZoom,
-          options.indexMaxPoints
-        );
-        console.time("generate tiles");
-      }
-      features = wrap(features, this.options);
-      if (features.length) {
-        this.splitTile(features, 0, 0, 0);
-      }
-      if (debug) {
-        if (features.length) {
-          console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
-        }
-        console.timeEnd("generate tiles");
-        console.log("tiles generated:", this.total, JSON.stringify(this.stats));
+      log.log(1, "TableTileSource creating root tiles", this.props)();
+      log.time(1, "preprocess table")();
+      let features = convert(table, this.props);
+      log.timeEnd(1, "preprocess table")();
+      log.time(1, "generate tiles")();
+      features = wrap(features, this.props);
+      if (features.length === 0) {
+        log.log(1, "TableTileSource: no features generated")();
+        return;
       }
+      this.splitTile(features, 0, 0, 0);
+      const rootTile = this.tiles[0];
+      log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
+      log.timeEnd(1, "generate tiles")();
+      log.log(1, `TableTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
     }
     /**
-     * Get a tile at the specified index
-     * @param z
-     * @param x
-     * @param y
-     * @returns
+     * Return geojsonvt-style "half formed" vector tile
+     * @note Application must await `source.ready` before calling sync methods.
      */
     // eslint-disable-next-line complexity, max-statements
-    getTile(z, x2, y2) {
-      const { extent, debug } = this.options;
+    getRawTile(tileIndex) {
+      const { z, y } = tileIndex;
+      let { x } = tileIndex;
+      const { extent } = this.props;
       if (z < 0 || z > 24) {
         return null;
       }
       const z2 = 1 << z;
-      x2 = x2 + z2 & z2 - 1;
-      const id = toID(z, x2, y2);
+      x = x + z2 & z2 - 1;
+      const id = toID(z, x, y);
       if (this.tiles[id]) {
         return transformTile(this.tiles[id], extent);
       }
-      if (debug > 1)
-        console.log("drilling down to z%d-%d-%d", z, x2, y2);
+      log.log(log, "drilling down to z%d-%d-%d", z, x, y)();
       let z0 = z;
-      let x0 = x2;
-      let y0 = y2;
+      let x0 = x;
+      let y0 = y;
       let parent;
       while (!parent && z0 > 0) {
         z0--;
@@ -3934,14 +4774,10 @@ var __exports__ = (() => {
       if (!parent || !parent.source) {
         return null;
       }
-      if (debug > 1) {
-        console.log("found parent tile z%d-%d-%d", z0, x0, y0);
-        console.time("drilling down");
-      }
-      this.splitTile(parent.source, z0, x0, y0, z, x2, y2);
-      if (debug > 1) {
-        console.timeEnd("drilling down");
-      }
+      log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
+      log.time(1, "drilling down")();
+      this.splitTile(parent.source, z0, x0, y0, z, x, y);
+      log.timeEnd(1, "drilling down")();
       return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
     }
     /**
@@ -3950,62 +4786,62 @@ var __exports__ = (() => {
      * @param cz, cx, and cy are the coordinates of the target tile
      *
      * If no target tile is specified, splitting stops when we reach the maximum
-     * zoom or the number of points is low as specified in the options.
+     * zoom or the number of points is low as specified in the props.
      */
     // eslint-disable-next-line max-params, max-statements, complexity
-    splitTile(features, z, x2, y2, cz, cx, cy) {
-      const stack = [features, z, x2, y2];
-      const options = this.options;
-      const debug = options.debug;
+    splitTile(features, z, x, y, cz, cx, cy) {
+      const stack = [features, z, x, y];
       while (stack.length) {
-        y2 = stack.pop();
-        x2 = stack.pop();
+        y = stack.pop();
+        x = stack.pop();
         z = stack.pop();
         features = stack.pop();
         const z2 = 1 << z;
-        const id = toID(z, x2, y2);
+        const id = toID(z, x, y);
         let tile = this.tiles[id];
         if (!tile) {
-          if (debug > 1) {
-            console.time("creation");
-          }
-          tile = this.tiles[id] = createTile(features, z, x2, y2, options);
-          this.tileCoords.push({ z, x: x2, y: y2 });
-          if (debug) {
-            if (debug > 1) {
-              console.log(
-                "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",
-                z,
-                x2,
-                y2,
-                tile.numFeatures,
-                tile.numPoints,
-                tile.numSimplified
-              );
-              console.timeEnd("creation");
-            }
-            const key = `z${z}`;
-            this.stats[key] = (this.stats[key] || 0) + 1;
-            this.total++;
-          }
+          log.time(2, "tile creation")();
+          tile = this.tiles[id] = createTile(features, z, x, y, this.props);
+          this.tileCoords.push({ z, x, y });
+          const key = `z${z}`;
+          let stat = this.stats.get(key, "count");
+          stat.incrementCount();
+          stat = this.stats.get("total");
+          stat.incrementCount();
+          stat = _TableTileSource.stats.get(key, "count");
+          stat.incrementCount();
+          stat = _TableTileSource.stats.get("total");
+          stat.incrementCount();
+          log.log(
+            2,
+            "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",
+            z,
+            x,
+            y,
+            tile.numFeatures,
+            tile.numPoints,
+            tile.numSimplified
+          )();
+          log.timeEnd(2, "tile creation")();
         }
         tile.source = features;
         if (cz === void 0) {
-          if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints)
+          if (z === this.props.indexMaxZoom || tile.numPoints <= this.props.maxPointsPerTile) {
             continue;
-        } else if (z === options.maxZoom || z === cz) {
+          }
+        } else if (z === this.props.maxZoom || z === cz) {
           continue;
         } else if (cz !== void 0) {
           const zoomSteps = cz - z;
-          if (x2 !== cx >> zoomSteps || y2 !== cy >> zoomSteps)
+          if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) {
             continue;
+          }
         }
         tile.source = null;
         if (features.length === 0)
           continue;
-        if (debug > 1)
-          console.time("clipping");
-        const k1 = 0.5 * options.buffer / options.extent;
+        log.time(2, "clipping tile")();
+        const k1 = 0.5 * this.props.buffer / this.props.extent;
         const k2 = 0.5 - k1;
         const k3 = 0.5 + k1;
         const k4 = 1 + k1;
@@ -4013,30 +4849,131 @@ var __exports__ = (() => {
         let bl = null;
         let tr = null;
         let br = null;
-        let left = clip(features, z2, x2 - k1, x2 + k3, 0, tile.minX, tile.maxX, options);
-        let right = clip(features, z2, x2 + k2, x2 + k4, 0, tile.minX, tile.maxX, options);
+        let left = clip(features, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, this.props);
+        let right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, this.props);
         features = null;
         if (left) {
-          tl = clip(left, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
-          bl = clip(left, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+          tl = clip(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+          bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
           left = null;
         }
         if (right) {
-          tr = clip(right, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
-          br = clip(right, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+          tr = clip(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+          br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
           right = null;
         }
-        if (debug > 1)
-          console.timeEnd("clipping");
-        stack.push(tl || [], z + 1, x2 * 2, y2 * 2);
-        stack.push(bl || [], z + 1, x2 * 2, y2 * 2 + 1);
-        stack.push(tr || [], z + 1, x2 * 2 + 1, y2 * 2);
-        stack.push(br || [], z + 1, x2 * 2 + 1, y2 * 2 + 1);
+        log.timeEnd(2, "clipping tile")();
+        stack.push(tl || [], z + 1, x * 2, y * 2);
+        stack.push(bl || [], z + 1, x * 2, y * 2 + 1);
+        stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
+        stack.push(br || [], z + 1, x * 2 + 1, y * 2 + 1);
       }
     }
   };
-  function toID(z, x2, y2) {
-    return ((1 << z) * y2 + x2) * 32 + z;
+  var TableTileSource = _TableTileSource;
+  __publicField(TableTileSource, "defaultProps", {
+    coordinates: "wgs84",
+    // coordinates in tile coordinates or lng/lat
+    maxZoom: 14,
+    // max zoom to preserve detail on
+    indexMaxZoom: 5,
+    // max zoom in the tile index
+    maxPointsPerTile: 1e5,
+    // max number of points per tile in the tile index
+    tolerance: 3,
+    // simplification tolerance (higher means simpler)
+    extent: 4096,
+    // tile extent
+    buffer: 64,
+    // tile buffer on each side
+    lineMetrics: false,
+    // whether to calculate line metrics
+    // @ts-expect-error
+    promoteId: void 0,
+    // name of a feature property to be promoted to feature.id
+    generateId: false,
+    // whether to generate feature ids. Cannot be used with promoteId
+    debug: 0
+    // logging level (0, 1 or 2)
+  });
+  /** Global stats for all TableTileSources */
+  __publicField(TableTileSource, "stats", new Stats({
+    id: "table-tile-source-all",
+    stats: [new Stat("count", "tiles"), new Stat("count", "features")]
+  }));
+  function toID(z, x, y) {
+    return ((1 << z) * y + x) * 32 + z;
+  }
+  function convertToGeoJSONTable(vtTile, props) {
+    const features = [];
+    for (const rawFeature of vtTile.features) {
+      if (!rawFeature || !rawFeature.geometry) {
+        continue;
+      }
+      let type;
+      let coordinates;
+      switch (rawFeature.type) {
+        case 1:
+          if (rawFeature.geometry.length === 1) {
+            type = "Point";
+            coordinates = rawFeature.geometry[0];
+          } else {
+            type = "MultiPoint";
+            coordinates = rawFeature.geometry;
+          }
+          break;
+        case 2:
+          if (rawFeature.geometry.length === 1) {
+            type = "LineString";
+            coordinates = rawFeature.geometry[0];
+          } else {
+            type = "MultiLineString";
+            coordinates = rawFeature.geometry;
+          }
+          break;
+        case 3:
+          if (rawFeature.geometry.length > 1) {
+            type = "MultiPolygon";
+            coordinates = [rawFeature.geometry];
+          } else {
+            type = "Polygon";
+            coordinates = rawFeature.geometry;
+          }
+          break;
+        default:
+          continue;
+      }
+      switch (props.coordinates) {
+        case "EPSG:4326":
+        case "wgs84":
+          projectToLngLat(coordinates, props.tileIndex, props.extent);
+          break;
+        case "local":
+          convertToLocalCoordinates(coordinates, props.extent);
+          break;
+        default:
+          throw new Error(`Unsupported CRS ${props.coordinates}`);
+      }
+      const feature = {
+        type: "Feature",
+        geometry: {
+          type,
+          coordinates
+        },
+        properties: rawFeature.tags || {},
+        id: rawFeature.id
+      };
+      features.push(feature);
+    }
+    if (features.length === 0) {
+      return null;
+    }
+    const table = {
+      shape: "geojson-table",
+      type: "FeatureCollection",
+      features
+    };
+    return table;
   }
   return __toCommonJS(bundle_exports);
 })();