@loaders.gl/mvt 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/dist.dev.js

@@ -2,8 +2,8 @@
   if (typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
   else if (typeof define === 'function' && define.amd) define([], factory);
-        else if (typeof exports === 'object') exports['loader'] = factory();
-  else root['loader'] = factory();})(globalThis, function () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
   var __create = Object.create;
@@ -27,6 +27,7 @@ var __exports__ = (() => {
     }
     return to;
   };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
   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-
@@ -37,6 +38,13 @@ var __exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
   // ../../node_modules/ieee754/index.js
   var require_ieee754 = __commonJS({
     "../../node_modules/ieee754/index.js"(exports) {
@@ -777,15 +785,16 @@ var __exports__ = (() => {
     }
   });
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     GeoJSONTiler: () => GeoJSONTiler,
     MVTLoader: () => MVTLoader,
     MVTSource: () => MVTSource,
     MVTWorkerLoader: () => MVTWorkerLoader,
     TileJSONLoader: () => TileJSONLoader
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
   function _typeof(obj) {
@@ -1350,14 +1359,18 @@ var __exports__ = (() => {
   function flatGeojsonToBinary(features, geometryInfo, options) {
     const propArrayTypes = extractNumericPropTypes(features);
     const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
-    return fillArrays(features, {
-      propArrayTypes,
-      ...geometryInfo
-    }, {
-      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
-      PositionDataType: options ? options.PositionDataType : Float32Array,
-      triangulate: options ? options.triangulate : true
-    });
+    return fillArrays(
+      features,
+      {
+        propArrayTypes,
+        ...geometryInfo
+      },
+      {
+        numericPropKeys: options && options.numericPropKeys || numericPropKeys,
+        PositionDataType: options ? options.PositionDataType : Float32Array,
+        triangulate: options ? options.triangulate : true
+      }
+    );
   }
   function extractNumericPropTypes(features) {
     const propArrayTypes = {};
@@ -1385,11 +1398,7 @@ var __exports__ = (() => {
       propArrayTypes,
       coordLength
     } = geometryInfo;
-    const {
-      numericPropKeys = [],
-      PositionDataType = Float32Array,
-      triangulate = true
-    } = options;
+    const { numericPropKeys = [], PositionDataType = Float32Array, triangulate = true } = options;
     const hasGlobalId = features[0] && "id" in features[0];
     const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
     const points = {
@@ -1454,9 +1463,7 @@ var __exports__ = (() => {
           handlePoint(geometry, points, indexMap, coordLength, properties);
           points.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
-            points.fields.push({
-              id: feature.id
-            });
+            points.fields.push({ id: feature.id });
           }
           indexMap.pointFeature++;
           break;
@@ -1464,9 +1471,7 @@ var __exports__ = (() => {
           handleLineString(geometry, lines, indexMap, coordLength, properties);
           lines.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
-            lines.fields.push({
-              id: feature.id
-            });
+            lines.fields.push({ id: feature.id });
           }
           indexMap.lineFeature++;
           break;
@@ -1474,9 +1479,7 @@ var __exports__ = (() => {
           handlePolygon(geometry, polygons, indexMap, coordLength, properties);
           polygons.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
-            polygons.fields.push({
-              id: feature.id
-            });
+            polygons.fields.push({ id: feature.id });
           }
           indexMap.polygonFeature++;
           break;
@@ -1491,16 +1494,32 @@ var __exports__ = (() => {
     points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
     const nPositions = geometry.data.length / coordLength;
     fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
-    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    points.globalFeatureIds.fill(
+      indexMap.feature,
+      indexMap.pointPosition,
+      indexMap.pointPosition + nPositions
+    );
+    points.featureIds.fill(
+      indexMap.pointFeature,
+      indexMap.pointPosition,
+      indexMap.pointPosition + nPositions
+    );
     indexMap.pointPosition += nPositions;
   }
   function handleLineString(geometry, lines, indexMap, coordLength, properties) {
     lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
     const nPositions = geometry.data.length / coordLength;
     fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
-    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    lines.globalFeatureIds.fill(
+      indexMap.feature,
+      indexMap.linePosition,
+      indexMap.linePosition + nPositions
+    );
+    lines.featureIds.fill(
+      indexMap.lineFeature,
+      indexMap.linePosition,
+      indexMap.linePosition + nPositions
+    );
     for (let i2 = 0, il = geometry.indices.length; i2 < il; ++i2) {
       const start = geometry.indices[i2];
       const end = i2 === il - 1 ? geometry.data.length : geometry.indices[i2 + 1];
@@ -1512,8 +1531,16 @@ var __exports__ = (() => {
     polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
     const nPositions = geometry.data.length / coordLength;
     fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    polygons.globalFeatureIds.fill(
+      indexMap.feature,
+      indexMap.polygonPosition,
+      indexMap.polygonPosition + nPositions
+    );
+    polygons.featureIds.fill(
+      indexMap.polygonFeature,
+      indexMap.polygonPosition,
+      indexMap.polygonPosition + nPositions
+    );
     for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
       const startPosition = indexMap.polygonPosition;
       polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
@@ -1522,16 +1549,15 @@ var __exports__ = (() => {
       const nextIndices = geometry.indices[l + 1];
       for (let i2 = 0, il = indices.length; i2 < il; ++i2) {
         const start = indices[i2];
-        const end = i2 === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i2 + 1];
+        const end = i2 === il - 1 ? (
+          // last line, so either read to:
+          nextIndices === void 0 ? geometry.data.length : nextIndices[0]
+        ) : indices[i2 + 1];
         polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
         indexMap.polygonPosition += (end - start) / coordLength;
       }
       const endPosition = indexMap.polygonPosition;
-      triangulatePolygon(polygons, areas, indices, {
-        startPosition,
-        endPosition,
-        coordLength
-      });
+      triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
     }
   }
   function triangulatePolygon(polygons, areas, indices, {
@@ -1555,10 +1581,7 @@ var __exports__ = (() => {
   function wrapProps(obj, size) {
     const returnObj = {};
     for (const key in obj) {
-      returnObj[key] = {
-        value: obj[key],
-        size
-      };
+      returnObj[key] = { value: obj[key], size };
     }
     return returnObj;
   }
@@ -1567,70 +1590,32 @@ var __exports__ = (() => {
       shape: "binary-feature-collection",
       points: {
         ...points,
-        positions: {
-          value: points.positions,
-          size: coordLength
-        },
-        globalFeatureIds: {
-          value: points.globalFeatureIds,
-          size: 1
-        },
-        featureIds: {
-          value: points.featureIds,
-          size: 1
-        },
+        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
-        },
+        positions: { value: lines.positions, size: coordLength },
+        pathIndices: { value: lines.pathIndices, size: 1 },
+        globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
+        featureIds: { value: lines.featureIds, size: 1 },
         numericProps: wrapProps(lines.numericProps, 1)
       },
       polygons: {
         ...polygons,
-        positions: {
-          value: polygons.positions,
-          size: coordLength
-        },
-        polygonIndices: {
-          value: polygons.polygonIndices,
-          size: 1
-        },
-        primitivePolygonIndices: {
-          value: polygons.primitivePolygonIndices,
-          size: 1
-        },
-        globalFeatureIds: {
-          value: polygons.globalFeatureIds,
-          size: 1
-        },
-        featureIds: {
-          value: polygons.featureIds,
-          size: 1
-        },
+        positions: { value: polygons.positions, size: coordLength },
+        polygonIndices: { value: polygons.polygonIndices, size: 1 },
+        primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
+        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
+        featureIds: { value: polygons.featureIds, size: 1 },
         numericProps: wrapProps(polygons.numericProps, 1)
       }
+      // triangles not expected
     };
     if (binaryFeatures.polygons && polygons.triangles) {
-      binaryFeatures.polygons.triangles = {
-        value: new Uint32Array(polygons.triangles),
-        size: 1
-      };
+      binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
     }
     return binaryFeatures;
   }
@@ -1718,6 +1703,14 @@ var __exports__ = (() => {
 
   // src/lib/mapbox-vector-tile/vector-tile-feature.ts
   var VectorTileFeature = class {
+    properties;
+    extent;
+    type;
+    id;
+    _pbf;
+    _geometry;
+    _keys;
+    _values;
     static get types() {
       return ["Unknown", "Point", "LineString", "Polygon"];
     }
@@ -1732,6 +1725,7 @@ var __exports__ = (() => {
       this._values = values;
       pbf.readFields(readFeature, this, end);
     }
+    // eslint-disable-next-line complexity, max-statements
     loadGeometry() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
@@ -1771,6 +1765,7 @@ var __exports__ = (() => {
         lines.push(line);
       return lines;
     }
+    // eslint-disable-next-line max-statements
     bbox() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
@@ -1857,11 +1852,7 @@ var __exports__ = (() => {
       if (typeof options === "function") {
         return this._toGeoJSON(options);
       }
-      const {
-        x: x2,
-        y: y2,
-        z
-      } = 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;
@@ -1879,6 +1870,14 @@ var __exports__ = (() => {
 
   // src/lib/mapbox-vector-tile/vector-tile-layer.ts
   var VectorTileLayer = class {
+    version;
+    name;
+    extent;
+    length;
+    _pbf;
+    _keys;
+    _values;
+    _features;
     constructor(pbf, end) {
       this.version = 1;
       this.name = "";
@@ -1891,6 +1890,11 @@ var __exports__ = (() => {
       pbf.readFields(readLayer, this, end);
       this.length = this._features.length;
     }
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     * @param index
+     * @returns feature
+     */
     feature(i2) {
       if (i2 < 0 || i2 >= this._features.length) {
         throw new Error("feature index out of bounds");
@@ -1928,6 +1932,7 @@ var __exports__ = (() => {
 
   // src/lib/mapbox-vector-tile/vector-tile.ts
   var VectorTile = class {
+    layers;
     constructor(pbf, end) {
       this.layers = pbf.readFields(readTile, {}, end);
     }
@@ -1991,12 +1996,7 @@ var __exports__ = (() => {
       areas.push(ringAreas);
     if (polygon.length)
       polygons.push(polygon);
-    return {
-      type,
-      areas,
-      indices: polygons,
-      data: geom.data
-    };
+    return { type, areas, indices: polygons, data: geom.data };
   }
   function project(data, x0, y0, size) {
     for (let j = 0, jl = data.length; j < jl; j += 2) {
@@ -2035,6 +2035,16 @@ var __exports__ = (() => {
   var y;
   var i;
   var VectorTileFeature2 = class {
+    properties;
+    extent;
+    type;
+    id;
+    _pbf;
+    _geometry;
+    _keys;
+    _values;
+    _geometryInfo;
+    // eslint-disable-next-line max-params
     constructor(pbf, end, extent, keys, values, geometryInfo) {
       this.properties = {};
       this.extent = extent;
@@ -2047,6 +2057,7 @@ var __exports__ = (() => {
       this._geometryInfo = geometryInfo;
       pbf.readFields(readFeature2, this, end);
     }
+    // eslint-disable-next-line complexity, max-statements
     loadGeometry() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
@@ -2083,11 +2094,13 @@ var __exports__ = (() => {
           throw new Error(`unknown command ${cmd}`);
         }
       }
-      return {
-        data,
-        indices
-      };
+      return { data, indices };
     }
+    /**
+     *
+     * @param transform
+     * @returns result
+     */
     _toBinaryCoordinates(transform) {
       const geom = this.loadGeometry();
       let geometry;
@@ -2097,19 +2110,13 @@ var __exports__ = (() => {
         case 1:
           this._geometryInfo.pointFeaturesCount++;
           this._geometryInfo.pointPositionsCount += geom.indices.length;
-          geometry = {
-            type: "Point",
-            ...geom
-          };
+          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
-          };
+          geometry = { type: "LineString", ...geom };
           break;
         case 3:
           geometry = classifyRings2(geom);
@@ -2123,11 +2130,7 @@ var __exports__ = (() => {
         default:
           throw new Error(`Invalid geometry type: ${this.type}`);
       }
-      const result = {
-        type: "Feature",
-        geometry,
-        properties: this.properties
-      };
+      const result = { type: "Feature", geometry, properties: this.properties };
       if (this.id !== null) {
         result.id = this.id;
       }
@@ -2137,11 +2140,7 @@ var __exports__ = (() => {
       if (typeof options === "function") {
         return this._toBinaryCoordinates(options);
       }
-      const {
-        x: x2,
-        y: y2,
-        z
-      } = 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;
@@ -2151,6 +2150,14 @@ var __exports__ = (() => {
 
   // src/lib/binary-vector-tile/vector-tile-layer.ts
   var VectorTileLayer2 = class {
+    version;
+    name;
+    extent;
+    length;
+    _pbf;
+    _keys;
+    _values;
+    _features;
     constructor(pbf, end) {
       this.version = 1;
       this.name = "";
@@ -2163,13 +2170,27 @@ var __exports__ = (() => {
       pbf.readFields(readLayer2, this, end);
       this.length = this._features.length;
     }
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     *
+     * @param index
+     * @param geometryInfo
+     * @returns {VectorTileFeature}
+     */
     feature(i2, geometryInfo) {
       if (i2 < 0 || i2 >= this._features.length) {
         throw new Error("feature index out of bounds");
       }
       this._pbf.pos = this._features[i2];
       const end = this._pbf.readVarint() + this._pbf.pos;
-      return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
+      return new VectorTileFeature2(
+        this._pbf,
+        end,
+        this.extent,
+        this._keys,
+        this._values,
+        geometryInfo
+      );
     }
   };
   function readLayer2(tag, layer, pbf) {
@@ -2200,6 +2221,7 @@ var __exports__ = (() => {
 
   // src/lib/binary-vector-tile/vector-tile.ts
   var VectorTile2 = class {
+    layers;
     constructor(pbf, end) {
       this.layers = pbf.readFields(readTile2, {}, end);
     }
@@ -2221,10 +2243,7 @@ var __exports__ = (() => {
     const shape = options?.gis?.format || options?.mvt?.shape || options?.shape;
     switch (shape) {
       case "columnar-table":
-        return {
-          shape: "columnar-table",
-          data: parseToBinary(arrayBuffer, mvtOptions)
-        };
+        return { shape: "columnar-table", data: parseToBinary(arrayBuffer, mvtOptions) };
       case "geojson-table": {
         const table = {
           shape: "geojson-table",
@@ -2306,9 +2325,7 @@ var __exports__ = (() => {
       throw new Error("mvt options required");
     }
     const wgs84Coordinates = options.mvt?.coordinates === "wgs84";
-    const {
-      tileIndex
-    } = options.mvt;
+    const { tileIndex } = options.mvt;
     const hasTileIndex = tileIndex && Number.isFinite(tileIndex.x) && Number.isFinite(tileIndex.y) && Number.isFinite(tileIndex.z);
     if (wgs84Coordinates && !hasTileIndex) {
       throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
@@ -2316,23 +2333,27 @@ var __exports__ = (() => {
     return options.mvt;
   }
   function getDecodedFeature(feature, options, layerName) {
-    const decodedFeature = feature.toGeoJSON(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates);
+    const decodedFeature = feature.toGeoJSON(
+      // @ts-expect-error What is going on here?
+      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates
+    );
     if (options.layerProperty) {
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
   function getDecodedFeatureBinary(feature, options, layerName) {
-    const decodedFeature = feature.toBinaryCoordinates(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary);
+    const decodedFeature = feature.toBinaryCoordinates(
+      // @ts-expect-error What is going on here?
+      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary
+    );
     if (options.layerProperty && decodedFeature.properties) {
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
   function transformToLocalCoordinates(line, feature) {
-    const {
-      extent
-    } = feature;
+    const { extent } = feature;
     for (let i2 = 0; i2 < line.length; i2++) {
       const p = line[i2];
       p[0] /= extent;
@@ -2340,23 +2361,27 @@ var __exports__ = (() => {
     }
   }
   function transformToLocalCoordinatesBinary(data, feature) {
-    const {
-      extent
-    } = feature;
+    const { extent } = feature;
     for (let i2 = 0, il = data.length; i2 < il; ++i2) {
       data[i2] /= extent;
     }
   }
 
   // src/mvt-loader.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var MVTWorkerLoader = {
     name: "Mapbox Vector Tile",
     id: "mvt",
     module: "mvt",
     version: VERSION,
+    // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
     extensions: ["mvt", "pbf"],
-    mimeTypes: ["application/vnd.mapbox-vector-tile", "application/x-protobuf"],
+    mimeTypes: [
+      // https://www.iana.org/assignments/media-types/application/vnd.mapbox-vector-tile
+      "application/vnd.mapbox-vector-tile",
+      "application/x-protobuf"
+      // 'application/octet-stream'
+    ],
     worker: true,
     category: "geometry",
     options: {
@@ -2430,9 +2455,7 @@ var __exports__ = (() => {
       name: key,
       ...attributeTypeToFieldType(String(datatype))
     }));
-    const layer2 = {
-      ...layer
-    };
+    const layer2 = { ...layer };
     delete layer2.fields;
     return {
       name: layer.id || "",
@@ -2474,9 +2497,7 @@ var __exports__ = (() => {
     return layers.map((layer) => {
       const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
       const fields = tilestatsLayer?.fields || [];
-      const layer2 = {
-        ...layer
-      };
+      const layer2 = { ...layer };
       delete layer2.fields;
       return {
         ...layer2,
@@ -2488,7 +2509,10 @@ var __exports__ = (() => {
   function parseBounds(bounds) {
     const result = fromArrayOrString(bounds);
     if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
-      return [[result[0], result[1]], [result[2], result[3]]];
+      return [
+        [result[0], result[1]],
+        [result[2], result[3]]
+      ];
     }
     return void 0;
   }
@@ -2553,6 +2577,8 @@ var __exports__ = (() => {
     const fieldTypes = attributeTypeToFieldType(attribute.type);
     const field = {
       name: attribute.attribute,
+      // what happens if attribute type is string...
+      // filterProps: getFilterProps(fieldTypes.type, attribute),
       ...fieldTypes
     };
     if (typeof attribute.min === "number") {
@@ -2576,13 +2602,11 @@ var __exports__ = (() => {
     const type = aType.toLowerCase();
     if (!type || !attrTypeMap[type]) {
     }
-    return attrTypeMap[type] || {
-      type: "string"
-    };
+    return attrTypeMap[type] || { type: "string" };
   }
 
   // src/tilejson-loader.ts
-  var VERSION2 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TileJSONLoader = {
     name: "TileJSON",
     id: "tilejson",
@@ -2600,18 +2624,12 @@ var __exports__ = (() => {
     parse: async (arrayBuffer, options) => {
       const jsonString = new TextDecoder().decode(arrayBuffer);
       const json = JSON.parse(jsonString);
-      const tilejsonOptions = {
-        ...TileJSONLoader.options.tilejson,
-        ...options?.tilejson
-      };
+      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
       return parseTileJSON(json, tilejsonOptions);
     },
     parseTextSync: (text, options) => {
       const json = JSON.parse(text);
-      const tilejsonOptions = {
-        ...TileJSONLoader.options.tilejson,
-        ...options?.tilejson
-      };
+      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
       return parseTileJSON(json, tilejsonOptions);
     }
   };
@@ -2634,7 +2652,10 @@ var __exports__ = (() => {
   var window_ = globals.window || globals.self || globals.global || {};
   var global_ = globals.global || globals.self || globals.window || {};
   var document_ = globals.document || {};
-  var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
@@ -2656,23 +2677,29 @@ var __exports__ = (() => {
 
   // ../loader-utils/src/lib/sources/data-source.ts
   var DataSource = class {
+    /** A resolved fetch function extracted from loadOptions prop */
+    fetch;
+    /** The actual load options, if calling a loaders.gl loader */
+    loadOptions;
     _needsRefresh = true;
+    props;
     constructor(props) {
-      this.props = {
-        ...props
-      };
-      this.loadOptions = {
-        ...props.loadOptions
-      };
+      this.props = { ...props };
+      this.loadOptions = { ...props.loadOptions };
       this.fetch = getFetchFunction(this.loadOptions);
     }
     setProps(props) {
       this.props = Object.assign(this.props, props);
       this.setNeedsRefresh();
     }
+    /** Mark this data source as needing a refresh (redraw) */
     setNeedsRefresh() {
       this._needsRefresh = true;
     }
+    /**
+     * Does this data source need refreshing?
+     * @note The specifics of the refresh mechanism depends on type of data source
+     */
     getNeedsRefresh(clear = true) {
       const needsRefresh = this._needsRefresh;
       if (clear) {
@@ -2694,7 +2721,7 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/utils/version.ts
-  var VERSION3 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -2881,10 +2908,7 @@ var __exports__ = (() => {
     switch (brandMajor) {
       case "avif":
       case "avis":
-        return {
-          extension: "avif",
-          mimeType: "image/avif"
-        };
+        return { extension: "avif", mimeType: "image/avif" };
       default:
         return null;
     }
@@ -2920,6 +2944,7 @@ var __exports__ = (() => {
     }
     return {
       mimeType: mediaType.mimeType,
+      // TODO - decode width and height
       width: 0,
       height: 0
     };
@@ -2966,10 +2991,7 @@ var __exports__ = (() => {
     if (!isJpeg) {
       return null;
     }
-    const {
-      tableMarkers,
-      sofMarkers
-    } = getJpegMarkers();
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
     let i2 = 2;
     while (i2 + 9 < dataView.byteLength) {
       const marker = dataView.getUint16(i2, BIG_ENDIAN);
@@ -2977,7 +2999,9 @@ var __exports__ = (() => {
         return {
           mimeType: "image/jpeg",
           height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+          // Number of lines
           width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+          // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
@@ -2993,11 +3017,23 @@ var __exports__ = (() => {
     for (let i2 = 65504; i2 < 65520; ++i2) {
       tableMarkers.add(i2);
     }
-    const sofMarkers = /* @__PURE__ */ new Set([65472, 65473, 65474, 65475, 65477, 65478, 65479, 65481, 65482, 65483, 65485, 65486, 65487, 65502]);
-    return {
-      tableMarkers,
-      sofMarkers
-    };
+    const sofMarkers = /* @__PURE__ */ new Set([
+      65472,
+      65473,
+      65474,
+      65475,
+      65477,
+      65478,
+      65479,
+      65481,
+      65482,
+      65483,
+      65485,
+      65486,
+      65487,
+      65502
+    ]);
+    return { tableMarkers, sofMarkers };
   }
   function toDataView(data) {
     if (data instanceof DataView) {
@@ -3014,9 +3050,7 @@ var __exports__ = (() => {
 
   // ../images/src/lib/parsers/parse-to-node-image.ts
   async function parseToNodeImage(arrayBuffer, options) {
-    const {
-      mimeType
-    } = getBinaryImageMetadata(arrayBuffer) || {};
+    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
     const parseImageNode2 = globalThis.loaders?.parseImageNode;
     assert(parseImageNode2);
     return await parseImageNode2(arrayBuffer, mimeType);
@@ -3027,9 +3061,7 @@ var __exports__ = (() => {
     options = options || {};
     const imageOptions = options.image || {};
     const imageType = imageOptions.type || "auto";
-    const {
-      url
-    } = context || {};
+    const { url } = context || {};
     const loadType = getLoadableImageType(imageType);
     let image;
     switch (loadType) {
@@ -3063,12 +3095,23 @@ var __exports__ = (() => {
 
   // ../images/src/image-loader.ts
   var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
-  var MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp", "image/vnd.microsoft.icon", "image/svg+xml"];
+  var MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "image/avif",
+    "image/bmp",
+    "image/vnd.microsoft.icon",
+    "image/svg+xml"
+  ];
   var DEFAULT_IMAGE_LOADER_OPTIONS = {
     image: {
       type: "auto",
       decode: true
+      // if format is HTML
     }
+    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
   };
   var ImageLoader = {
     id: "image",
@@ -3078,14 +3121,20 @@ var __exports__ = (() => {
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
+    // TODO: byteOffset, byteLength;
     tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
 
   // src/mvt-source.ts
   var MVTSource = class extends DataSource {
+    props;
+    url;
     metadataUrl = null;
+    data;
     schema = "tms";
+    metadata;
+    extension;
     mimeType = null;
     constructor(props) {
       super(props);
@@ -3100,6 +3149,7 @@ var __exports__ = (() => {
         this.schema = "template";
       }
     }
+    // @ts-ignore - Metadata type misalignment
     async getMetadata() {
       if (!this.metadataUrl) {
         return null;
@@ -3123,11 +3173,7 @@ var __exports__ = (() => {
       return this.mimeType;
     }
     async getTile(tileParams) {
-      const {
-        x: x2,
-        y: y2,
-        zoom: z
-      } = tileParams;
+      const { x: x2, y: y2, zoom: z } = tileParams;
       const tileUrl = this.getTileURL(x2, y2, z);
       const response = await this.fetch(tileUrl);
       if (!response.ok) {
@@ -3136,18 +3182,11 @@ var __exports__ = (() => {
       const arrayBuffer = await response.arrayBuffer();
       return arrayBuffer;
     }
+    // Tile Source interface implementation: deck.gl compatible API
+    // TODO - currently only handles image tiles, not vector tiles
     async getTileData(tileParams) {
-      const {
-        x: x2,
-        y: y2,
-        z
-      } = tileParams.index;
-      const arrayBuffer = await this.getTile({
-        x: x2,
-        y: y2,
-        zoom: z,
-        layers: []
-      });
+      const { x: x2, y: y2, z } = tileParams.index;
+      const arrayBuffer = await this.getTile({ x: x2, y: y2, zoom: z, layers: [] });
       if (arrayBuffer === null) {
         return null;
       }
@@ -3155,16 +3194,12 @@ var __exports__ = (() => {
       this.mimeType = this.mimeType || imageMetadata?.mimeType || "application/vnd.mapbox-vector-tile";
       switch (this.mimeType) {
         case "application/vnd.mapbox-vector-tile":
-          return await this._parseVectorTile(arrayBuffer, {
-            x: x2,
-            y: y2,
-            zoom: z,
-            layers: []
-          });
+          return await this._parseVectorTile(arrayBuffer, { x: x2, y: y2, zoom: z, layers: [] });
         default:
           return await this._parseImageTile(arrayBuffer);
       }
     }
+    // ImageTileSource interface implementation
     async getImageTile(tileParams) {
       const arrayBuffer = await this.getTile(tileParams);
       return arrayBuffer ? this._parseImageTile(arrayBuffer) : null;
@@ -3172,6 +3207,7 @@ var __exports__ = (() => {
     async _parseImageTile(arrayBuffer) {
       return await ImageLoader.parse(arrayBuffer, this.loadOptions);
     }
+    // VectorTileSource interface implementation
     async getVectorTile(tileParams) {
       const arrayBuffer = await this.getTile(tileParams);
       return arrayBuffer ? this._parseVectorTile(arrayBuffer, tileParams) : null;
@@ -3181,11 +3217,7 @@ var __exports__ = (() => {
         shape: "geojson-table",
         mvt: {
           coordinates: "wgs84",
-          tileIndex: {
-            x: tileParams.x,
-            y: tileParams.y,
-            z: tileParams.zoom
-          },
+          tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.zoom },
           ...this.loadOptions?.mvt
         },
         ...this.loadOptions
@@ -3284,6 +3316,7 @@ var __exports__ = (() => {
   // src/lib/geojson-tiler/feature.ts
   function createFeature(id, type, geom, tags) {
     const feature = {
+      // eslint-disable-next-line
       id: id == null ? null : id,
       type,
       geometry: geom,
@@ -3327,9 +3360,7 @@ var __exports__ = (() => {
     } else if (data.type === "Feature") {
       convertFeature(features, data, options);
     } else {
-      convertFeature(features, {
-        geometry: data
-      }, options);
+      convertFeature(features, { geometry: data }, options);
     }
     return features;
   }
@@ -3376,11 +3407,16 @@ var __exports__ = (() => {
       }
     } else if (type === "GeometryCollection") {
       for (const singleGeometry of geojson.geometry.geometries) {
-        convertFeature(features, {
-          id,
-          geometry: singleGeometry,
-          properties: geojson.properties
-        }, options, index);
+        convertFeature(
+          features,
+          {
+            id,
+            geometry: singleGeometry,
+            properties: geojson.properties
+          },
+          options,
+          index
+        );
       }
       return;
     } else {
@@ -3796,26 +3832,36 @@ var __exports__ = (() => {
   // src/lib/geojson-tiler/geojson-tiler.ts
   var DEFAULT_OPTIONS = {
     maxZoom: 14,
+    // max zoom to preserve detail on
     indexMaxZoom: 5,
+    // max zoom in the tile index
     indexMaxPoints: 1e5,
+    // max number of points per tile in the tile index
     tolerance: 3,
+    // simplification tolerance (higher means simpler)
     extent: 4096,
+    // tile extent
     buffer: 64,
+    // tile buffer on each side
     lineMetrics: false,
+    // whether to calculate line metrics
+    // @ts-expect-error Ensures all these required params have defaults
     promoteId: void 0,
+    // name of a feature property to be promoted to feature.id
     generateId: false,
+    // whether to generate feature ids. Cannot be used with promoteId
     debug: 0
+    // logging level (0, 1 or 2)
   };
   var GeoJSONTiler = class {
+    options;
+    // tiles and tileCoords are part of the public API
     tiles = {};
     tileCoords = [];
     stats = {};
     total = 0;
     constructor(data, options) {
-      this.options = {
-        ...DEFAULT_OPTIONS,
-        ...options
-      };
+      this.options = { ...DEFAULT_OPTIONS, ...options };
       options = this.options;
       const debug = options.debug;
       if (debug)
@@ -3829,7 +3875,11 @@ var __exports__ = (() => {
       let features = convert(data, options);
       if (debug) {
         console.timeEnd("preprocess data");
-        console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
+        console.log(
+          "index: maxZoom: %d, maxPoints: %d",
+          options.indexMaxZoom,
+          options.indexMaxPoints
+        );
         console.time("generate tiles");
       }
       features = wrap(features, this.options);
@@ -3844,11 +3894,16 @@ var __exports__ = (() => {
         console.log("tiles generated:", this.total, JSON.stringify(this.stats));
       }
     }
+    /**
+     * Get a tile at the specified index
+     * @param z
+     * @param x
+     * @param y
+     * @returns
+     */
+    // eslint-disable-next-line complexity, max-statements
     getTile(z, x2, y2) {
-      const {
-        extent,
-        debug
-      } = this.options;
+      const { extent, debug } = this.options;
       if (z < 0 || z > 24) {
         return null;
       }
@@ -3883,6 +3938,15 @@ var __exports__ = (() => {
       }
       return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
     }
+    /**
+     * splits features from a parent tile to sub-tiles.
+     * @param z, x, and y are the coordinates of the parent tile
+     * @param cz, cx, and cy are the coordinates of the target tile
+     *
+     * If no target tile is specified, splitting stops when we reach the maximum
+     * zoom or the number of points is low as specified in the options.
+     */
+    // eslint-disable-next-line max-params, max-statements, complexity
     splitTile(features, z, x2, y2, cz, cx, cy) {
       const stack = [features, z, x2, y2];
       const options = this.options;
@@ -3900,14 +3964,18 @@ var __exports__ = (() => {
             console.time("creation");
           }
           tile = this.tiles[id] = createTile(features, z, x2, y2, options);
-          this.tileCoords.push({
-            z,
-            x: x2,
-            y: y2
-          });
+          this.tileCoords.push({ z, x: x2, y: y2 });
           if (debug) {
             if (debug > 1) {
-              console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x2, y2, tile.numFeatures, tile.numPoints, tile.numSimplified);
+              console.log(
+                "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",
+                z,
+                x2,
+                y2,
+                tile.numFeatures,
+                tile.numPoints,
+                tile.numSimplified
+              );
               console.timeEnd("creation");
             }
             const key = `z${z}`;
@@ -3964,7 +4032,7 @@ var __exports__ = (() => {
   function toID(z, x2, y2) {
     return ((1 << z) * y2 + x2) * 32 + z;
   }
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: