@loaders.gl/mvt 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/mvt-worker.js

@@ -757,413 +757,134 @@
     }
   });
 
-  // src/helpers/mapbox-util-functions.ts
-  function classifyRings(rings) {
-    const len = rings.length;
-    if (len <= 1)
-      return [rings];
-    const polygons = [];
-    let polygon;
-    let ccw;
-    for (let i2 = 0; i2 < len; i2++) {
-      const area2 = signedArea(rings[i2]);
-      if (area2 === 0)
-        continue;
-      if (ccw === void 0)
-        ccw = area2 < 0;
-      if (ccw === area2 < 0) {
-        if (polygon)
-          polygons.push(polygon);
-        polygon = [rings[i2]];
-      } else if (polygon)
-        polygon.push(rings[i2]);
-    }
-    if (polygon)
-      polygons.push(polygon);
-    return polygons;
-  }
-  function signedArea(ring) {
-    let sum = 0;
-    for (let i2 = 0, j = ring.length - 1, p1, p2; i2 < ring.length; j = i2++) {
-      p1 = ring[i2];
-      p2 = ring[j];
-      sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+  // ../../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 sum;
+    return area2 / 2;
   }
-  function readFeature(tag, feature, pbf) {
-    if (feature && pbf) {
-      if (tag === 1)
-        feature.id = pbf.readVarint();
-      else if (tag === 2)
-        readTag(pbf, feature);
-      else if (tag === 3)
-        feature.type = pbf.readVarint();
-      else if (tag === 4)
-        feature._geometry = pbf.pos;
+
+  // ../../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 readTag(pbf, feature) {
-    const end = pbf.readVarint() + pbf.pos;
-    while (pbf.pos < end) {
-      const key = feature._keys[pbf.readVarint()];
-      const value = feature._values[pbf.readVarint()];
-      feature.properties[key] = value;
+  function linkedList(data, start, end, dim, clockwise, area2) {
+    let i2;
+    let last;
+    if (area2 === void 0) {
+      area2 = getPolygonSignedArea(data, {
+        start,
+        end,
+        size: dim
+      });
     }
-  }
-
-  // src/lib/mapbox-vector-tile/vector-tile-feature.ts
-  var VectorTileFeature = class {
-    static get types() {
-      return ["Unknown", "Point", "LineString", "Polygon"];
+    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);
     }
-    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);
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
     }
-    loadGeometry() {
-      const pbf = this._pbf;
-      pbf.pos = this._geometry;
-      const end = pbf.readVarint() + pbf.pos;
-      let cmd2 = 1;
-      let length2 = 0;
-      let x2 = 0;
-      let y2 = 0;
-      const lines = [];
-      let line;
-      while (pbf.pos < end) {
-        if (length2 <= 0) {
-          const cmdLen2 = pbf.readVarint();
-          cmd2 = cmdLen2 & 7;
-          length2 = cmdLen2 >> 3;
-        }
-        length2--;
-        if (cmd2 === 1 || cmd2 === 2) {
-          x2 += pbf.readSVarint();
-          y2 += pbf.readSVarint();
-          if (cmd2 === 1) {
-            if (line)
-              lines.push(line);
-            line = [];
-          }
-          if (line)
-            line.push([x2, y2]);
-        } else if (cmd2 === 7) {
-          if (line) {
-            line.push(line[0].slice());
-          }
-        } else {
-          throw new Error(`unknown command ${cmd2}`);
-        }
+    return 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;
       }
-      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}`);
+    } 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);
         }
-      }
-      return [x1, y1, x22, y22];
-    }
-    _toGeoJSON(transform) {
-      let coords = this.loadGeometry();
-      let type = VectorTileFeature.types[this.type];
-      let i2;
-      let j;
-      switch (this.type) {
-        case 1:
-          const points = [];
-          for (i2 = 0; i2 < coords.length; i2++) {
-            points[i2] = coords[i2][0];
-          }
-          coords = points;
-          transform(coords, this);
-          break;
-        case 2:
-          for (i2 = 0; i2 < coords.length; i2++) {
-            transform(coords[i2], this);
-          }
-          break;
-        case 3:
-          coords = classifyRings(coords);
-          for (i2 = 0; i2 < coords.length; i2++) {
-            for (j = 0; j < coords[i2].length; j++) {
-              transform(coords[i2][j], this);
-            }
-          }
-          break;
-      }
-      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;
-    }
-    feature(i2) {
-      if (i2 < 0 || i2 >= this._features.length) {
-        throw new Error("feature index out of bounds");
-      }
-      this._pbf.pos = this._features[i2];
-      const end = this._pbf.readVarint() + this._pbf.pos;
-      return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
-    }
-  };
-  function readLayer(tag, layer, pbf) {
-    if (layer && pbf) {
-      if (tag === 15)
-        layer.version = pbf.readVarint();
-      else if (tag === 1)
-        layer.name = pbf.readString();
-      else if (tag === 5)
-        layer.extent = pbf.readVarint();
-      else if (tag === 2)
-        layer._features.push(pbf.pos);
-      else if (tag === 3)
-        layer._keys.push(pbf.readString());
-      else if (tag === 4)
-        layer._values.push(readValueMessage(pbf));
-    }
-  }
-  function readValueMessage(pbf) {
-    let value = null;
-    const end = pbf.readVarint() + pbf.pos;
-    while (pbf.pos < end) {
-      const tag = pbf.readVarint() >> 3;
-      value = tag === 1 ? pbf.readString() : tag === 2 ? pbf.readFloat() : tag === 3 ? pbf.readDouble() : tag === 4 ? pbf.readVarint64() : tag === 5 ? pbf.readVarint() : tag === 6 ? pbf.readSVarint() : tag === 7 ? pbf.readBoolean() : null;
-    }
-    return value;
-  }
-
-  // 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) {
-        const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
-        if (layer.length && layers) {
-          layers[layer.name] = layer;
-        }
-      }
-    }
-  }
-
-  // ../../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;
-  }
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
-  function earcut(data, holeIndices, dim, areas) {
-    dim = dim || 2;
-    const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-    let outerNode = linkedList(data, 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(data, holeIndices, outerNode, dim, areas);
-    if (data.length > 80 * dim) {
-      minX = maxX = data[0];
-      minY = maxY = data[1];
-      for (let i2 = dim; i2 < outerLen; i2 += dim) {
-        x2 = data[i2];
-        y2 = data[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;
+        break;
       }
     }
   }
@@ -1501,36 +1222,565 @@
       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;
+    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;
+  }
+
+  // ../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
+    });
+  }
+  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 } = 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),
+      triangles: [],
+      globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+      featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    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
+  }) {
+    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) {
+    return {
+      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 },
+        triangles: { value: new Uint32Array(polygons.triangles), size: 1 },
+        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
+        featureIds: { value: polygons.featureIds, size: 1 },
+        numericProps: wrapProps(polygons.numericProps, 1)
+      }
+    };
+  }
+  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 = __toModule(require_pbf());
+
+  // src/helpers/mapbox-util-functions.ts
+  function classifyRings(rings) {
+    const len = rings.length;
+    if (len <= 1)
+      return [rings];
+    const polygons = [];
+    let polygon;
+    let ccw;
+    for (let i2 = 0; i2 < len; i2++) {
+      const area2 = signedArea(rings[i2]);
+      if (area2 === 0)
+        continue;
+      if (ccw === void 0)
+        ccw = area2 < 0;
+      if (ccw === area2 < 0) {
+        if (polygon)
+          polygons.push(polygon);
+        polygon = [rings[i2]];
+      } else if (polygon)
+        polygon.push(rings[i2]);
+    }
+    if (polygon)
+      polygons.push(polygon);
+    return polygons;
+  }
+  function signedArea(ring) {
+    let sum = 0;
+    for (let i2 = 0, j = ring.length - 1, p1, p2; i2 < ring.length; j = i2++) {
+      p1 = ring[i2];
+      p2 = ring[j];
+      sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+    }
+    return sum;
+  }
+  function readFeature(tag, feature, pbf) {
+    if (feature && pbf) {
+      if (tag === 1)
+        feature.id = pbf.readVarint();
+      else if (tag === 2)
+        readTag(pbf, feature);
+      else if (tag === 3)
+        feature.type = pbf.readVarint();
+      else if (tag === 4)
+        feature._geometry = pbf.pos;
+    }
+  }
+  function readTag(pbf, feature) {
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+      const key = feature._keys[pbf.readVarint()];
+      const value = feature._values[pbf.readVarint()];
+      feature.properties[key] = value;
+    }
+  }
+
+  // src/lib/mapbox-vector-tile/vector-tile-feature.ts
+  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);
+    }
+    loadGeometry() {
+      const pbf = this._pbf;
+      pbf.pos = this._geometry;
+      const end = pbf.readVarint() + pbf.pos;
+      let cmd2 = 1;
+      let length2 = 0;
+      let x2 = 0;
+      let y2 = 0;
+      const lines = [];
+      let line;
+      while (pbf.pos < end) {
+        if (length2 <= 0) {
+          const cmdLen2 = pbf.readVarint();
+          cmd2 = cmdLen2 & 7;
+          length2 = cmdLen2 >> 3;
+        }
+        length2--;
+        if (cmd2 === 1 || cmd2 === 2) {
+          x2 += pbf.readSVarint();
+          y2 += pbf.readSVarint();
+          if (cmd2 === 1) {
+            if (line)
+              lines.push(line);
+            line = [];
+          }
+          if (line)
+            line.push([x2, y2]);
+        } else if (cmd2 === 7) {
+          if (line) {
+            line.push(line[0].slice());
+          }
+        } else {
+          throw new Error(`unknown command ${cmd2}`);
+        }
+      }
+      if (line)
+        lines.push(line);
+      return lines;
+    }
+    bbox() {
+      const pbf = this._pbf;
+      pbf.pos = this._geometry;
+      const end = pbf.readVarint() + pbf.pos;
+      let cmd2 = 1;
+      let length2 = 0;
+      let x2 = 0;
+      let y2 = 0;
+      let x1 = Infinity;
+      let x22 = -Infinity;
+      let y1 = Infinity;
+      let y22 = -Infinity;
+      while (pbf.pos < end) {
+        if (length2 <= 0) {
+          const cmdLen2 = pbf.readVarint();
+          cmd2 = cmdLen2 & 7;
+          length2 = cmdLen2 >> 3;
+        }
+        length2--;
+        if (cmd2 === 1 || cmd2 === 2) {
+          x2 += pbf.readSVarint();
+          y2 += pbf.readSVarint();
+          if (x2 < x1)
+            x1 = x2;
+          if (x2 > x22)
+            x22 = x2;
+          if (y2 < y1)
+            y1 = y2;
+          if (y2 > y22)
+            y22 = y2;
+        } else if (cmd2 !== 7) {
+          throw new Error(`unknown command ${cmd2}`);
+        }
+      }
+      return [x1, y1, x22, y22];
+    }
+    _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;
+    }
+    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;
+    }
+    feature(i2) {
+      if (i2 < 0 || i2 >= this._features.length) {
+        throw new Error("feature index out of bounds");
+      }
+      this._pbf.pos = this._features[i2];
+      const end = this._pbf.readVarint() + this._pbf.pos;
+      return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+    }
+  };
+  function readLayer(tag, layer, pbf) {
+    if (layer && pbf) {
+      if (tag === 15)
+        layer.version = pbf.readVarint();
+      else if (tag === 1)
+        layer.name = pbf.readString();
+      else if (tag === 5)
+        layer.extent = pbf.readVarint();
+      else if (tag === 2)
+        layer._features.push(pbf.pos);
+      else if (tag === 3)
+        layer._keys.push(pbf.readString());
+      else if (tag === 4)
+        layer._values.push(readValueMessage(pbf));
+    }
+  }
+  function readValueMessage(pbf) {
+    let value = null;
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+      const tag = pbf.readVarint() >> 3;
+      value = tag === 1 ? pbf.readString() : tag === 2 ? pbf.readFloat() : tag === 3 ? pbf.readDouble() : tag === 4 ? pbf.readVarint64() : tag === 5 ? pbf.readVarint() : tag === 6 ? pbf.readSVarint() : tag === 7 ? pbf.readBoolean() : null;
+    }
+    return value;
+  }
+
+  // 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) {
+        const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+        if (layer.length && layers) {
+          layers[layer.name] = layer;
+        }
+      }
+    }
   }
 
   // src/helpers/binary-util-functions.ts
   function classifyRings2(geom) {
-    const len = geom.lines.length;
+    const len = geom.indices.length;
+    const type = "Polygon";
     if (len <= 1) {
       return {
+        type,
         data: geom.data,
         areas: [[getPolygonSignedArea(geom.data)]],
-        lines: [geom.lines]
+        indices: [geom.indices]
       };
     }
     const areas = [];
@@ -1540,8 +1790,8 @@
     let ccw;
     let offset = 0;
     for (let endIndex, i2 = 0, startIndex; i2 < len; i2++) {
-      startIndex = geom.lines[i2] - offset;
-      endIndex = geom.lines[i2 + 1] - offset || geom.data.length;
+      startIndex = geom.indices[i2] - offset;
+      endIndex = geom.indices[i2 + 1] - offset || geom.data.length;
       const shape = geom.data.slice(startIndex, endIndex);
       const area2 = getPolygonSignedArea(shape);
       if (area2 === 0) {
@@ -1569,7 +1819,7 @@
       areas.push(ringAreas);
     if (polygon.length)
       polygons.push(polygon);
-    return { areas, lines: 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) {
@@ -1608,10 +1858,7 @@
   var y;
   var i;
   var VectorTileFeature2 = class {
-    static get types() {
-      return ["Unknown", "Point", "LineString", "Polygon"];
-    }
-    constructor(pbf, end, extent, keys, values, firstPassData) {
+    constructor(pbf, end, extent, keys, values, geometryInfo) {
       this.properties = {};
       this.extent = extent;
       this.type = 0;
@@ -1620,7 +1867,7 @@
       this._geometry = -1;
       this._keys = keys;
       this._values = values;
-      this._firstPassData = firstPassData;
+      this._geometryInfo = geometryInfo;
       pbf.readFields(readFeature2, this, end);
     }
     loadGeometry() {
@@ -1632,7 +1879,7 @@
       x = 0;
       y = 0;
       i = 0;
-      const lines = [];
+      const indices = [];
       const data = [];
       while (pbf.pos < endPos) {
         if (length <= 0) {
@@ -1645,13 +1892,13 @@
           x += pbf.readSVarint();
           y += pbf.readSVarint();
           if (cmd === 1) {
-            lines.push(i);
+            indices.push(i);
           }
           data.push(x, y);
           i += 2;
         } else if (cmd === 7) {
           if (i > 0) {
-            const start = lines[lines.length - 1];
+            const start = indices[indices.length - 1];
             data.push(data[start], data[start + 1]);
             i += 2;
           }
@@ -1659,42 +1906,38 @@
           throw new Error(`unknown command ${cmd}`);
         }
       }
-      return { data, lines };
+      return { data, indices };
     }
     _toBinaryCoordinates(transform) {
-      let geom = this.loadGeometry();
+      const geom = this.loadGeometry();
+      let geometry;
       transform(geom.data, this);
       const coordLength = 2;
       switch (this.type) {
         case 1:
-          this._firstPassData.pointFeaturesCount++;
-          this._firstPassData.pointPositionsCount += geom.lines.length;
+          this._geometryInfo.pointFeaturesCount++;
+          this._geometryInfo.pointPositionsCount += geom.indices.length;
+          geometry = { type: "Point", ...geom };
           break;
         case 2:
-          this._firstPassData.lineFeaturesCount++;
-          this._firstPassData.linePathsCount += geom.lines.length;
-          this._firstPassData.linePositionsCount += geom.data.length / coordLength;
+          this._geometryInfo.lineFeaturesCount++;
+          this._geometryInfo.linePathsCount += geom.indices.length;
+          this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+          geometry = { type: "LineString", ...geom };
           break;
         case 3:
-          const classified = classifyRings2(geom);
-          this._firstPassData.polygonFeaturesCount++;
-          this._firstPassData.polygonObjectsCount += classified.lines.length;
-          for (const lines of classified.lines) {
-            this._firstPassData.polygonRingsCount += lines.length;
+          geometry = classifyRings2(geom);
+          this._geometryInfo.polygonFeaturesCount++;
+          this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+          for (const indices of geometry.indices) {
+            this._geometryInfo.polygonRingsCount += indices.length;
           }
-          this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
-          geom = classified;
+          this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
           break;
+        default:
+          throw new Error(`Invalid geometry type: ${this.type}`);
       }
-      geom.type = VectorTileFeature2.types[this.type];
-      if (geom.lines.length > 1) {
-        geom.type = `Multi${geom.type}`;
-      }
-      const result = {
-        type: "Feature",
-        geometry: geom,
-        properties: this.properties
-      };
+      const result = { type: "Feature", geometry, properties: this.properties };
       if (this.id !== null) {
         result.id = this.id;
       }
@@ -1704,7 +1947,11 @@
       if (typeof options === "function") {
         return this._toBinaryCoordinates(options);
       }
-      return this._toBinaryCoordinates(project);
+      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));
     }
   };
 
@@ -1722,13 +1969,13 @@
       pbf.readFields(readLayer2, this, end);
       this.length = this._features.length;
     }
-    feature(i2, firstPassData) {
+    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, firstPassData);
+      return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
     }
   };
   function readLayer2(tag, layer, pbf) {
@@ -1774,313 +2021,111 @@
     }
   }
 
-  // src/lib/binary-vector-tile/features-to-binary.ts
-  function featuresToBinary(features, firstPassData, options) {
-    return fillArrays(features, firstPassData, {
-      numericPropKeys: options ? options.numericPropKeys : extractNumericPropKeys(features),
-      PositionDataType: options ? options.PositionDataType : Float32Array
-    });
-  }
-  function extractNumericPropKeys(features) {
-    const numericPropKeys = {};
-    for (const feature of features) {
-      if (feature.properties) {
-        for (const key in feature.properties) {
-          const numericSoFar = numericPropKeys[key];
-          if (numericSoFar || numericSoFar === void 0) {
-            const val = feature.properties[key];
-            numericPropKeys[key] = isNumeric(val);
-          }
-        }
-      }
-    }
-    return Object.keys(numericPropKeys).filter((k) => numericPropKeys[k]);
-  }
-  function fillArrays(features, firstPassData, options) {
-    const {
-      pointPositionsCount,
-      pointFeaturesCount,
-      linePositionsCount,
-      linePathsCount,
-      lineFeaturesCount,
-      polygonPositionsCount,
-      polygonObjectsCount,
-      polygonRingsCount,
-      polygonFeaturesCount
-    } = firstPassData;
-    const { numericPropKeys, PositionDataType = Float32Array } = options;
-    const hasGlobalId = features[0] && "id" in features[0];
-    const coordLength = 2;
-    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-    const points = {
-      positions: new PositionDataType(pointPositionsCount * coordLength),
-      globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-      featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
-      numericProps: {},
-      properties: [],
-      fields: []
-    };
-    const lines = {
-      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 = {
-      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),
-      triangles: [],
-      globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-      featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
-      numericProps: {},
-      properties: [],
-      fields: []
-    };
-    for (const object of [points, lines, polygons]) {
-      for (const propName of numericPropKeys) {
-        object.numericProps[propName] = new Float32Array(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":
-        case "MultiPoint":
-          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":
-        case "MultiLineString":
-          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":
-        case "MultiPolygon":
-          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.lines.length; i2 < il; ++i2) {
-      const start = geometry.lines[i2];
-      const end = i2 === il - 1 ? geometry.data.length : geometry.lines[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.lines.length; l < ll; ++l) {
-      const startPosition = indexMap.polygonPosition;
-      polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
-      const areas = geometry.areas[l];
-      const lines = geometry.lines[l];
-      const nextLines = geometry.lines[l + 1];
-      for (let i2 = 0, il = lines.length; i2 < il; ++i2) {
-        const start = lines[i2];
-        const end = i2 === il - 1 ? nextLines === void 0 ? geometry.data.length : nextLines[0] : lines[i2 + 1];
-        polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
-        indexMap.polygonPosition += (end - start) / coordLength;
+  // src/lib/parse-mvt.ts
+  function parseMVT(arrayBuffer, options) {
+    const mvtOptions = normalizeOptions(options);
+    const shape = options?.gis?.format || options?.mvt?.shape;
+    switch (shape) {
+      case "columnar-table":
+        return { shape: "columnar-table", data: parseToBinary(arrayBuffer, mvtOptions) };
+      case "geojson-row-table": {
+        const table = {
+          shape: "geojson-row-table",
+          data: parseToGeojson(arrayBuffer, mvtOptions)
+        };
+        return table;
       }
-      const endPosition = indexMap.polygonPosition;
-      triangulatePolygon(polygons, areas, lines, { startPosition, endPosition, coordLength });
+      case "geojson":
+        return parseToGeojson(arrayBuffer, mvtOptions);
+      case "binary-geometry":
+        return parseToBinary(arrayBuffer, mvtOptions);
+      case "binary":
+        return parseToBinary(arrayBuffer, mvtOptions);
+      default:
+        throw new Error(shape);
     }
   }
-  function triangulatePolygon(polygons, areas, lines, {
-    startPosition,
-    endPosition,
-    coordLength
-  }) {
-    const start = startPosition * coordLength;
-    const end = endPosition * coordLength;
-    const polygonPositions = polygons.positions.subarray(start, end);
-    const offset = lines[0];
-    const holes = lines.slice(1).map((n) => (n - offset) / coordLength);
-    const indices = earcut(polygonPositions, holes, coordLength, areas);
-    for (let t = 0, tl = indices.length; t < tl; ++t) {
-      polygons.triangles.push(startPosition + indices[t]);
-    }
+  function parseToBinary(arrayBuffer, options) {
+    const [flatGeoJsonFeatures, geometryInfo] = parseToFlatGeoJson(arrayBuffer, options);
+    const binaryData = flatGeojsonToBinary(flatGeoJsonFeatures, geometryInfo);
+    binaryData.byteLength = arrayBuffer.byteLength;
+    return binaryData;
   }
-  function makeAccessorObjects(points, lines, polygons, coordLength) {
-    const returnObj = {
-      points: {
-        ...points,
-        positions: { value: points.positions, size: coordLength },
-        globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-        featureIds: { value: points.featureIds, size: 1 }
-      },
-      lines: {
-        ...lines,
-        pathIndices: { value: lines.pathIndices, size: 1 },
-        positions: { value: lines.positions, size: coordLength },
-        globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-        featureIds: { value: lines.featureIds, size: 1 }
-      },
-      polygons: {
-        ...polygons,
-        polygonIndices: { value: polygons.polygonIndices, size: 1 },
-        primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
-        positions: { value: polygons.positions, size: coordLength },
-        triangles: { value: new Uint32Array(polygons.triangles), size: 1 },
-        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-        featureIds: { value: polygons.featureIds, size: 1 }
-      }
+  function parseToFlatGeoJson(arrayBuffer, options) {
+    const features = [];
+    const geometryInfo = {
+      coordLength: 2,
+      pointPositionsCount: 0,
+      pointFeaturesCount: 0,
+      linePositionsCount: 0,
+      linePathsCount: 0,
+      lineFeaturesCount: 0,
+      polygonPositionsCount: 0,
+      polygonObjectsCount: 0,
+      polygonRingsCount: 0,
+      polygonFeaturesCount: 0
     };
-    for (const geomType in returnObj) {
-      for (const numericProp in returnObj[geomType].numericProps) {
-        returnObj[geomType].numericProps[numericProp] = {
-          value: returnObj[geomType].numericProps[numericProp],
-          size: 1
-        };
-      }
+    if (arrayBuffer.byteLength <= 0) {
+      return [features, geometryInfo];
     }
-    return returnObj;
-  }
-  function fillNumericProperties(object, properties, index, length2) {
-    for (const numericPropName in object.numericProps) {
-      if (numericPropName in properties) {
-        object.numericProps[numericPropName].fill(properties[numericPropName], index, index + length2);
+    const tile = new VectorTile2(new import_pbf.default(arrayBuffer));
+    const selectedLayers = options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
+    selectedLayers.forEach((layerName) => {
+      const vectorTileLayer = tile.layers[layerName];
+      if (!vectorTileLayer) {
+        return;
       }
-    }
-  }
-  function keepStringProperties(properties, numericKeys) {
-    const props = {};
-    for (const key in properties) {
-      if (!numericKeys.includes(key)) {
-        props[key] = properties[key];
+      for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
+        const vectorTileFeature = vectorTileLayer.feature(i2, geometryInfo);
+        const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
+        features.push(decodedFeature);
       }
-    }
-    return props;
-  }
-  function isNumeric(x2) {
-    return Number.isFinite(x2);
+    });
+    return [features, geometryInfo];
   }
-
-  // src/lib/parse-mvt.ts
-  var import_pbf = __toModule(require_pbf());
-  function parseMVT(arrayBuffer, options) {
-    options = normalizeOptions(options);
+  function parseToGeojson(arrayBuffer, options) {
+    if (arrayBuffer.byteLength <= 0) {
+      return [];
+    }
     const features = [];
-    if (options) {
-      const binary = options.gis.format === "binary";
-      const firstPassData = {
-        pointPositionsCount: 0,
-        pointFeaturesCount: 0,
-        linePositionsCount: 0,
-        linePathsCount: 0,
-        lineFeaturesCount: 0,
-        polygonPositionsCount: 0,
-        polygonObjectsCount: 0,
-        polygonRingsCount: 0,
-        polygonFeaturesCount: 0
-      };
-      if (arrayBuffer.byteLength > 0) {
-        const tile = binary ? new VectorTile2(new import_pbf.default(arrayBuffer)) : new VectorTile(new import_pbf.default(arrayBuffer));
-        const loaderOptions = options.mvt;
-        const selectedLayers = Array.isArray(loaderOptions.layers) ? loaderOptions.layers : Object.keys(tile.layers);
-        selectedLayers.forEach((layerName) => {
-          const vectorTileLayer = tile.layers[layerName];
-          const featureOptions = { ...loaderOptions, layerName };
-          if (!vectorTileLayer) {
-            return;
-          }
-          for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
-            const vectorTileFeature = vectorTileLayer.feature(i2, firstPassData);
-            const decodedFeature = binary ? getDecodedFeatureBinary(vectorTileFeature, featureOptions) : getDecodedFeature(vectorTileFeature, featureOptions);
-            features.push(decodedFeature);
-          }
-        });
-      }
-      if (binary) {
-        const data = featuresToBinary(features, firstPassData);
-        data.byteLength = arrayBuffer.byteLength;
-        return data;
+    const tile = new VectorTile(new import_pbf.default(arrayBuffer));
+    const selectedLayers = Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
+    selectedLayers.forEach((layerName) => {
+      const vectorTileLayer = tile.layers[layerName];
+      if (!vectorTileLayer) {
+        return;
+      }
+      for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
+        const vectorTileFeature = vectorTileLayer.feature(i2);
+        const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
+        features.push(decodedFeature);
       }
-    }
+    });
     return features;
   }
   function normalizeOptions(options) {
-    if (options) {
-      options = {
-        ...options,
-        mvt: options.mvt || {},
-        gis: options.gis || {}
-      };
-      const wgs84Coordinates = options.coordinates === "wgs84";
-      const { tileIndex } = options;
-      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. Check documentation.");
-      }
+    if (!options?.mvt) {
+      throw new Error("mvt options required");
     }
-    return options;
+    const wgs84Coordinates = options.mvt?.coordinates === "wgs84";
+    const { tileIndex } = options.mvt;
+    const hasTileIndex = tileIndex && Number.isFinite(tileIndex.x) && Number.isFinite(tileIndex.y) && Number.isFinite(tileIndex.z);
+    if (wgs84Coordinates && !hasTileIndex) {
+      throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
+    }
+    return options.mvt;
   }
-  function getDecodedFeature(feature, options) {
+  function getDecodedFeature(feature, options, layerName) {
     const decodedFeature = feature.toGeoJSON(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates);
     if (options.layerProperty) {
-      decodedFeature.properties[options.layerProperty] = options.layerName;
+      decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
-  function getDecodedFeatureBinary(feature, options) {
+  function getDecodedFeatureBinary(feature, options, layerName) {
     const decodedFeature = feature.toBinaryCoordinates(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary);
-    if (options.layerProperty) {
-      decodedFeature.properties[options.layerProperty] = options.layerName;
+    if (options.layerProperty && decodedFeature.properties) {
+      decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
@@ -2100,7 +2145,16 @@
   }
 
   // src/mvt-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION = true ? "4.0.0-alpha.11" : "latest";
+  var DEFAULT_MVT_LOADER_OPTIONS = {
+    mvt: {
+      shape: "geojson",
+      coordinates: "local",
+      layerProperty: "layerName",
+      layers: void 0,
+      tileIndex: null
+    }
+  };
   var MVTWorkerLoader = {
     name: "Mapbox Vector Tile",
     id: "mvt",
@@ -2113,14 +2167,7 @@
     ],
     worker: true,
     category: "geometry",
-    options: {
-      mvt: {
-        coordinates: "local",
-        layerProperty: "layerName",
-        layers: null,
-        tileIndex: null
-      }
-    }
+    options: DEFAULT_MVT_LOADER_OPTIONS
   };
   var MVTLoader = {
     ...MVTWorkerLoader,
@@ -2165,16 +2212,33 @@
   }
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage);
@@ -2183,22 +2247,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage);
       onMessageWrapperMap.delete(onMessage);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -2210,19 +2288,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });