@loaders.gl/pmtiles 4.2.0-alpha.3 → 4.2.0-alpha.5

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,11 +785,12 @@ var __exports__ = (() => {
     }
   });
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     PMTilesSource: () => PMTilesSource
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // ../loader-utils/src/lib/env-utils/assert.ts
   function assert(condition, message) {
@@ -801,7 +810,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;
 
@@ -869,23 +881,24 @@ var __exports__ = (() => {
 
   // ../loader-utils/src/lib/sources/data-source.ts
   var DataSource = class {
-    _needsRefresh = true;
     constructor(props) {
-      this.props = {
-        ...props
-      };
-      this.loadOptions = {
-        ...props.loadOptions
-      };
+      this._needsRefresh = true;
+      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) {
@@ -907,7 +920,7 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/utils/version.ts
-  var VERSION = true ? "4.2.0-alpha.3" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -1094,10 +1107,7 @@ var __exports__ = (() => {
     switch (brandMajor) {
       case "avif":
       case "avis":
-        return {
-          extension: "avif",
-          mimeType: "image/avif"
-        };
+        return { extension: "avif", mimeType: "image/avif" };
       default:
         return null;
     }
@@ -1133,6 +1143,7 @@ var __exports__ = (() => {
     }
     return {
       mimeType: mediaType.mimeType,
+      // TODO - decode width and height
       width: 0,
       height: 0
     };
@@ -1179,10 +1190,7 @@ var __exports__ = (() => {
     if (!isJpeg) {
       return null;
     }
-    const {
-      tableMarkers,
-      sofMarkers
-    } = getJpegMarkers();
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
     let i3 = 2;
     while (i3 + 9 < dataView.byteLength) {
       const marker = dataView.getUint16(i3, BIG_ENDIAN);
@@ -1190,7 +1198,9 @@ var __exports__ = (() => {
         return {
           mimeType: "image/jpeg",
           height: dataView.getUint16(i3 + 5, BIG_ENDIAN),
+          // Number of lines
           width: dataView.getUint16(i3 + 7, BIG_ENDIAN)
+          // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
@@ -1206,11 +1216,23 @@ var __exports__ = (() => {
     for (let i3 = 65504; i3 < 65520; ++i3) {
       tableMarkers.add(i3);
     }
-    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) {
@@ -1227,9 +1249,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);
@@ -1240,9 +1260,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) {
@@ -1276,12 +1294,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",
@@ -1291,6 +1320,7 @@ var __exports__ = (() => {
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
+    // TODO: byteOffset, byteLength;
     tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
@@ -1812,14 +1842,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 = {};
@@ -1847,11 +1881,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 = {
@@ -1916,9 +1946,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;
@@ -1926,9 +1954,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;
@@ -1936,9 +1962,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;
@@ -1953,16 +1977,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 i3 = 0, il = geometry.indices.length; i3 < il; ++i3) {
       const start = geometry.indices[i3];
       const end = i3 === il - 1 ? geometry.data.length : geometry.indices[i3 + 1];
@@ -1974,8 +2014,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;
@@ -1984,16 +2032,15 @@ var __exports__ = (() => {
       const nextIndices = geometry.indices[l + 1];
       for (let i3 = 0, il = indices.length; i3 < il; ++i3) {
         const start = indices[i3];
-        const end = i3 === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i3 + 1];
+        const end = i3 === il - 1 ? (
+          // last line, so either read to:
+          nextIndices === void 0 ? geometry.data.length : nextIndices[0]
+        ) : indices[i3 + 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, {
@@ -2017,10 +2064,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;
   }
@@ -2029,70 +2073,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;
   }
@@ -2194,6 +2200,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;
@@ -2233,6 +2240,7 @@ var __exports__ = (() => {
         lines.push(line);
       return lines;
     }
+    // eslint-disable-next-line max-statements
     bbox() {
       const pbf = this._pbf;
       pbf.pos = this._geometry;
@@ -2319,11 +2327,7 @@ var __exports__ = (() => {
       if (typeof options === "function") {
         return this._toGeoJSON(options);
       }
-      const {
-        x: x3,
-        y: y2,
-        z
-      } = options;
+      const { x: x3, y: y2, z } = options;
       const size = this.extent * Math.pow(2, z);
       const x0 = this.extent * x3;
       const y0 = this.extent * y2;
@@ -2353,6 +2357,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(i3) {
       if (i3 < 0 || i3 >= this._features.length) {
         throw new Error("feature index out of bounds");
@@ -2453,12 +2462,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) {
@@ -2497,6 +2501,7 @@ var __exports__ = (() => {
   var y;
   var i;
   var VectorTileFeature2 = class {
+    // eslint-disable-next-line max-params
     constructor(pbf, end, extent, keys, values, geometryInfo) {
       this.properties = {};
       this.extent = extent;
@@ -2509,6 +2514,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;
@@ -2545,11 +2551,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;
@@ -2559,19 +2567,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);
@@ -2585,11 +2587,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;
       }
@@ -2599,11 +2597,7 @@ var __exports__ = (() => {
       if (typeof options === "function") {
         return this._toBinaryCoordinates(options);
       }
-      const {
-        x: x3,
-        y: y2,
-        z
-      } = options;
+      const { x: x3, y: y2, z } = options;
       const size = this.extent * Math.pow(2, z);
       const x0 = this.extent * x3;
       const y0 = this.extent * y2;
@@ -2625,13 +2619,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(i3, geometryInfo) {
       if (i3 < 0 || i3 >= this._features.length) {
         throw new Error("feature index out of bounds");
       }
       this._pbf.pos = this._features[i3];
       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) {
@@ -2683,10 +2691,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",
@@ -2768,9 +2773,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");
@@ -2778,23 +2781,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 i3 = 0; i3 < line.length; i3++) {
       const p = line[i3];
       p[0] /= extent;
@@ -2802,23 +2809,27 @@ var __exports__ = (() => {
     }
   }
   function transformToLocalCoordinatesBinary(data, feature) {
-    const {
-      extent
-    } = feature;
+    const { extent } = feature;
     for (let i3 = 0, il = data.length; i3 < il; ++i3) {
       data[i3] /= extent;
     }
   }
 
   // ../mvt/src/mvt-loader.ts
-  var VERSION2 = true ? "4.2.0-alpha.3" : "latest";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var MVTWorkerLoader = {
     name: "Mapbox Vector Tile",
     id: "mvt",
     module: "mvt",
     version: VERSION2,
+    // 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: {
@@ -2892,9 +2903,7 @@ var __exports__ = (() => {
       name: key,
       ...attributeTypeToFieldType(String(datatype))
     }));
-    const layer2 = {
-      ...layer
-    };
+    const layer2 = { ...layer };
     delete layer2.fields;
     return {
       name: layer.id || "",
@@ -2936,9 +2945,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,
@@ -2950,7 +2957,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;
   }
@@ -3015,6 +3025,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") {
@@ -3038,13 +3050,11 @@ var __exports__ = (() => {
     const type = aType.toLowerCase();
     if (!type || !attrTypeMap[type]) {
     }
-    return attrTypeMap[type] || {
-      type: "string"
-    };
+    return attrTypeMap[type] || { type: "string" };
   }
 
   // ../mvt/src/tilejson-loader.ts
-  var VERSION3 = true ? "4.2.0-alpha.3" : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TileJSONLoader = {
     name: "TileJSON",
     id: "tilejson",
@@ -3062,29 +3072,23 @@ 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);
     }
   };
 
-  // ../../node_modules/pmtiles/dist/index.mjs
+  // ../../node_modules/pmtiles/dist/index.js
   var dist_exports = {};
   __export(dist_exports, {
     Compression: () => Compression,
     EtagMismatch: () => EtagMismatch,
     FetchSource: () => FetchSource,
-    FileAPISource: () => FileAPISource,
+    FileSource: () => FileSource,
     PMTiles: () => PMTiles,
     Protocol: () => Protocol,
     ResolvedValueCache: () => ResolvedValueCache,
@@ -3098,6 +3102,7 @@ var __exports__ = (() => {
     tileIdToZxy: () => tileIdToZxy,
     zxyToTileId: () => zxyToTileId
   });
+  var __pow = Math.pow;
   var __async = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
@@ -3121,8 +3126,77 @@ var __exports__ = (() => {
   var u8 = Uint8Array;
   var u16 = Uint16Array;
   var i32 = Int32Array;
-  var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
-  var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
+  var fleb = new u8([
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    2,
+    2,
+    3,
+    3,
+    3,
+    3,
+    4,
+    4,
+    4,
+    4,
+    5,
+    5,
+    5,
+    5,
+    0,
+    /* unused */
+    0,
+    0,
+    /* impossible */
+    0
+  ]);
+  var fdeb = new u8([
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    2,
+    2,
+    3,
+    3,
+    4,
+    4,
+    5,
+    5,
+    6,
+    6,
+    7,
+    7,
+    8,
+    8,
+    9,
+    9,
+    10,
+    10,
+    11,
+    11,
+    12,
+    12,
+    13,
+    13,
+    /* unused */
+    0,
+    0
+  ]);
   var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
   var freb = function(eb, start) {
     var b = new u16(31);
@@ -3251,6 +3325,7 @@ var __exports__ = (() => {
     "filename too long",
     "stream finishing",
     "invalid zip data"
+    // determined by unknown compression method
   ];
   var err = function(ind, msg, nt) {
     var e = new Error(msg || ec[ind]);
@@ -3452,10 +3527,10 @@ var __exports__ = (() => {
   } catch (e) {
   }
   var shift = (n, shift2) => {
-    return n * Math.pow(2, shift2);
+    return n * __pow(2, shift2);
   };
   var unshift = (n, shift2) => {
-    return Math.floor(n / Math.pow(2, shift2));
+    return Math.floor(n / __pow(2, shift2));
   };
   var getUint24 = (view, pos) => {
     return shift(view.getUint16(pos + 1, true), 8) + view.getUint8(pos);
@@ -3464,40 +3539,40 @@ var __exports__ = (() => {
     return shift(view.getUint32(pos + 2, true), 16) + view.getUint16(pos, true);
   };
   var compare = (tz, tx, ty, view, i3) => {
-    if (tz != view.getUint8(i3))
+    if (tz !== view.getUint8(i3))
       return tz - view.getUint8(i3);
     const x3 = getUint24(view, i3 + 1);
-    if (tx != x3)
+    if (tx !== x3)
       return tx - x3;
     const y2 = getUint24(view, i3 + 4);
-    if (ty != y2)
+    if (ty !== y2)
       return ty - y2;
     return 0;
   };
   var queryLeafdir = (view, z, x3, y2) => {
-    const offset_len = queryView(view, z | 128, x3, y2);
-    if (offset_len) {
+    const offsetLen = queryView(view, z | 128, x3, y2);
+    if (offsetLen) {
       return {
         z,
         x: x3,
         y: y2,
-        offset: offset_len[0],
-        length: offset_len[1],
-        is_dir: true
+        offset: offsetLen[0],
+        length: offsetLen[1],
+        isDir: true
       };
     }
     return null;
   };
   var queryTile = (view, z, x3, y2) => {
-    const offset_len = queryView(view, z, x3, y2);
-    if (offset_len) {
+    const offsetLen = queryView(view, z, x3, y2);
+    if (offsetLen) {
       return {
         z,
         x: x3,
         y: y2,
-        offset: offset_len[0],
-        length: offset_len[1],
-        is_dir: false
+        offset: offsetLen[0],
+        length: offsetLen[1],
+        isDir: false
       };
     }
     return null;
@@ -3519,10 +3594,10 @@ var __exports__ = (() => {
     return null;
   };
   var entrySort = (a, b) => {
-    if (a.is_dir && !b.is_dir) {
+    if (a.isDir && !b.isDir) {
       return 1;
     }
-    if (!a.is_dir && b.is_dir) {
+    if (!a.isDir && b.isDir) {
       return -1;
     }
     if (a.z !== b.z) {
@@ -3534,15 +3609,15 @@ var __exports__ = (() => {
     return a.y - b.y;
   };
   var parseEntry = (dataview, i3) => {
-    const z_raw = dataview.getUint8(i3 * 17);
-    const z = z_raw & 127;
+    const zRaw = dataview.getUint8(i3 * 17);
+    const z = zRaw & 127;
     return {
       z,
       x: getUint24(dataview, i3 * 17 + 1),
       y: getUint24(dataview, i3 * 17 + 4),
       offset: getUint48(dataview, i3 * 17 + 7),
       length: dataview.getUint32(i3 * 17 + 13, true),
-      is_dir: z_raw >> 7 === 1
+      isDir: zRaw >> 7 === 1
     };
   };
   var sortDir = (a) => {
@@ -3560,7 +3635,7 @@ var __exports__ = (() => {
     for (let i3 = 0; i3 < entries.length; i3++) {
       const entry = entries[i3];
       let z = entry.z;
-      if (entry.is_dir)
+      if (entry.isDir)
         z = z | 128;
       arr[i3 * 17] = z;
       arr[i3 * 17 + 1] = entry.x & 255;
@@ -3587,12 +3662,12 @@ var __exports__ = (() => {
       return null;
     const numEntries = view.byteLength / 17;
     const entry = parseEntry(view, numEntries - 1);
-    if (entry.is_dir) {
-      const leaf_level = entry.z;
-      const level_diff = tile.z - leaf_level;
-      const leaf_x = Math.trunc(tile.x / (1 << level_diff));
-      const leaf_y = Math.trunc(tile.y / (1 << level_diff));
-      return { z: leaf_level, x: leaf_x, y: leaf_y };
+    if (entry.isDir) {
+      const leafLevel = entry.z;
+      const levelDiff = tile.z - leafLevel;
+      const leafX = Math.trunc(tile.x / (1 << levelDiff));
+      const leafY = Math.trunc(tile.y / (1 << levelDiff));
+      return { z: leafLevel, x: leafX, y: leafY };
     }
     return null;
   };
@@ -3600,50 +3675,50 @@ var __exports__ = (() => {
     return __async(this, null, function* () {
       const resp = yield source.getBytes(0, 512e3);
       const dataview = new DataView(resp.data);
-      const json_size = dataview.getUint32(4, true);
-      const root_entries = dataview.getUint16(8, true);
+      const jsonSize = dataview.getUint32(4, true);
+      const rootEntries = dataview.getUint16(8, true);
       const dec = new TextDecoder("utf-8");
-      const json_metadata = JSON.parse(
-        dec.decode(new DataView(resp.data, 10, json_size))
+      const jsonMetadata = JSON.parse(
+        dec.decode(new DataView(resp.data, 10, jsonSize))
       );
-      let tile_compression = 0;
-      if (json_metadata.compression === "gzip") {
-        tile_compression = 2;
+      let tileCompression = 0;
+      if (jsonMetadata.compression === "gzip") {
+        tileCompression = 2;
       }
       let minzoom = 0;
-      if ("minzoom" in json_metadata) {
-        minzoom = +json_metadata.minzoom;
+      if ("minzoom" in jsonMetadata) {
+        minzoom = +jsonMetadata.minzoom;
       }
       let maxzoom = 0;
-      if ("maxzoom" in json_metadata) {
-        maxzoom = +json_metadata.maxzoom;
+      if ("maxzoom" in jsonMetadata) {
+        maxzoom = +jsonMetadata.maxzoom;
       }
-      let center_lon = 0;
-      let center_lat = 0;
-      let center_zoom = 0;
-      let min_lon = -180;
-      let min_lat = -85;
-      let max_lon = 180;
-      let max_lat = 85;
-      if (json_metadata.bounds) {
-        const split = json_metadata.bounds.split(",");
-        min_lon = +split[0];
-        min_lat = +split[1];
-        max_lon = +split[2];
-        max_lat = +split[3];
+      let centerLon = 0;
+      let centerLat = 0;
+      let centerZoom = 0;
+      let minLon = -180;
+      let minLat = -85;
+      let maxLon = 180;
+      let maxLat = 85;
+      if (jsonMetadata.bounds) {
+        const split = jsonMetadata.bounds.split(",");
+        minLon = +split[0];
+        minLat = +split[1];
+        maxLon = +split[2];
+        maxLat = +split[3];
       }
-      if (json_metadata.center) {
-        const split = json_metadata.center.split(",");
-        center_lon = +split[0];
-        center_lat = +split[1];
-        center_zoom = +split[2];
+      if (jsonMetadata.center) {
+        const split = jsonMetadata.center.split(",");
+        centerLon = +split[0];
+        centerLat = +split[1];
+        centerZoom = +split[2];
       }
       const header = {
         specVersion: dataview.getUint16(2, true),
-        rootDirectoryOffset: 10 + json_size,
-        rootDirectoryLength: root_entries * 17,
+        rootDirectoryOffset: 10 + jsonSize,
+        rootDirectoryLength: rootEntries * 17,
         jsonMetadataOffset: 10,
-        jsonMetadataLength: json_size,
+        jsonMetadataLength: jsonSize,
         leafDirectoryOffset: 0,
         leafDirectoryLength: void 0,
         tileDataOffset: 0,
@@ -3653,17 +3728,17 @@ var __exports__ = (() => {
         numTileContents: 0,
         clustered: false,
         internalCompression: 1,
-        tileCompression: tile_compression,
+        tileCompression,
         tileType: 1,
         minZoom: minzoom,
         maxZoom: maxzoom,
-        minLon: min_lon,
-        minLat: min_lat,
-        maxLon: max_lon,
-        maxLat: max_lat,
-        centerZoom: center_zoom,
-        centerLon: center_lon,
-        centerLat: center_lat,
+        minLon,
+        minLat,
+        maxLon,
+        maxLat,
+        centerZoom,
+        centerLon,
+        centerLat,
         etag: resp.etag
       };
       return header;
@@ -3671,59 +3746,59 @@ var __exports__ = (() => {
   }
   function getZxy(header, source, cache, z, x3, y2, signal) {
     return __async(this, null, function* () {
-      let root_dir = yield cache.getArrayBuffer(
+      let rootDir = yield cache.getArrayBuffer(
         source,
         header.rootDirectoryOffset,
         header.rootDirectoryLength,
         header
       );
       if (header.specVersion === 1) {
-        root_dir = sortDir(root_dir);
+        rootDir = sortDir(rootDir);
       }
-      const entry = queryTile(new DataView(root_dir), z, x3, y2);
+      const entry = queryTile(new DataView(rootDir), z, x3, y2);
       if (entry) {
         const resp = yield source.getBytes(entry.offset, entry.length, signal);
-        let tile_data = resp.data;
-        const view = new DataView(tile_data);
-        if (view.getUint8(0) == 31 && view.getUint8(1) == 139) {
-          tile_data = decompressSync(new Uint8Array(tile_data));
+        let tileData = resp.data;
+        const view = new DataView(tileData);
+        if (view.getUint8(0) === 31 && view.getUint8(1) === 139) {
+          tileData = decompressSync(new Uint8Array(tileData));
         }
         return {
-          data: tile_data
+          data: tileData
         };
       }
-      const leafcoords = deriveLeaf(new DataView(root_dir), { z, x: x3, y: y2 });
+      const leafcoords = deriveLeaf(new DataView(rootDir), { z, x: x3, y: y2 });
       if (leafcoords) {
-        const leafdir_entry = queryLeafdir(
-          new DataView(root_dir),
+        const leafdirEntry = queryLeafdir(
+          new DataView(rootDir),
           leafcoords.z,
           leafcoords.x,
           leafcoords.y
         );
-        if (leafdir_entry) {
-          let leaf_dir = yield cache.getArrayBuffer(
+        if (leafdirEntry) {
+          let leafDir = yield cache.getArrayBuffer(
             source,
-            leafdir_entry.offset,
-            leafdir_entry.length,
+            leafdirEntry.offset,
+            leafdirEntry.length,
             header
           );
           if (header.specVersion === 1) {
-            leaf_dir = sortDir(leaf_dir);
+            leafDir = sortDir(leafDir);
           }
-          const tile_entry = queryTile(new DataView(leaf_dir), z, x3, y2);
-          if (tile_entry) {
+          const tileEntry = queryTile(new DataView(leafDir), z, x3, y2);
+          if (tileEntry) {
             const resp = yield source.getBytes(
-              tile_entry.offset,
-              tile_entry.length,
+              tileEntry.offset,
+              tileEntry.length,
               signal
             );
-            let tile_data = resp.data;
-            const view = new DataView(tile_data);
-            if (view.getUint8(0) == 31 && view.getUint8(1) == 139) {
-              tile_data = decompressSync(new Uint8Array(tile_data));
+            let tileData = resp.data;
+            const view = new DataView(tileData);
+            if (view.getUint8(0) === 31 && view.getUint8(1) === 139) {
+              tileData = decompressSync(new Uint8Array(tileData));
             }
             return {
-              data: tile_data
+              data: tileData
             };
           }
         }
@@ -3739,7 +3814,7 @@ var __exports__ = (() => {
     let loaded = false;
     let mimeType = "";
     const cls = L.GridLayer.extend({
-      createTile: function(coord, done) {
+      createTile: (coord, done) => {
         const el = document.createElement("img");
         const controller = new AbortController();
         const signal = controller.signal;
@@ -3748,17 +3823,17 @@ var __exports__ = (() => {
         };
         if (!loaded) {
           source.getHeader().then((header) => {
-            if (header.tileType == 1) {
+            if (header.tileType === 1) {
               console.error(
                 "Error: archive contains MVT vector tiles, but leafletRasterLayer is for displaying raster tiles. See https://github.com/protomaps/PMTiles/tree/main/js for details."
               );
-            } else if (header.tileType == 2) {
+            } else if (header.tileType === 2) {
               mimeType = "image/png";
-            } else if (header.tileType == 3) {
+            } else if (header.tileType === 3) {
               mimeType = "image/jpeg";
-            } else if (header.tileType == 4) {
+            } else if (header.tileType === 4) {
               mimeType = "image/webp";
-            } else if (header.tileType == 5) {
+            } else if (header.tileType === 5) {
               mimeType = "image/avif";
             }
           });
@@ -3769,8 +3844,8 @@ var __exports__ = (() => {
             const blob = new Blob([arr.data], { type: mimeType });
             const imageUrl = window.URL.createObjectURL(blob);
             el.src = imageUrl;
-            el.cancel = null;
-            done(null, el);
+            el.cancel = void 0;
+            done(void 0, el);
           }
         }).catch((e) => {
           if (e.name !== "AbortError") {
@@ -3799,82 +3874,77 @@ var __exports__ = (() => {
     });
     return new cls(options);
   };
+  var v3compat = (v4) => (requestParameters, arg2) => {
+    if (arg2 instanceof AbortController) {
+      return v4(requestParameters, arg2);
+    }
+    const abortController = new AbortController();
+    v4(requestParameters, abortController).then(
+      (result) => {
+        return arg2(
+          void 0,
+          result.data,
+          result.cacheControl || "",
+          result.expires || ""
+        );
+      },
+      (err2) => {
+        return arg2(err2);
+      }
+    ).catch((e) => {
+      return arg2(e);
+    });
+    return { cancel: () => abortController.abort() };
+  };
   var Protocol = class {
     constructor() {
-      this.tile = (params, callback) => {
-        if (params.type == "json") {
-          const pmtiles_url = params.url.substr(10);
-          let instance = this.tiles.get(pmtiles_url);
-          if (!instance) {
-            instance = new PMTiles(pmtiles_url);
-            this.tiles.set(pmtiles_url, instance);
+      this.tilev4 = (params, abortController) => __async(this, null, function* () {
+        if (params.type === "json") {
+          const pmtilesUrl2 = params.url.substr(10);
+          let instance2 = this.tiles.get(pmtilesUrl2);
+          if (!instance2) {
+            instance2 = new PMTiles(pmtilesUrl2);
+            this.tiles.set(pmtilesUrl2, instance2);
           }
-          instance.getHeader().then((h) => {
-            const tilejson = {
-              tiles: [params.url + "/{z}/{x}/{y}"],
+          const h = yield instance2.getHeader();
+          return {
+            data: {
+              tiles: [`${params.url}/{z}/{x}/{y}`],
               minzoom: h.minZoom,
               maxzoom: h.maxZoom,
               bounds: [h.minLon, h.minLat, h.maxLon, h.maxLat]
-            };
-            callback(null, tilejson, null, null);
-          }).catch((e) => {
-            callback(e, null, null, null);
-          });
-          return {
-            cancel: () => {
             }
           };
-        } else {
-          const re = new RegExp(/pmtiles:\/\/(.+)\/(\d+)\/(\d+)\/(\d+)/);
-          const result = params.url.match(re);
-          if (!result) {
-            throw new Error("Invalid PMTiles protocol URL");
-            return {
-              cancel: () => {
-              }
-            };
-          }
-          const pmtiles_url = result[1];
-          let instance = this.tiles.get(pmtiles_url);
-          if (!instance) {
-            instance = new PMTiles(pmtiles_url);
-            this.tiles.set(pmtiles_url, instance);
-          }
-          const z = result[2];
-          const x3 = result[3];
-          const y2 = result[4];
-          const controller = new AbortController();
-          const signal = controller.signal;
-          let cancel = () => {
-            controller.abort();
-          };
-          instance.getHeader().then((header) => {
-            instance.getZxy(+z, +x3, +y2, signal).then((resp) => {
-              if (resp) {
-                callback(
-                  null,
-                  new Uint8Array(resp.data),
-                  resp.cacheControl,
-                  resp.expires
-                );
-              } else {
-                if (header.tileType == 1) {
-                  callback(null, new Uint8Array(), null, null);
-                } else {
-                  callback(null, null, null, null);
-                }
-              }
-            }).catch((e) => {
-              if (e.name !== "AbortError") {
-                callback(e, null, null, null);
-              }
-            });
-          });
+        }
+        const re = new RegExp(/pmtiles:\/\/(.+)\/(\d+)\/(\d+)\/(\d+)/);
+        const result = params.url.match(re);
+        if (!result) {
+          throw new Error("Invalid PMTiles protocol URL");
+        }
+        const pmtilesUrl = result[1];
+        let instance = this.tiles.get(pmtilesUrl);
+        if (!instance) {
+          instance = new PMTiles(pmtilesUrl);
+          this.tiles.set(pmtilesUrl, instance);
+        }
+        const z = result[2];
+        const x3 = result[3];
+        const y2 = result[4];
+        const header = yield instance.getHeader();
+        const resp = yield instance == null ? void 0 : instance.getZxy(+z, +x3, +y2, abortController.signal);
+        if (resp) {
           return {
-            cancel
+            data: new Uint8Array(resp.data),
+            cacheControl: resp.cacheControl,
+            expires: resp.expires
           };
         }
-      };
+        if (header.tileType === 1) {
+          return { data: new Uint8Array() };
+        }
+        return { data: null };
+      });
+      this.tile = v3compat(this.tilev4);
       this.tiles = /* @__PURE__ */ new Map();
     }
     add(p) {
@@ -3889,9 +3959,8 @@ var __exports__ = (() => {
   }
   function readVarintRemainder(l, p) {
     const buf = p.buf;
-    let h, b;
-    b = buf[p.pos++];
-    h = (b & 112) >> 4;
+    let b = buf[p.pos++];
+    let h = (b & 112) >> 4;
     if (b < 128)
       return toNum(l, h);
     b = buf[p.pos++];
@@ -3918,9 +3987,8 @@ var __exports__ = (() => {
   }
   function readVarint(p) {
     const buf = p.buf;
-    let val, b;
-    b = buf[p.pos++];
-    val = b & 127;
+    let b = buf[p.pos++];
+    let val = b & 127;
     if (b < 128)
       return val;
     b = buf[p.pos++];
@@ -3940,8 +4008,8 @@ var __exports__ = (() => {
     return readVarintRemainder(val, p);
   }
   function rotate(n, xy, rx, ry) {
-    if (ry == 0) {
-      if (rx == 1) {
+    if (ry === 0) {
+      if (rx === 1) {
         xy[0] = n - 1 - xy[0];
         xy[1] = n - 1 - xy[1];
       }
@@ -3951,7 +4019,7 @@ var __exports__ = (() => {
     }
   }
   function idOnLevel(z, pos) {
-    const n = Math.pow(2, z);
+    const n = __pow(2, z);
     let rx = pos;
     let ry = pos;
     let t = pos;
@@ -4001,11 +4069,11 @@ var __exports__ = (() => {
     if (z > 26) {
       throw Error("Tile zoom level exceeds max safe number limit (26)");
     }
-    if (x3 > Math.pow(2, z) - 1 || y2 > Math.pow(2, z) - 1) {
+    if (x3 > __pow(2, z) - 1 || y2 > __pow(2, z) - 1) {
       throw Error("tile x/y outside zoom level bounds");
     }
     const acc = tzValues[z];
-    const n = Math.pow(2, z);
+    const n = __pow(2, z);
     let rx = 0;
     let ry = 0;
     let d = 0;
@@ -4022,13 +4090,13 @@ var __exports__ = (() => {
   }
   function tileIdToZxy(i3) {
     let acc = 0;
-    let z = 0;
+    const z = 0;
     for (let z2 = 0; z2 < 27; z2++) {
-      const num_tiles = (1 << z2) * (1 << z2);
-      if (acc + num_tiles > i3) {
+      const numTiles = (1 << z2) * (1 << z2);
+      if (acc + numTiles > i3) {
         return idOnLevel(z2, i3 - acc);
       }
-      acc += num_tiles;
+      acc += numTiles;
     }
     throw Error("Tile zoom level exceeds max safe number limit (26)");
   }
@@ -4044,19 +4112,22 @@ var __exports__ = (() => {
     return __async(this, null, function* () {
       if (compression === 1 || compression === 0) {
         return buf;
-      } else if (compression === 2) {
-        if (typeof globalThis.DecompressionStream == "undefined") {
+      }
+      if (compression === 2) {
+        if (typeof globalThis.DecompressionStream === "undefined") {
           return decompressSync(new Uint8Array(buf));
-        } else {
-          let stream = new Response(buf).body;
-          let result = stream.pipeThrough(
-            new globalThis.DecompressionStream("gzip")
-          );
-          return new Response(result).arrayBuffer();
         }
-      } else {
-        throw Error("Compression method not supported");
+        const stream = new Response(buf).body;
+        if (!stream) {
+          throw Error("Failed to read response stream");
+        }
+        const result = stream.pipeThrough(
+          // biome-ignore lint: needed to detect DecompressionStream in browser+node+cloudflare workers
+          new globalThis.DecompressionStream("gzip")
+        );
+        return new Response(result).arrayBuffer();
       }
+      throw Error("Compression method not supported");
     });
   }
   var TileType = /* @__PURE__ */ ((TileType22) => {
@@ -4093,7 +4164,7 @@ var __exports__ = (() => {
     }
     return null;
   }
-  var FileAPISource = class {
+  var FileSource = class {
     constructor(file) {
       this.file = file;
     }
@@ -4109,39 +4180,65 @@ var __exports__ = (() => {
     }
   };
   var FetchSource = class {
-    constructor(url) {
+    constructor(url, customHeaders = new Headers()) {
       this.url = url;
+      this.customHeaders = customHeaders;
+      this.mustReload = false;
     }
     getKey() {
       return this.url;
     }
-    getBytes(offset, length2, signal) {
+    setHeaders(customHeaders) {
+      this.customHeaders = customHeaders;
+    }
+    getBytes(offset, length2, passedSignal, etag) {
       return __async(this, null, function* () {
         let controller;
-        if (!signal) {
+        let signal;
+        if (passedSignal) {
+          signal = passedSignal;
+        } else {
           controller = new AbortController();
           signal = controller.signal;
         }
+        const requestHeaders = new Headers(this.customHeaders);
+        requestHeaders.set("range", `bytes=${offset}-${offset + length2 - 1}`);
+        let cache;
+        if (this.mustReload) {
+          cache = "reload";
+        }
         let resp = yield fetch(this.url, {
           signal,
-          headers: { Range: "bytes=" + offset + "-" + (offset + length2 - 1) }
+          cache,
+          headers: requestHeaders
+          //biome-ignore lint: "cache" is incompatible between cloudflare workers and browser
         });
-        if (resp.status === 416 && offset === 0) {
-          const content_range = resp.headers.get("Content-Range");
-          if (!content_range || !content_range.startsWith("bytes */")) {
+        if (offset === 0 && resp.status === 416) {
+          const contentRange = resp.headers.get("Content-Range");
+          if (!contentRange || !contentRange.startsWith("bytes */")) {
             throw Error("Missing content-length on 416 response");
           }
-          const actual_length = +content_range.substr(8);
+          const actualLength = +contentRange.substr(8);
           resp = yield fetch(this.url, {
             signal,
-            headers: { Range: "bytes=0-" + (actual_length - 1) }
+            cache: "reload",
+            headers: { range: `bytes=0-${actualLength - 1}` }
+            //biome-ignore lint: "cache" is incompatible between cloudflare workers and browser
           });
         }
+        let newEtag = resp.headers.get("Etag");
+        if (newEtag == null ? void 0 : newEtag.startsWith("W/")) {
+          newEtag = null;
+        }
+        if (resp.status === 416 || etag && newEtag && newEtag !== etag) {
+          this.mustReload = true;
+          throw new EtagMismatch(etag);
+        }
         if (resp.status >= 300) {
-          throw Error("Bad response code: " + resp.status);
+          throw Error(`Bad response code: ${resp.status}`);
         }
-        const content_length = resp.headers.get("Content-Length");
-        if (resp.status === 200 && (!content_length || +content_length > length2)) {
+        const contentLength = resp.headers.get("Content-Length");
+        if (resp.status === 200 && (!contentLength || +contentLength > length2)) {
           if (controller)
             controller.abort();
           throw Error(
@@ -4151,7 +4248,7 @@ var __exports__ = (() => {
         const a = yield resp.arrayBuffer();
         return {
           data: a,
-          etag: resp.headers.get("ETag") || void 0,
+          etag: newEtag || void 0,
           cacheControl: resp.headers.get("Cache-Control") || void 0,
           expires: resp.headers.get("Expires") || void 0
         };
@@ -4161,18 +4258,18 @@ var __exports__ = (() => {
   function getUint64(v, offset) {
     const wh = v.getUint32(offset + 4, true);
     const wl = v.getUint32(offset + 0, true);
-    return wh * Math.pow(2, 32) + wl;
+    return wh * __pow(2, 32) + wl;
   }
   function bytesToHeader(bytes, etag) {
     const v = new DataView(bytes);
-    const spec_version = v.getUint8(7);
-    if (spec_version > 3) {
+    const specVersion = v.getUint8(7);
+    if (specVersion > 3) {
       throw Error(
-        `Archive is spec version ${spec_version} but this library supports up to spec version 3`
+        `Archive is spec version ${specVersion} but this library supports up to spec version 3`
       );
     }
     return {
-      specVersion: spec_version,
+      specVersion,
       rootDirectoryOffset: getUint64(v, 8),
       rootDirectoryLength: getUint64(v, 16),
       jsonMetadataOffset: getUint64(v, 24),
@@ -4233,7 +4330,8 @@ var __exports__ = (() => {
         "PMTiles spec version 2 has been deprecated; please see github.com/protomaps/PMTiles for tools to upgrade"
       );
       return 2;
-    } else if (v.getUint16(2, true) === 1) {
+    }
+    if (v.getUint16(2, true) === 1) {
       console.warn(
         "PMTiles spec version 1 has been deprecated; please see github.com/protomaps/PMTiles for tools to upgrade"
       );
@@ -4243,7 +4341,7 @@ var __exports__ = (() => {
   }
   var EtagMismatch = class extends Error {
   };
-  function getHeaderAndRoot(source, decompress, prefetch, current_etag) {
+  function getHeaderAndRoot(source, decompress) {
     return __async(this, null, function* () {
       const resp = yield source.getBytes(0, 16384);
       const v = new DataView(resp.data);
@@ -4254,34 +4352,21 @@ var __exports__ = (() => {
         return [yield v2_default.getHeader(source)];
       }
       const headerData = resp.data.slice(0, HEADER_SIZE_BYTES);
-      let resp_etag = resp.etag;
-      if (current_etag && resp.etag != current_etag) {
-        console.warn(
-          "ETag conflict detected; your HTTP server might not support content-based ETag headers. ETags disabled for " + source.getKey()
-        );
-        resp_etag = void 0;
-      }
-      const header = bytesToHeader(headerData, resp_etag);
-      if (prefetch) {
-        const rootDirData = resp.data.slice(
-          header.rootDirectoryOffset,
-          header.rootDirectoryOffset + header.rootDirectoryLength
-        );
-        const dirKey = source.getKey() + "|" + (header.etag || "") + "|" + header.rootDirectoryOffset + "|" + header.rootDirectoryLength;
-        const rootDir = deserializeIndex(
-          yield decompress(rootDirData, header.internalCompression)
-        );
-        return [header, [dirKey, rootDir.length, rootDir]];
-      }
-      return [header, void 0];
+      const header = bytesToHeader(headerData, resp.etag);
+      const rootDirData = resp.data.slice(
+        header.rootDirectoryOffset,
+        header.rootDirectoryOffset + header.rootDirectoryLength
+      );
+      const dirKey = `${source.getKey()}|${header.etag || ""}|${header.rootDirectoryOffset}|${header.rootDirectoryLength}`;
+      const rootDir = deserializeIndex(
+        yield decompress(rootDirData, header.internalCompression)
+      );
+      return [header, [dirKey, rootDir.length, rootDir]];
     });
   }
   function getDirectory(source, decompress, offset, length2, header) {
     return __async(this, null, function* () {
-      const resp = yield source.getBytes(offset, length2);
-      if (header.etag && header.etag !== resp.etag) {
-        throw new EtagMismatch(resp.etag);
-      }
+      const resp = yield source.getBytes(offset, length2, void 0, header.etag);
       const data = yield decompress(resp.data, header.internalCompression);
       const directory = deserializeIndex(data);
       if (directory.length === 0) {
@@ -4295,23 +4380,18 @@ var __exports__ = (() => {
       this.cache = /* @__PURE__ */ new Map();
       this.maxCacheEntries = maxCacheEntries;
       this.counter = 1;
-      this.prefetch = prefetch;
       this.decompress = decompress;
     }
-    getHeader(source, current_etag) {
+    getHeader(source) {
       return __async(this, null, function* () {
         const cacheKey = source.getKey();
-        if (this.cache.has(cacheKey)) {
-          this.cache.get(cacheKey).lastUsed = this.counter++;
-          const data = this.cache.get(cacheKey).data;
+        const cacheValue = this.cache.get(cacheKey);
+        if (cacheValue) {
+          cacheValue.lastUsed = this.counter++;
+          const data = cacheValue.data;
           return data;
         }
-        const res = yield getHeaderAndRoot(
-          source,
-          this.decompress,
-          this.prefetch,
-          current_etag
-        );
+        const res = yield getHeaderAndRoot(source, this.decompress);
         if (res[1]) {
           this.cache.set(res[1][0], {
             lastUsed: this.counter++,
@@ -4328,10 +4408,11 @@ var __exports__ = (() => {
     }
     getDirectory(source, offset, length2, header) {
       return __async(this, null, function* () {
-        const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length2;
-        if (this.cache.has(cacheKey)) {
-          this.cache.get(cacheKey).lastUsed = this.counter++;
-          const data = this.cache.get(cacheKey).data;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheValue = this.cache.get(cacheKey);
+        if (cacheValue) {
+          cacheValue.lastUsed = this.counter++;
+          const data = cacheValue.data;
           return data;
         }
         const directory = yield getDirectory(
@@ -4349,18 +4430,17 @@ var __exports__ = (() => {
         return directory;
       });
     }
+    // for v2 backwards compatibility
     getArrayBuffer(source, offset, length2, header) {
       return __async(this, null, function* () {
-        const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length2;
-        if (this.cache.has(cacheKey)) {
-          this.cache.get(cacheKey).lastUsed = this.counter++;
-          const data = yield this.cache.get(cacheKey).data;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheValue = this.cache.get(cacheKey);
+        if (cacheValue) {
+          cacheValue.lastUsed = this.counter++;
+          const data = yield cacheValue.data;
           return data;
         }
-        const resp = yield source.getBytes(offset, length2);
-        if (header.etag && header.etag !== resp.etag) {
-          throw new EtagMismatch(header.etag);
-        }
+        const resp = yield source.getBytes(offset, length2, void 0, header.etag);
         this.cache.set(cacheKey, {
           lastUsed: this.counter++,
           data: resp.data
@@ -4373,9 +4453,9 @@ var __exports__ = (() => {
       if (this.cache.size > this.maxCacheEntries) {
         let minUsed = Infinity;
         let minKey = void 0;
-        this.cache.forEach((cache_value, key) => {
-          if (cache_value.lastUsed < minUsed) {
-            minUsed = cache_value.lastUsed;
+        this.cache.forEach((cacheValue, key) => {
+          if (cacheValue.lastUsed < minUsed) {
+            minUsed = cacheValue.lastUsed;
             minKey = key;
           }
         });
@@ -4384,31 +4464,31 @@ var __exports__ = (() => {
         }
       }
     }
-    invalidate(source, current_etag) {
+    invalidate(source) {
       return __async(this, null, function* () {
         this.cache.delete(source.getKey());
-        yield this.getHeader(source, current_etag);
       });
     }
   };
   var SharedPromiseCache = class {
     constructor(maxCacheEntries = 100, prefetch = true, decompress = defaultDecompress) {
       this.cache = /* @__PURE__ */ new Map();
+      this.invalidations = /* @__PURE__ */ new Map();
       this.maxCacheEntries = maxCacheEntries;
       this.counter = 1;
-      this.prefetch = prefetch;
       this.decompress = decompress;
     }
-    getHeader(source, current_etag) {
+    getHeader(source) {
       return __async(this, null, function* () {
         const cacheKey = source.getKey();
-        if (this.cache.has(cacheKey)) {
-          this.cache.get(cacheKey).lastUsed = this.counter++;
-          const data = yield this.cache.get(cacheKey).data;
+        const cacheValue = this.cache.get(cacheKey);
+        if (cacheValue) {
+          cacheValue.lastUsed = this.counter++;
+          const data = yield cacheValue.data;
           return data;
         }
         const p = new Promise((resolve, reject) => {
-          getHeaderAndRoot(source, this.decompress, this.prefetch, current_etag).then((res) => {
+          getHeaderAndRoot(source, this.decompress).then((res) => {
             if (res[1]) {
               this.cache.set(res[1][0], {
                 lastUsed: this.counter++,
@@ -4427,10 +4507,11 @@ var __exports__ = (() => {
     }
     getDirectory(source, offset, length2, header) {
       return __async(this, null, function* () {
-        const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length2;
-        if (this.cache.has(cacheKey)) {
-          this.cache.get(cacheKey).lastUsed = this.counter++;
-          const data = yield this.cache.get(cacheKey).data;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheValue = this.cache.get(cacheKey);
+        if (cacheValue) {
+          cacheValue.lastUsed = this.counter++;
+          const data = yield cacheValue.data;
           return data;
         }
         const p = new Promise((resolve, reject) => {
@@ -4445,19 +4526,18 @@ var __exports__ = (() => {
         return p;
       });
     }
+    // for v2 backwards compatibility
     getArrayBuffer(source, offset, length2, header) {
       return __async(this, null, function* () {
-        const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length2;
-        if (this.cache.has(cacheKey)) {
-          this.cache.get(cacheKey).lastUsed = this.counter++;
-          const data = yield this.cache.get(cacheKey).data;
+        const cacheKey = `${source.getKey()}|${header.etag || ""}|${offset}|${length2}`;
+        const cacheValue = this.cache.get(cacheKey);
+        if (cacheValue) {
+          cacheValue.lastUsed = this.counter++;
+          const data = yield cacheValue.data;
           return data;
         }
         const p = new Promise((resolve, reject) => {
-          source.getBytes(offset, length2).then((resp) => {
-            if (header.etag && header.etag !== resp.etag) {
-              throw new EtagMismatch(resp.etag);
-            }
+          source.getBytes(offset, length2, void 0, header.etag).then((resp) => {
             resolve(resp.data);
             if (this.cache.has(cacheKey)) {
             }
@@ -4474,23 +4554,33 @@ var __exports__ = (() => {
       if (this.cache.size >= this.maxCacheEntries) {
         let minUsed = Infinity;
         let minKey = void 0;
-        this.cache.forEach(
-          (cache_value, key) => {
-            if (cache_value.lastUsed < minUsed) {
-              minUsed = cache_value.lastUsed;
-              minKey = key;
-            }
+        this.cache.forEach((cacheValue, key) => {
+          if (cacheValue.lastUsed < minUsed) {
+            minUsed = cacheValue.lastUsed;
+            minKey = key;
           }
-        );
+        });
         if (minKey) {
           this.cache.delete(minKey);
         }
       }
     }
-    invalidate(source, current_etag) {
+    invalidate(source) {
       return __async(this, null, function* () {
+        const key = source.getKey();
+        if (this.invalidations.get(key)) {
+          return yield this.invalidations.get(key);
+        }
         this.cache.delete(source.getKey());
-        yield this.getHeader(source, current_etag);
+        const p = new Promise((resolve, reject) => {
+          this.getHeader(source).then((h) => {
+            resolve();
+            this.invalidations.delete(key);
+          }).catch((e) => {
+            reject(e);
+          });
+        });
+        this.invalidations.set(key, p);
       });
     }
   };
@@ -4512,14 +4602,19 @@ var __exports__ = (() => {
         this.cache = new SharedPromiseCache();
       }
     }
+    /**
+     * Return the header of the archive,
+     * including information such as tile type, min/max zoom, bounds, and summary statistics.
+     */
     getHeader() {
       return __async(this, null, function* () {
         return yield this.cache.getHeader(this.source);
       });
     }
+    /** @hidden */
     getZxyAttempt(z, x3, y2, signal) {
       return __async(this, null, function* () {
-        const tile_id = zxyToTileId(z, x3, y2);
+        const tileId = zxyToTileId(z, x3, y2);
         const header = yield this.cache.getHeader(this.source);
         if (header.specVersion < 3) {
           return v2_default.getZxy(header, this.source, this.cache, z, x3, y2, signal);
@@ -4527,35 +4622,32 @@ var __exports__ = (() => {
         if (z < header.minZoom || z > header.maxZoom) {
           return void 0;
         }
-        let d_o = header.rootDirectoryOffset;
-        let d_l = header.rootDirectoryLength;
+        let dO = header.rootDirectoryOffset;
+        let dL = header.rootDirectoryLength;
         for (let depth = 0; depth <= 3; depth++) {
           const directory = yield this.cache.getDirectory(
             this.source,
-            d_o,
-            d_l,
+            dO,
+            dL,
             header
           );
-          const entry = findTile(directory, tile_id);
+          const entry = findTile(directory, tileId);
           if (entry) {
             if (entry.runLength > 0) {
               const resp = yield this.source.getBytes(
                 header.tileDataOffset + entry.offset,
                 entry.length,
-                signal
+                signal,
+                header.etag
               );
-              if (header.etag && header.etag !== resp.etag) {
-                throw new EtagMismatch(resp.etag);
-              }
               return {
                 data: yield this.decompress(resp.data, header.tileCompression),
                 cacheControl: resp.cacheControl,
                 expires: resp.expires
               };
-            } else {
-              d_o = header.leafDirectoryOffset + entry.offset;
-              d_l = entry.length;
             }
+            dO = header.leafDirectoryOffset + entry.offset;
+            dL = entry.length;
           } else {
             return void 0;
           }
@@ -4563,30 +4655,34 @@ var __exports__ = (() => {
         throw Error("Maximum directory depth exceeded");
       });
     }
+    /**
+     * Primary method to get a single tile bytes from an archive.
+     *
+     * Returns undefined if the tile does not exist in the archive.
+     */
     getZxy(z, x3, y2, signal) {
       return __async(this, null, function* () {
         try {
           return yield this.getZxyAttempt(z, x3, y2, signal);
         } catch (e) {
           if (e instanceof EtagMismatch) {
-            this.cache.invalidate(this.source, e.message);
+            this.cache.invalidate(this.source);
             return yield this.getZxyAttempt(z, x3, y2, signal);
-          } else {
-            throw e;
           }
+          throw e;
         }
       });
     }
+    /** @hidden */
     getMetadataAttempt() {
       return __async(this, null, function* () {
         const header = yield this.cache.getHeader(this.source);
         const resp = yield this.source.getBytes(
           header.jsonMetadataOffset,
-          header.jsonMetadataLength
+          header.jsonMetadataLength,
+          void 0,
+          header.etag
         );
-        if (header.etag && header.etag !== resp.etag) {
-          throw new EtagMismatch(resp.etag);
-        }
         const decompressed = yield this.decompress(
           resp.data,
           header.internalCompression
@@ -4595,27 +4691,28 @@ var __exports__ = (() => {
         return JSON.parse(dec.decode(decompressed));
       });
     }
+    /**
+     * Return the arbitrary JSON metadata of the archive.
+     */
     getMetadata() {
       return __async(this, null, function* () {
         try {
           return yield this.getMetadataAttempt();
         } catch (e) {
           if (e instanceof EtagMismatch) {
-            this.cache.invalidate(this.source, e.message);
+            this.cache.invalidate(this.source);
             return yield this.getMetadataAttempt();
-          } else {
-            throw e;
           }
+          throw e;
         }
       });
     }
   };
 
   // src/lib/parse-pmtiles.ts
-  var {
-    TileType: TileType2
-  } = dist_exports;
-  function parsePMTilesHeader(header, pmtilesMetadata, options, loadOptions) {
+  var { TileType: TileType2 } = dist_exports;
+  function parsePMTilesHeader(header, pmmetadata, options, loadOptions) {
+    const pmtilesMetadata = pmmetadata;
     let tilejson = null;
     if (pmtilesMetadata) {
       try {
@@ -4640,7 +4737,10 @@ var __exports__ = (() => {
       tileMIMEType: decodeTileType(header.tileType),
       minZoom: header.minZoom,
       maxZoom: header.maxZoom,
-      boundingBox: [[header.minLon, header.minLat], [header.maxLon, header.maxLat]],
+      boundingBox: [
+        [header.minLon, header.minLat],
+        [header.maxLon, header.maxLat]
+      ],
       center: [header.centerLon, header.centerLat],
       centerZoom: header.centerZoom,
       etag: header.etag
@@ -4677,6 +4777,7 @@ var __exports__ = (() => {
       this.blob = blob;
       this.key = key;
     }
+    // TODO - how is this used?
     getKey() {
       return this.blob.url || "";
     }
@@ -4685,18 +4786,19 @@ var __exports__ = (() => {
       const data = await slice.arrayBuffer();
       return {
         data
+        // etag: response.headers.get('ETag') || undefined,
+        // cacheControl: response.headers.get('Cache-Control') || undefined,
+        // expires: response.headers.get('Expires') || undefined
       };
     }
   };
 
   // src/pmtiles-source.ts
-  var {
-    PMTiles: PMTiles2
-  } = dist_exports;
+  var { PMTiles: PMTiles2 } = dist_exports;
   var PMTilesSource = class extends DataSource {
-    mimeType = null;
     constructor(props) {
       super(props);
+      this.mimeType = null;
       this.props = props;
       const url = typeof props.url === "string" ? resolvePath(props.url) : new BlobSource(props.url, "pmtiles");
       this.data = props.url;
@@ -4707,9 +4809,12 @@ var __exports__ = (() => {
     async getMetadata() {
       const pmtilesHeader = await this.pmtiles.getHeader();
       const pmtilesMetadata = await this.pmtiles.getMetadata();
-      const metadata = parsePMTilesHeader(pmtilesHeader, pmtilesMetadata, {
-        includeFormatHeader: false
-      }, this.loadOptions);
+      const metadata = parsePMTilesHeader(
+        pmtilesHeader,
+        pmtilesMetadata,
+        { includeFormatHeader: false },
+        this.loadOptions
+      );
       if (this.props.attributions) {
         metadata.attributions = [...this.props.attributions, ...metadata.attributions || []];
       }
@@ -4719,11 +4824,7 @@ var __exports__ = (() => {
       return metadata;
     }
     async getTile(tileParams) {
-      const {
-        x: x3,
-        y: y2,
-        zoom: z
-      } = tileParams;
+      const { x: x3, y: y2, zoom: z } = tileParams;
       const rangeResponse = await this.pmtiles.getZxy(z, x3, y2);
       const arrayBuffer = rangeResponse?.data;
       if (!arrayBuffer) {
@@ -4731,45 +4832,31 @@ var __exports__ = (() => {
       }
       return arrayBuffer;
     }
+    // Tile Source interface implementation: deck.gl compatible API
+    // TODO - currently only handles image tiles, not vector tiles
     async getTileData(tileParams) {
-      const {
-        x: x3,
-        y: y2,
-        z
-      } = tileParams.index;
+      const { x: x3, y: y2, z } = tileParams.index;
       const metadata = await this.metadata;
       switch (metadata.tileMIMEType) {
         case "application/vnd.mapbox-vector-tile":
-          return await this.getVectorTile({
-            x: x3,
-            y: y2,
-            zoom: z,
-            layers: []
-          });
+          return await this.getVectorTile({ x: x3, y: y2, zoom: z, layers: [] });
         default:
-          return await this.getImageTile({
-            x: x3,
-            y: y2,
-            zoom: z,
-            layers: []
-          });
+          return await this.getImageTile({ x: x3, y: y2, zoom: z, layers: [] });
       }
     }
+    // ImageTileSource interface implementation
     async getImageTile(tileParams) {
       const arrayBuffer = await this.getTile(tileParams);
       return arrayBuffer ? await ImageLoader.parse(arrayBuffer, this.loadOptions) : null;
     }
+    // VectorTileSource interface implementation
     async getVectorTile(tileParams) {
       const arrayBuffer = await this.getTile(tileParams);
       const loadOptions = {
         shape: "geojson-table",
         mvt: {
           coordinates: "wgs84",
-          tileIndex: {
-            x: tileParams.x,
-            y: tileParams.y,
-            z: tileParams.zoom
-          },
+          tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.zoom },
           ...this.loadOptions?.mvt
         },
         ...this.loadOptions
@@ -4777,7 +4864,7 @@ var __exports__ = (() => {
       return arrayBuffer ? await MVTLoader.parse(arrayBuffer, loadOptions) : null;
     }
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: