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

package/dist/mvt-worker.js

@@ -1,3 +1,4 @@
+"use strict";
 (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
@@ -5,21 +6,25 @@
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
   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 __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
+  ));
 
   // ../../node_modules/ieee754/index.js
   var require_ieee754 = __commonJS({
@@ -128,6 +133,7 @@
         destroy: function() {
           this.buf = null;
         },
+        // === READING =================================================================
         readFields: function(readField, result, end) {
           end = end || this.length;
           while (this.pos < end) {
@@ -152,6 +158,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;
@@ -218,6 +225,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));
@@ -313,6 +321,7 @@
           else
             throw new Error("Unimplemented type: " + type);
         },
+        // === WRITING =================================================================
         writeTag: function(tag, type) {
           this.writeVarint(tag << 3 | type);
         },
@@ -757,26 +766,80 @@
     }
   });
 
-  // ../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js
+  // ../../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
+      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] - points[j]) * (points[i2 + 1] + points[j + 1]);
+      area2 += (points[i2 + i0] - points[j + i0]) * (points[i2 + i1] + points[j + i1]);
       j = i2;
     }
     return area2 / 2;
   }
 
-  // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
-  function earcut(positions, holeIndices, dim = 2, areas) {
+  // ../../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]);
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
     const triangles = [];
     if (!outerNode || outerNode.next === outerNode.prev)
       return triangles;
@@ -788,7 +851,7 @@
     let x2;
     let y2;
     if (hasHoles)
-      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
     if (positions.length > 80 * dim) {
       minX = maxX = positions[0];
       minY = maxY = positions[1];
@@ -805,27 +868,30 @@
           maxY = y2;
       }
       invSize = Math.max(maxX - minX, maxY - minY);
-      invSize = invSize !== 0 ? 1 / invSize : 0;
+      invSize = invSize !== 0 ? 32767 / invSize : 0;
     }
-    earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
     return triangles;
   }
-  function linkedList(data, start, end, dim, clockwise, area2) {
+  function linkedList(data, start, end, dim, clockwise, area2, plane) {
     let i2;
     let last;
     if (area2 === void 0) {
       area2 = getPolygonSignedArea(data, {
         start,
         end,
-        size: dim
+        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], data[i2 + 1], last);
+        last = insertNode(i2, data[i2 + i0], data[i2 + i1], last);
     } else {
       for (i2 = end - dim; i2 >= start; i2 -= dim)
-        last = insertNode(i2, data[i2], data[i2 + 1], last);
+        last = insertNode(i2, data[i2 + i0], data[i2 + i1], last);
     }
     if (last && equals(last, last.next)) {
       removeNode(last);
@@ -866,9 +932,9 @@
       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);
+        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;
@@ -894,9 +960,19 @@
     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)
+    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;
     }
@@ -908,29 +984,35 @@
     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);
+    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 !== 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)
+      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 !== 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)
+      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 !== 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)
+      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 !== 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)
+      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;
     }
@@ -942,9 +1024,9 @@
       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);
+        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;
@@ -962,8 +1044,8 @@
           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);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
           return;
         }
         b = b.next;
@@ -971,7 +1053,7 @@
       a = a.next;
     } while (a !== start);
   }
-  function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
+  function eliminateHoles(data, holeIndices, outerNode, dim, areas, plane) {
     const queue = [];
     let i2;
     let len;
@@ -981,15 +1063,14 @@
     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]);
+      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++) {
-      eliminateHole(queue[i2], outerNode);
-      outerNode = filterPoints(outerNode, outerNode.next);
+      outerNode = eliminateHole(queue[i2], outerNode);
     }
     return outerNode;
   }
@@ -997,12 +1078,13 @@
     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);
+    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;
@@ -1015,21 +1097,15 @@
         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;
+          if (x2 === hx)
+            return m;
         }
       }
       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;
@@ -1054,7 +1130,7 @@
   function indexCurve(start, minX, minY, invSize) {
     let p = start;
     do {
-      if (p.z === null)
+      if (p.z === 0)
         p.z = zOrder(p.x, p.y, minX, minY, invSize);
       p.prevZ = p.prev;
       p.nextZ = p.next;
@@ -1115,8 +1191,8 @@
     return list;
   }
   function zOrder(x2, y2, minX, minY, invSize) {
-    x2 = 32767 * (x2 - minX) * invSize;
-    y2 = 32767 * (y2 - 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;
@@ -1138,7 +1214,7 @@
     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;
+    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);
@@ -1197,8 +1273,8 @@
     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 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;
@@ -1212,7 +1288,7 @@
     return b2;
   }
   function insertNode(i2, x2, y2, last) {
-    const p = new Node(i2, x2, y2);
+    const p = new Vertex(i2, x2, y2);
     if (!last) {
       p.prev = p;
       p.next = p;
@@ -1232,30 +1308,39 @@
     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 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
-    });
+    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 = {};
@@ -1379,16 +1464,32 @@
     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);
+    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);
+    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];
@@ -1400,8 +1501,16 @@
     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);
+    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;
@@ -1410,7 +1519,10 @@
       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];
+        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;
       }
@@ -1469,6 +1581,7 @@
         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 };
@@ -1500,7 +1613,7 @@
   }
 
   // src/lib/parse-mvt.ts
-  var import_pbf = __toModule(require_pbf());
+  var import_pbf = __toESM(require_pbf(), 1);
 
   // src/helpers/mapbox-util-functions.ts
   function classifyRings(rings) {
@@ -1573,6 +1686,7 @@
       this._values = values;
       pbf.readFields(readFeature, this, end);
     }
+    // eslint-disable-next-line complexity, max-statements
     loadGeometry() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
@@ -1612,6 +1726,7 @@
         lines.push(line);
       return lines;
     }
+    // eslint-disable-next-line max-statements
     bbox() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
@@ -1728,6 +1843,11 @@
       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");
@@ -1867,6 +1987,7 @@
   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;
@@ -1879,6 +2000,7 @@
       this._geometryInfo = geometryInfo;
       pbf.readFields(readFeature2, this, end);
     }
+    // eslint-disable-next-line complexity, max-statements
     loadGeometry() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
@@ -1917,6 +2039,11 @@
       }
       return { data, indices };
     }
+    /**
+     *
+     * @param transform
+     * @returns result
+     */
     _toBinaryCoordinates(transform) {
       const geom = this.loadGeometry();
       let geometry;
@@ -1978,13 +2105,27 @@
       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);
+      return new VectorTileFeature2(
+        this._pbf,
+        end,
+        this.extent,
+        this._keys,
+        this._values,
+        geometryInfo
+      );
     }
   };
   function readLayer2(tag, layer, pbf) {
@@ -2126,14 +2267,20 @@
     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;
     }
@@ -2155,16 +2302,19 @@
   }
 
   // src/mvt-loader.ts
-  var VERSION = true ? "4.0.0-beta.2" : "latest";
+  var VERSION = true ? "4.0.0-beta.4" : "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",
@@ -2187,7 +2337,7 @@
 
   // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
   function getTransferList(object, recursive = true, transfers) {
-    const transfersSet = transfers || new Set();
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
     if (!object) {
     } else if (isTransferable(object)) {
       transfersSet.add(object);
@@ -2230,11 +2380,15 @@
     }
     return parentPort;
   }
-  var onMessageWrapperMap = new Map();
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
   var WorkerBody = class {
+    /** Check that we are actually in a worker thread */
     static inWorkerThread() {
       return typeof self !== "undefined" || Boolean(getParentPort());
     }
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
     static set onmessage(onMessage) {
       function handleMessage(message) {
         const parentPort3 = getParentPort();
@@ -2278,6 +2432,11 @@
         globalThis.removeEventListener("message", onMessageWrapper);
       }
     }
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
     static postMessage(type, payload) {
       const data = { source: "loaders.gl", type, payload };
       const transferList = getTransferList(payload);
@@ -2309,6 +2468,7 @@
               loader,
               arrayBuffer: input,
               options,
+              // @ts-expect-error fetch missing
               context: {
                 ...context,
                 _parse: parseOnMainThread
@@ -2377,4 +2537,8 @@
   // src/workers/mvt-worker.ts
   createLoaderWorker(MVTLoader);
 })();
-/*! 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> *)
+*/