@loaders.gl/tiles 5.0.0-alpha.11 → 5.0.0-alpha.13

package/dist/mvt/mvt-geojson-loader.cjs

@@ -0,0 +1,1366 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mvt/lib/utils/geometry-utils.ts
+function signedArea2(ring) {
+  let sum = 0;
+  for (let i = 0, j = ring.length - 1, p1, p2; i < ring.length; j = i++) {
+    p1 = ring[i];
+    p2 = ring[j];
+    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+  }
+  return sum;
+}
+function convertToLocalCoordinates2(coordinates, extent) {
+  if (Array.isArray(coordinates[0])) {
+    for (const subcoords of coordinates) {
+      convertToLocalCoordinates2(subcoords, extent);
+    }
+    return;
+  }
+  const p = coordinates;
+  p[0] /= extent;
+  p[1] /= extent;
+}
+function convertToLocalCoordinatesFlat2(data, extent) {
+  for (let i = 0; i < data.length; ++i) {
+    data[i] /= extent;
+  }
+}
+function projectToLngLat2(line, tileIndex, extent) {
+  if (typeof line[0] === "number") {
+    projectToLngLat2([line], tileIndex, extent);
+    return;
+  }
+  if (typeof line[0][0] !== "number") {
+    for (const point of line) {
+      projectToLngLat2(point, tileIndex, extent);
+    }
+    return;
+  }
+  const size = extent * Math.pow(2, tileIndex.z);
+  const x0 = extent * tileIndex.x;
+  const y0 = extent * tileIndex.y;
+  for (let j = 0; j < line.length; j++) {
+    const p = line[j];
+    p[0] = (p[0] + x0) * 360 / size - 180;
+    const y2 = 180 - (p[1] + y0) * 360 / size;
+    p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+}
+function projectToLngLatFlat2(data, tileIndex, extent) {
+  const { x, y, z } = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+  for (let j = 0, jl = data.length; j < jl; j += 2) {
+    data[j] = (data[j] + x0) * 360 / size - 180;
+    const y2 = 180 - (data[j + 1] + y0) * 360 / size;
+    data[j + 1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+}
+function classifyRings2(rings) {
+  const len = rings.length;
+  if (len <= 1) return [rings];
+  const polygons = [];
+  let polygon;
+  let ccw;
+  for (let i = 0; i < len; i++) {
+    const area = signedArea2(rings[i]);
+    if (area === 0) continue;
+    if (ccw === void 0) ccw = area < 0;
+    if (ccw === area < 0) {
+      if (polygon) polygons.push(polygon);
+      polygon = [rings[i]];
+    } else if (polygon) polygon.push(rings[i]);
+  }
+  if (polygon) polygons.push(polygon);
+  return polygons;
+}
+function classifyRingsFlat2(geom) {
+  const len = geom.indices.length;
+  const type = "Polygon";
+  if (len <= 1) {
+    return {
+      type,
+      data: geom.data,
+      areas: [[(0, import_polygon2.getPolygonSignedArea)(geom.data)]],
+      indices: [geom.indices]
+    };
+  }
+  const areas = [];
+  const polygons = [];
+  let ringAreas = [];
+  let polygon = [];
+  let ccw;
+  let offset = 0;
+  for (let endIndex, i = 0, startIndex; i < len; i++) {
+    startIndex = geom.indices[i] - offset;
+    endIndex = geom.indices[i + 1] - offset || geom.data.length;
+    const shape = geom.data.slice(startIndex, endIndex);
+    const area = (0, import_polygon2.getPolygonSignedArea)(shape);
+    if (area === 0) {
+      const before = geom.data.slice(0, startIndex);
+      const after = geom.data.slice(endIndex);
+      geom.data = before.concat(after);
+      offset += endIndex - startIndex;
+      continue;
+    }
+    if (ccw === void 0) ccw = area < 0;
+    if (ccw === area < 0) {
+      if (polygon.length) {
+        areas.push(ringAreas);
+        polygons.push(polygon);
+      }
+      polygon = [startIndex];
+      ringAreas = [area];
+    } else {
+      ringAreas.push(area);
+      polygon.push(startIndex);
+    }
+  }
+  if (ringAreas) areas.push(ringAreas);
+  if (polygon.length) polygons.push(polygon);
+  return { type, areas, indices: polygons, data: geom.data };
+}
+var import_polygon2;
+var init_geometry_utils = __esm({
+  "src/mvt/lib/utils/geometry-utils.ts"() {
+    "use strict";
+    import_polygon2 = require("@math.gl/geometry/polygon");
+  }
+});
+
+// src/mvt/lib/vector-tile/vector-tile-feature.ts
+function _toGeoJSONFeature2(vtFeature, coords, transform) {
+  let type = VectorTileFeature2.types[vtFeature.type];
+  let i;
+  let j;
+  let coordinates;
+  switch (vtFeature.type) {
+    case 1:
+      const points = [];
+      for (i = 0; i < coords.length; i++) {
+        points[i] = coords[i][0];
+      }
+      coordinates = points;
+      transform(coordinates, vtFeature.extent);
+      break;
+    case 2:
+      coordinates = coords;
+      for (i = 0; i < coordinates.length; i++) {
+        transform(coordinates[i], vtFeature.extent);
+      }
+      break;
+    case 3:
+      coordinates = classifyRings2(coords);
+      for (i = 0; i < coordinates.length; i++) {
+        for (j = 0; j < coordinates[i].length; j++) {
+          transform(coordinates[i][j], vtFeature.extent);
+        }
+      }
+      break;
+    default:
+      throw new Error("illegal vector tile type");
+  }
+  if (coordinates.length === 1) {
+    coordinates = coordinates[0];
+  } else {
+    type = `Multi${type}`;
+  }
+  const result = {
+    type: "Feature",
+    geometry: {
+      type,
+      coordinates
+    },
+    properties: vtFeature.properties
+  };
+  if (vtFeature.id !== null) {
+    result.id = vtFeature.id;
+  }
+  return result;
+}
+function readFeature2(tag, feature, pbf) {
+  if (feature && pbf) {
+    if (tag === 1) feature.id = pbf.readVarint();
+    else if (tag === 2) readTag2(pbf, feature);
+    else if (tag === 3) feature.type = pbf.readVarint();
+    else if (tag === 4) feature._geometry = pbf.pos;
+  }
+}
+function readTag2(pbf, feature) {
+  const end = pbf.readVarint() + pbf.pos;
+  while (pbf.pos < end) {
+    const key = feature._keys[pbf.readVarint()];
+    const value = feature._values[pbf.readVarint()];
+    if (key === "__proto__") {
+      Object.defineProperty(feature.properties, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      feature.properties[key] = value;
+    }
+  }
+}
+var VectorTileFeature2;
+var init_vector_tile_feature = __esm({
+  "src/mvt/lib/vector-tile/vector-tile-feature.ts"() {
+    "use strict";
+    init_geometry_utils();
+    VectorTileFeature2 = class {
+      properties;
+      extent;
+      type;
+      id;
+      _pbf;
+      _geometry;
+      _keys;
+      _values;
+      _geometryInfo;
+      static types = ["Unknown", "Point", "LineString", "Polygon"];
+      // eslint-disable-next-line max-params
+      constructor(pbf, end, extent, keys, values, geometryInfo) {
+        this.properties = {};
+        this.extent = extent;
+        this.type = 0;
+        this.id = null;
+        this._pbf = pbf;
+        this._geometry = -1;
+        this._keys = keys;
+        this._values = values;
+        this._geometryInfo = geometryInfo;
+        pbf.readFields(readFeature2, this, end);
+      }
+      toGeoJSONFeature(coordinates, tileIndex) {
+        const coords = this.loadGeometry();
+        switch (coordinates) {
+          case "wgs84":
+            return _toGeoJSONFeature2(
+              this,
+              coords,
+              (line) => projectToLngLat2(line, tileIndex, this.extent)
+            );
+          default:
+            return _toGeoJSONFeature2(this, coords, convertToLocalCoordinates2);
+        }
+      }
+      /**
+       *
+       * @param options
+       * @returns
+       */
+      toBinaryFeature(coordinates, tileIndex) {
+        const geom = this.loadFlatGeometry();
+        switch (coordinates) {
+          case "wgs84":
+            return this._toBinaryCoordinates(
+              geom,
+              (coords) => projectToLngLatFlat2(coords, tileIndex, this.extent)
+            );
+          default:
+            return this._toBinaryCoordinates(geom, convertToLocalCoordinatesFlat2);
+        }
+      }
+      /** Read a bounding box from the feature */
+      // eslint-disable-next-line max-statements
+      bbox() {
+        const pbf = this._pbf;
+        pbf.pos = this._geometry;
+        const end = pbf.readVarint() + pbf.pos;
+        let cmd = 1;
+        let length = 0;
+        let x = 0;
+        let y = 0;
+        let x1 = Infinity;
+        let x2 = -Infinity;
+        let y1 = Infinity;
+        let y2 = -Infinity;
+        while (pbf.pos < end) {
+          if (length <= 0) {
+            const cmdLen = pbf.readVarint();
+            cmd = cmdLen & 7;
+            length = cmdLen >> 3;
+          }
+          length--;
+          if (cmd === 1 || cmd === 2) {
+            x += pbf.readSVarint();
+            y += pbf.readSVarint();
+            if (x < x1) x1 = x;
+            if (x > x2) x2 = x;
+            if (y < y1) y1 = y;
+            if (y > y2) y2 = y;
+          } else if (cmd !== 7) {
+            throw new Error(`unknown command ${cmd}`);
+          }
+        }
+        return [x1, y1, x2, y2];
+      }
+      // BINARY HELPERS
+      /**
+       *
+       * @param transform
+       * @returns result
+       */
+      _toBinaryCoordinates(geom, transform) {
+        let geometry;
+        transform(geom.data, this.extent);
+        const coordLength = 2;
+        switch (this.type) {
+          case 1:
+            this._geometryInfo.pointFeaturesCount++;
+            this._geometryInfo.pointPositionsCount += geom.indices.length;
+            geometry = { type: "Point", ...geom };
+            break;
+          case 2:
+            this._geometryInfo.lineFeaturesCount++;
+            this._geometryInfo.linePathsCount += geom.indices.length;
+            this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+            geometry = { type: "LineString", ...geom };
+            break;
+          case 3:
+            geometry = classifyRingsFlat2(geom);
+            this._geometryInfo.polygonFeaturesCount++;
+            this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+            for (const indices of geometry.indices) {
+              this._geometryInfo.polygonRingsCount += indices.length;
+            }
+            this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
+            break;
+          default:
+            throw new Error(`Invalid geometry type: ${this.type}`);
+        }
+        const result = { type: "Feature", geometry, properties: this.properties };
+        if (this.id !== null) {
+          result.id = this.id;
+        }
+        return result;
+      }
+      // GEOJSON HELPER
+      // eslint-disable-next-line complexity, max-statements
+      loadGeometry() {
+        const pbf = this._pbf;
+        pbf.pos = this._geometry;
+        const end = pbf.readVarint() + pbf.pos;
+        let cmd = 1;
+        let length = 0;
+        let x = 0;
+        let y = 0;
+        const lines = [];
+        let line;
+        while (pbf.pos < end) {
+          if (length <= 0) {
+            const cmdLen = pbf.readVarint();
+            cmd = cmdLen & 7;
+            length = cmdLen >> 3;
+          }
+          length--;
+          switch (cmd) {
+            case 1:
+            case 2:
+              x += pbf.readSVarint();
+              y += pbf.readSVarint();
+              if (cmd === 1) {
+                if (line) lines.push(line);
+                line = [];
+              }
+              if (line) line.push([x, y]);
+              break;
+            case 7:
+              if (line) {
+                line.push(line[0].slice());
+              }
+              break;
+            default:
+              throw new Error(`unknown command ${cmd}`);
+          }
+        }
+        if (line) lines.push(line);
+        return lines;
+      }
+      /**
+       * Expands the protobuf data to an intermediate Flat GeoJSON
+       * data format, which maps closely to the binary data buffers.
+       * It is similar to GeoJSON, but rather than storing the coordinates
+       * in multidimensional arrays, we have a 1D `data` with all the
+       * coordinates, and then index into this using the `indices`
+       * parameter, e.g.
+       *
+       * geometry: {
+       *   type: 'Point', data: [1,2], indices: [0]
+       * }
+       * geometry: {
+       *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+       * }
+       * geometry: {
+       *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+       * }
+       * Thus the indices member lets us look up the relevant range
+       * from the data array.
+       * The Multi* versions of the above types share the same data
+       * structure, just with multiple elements in the indices array
+       */
+      // eslint-disable-next-line complexity, max-statements
+      loadFlatGeometry() {
+        const pbf = this._pbf;
+        pbf.pos = this._geometry;
+        const endPos = pbf.readVarint() + pbf.pos;
+        let cmd = 1;
+        let cmdLen;
+        let length = 0;
+        let x = 0;
+        let y = 0;
+        let i = 0;
+        const indices = [];
+        const data = [];
+        while (pbf.pos < endPos) {
+          if (length <= 0) {
+            cmdLen = pbf.readVarint();
+            cmd = cmdLen & 7;
+            length = cmdLen >> 3;
+          }
+          length--;
+          if (cmd === 1 || cmd === 2) {
+            x += pbf.readSVarint();
+            y += pbf.readSVarint();
+            if (cmd === 1) {
+              indices.push(i);
+            }
+            data.push(x, y);
+            i += 2;
+          } else if (cmd === 7) {
+            if (i > 0) {
+              const start = indices[indices.length - 1];
+              data.push(data[start], data[start + 1]);
+              i += 2;
+            }
+          } else {
+            throw new Error(`unknown command ${cmd}`);
+          }
+        }
+        return { data, indices };
+      }
+    };
+  }
+});
+
+// src/mvt/lib/vector-tile/vector-tile-layer.ts
+function readLayer2(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(readValueMessage2(pbf));
+  }
+}
+function readValueMessage2(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;
+}
+var VectorTileLayer2;
+var init_vector_tile_layer = __esm({
+  "src/mvt/lib/vector-tile/vector-tile-layer.ts"() {
+    "use strict";
+    init_vector_tile_feature();
+    VectorTileLayer2 = class {
+      version;
+      name;
+      extent;
+      length;
+      _pbf;
+      _keys;
+      _values;
+      _features;
+      constructor(pbf, end) {
+        this.version = 1;
+        this.name = "";
+        this.extent = 4096;
+        this.length = 0;
+        this._pbf = pbf;
+        this._keys = [];
+        this._values = [];
+        this._features = [];
+        pbf.readFields(readLayer2, this, end);
+        this.length = this._features.length;
+      }
+      /**
+       * return feature `i` from this layer as a `VectorTileFeature`
+       * @param index
+       * @returns feature
+       */
+      getGeoJSONFeature(i) {
+        if (i < 0 || i >= this._features.length) {
+          throw new Error("feature index out of bounds");
+        }
+        this._pbf.pos = this._features[i];
+        const end = this._pbf.readVarint() + this._pbf.pos;
+        return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values);
+      }
+      /**
+       * return binary feature `i` from this layer as a `VectorTileFeature`
+       *
+       * @param index
+       * @param geometryInfo
+       * @returns binary feature
+       */
+      getBinaryFeature(i, geometryInfo) {
+        if (i < 0 || i >= this._features.length) {
+          throw new Error("feature index out of bounds");
+        }
+        this._pbf.pos = this._features[i];
+        const end = this._pbf.readVarint() + this._pbf.pos;
+        return new VectorTileFeature2(
+          this._pbf,
+          end,
+          this.extent,
+          this._keys,
+          this._values,
+          geometryInfo
+        );
+      }
+    };
+  }
+});
+
+// src/mvt/lib/vector-tile/vector-tile.ts
+function readTile2(tag, layers, pbf) {
+  if (tag === 3) {
+    if (pbf) {
+      const layer = new VectorTileLayer2(pbf, pbf.readVarint() + pbf.pos);
+      if (layer.length && layers) {
+        layers[layer.name] = layer;
+      }
+    }
+  }
+}
+var VectorTile2;
+var init_vector_tile = __esm({
+  "src/mvt/lib/vector-tile/vector-tile.ts"() {
+    "use strict";
+    init_vector_tile_layer();
+    VectorTile2 = class {
+      layers;
+      constructor(pbf, end) {
+        this.layers = pbf.readFields(readTile2, /* @__PURE__ */ Object.create(null), end);
+      }
+    };
+  }
+});
+
+// src/mvt/lib/parse-mvt-geojson.ts
+function parseMVTGeoJSON2(arrayBuffer, options = {}) {
+  const mvtOptions = options.mvt || {};
+  if (mvtOptions.coordinates === "wgs84" && !mvtOptions.tileIndex) {
+    throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
+  }
+  const features = [];
+  if (arrayBuffer.byteLength > 0) {
+    features.push(...parseToGeoJSONFeatures2(arrayBuffer, mvtOptions));
+  }
+  return { shape: "geojson-table", type: "FeatureCollection", features };
+}
+function parseToGeoJSONFeatures2(arrayBuffer, mvtOptions) {
+  if (arrayBuffer.byteLength <= 0) {
+    return [];
+  }
+  const tile = new VectorTile2(new import_pbf2.default(arrayBuffer));
+  const selectedLayers = Array.isArray(mvtOptions.layers) ? mvtOptions.layers : Object.keys(tile.layers);
+  const features = [];
+  for (const layerName of selectedLayers) {
+    const vectorTileLayer = tile.layers[layerName];
+    if (!vectorTileLayer) {
+      continue;
+    }
+    for (let index = 0; index < vectorTileLayer.length; index++) {
+      const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(index);
+      const feature = vectorTileFeature.toGeoJSONFeature(
+        mvtOptions.coordinates || "local",
+        mvtOptions.tileIndex
+      );
+      if (mvtOptions.layerProperty) {
+        feature.properties ||= {};
+        feature.properties[mvtOptions.layerProperty] = layerName;
+      }
+      if (mvtOptions.sourceLayer) {
+        feature.sourceLayer = layerName;
+      }
+      features.push(feature);
+    }
+  }
+  return features;
+}
+var import_pbf2;
+var init_parse_mvt_geojson = __esm({
+  "src/mvt/lib/parse-mvt-geojson.ts"() {
+    "use strict";
+    import_pbf2 = __toESM(require("pbf"), 1);
+    init_vector_tile();
+  }
+});
+
+// src/mvt/mvt-format.ts
+var MVTFormat2;
+var init_mvt_format = __esm({
+  "src/mvt/mvt-format.ts"() {
+    "use strict";
+    MVTFormat2 = {
+      name: "Mapbox Vector Tile",
+      id: "mvt",
+      module: "tiles",
+      encoding: "protobuf",
+      format: "mvt",
+      // 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'
+      ],
+      category: "geometry"
+    };
+  }
+});
+
+// src/mvt/mvt-geojson-loader-types.ts
+async function preload() {
+  const { MVTGeoJSONLoaderWithParser: MVTGeoJSONLoaderWithParser3 } = await Promise.resolve().then(() => (init_mvt_geojson_loader(), mvt_geojson_loader_exports));
+  return MVTGeoJSONLoaderWithParser3;
+}
+var VERSION, MVTGeoJSONLoader;
+var init_mvt_geojson_loader_types = __esm({
+  "src/mvt/mvt-geojson-loader-types.ts"() {
+    "use strict";
+    init_mvt_format();
+    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    MVTGeoJSONLoader = {
+      ...MVTFormat2,
+      name: "Mapbox Vector Tile (GeoJSON)",
+      dataType: null,
+      batchType: null,
+      version: VERSION,
+      worker: false,
+      options: {
+        mvt: {
+          shape: "geojson-table",
+          coordinates: "local",
+          layerProperty: "layerName",
+          sourceLayer: false,
+          layers: void 0,
+          tileIndex: void 0
+        }
+      },
+      preload,
+      binary: true
+    };
+  }
+});
+
+// src/mvt/mvt-geojson-loader.ts
+var mvt_geojson_loader_exports = {};
+__export(mvt_geojson_loader_exports, {
+  MVTGeoJSONLoaderWithParser: () => MVTGeoJSONLoaderWithParser
+});
+var _MVTGeoJSONLoaderPreload, MVTGeoJSONLoaderMetadataWithoutPreload, MVTGeoJSONLoaderWithParser;
+var init_mvt_geojson_loader = __esm({
+  "src/mvt/mvt-geojson-loader.ts"() {
+    "use strict";
+    init_parse_mvt_geojson();
+    init_mvt_geojson_loader_types();
+    ({ preload: _MVTGeoJSONLoaderPreload, ...MVTGeoJSONLoaderMetadataWithoutPreload } = MVTGeoJSONLoader);
+    MVTGeoJSONLoaderWithParser = {
+      ...MVTGeoJSONLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer, options) => parseMVTGeoJSON2(arrayBuffer, options),
+      parseSync: parseMVTGeoJSON2
+    };
+  }
+});
+
+// dist/mvt/mvt-geojson-loader.js
+var mvt_geojson_loader_exports2 = {};
+__export(mvt_geojson_loader_exports2, {
+  MVTGeoJSONLoaderWithParser: () => MVTGeoJSONLoaderWithParser2
+});
+module.exports = __toCommonJS(mvt_geojson_loader_exports2);
+
+// dist/mvt/lib/parse-mvt-geojson.js
+var import_pbf = __toESM(require("pbf"), 1);
+
+// dist/mvt/lib/utils/geometry-utils.js
+var import_polygon = require("@math.gl/geometry/polygon");
+function signedArea(ring) {
+  let sum = 0;
+  for (let i = 0, j = ring.length - 1, p1, p2; i < ring.length; j = i++) {
+    p1 = ring[i];
+    p2 = ring[j];
+    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+  }
+  return sum;
+}
+function convertToLocalCoordinates(coordinates, extent) {
+  if (Array.isArray(coordinates[0])) {
+    for (const subcoords of coordinates) {
+      convertToLocalCoordinates(subcoords, extent);
+    }
+    return;
+  }
+  const p = coordinates;
+  p[0] /= extent;
+  p[1] /= extent;
+}
+function convertToLocalCoordinatesFlat(data, extent) {
+  for (let i = 0; i < data.length; ++i) {
+    data[i] /= extent;
+  }
+}
+function projectToLngLat(line, tileIndex, extent) {
+  if (typeof line[0] === "number") {
+    projectToLngLat([line], tileIndex, extent);
+    return;
+  }
+  if (typeof line[0][0] !== "number") {
+    for (const point of line) {
+      projectToLngLat(point, tileIndex, extent);
+    }
+    return;
+  }
+  const size = extent * Math.pow(2, tileIndex.z);
+  const x0 = extent * tileIndex.x;
+  const y0 = extent * tileIndex.y;
+  for (let j = 0; j < line.length; j++) {
+    const p = line[j];
+    p[0] = (p[0] + x0) * 360 / size - 180;
+    const y2 = 180 - (p[1] + y0) * 360 / size;
+    p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+}
+function projectToLngLatFlat(data, tileIndex, extent) {
+  const { x, y, z } = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+  for (let j = 0, jl = data.length; j < jl; j += 2) {
+    data[j] = (data[j] + x0) * 360 / size - 180;
+    const y2 = 180 - (data[j + 1] + y0) * 360 / size;
+    data[j + 1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+}
+function classifyRings(rings) {
+  const len = rings.length;
+  if (len <= 1)
+    return [rings];
+  const polygons = [];
+  let polygon;
+  let ccw;
+  for (let i = 0; i < len; i++) {
+    const area = signedArea(rings[i]);
+    if (area === 0)
+      continue;
+    if (ccw === void 0)
+      ccw = area < 0;
+    if (ccw === area < 0) {
+      if (polygon)
+        polygons.push(polygon);
+      polygon = [rings[i]];
+    } else if (polygon)
+      polygon.push(rings[i]);
+  }
+  if (polygon)
+    polygons.push(polygon);
+  return polygons;
+}
+function classifyRingsFlat(geom) {
+  const len = geom.indices.length;
+  const type = "Polygon";
+  if (len <= 1) {
+    return {
+      type,
+      data: geom.data,
+      areas: [[(0, import_polygon.getPolygonSignedArea)(geom.data)]],
+      indices: [geom.indices]
+    };
+  }
+  const areas = [];
+  const polygons = [];
+  let ringAreas = [];
+  let polygon = [];
+  let ccw;
+  let offset = 0;
+  for (let endIndex, i = 0, startIndex; i < len; i++) {
+    startIndex = geom.indices[i] - offset;
+    endIndex = geom.indices[i + 1] - offset || geom.data.length;
+    const shape = geom.data.slice(startIndex, endIndex);
+    const area = (0, import_polygon.getPolygonSignedArea)(shape);
+    if (area === 0) {
+      const before = geom.data.slice(0, startIndex);
+      const after = geom.data.slice(endIndex);
+      geom.data = before.concat(after);
+      offset += endIndex - startIndex;
+      continue;
+    }
+    if (ccw === void 0)
+      ccw = area < 0;
+    if (ccw === area < 0) {
+      if (polygon.length) {
+        areas.push(ringAreas);
+        polygons.push(polygon);
+      }
+      polygon = [startIndex];
+      ringAreas = [area];
+    } else {
+      ringAreas.push(area);
+      polygon.push(startIndex);
+    }
+  }
+  if (ringAreas)
+    areas.push(ringAreas);
+  if (polygon.length)
+    polygons.push(polygon);
+  return { type, areas, indices: polygons, data: geom.data };
+}
+
+// dist/mvt/lib/vector-tile/vector-tile-feature.js
+var VectorTileFeature = class {
+  properties;
+  extent;
+  type;
+  id;
+  _pbf;
+  _geometry;
+  _keys;
+  _values;
+  _geometryInfo;
+  static types = ["Unknown", "Point", "LineString", "Polygon"];
+  // eslint-disable-next-line max-params
+  constructor(pbf, end, extent, keys, values, geometryInfo) {
+    this.properties = {};
+    this.extent = extent;
+    this.type = 0;
+    this.id = null;
+    this._pbf = pbf;
+    this._geometry = -1;
+    this._keys = keys;
+    this._values = values;
+    this._geometryInfo = geometryInfo;
+    pbf.readFields(readFeature, this, end);
+  }
+  toGeoJSONFeature(coordinates, tileIndex) {
+    const coords = this.loadGeometry();
+    switch (coordinates) {
+      case "wgs84":
+        return _toGeoJSONFeature(this, coords, (line) => projectToLngLat(line, tileIndex, this.extent));
+      default:
+        return _toGeoJSONFeature(this, coords, convertToLocalCoordinates);
+    }
+  }
+  /**
+   *
+   * @param options
+   * @returns
+   */
+  toBinaryFeature(coordinates, tileIndex) {
+    const geom = this.loadFlatGeometry();
+    switch (coordinates) {
+      case "wgs84":
+        return this._toBinaryCoordinates(geom, (coords) => projectToLngLatFlat(coords, tileIndex, this.extent));
+      default:
+        return this._toBinaryCoordinates(geom, convertToLocalCoordinatesFlat);
+    }
+  }
+  /** Read a bounding box from the feature */
+  // eslint-disable-next-line max-statements
+  bbox() {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+    const end = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    let x1 = Infinity;
+    let x2 = -Infinity;
+    let y1 = Infinity;
+    let y2 = -Infinity;
+    while (pbf.pos < end) {
+      if (length <= 0) {
+        const cmdLen = pbf.readVarint();
+        cmd = cmdLen & 7;
+        length = cmdLen >> 3;
+      }
+      length--;
+      if (cmd === 1 || cmd === 2) {
+        x += pbf.readSVarint();
+        y += pbf.readSVarint();
+        if (x < x1)
+          x1 = x;
+        if (x > x2)
+          x2 = x;
+        if (y < y1)
+          y1 = y;
+        if (y > y2)
+          y2 = y;
+      } else if (cmd !== 7) {
+        throw new Error(`unknown command ${cmd}`);
+      }
+    }
+    return [x1, y1, x2, y2];
+  }
+  // BINARY HELPERS
+  /**
+   *
+   * @param transform
+   * @returns result
+   */
+  _toBinaryCoordinates(geom, transform) {
+    let geometry;
+    transform(geom.data, this.extent);
+    const coordLength = 2;
+    switch (this.type) {
+      case 1:
+        this._geometryInfo.pointFeaturesCount++;
+        this._geometryInfo.pointPositionsCount += geom.indices.length;
+        geometry = { type: "Point", ...geom };
+        break;
+      case 2:
+        this._geometryInfo.lineFeaturesCount++;
+        this._geometryInfo.linePathsCount += geom.indices.length;
+        this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+        geometry = { type: "LineString", ...geom };
+        break;
+      case 3:
+        geometry = classifyRingsFlat(geom);
+        this._geometryInfo.polygonFeaturesCount++;
+        this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+        for (const indices of geometry.indices) {
+          this._geometryInfo.polygonRingsCount += indices.length;
+        }
+        this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
+        break;
+      default:
+        throw new Error(`Invalid geometry type: ${this.type}`);
+    }
+    const result = { type: "Feature", geometry, properties: this.properties };
+    if (this.id !== null) {
+      result.id = this.id;
+    }
+    return result;
+  }
+  // GEOJSON HELPER
+  // eslint-disable-next-line complexity, max-statements
+  loadGeometry() {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+    const end = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    const lines = [];
+    let line;
+    while (pbf.pos < end) {
+      if (length <= 0) {
+        const cmdLen = pbf.readVarint();
+        cmd = cmdLen & 7;
+        length = cmdLen >> 3;
+      }
+      length--;
+      switch (cmd) {
+        case 1:
+        case 2:
+          x += pbf.readSVarint();
+          y += pbf.readSVarint();
+          if (cmd === 1) {
+            if (line)
+              lines.push(line);
+            line = [];
+          }
+          if (line)
+            line.push([x, y]);
+          break;
+        case 7:
+          if (line) {
+            line.push(line[0].slice());
+          }
+          break;
+        default:
+          throw new Error(`unknown command ${cmd}`);
+      }
+    }
+    if (line)
+      lines.push(line);
+    return lines;
+  }
+  /**
+   * Expands the protobuf data to an intermediate Flat GeoJSON
+   * data format, which maps closely to the binary data buffers.
+   * It is similar to GeoJSON, but rather than storing the coordinates
+   * in multidimensional arrays, we have a 1D `data` with all the
+   * coordinates, and then index into this using the `indices`
+   * parameter, e.g.
+   *
+   * geometry: {
+   *   type: 'Point', data: [1,2], indices: [0]
+   * }
+   * geometry: {
+   *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+   * }
+   * geometry: {
+   *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+   * }
+   * Thus the indices member lets us look up the relevant range
+   * from the data array.
+   * The Multi* versions of the above types share the same data
+   * structure, just with multiple elements in the indices array
+   */
+  // eslint-disable-next-line complexity, max-statements
+  loadFlatGeometry() {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+    const endPos = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let cmdLen;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    let i = 0;
+    const indices = [];
+    const data = [];
+    while (pbf.pos < endPos) {
+      if (length <= 0) {
+        cmdLen = pbf.readVarint();
+        cmd = cmdLen & 7;
+        length = cmdLen >> 3;
+      }
+      length--;
+      if (cmd === 1 || cmd === 2) {
+        x += pbf.readSVarint();
+        y += pbf.readSVarint();
+        if (cmd === 1) {
+          indices.push(i);
+        }
+        data.push(x, y);
+        i += 2;
+      } else if (cmd === 7) {
+        if (i > 0) {
+          const start = indices[indices.length - 1];
+          data.push(data[start], data[start + 1]);
+          i += 2;
+        }
+      } else {
+        throw new Error(`unknown command ${cmd}`);
+      }
+    }
+    return { data, indices };
+  }
+};
+function _toGeoJSONFeature(vtFeature, coords, transform) {
+  let type = VectorTileFeature.types[vtFeature.type];
+  let i;
+  let j;
+  let coordinates;
+  switch (vtFeature.type) {
+    case 1:
+      const points = [];
+      for (i = 0; i < coords.length; i++) {
+        points[i] = coords[i][0];
+      }
+      coordinates = points;
+      transform(coordinates, vtFeature.extent);
+      break;
+    case 2:
+      coordinates = coords;
+      for (i = 0; i < coordinates.length; i++) {
+        transform(coordinates[i], vtFeature.extent);
+      }
+      break;
+    case 3:
+      coordinates = classifyRings(coords);
+      for (i = 0; i < coordinates.length; i++) {
+        for (j = 0; j < coordinates[i].length; j++) {
+          transform(coordinates[i][j], vtFeature.extent);
+        }
+      }
+      break;
+    default:
+      throw new Error("illegal vector tile type");
+  }
+  if (coordinates.length === 1) {
+    coordinates = coordinates[0];
+  } else {
+    type = `Multi${type}`;
+  }
+  const result = {
+    type: "Feature",
+    geometry: {
+      type,
+      coordinates
+    },
+    properties: vtFeature.properties
+  };
+  if (vtFeature.id !== null) {
+    result.id = vtFeature.id;
+  }
+  return result;
+}
+function readFeature(tag, feature, pbf) {
+  if (feature && pbf) {
+    if (tag === 1)
+      feature.id = pbf.readVarint();
+    else if (tag === 2)
+      readTag(pbf, feature);
+    else if (tag === 3)
+      feature.type = pbf.readVarint();
+    else if (tag === 4)
+      feature._geometry = pbf.pos;
+  }
+}
+function readTag(pbf, feature) {
+  const end = pbf.readVarint() + pbf.pos;
+  while (pbf.pos < end) {
+    const key = feature._keys[pbf.readVarint()];
+    const value = feature._values[pbf.readVarint()];
+    if (key === "__proto__") {
+      Object.defineProperty(feature.properties, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      feature.properties[key] = value;
+    }
+  }
+}
+
+// dist/mvt/lib/vector-tile/vector-tile-layer.js
+var VectorTileLayer = class {
+  version;
+  name;
+  extent;
+  length;
+  _pbf;
+  _keys;
+  _values;
+  _features;
+  constructor(pbf, end) {
+    this.version = 1;
+    this.name = "";
+    this.extent = 4096;
+    this.length = 0;
+    this._pbf = pbf;
+    this._keys = [];
+    this._values = [];
+    this._features = [];
+    pbf.readFields(readLayer, this, end);
+    this.length = this._features.length;
+  }
+  /**
+   * return feature `i` from this layer as a `VectorTileFeature`
+   * @param index
+   * @returns feature
+   */
+  getGeoJSONFeature(i) {
+    if (i < 0 || i >= this._features.length) {
+      throw new Error("feature index out of bounds");
+    }
+    this._pbf.pos = this._features[i];
+    const end = this._pbf.readVarint() + this._pbf.pos;
+    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+  }
+  /**
+   * return binary feature `i` from this layer as a `VectorTileFeature`
+   *
+   * @param index
+   * @param geometryInfo
+   * @returns binary feature
+   */
+  getBinaryFeature(i, geometryInfo) {
+    if (i < 0 || i >= this._features.length) {
+      throw new Error("feature index out of bounds");
+    }
+    this._pbf.pos = this._features[i];
+    const end = this._pbf.readVarint() + this._pbf.pos;
+    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
+  }
+};
+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;
+}
+
+// dist/mvt/lib/vector-tile/vector-tile.js
+var VectorTile = class {
+  layers;
+  constructor(pbf, end) {
+    this.layers = pbf.readFields(readTile, /* @__PURE__ */ Object.create(null), 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;
+      }
+    }
+  }
+}
+
+// dist/mvt/lib/parse-mvt-geojson.js
+function parseMVTGeoJSON(arrayBuffer, options = {}) {
+  const mvtOptions = options.mvt || {};
+  if (mvtOptions.coordinates === "wgs84" && !mvtOptions.tileIndex) {
+    throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
+  }
+  const features = [];
+  if (arrayBuffer.byteLength > 0) {
+    features.push(...parseToGeoJSONFeatures(arrayBuffer, mvtOptions));
+  }
+  return { shape: "geojson-table", type: "FeatureCollection", features };
+}
+function parseToGeoJSONFeatures(arrayBuffer, mvtOptions) {
+  if (arrayBuffer.byteLength <= 0) {
+    return [];
+  }
+  const tile = new VectorTile(new import_pbf.default(arrayBuffer));
+  const selectedLayers = Array.isArray(mvtOptions.layers) ? mvtOptions.layers : Object.keys(tile.layers);
+  const features = [];
+  for (const layerName of selectedLayers) {
+    const vectorTileLayer = tile.layers[layerName];
+    if (!vectorTileLayer) {
+      continue;
+    }
+    for (let index = 0; index < vectorTileLayer.length; index++) {
+      const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(index);
+      const feature = vectorTileFeature.toGeoJSONFeature(mvtOptions.coordinates || "local", mvtOptions.tileIndex);
+      if (mvtOptions.layerProperty) {
+        feature.properties ||= {};
+        feature.properties[mvtOptions.layerProperty] = layerName;
+      }
+      if (mvtOptions.sourceLayer) {
+        feature.sourceLayer = layerName;
+      }
+      features.push(feature);
+    }
+  }
+  return features;
+}
+
+// dist/mvt/mvt-format.js
+var MVTFormat = {
+  name: "Mapbox Vector Tile",
+  id: "mvt",
+  module: "tiles",
+  encoding: "protobuf",
+  format: "mvt",
+  // 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'
+  ],
+  category: "geometry"
+};
+
+// dist/mvt/mvt-geojson-loader-types.js
+var VERSION2 = true ? "5.0.0-alpha.13" : "latest";
+async function preload2() {
+  const { MVTGeoJSONLoaderWithParser: MVTGeoJSONLoaderWithParser3 } = await Promise.resolve().then(() => (init_mvt_geojson_loader(), mvt_geojson_loader_exports));
+  return MVTGeoJSONLoaderWithParser3;
+}
+var MVTGeoJSONLoader2 = {
+  ...MVTFormat,
+  name: "Mapbox Vector Tile (GeoJSON)",
+  dataType: null,
+  batchType: null,
+  version: VERSION2,
+  worker: false,
+  options: {
+    mvt: {
+      shape: "geojson-table",
+      coordinates: "local",
+      layerProperty: "layerName",
+      sourceLayer: false,
+      layers: void 0,
+      tileIndex: void 0
+    }
+  },
+  preload: preload2,
+  binary: true
+};
+
+// dist/mvt/mvt-geojson-loader.js
+var { preload: _MVTGeoJSONLoaderPreload2, ...MVTGeoJSONLoaderMetadataWithoutPreload2 } = MVTGeoJSONLoader2;
+var MVTGeoJSONLoaderWithParser2 = {
+  ...MVTGeoJSONLoaderMetadataWithoutPreload2,
+  parse: async (arrayBuffer, options) => parseMVTGeoJSON(arrayBuffer, options),
+  parseSync: parseMVTGeoJSON
+};
+//# sourceMappingURL=mvt-geojson-loader.cjs.map