@loaders.gl/pmtiles 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 i3 = isLE ? nBytes - 1 : 0;
+        var i2 = isLE ? nBytes - 1 : 0;
         var d = isLE ? -1 : 1;
-        var s = buffer[offset + i3];
-        i3 += d;
+        var s = buffer[offset + i2];
+        i2 += d;
         e = s & (1 << -nBits) - 1;
         s >>= -nBits;
         nBits += eLen;
-        for (; nBits > 0; e = e * 256 + buffer[offset + i3], i3 += d, nBits -= 8) {
+        for (; nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8) {
         }
         m = e & (1 << -nBits) - 1;
         e >>= -nBits;
         nBits += mLen;
-        for (; nBits > 0; m = m * 256 + buffer[offset + i3], i3 += d, nBits -= 8) {
+        for (; nBits > 0; m = m * 256 + buffer[offset + i2], i2 += 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 i3 = isLE ? 0 : nBytes - 1;
+        var i2 = 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 + i3] = m & 255, i3 += d, m /= 256, mLen -= 8) {
+        for (; mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) {
         }
         e = e << mLen | m;
         eLen += mLen;
-        for (; eLen > 0; buffer[offset + i3] = e & 255, i3 += d, e /= 256, eLen -= 8) {
+        for (; eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) {
         }
-        buffer[offset + i3 - d] |= s * 128;
+        buffer[offset + i2 - 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 i3 = 0; i3 < len; i3++)
-            this.buf[this.pos++] = buffer[i3];
+          for (var i2 = 0; i2 < len; i2++)
+            this.buf[this.pos++] = buffer[i2];
         },
         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 i3 = pbf.pos - 1; i3 >= startPos; i3--)
-          pbf.buf[i3 + extraLen] = pbf.buf[i3];
+        for (var i2 = pbf.pos - 1; i2 >= startPos; i2--)
+          pbf.buf[i2 + extraLen] = pbf.buf[i2];
       }
       function writePackedVarint(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeVarint(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeVarint(arr[i2]);
       }
       function writePackedSVarint(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeSVarint(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeSVarint(arr[i2]);
       }
       function writePackedFloat(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeFloat(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeFloat(arr[i2]);
       }
       function writePackedDouble(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeDouble(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeDouble(arr[i2]);
       }
       function writePackedBoolean(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeBoolean(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeBoolean(arr[i2]);
       }
       function writePackedFixed32(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeFixed32(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeFixed32(arr[i2]);
       }
       function writePackedSFixed32(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeSFixed32(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeSFixed32(arr[i2]);
       }
       function writePackedFixed64(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeFixed64(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeFixed64(arr[i2]);
       }
       function writePackedSFixed64(arr, pbf) {
-        for (var i3 = 0; i3 < arr.length; i3++)
-          pbf.writeSFixed64(arr[i3]);
+        for (var i2 = 0; i2 < arr.length; i2++)
+          pbf.writeSFixed64(arr[i2]);
       }
       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 i3 = pos;
-        while (i3 < end) {
-          var b0 = buf[i3];
+        var i2 = pos;
+        while (i2 < end) {
+          var b0 = buf[i2];
           var c = null;
           var bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
-          if (i3 + bytesPerSequence > end)
+          if (i2 + bytesPerSequence > end)
             break;
           var b1, b2, b3;
           if (bytesPerSequence === 1) {
@@ -689,7 +694,7 @@ var __exports__ = (() => {
               c = b0;
             }
           } else if (bytesPerSequence === 2) {
-            b1 = buf[i3 + 1];
+            b1 = buf[i2 + 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[i3 + 1];
-            b2 = buf[i3 + 2];
+            b1 = buf[i2 + 1];
+            b2 = buf[i2 + 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[i3 + 1];
-            b2 = buf[i3 + 2];
-            b3 = buf[i3 + 3];
+            b1 = buf[i2 + 1];
+            b2 = buf[i2 + 2];
+            b3 = buf[i2 + 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);
-          i3 += bytesPerSequence;
+          i2 += bytesPerSequence;
         }
         return str;
       }
@@ -733,8 +738,8 @@ var __exports__ = (() => {
         return utf8TextDecoder.decode(buf.subarray(pos, end));
       }
       function writeUtf8(buf, str, pos) {
-        for (var i3 = 0, c, lead; i3 < str.length; i3++) {
-          c = str.charCodeAt(i3);
+        for (var i2 = 0, c, lead; i2 < str.length; i2++) {
+          c = str.charCodeAt(i2);
           if (c > 55295 && c < 57344) {
             if (lead) {
               if (c < 56320) {
@@ -748,7 +753,7 @@ var __exports__ = (() => {
                 lead = null;
               }
             } else {
-              if (c > 56319 || i3 + 1 === str.length) {
+              if (c > 56319 || i2 + 1 === str.length) {
                 buf[pos++] = 239;
                 buf[pos++] = 191;
                 buf[pos++] = 189;
@@ -863,6 +868,548 @@ var __exports__ = (() => {
     return obj;
   }
 
+  // ../../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 (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;
+  }
+
+  // ../../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 x2 = "__storage_test__";
+      storage.setItem(x2, x2);
+      storage.removeItem(x2);
+      return storage;
+    } catch (e) {
+      return null;
+    }
+  }
+  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 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];
+  }
+
+  // ../../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");
+      }
+    }
+    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);
+        }
+      }
+    }
+  }
+
+  // ../../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);
+      }
+    }
+    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)
+        });
+      }
+      return noop;
+    }
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop;
+      }
+      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
+      };
+      const options = normalizeArguments({
+        logLevel,
+        message,
+        opts
+      });
+      const {
+        collapsed
+      } = opts;
+      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._getLogFunction(options);
+    }
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      return this.group(logLevel, message, Object.assign({}, opts, {
+        collapsed: true
+      }));
+    }
+    groupEnd(logLevel) {
+      return this._getLogFunction(logLevel, "", console.groupEnd || noop);
+    }
+    withGroup(logLevel, message, func) {
+      this.group(logLevel, message)();
+      try {
+        func();
+      } finally {
+        this.groupEnd(logLevel)();
+      }
+    }
+    trace() {
+      if (console.trace) {
+        console.trace();
+      }
+    }
+    _shouldLog(logLevel) {
+      return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+    }
+    _getLogFunction(logLevel, message, method, args, opts) {
+      if (this._shouldLog(logLevel)) {
+        opts = normalizeArguments({
+          logLevel,
+          message,
+          args,
+          opts
+        });
+        method = method || opts.method;
+        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 noop;
+    }
+  };
+  _defineProperty(Log, "VERSION", VERSION);
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    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 = {};
@@ -925,7 +1472,7 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/utils/version.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -1125,8 +1672,8 @@ var __exports__ = (() => {
   }
   function checkString(buffer, header, offset = 0) {
     const headerBytes = stringToBytes(header);
-    for (let i3 = 0; i3 < headerBytes.length; ++i3) {
-      if (headerBytes[i3] !== buffer[i3 + offset]) {
+    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
+      if (headerBytes[i2] !== buffer[i2 + offset]) {
         return false;
       }
     }
@@ -1196,30 +1743,30 @@ var __exports__ = (() => {
       return null;
     }
     const { tableMarkers, sofMarkers } = getJpegMarkers();
-    let i3 = 2;
-    while (i3 + 9 < dataView.byteLength) {
-      const marker = dataView.getUint16(i3, BIG_ENDIAN);
+    let i2 = 2;
+    while (i2 + 9 < dataView.byteLength) {
+      const marker = dataView.getUint16(i2, BIG_ENDIAN);
       if (sofMarkers.has(marker)) {
         return {
           mimeType: "image/jpeg",
-          height: dataView.getUint16(i3 + 5, BIG_ENDIAN),
+          height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
           // Number of lines
-          width: dataView.getUint16(i3 + 7, BIG_ENDIAN)
+          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
           // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
         return null;
       }
-      i3 += 2;
-      i3 += dataView.getUint16(i3, BIG_ENDIAN);
+      i2 += 2;
+      i2 += dataView.getUint16(i2, BIG_ENDIAN);
     }
     return null;
   }
   function getJpegMarkers() {
     const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]);
-    for (let i3 = 65504; i3 < 65520; ++i3) {
-      tableMarkers.add(i3);
+    for (let i2 = 65504; i2 < 65520; ++i2) {
+      tableMarkers.add(i2);
     }
     const sofMarkers = /* @__PURE__ */ new Set([
       65472,
@@ -1323,7 +1870,7 @@ var __exports__ = (() => {
     id: "image",
     module: "images",
     name: "Images",
-    version: VERSION,
+    version: VERSION3,
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
@@ -1348,9 +1895,9 @@ var __exports__ = (() => {
     let area2 = 0;
     const i0 = DimIndex[plane[0]];
     const i1 = DimIndex[plane[1]];
-    for (let i3 = start, j = end - dim; i3 < end; i3 += dim) {
-      area2 += (points[i3 + i0] - points[j + i0]) * (points[i3 + i1] + points[j + i1]);
-      j = i3;
+    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;
     }
     return area2 / 2;
   }
@@ -1368,24 +1915,24 @@ var __exports__ = (() => {
     let maxY;
     let minX;
     let minY;
-    let x3;
-    let y2;
+    let x2;
+    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 i3 = dim; i3 < outerLen; i3 += dim) {
-        x3 = positions[i3];
-        y2 = positions[i3 + 1];
-        if (x3 < minX)
-          minX = x3;
-        if (y2 < minY)
-          minY = y2;
-        if (x3 > maxX)
-          maxX = x3;
-        if (y2 > maxY)
-          maxY = y2;
+      for (let i2 = dim; i2 < outerLen; i2 += dim) {
+        x2 = positions[i2];
+        y = positions[i2 + 1];
+        if (x2 < minX)
+          minX = x2;
+        if (y < minY)
+          minY = y;
+        if (x2 > maxX)
+          maxX = x2;
+        if (y > maxY)
+          maxY = y;
       }
       invSize = Math.max(maxX - minX, maxY - minY);
       invSize = invSize !== 0 ? 32767 / invSize : 0;
@@ -1394,7 +1941,7 @@ var __exports__ = (() => {
     return triangles;
   }
   function linkedList(data, start, end, dim, clockwise, area2, plane) {
-    let i3;
+    let i2;
     let last;
     if (area2 === void 0) {
       area2 = getPolygonSignedArea(data, {
@@ -1407,11 +1954,11 @@ var __exports__ = (() => {
     let i0 = DimIndex[plane[0]];
     let i1 = DimIndex[plane[1]];
     if (clockwise === area2 < 0) {
-      for (i3 = start; i3 < end; i3 += dim)
-        last = insertNode(i3, data[i3 + i0], data[i3 + i1], last);
+      for (i2 = start; i2 < end; i2 += dim)
+        last = insertNode(i2, data[i2 + i0], data[i2 + i1], last);
     } else {
-      for (i3 = end - dim; i3 >= start; i3 -= dim)
-        last = insertNode(i3, data[i3 + i0], data[i3 + i1], last);
+      for (i2 = end - dim; i2 >= start; i2 -= dim)
+        last = insertNode(i2, data[i2 + i0], data[i2 + i1], last);
     }
     if (last && equals(last, last.next)) {
       removeNode(last);
@@ -1575,22 +2122,22 @@ var __exports__ = (() => {
   }
   function eliminateHoles(data, holeIndices, outerNode, dim, areas, plane) {
     const queue = [];
-    let i3;
+    let i2;
     let len;
     let start;
     let end;
     let list;
-    for (i3 = 0, len = holeIndices.length; i3 < len; i3++) {
-      start = holeIndices[i3] * dim;
-      end = i3 < len - 1 ? holeIndices[i3 + 1] * dim : data.length;
-      list = linkedList(data, start, end, dim, false, areas && areas[i3 + 1], plane);
+    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);
       if (list === list.next)
         list.steiner = true;
       queue.push(getLeftmost(list));
     }
     queue.sort(compareX);
-    for (i3 = 0; i3 < queue.length; i3++) {
-      outerNode = eliminateHole(queue[i3], outerNode);
+    for (i2 = 0; i2 < queue.length; i2++) {
+      outerNode = eliminateHole(queue[i2], outerNode);
     }
     return outerNode;
   }
@@ -1614,11 +2161,11 @@ var __exports__ = (() => {
     let m;
     do {
       if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-        const x3 = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-        if (x3 <= hx && x3 > qx) {
-          qx = x3;
+        const x2 = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x2 <= hx && x2 > qx) {
+          qx = x2;
           m = p.x < p.next.x ? p : p.next;
-          if (x3 === hx)
+          if (x2 === hx)
             return m;
         }
       }
@@ -1662,7 +2209,7 @@ var __exports__ = (() => {
   }
   function sortLinked(list) {
     let e;
-    let i3;
+    let i2;
     let inSize = 1;
     let numMerges;
     let p;
@@ -1679,7 +2226,7 @@ var __exports__ = (() => {
         numMerges++;
         q = p;
         pSize = 0;
-        for (i3 = 0; i3 < inSize; i3++) {
+        for (i2 = 0; i2 < inSize; i2++) {
           pSize++;
           q = q.nextZ;
           if (!q)
@@ -1710,18 +2257,18 @@ var __exports__ = (() => {
     } while (numMerges > 1);
     return list;
   }
-  function zOrder(x3, y2, minX, minY, invSize) {
-    x3 = (x3 - minX) * invSize | 0;
-    y2 = (y2 - minY) * invSize | 0;
-    x3 = (x3 | x3 << 8) & 16711935;
-    x3 = (x3 | x3 << 4) & 252645135;
-    x3 = (x3 | x3 << 2) & 858993459;
-    x3 = (x3 | x3 << 1) & 1431655765;
-    y2 = (y2 | y2 << 8) & 16711935;
-    y2 = (y2 | y2 << 4) & 252645135;
-    y2 = (y2 | y2 << 2) & 858993459;
-    y2 = (y2 | y2 << 1) & 1431655765;
-    return x3 | y2 << 1;
+  function zOrder(x2, y, minX, minY, invSize) {
+    x2 = (x2 - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
+    x2 = (x2 | x2 << 8) & 16711935;
+    x2 = (x2 | x2 << 4) & 252645135;
+    x2 = (x2 | x2 << 2) & 858993459;
+    x2 = (x2 | x2 << 1) & 1431655765;
+    y = (y | y << 8) & 16711935;
+    y = (y | y << 4) & 252645135;
+    y = (y | y << 2) & 858993459;
+    y = (y | y << 1) & 1431655765;
+    return x2 | y << 1;
   }
   function getLeftmost(start) {
     let p = start;
@@ -1807,8 +2354,8 @@ var __exports__ = (() => {
     b2.prev = bp;
     return b2;
   }
-  function insertNode(i3, x3, y2, last) {
-    const p = new Vertex(i3, x3, y2);
+  function insertNode(i2, x2, y, last) {
+    const p = new Vertex(i2, x2, y);
     if (!last) {
       p.prev = p;
       p.next = p;
@@ -1829,7 +2376,7 @@ var __exports__ = (() => {
       p.nextZ.prevZ = p.prevZ;
   }
   var Vertex = class {
-    constructor(i3, x3, y2) {
+    constructor(i2, x2, y) {
       _defineProperty(this, "i", void 0);
       _defineProperty(this, "x", void 0);
       _defineProperty(this, "y", void 0);
@@ -1839,9 +2386,9 @@ var __exports__ = (() => {
       _defineProperty(this, "prevZ", null);
       _defineProperty(this, "nextZ", null);
       _defineProperty(this, "steiner", false);
-      this.i = i3;
-      this.x = x3;
-      this.y = y2;
+      this.i = i2;
+      this.x = x2;
+      this.y = y;
     }
   };
 
@@ -2010,9 +2557,9 @@ var __exports__ = (() => {
       indexMap.linePosition,
       indexMap.linePosition + nPositions
     );
-    for (let i3 = 0, il = geometry.indices.length; i3 < il; ++i3) {
-      const start = geometry.indices[i3];
-      const end = i3 === il - 1 ? geometry.data.length : geometry.indices[i3 + 1];
+    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];
       lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
       indexMap.linePosition += (end - start) / coordLength;
     }
@@ -2037,12 +2584,12 @@ var __exports__ = (() => {
       const areas = geometry.areas[l];
       const indices = geometry.indices[l];
       const nextIndices = geometry.indices[l + 1];
-      for (let i3 = 0, il = indices.length; i3 < il; ++i3) {
-        const start = indices[i3];
-        const end = i3 === il - 1 ? (
+      for (let i2 = 0, il = indices.length; i2 < il; ++i2) {
+        const start = indices[i2];
+        const end = i2 === il - 1 ? (
           // last line, so either read to:
           nextIndices === void 0 ? geometry.data.length : nextIndices[0]
-        ) : indices[i3 + 1];
+        ) : indices[i2 + 1];
         polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
         indexMap.polygonPosition += (end - start) / coordLength;
       }
@@ -2109,11 +2656,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);
       }
     }
   }
@@ -2126,17 +2673,70 @@ var __exports__ = (() => {
     }
     return props;
   }
-  function deduceArrayType(x3, constructor) {
-    if (constructor === Array || !Number.isFinite(x3)) {
+  function deduceArrayType(x2, constructor) {
+    if (constructor === Array || !Number.isFinite(x2)) {
       return Array;
     }
-    return constructor === Float64Array || Math.fround(x3) !== x3 ? Float64Array : Float32Array;
+    return constructor === Float64Array || Math.fround(x2) !== x2 ? Float64Array : Float32Array;
   }
 
   // ../mvt/src/lib/parse-mvt.ts
   var import_pbf = __toESM(require_pbf(), 1);
 
-  // ../mvt/src/helpers/mapbox-util-functions.ts
+  // ../mvt/src/lib/utils/geometry-utils.ts
+  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]);
+    }
+    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;
+  }
+  function convertToLocalCoordinatesFlat(data, extent) {
+    for (let i2 = 0, il = data.length; i2 < il; ++i2) {
+      data[i2] /= 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: x2, y, z } = tileIndex;
+    const size = extent * Math.pow(2, z);
+    const x0 = extent * x2;
+    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)
@@ -2144,8 +2744,8 @@ var __exports__ = (() => {
     const polygons = [];
     let polygon;
     let ccw;
-    for (let i3 = 0; i3 < len; i3++) {
-      const area2 = signedArea(rings[i3]);
+    for (let i2 = 0; i2 < len; i2++) {
+      const area2 = signedArea(rings[i2]);
       if (area2 === 0)
         continue;
       if (ccw === void 0)
@@ -2153,293 +2753,15 @@ var __exports__ = (() => {
       if (ccw === area2 < 0) {
         if (polygon)
           polygons.push(polygon);
-        polygon = [rings[i3]];
+        polygon = [rings[i2]];
       } else if (polygon)
-        polygon.push(rings[i3]);
+        polygon.push(rings[i2]);
     }
     if (polygon)
       polygons.push(polygon);
     return polygons;
   }
-  function signedArea(ring) {
-    let sum = 0;
-    for (let i3 = 0, j = ring.length - 1, p1, p2; i3 < ring.length; j = i3++) {
-      p1 = ring[i3];
-      p2 = ring[j];
-      sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
-    }
-    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;
-    }
-  }
-  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;
-    }
-  }
-
-  // ../mvt/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);
-    }
-    // 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 x3 = 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) {
-          x3 += pbf.readSVarint();
-          y2 += pbf.readSVarint();
-          if (cmd2 === 1) {
-            if (line)
-              lines.push(line);
-            line = [];
-          }
-          if (line)
-            line.push([x3, y2]);
-        } else if (cmd2 === 7) {
-          if (line) {
-            line.push(line[0].slice());
-          }
-        } else {
-          throw new Error(`unknown command ${cmd2}`);
-        }
-      }
-      if (line)
-        lines.push(line);
-      return lines;
-    }
-    // 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 x3 = 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) {
-          x3 += pbf.readSVarint();
-          y2 += pbf.readSVarint();
-          if (x3 < x1)
-            x1 = x3;
-          if (x3 > x22)
-            x22 = x3;
-          if (y2 < y1)
-            y1 = y2;
-          if (y2 > y22)
-            y22 = y2;
-        } else if (cmd2 !== 7) {
-          throw new Error(`unknown command ${cmd2}`);
-        }
-      }
-      return [x1, y1, x22, y22];
-    }
-    _toGeoJSON(transform) {
-      let coords = this.loadGeometry();
-      let type = VectorTileFeature.types[this.type];
-      let i3;
-      let j;
-      switch (this.type) {
-        case 1:
-          const points = [];
-          for (i3 = 0; i3 < coords.length; i3++) {
-            points[i3] = coords[i3][0];
-          }
-          coords = points;
-          transform(coords, this);
-          break;
-        case 2:
-          for (i3 = 0; i3 < coords.length; i3++) {
-            transform(coords[i3], this);
-          }
-          break;
-        case 3:
-          coords = classifyRings(coords);
-          for (i3 = 0; i3 < coords.length; i3++) {
-            for (j = 0; j < coords[i3].length; j++) {
-              transform(coords[i3][j], this);
-            }
-          }
-          break;
-      }
-      if (coords.length === 1) {
-        coords = coords[0];
-      } else {
-        type = `Multi${type}`;
-      }
-      const result = {
-        type: "Feature",
-        geometry: {
-          type,
-          coordinates: coords
-        },
-        properties: this.properties
-      };
-      if (this.id !== null) {
-        result.id = this.id;
-      }
-      return result;
-    }
-    toGeoJSON(options) {
-      if (typeof options === "function") {
-        return this._toGeoJSON(options);
-      }
-      const { x: x3, y: y2, z } = options;
-      const size = this.extent * Math.pow(2, z);
-      const x0 = this.extent * x3;
-      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;
-        }
-      }
-      return this._toGeoJSON(project2);
-    }
-  };
-
-  // ../mvt/src/lib/mapbox-vector-tile/vector-tile-layer.ts
-  var VectorTileLayer = class {
-    version;
-    name;
-    extent;
-    length;
-    _pbf;
-    _keys;
-    _values;
-    _features;
-    constructor(pbf, end) {
-      this.version = 1;
-      this.name = "";
-      this.extent = 4096;
-      this.length = 0;
-      this._pbf = pbf;
-      this._keys = [];
-      this._values = [];
-      this._features = [];
-      pbf.readFields(readLayer, this, end);
-      this.length = this._features.length;
-    }
-    /**
-     * return feature `i` from this layer as a `VectorTileFeature`
-     * @param index
-     * @returns feature
-     */
-    feature(i3) {
-      if (i3 < 0 || i3 >= this._features.length) {
-        throw new Error("feature index out of bounds");
-      }
-      this._pbf.pos = this._features[i3];
-      const end = this._pbf.readVarint() + this._pbf.pos;
-      return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
-    }
-  };
-  function readLayer(tag, layer, pbf) {
-    if (layer && pbf) {
-      if (tag === 15)
-        layer.version = pbf.readVarint();
-      else if (tag === 1)
-        layer.name = pbf.readString();
-      else if (tag === 5)
-        layer.extent = pbf.readVarint();
-      else if (tag === 2)
-        layer._features.push(pbf.pos);
-      else if (tag === 3)
-        layer._keys.push(pbf.readString());
-      else if (tag === 4)
-        layer._values.push(readValueMessage(pbf));
-    }
-  }
-  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;
-    }
-    return value;
-  }
-
-  // ../mvt/src/lib/mapbox-vector-tile/vector-tile.ts
-  var VectorTile = class {
-    layers;
-    constructor(pbf, end) {
-      this.layers = pbf.readFields(readTile, {}, end);
-    }
-  };
-  function readTile(tag, layers, pbf) {
-    if (tag === 3) {
-      if (pbf) {
-        const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
-        if (layer.length && layers) {
-          layers[layer.name] = layer;
-        }
-      }
-    }
-  }
-
-  // ../mvt/src/helpers/binary-util-functions.ts
-  function classifyRings2(geom) {
+  function classifyRingsFlat(geom) {
     const len = geom.indices.length;
     const type = "Polygon";
     if (len <= 1) {
@@ -2456,9 +2778,9 @@ var __exports__ = (() => {
     let polygon = [];
     let ccw;
     let offset = 0;
-    for (let endIndex, i3 = 0, startIndex; i3 < len; i3++) {
-      startIndex = geom.indices[i3] - offset;
-      endIndex = geom.indices[i3 + 1] - offset || geom.data.length;
+    for (let endIndex, i2 = 0, startIndex; i2 < len; i2++) {
+      startIndex = geom.indices[i2] - offset;
+      endIndex = geom.indices[i2 + 1] - offset || geom.data.length;
       const shape = geom.data.slice(startIndex, endIndex);
       const area2 = getPolygonSignedArea(shape);
       if (area2 === 0) {
@@ -2488,43 +2810,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;
-    }
-  }
 
-  // ../mvt/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 {
+  // ../mvt/src/lib/vector-tile/vector-tile-feature.ts
+  var VectorTileFeature = class {
     properties;
     extent;
     type;
@@ -2545,56 +2833,85 @@ 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 x2 = 0;
+      let y = 0;
+      let x1 = Infinity;
+      let x22 = -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;
         }
         length--;
         if (cmd === 1 || cmd === 2) {
-          x += pbf.readSVarint();
+          x2 += 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 (x2 < x1)
+            x1 = x2;
+          if (x2 > x22)
+            x22 = x2;
+          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, x22, 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:
@@ -2609,7 +2926,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) {
@@ -2626,20 +2943,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 x2 = 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:
+            x2 += pbf.readSVarint();
+            y += pbf.readSVarint();
+            if (cmd === 1) {
+              if (line)
+                lines.push(line);
+              line = [];
+            }
+            if (line)
+              line.push([x2, y]);
+            break;
+          case 7:
+            if (line) {
+              line.push(line[0].slice());
+            }
+            break;
+          default:
+            throw new Error(`unknown command ${cmd}`);
+        }
+      }
+      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 x2 = 0;
+      let y = 0;
+      let i2 = 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) {
+          x2 += pbf.readSVarint();
+          y += pbf.readSVarint();
+          if (cmd === 1) {
+            indices.push(i2);
+          }
+          data.push(x2, y);
+          i2 += 2;
+        } else if (cmd === 7) {
+          if (i2 > 0) {
+            const start = indices[indices.length - 1];
+            data.push(data[start], data[start + 1]);
+            i2 += 2;
+          }
+        } else {
+          throw new Error(`unknown command ${cmd}`);
+        }
       }
-      const { x: x3, y: y2, z } = options;
-      const size = this.extent * Math.pow(2, z);
-      const x0 = this.extent * x3;
-      const y0 = this.extent * y2;
-      return this._toBinaryCoordinates((data) => project(data, x0, y0, size));
+      return { data, indices };
     }
   };
+  __publicField(VectorTileFeature, "types", ["Unknown", "Point", "LineString", "Polygon"]);
+  function _toGeoJSONFeature(vtFeature, coords, transform) {
+    let type = VectorTileFeature.types[vtFeature.type];
+    let i2;
+    let j;
+    let coordinates;
+    switch (vtFeature.type) {
+      case 1:
+        const points = [];
+        for (i2 = 0; i2 < coords.length; i2++) {
+          points[i2] = coords[i2][0];
+        }
+        coordinates = points;
+        transform(coordinates, vtFeature.extent);
+        break;
+      case 2:
+        coordinates = coords;
+        for (i2 = 0; i2 < coordinates.length; i2++) {
+          transform(coordinates[i2], vtFeature.extent);
+        }
+        break;
+      case 3:
+        coordinates = classifyRings(coords);
+        for (i2 = 0; i2 < coordinates.length; i2++) {
+          for (j = 0; j < coordinates[i2].length; j++) {
+            transform(coordinates[i2][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;
+    }
+  }
 
-  // ../mvt/src/lib/binary-vector-tile/vector-tile-layer.ts
-  var BinaryVectorTileLayer = class {
+  // ../mvt/src/lib/vector-tile/vector-tile-layer.ts
+  var VectorTileLayer = class {
     version;
     name;
     extent;
@@ -2657,23 +3142,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(i2) {
+      if (i2 < 0 || i2 >= this._features.length) {
+        throw new Error("feature index out of bounds");
+      }
+      this._pbf.pos = this._features[i2];
+      const end = this._pbf.readVarint() + this._pbf.pos;
+      return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+    }
+    /**
+     * return binary feature `i` from this layer as a `VectorTileFeature`
      *
      * @param index
      * @param geometryInfo
-     * @returns {BinaryVectorTileFeature}
+     * @returns binary feature
      */
-    feature(i3, geometryInfo) {
-      if (i3 < 0 || i3 >= this._features.length) {
+    getBinaryFeature(i2, geometryInfo) {
+      if (i2 < 0 || i2 >= this._features.length) {
         throw new Error("feature index out of bounds");
       }
-      this._pbf.pos = this._features[i3];
+      this._pbf.pos = this._features[i2];
       const end = this._pbf.readVarint() + this._pbf.pos;
-      return new BinaryVectorTileFeature(
+      return new VectorTileFeature(
         this._pbf,
         end,
         this.extent,
@@ -2683,7 +3181,7 @@ var __exports__ = (() => {
       );
     }
   };
-  function readLayer2(tag, layer, pbf) {
+  function readLayer(tag, layer, pbf) {
     if (layer && pbf) {
       if (tag === 15)
         layer.version = pbf.readVarint();
@@ -2696,10 +3194,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) {
@@ -2709,17 +3207,17 @@ var __exports__ = (() => {
     return value;
   }
 
-  // ../mvt/src/lib/binary-vector-tile/vector-tile.ts
-  var BinaryVectorTile = class {
+  // ../mvt/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;
         }
@@ -2729,7 +3227,7 @@ var __exports__ = (() => {
 
   // ../mvt/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":
@@ -2775,15 +3273,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 i3 = 0; i3 < vectorTileLayer.length; i3++) {
-        const vectorTileFeature = vectorTileLayer.feature(i3, geometryInfo);
+      for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
+        const vectorTileFeature = vectorTileLayer.getBinaryFeature(i2, geometryInfo);
         const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
         features.push(decodedFeature);
       }
@@ -2802,70 +3300,54 @@ var __exports__ = (() => {
       if (!vectorTileLayer) {
         return;
       }
-      for (let i3 = 0; i3 < vectorTileLayer.length; i3++) {
-        const vectorTileFeature = vectorTileLayer.feature(i3);
+      for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
+        const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(i2);
         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 i3 = 0; i3 < line.length; i3++) {
-      const p = line[i3];
-      p[0] /= extent;
-      p[1] /= extent;
-    }
-  }
-  function transformToLocalCoordinatesBinary(data, feature) {
-    const { extent } = feature;
-    for (let i3 = 0, il = data.length; i3 < il; ++i3) {
-      data[i3] /= extent;
-    }
-  }
 
   // ../mvt/src/mvt-loader.ts
-  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var MVTWorkerLoader = {
     dataType: null,
     batchType: null,
     name: "Mapbox Vector Tile",
     id: "mvt",
     module: "mvt",
-    version: VERSION2,
+    version: VERSION4,
     // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
     extensions: ["mvt", "pbf"],
     mimeTypes: [
@@ -2882,7 +3364,7 @@ var __exports__ = (() => {
         coordinates: "local",
         layerProperty: "layerName",
         layers: void 0,
-        tileIndex: null
+        tileIndex: void 0
       }
     }
   };
@@ -2894,7 +3376,7 @@ var __exports__ = (() => {
   };
 
   // ../mvt/src/lib/parse-tilejson.ts
-  var isObject = (x3) => x3 !== null && typeof x3 === "object";
+  var isObject = (x2) => x2 !== null && typeof x2 === "object";
   function parseTileJSON(jsonMetadata, options) {
     if (!jsonMetadata || !isObject(jsonMetadata)) {
       return null;
@@ -3098,14 +3580,14 @@ var __exports__ = (() => {
   }
 
   // ../mvt/src/tilejson-loader.ts
-  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TileJSONLoader = {
     dataType: null,
     batchType: null,
     name: "TileJSON",
     id: "tilejson",
     module: "pmtiles",
-    version: VERSION3,
+    version: VERSION5,
     worker: true,
     extensions: ["json"],
     mimeTypes: ["application/json"],
@@ -3165,7 +3647,7 @@ var __exports__ = (() => {
           reject(e);
         }
       };
-      var step = (x3) => x3.done ? resolve(x3.value) : Promise.resolve(x3.value).then(fulfilled, rejected);
+      var step = (x2) => x2.done ? resolve(x2.value) : Promise.resolve(x2.value).then(fulfilled, rejected);
       step((generator = generator.apply(__this, __arguments)).next());
     });
   };
@@ -3246,13 +3728,13 @@ var __exports__ = (() => {
   var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
   var freb = function(eb, start) {
     var b = new u16(31);
-    for (var i3 = 0; i3 < 31; ++i3) {
-      b[i3] = start += 1 << eb[i3 - 1];
+    for (var i2 = 0; i2 < 31; ++i2) {
+      b[i2] = start += 1 << eb[i2 - 1];
     }
     var r = new i32(b[30]);
-    for (var i3 = 1; i3 < 30; ++i3) {
-      for (var j = b[i3]; j < b[i3 + 1]; ++j) {
-        r[j] = j - b[i3] << 5 | i3;
+    for (var i2 = 1; i2 < 30; ++i2) {
+      for (var j = b[i2]; j < b[i2 + 1]; ++j) {
+        r[j] = j - b[i2] << 5 | i2;
       }
     }
     return { b, r };
@@ -3265,35 +3747,35 @@ var __exports__ = (() => {
   var fd = _b.b;
   var revfd = _b.r;
   var rev = new u16(32768);
-  for (i2 = 0; i2 < 32768; ++i2) {
-    x2 = (i2 & 43690) >> 1 | (i2 & 21845) << 1;
-    x2 = (x2 & 52428) >> 2 | (x2 & 13107) << 2;
-    x2 = (x2 & 61680) >> 4 | (x2 & 3855) << 4;
-    rev[i2] = ((x2 & 65280) >> 8 | (x2 & 255) << 8) >> 1;
-  }
-  var x2;
-  var i2;
+  for (i = 0; i < 32768; ++i) {
+    x = (i & 43690) >> 1 | (i & 21845) << 1;
+    x = (x & 52428) >> 2 | (x & 13107) << 2;
+    x = (x & 61680) >> 4 | (x & 3855) << 4;
+    rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+  }
+  var x;
+  var i;
   var hMap = function(cd, mb, r) {
     var s = cd.length;
-    var i3 = 0;
+    var i2 = 0;
     var l = new u16(mb);
-    for (; i3 < s; ++i3) {
-      if (cd[i3])
-        ++l[cd[i3] - 1];
+    for (; i2 < s; ++i2) {
+      if (cd[i2])
+        ++l[cd[i2] - 1];
     }
     var le = new u16(mb);
-    for (i3 = 1; i3 < mb; ++i3) {
-      le[i3] = le[i3 - 1] + l[i3 - 1] << 1;
+    for (i2 = 1; i2 < mb; ++i2) {
+      le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
     }
     var co;
     if (r) {
       co = new u16(1 << mb);
       var rvb = 15 - mb;
-      for (i3 = 0; i3 < s; ++i3) {
-        if (cd[i3]) {
-          var sv = i3 << 4 | cd[i3];
-          var r_1 = mb - cd[i3];
-          var v = le[cd[i3] - 1]++ << r_1;
+      for (i2 = 0; i2 < s; ++i2) {
+        if (cd[i2]) {
+          var sv = i2 << 4 | cd[i2];
+          var r_1 = mb - cd[i2];
+          var v = le[cd[i2] - 1]++ << r_1;
           for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
             co[rev[v] >> rvb] = sv;
           }
@@ -3301,38 +3783,38 @@ var __exports__ = (() => {
       }
     } else {
       co = new u16(s);
-      for (i3 = 0; i3 < s; ++i3) {
-        if (cd[i3]) {
-          co[i3] = rev[le[cd[i3] - 1]++] >> 15 - cd[i3];
+      for (i2 = 0; i2 < s; ++i2) {
+        if (cd[i2]) {
+          co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
         }
       }
     }
     return co;
   };
   var flt = new u8(288);
-  for (i2 = 0; i2 < 144; ++i2)
-    flt[i2] = 8;
-  var i2;
-  for (i2 = 144; i2 < 256; ++i2)
-    flt[i2] = 9;
-  var i2;
-  for (i2 = 256; i2 < 280; ++i2)
-    flt[i2] = 7;
-  var i2;
-  for (i2 = 280; i2 < 288; ++i2)
-    flt[i2] = 8;
-  var i2;
+  for (i = 0; i < 144; ++i)
+    flt[i] = 8;
+  var i;
+  for (i = 144; i < 256; ++i)
+    flt[i] = 9;
+  var i;
+  for (i = 256; i < 280; ++i)
+    flt[i] = 7;
+  var i;
+  for (i = 280; i < 288; ++i)
+    flt[i] = 8;
+  var i;
   var fdt = new u8(32);
-  for (i2 = 0; i2 < 32; ++i2)
-    fdt[i2] = 5;
-  var i2;
+  for (i = 0; i < 32; ++i)
+    fdt[i] = 5;
+  var i;
   var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
   var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
   var max = function(a) {
     var m = a[0];
-    for (var i3 = 1; i3 < a.length; ++i3) {
-      if (a[i3] > m)
-        m = a[i3];
+    for (var i2 = 1; i2 < a.length; ++i2) {
+      if (a[i2] > m)
+        m = a[i2];
     }
     return m;
   };
@@ -3425,28 +3907,28 @@ var __exports__ = (() => {
           pos += 14;
           var ldt = new u8(tl);
           var clt = new u8(19);
-          for (var i3 = 0; i3 < hcLen; ++i3) {
-            clt[clim[i3]] = bits(dat, pos + i3 * 3, 7);
+          for (var i2 = 0; i2 < hcLen; ++i2) {
+            clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
           }
           pos += hcLen * 3;
           var clb = max(clt), clbmsk = (1 << clb) - 1;
           var clm = hMap(clt, clb, 1);
-          for (var i3 = 0; i3 < tl; ) {
+          for (var i2 = 0; i2 < tl; ) {
             var r = clm[bits(dat, pos, clbmsk)];
             pos += r & 15;
             var s = r >> 4;
             if (s < 16) {
-              ldt[i3++] = s;
+              ldt[i2++] = s;
             } else {
               var c = 0, n = 0;
               if (s == 16)
-                n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i3 - 1];
+                n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
               else if (s == 17)
                 n = 3 + bits(dat, pos, 7), pos += 3;
               else if (s == 18)
                 n = 11 + bits(dat, pos, 127), pos += 7;
               while (n--)
-                ldt[i3++] = c;
+                ldt[i2++] = c;
             }
           }
           var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
@@ -3484,8 +3966,8 @@ var __exports__ = (() => {
         } else {
           var add = sym - 254;
           if (sym > 264) {
-            var i3 = sym - 257, b = fleb[i3];
-            add = bits(dat, pos, (1 << b) - 1) + fl[i3];
+            var i2 = sym - 257, b = fleb[i2];
+            add = bits(dat, pos, (1 << b) - 1) + fl[i2];
             pos += b;
           }
           var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
@@ -3584,24 +4066,24 @@ var __exports__ = (() => {
   var getUint48 = (view, pos) => {
     return shift(view.getUint32(pos + 2, true), 16) + view.getUint16(pos, true);
   };
-  var compare = (tz, tx, ty, view, i3) => {
-    if (tz !== view.getUint8(i3))
-      return tz - view.getUint8(i3);
-    const x3 = getUint24(view, i3 + 1);
-    if (tx !== x3)
-      return tx - x3;
-    const y2 = getUint24(view, i3 + 4);
-    if (ty !== y2)
-      return ty - y2;
+  var compare = (tz, tx, ty, view, i2) => {
+    if (tz !== view.getUint8(i2))
+      return tz - view.getUint8(i2);
+    const x2 = getUint24(view, i2 + 1);
+    if (tx !== x2)
+      return tx - x2;
+    const y = getUint24(view, i2 + 4);
+    if (ty !== y)
+      return ty - y;
     return 0;
   };
-  var queryLeafdir = (view, z, x3, y2) => {
-    const offsetLen = queryView(view, z | 128, x3, y2);
+  var queryLeafdir = (view, z, x2, y) => {
+    const offsetLen = queryView(view, z | 128, x2, y);
     if (offsetLen) {
       return {
         z,
-        x: x3,
-        y: y2,
+        x: x2,
+        y,
         offset: offsetLen[0],
         length: offsetLen[1],
         isDir: true
@@ -3609,13 +4091,13 @@ var __exports__ = (() => {
     }
     return null;
   };
-  var queryTile = (view, z, x3, y2) => {
-    const offsetLen = queryView(view, z, x3, y2);
+  var queryTile = (view, z, x2, y) => {
+    const offsetLen = queryView(view, z, x2, y);
     if (offsetLen) {
       return {
         z,
-        x: x3,
-        y: y2,
+        x: x2,
+        y,
         offset: offsetLen[0],
         length: offsetLen[1],
         isDir: false
@@ -3623,12 +4105,12 @@ var __exports__ = (() => {
     }
     return null;
   };
-  var queryView = (view, z, x3, y2) => {
+  var queryView = (view, z, x2, y) => {
     let m = 0;
     let n = view.byteLength / 17 - 1;
     while (m <= n) {
       const k = n + m >> 1;
-      const cmp = compare(z, x3, y2, view, k * 17);
+      const cmp = compare(z, x2, y, view, k * 17);
       if (cmp > 0) {
         m = k + 1;
       } else if (cmp < 0) {
@@ -3654,23 +4136,23 @@ var __exports__ = (() => {
     }
     return a.y - b.y;
   };
-  var parseEntry = (dataview, i3) => {
-    const zRaw = dataview.getUint8(i3 * 17);
+  var parseEntry = (dataview, i2) => {
+    const zRaw = dataview.getUint8(i2 * 17);
     const z = zRaw & 127;
     return {
       z,
-      x: getUint24(dataview, i3 * 17 + 1),
-      y: getUint24(dataview, i3 * 17 + 4),
-      offset: getUint48(dataview, i3 * 17 + 7),
-      length: dataview.getUint32(i3 * 17 + 13, true),
+      x: getUint24(dataview, i2 * 17 + 1),
+      y: getUint24(dataview, i2 * 17 + 4),
+      offset: getUint48(dataview, i2 * 17 + 7),
+      length: dataview.getUint32(i2 * 17 + 13, true),
       isDir: zRaw >> 7 === 1
     };
   };
   var sortDir = (a) => {
     const entries = [];
     const view = new DataView(a);
-    for (let i3 = 0; i3 < view.byteLength / 17; i3++) {
-      entries.push(parseEntry(view, i3));
+    for (let i2 = 0; i2 < view.byteLength / 17; i2++) {
+      entries.push(parseEntry(view, i2));
     }
     return createDirectory(entries);
   };
@@ -3678,28 +4160,28 @@ var __exports__ = (() => {
     entries.sort(entrySort);
     const buffer = new ArrayBuffer(17 * entries.length);
     const arr = new Uint8Array(buffer);
-    for (let i3 = 0; i3 < entries.length; i3++) {
-      const entry = entries[i3];
+    for (let i2 = 0; i2 < entries.length; i2++) {
+      const entry = entries[i2];
       let z = entry.z;
       if (entry.isDir)
         z = z | 128;
-      arr[i3 * 17] = z;
-      arr[i3 * 17 + 1] = entry.x & 255;
-      arr[i3 * 17 + 2] = entry.x >> 8 & 255;
-      arr[i3 * 17 + 3] = entry.x >> 16 & 255;
-      arr[i3 * 17 + 4] = entry.y & 255;
-      arr[i3 * 17 + 5] = entry.y >> 8 & 255;
-      arr[i3 * 17 + 6] = entry.y >> 16 & 255;
-      arr[i3 * 17 + 7] = entry.offset & 255;
-      arr[i3 * 17 + 8] = unshift(entry.offset, 8) & 255;
-      arr[i3 * 17 + 9] = unshift(entry.offset, 16) & 255;
-      arr[i3 * 17 + 10] = unshift(entry.offset, 24) & 255;
-      arr[i3 * 17 + 11] = unshift(entry.offset, 32) & 255;
-      arr[i3 * 17 + 12] = unshift(entry.offset, 48) & 255;
-      arr[i3 * 17 + 13] = entry.length & 255;
-      arr[i3 * 17 + 14] = entry.length >> 8 & 255;
-      arr[i3 * 17 + 15] = entry.length >> 16 & 255;
-      arr[i3 * 17 + 16] = entry.length >> 24 & 255;
+      arr[i2 * 17] = z;
+      arr[i2 * 17 + 1] = entry.x & 255;
+      arr[i2 * 17 + 2] = entry.x >> 8 & 255;
+      arr[i2 * 17 + 3] = entry.x >> 16 & 255;
+      arr[i2 * 17 + 4] = entry.y & 255;
+      arr[i2 * 17 + 5] = entry.y >> 8 & 255;
+      arr[i2 * 17 + 6] = entry.y >> 16 & 255;
+      arr[i2 * 17 + 7] = entry.offset & 255;
+      arr[i2 * 17 + 8] = unshift(entry.offset, 8) & 255;
+      arr[i2 * 17 + 9] = unshift(entry.offset, 16) & 255;
+      arr[i2 * 17 + 10] = unshift(entry.offset, 24) & 255;
+      arr[i2 * 17 + 11] = unshift(entry.offset, 32) & 255;
+      arr[i2 * 17 + 12] = unshift(entry.offset, 48) & 255;
+      arr[i2 * 17 + 13] = entry.length & 255;
+      arr[i2 * 17 + 14] = entry.length >> 8 & 255;
+      arr[i2 * 17 + 15] = entry.length >> 16 & 255;
+      arr[i2 * 17 + 16] = entry.length >> 24 & 255;
     }
     return buffer;
   };
@@ -3790,9 +4272,9 @@ var __exports__ = (() => {
       return header;
     });
   }
-  function getZxy(header, source, cache, z, x3, y2, signal) {
+  function getZxy(header, source, cache2, z, x2, y, signal) {
     return __async(this, null, function* () {
-      let rootDir = yield cache.getArrayBuffer(
+      let rootDir = yield cache2.getArrayBuffer(
         source,
         header.rootDirectoryOffset,
         header.rootDirectoryLength,
@@ -3801,7 +4283,7 @@ var __exports__ = (() => {
       if (header.specVersion === 1) {
         rootDir = sortDir(rootDir);
       }
-      const entry = queryTile(new DataView(rootDir), z, x3, y2);
+      const entry = queryTile(new DataView(rootDir), z, x2, y);
       if (entry) {
         const resp = yield source.getBytes(entry.offset, entry.length, signal);
         let tileData = resp.data;
@@ -3813,7 +4295,7 @@ var __exports__ = (() => {
           data: tileData
         };
       }
-      const leafcoords = deriveLeaf(new DataView(rootDir), { z, x: x3, y: y2 });
+      const leafcoords = deriveLeaf(new DataView(rootDir), { z, x: x2, y });
       if (leafcoords) {
         const leafdirEntry = queryLeafdir(
           new DataView(rootDir),
@@ -3822,7 +4304,7 @@ var __exports__ = (() => {
           leafcoords.y
         );
         if (leafdirEntry) {
-          let leafDir = yield cache.getArrayBuffer(
+          let leafDir = yield cache2.getArrayBuffer(
             source,
             leafdirEntry.offset,
             leafdirEntry.length,
@@ -3831,7 +4313,7 @@ var __exports__ = (() => {
           if (header.specVersion === 1) {
             leafDir = sortDir(leafDir);
           }
-          const tileEntry = queryTile(new DataView(leafDir), z, x3, y2);
+          const tileEntry = queryTile(new DataView(leafDir), z, x2, y);
           if (tileEntry) {
             const resp = yield source.getBytes(
               tileEntry.offset,
@@ -3974,10 +4456,10 @@ var __exports__ = (() => {
           this.tiles.set(pmtilesUrl, instance);
         }
         const z = result[2];
-        const x3 = result[3];
-        const y2 = result[4];
+        const x2 = result[3];
+        const y = result[4];
         const header = yield instance.getHeader();
-        const resp = yield instance == null ? void 0 : instance.getZxy(+z, +x3, +y2, abortController.signal);
+        const resp = yield instance == null ? void 0 : instance.getZxy(+z, +x2, +y, abortController.signal);
         if (resp) {
           return {
             data: new Uint8Array(resp.data),
@@ -4111,11 +4593,11 @@ var __exports__ = (() => {
     375299968947541,
     1501199875790165
   ];
-  function zxyToTileId(z, x3, y2) {
+  function zxyToTileId(z, x2, y) {
     if (z > 26) {
       throw Error("Tile zoom level exceeds max safe number limit (26)");
     }
-    if (x3 > __pow(2, z) - 1 || y2 > __pow(2, z) - 1) {
+    if (x2 > __pow(2, z) - 1 || y > __pow(2, z) - 1) {
       throw Error("tile x/y outside zoom level bounds");
     }
     const acc = tzValues[z];
@@ -4123,7 +4605,7 @@ var __exports__ = (() => {
     let rx = 0;
     let ry = 0;
     let d = 0;
-    const xy = [x3, y2];
+    const xy = [x2, y];
     let s = n / 2;
     while (s > 0) {
       rx = (xy[0] & s) > 0 ? 1 : 0;
@@ -4134,13 +4616,13 @@ var __exports__ = (() => {
     }
     return acc + d;
   }
-  function tileIdToZxy(i3) {
+  function tileIdToZxy(i2) {
     let acc = 0;
     const z = 0;
     for (let z2 = 0; z2 < 27; z2++) {
       const numTiles = (1 << z2) * (1 << z2);
-      if (acc + numTiles > i3) {
-        return idOnLevel(z2, i3 - acc);
+      if (acc + numTiles > i2) {
+        return idOnLevel(z2, i2 - acc);
       }
       acc += numTiles;
     }
@@ -4217,9 +4699,9 @@ var __exports__ = (() => {
     getKey() {
       return this.file.name;
     }
-    getBytes(offset, length2) {
+    getBytes(offset, length) {
       return __async(this, null, function* () {
-        const blob = this.file.slice(offset, offset + length2);
+        const blob = this.file.slice(offset, offset + length);
         const a = yield blob.arrayBuffer();
         return { data: a };
       });
@@ -4237,7 +4719,7 @@ var __exports__ = (() => {
     setHeaders(customHeaders) {
       this.customHeaders = customHeaders;
     }
-    getBytes(offset, length2, passedSignal, etag) {
+    getBytes(offset, length, passedSignal, etag) {
       return __async(this, null, function* () {
         let controller;
         let signal;
@@ -4248,14 +4730,14 @@ var __exports__ = (() => {
           signal = controller.signal;
         }
         const requestHeaders = new Headers(this.customHeaders);
-        requestHeaders.set("range", `bytes=${offset}-${offset + length2 - 1}`);
-        let cache;
+        requestHeaders.set("range", `bytes=${offset}-${offset + length - 1}`);
+        let cache2;
         if (this.mustReload) {
-          cache = "reload";
+          cache2 = "reload";
         }
         let resp = yield fetch(this.url, {
           signal,
-          cache,
+          cache: cache2,
           headers: requestHeaders
           //biome-ignore lint: "cache" is incompatible between cloudflare workers and browser
         });
@@ -4284,7 +4766,7 @@ var __exports__ = (() => {
           throw Error(`Bad response code: ${resp.status}`);
         }
         const contentLength = resp.headers.get("Content-Length");
-        if (resp.status === 200 && (!contentLength || +contentLength > length2)) {
+        if (resp.status === 200 && (!contentLength || +contentLength > length)) {
           if (controller)
             controller.abort();
           throw Error(
@@ -4348,23 +4830,23 @@ var __exports__ = (() => {
     const numEntries = readVarint(p);
     const entries = [];
     let lastId = 0;
-    for (let i3 = 0; i3 < numEntries; i3++) {
+    for (let i2 = 0; i2 < numEntries; i2++) {
       const v = readVarint(p);
       entries.push({ tileId: lastId + v, offset: 0, length: 0, runLength: 1 });
       lastId += v;
     }
-    for (let i3 = 0; i3 < numEntries; i3++) {
-      entries[i3].runLength = readVarint(p);
+    for (let i2 = 0; i2 < numEntries; i2++) {
+      entries[i2].runLength = readVarint(p);
     }
-    for (let i3 = 0; i3 < numEntries; i3++) {
-      entries[i3].length = readVarint(p);
+    for (let i2 = 0; i2 < numEntries; i2++) {
+      entries[i2].length = readVarint(p);
     }
-    for (let i3 = 0; i3 < numEntries; i3++) {
+    for (let i2 = 0; i2 < numEntries; i2++) {
       const v = readVarint(p);
-      if (v === 0 && i3 > 0) {
-        entries[i3].offset = entries[i3 - 1].offset + entries[i3 - 1].length;
+      if (v === 0 && i2 > 0) {
+        entries[i2].offset = entries[i2 - 1].offset + entries[i2 - 1].length;
       } else {
-        entries[i3].offset = v - 1;
+        entries[i2].offset = v - 1;
       }
     }
     return entries;
@@ -4410,9 +4892,9 @@ var __exports__ = (() => {
       return [header, [dirKey, rootDir.length, rootDir]];
     });
   }
-  function getDirectory(source, decompress, offset, length2, header) {
+  function getDirectory(source, decompress, offset, length, header) {
     return __async(this, null, function* () {
-      const resp = yield source.getBytes(offset, length2, void 0, header.etag);
+      const resp = yield source.getBytes(offset, length, void 0, header.etag);
       const data = yield decompress(resp.data, header.internalCompression);
       const directory = deserializeIndex(data);
       if (directory.length === 0) {
@@ -4452,9 +4934,9 @@ var __exports__ = (() => {
         return res[0];
       });
     }
-    getDirectory(source, offset, length2, header) {
+    getDirectory(source, offset, length, header) {
       return __async(this, null, function* () {
-        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length}`;
         const cacheValue = this.cache.get(cacheKey);
         if (cacheValue) {
           cacheValue.lastUsed = this.counter++;
@@ -4465,7 +4947,7 @@ var __exports__ = (() => {
           source,
           this.decompress,
           offset,
-          length2,
+          length,
           header
         );
         this.cache.set(cacheKey, {
@@ -4477,16 +4959,16 @@ var __exports__ = (() => {
       });
     }
     // for v2 backwards compatibility
-    getArrayBuffer(source, offset, length2, header) {
+    getArrayBuffer(source, offset, length, header) {
       return __async(this, null, function* () {
-        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length}`;
         const cacheValue = this.cache.get(cacheKey);
         if (cacheValue) {
           cacheValue.lastUsed = this.counter++;
           const data = yield cacheValue.data;
           return data;
         }
-        const resp = yield source.getBytes(offset, length2, void 0, header.etag);
+        const resp = yield source.getBytes(offset, length, void 0, header.etag);
         this.cache.set(cacheKey, {
           lastUsed: this.counter++,
           data: resp.data
@@ -4551,9 +5033,9 @@ var __exports__ = (() => {
         return p;
       });
     }
-    getDirectory(source, offset, length2, header) {
+    getDirectory(source, offset, length, header) {
       return __async(this, null, function* () {
-        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length}`;
         const cacheValue = this.cache.get(cacheKey);
         if (cacheValue) {
           cacheValue.lastUsed = this.counter++;
@@ -4561,7 +5043,7 @@ var __exports__ = (() => {
           return data;
         }
         const p = new Promise((resolve, reject) => {
-          getDirectory(source, this.decompress, offset, length2, header).then((directory) => {
+          getDirectory(source, this.decompress, offset, length, header).then((directory) => {
             resolve(directory);
             this.prune();
           }).catch((e) => {
@@ -4573,9 +5055,9 @@ var __exports__ = (() => {
       });
     }
     // for v2 backwards compatibility
-    getArrayBuffer(source, offset, length2, header) {
+    getArrayBuffer(source, offset, length, header) {
       return __async(this, null, function* () {
-        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length}`;
         const cacheValue = this.cache.get(cacheKey);
         if (cacheValue) {
           cacheValue.lastUsed = this.counter++;
@@ -4583,7 +5065,7 @@ var __exports__ = (() => {
           return data;
         }
         const p = new Promise((resolve, reject) => {
-          source.getBytes(offset, length2, void 0, header.etag).then((resp) => {
+          source.getBytes(offset, length, void 0, header.etag).then((resp) => {
             resolve(resp.data);
             if (this.cache.has(cacheKey)) {
             }
@@ -4631,7 +5113,7 @@ var __exports__ = (() => {
     }
   };
   var PMTiles = class {
-    constructor(source, cache, decompress) {
+    constructor(source, cache2, decompress) {
       if (typeof source === "string") {
         this.source = new FetchSource(source);
       } else {
@@ -4642,8 +5124,8 @@ var __exports__ = (() => {
       } else {
         this.decompress = defaultDecompress;
       }
-      if (cache) {
-        this.cache = cache;
+      if (cache2) {
+        this.cache = cache2;
       } else {
         this.cache = new SharedPromiseCache();
       }
@@ -4658,12 +5140,12 @@ var __exports__ = (() => {
       });
     }
     /** @hidden */
-    getZxyAttempt(z, x3, y2, signal) {
+    getZxyAttempt(z, x2, y, signal) {
       return __async(this, null, function* () {
-        const tileId = zxyToTileId(z, x3, y2);
+        const tileId = zxyToTileId(z, x2, y);
         const header = yield this.cache.getHeader(this.source);
         if (header.specVersion < 3) {
-          return v2_default.getZxy(header, this.source, this.cache, z, x3, y2, signal);
+          return v2_default.getZxy(header, this.source, this.cache, z, x2, y, signal);
         }
         if (z < header.minZoom || z > header.maxZoom) {
           return void 0;
@@ -4706,14 +5188,14 @@ var __exports__ = (() => {
      *
      * Returns undefined if the tile does not exist in the archive.
      */
-    getZxy(z, x3, y2, signal) {
+    getZxy(z, x2, y, signal) {
       return __async(this, null, function* () {
         try {
-          return yield this.getZxyAttempt(z, x3, y2, signal);
+          return yield this.getZxyAttempt(z, x2, y, signal);
         } catch (e) {
           if (e instanceof EtagMismatch) {
             this.cache.invalidate(this.source);
-            return yield this.getZxyAttempt(z, x3, y2, signal);
+            return yield this.getZxyAttempt(z, x2, y, signal);
           }
           throw e;
         }
@@ -4829,8 +5311,8 @@ var __exports__ = (() => {
     getKey() {
       return this.blob.url || "";
     }
-    async getBytes(offset, length2, signal) {
-      const slice = this.blob.slice(offset, offset + length2);
+    async getBytes(offset, length, signal) {
+      const slice = this.blob.slice(offset, offset + length);
       const data = await slice.arrayBuffer();
       return {
         data
@@ -4858,6 +5340,9 @@ var __exports__ = (() => {
       this.getTileData = this.getTileData.bind(this);
       this.metadata = this.getMetadata();
     }
+    async getSchema() {
+      return { fields: [], metadata: {} };
+    }
     async getMetadata() {
       const pmtilesHeader = await this.pmtiles.getHeader();
       const pmtilesMetadata = await this.pmtiles.getMetadata();
@@ -4876,8 +5361,8 @@ var __exports__ = (() => {
       return metadata;
     }
     async getTile(tileParams) {
-      const { x: x3, y: y2, zoom: z } = tileParams;
-      const rangeResponse = await this.pmtiles.getZxy(z, x3, y2);
+      const { x: x2, y, z } = tileParams;
+      const rangeResponse = await this.pmtiles.getZxy(z, x2, y);
       const arrayBuffer = rangeResponse?.data;
       if (!arrayBuffer) {
         return null;
@@ -4887,13 +5372,13 @@ var __exports__ = (() => {
     // Tile Source interface implementation: deck.gl compatible API
     // TODO - currently only handles image tiles, not vector tiles
     async getTileData(tileParams) {
-      const { x: x3, y: y2, z } = tileParams.index;
+      const { x: x2, y, z } = tileParams.index;
       const metadata = await this.metadata;
       switch (metadata.tileMIMEType) {
         case "application/vnd.mapbox-vector-tile":
-          return await this.getVectorTile({ x: x3, y: y2, zoom: z, layers: [] });
+          return await this.getVectorTile({ x: x2, y, z, layers: [] });
         default:
-          return await this.getImageTile({ x: x3, y: y2, zoom: z, layers: [] });
+          return await this.getImageTile({ x: x2, y, z, layers: [] });
       }
     }
     // ImageTileSource interface implementation
@@ -4908,7 +5393,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