@loaders.gl/mvt 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/{dist.min.js → dist.dev.js}

@@ -1,969 +1,136 @@
-(() => {
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['loader'] = factory();
+  else root['loader'] = factory();})(globalThis, function () {
+"use strict";
+var __exports__ = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
   var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  var __reExport = (target, module, desc) => {
-    if (module && typeof module === "object" || typeof module === "function") {
-      for (let key of __getOwnPropNames(module))
-        if (!__hasOwnProp.call(target, key) && key !== "default")
-          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
-    return target;
-  };
-  var __toModule = (module) => {
-    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+    return to;
   };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
-  var init_typeof = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
-    }
-  });
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-  var init_toPrimitive = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
-      init_typeof();
-    }
-  });
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-  var init_toPropertyKey = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
-      init_typeof();
-      init_toPrimitive();
-    }
-  });
-
-  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-  var init_defineProperty = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
-      init_toPropertyKey();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js
-  function getPolygonSignedArea(points, options = {}) {
-    const {
-      start = 0,
-      end = points.length
-    } = options;
-    const dim = options.size || 2;
-    let area2 = 0;
-    for (let i2 = start, j = end - dim; i2 < end; i2 += dim) {
-      area2 += (points[i2] - points[j]) * (points[i2 + 1] + points[j + 1]);
-      j = i2;
-    }
-    return area2 / 2;
-  }
-  var init_polygon_utils = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js"() {
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/polygon.js
-  var init_polygon = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/polygon.js"() {
-      init_defineProperty();
-      init_polygon_utils();
+  // ../../node_modules/ieee754/index.js
+  var require_ieee754 = __commonJS({
+    "../../node_modules/ieee754/index.js"(exports) {
+      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+        var e, m;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var nBits = -7;
+        var i2 = isLE ? nBytes - 1 : 0;
+        var d = isLE ? -1 : 1;
+        var s = buffer[offset + i2];
+        i2 += d;
+        e = s & (1 << -nBits) - 1;
+        s >>= -nBits;
+        nBits += eLen;
+        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 + i2], i2 += d, nBits -= 8) {
+        }
+        if (e === 0) {
+          e = 1 - eBias;
+        } else if (e === eMax) {
+          return m ? NaN : (s ? -1 : 1) * Infinity;
+        } else {
+          m = m + Math.pow(2, mLen);
+          e = e - eBias;
+        }
+        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+      };
+      exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+        var e, m, c;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+        var 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);
+        if (isNaN(value) || value === Infinity) {
+          m = isNaN(value) ? 1 : 0;
+          e = eMax;
+        } else {
+          e = Math.floor(Math.log(value) / Math.LN2);
+          if (value * (c = Math.pow(2, -e)) < 1) {
+            e--;
+            c *= 2;
+          }
+          if (e + eBias >= 1) {
+            value += rt / c;
+          } else {
+            value += rt * Math.pow(2, 1 - eBias);
+          }
+          if (value * c >= 2) {
+            e++;
+            c /= 2;
+          }
+          if (e + eBias >= eMax) {
+            m = 0;
+            e = eMax;
+          } else if (e + eBias >= 1) {
+            m = (value * c - 1) * Math.pow(2, mLen);
+            e = e + eBias;
+          } else {
+            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+            e = 0;
+          }
+        }
+        for (; mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) {
+        }
+        e = e << mLen | m;
+        eLen += mLen;
+        for (; eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) {
+        }
+        buffer[offset + i2 - d] |= s * 128;
+      };
     }
   });
 
-  // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
-  function earcut(positions, holeIndices, dim = 2, areas) {
-    const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
-    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
-    const triangles = [];
-    if (!outerNode || outerNode.next === outerNode.prev)
-      return triangles;
-    let invSize;
-    let maxX;
-    let maxY;
-    let minX;
-    let minY;
-    let x2;
-    let y2;
-    if (hasHoles)
-      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
-    if (positions.length > 80 * dim) {
-      minX = maxX = positions[0];
-      minY = maxY = positions[1];
-      for (let i2 = dim; i2 < outerLen; i2 += dim) {
-        x2 = positions[i2];
-        y2 = positions[i2 + 1];
-        if (x2 < minX)
-          minX = x2;
-        if (y2 < minY)
-          minY = y2;
-        if (x2 > maxX)
-          maxX = x2;
-        if (y2 > maxY)
-          maxY = y2;
-      }
-      invSize = Math.max(maxX - minX, maxY - minY);
-      invSize = invSize !== 0 ? 1 / invSize : 0;
-    }
-    earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
-    return triangles;
-  }
-  function linkedList(data, start, end, dim, clockwise, area2) {
-    let i2;
-    let last;
-    if (area2 === void 0) {
-      area2 = getPolygonSignedArea(data, {
-        start,
-        end,
-        size: dim
-      });
-    }
-    if (clockwise === area2 < 0) {
-      for (i2 = start; i2 < end; i2 += dim)
-        last = insertNode(i2, data[i2], data[i2 + 1], last);
-    } else {
-      for (i2 = end - dim; i2 >= start; i2 -= dim)
-        last = insertNode(i2, data[i2], data[i2 + 1], last);
-    }
-    if (last && equals(last, last.next)) {
-      removeNode(last);
-      last = last.next;
-    }
-    return last;
-  }
-  function filterPoints(start, end) {
-    if (!start)
-      return start;
-    if (!end)
-      end = start;
-    let p = start;
-    let again;
-    do {
-      again = false;
-      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-        removeNode(p);
-        p = end = p.prev;
-        if (p === p.next)
-          break;
-        again = true;
-      } else {
-        p = p.next;
-      }
-    } while (again || p !== end);
-    return end;
-  }
-  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
-    if (!ear)
-      return;
-    if (!pass && invSize)
-      indexCurve(ear, minX, minY, invSize);
-    let stop = ear;
-    let prev;
-    let next;
-    while (ear.prev !== ear.next) {
-      prev = ear.prev;
-      next = ear.next;
-      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-        triangles.push(prev.i / dim);
-        triangles.push(ear.i / dim);
-        triangles.push(next.i / dim);
-        removeNode(ear);
-        ear = next.next;
-        stop = next.next;
-        continue;
-      }
-      ear = next;
-      if (ear === stop) {
-        if (!pass) {
-          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
-        } else if (pass === 1) {
-          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
-          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
-        } else if (pass === 2) {
-          splitEarcut(ear, triangles, dim, minX, minY, invSize);
-        }
-        break;
-      }
-    }
-  }
-  function isEar(ear) {
-    const a = ear.prev;
-    const b = ear;
-    const c = ear.next;
-    if (area(a, b, c) >= 0)
-      return false;
-    let p = ear.next.next;
-    while (p !== ear.prev) {
-      if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
-        return false;
-      p = p.next;
-    }
-    return true;
-  }
-  function isEarHashed(ear, minX, minY, invSize) {
-    const a = ear.prev;
-    const b = ear;
-    const c = ear.next;
-    if (area(a, b, c) >= 0)
-      return false;
-    const minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x;
-    const minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y;
-    const maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x;
-    const maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;
-    const minZ = zOrder(minTX, minTY, minX, minY, invSize);
-    const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
-    let p = ear.prevZ;
-    let n = ear.nextZ;
-    while (p && p.z >= minZ && n && n.z <= maxZ) {
-      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
-        return false;
-      p = p.prevZ;
-      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
-        return false;
-      n = n.nextZ;
-    }
-    while (p && p.z >= minZ) {
-      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
-        return false;
-      p = p.prevZ;
-    }
-    while (n && n.z <= maxZ) {
-      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
-        return false;
-      n = n.nextZ;
-    }
-    return true;
-  }
-  function cureLocalIntersections(start, triangles, dim) {
-    let p = start;
-    do {
-      const a = p.prev;
-      const b = p.next.next;
-      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-        triangles.push(a.i / dim);
-        triangles.push(p.i / dim);
-        triangles.push(b.i / dim);
-        removeNode(p);
-        removeNode(p.next);
-        p = start = b;
-      }
-      p = p.next;
-    } while (p !== start);
-    return filterPoints(p);
-  }
-  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
-    let a = start;
-    do {
-      let b = a.next.next;
-      while (b !== a.prev) {
-        if (a.i !== b.i && isValidDiagonal(a, b)) {
-          let c = splitPolygon(a, b);
-          a = filterPoints(a, a.next);
-          c = filterPoints(c, c.next);
-          earcutLinked(a, triangles, dim, minX, minY, invSize);
-          earcutLinked(c, triangles, dim, minX, minY, invSize);
-          return;
-        }
-        b = b.next;
-      }
-      a = a.next;
-    } while (a !== start);
-  }
-  function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
-    const queue = [];
-    let i2;
-    let len;
-    let start;
-    let end;
-    let list;
-    for (i2 = 0, len = holeIndices.length; i2 < len; i2++) {
-      start = holeIndices[i2] * dim;
-      end = i2 < len - 1 ? holeIndices[i2 + 1] * dim : data.length;
-      list = linkedList(data, start, end, dim, false, areas && areas[i2 + 1]);
-      if (list === list.next)
-        list.steiner = true;
-      queue.push(getLeftmost(list));
-    }
-    queue.sort(compareX);
-    for (i2 = 0; i2 < queue.length; i2++) {
-      eliminateHole(queue[i2], outerNode);
-      outerNode = filterPoints(outerNode, outerNode.next);
-    }
-    return outerNode;
-  }
-  function compareX(a, b) {
-    return a.x - b.x;
-  }
-  function eliminateHole(hole, outerNode) {
-    outerNode = findHoleBridge(hole, outerNode);
-    if (outerNode) {
-      const b = splitPolygon(outerNode, hole);
-      filterPoints(outerNode, outerNode.next);
-      filterPoints(b, b.next);
-    }
-  }
-  function findHoleBridge(hole, outerNode) {
-    let p = outerNode;
-    const hx = hole.x;
-    const hy = hole.y;
-    let qx = -Infinity;
-    let m;
-    do {
-      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-        const x2 = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-        if (x2 <= hx && x2 > qx) {
-          qx = x2;
-          if (x2 === hx) {
-            if (hy === p.y)
-              return p;
-            if (hy === p.next.y)
-              return p.next;
-          }
-          m = p.x < p.next.x ? p : p.next;
-        }
-      }
-      p = p.next;
-    } while (p !== outerNode);
-    if (!m)
-      return null;
-    if (hx === qx)
-      return m;
-    const stop = m;
-    const mx = m.x;
-    const my = m.y;
-    let tanMin = Infinity;
-    let tan;
-    p = m;
-    do {
-      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
-        tan = Math.abs(hy - p.y) / (hx - p.x);
-        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
-          m = p;
-          tanMin = tan;
-        }
-      }
-      p = p.next;
-    } while (p !== stop);
-    return m;
-  }
-  function sectorContainsSector(m, p) {
-    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
-  }
-  function indexCurve(start, minX, minY, invSize) {
-    let p = start;
-    do {
-      if (p.z === null)
-        p.z = zOrder(p.x, p.y, minX, minY, invSize);
-      p.prevZ = p.prev;
-      p.nextZ = p.next;
-      p = p.next;
-    } while (p !== start);
-    p.prevZ.nextZ = null;
-    p.prevZ = null;
-    sortLinked(p);
-  }
-  function sortLinked(list) {
-    let e;
-    let i2;
-    let inSize = 1;
-    let numMerges;
-    let p;
-    let pSize;
-    let q;
-    let qSize;
-    let tail;
-    do {
-      p = list;
-      list = null;
-      tail = null;
-      numMerges = 0;
-      while (p) {
-        numMerges++;
-        q = p;
-        pSize = 0;
-        for (i2 = 0; i2 < inSize; i2++) {
-          pSize++;
-          q = q.nextZ;
-          if (!q)
-            break;
-        }
-        qSize = inSize;
-        while (pSize > 0 || qSize > 0 && q) {
-          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
-            e = p;
-            p = p.nextZ;
-            pSize--;
-          } else {
-            e = q;
-            q = q.nextZ;
-            qSize--;
-          }
-          if (tail)
-            tail.nextZ = e;
-          else
-            list = e;
-          e.prevZ = tail;
-          tail = e;
-        }
-        p = q;
-      }
-      tail.nextZ = null;
-      inSize *= 2;
-    } while (numMerges > 1);
-    return list;
-  }
-  function zOrder(x2, y2, minX, minY, invSize) {
-    x2 = 32767 * (x2 - minX) * invSize;
-    y2 = 32767 * (y2 - minY) * invSize;
-    x2 = (x2 | x2 << 8) & 16711935;
-    x2 = (x2 | x2 << 4) & 252645135;
-    x2 = (x2 | x2 << 2) & 858993459;
-    x2 = (x2 | x2 << 1) & 1431655765;
-    y2 = (y2 | y2 << 8) & 16711935;
-    y2 = (y2 | y2 << 4) & 252645135;
-    y2 = (y2 | y2 << 2) & 858993459;
-    y2 = (y2 | y2 << 1) & 1431655765;
-    return x2 | y2 << 1;
-  }
-  function getLeftmost(start) {
-    let p = start;
-    let leftmost = start;
-    do {
-      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
-        leftmost = p;
-      p = p.next;
-    } while (p !== start);
-    return leftmost;
-  }
-  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
-    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
-  }
-  function isValidDiagonal(a, b) {
-    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
-  }
-  function area(p, q, r) {
-    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-  }
-  function equals(p1, p2) {
-    return p1.x === p2.x && p1.y === p2.y;
-  }
-  function intersects(p1, q1, p2, q2) {
-    const o1 = sign(area(p1, q1, p2));
-    const o2 = sign(area(p1, q1, q2));
-    const o3 = sign(area(p2, q2, p1));
-    const o4 = sign(area(p2, q2, q1));
-    if (o1 !== o2 && o3 !== o4)
-      return true;
-    if (o1 === 0 && onSegment(p1, p2, q1))
-      return true;
-    if (o2 === 0 && onSegment(p1, q2, q1))
-      return true;
-    if (o3 === 0 && onSegment(p2, p1, q2))
-      return true;
-    if (o4 === 0 && onSegment(p2, q1, q2))
-      return true;
-    return false;
-  }
-  function onSegment(p, q, r) {
-    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
-  }
-  function sign(num) {
-    return num > 0 ? 1 : num < 0 ? -1 : 0;
-  }
-  function intersectsPolygon(a, b) {
-    let p = a;
-    do {
-      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
-        return true;
-      p = p.next;
-    } while (p !== a);
-    return false;
-  }
-  function locallyInside(a, b) {
-    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
-  }
-  function middleInside(a, b) {
-    let p = a;
-    let inside = false;
-    const px = (a.x + b.x) / 2;
-    const py = (a.y + b.y) / 2;
-    do {
-      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
-        inside = !inside;
-      p = p.next;
-    } while (p !== a);
-    return inside;
-  }
-  function splitPolygon(a, b) {
-    const a2 = new Node(a.i, a.x, a.y);
-    const b2 = new Node(b.i, b.x, b.y);
-    const an = a.next;
-    const bp = b.prev;
-    a.next = b;
-    b.prev = a;
-    a2.next = an;
-    an.prev = a2;
-    b2.next = a2;
-    a2.prev = b2;
-    bp.next = b2;
-    b2.prev = bp;
-    return b2;
-  }
-  function insertNode(i2, x2, y2, last) {
-    const p = new Node(i2, x2, y2);
-    if (!last) {
-      p.prev = p;
-      p.next = p;
-    } else {
-      p.next = last.next;
-      p.prev = last;
-      last.next.prev = p;
-      last.next = p;
-    }
-    return p;
-  }
-  function removeNode(p) {
-    p.next.prev = p.prev;
-    p.prev.next = p.next;
-    if (p.prevZ)
-      p.prevZ.nextZ = p.nextZ;
-    if (p.nextZ)
-      p.nextZ.prevZ = p.prevZ;
-  }
-  function Node(i2, x2, y2) {
-    this.i = i2;
-    this.x = x2;
-    this.y = y2;
-    this.prev = null;
-    this.next = null;
-    this.z = null;
-    this.prevZ = null;
-    this.nextZ = null;
-    this.steiner = false;
-  }
-  var init_earcut = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/earcut.js"() {
-      init_polygon_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/utils.js
-  var init_utils = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/utils.js"() {
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/lineclip.js
-  var init_lineclip = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/lineclip.js"() {
-      init_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js
-  var init_cut_by_grid = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js"() {
-      init_lineclip();
-      init_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js
-  var init_cut_by_mercator_bounds = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js"() {
-      init_cut_by_grid();
-      init_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/index.js
-  var init_esm = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/index.js"() {
-      init_polygon();
-      init_polygon_utils();
-      init_earcut();
-      init_lineclip();
-      init_cut_by_grid();
-      init_cut_by_mercator_bounds();
-      init_polygon();
-    }
-  });
-
-  // ../gis/src/lib/flat-geojson-to-binary.ts
-  function flatGeojsonToBinary(features, geometryInfo, options) {
-    const propArrayTypes = extractNumericPropTypes(features);
-    const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
-    return fillArrays(features, {
-      propArrayTypes,
-      ...geometryInfo
-    }, {
-      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
-      PositionDataType: options ? options.PositionDataType : Float32Array,
-      triangulate: options ? options.triangulate : true
-    });
-  }
-  function extractNumericPropTypes(features) {
-    const propArrayTypes = {};
-    for (const feature of features) {
-      if (feature.properties) {
-        for (const key in feature.properties) {
-          const val = feature.properties[key];
-          propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
-        }
-      }
-    }
-    return propArrayTypes;
-  }
-  function fillArrays(features, geometryInfo, options) {
-    const {
-      pointPositionsCount,
-      pointFeaturesCount,
-      linePositionsCount,
-      linePathsCount,
-      lineFeaturesCount,
-      polygonPositionsCount,
-      polygonObjectsCount,
-      polygonRingsCount,
-      polygonFeaturesCount,
-      propArrayTypes,
-      coordLength
-    } = geometryInfo;
-    const { numericPropKeys = [], PositionDataType = Float32Array, triangulate = true } = options;
-    const hasGlobalId = features[0] && "id" in features[0];
-    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-    const points = {
-      type: "Point",
-      positions: new PositionDataType(pointPositionsCount * coordLength),
-      globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-      featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
-      numericProps: {},
-      properties: [],
-      fields: []
-    };
-    const lines = {
-      type: "LineString",
-      pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
-      positions: new PositionDataType(linePositionsCount * coordLength),
-      globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
-      featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
-      numericProps: {},
-      properties: [],
-      fields: []
-    };
-    const polygons = {
-      type: "Polygon",
-      polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
-      primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
-      positions: new PositionDataType(polygonPositionsCount * coordLength),
-      globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-      featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
-      numericProps: {},
-      properties: [],
-      fields: []
-    };
-    if (triangulate) {
-      polygons.triangles = [];
-    }
-    for (const object of [points, lines, polygons]) {
-      for (const propName of numericPropKeys) {
-        const T = propArrayTypes[propName];
-        object.numericProps[propName] = new T(object.positions.length / coordLength);
-      }
-    }
-    lines.pathIndices[linePathsCount] = linePositionsCount;
-    polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
-    polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
-    const indexMap = {
-      pointPosition: 0,
-      pointFeature: 0,
-      linePosition: 0,
-      linePath: 0,
-      lineFeature: 0,
-      polygonPosition: 0,
-      polygonObject: 0,
-      polygonRing: 0,
-      polygonFeature: 0,
-      feature: 0
-    };
-    for (const feature of features) {
-      const geometry = feature.geometry;
-      const properties = feature.properties || {};
-      switch (geometry.type) {
-        case "Point":
-          handlePoint(geometry, points, indexMap, coordLength, properties);
-          points.properties.push(keepStringProperties(properties, numericPropKeys));
-          if (hasGlobalId) {
-            points.fields.push({ id: feature.id });
-          }
-          indexMap.pointFeature++;
-          break;
-        case "LineString":
-          handleLineString(geometry, lines, indexMap, coordLength, properties);
-          lines.properties.push(keepStringProperties(properties, numericPropKeys));
-          if (hasGlobalId) {
-            lines.fields.push({ id: feature.id });
-          }
-          indexMap.lineFeature++;
-          break;
-        case "Polygon":
-          handlePolygon(geometry, polygons, indexMap, coordLength, properties);
-          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-          if (hasGlobalId) {
-            polygons.fields.push({ id: feature.id });
-          }
-          indexMap.polygonFeature++;
-          break;
-        default:
-          throw new Error("Invalid geometry type");
-      }
-      indexMap.feature++;
-    }
-    return makeAccessorObjects(points, lines, polygons, coordLength);
-  }
-  function handlePoint(geometry, points, indexMap, coordLength, properties) {
-    points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
-    const nPositions = geometry.data.length / coordLength;
-    fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
-    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-    indexMap.pointPosition += nPositions;
-  }
-  function handleLineString(geometry, lines, indexMap, coordLength, properties) {
-    lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
-    const nPositions = geometry.data.length / coordLength;
-    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
-    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
-    for (let i2 = 0, il = geometry.indices.length; i2 < il; ++i2) {
-      const start = geometry.indices[i2];
-      const end = i2 === il - 1 ? geometry.data.length : geometry.indices[i2 + 1];
-      lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
-      indexMap.linePosition += (end - start) / coordLength;
-    }
-  }
-  function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
-    polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
-    const nPositions = geometry.data.length / coordLength;
-    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-    for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
-      const startPosition = indexMap.polygonPosition;
-      polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
-      const areas = geometry.areas[l];
-      const indices = geometry.indices[l];
-      const nextIndices = geometry.indices[l + 1];
-      for (let i2 = 0, il = indices.length; i2 < il; ++i2) {
-        const start = indices[i2];
-        const end = i2 === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i2 + 1];
-        polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
-        indexMap.polygonPosition += (end - start) / coordLength;
-      }
-      const endPosition = indexMap.polygonPosition;
-      triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
-    }
-  }
-  function triangulatePolygon(polygons, areas, indices, {
-    startPosition,
-    endPosition,
-    coordLength
-  }) {
-    if (!polygons.triangles) {
-      return;
-    }
-    const start = startPosition * coordLength;
-    const end = endPosition * coordLength;
-    const polygonPositions = polygons.positions.subarray(start, end);
-    const offset = indices[0];
-    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
-    const triangles = earcut(polygonPositions, holes, coordLength, areas);
-    for (let t = 0, tl = triangles.length; t < tl; ++t) {
-      polygons.triangles.push(startPosition + triangles[t]);
-    }
-  }
-  function wrapProps(obj, size) {
-    const returnObj = {};
-    for (const key in obj) {
-      returnObj[key] = { value: obj[key], size };
-    }
-    return returnObj;
-  }
-  function makeAccessorObjects(points, lines, polygons, coordLength) {
-    const binaryFeatures = {
-      points: {
-        ...points,
-        positions: { value: points.positions, size: coordLength },
-        globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-        featureIds: { value: points.featureIds, size: 1 },
-        numericProps: wrapProps(points.numericProps, 1)
-      },
-      lines: {
-        ...lines,
-        positions: { value: lines.positions, size: coordLength },
-        pathIndices: { value: lines.pathIndices, size: 1 },
-        globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-        featureIds: { value: lines.featureIds, size: 1 },
-        numericProps: wrapProps(lines.numericProps, 1)
-      },
-      polygons: {
-        ...polygons,
-        positions: { value: polygons.positions, size: coordLength },
-        polygonIndices: { value: polygons.polygonIndices, size: 1 },
-        primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
-        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-        featureIds: { value: polygons.featureIds, size: 1 },
-        numericProps: wrapProps(polygons.numericProps, 1)
-      }
-    };
-    if (binaryFeatures.polygons && polygons.triangles) {
-      binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
-    }
-    return binaryFeatures;
-  }
-  function fillNumericProperties(object, properties, index, length2) {
-    for (const numericPropName in object.numericProps) {
-      if (numericPropName in properties) {
-        const value = properties[numericPropName];
-        object.numericProps[numericPropName].fill(value, index, index + length2);
-      }
-    }
-  }
-  function keepStringProperties(properties, numericKeys) {
-    const props = {};
-    for (const key in properties) {
-      if (!numericKeys.includes(key)) {
-        props[key] = properties[key];
-      }
-    }
-    return props;
-  }
-  function deduceArrayType(x2, constructor) {
-    if (constructor === Array || !Number.isFinite(x2)) {
-      return Array;
-    }
-    return constructor === Float64Array || Math.fround(x2) !== x2 ? Float64Array : Float32Array;
-  }
-  var init_flat_geojson_to_binary = __esm({
-    "../gis/src/lib/flat-geojson-to-binary.ts"() {
-      init_esm();
-    }
-  });
-
-  // ../gis/src/index.ts
-  var init_src = __esm({
-    "../gis/src/index.ts"() {
-      init_flat_geojson_to_binary();
-    }
-  });
-
-  // ../../node_modules/ieee754/index.js
-  var require_ieee754 = __commonJS({
-    "../../node_modules/ieee754/index.js"(exports) {
-      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
-        var e, m;
-        var eLen = nBytes * 8 - mLen - 1;
-        var eMax = (1 << eLen) - 1;
-        var eBias = eMax >> 1;
-        var nBits = -7;
-        var i2 = isLE ? nBytes - 1 : 0;
-        var d = isLE ? -1 : 1;
-        var s = buffer[offset + i2];
-        i2 += d;
-        e = s & (1 << -nBits) - 1;
-        s >>= -nBits;
-        nBits += eLen;
-        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 + i2], i2 += d, nBits -= 8) {
-        }
-        if (e === 0) {
-          e = 1 - eBias;
-        } else if (e === eMax) {
-          return m ? NaN : (s ? -1 : 1) * Infinity;
-        } else {
-          m = m + Math.pow(2, mLen);
-          e = e - eBias;
-        }
-        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
-      };
-      exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
-        var e, m, c;
-        var eLen = nBytes * 8 - mLen - 1;
-        var eMax = (1 << eLen) - 1;
-        var eBias = eMax >> 1;
-        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-        var 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);
-        if (isNaN(value) || value === Infinity) {
-          m = isNaN(value) ? 1 : 0;
-          e = eMax;
-        } else {
-          e = Math.floor(Math.log(value) / Math.LN2);
-          if (value * (c = Math.pow(2, -e)) < 1) {
-            e--;
-            c *= 2;
-          }
-          if (e + eBias >= 1) {
-            value += rt / c;
-          } else {
-            value += rt * Math.pow(2, 1 - eBias);
-          }
-          if (value * c >= 2) {
-            e++;
-            c /= 2;
-          }
-          if (e + eBias >= eMax) {
-            m = 0;
-            e = eMax;
-          } else if (e + eBias >= 1) {
-            m = (value * c - 1) * Math.pow(2, mLen);
-            e = e + eBias;
-          } else {
-            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
-            e = 0;
-          }
-        }
-        for (; mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) {
-        }
-        e = e << mLen | m;
-        eLen += mLen;
-        for (; eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) {
-        }
-        buffer[offset + i2 - d] |= s * 128;
-      };
-    }
-  });
-
-  // ../../node_modules/pbf/index.js
-  var require_pbf = __commonJS({
-    "../../node_modules/pbf/index.js"(exports, module) {
-      "use strict";
-      module.exports = Pbf;
-      var ieee754 = require_ieee754();
-      function Pbf(buf) {
-        this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
-        this.pos = 0;
-        this.type = 0;
-        this.length = this.buf.length;
+  // ../../node_modules/pbf/index.js
+  var require_pbf = __commonJS({
+    "../../node_modules/pbf/index.js"(exports, module) {
+      "use strict";
+      module.exports = Pbf;
+      var ieee754 = require_ieee754();
+      function Pbf(buf) {
+        this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
+        this.pos = 0;
+        this.type = 0;
+        this.length = this.buf.length;
       }
       Pbf.Varint = 0;
       Pbf.Fixed64 = 1;
@@ -977,6 +144,7 @@
         destroy: function() {
           this.buf = null;
         },
+        // === READING =================================================================
         readFields: function(readField, result, end) {
           end = end || this.length;
           while (this.pos < end) {
@@ -1001,6 +169,7 @@
           this.pos += 4;
           return val;
         },
+        // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)
         readFixed64: function() {
           var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
           this.pos += 8;
@@ -1067,6 +236,7 @@
           this.pos = end;
           return buffer;
         },
+        // verbose for performance reasons; doesn't affect gzipped size
         readPackedVarint: function(arr, isSigned) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readVarint(isSigned));
@@ -1162,6 +332,7 @@
           else
             throw new Error("Unimplemented type: " + type);
         },
+        // === WRITING =================================================================
         writeTag: function(tag, type) {
           this.writeVarint(tag << 3 | type);
         },
@@ -1479,132 +650,1019 @@
         for (var i2 = 0; i2 < arr.length; i2++)
           pbf.writeFixed64(arr[i2]);
       }
-      function writePackedSFixed64(arr, pbf) {
-        for (var i2 = 0; i2 < arr.length; i2++)
-          pbf.writeSFixed64(arr[i2]);
+      function writePackedSFixed64(arr, pbf) {
+        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;
+      }
+      function writeInt32(buf, val, pos) {
+        buf[pos] = val;
+        buf[pos + 1] = val >>> 8;
+        buf[pos + 2] = val >>> 16;
+        buf[pos + 3] = val >>> 24;
+      }
+      function readInt32(buf, pos) {
+        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + (buf[pos + 3] << 24);
+      }
+      function readUtf8(buf, pos, end) {
+        var str = "";
+        var 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 (i2 + bytesPerSequence > end)
+            break;
+          var b1, b2, b3;
+          if (bytesPerSequence === 1) {
+            if (b0 < 128) {
+              c = b0;
+            }
+          } else if (bytesPerSequence === 2) {
+            b1 = buf[i2 + 1];
+            if ((b1 & 192) === 128) {
+              c = (b0 & 31) << 6 | b1 & 63;
+              if (c <= 127) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 3) {
+            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) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 4) {
+            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) {
+                c = null;
+              }
+            }
+          }
+          if (c === null) {
+            c = 65533;
+            bytesPerSequence = 1;
+          } else if (c > 65535) {
+            c -= 65536;
+            str += String.fromCharCode(c >>> 10 & 1023 | 55296);
+            c = 56320 | c & 1023;
+          }
+          str += String.fromCharCode(c);
+          i2 += bytesPerSequence;
+        }
+        return str;
+      }
+      function readUtf8TextDecoder(buf, pos, end) {
+        return utf8TextDecoder.decode(buf.subarray(pos, end));
+      }
+      function writeUtf8(buf, str, pos) {
+        for (var i2 = 0, c, lead; i2 < str.length; i2++) {
+          c = str.charCodeAt(i2);
+          if (c > 55295 && c < 57344) {
+            if (lead) {
+              if (c < 56320) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+                lead = c;
+                continue;
+              } else {
+                c = lead - 55296 << 10 | c - 56320 | 65536;
+                lead = null;
+              }
+            } else {
+              if (c > 56319 || i2 + 1 === str.length) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+              } else {
+                lead = c;
+              }
+              continue;
+            }
+          } else if (lead) {
+            buf[pos++] = 239;
+            buf[pos++] = 191;
+            buf[pos++] = 189;
+            lead = null;
+          }
+          if (c < 128) {
+            buf[pos++] = c;
+          } else {
+            if (c < 2048) {
+              buf[pos++] = c >> 6 | 192;
+            } else {
+              if (c < 65536) {
+                buf[pos++] = c >> 12 | 224;
+              } else {
+                buf[pos++] = c >> 18 | 240;
+                buf[pos++] = c >> 12 & 63 | 128;
+              }
+              buf[pos++] = c >> 6 & 63 | 128;
+            }
+            buf[pos++] = c & 63 | 128;
+          }
+        }
+        return pos;
+      }
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    GeoJSONTiler: () => GeoJSONTiler,
+    MVTLoader: () => MVTLoader,
+    MVTSource: () => MVTSource,
+    MVTWorkerLoader: () => MVTWorkerLoader,
+    TileJSONLoader: () => TileJSONLoader
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+
+  // ../../node_modules/@math.gl/polygon/dist/polygon-utils.js
+  var DimIndex = {
+    x: 0,
+    y: 1,
+    z: 2
+  };
+  function getPolygonSignedArea(points, options = {}) {
+    const {
+      start = 0,
+      end = points.length,
+      plane = "xy"
+    } = options;
+    const dim = options.size || 2;
+    let area2 = 0;
+    const i0 = DimIndex[plane[0]];
+    const i1 = DimIndex[plane[1]];
+    for (let i2 = start, j = end - dim; i2 < end; i2 += dim) {
+      area2 += (points[i2 + i0] - points[j + i0]) * (points[i2 + i1] + points[j + i1]);
+      j = i2;
+    }
+    return area2 / 2;
+  }
+
+  // ../../node_modules/@math.gl/polygon/dist/earcut.js
+  function earcut(positions, holeIndices, dim = 2, areas, plane = "xy") {
+    const hasHoles = holeIndices && holeIndices.length;
+    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
+    const triangles = [];
+    if (!outerNode || outerNode.next === outerNode.prev)
+      return triangles;
+    let invSize;
+    let maxX;
+    let maxY;
+    let minX;
+    let minY;
+    let x2;
+    let y2;
+    if (hasHoles)
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
+    if (positions.length > 80 * dim) {
+      minX = maxX = positions[0];
+      minY = maxY = positions[1];
+      for (let i2 = dim; i2 < outerLen; i2 += dim) {
+        x2 = positions[i2];
+        y2 = positions[i2 + 1];
+        if (x2 < minX)
+          minX = x2;
+        if (y2 < minY)
+          minY = y2;
+        if (x2 > maxX)
+          maxX = x2;
+        if (y2 > maxY)
+          maxY = y2;
+      }
+      invSize = Math.max(maxX - minX, maxY - minY);
+      invSize = invSize !== 0 ? 32767 / invSize : 0;
+    }
+    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+    return triangles;
+  }
+  function linkedList(data, start, end, dim, clockwise, area2, plane) {
+    let i2;
+    let last;
+    if (area2 === void 0) {
+      area2 = getPolygonSignedArea(data, {
+        start,
+        end,
+        size: dim,
+        plane
+      });
+    }
+    let i0 = DimIndex[plane[0]];
+    let i1 = DimIndex[plane[1]];
+    if (clockwise === area2 < 0) {
+      for (i2 = start; i2 < end; i2 += dim)
+        last = insertNode(i2, data[i2 + i0], data[i2 + i1], last);
+    } else {
+      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);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start)
+      return start;
+    if (!end)
+      end = start;
+    let p = start;
+    let again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next)
+          break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear)
+      return;
+    if (!pass && invSize)
+      indexCurve(ear, minX, minY, invSize);
+    let stop = ear;
+    let prev;
+    let next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    const ax = a.x;
+    const bx = b.x;
+    const cx = c.x;
+    const ay = a.y;
+    const by = b.y;
+    const cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
+    const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
+    const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
+    const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    const ax = a.x;
+    const bx = b.x;
+    const cx = c.x;
+    const ay = a.y;
+    const by = b.y;
+    const cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
+    const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
+    const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
+    const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize);
+    const maxZ = zOrder(x1, y1, minX, minY, invSize);
+    let p = ear.prevZ;
+    let n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev;
+      const b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
       }
-      function readUInt32(buf, pos) {
-        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + buf[pos + 3] * 16777216;
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+          return;
+        }
+        b = b.next;
       }
-      function writeInt32(buf, val, pos) {
-        buf[pos] = val;
-        buf[pos + 1] = val >>> 8;
-        buf[pos + 2] = val >>> 16;
-        buf[pos + 3] = val >>> 24;
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim, areas, plane) {
+    const queue = [];
+    let i2;
+    let len;
+    let start;
+    let end;
+    let list;
+    for (i2 = 0, len = holeIndices.length; i2 < len; i2++) {
+      start = holeIndices[i2] * dim;
+      end = i2 < len - 1 ? holeIndices[i2 + 1] * dim : data.length;
+      list = linkedList(data, start, end, dim, false, areas && areas[i2 + 1], plane);
+      if (list === list.next)
+        list.steiner = true;
+      queue.push(getLeftmost(list));
+    }
+    queue.sort(compareX);
+    for (i2 = 0; i2 < queue.length; i2++) {
+      outerNode = eliminateHole(queue[i2], outerNode);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+      return outerNode;
+    }
+    const bridgeReverse = splitPolygon(bridge, hole);
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode;
+    const hx = hole.x;
+    const hy = hole.y;
+    let qx = -Infinity;
+    let m;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x2 = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x2 <= hx && x2 > qx) {
+          qx = x2;
+          m = p.x < p.next.x ? p : p.next;
+          if (x2 === hx)
+            return m;
+        }
       }
-      function readInt32(buf, pos) {
-        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + (buf[pos + 3] << 24);
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m)
+      return null;
+    const stop = m;
+    const mx = m.x;
+    const my = m.y;
+    let tanMin = Infinity;
+    let tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
       }
-      function readUtf8(buf, pos, end) {
-        var str = "";
-        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 (i2 + bytesPerSequence > end)
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === 0)
+        p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list) {
+    let e;
+    let i2;
+    let inSize = 1;
+    let numMerges;
+    let p;
+    let pSize;
+    let q;
+    let qSize;
+    let tail;
+    do {
+      p = list;
+      list = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i2 = 0; i2 < inSize; i2++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q)
             break;
-          var b1, b2, b3;
-          if (bytesPerSequence === 1) {
-            if (b0 < 128) {
-              c = b0;
-            }
-          } else if (bytesPerSequence === 2) {
-            b1 = buf[i2 + 1];
-            if ((b1 & 192) === 128) {
-              c = (b0 & 31) << 6 | b1 & 63;
-              if (c <= 127) {
-                c = null;
-              }
-            }
-          } else if (bytesPerSequence === 3) {
-            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) {
-                c = null;
-              }
-            }
-          } else if (bytesPerSequence === 4) {
-            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) {
-                c = null;
-              }
-            }
-          }
-          if (c === null) {
-            c = 65533;
-            bytesPerSequence = 1;
-          } else if (c > 65535) {
-            c -= 65536;
-            str += String.fromCharCode(c >>> 10 & 1023 | 55296);
-            c = 56320 | c & 1023;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
           }
-          str += String.fromCharCode(c);
-          i2 += bytesPerSequence;
+          if (tail)
+            tail.nextZ = e;
+          else
+            list = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list;
+  }
+  function zOrder(x2, y2, minX, minY, invSize) {
+    x2 = (x2 - minX) * invSize | 0;
+    y2 = (y2 - minY) * invSize | 0;
+    x2 = (x2 | x2 << 8) & 16711935;
+    x2 = (x2 | x2 << 4) & 252645135;
+    x2 = (x2 | x2 << 2) & 858993459;
+    x2 = (x2 | x2 << 1) & 1431655765;
+    y2 = (y2 | y2 << 8) & 16711935;
+    y2 = (y2 | y2 << 4) & 252645135;
+    y2 = (y2 | y2 << 2) & 858993459;
+    y2 = (y2 | y2 << 1) & 1431655765;
+    return x2 | y2 << 1;
+  }
+  function getLeftmost(start) {
+    let p = start;
+    let leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+        leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4)
+      return true;
+    if (o1 === 0 && onSegment(p1, p2, q1))
+      return true;
+    if (o2 === 0 && onSegment(p1, q2, q1))
+      return true;
+    if (o3 === 0 && onSegment(p2, p1, q2))
+      return true;
+    if (o4 === 0 && onSegment(p2, q1, q2))
+      return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num) {
+    return num > 0 ? 1 : num < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+        return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a;
+    let inside = false;
+    const px = (a.x + b.x) / 2;
+    const py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Vertex(a.i, a.x, a.y);
+    const b2 = new Vertex(b.i, b.x, b.y);
+    const an = a.next;
+    const bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i2, x2, y2, last) {
+    const p = new Vertex(i2, x2, y2);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ)
+      p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ)
+      p.nextZ.prevZ = p.prevZ;
+  }
+  var Vertex = class {
+    constructor(i2, x2, y2) {
+      _defineProperty(this, "i", void 0);
+      _defineProperty(this, "x", void 0);
+      _defineProperty(this, "y", void 0);
+      _defineProperty(this, "prev", null);
+      _defineProperty(this, "next", null);
+      _defineProperty(this, "z", 0);
+      _defineProperty(this, "prevZ", null);
+      _defineProperty(this, "nextZ", null);
+      _defineProperty(this, "steiner", false);
+      this.i = i2;
+      this.x = x2;
+      this.y = y2;
+    }
+  };
+
+  // ../gis/src/lib/flat-geojson-to-binary.ts
+  function flatGeojsonToBinary(features, geometryInfo, options) {
+    const propArrayTypes = extractNumericPropTypes(features);
+    const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
+    return fillArrays(features, {
+      propArrayTypes,
+      ...geometryInfo
+    }, {
+      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
+      PositionDataType: options ? options.PositionDataType : Float32Array,
+      triangulate: options ? options.triangulate : true
+    });
+  }
+  function extractNumericPropTypes(features) {
+    const propArrayTypes = {};
+    for (const feature of features) {
+      if (feature.properties) {
+        for (const key in feature.properties) {
+          const val = feature.properties[key];
+          propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
         }
-        return str;
       }
-      function readUtf8TextDecoder(buf, pos, end) {
-        return utf8TextDecoder.decode(buf.subarray(pos, end));
+    }
+    return propArrayTypes;
+  }
+  function fillArrays(features, geometryInfo, options) {
+    const {
+      pointPositionsCount,
+      pointFeaturesCount,
+      linePositionsCount,
+      linePathsCount,
+      lineFeaturesCount,
+      polygonPositionsCount,
+      polygonObjectsCount,
+      polygonRingsCount,
+      polygonFeaturesCount,
+      propArrayTypes,
+      coordLength
+    } = geometryInfo;
+    const {
+      numericPropKeys = [],
+      PositionDataType = Float32Array,
+      triangulate = true
+    } = options;
+    const hasGlobalId = features[0] && "id" in features[0];
+    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+    const points = {
+      type: "Point",
+      positions: new PositionDataType(pointPositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
+      featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    const lines = {
+      type: "LineString",
+      pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
+      positions: new PositionDataType(linePositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
+      featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    const polygons = {
+      type: "Polygon",
+      polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
+      primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
+      positions: new PositionDataType(polygonPositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+      featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    if (triangulate) {
+      polygons.triangles = [];
+    }
+    for (const object of [points, lines, polygons]) {
+      for (const propName of numericPropKeys) {
+        const T = propArrayTypes[propName];
+        object.numericProps[propName] = new T(object.positions.length / coordLength);
       }
-      function writeUtf8(buf, str, pos) {
-        for (var i2 = 0, c, lead; i2 < str.length; i2++) {
-          c = str.charCodeAt(i2);
-          if (c > 55295 && c < 57344) {
-            if (lead) {
-              if (c < 56320) {
-                buf[pos++] = 239;
-                buf[pos++] = 191;
-                buf[pos++] = 189;
-                lead = c;
-                continue;
-              } else {
-                c = lead - 55296 << 10 | c - 56320 | 65536;
-                lead = null;
-              }
-            } else {
-              if (c > 56319 || i2 + 1 === str.length) {
-                buf[pos++] = 239;
-                buf[pos++] = 191;
-                buf[pos++] = 189;
-              } else {
-                lead = c;
-              }
-              continue;
-            }
-          } else if (lead) {
-            buf[pos++] = 239;
-            buf[pos++] = 191;
-            buf[pos++] = 189;
-            lead = null;
+    }
+    lines.pathIndices[linePathsCount] = linePositionsCount;
+    polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
+    polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
+    const indexMap = {
+      pointPosition: 0,
+      pointFeature: 0,
+      linePosition: 0,
+      linePath: 0,
+      lineFeature: 0,
+      polygonPosition: 0,
+      polygonObject: 0,
+      polygonRing: 0,
+      polygonFeature: 0,
+      feature: 0
+    };
+    for (const feature of features) {
+      const geometry = feature.geometry;
+      const properties = feature.properties || {};
+      switch (geometry.type) {
+        case "Point":
+          handlePoint(geometry, points, indexMap, coordLength, properties);
+          points.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            points.fields.push({
+              id: feature.id
+            });
+          }
+          indexMap.pointFeature++;
+          break;
+        case "LineString":
+          handleLineString(geometry, lines, indexMap, coordLength, properties);
+          lines.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            lines.fields.push({
+              id: feature.id
+            });
           }
-          if (c < 128) {
-            buf[pos++] = c;
-          } else {
-            if (c < 2048) {
-              buf[pos++] = c >> 6 | 192;
-            } else {
-              if (c < 65536) {
-                buf[pos++] = c >> 12 | 224;
-              } else {
-                buf[pos++] = c >> 18 | 240;
-                buf[pos++] = c >> 12 & 63 | 128;
-              }
-              buf[pos++] = c >> 6 & 63 | 128;
-            }
-            buf[pos++] = c & 63 | 128;
+          indexMap.lineFeature++;
+          break;
+        case "Polygon":
+          handlePolygon(geometry, polygons, indexMap, coordLength, properties);
+          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            polygons.fields.push({
+              id: feature.id
+            });
           }
-        }
-        return pos;
+          indexMap.polygonFeature++;
+          break;
+        default:
+          throw new Error("Invalid geometry type");
       }
+      indexMap.feature++;
     }
-  });
+    return makeAccessorObjects(points, lines, polygons, coordLength);
+  }
+  function handlePoint(geometry, points, indexMap, coordLength, properties) {
+    points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
+    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    indexMap.pointPosition += nPositions;
+  }
+  function handleLineString(geometry, lines, indexMap, coordLength, properties) {
+    lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
+    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    for (let i2 = 0, il = geometry.indices.length; i2 < il; ++i2) {
+      const start = geometry.indices[i2];
+      const end = i2 === il - 1 ? geometry.data.length : geometry.indices[i2 + 1];
+      lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
+      indexMap.linePosition += (end - start) / coordLength;
+    }
+  }
+  function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
+    polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
+    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
+      const startPosition = indexMap.polygonPosition;
+      polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
+      const areas = geometry.areas[l];
+      const indices = geometry.indices[l];
+      const nextIndices = geometry.indices[l + 1];
+      for (let i2 = 0, il = indices.length; i2 < il; ++i2) {
+        const start = indices[i2];
+        const end = i2 === il - 1 ? (
+          // last line, so either read to:
+          nextIndices === void 0 ? geometry.data.length : nextIndices[0]
+        ) : indices[i2 + 1];
+        polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
+        indexMap.polygonPosition += (end - start) / coordLength;
+      }
+      const endPosition = indexMap.polygonPosition;
+      triangulatePolygon(polygons, areas, indices, {
+        startPosition,
+        endPosition,
+        coordLength
+      });
+    }
+  }
+  function triangulatePolygon(polygons, areas, indices, {
+    startPosition,
+    endPosition,
+    coordLength
+  }) {
+    if (!polygons.triangles) {
+      return;
+    }
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    const polygonPositions = polygons.positions.subarray(start, end);
+    const offset = indices[0];
+    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+    const triangles = earcut(polygonPositions, holes, coordLength, areas);
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+      polygons.triangles.push(startPosition + triangles[t]);
+    }
+  }
+  function wrapProps(obj, size) {
+    const returnObj = {};
+    for (const key in obj) {
+      returnObj[key] = {
+        value: obj[key],
+        size
+      };
+    }
+    return returnObj;
+  }
+  function makeAccessorObjects(points, lines, polygons, coordLength) {
+    const binaryFeatures = {
+      points: {
+        ...points,
+        positions: {
+          value: points.positions,
+          size: coordLength
+        },
+        globalFeatureIds: {
+          value: points.globalFeatureIds,
+          size: 1
+        },
+        featureIds: {
+          value: points.featureIds,
+          size: 1
+        },
+        numericProps: wrapProps(points.numericProps, 1)
+      },
+      lines: {
+        ...lines,
+        positions: {
+          value: lines.positions,
+          size: coordLength
+        },
+        pathIndices: {
+          value: lines.pathIndices,
+          size: 1
+        },
+        globalFeatureIds: {
+          value: lines.globalFeatureIds,
+          size: 1
+        },
+        featureIds: {
+          value: lines.featureIds,
+          size: 1
+        },
+        numericProps: wrapProps(lines.numericProps, 1)
+      },
+      polygons: {
+        ...polygons,
+        positions: {
+          value: polygons.positions,
+          size: coordLength
+        },
+        polygonIndices: {
+          value: polygons.polygonIndices,
+          size: 1
+        },
+        primitivePolygonIndices: {
+          value: polygons.primitivePolygonIndices,
+          size: 1
+        },
+        globalFeatureIds: {
+          value: polygons.globalFeatureIds,
+          size: 1
+        },
+        featureIds: {
+          value: polygons.featureIds,
+          size: 1
+        },
+        numericProps: wrapProps(polygons.numericProps, 1)
+      }
+      // triangles not expected
+    };
+    if (binaryFeatures.polygons && polygons.triangles) {
+      binaryFeatures.polygons.triangles = {
+        value: new Uint32Array(polygons.triangles),
+        size: 1
+      };
+    }
+    return binaryFeatures;
+  }
+  function fillNumericProperties(object, properties, index, length2) {
+    for (const numericPropName in object.numericProps) {
+      if (numericPropName in properties) {
+        const value = properties[numericPropName];
+        object.numericProps[numericPropName].fill(value, index, index + length2);
+      }
+    }
+  }
+  function keepStringProperties(properties, numericKeys) {
+    const props = {};
+    for (const key in properties) {
+      if (!numericKeys.includes(key)) {
+        props[key] = properties[key];
+      }
+    }
+    return props;
+  }
+  function deduceArrayType(x2, constructor) {
+    if (constructor === Array || !Number.isFinite(x2)) {
+      return Array;
+    }
+    return constructor === Float64Array || Math.fround(x2) !== x2 ? Float64Array : Float32Array;
+  }
+
+  // src/lib/parse-mvt.ts
+  var import_pbf = __toESM(require_pbf(), 1);
 
   // src/helpers/mapbox-util-functions.ts
   function classifyRings(rings) {
@@ -1660,175 +1718,198 @@
       feature.properties[key] = value;
     }
   }
-  var init_mapbox_util_functions = __esm({
-    "src/helpers/mapbox-util-functions.ts"() {
-    }
-  });
 
   // src/lib/mapbox-vector-tile/vector-tile-feature.ts
-  var VectorTileFeature;
-  var init_vector_tile_feature = __esm({
-    "src/lib/mapbox-vector-tile/vector-tile-feature.ts"() {
-      init_mapbox_util_functions();
-      VectorTileFeature = class {
-        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);
+  var VectorTileFeature = class {
+    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 x2 = 0;
+      let y2 = 0;
+      const lines = [];
+      let line;
+      while (pbf.pos < end) {
+        if (length2 <= 0) {
+          const cmdLen2 = pbf.readVarint();
+          cmd2 = cmdLen2 & 7;
+          length2 = cmdLen2 >> 3;
         }
-        loadGeometry() {
-          const pbf = this._pbf;
-          pbf.pos = this._geometry;
-          const end = pbf.readVarint() + pbf.pos;
-          let cmd2 = 1;
-          let length2 = 0;
-          let x2 = 0;
-          let y2 = 0;
-          const lines = [];
-          let line;
-          while (pbf.pos < end) {
-            if (length2 <= 0) {
-              const cmdLen2 = pbf.readVarint();
-              cmd2 = cmdLen2 & 7;
-              length2 = cmdLen2 >> 3;
-            }
-            length2--;
-            if (cmd2 === 1 || cmd2 === 2) {
-              x2 += pbf.readSVarint();
-              y2 += pbf.readSVarint();
-              if (cmd2 === 1) {
-                if (line)
-                  lines.push(line);
-                line = [];
-              }
-              if (line)
-                line.push([x2, y2]);
-            } else if (cmd2 === 7) {
-              if (line) {
-                line.push(line[0].slice());
-              }
-            } else {
-              throw new Error(`unknown command ${cmd2}`);
-            }
+        length2--;
+        if (cmd2 === 1 || cmd2 === 2) {
+          x2 += pbf.readSVarint();
+          y2 += pbf.readSVarint();
+          if (cmd2 === 1) {
+            if (line)
+              lines.push(line);
+            line = [];
           }
           if (line)
-            lines.push(line);
-          return lines;
-        }
-        bbox() {
-          const pbf = this._pbf;
-          pbf.pos = this._geometry;
-          const end = pbf.readVarint() + pbf.pos;
-          let cmd2 = 1;
-          let length2 = 0;
-          let x2 = 0;
-          let y2 = 0;
-          let x1 = Infinity;
-          let x22 = -Infinity;
-          let y1 = Infinity;
-          let y22 = -Infinity;
-          while (pbf.pos < end) {
-            if (length2 <= 0) {
-              const cmdLen2 = pbf.readVarint();
-              cmd2 = cmdLen2 & 7;
-              length2 = cmdLen2 >> 3;
-            }
-            length2--;
-            if (cmd2 === 1 || cmd2 === 2) {
-              x2 += pbf.readSVarint();
-              y2 += pbf.readSVarint();
-              if (x2 < x1)
-                x1 = x2;
-              if (x2 > x22)
-                x22 = x2;
-              if (y2 < y1)
-                y1 = y2;
-              if (y2 > y22)
-                y22 = y2;
-            } else if (cmd2 !== 7) {
-              throw new Error(`unknown command ${cmd2}`);
-            }
+            line.push([x2, y2]);
+        } else if (cmd2 === 7) {
+          if (line) {
+            line.push(line[0].slice());
           }
-          return [x1, y1, x22, y22];
+        } else {
+          throw new Error(`unknown command ${cmd2}`);
         }
-        _toGeoJSON(transform) {
-          let coords = this.loadGeometry();
-          let type = VectorTileFeature.types[this.type];
-          let i2;
-          let j;
-          switch (this.type) {
-            case 1:
-              const points = [];
-              for (i2 = 0; i2 < coords.length; i2++) {
-                points[i2] = coords[i2][0];
-              }
-              coords = points;
-              transform(coords, this);
-              break;
-            case 2:
-              for (i2 = 0; i2 < coords.length; i2++) {
-                transform(coords[i2], this);
-              }
-              break;
-            case 3:
-              coords = classifyRings(coords);
-              for (i2 = 0; i2 < coords.length; i2++) {
-                for (j = 0; j < coords[i2].length; j++) {
-                  transform(coords[i2][j], this);
-                }
-              }
-              break;
-          }
-          if (coords.length === 1) {
-            coords = coords[0];
-          } else {
-            type = `Multi${type}`;
-          }
-          const result = {
-            type: "Feature",
-            geometry: {
-              type,
-              coordinates: coords
-            },
-            properties: this.properties
-          };
-          if (this.id !== null) {
-            result.id = this.id;
-          }
-          return result;
+      }
+      if (line)
+        lines.push(line);
+      return lines;
+    }
+    // eslint-disable-next-line max-statements
+    bbox() {
+      const pbf = this._pbf;
+      pbf.pos = this._geometry;
+      const end = pbf.readVarint() + pbf.pos;
+      let cmd2 = 1;
+      let length2 = 0;
+      let x2 = 0;
+      let y2 = 0;
+      let x1 = Infinity;
+      let x22 = -Infinity;
+      let y1 = Infinity;
+      let y22 = -Infinity;
+      while (pbf.pos < end) {
+        if (length2 <= 0) {
+          const cmdLen2 = pbf.readVarint();
+          cmd2 = cmdLen2 & 7;
+          length2 = cmdLen2 >> 3;
+        }
+        length2--;
+        if (cmd2 === 1 || cmd2 === 2) {
+          x2 += pbf.readSVarint();
+          y2 += pbf.readSVarint();
+          if (x2 < x1)
+            x1 = x2;
+          if (x2 > x22)
+            x22 = x2;
+          if (y2 < y1)
+            y1 = y2;
+          if (y2 > y22)
+            y22 = y2;
+        } else if (cmd2 !== 7) {
+          throw new Error(`unknown command ${cmd2}`);
         }
-        toGeoJSON(options) {
-          if (typeof options === "function") {
-            return this._toGeoJSON(options);
+      }
+      return [x1, y1, x22, y22];
+    }
+    _toGeoJSON(transform) {
+      let coords = this.loadGeometry();
+      let type = VectorTileFeature.types[this.type];
+      let i2;
+      let j;
+      switch (this.type) {
+        case 1:
+          const points = [];
+          for (i2 = 0; i2 < coords.length; i2++) {
+            points[i2] = coords[i2][0];
+          }
+          coords = points;
+          transform(coords, this);
+          break;
+        case 2:
+          for (i2 = 0; i2 < coords.length; i2++) {
+            transform(coords[i2], this);
           }
-          const { x: x2, y: y2, z } = options;
-          const size = this.extent * Math.pow(2, z);
-          const x0 = this.extent * x2;
-          const y0 = this.extent * y2;
-          function project2(line) {
-            for (let j = 0; j < line.length; j++) {
-              const p = line[j];
-              p[0] = (p[0] + x0) * 360 / size - 180;
-              const y22 = 180 - (p[1] + y0) * 360 / size;
-              p[1] = 360 / Math.PI * Math.atan(Math.exp(y22 * Math.PI / 180)) - 90;
+          break;
+        case 3:
+          coords = classifyRings(coords);
+          for (i2 = 0; i2 < coords.length; i2++) {
+            for (j = 0; j < coords[i2].length; j++) {
+              transform(coords[i2][j], this);
             }
           }
-          return this._toGeoJSON(project2);
-        }
+          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: x2,
+        y: y2,
+        z
+      } = options;
+      const size = this.extent * Math.pow(2, z);
+      const x0 = this.extent * x2;
+      const y0 = this.extent * y2;
+      function project2(line) {
+        for (let j = 0; j < line.length; j++) {
+          const p = line[j];
+          p[0] = (p[0] + x0) * 360 / size - 180;
+          const y22 = 180 - (p[1] + y0) * 360 / size;
+          p[1] = 360 / Math.PI * Math.atan(Math.exp(y22 * Math.PI / 180)) - 90;
+        }
+      }
+      return this._toGeoJSON(project2);
+    }
+  };
 
   // src/lib/mapbox-vector-tile/vector-tile-layer.ts
+  var VectorTileLayer = class {
+    constructor(pbf, end) {
+      this.version = 1;
+      this.name = "";
+      this.extent = 4096;
+      this.length = 0;
+      this._pbf = pbf;
+      this._keys = [];
+      this._values = [];
+      this._features = [];
+      pbf.readFields(readLayer, this, end);
+      this.length = this._features.length;
+    }
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     * @param index
+     * @returns feature
+     */
+    feature(i2) {
+      if (i2 < 0 || i2 >= this._features.length) {
+        throw new Error("feature index out of bounds");
+      }
+      this._pbf.pos = this._features[i2];
+      const end = this._pbf.readVarint() + this._pbf.pos;
+      return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+    }
+  };
   function readLayer(tag, layer, pbf) {
     if (layer && pbf) {
       if (tag === 15)
@@ -1854,36 +1935,13 @@
     }
     return value;
   }
-  var VectorTileLayer;
-  var init_vector_tile_layer = __esm({
-    "src/lib/mapbox-vector-tile/vector-tile-layer.ts"() {
-      init_vector_tile_feature();
-      VectorTileLayer = class {
-        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;
-        }
-        feature(i2) {
-          if (i2 < 0 || i2 >= this._features.length) {
-            throw new Error("feature index out of bounds");
-          }
-          this._pbf.pos = this._features[i2];
-          const end = this._pbf.readVarint() + this._pbf.pos;
-          return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
-        }
-      };
-    }
-  });
 
   // src/lib/mapbox-vector-tile/vector-tile.ts
+  var VectorTile = class {
+    constructor(pbf, end) {
+      this.layers = pbf.readFields(readTile, {}, end);
+    }
+  };
   function readTile(tag, layers, pbf) {
     if (tag === 3) {
       if (pbf) {
@@ -1894,17 +1952,6 @@
       }
     }
   }
-  var VectorTile;
-  var init_vector_tile = __esm({
-    "src/lib/mapbox-vector-tile/vector-tile.ts"() {
-      init_vector_tile_layer();
-      VectorTile = class {
-        constructor(pbf, end) {
-          this.layers = pbf.readFields(readTile, {}, end);
-        }
-      };
-    }
-  });
 
   // src/helpers/binary-util-functions.ts
   function classifyRings2(geom) {
@@ -1954,7 +2001,12 @@
       areas.push(ringAreas);
     if (polygon.length)
       polygons.push(polygon);
-    return { type, areas, indices: polygons, data: geom.data };
+    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) {
@@ -1983,118 +2035,167 @@
       feature.properties[key] = value;
     }
   }
-  var init_binary_util_functions = __esm({
-    "src/helpers/binary-util-functions.ts"() {
-      init_esm();
-    }
-  });
 
   // src/lib/binary-vector-tile/vector-tile-feature.ts
-  var endPos, cmd, cmdLen, length, x, y, i, VectorTileFeature2;
-  var init_vector_tile_feature2 = __esm({
-    "src/lib/binary-vector-tile/vector-tile-feature.ts"() {
-      init_binary_util_functions();
-      VectorTileFeature2 = class {
-        constructor(pbf, end, extent, keys, values, geometryInfo) {
-          this.properties = {};
-          this.extent = extent;
-          this.type = 0;
-          this.id = null;
-          this._pbf = pbf;
-          this._geometry = -1;
-          this._keys = keys;
-          this._values = values;
-          this._geometryInfo = geometryInfo;
-          pbf.readFields(readFeature2, this, end);
-        }
-        loadGeometry() {
-          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) {
-            if (length <= 0) {
-              cmdLen = pbf.readVarint();
-              cmd = cmdLen & 7;
-              length = cmdLen >> 3;
-            }
-            length--;
-            if (cmd === 1 || cmd === 2) {
-              x += pbf.readSVarint();
-              y += pbf.readSVarint();
-              if (cmd === 1) {
-                indices.push(i);
-              }
-              data.push(x, y);
-              i += 2;
-            } else if (cmd === 7) {
-              if (i > 0) {
-                const start = indices[indices.length - 1];
-                data.push(data[start], data[start + 1]);
-                i += 2;
-              }
-            } else {
-              throw new Error(`unknown command ${cmd}`);
-            }
-          }
-          return { data, indices };
+  var endPos;
+  var cmd;
+  var cmdLen;
+  var length;
+  var x;
+  var y;
+  var i;
+  var VectorTileFeature2 = class {
+    // eslint-disable-next-line max-params
+    constructor(pbf, end, extent, keys, values, geometryInfo) {
+      this.properties = {};
+      this.extent = extent;
+      this.type = 0;
+      this.id = null;
+      this._pbf = pbf;
+      this._geometry = -1;
+      this._keys = keys;
+      this._values = values;
+      this._geometryInfo = geometryInfo;
+      pbf.readFields(readFeature2, this, end);
+    }
+    // eslint-disable-next-line complexity, max-statements
+    loadGeometry() {
+      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) {
+        if (length <= 0) {
+          cmdLen = pbf.readVarint();
+          cmd = cmdLen & 7;
+          length = cmdLen >> 3;
         }
-        _toBinaryCoordinates(transform) {
-          const geom = this.loadGeometry();
-          let geometry;
-          transform(geom.data, this);
-          const coordLength = 2;
-          switch (this.type) {
-            case 1:
-              this._geometryInfo.pointFeaturesCount++;
-              this._geometryInfo.pointPositionsCount += geom.indices.length;
-              geometry = { type: "Point", ...geom };
-              break;
-            case 2:
-              this._geometryInfo.lineFeaturesCount++;
-              this._geometryInfo.linePathsCount += geom.indices.length;
-              this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
-              geometry = { type: "LineString", ...geom };
-              break;
-            case 3:
-              geometry = classifyRings2(geom);
-              this._geometryInfo.polygonFeaturesCount++;
-              this._geometryInfo.polygonObjectsCount += geometry.indices.length;
-              for (const indices of geometry.indices) {
-                this._geometryInfo.polygonRingsCount += indices.length;
-              }
-              this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
-              break;
-            default:
-              throw new Error(`Invalid geometry type: ${this.type}`);
+        length--;
+        if (cmd === 1 || cmd === 2) {
+          x += pbf.readSVarint();
+          y += pbf.readSVarint();
+          if (cmd === 1) {
+            indices.push(i);
           }
-          const result = { type: "Feature", geometry, properties: this.properties };
-          if (this.id !== null) {
-            result.id = this.id;
+          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;
           }
-          return result;
+        } else {
+          throw new Error(`unknown command ${cmd}`);
         }
-        toBinaryCoordinates(options) {
-          if (typeof options === "function") {
-            return this._toBinaryCoordinates(options);
+      }
+      return {
+        data,
+        indices
+      };
+    }
+    /**
+     *
+     * @param transform
+     * @returns result
+     */
+    _toBinaryCoordinates(transform) {
+      const geom = this.loadGeometry();
+      let geometry;
+      transform(geom.data, this);
+      const coordLength = 2;
+      switch (this.type) {
+        case 1:
+          this._geometryInfo.pointFeaturesCount++;
+          this._geometryInfo.pointPositionsCount += geom.indices.length;
+          geometry = {
+            type: "Point",
+            ...geom
+          };
+          break;
+        case 2:
+          this._geometryInfo.lineFeaturesCount++;
+          this._geometryInfo.linePathsCount += geom.indices.length;
+          this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+          geometry = {
+            type: "LineString",
+            ...geom
+          };
+          break;
+        case 3:
+          geometry = classifyRings2(geom);
+          this._geometryInfo.polygonFeaturesCount++;
+          this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+          for (const indices of geometry.indices) {
+            this._geometryInfo.polygonRingsCount += indices.length;
           }
-          const { x: x2, y: y2, z } = options;
-          const size = this.extent * Math.pow(2, z);
-          const x0 = this.extent * x2;
-          const y0 = this.extent * y2;
-          return this._toBinaryCoordinates((data) => project(data, x0, y0, size));
-        }
+          this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
+          break;
+        default:
+          throw new Error(`Invalid geometry type: ${this.type}`);
+      }
+      const result = {
+        type: "Feature",
+        geometry,
+        properties: this.properties
       };
+      if (this.id !== null) {
+        result.id = this.id;
+      }
+      return result;
     }
-  });
+    toBinaryCoordinates(options) {
+      if (typeof options === "function") {
+        return this._toBinaryCoordinates(options);
+      }
+      const {
+        x: x2,
+        y: y2,
+        z
+      } = options;
+      const size = this.extent * Math.pow(2, z);
+      const x0 = this.extent * x2;
+      const y0 = this.extent * y2;
+      return this._toBinaryCoordinates((data) => project(data, x0, y0, size));
+    }
+  };
 
   // src/lib/binary-vector-tile/vector-tile-layer.ts
+  var VectorTileLayer2 = class {
+    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(readLayer2, this, end);
+      this.length = this._features.length;
+    }
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     *
+     * @param index
+     * @param geometryInfo
+     * @returns {VectorTileFeature}
+     */
+    feature(i2, geometryInfo) {
+      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 VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
+    }
+  };
   function readLayer2(tag, layer, pbf) {
     if (layer && pbf) {
       if (tag === 15)
@@ -2116,40 +2217,17 @@
     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;
-  }
-  var VectorTileLayer2;
-  var init_vector_tile_layer2 = __esm({
-    "src/lib/binary-vector-tile/vector-tile-layer.ts"() {
-      init_vector_tile_feature2();
-      VectorTileLayer2 = class {
-        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(readLayer2, this, end);
-          this.length = this._features.length;
-        }
-        feature(i2, geometryInfo) {
-          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 VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
-        }
-      };
+      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;
+  }
 
   // src/lib/binary-vector-tile/vector-tile.ts
+  var VectorTile2 = class {
+    constructor(pbf, end) {
+      this.layers = pbf.readFields(readTile2, {}, end);
+    }
+  };
   function readTile2(tag, layers, pbf) {
     if (tag === 3) {
       if (pbf) {
@@ -2160,17 +2238,6 @@
       }
     }
   }
-  var VectorTile2;
-  var init_vector_tile2 = __esm({
-    "src/lib/binary-vector-tile/vector-tile.ts"() {
-      init_vector_tile_layer2();
-      VectorTile2 = class {
-        constructor(pbf, end) {
-          this.layers = pbf.readFields(readTile2, {}, end);
-        }
-      };
-    }
-  });
 
   // src/lib/parse-mvt.ts
   function parseMVT(arrayBuffer, options) {
@@ -2178,7 +2245,10 @@
     const shape = options?.gis?.format || options?.mvt?.shape || options?.shape;
     switch (shape) {
       case "columnar-table":
-        return { shape: "columnar-table", data: parseToBinary(arrayBuffer, mvtOptions) };
+        return {
+          shape: "columnar-table",
+          data: parseToBinary(arrayBuffer, mvtOptions)
+        };
       case "geojson-table": {
         const table = {
           shape: "geojson-table",
@@ -2260,7 +2330,9 @@
       throw new Error("mvt options required");
     }
     const wgs84Coordinates = options.mvt?.coordinates === "wgs84";
-    const { tileIndex } = options.mvt;
+    const {
+      tileIndex
+    } = options.mvt;
     const hasTileIndex = tileIndex && Number.isFinite(tileIndex.x) && Number.isFinite(tileIndex.y) && Number.isFinite(tileIndex.z);
     if (wgs84Coordinates && !hasTileIndex) {
       throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
@@ -2268,21 +2340,29 @@
     return options.mvt;
   }
   function getDecodedFeature(feature, options, layerName) {
-    const decodedFeature = feature.toGeoJSON(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates);
+    const decodedFeature = feature.toGeoJSON(
+      // @ts-expect-error What is going on here?
+      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates
+    );
     if (options.layerProperty) {
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
   function getDecodedFeatureBinary(feature, options, layerName) {
-    const decodedFeature = feature.toBinaryCoordinates(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary);
+    const decodedFeature = feature.toBinaryCoordinates(
+      // @ts-expect-error What is going on here?
+      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary
+    );
     if (options.layerProperty && decodedFeature.properties) {
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
   function transformToLocalCoordinates(line, feature) {
-    const { extent } = feature;
+    const {
+      extent
+    } = feature;
     for (let i2 = 0; i2 < line.length; i2++) {
       const p = line[i2];
       p[0] /= extent;
@@ -2290,59 +2370,50 @@
     }
   }
   function transformToLocalCoordinatesBinary(data, feature) {
-    const { extent } = feature;
+    const {
+      extent
+    } = feature;
     for (let i2 = 0, il = data.length; i2 < il; ++i2) {
       data[i2] /= extent;
     }
   }
-  var import_pbf;
-  var init_parse_mvt = __esm({
-    "src/lib/parse-mvt.ts"() {
-      init_src();
-      import_pbf = __toModule(require_pbf());
-      init_vector_tile();
-      init_vector_tile2();
-    }
-  });
 
   // src/mvt-loader.ts
-  var VERSION, MVTWorkerLoader, MVTLoader;
-  var init_mvt_loader = __esm({
-    "src/mvt-loader.ts"() {
-      init_parse_mvt();
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      MVTWorkerLoader = {
-        name: "Mapbox Vector Tile",
-        id: "mvt",
-        module: "mvt",
-        version: VERSION,
-        extensions: ["mvt", "pbf"],
-        mimeTypes: [
-          "application/vnd.mapbox-vector-tile",
-          "application/x-protobuf"
-        ],
-        worker: true,
-        category: "geometry",
-        options: {
-          mvt: {
-            shape: "geojson",
-            coordinates: "local",
-            layerProperty: "layerName",
-            layers: void 0,
-            tileIndex: null
-          }
-        }
-      };
-      MVTLoader = {
-        ...MVTWorkerLoader,
-        parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),
-        parseSync: parseMVT,
-        binary: true
-      };
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var MVTWorkerLoader = {
+    name: "Mapbox Vector Tile",
+    id: "mvt",
+    module: "mvt",
+    version: VERSION,
+    // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
+    extensions: ["mvt", "pbf"],
+    mimeTypes: [
+      // https://www.iana.org/assignments/media-types/application/vnd.mapbox-vector-tile
+      "application/vnd.mapbox-vector-tile",
+      "application/x-protobuf"
+      // 'application/octet-stream'
+    ],
+    worker: true,
+    category: "geometry",
+    options: {
+      mvt: {
+        shape: "geojson",
+        coordinates: "local",
+        layerProperty: "layerName",
+        layers: void 0,
+        tileIndex: null
+      }
     }
-  });
+  };
+  var MVTLoader = {
+    ...MVTWorkerLoader,
+    parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),
+    parseSync: parseMVT,
+    binary: true
+  };
 
   // src/lib/parse-tilejson.ts
+  var isObject = (x2) => x2 !== null && typeof x2 === "object";
   function parseTileJSON(jsonMetadata) {
     if (!jsonMetadata || !isObject(jsonMetadata)) {
       return null;
@@ -2420,10 +2491,7 @@
   function parseBounds(bounds) {
     const result = fromArrayOrString(bounds);
     if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
-      return [
-        [result[0], result[1]],
-        [result[2], result[3]]
-      ];
+      return [[result[0], result[1]], [result[2], result[3]]];
     }
     return void 0;
   }
@@ -2455,10 +2523,41 @@
     }
     return null;
   }
+  var attrTypeMap = {
+    number: {
+      type: "float32"
+    },
+    numeric: {
+      type: "float32"
+    },
+    string: {
+      type: "utf8"
+    },
+    vachar: {
+      type: "utf8"
+    },
+    float: {
+      type: "float32"
+    },
+    int: {
+      type: "int32"
+    },
+    int4: {
+      type: "int32"
+    },
+    boolean: {
+      type: "boolean"
+    },
+    bool: {
+      type: "boolean"
+    }
+  };
   function attributeToField(attribute = {}) {
     const fieldTypes = attributeTypeToFieldType(attribute.type);
     return {
       name: attribute.attribute,
+      // what happens if attribute type is string...
+      // filterProps: getFilterProps(fieldTypes.type, attribute),
       ...fieldTypes
     };
   }
@@ -2466,74 +2565,614 @@
     const type = aType.toLowerCase();
     if (!type || !attrTypeMap[type]) {
     }
-    return attrTypeMap[type] || { type: "string" };
+    return attrTypeMap[type] || {
+      type: "string"
+    };
   }
-  var isObject, attrTypeMap;
-  var init_parse_tilejson = __esm({
-    "src/lib/parse-tilejson.ts"() {
-      isObject = (x2) => x2 !== null && typeof x2 === "object";
-      attrTypeMap = {
-        number: {
-          type: "float32"
-        },
-        numeric: {
-          type: "float32"
-        },
-        string: {
-          type: "utf8"
-        },
-        vachar: {
-          type: "utf8"
-        },
-        float: {
-          type: "float32"
-        },
-        int: {
-          type: "int32"
-        },
-        int4: {
-          type: "int32"
-        },
-        boolean: {
-          type: "boolean"
-        },
-        bool: {
-          type: "boolean"
-        }
+
+  // src/tilejson-loader.ts
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var TileJSONLoader = {
+    name: "TileJSON",
+    id: "tilejson",
+    module: "pmtiles",
+    version: VERSION2,
+    worker: true,
+    extensions: ["json"],
+    mimeTypes: ["application/json"],
+    text: true,
+    options: {
+      tilejson: {}
+    },
+    parse: async (arrayBuffer, options) => {
+      const jsonString = new TextDecoder().decode(arrayBuffer);
+      const json = JSON.parse(jsonString);
+      return parseTileJSON(json);
+    },
+    parseTextSync: (text, options) => {
+      const json = JSON.parse(text);
+      return parseTileJSON(json);
+    }
+  };
+
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
+    }
+  }
+
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../loader-utils/src/lib/path-utils/file-aliases.ts
+  var pathPrefix = "";
+  var fileAliases = {};
+  function resolvePath(filename) {
+    for (const alias in fileAliases) {
+      if (filename.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename = filename.replace(alias, replacement);
+      }
+    }
+    if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+      filename = `${pathPrefix}${filename}`;
+    }
+    return filename;
+  }
+
+  // ../loader-utils/src/lib/sources/data-source.ts
+  var DataSource = class {
+    /** A resolved fetch function extracted from loadOptions prop */
+    /** The actual load options, if calling a loaders.gl loader */
+    _needsRefresh = true;
+    constructor(props) {
+      this.props = {
+        ...props
+      };
+      this.loadOptions = {
+        ...props.loadOptions
       };
+      this.fetch = getFetchFunction(this.loadOptions);
     }
-  });
+    setProps(props) {
+      this.props = Object.assign(this.props, props);
+      this.setNeedsRefresh();
+    }
+    /** Mark this data source as needing a refresh (redraw) */
+    setNeedsRefresh() {
+      this._needsRefresh = true;
+    }
+    /**
+     * Does this data source need refreshing?
+     * @note The specifics of the refresh mechanism depends on type of data source
+     */
+    getNeedsRefresh(clear = true) {
+      const needsRefresh = this._needsRefresh;
+      if (clear) {
+        this._needsRefresh = false;
+      }
+      return needsRefresh;
+    }
+  };
+  function getFetchFunction(options) {
+    const fetchFunction = options?.fetch;
+    if (fetchFunction && typeof fetchFunction === "function") {
+      return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
+    }
+    const fetchOptions = options?.fetch;
+    if (fetchOptions && typeof fetchOptions !== "function") {
+      return (url) => fetch(url, fetchOptions);
+    }
+    return (url) => fetch(url);
+  }
 
-  // src/tilejson-loader.ts
-  var VERSION2, TileJSONLoader;
-  var init_tilejson_loader = __esm({
-    "src/tilejson-loader.ts"() {
-      init_parse_tilejson();
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      TileJSONLoader = {
-        name: "TileJSON",
-        id: "tilejson",
-        module: "pmtiles",
-        version: VERSION2,
-        worker: true,
-        extensions: ["json"],
-        mimeTypes: ["application/json"],
-        text: true,
-        options: {
-          tilejson: {}
-        },
-        parse: async (arrayBuffer, options) => {
-          const jsonString = new TextDecoder().decode(arrayBuffer);
-          const json = JSON.parse(jsonString);
-          return parseTileJSON(json);
-        },
-        parseTextSync: (text, options) => {
-          const json = JSON.parse(text);
-          return parseTileJSON(json);
+  // ../images/src/lib/utils/version.ts
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+
+  // ../images/src/lib/category-api/image-type.ts
+  var {
+    _parseImageNode
+  } = globalThis;
+  var IMAGE_SUPPORTED = typeof Image !== "undefined";
+  var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+  var NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+  var DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+  function isImageTypeSupported(type) {
+    switch (type) {
+      case "auto":
+        return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+      case "imagebitmap":
+        return IMAGE_BITMAP_SUPPORTED;
+      case "image":
+        return IMAGE_SUPPORTED;
+      case "data":
+        return DATA_SUPPORTED;
+      default:
+        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+    }
+  }
+  function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+      return "imagebitmap";
+    }
+    if (IMAGE_SUPPORTED) {
+      return "image";
+    }
+    if (DATA_SUPPORTED) {
+      return "data";
+    }
+    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
+  }
+
+  // ../images/src/lib/category-api/parsed-image-api.ts
+  function getImageType(image) {
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+      throw new Error("Not an image");
+    }
+    return format;
+  }
+  function getImageData(image) {
+    switch (getImageType(image)) {
+      case "data":
+        return image;
+      case "image":
+      case "imagebitmap":
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!context) {
+          throw new Error("getImageData");
+        }
+        canvas.width = image.width;
+        canvas.height = image.height;
+        context.drawImage(image, 0, 0);
+        return context.getImageData(0, 0, image.width, image.height);
+      default:
+        throw new Error("getImageData");
+    }
+  }
+  function getImageTypeOrNull(image) {
+    if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+      return "imagebitmap";
+    }
+    if (typeof Image !== "undefined" && image instanceof Image) {
+      return "image";
+    }
+    if (image && typeof image === "object" && image.data && image.width && image.height) {
+      return "data";
+    }
+    return null;
+  }
+
+  // ../images/src/lib/parsers/svg-utils.ts
+  var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+  var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+  function isSVG(url) {
+    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+  }
+  function getBlobOrSVGDataUrl(arrayBuffer, url) {
+    if (isSVG(url)) {
+      const textDecoder = new TextDecoder();
+      let xmlText = textDecoder.decode(arrayBuffer);
+      try {
+        if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
+          xmlText = unescape(encodeURIComponent(xmlText));
         }
+      } catch (error) {
+        throw new Error(error.message);
+      }
+      const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+      return src;
+    }
+    return getBlob(arrayBuffer, url);
+  }
+  function getBlob(arrayBuffer, url) {
+    if (isSVG(url)) {
+      throw new Error("SVG cannot be parsed directly to imagebitmap");
+    }
+    return new Blob([new Uint8Array(arrayBuffer)]);
+  }
+
+  // ../images/src/lib/parsers/parse-to-image.ts
+  async function parseToImage(arrayBuffer, options, url) {
+    const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
+    const URL = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
+    try {
+      return await loadToImage(objectUrl || blobOrDataUrl, options);
+    } finally {
+      if (objectUrl) {
+        URL.revokeObjectURL(objectUrl);
+      }
+    }
+  }
+  async function loadToImage(url, options) {
+    const image = new Image();
+    image.src = url;
+    if (options.image && options.image.decode && image.decode) {
+      await image.decode();
+      return image;
+    }
+    return await new Promise((resolve, reject) => {
+      try {
+        image.onload = () => resolve(image);
+        image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  // ../images/src/lib/parsers/parse-to-image-bitmap.ts
+  var EMPTY_OBJECT = {};
+  var imagebitmapOptionsSupported = true;
+  async function parseToImageBitmap(arrayBuffer, options, url) {
+    let blob;
+    if (isSVG(url)) {
+      const image = await parseToImage(arrayBuffer, options, url);
+      blob = image;
+    } else {
+      blob = getBlob(arrayBuffer, url);
+    }
+    const imagebitmapOptions = options && options.imagebitmap;
+    return await safeCreateImageBitmap(blob, imagebitmapOptions);
+  }
+  async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+      imagebitmapOptions = null;
+    }
+    if (imagebitmapOptions) {
+      try {
+        return await createImageBitmap(blob, imagebitmapOptions);
+      } catch (error) {
+        console.warn(error);
+        imagebitmapOptionsSupported = false;
+      }
+    }
+    return await createImageBitmap(blob);
+  }
+  function isEmptyObject(object) {
+    for (const key in object || EMPTY_OBJECT) {
+      return false;
+    }
+    return true;
+  }
+
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
+    }
+    if ((buffer[8] & 96) === 0) {
+      return null;
+    }
+    return decodeMajorBrand(buffer);
+  }
+  function decodeMajorBrand(buffer) {
+    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+    switch (brandMajor) {
+      case "avif":
+      case "avis":
+        return {
+          extension: "avif",
+          mimeType: "image/avif"
+        };
+      default:
+        return null;
+    }
+  }
+  function getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
+  }
+  function stringToBytes(string) {
+    return [...string].map((character) => character.charCodeAt(0));
+  }
+  function checkString(buffer, header, offset = 0) {
+    const headerBytes = stringToBytes(header);
+    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
+      if (headerBytes[i2] !== buffer[i2 + offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // ../images/src/lib/category-api/binary-image-api.ts
+  var BIG_ENDIAN = false;
+  var LITTLE_ENDIAN = true;
+  function getBinaryImageMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+  }
+  function getISOBMFFMetadata(binaryData) {
+    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+    const mediaType = getISOBMFFMediaType(buffer);
+    if (!mediaType) {
+      return null;
+    }
+    return {
+      mimeType: mediaType.mimeType,
+      // TODO - decode width and height
+      width: 0,
+      height: 0
+    };
+  }
+  function getPngMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+    if (!isPng) {
+      return null;
+    }
+    return {
+      mimeType: "image/png",
+      width: dataView.getUint32(16, BIG_ENDIAN),
+      height: dataView.getUint32(20, BIG_ENDIAN)
+    };
+  }
+  function getGifMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+    if (!isGif) {
+      return null;
+    }
+    return {
+      mimeType: "image/gif",
+      width: dataView.getUint16(6, LITTLE_ENDIAN),
+      height: dataView.getUint16(8, LITTLE_ENDIAN)
+    };
+  }
+  function getBmpMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+    if (!isBmp) {
+      return null;
+    }
+    return {
+      mimeType: "image/bmp",
+      width: dataView.getUint32(18, LITTLE_ENDIAN),
+      height: dataView.getUint32(22, LITTLE_ENDIAN)
+    };
+  }
+  function getJpegMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
+    if (!isJpeg) {
+      return null;
+    }
+    const {
+      tableMarkers,
+      sofMarkers
+    } = getJpegMarkers();
+    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(i2 + 5, BIG_ENDIAN),
+          // Number of lines
+          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+          // Number of pixels per line
+        };
+      }
+      if (!tableMarkers.has(marker)) {
+        return null;
+      }
+      i2 += 2;
+      i2 += dataView.getUint16(i2, BIG_ENDIAN);
+    }
+    return null;
+  }
+  function getJpegMarkers() {
+    const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]);
+    for (let i2 = 65504; i2 < 65520; ++i2) {
+      tableMarkers.add(i2);
+    }
+    const sofMarkers = /* @__PURE__ */ new Set([65472, 65473, 65474, 65475, 65477, 65478, 65479, 65481, 65482, 65483, 65485, 65486, 65487, 65502]);
+    return {
+      tableMarkers,
+      sofMarkers
+    };
+  }
+  function toDataView(data) {
+    if (data instanceof DataView) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new DataView(data.buffer);
+    }
+    if (data instanceof ArrayBuffer) {
+      return new DataView(data);
+    }
+    throw new Error("toDataView");
+  }
+
+  // ../images/src/lib/parsers/parse-to-node-image.ts
+  async function parseToNodeImage(arrayBuffer, options) {
+    const {
+      mimeType
+    } = getBinaryImageMetadata(arrayBuffer) || {};
+    const _parseImageNode2 = globalThis._parseImageNode;
+    assert(_parseImageNode2);
+    return await _parseImageNode2(arrayBuffer, mimeType);
+  }
+
+  // ../images/src/lib/parsers/parse-image.ts
+  async function parseImage(arrayBuffer, options, context) {
+    options = options || {};
+    const imageOptions = options.image || {};
+    const imageType = imageOptions.type || "auto";
+    const {
+      url
+    } = context || {};
+    const loadType = getLoadableImageType(imageType);
+    let image;
+    switch (loadType) {
+      case "imagebitmap":
+        image = await parseToImageBitmap(arrayBuffer, options, url);
+        break;
+      case "image":
+        image = await parseToImage(arrayBuffer, options, url);
+        break;
+      case "data":
+        image = await parseToNodeImage(arrayBuffer, options);
+        break;
+      default:
+        assert(false);
+    }
+    if (imageType === "data") {
+      image = getImageData(image);
+    }
+    return image;
+  }
+  function getLoadableImageType(type) {
+    switch (type) {
+      case "auto":
+      case "data":
+        return getDefaultImageType();
+      default:
+        isImageTypeSupported(type);
+        return type;
+    }
+  }
+
+  // ../images/src/image-loader.ts
+  var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
+  var MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp", "image/vnd.microsoft.icon", "image/svg+xml"];
+  var DEFAULT_IMAGE_LOADER_OPTIONS = {
+    image: {
+      type: "auto",
+      decode: true
+      // if format is HTML
+    }
+    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
+  };
+  var ImageLoader = {
+    id: "image",
+    module: "images",
+    name: "Images",
+    version: VERSION3,
+    mimeTypes: MIME_TYPES,
+    extensions: EXTENSIONS,
+    parse: parseImage,
+    // TODO: byteOffset, byteLength;
+    tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+    options: DEFAULT_IMAGE_LOADER_OPTIONS
+  };
+
+  // src/mvt-source.ts
+  var MVTSource = class extends DataSource {
+    schema = "tms";
+    constructor(props) {
+      super(props);
+      this.props = props;
+      this.url = resolvePath(props.url);
+      this.getTileData = this.getTileData.bind(this);
+      this.metadata = this.getMetadata();
+    }
+    // @ts-ignore - Metadata type misalignment
+    async getMetadata() {
+      const metadataUrl = this.getMetadataUrl();
+      const response = await this.fetch(metadataUrl);
+      if (!response.ok) {
+        return null;
+      }
+      const tileJSON = await response.text();
+      const metadata = TileJSONLoader.parseTextSync?.(JSON.stringify(tileJSON)) || null;
+      return metadata;
+    }
+    async getTile(tileParams) {
+      const {
+        x: x2,
+        y: y2,
+        zoom: z
+      } = tileParams;
+      const tileUrl = this.getTileURL(x2, y2, z);
+      const response = await this.fetch(tileUrl);
+      if (!response.ok) {
+        return null;
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return arrayBuffer;
+    }
+    // Tile Source interface implementation: deck.gl compatible API
+    // TODO - currently only handles image tiles, not vector tiles
+    async getTileData(tileParams) {
+      const {
+        x: x2,
+        y: y2,
+        z
+      } = tileParams.index;
+      const metadata = await this.metadata;
+      switch (metadata.mimeType || "application/vnd.mapbox-vector-tile") {
+        case "application/vnd.mapbox-vector-tile":
+          return await this.getVectorTile({
+            x: x2,
+            y: y2,
+            zoom: z,
+            layers: []
+          });
+        default:
+          return await this.getImageTile({
+            x: x2,
+            y: y2,
+            zoom: z,
+            layers: []
+          });
+      }
+    }
+    // ImageTileSource interface implementation
+    async getImageTile(tileParams) {
+      const arrayBuffer = await this.getTile(tileParams);
+      return arrayBuffer ? await ImageLoader.parse(arrayBuffer, this.loadOptions) : null;
+    }
+    // VectorTileSource interface implementation
+    async getVectorTile(tileParams) {
+      const arrayBuffer = await this.getTile(tileParams);
+      const loadOptions = {
+        shape: "geojson-table",
+        mvt: {
+          coordinates: "wgs84",
+          tileIndex: {
+            x: tileParams.x,
+            y: tileParams.y,
+            z: tileParams.zoom
+          },
+          ...this.loadOptions?.mvt
+        },
+        ...this.loadOptions
       };
+      return arrayBuffer ? await MVTLoader.parse(arrayBuffer, loadOptions) : null;
     }
-  });
+    getMetadataUrl() {
+      return `${this.url}/tilejson.json`;
+    }
+    getTileURL(x2, y2, z) {
+      switch (this.schema) {
+        case "xyz":
+          return `${this.url}/${x2}/${y2}/${z}`;
+        case "tms":
+        default:
+          return `${this.url}/${z}/${x2}/${y2}`;
+      }
+    }
+  };
 
   // src/lib/geojson-tiler/simplify.ts
   function simplify(coords, first, last, sqTolerance) {
@@ -2583,14 +3222,11 @@
     dy = py - y2;
     return dx * dx + dy * dy;
   }
-  var init_simplify = __esm({
-    "src/lib/geojson-tiler/simplify.ts"() {
-    }
-  });
 
   // src/lib/geojson-tiler/feature.ts
   function createFeature(id, type, geom, tags) {
     const feature = {
+      // eslint-disable-next-line
       id: id == null ? null : id,
       type,
       geometry: geom,
@@ -2623,10 +3259,6 @@
       feature.maxY = Math.max(feature.maxY, geom[i2 + 1]);
     }
   }
-  var init_feature = __esm({
-    "src/lib/geojson-tiler/feature.ts"() {
-    }
-  });
 
   // src/lib/geojson-tiler/convert.ts
   function convert(data, options) {
@@ -2638,7 +3270,9 @@
     } else if (data.type === "Feature") {
       convertFeature(features, data, options);
     } else {
-      convertFeature(features, { geometry: data }, options);
+      convertFeature(features, {
+        geometry: data
+      }, options);
     }
     return features;
   }
@@ -2740,12 +3374,6 @@
     const y22 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
     return y22 < 0 ? 0 : y22 > 1 ? 1 : y22;
   }
-  var init_convert = __esm({
-    "src/lib/geojson-tiler/convert.ts"() {
-      init_simplify();
-      init_feature();
-    }
-  });
 
   // src/lib/geojson-tiler/clip.ts
   function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
@@ -2911,11 +3539,6 @@
     addPoint(out, ax + (bx - ax) * t, y2, 1);
     return t;
   }
-  var init_clip = __esm({
-    "src/lib/geojson-tiler/clip.ts"() {
-      init_feature();
-    }
-  });
 
   // src/lib/geojson-tiler/wrap.ts
   function wrap(features, options) {
@@ -2973,12 +3596,6 @@
     }
     return newPoints;
   }
-  var init_wrap = __esm({
-    "src/lib/geojson-tiler/wrap.ts"() {
-      init_clip();
-      init_feature();
-    }
-  });
 
   // src/lib/geojson-tiler/transform.ts
   function transformTile(tile, extent) {
@@ -3012,10 +3629,6 @@
   function transformPoint(x2, y2, extent, z2, tx, ty) {
     return [Math.round(extent * (x2 * z2 - tx)), Math.round(extent * (y2 * z2 - ty))];
   }
-  var init_transform = __esm({
-    "src/lib/geojson-tiler/transform.ts"() {
-    }
-  });
 
   // src/lib/geojson-tiler/tile.ts
   function createTile(features, z, tx, ty, options) {
@@ -3122,207 +3735,213 @@
       }
     }
   }
-  var init_tile = __esm({
-    "src/lib/geojson-tiler/tile.ts"() {
-    }
-  });
 
   // src/lib/geojson-tiler/geojson-tiler.ts
-  function toID(z, x2, y2) {
-    return ((1 << z) * y2 + x2) * 32 + z;
-  }
-  var DEFAULT_OPTIONS, GeoJSONTiler;
-  var init_geojson_tiler = __esm({
-    "src/lib/geojson-tiler/geojson-tiler.ts"() {
-      init_convert();
-      init_clip();
-      init_wrap();
-      init_transform();
-      init_tile();
-      DEFAULT_OPTIONS = {
-        maxZoom: 14,
-        indexMaxZoom: 5,
-        indexMaxPoints: 1e5,
-        tolerance: 3,
-        extent: 4096,
-        buffer: 64,
-        lineMetrics: false,
-        promoteId: void 0,
-        generateId: false,
-        debug: 0
+  var DEFAULT_OPTIONS = {
+    maxZoom: 14,
+    // max zoom to preserve detail on
+    indexMaxZoom: 5,
+    // max zoom in the tile index
+    indexMaxPoints: 1e5,
+    // max number of points per tile in the tile index
+    tolerance: 3,
+    // simplification tolerance (higher means simpler)
+    extent: 4096,
+    // tile extent
+    buffer: 64,
+    // tile buffer on each side
+    lineMetrics: false,
+    // whether to calculate line metrics
+    // @ts-expect-error Ensures all these required params have defaults
+    promoteId: void 0,
+    // name of a feature property to be promoted to feature.id
+    generateId: false,
+    // whether to generate feature ids. Cannot be used with promoteId
+    debug: 0
+    // logging level (0, 1 or 2)
+  };
+  var GeoJSONTiler = class {
+    // tiles and tileCoords are part of the public API
+    tiles = {};
+    tileCoords = [];
+    stats = {};
+    total = 0;
+    constructor(data, options) {
+      this.options = {
+        ...DEFAULT_OPTIONS,
+        ...options
       };
-      GeoJSONTiler = class {
-        constructor(data, options) {
-          this.tiles = {};
-          this.tileCoords = [];
-          this.stats = {};
-          this.total = 0;
-          this.options = { ...DEFAULT_OPTIONS, ...options };
-          options = this.options;
-          const debug = options.debug;
-          if (debug)
-            console.time("preprocess data");
-          if (this.options.maxZoom < 0 || this.options.maxZoom > 24) {
-            throw new Error("maxZoom should be in the 0-24 range");
-          }
-          if (options.promoteId && this.options.generateId) {
-            throw new Error("promoteId and generateId cannot be used together.");
-          }
-          let features = convert(data, options);
-          if (debug) {
-            console.timeEnd("preprocess data");
-            console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
-            console.time("generate tiles");
-          }
-          features = wrap(features, this.options);
-          if (features.length) {
-            this.splitTile(features, 0, 0, 0);
+      options = this.options;
+      const debug = options.debug;
+      if (debug)
+        console.time("preprocess data");
+      if (this.options.maxZoom < 0 || this.options.maxZoom > 24) {
+        throw new Error("maxZoom should be in the 0-24 range");
+      }
+      if (options.promoteId && this.options.generateId) {
+        throw new Error("promoteId and generateId cannot be used together.");
+      }
+      let features = convert(data, options);
+      if (debug) {
+        console.timeEnd("preprocess data");
+        console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
+        console.time("generate tiles");
+      }
+      features = wrap(features, this.options);
+      if (features.length) {
+        this.splitTile(features, 0, 0, 0);
+      }
+      if (debug) {
+        if (features.length) {
+          console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
+        }
+        console.timeEnd("generate tiles");
+        console.log("tiles generated:", this.total, JSON.stringify(this.stats));
+      }
+    }
+    /**
+     * Get a tile at the specified index
+     * @param z
+     * @param x
+     * @param y
+     * @returns
+     */
+    // eslint-disable-next-line complexity, max-statements
+    getTile(z, x2, y2) {
+      const {
+        extent,
+        debug
+      } = this.options;
+      if (z < 0 || z > 24) {
+        return null;
+      }
+      const z2 = 1 << z;
+      x2 = x2 + z2 & z2 - 1;
+      const id = toID(z, x2, y2);
+      if (this.tiles[id]) {
+        return transformTile(this.tiles[id], extent);
+      }
+      if (debug > 1)
+        console.log("drilling down to z%d-%d-%d", z, x2, y2);
+      let z0 = z;
+      let x0 = x2;
+      let y0 = y2;
+      let parent;
+      while (!parent && z0 > 0) {
+        z0--;
+        x0 = x0 >> 1;
+        y0 = y0 >> 1;
+        parent = this.tiles[toID(z0, x0, y0)];
+      }
+      if (!parent || !parent.source) {
+        return null;
+      }
+      if (debug > 1) {
+        console.log("found parent tile z%d-%d-%d", z0, x0, y0);
+        console.time("drilling down");
+      }
+      this.splitTile(parent.source, z0, x0, y0, z, x2, y2);
+      if (debug > 1) {
+        console.timeEnd("drilling down");
+      }
+      return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
+    }
+    /**
+     * splits features from a parent tile to sub-tiles.
+     * @param z, x, and y are the coordinates of the parent tile
+     * @param cz, cx, and cy are the coordinates of the target tile
+     *
+     * If no target tile is specified, splitting stops when we reach the maximum
+     * zoom or the number of points is low as specified in the options.
+     */
+    // eslint-disable-next-line max-params, max-statements, complexity
+    splitTile(features, z, x2, y2, cz, cx, cy) {
+      const stack = [features, z, x2, y2];
+      const options = this.options;
+      const debug = options.debug;
+      while (stack.length) {
+        y2 = stack.pop();
+        x2 = stack.pop();
+        z = stack.pop();
+        features = stack.pop();
+        const z2 = 1 << z;
+        const id = toID(z, x2, y2);
+        let tile = this.tiles[id];
+        if (!tile) {
+          if (debug > 1) {
+            console.time("creation");
           }
+          tile = this.tiles[id] = createTile(features, z, x2, y2, options);
+          this.tileCoords.push({
+            z,
+            x: x2,
+            y: y2
+          });
           if (debug) {
-            if (features.length) {
-              console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
+            if (debug > 1) {
+              console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x2, y2, tile.numFeatures, tile.numPoints, tile.numSimplified);
+              console.timeEnd("creation");
             }
-            console.timeEnd("generate tiles");
-            console.log("tiles generated:", this.total, JSON.stringify(this.stats));
+            const key = `z${z}`;
+            this.stats[key] = (this.stats[key] || 0) + 1;
+            this.total++;
           }
         }
-        getTile(z, x2, y2) {
-          const { extent, debug } = this.options;
-          if (z < 0 || z > 24) {
-            return null;
-          }
-          const z2 = 1 << z;
-          x2 = x2 + z2 & z2 - 1;
-          const id = toID(z, x2, y2);
-          if (this.tiles[id]) {
-            return transformTile(this.tiles[id], extent);
-          }
-          if (debug > 1)
-            console.log("drilling down to z%d-%d-%d", z, x2, y2);
-          let z0 = z;
-          let x0 = x2;
-          let y0 = y2;
-          let parent;
-          while (!parent && z0 > 0) {
-            z0--;
-            x0 = x0 >> 1;
-            y0 = y0 >> 1;
-            parent = this.tiles[toID(z0, x0, y0)];
-          }
-          if (!parent || !parent.source) {
-            return null;
-          }
-          if (debug > 1) {
-            console.log("found parent tile z%d-%d-%d", z0, x0, y0);
-            console.time("drilling down");
-          }
-          this.splitTile(parent.source, z0, x0, y0, z, x2, y2);
-          if (debug > 1) {
-            console.timeEnd("drilling down");
-          }
-          return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
+        tile.source = features;
+        if (cz === void 0) {
+          if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints)
+            continue;
+        } else if (z === options.maxZoom || z === cz) {
+          continue;
+        } else if (cz !== void 0) {
+          const zoomSteps = cz - z;
+          if (x2 !== cx >> zoomSteps || y2 !== cy >> zoomSteps)
+            continue;
         }
-        splitTile(features, z, x2, y2, cz, cx, cy) {
-          const stack = [features, z, x2, y2];
-          const options = this.options;
-          const debug = options.debug;
-          while (stack.length) {
-            y2 = stack.pop();
-            x2 = stack.pop();
-            z = stack.pop();
-            features = stack.pop();
-            const z2 = 1 << z;
-            const id = toID(z, x2, y2);
-            let tile = this.tiles[id];
-            if (!tile) {
-              if (debug > 1) {
-                console.time("creation");
-              }
-              tile = this.tiles[id] = createTile(features, z, x2, y2, options);
-              this.tileCoords.push({ z, x: x2, y: y2 });
-              if (debug) {
-                if (debug > 1) {
-                  console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x2, y2, tile.numFeatures, tile.numPoints, tile.numSimplified);
-                  console.timeEnd("creation");
-                }
-                const key = `z${z}`;
-                this.stats[key] = (this.stats[key] || 0) + 1;
-                this.total++;
-              }
-            }
-            tile.source = features;
-            if (cz === void 0) {
-              if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints)
-                continue;
-            } else if (z === options.maxZoom || z === cz) {
-              continue;
-            } else if (cz !== void 0) {
-              const zoomSteps = cz - z;
-              if (x2 !== cx >> zoomSteps || y2 !== cy >> zoomSteps)
-                continue;
-            }
-            tile.source = null;
-            if (features.length === 0)
-              continue;
-            if (debug > 1)
-              console.time("clipping");
-            const k1 = 0.5 * options.buffer / options.extent;
-            const k2 = 0.5 - k1;
-            const k3 = 0.5 + k1;
-            const k4 = 1 + k1;
-            let tl = null;
-            let bl = null;
-            let tr = null;
-            let br = null;
-            let left = clip(features, z2, x2 - k1, x2 + k3, 0, tile.minX, tile.maxX, options);
-            let right = clip(features, z2, x2 + k2, x2 + k4, 0, tile.minX, tile.maxX, options);
-            features = null;
-            if (left) {
-              tl = clip(left, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
-              bl = clip(left, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
-              left = null;
-            }
-            if (right) {
-              tr = clip(right, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
-              br = clip(right, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
-              right = null;
-            }
-            if (debug > 1)
-              console.timeEnd("clipping");
-            stack.push(tl || [], z + 1, x2 * 2, y2 * 2);
-            stack.push(bl || [], z + 1, x2 * 2, y2 * 2 + 1);
-            stack.push(tr || [], z + 1, x2 * 2 + 1, y2 * 2);
-            stack.push(br || [], z + 1, x2 * 2 + 1, y2 * 2 + 1);
-          }
+        tile.source = null;
+        if (features.length === 0)
+          continue;
+        if (debug > 1)
+          console.time("clipping");
+        const k1 = 0.5 * options.buffer / options.extent;
+        const k2 = 0.5 - k1;
+        const k3 = 0.5 + k1;
+        const k4 = 1 + k1;
+        let tl = null;
+        let bl = null;
+        let tr = null;
+        let br = null;
+        let left = clip(features, z2, x2 - k1, x2 + k3, 0, tile.minX, tile.maxX, options);
+        let right = clip(features, z2, x2 + k2, x2 + k4, 0, tile.minX, tile.maxX, options);
+        features = null;
+        if (left) {
+          tl = clip(left, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
+          bl = clip(left, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+          left = null;
         }
-      };
-    }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    GeoJSONTiler: () => GeoJSONTiler,
-    MVTLoader: () => MVTLoader,
-    MVTWorkerLoader: () => MVTWorkerLoader,
-    TileJSONLoader: () => TileJSONLoader
-  });
-  var init_src2 = __esm({
-    "src/index.ts"() {
-      init_mvt_loader();
-      init_tilejson_loader();
-      init_geojson_tiler();
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src2(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
+        if (right) {
+          tr = clip(right, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
+          br = clip(right, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+          right = null;
+        }
+        if (debug > 1)
+          console.timeEnd("clipping");
+        stack.push(tl || [], z + 1, x2 * 2, y2 * 2);
+        stack.push(bl || [], z + 1, x2 * 2, y2 * 2 + 1);
+        stack.push(tr || [], z + 1, x2 * 2 + 1, y2 * 2);
+        stack.push(br || [], z + 1, x2 * 2 + 1, y2 * 2 + 1);
+      }
     }
-  });
-  require_bundle();
+  };
+  function toID(z, x2, y2) {
+    return ((1 << z) * y2 + x2) * 32 + z;
+  }
+  return __toCommonJS(src_exports);
 })();
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+/*! Bundled license information:
+
+ieee754/index.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/
+      return __exports__;
+      });