npm - @loaders.gl/pmtiles - Versions diffs - 4.2.0-alpha.4 → 4.2.0-alpha.6 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/dist/dist.dev.js +682 -549
package/dist/dist.min.js +14 -0
package/dist/index.cjs +19 -16
package/dist/index.cjs.map +7 -0
package/dist/index.d.ts +3 -3
package/dist/index.d.ts.map +1 -1
package/dist/index.js +3 -1
package/dist/lib/blob-source.js +29 -17
package/dist/lib/parse-pmtiles.d.ts +2 -2
package/dist/lib/parse-pmtiles.d.ts.map +1 -1
package/dist/lib/parse-pmtiles.js +75 -57
package/dist/pmtiles-source.d.ts +1 -1
package/dist/pmtiles-source.d.ts.map +1 -1
package/dist/pmtiles-source.js +83 -97
package/package.json +13 -9
package/src/lib/parse-pmtiles.ts +4 -2
package/dist/index.js.map +0 -1
package/dist/lib/blob-source.js.map +0 -1
package/dist/lib/parse-pmtiles.js.map +0 -1
package/dist/pmtiles-source.js.map +0 -1

package/dist/dist.dev.js CHANGED Viewed

@@ -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,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) {
@@ -907,7 +925,7 @@ var __exports__ = (() => {
   }
   // ../images/src/lib/utils/version.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -1094,10 +1112,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 +1148,7 @@ var __exports__ = (() => {
     }
     return {
       mimeType: mediaType.mimeType,
+      // TODO - decode width and height
       width: 0,
       height: 0
     };
@@ -1179,10 +1195,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 +1203,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 +1221,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 +1254,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 +1265,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 +1299,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 +1325,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 +1847,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 +1886,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 +1951,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 +1959,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 +1967,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 +1982,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 +2019,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 +2037,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 +2069,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 +2078,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;
   }
@@ -2180,6 +2191,14 @@ var __exports__ = (() => {
   // ../mvt/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"];
     }
@@ -2194,6 +2213,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 +2253,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 +2340,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;
@@ -2341,6 +2358,14 @@ var __exports__ = (() => {
   // ../mvt/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 = "";
@@ -2353,6 +2378,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");
@@ -2390,6 +2420,7 @@ var __exports__ = (() => {
   // ../mvt/src/lib/mapbox-vector-tile/vector-tile.ts
   var VectorTile = class {
+    layers;
     constructor(pbf, end) {
       this.layers = pbf.readFields(readTile, {}, end);
     }
@@ -2453,12 +2484,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 +2523,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;
@@ -2509,6 +2545,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 +2582,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 +2598,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 +2618,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 +2628,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;
@@ -2613,6 +2638,14 @@ var __exports__ = (() => {
   // ../mvt/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 = "";
@@ -2625,13 +2658,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) {
@@ -2662,6 +2709,7 @@ var __exports__ = (() => {
   // ../mvt/src/lib/binary-vector-tile/vector-tile.ts
   var VectorTile2 = class {
+    layers;
     constructor(pbf, end) {
       this.layers = pbf.readFields(readTile2, {}, end);
     }
@@ -2683,10 +2731,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 +2813,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 +2821,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 +2849,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.4" : "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 +2943,7 @@ var __exports__ = (() => {
       name: key,
       ...attributeTypeToFieldType(String(datatype))
     }));
-    const layer2 = {
-      ...layer
-    };
+    const layer2 = { ...layer };
     delete layer2.fields;
     return {
       name: layer.id || "",
@@ -2936,9 +2985,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 +2997,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 +3065,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 +3090,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.4" : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TileJSONLoader = {
     name: "TileJSON",
     id: "tilejson",
@@ -3062,29 +3112,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 +3142,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 +3166,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 +3365,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 +3567,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 +3579,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 +3634,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 +3649,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 +3675,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 +3702,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 +3715,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 +3768,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 +3786,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 +3854,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 +3863,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 +3884,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 +3914,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 +3999,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 +4027,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 +4048,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 +4059,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 +4109,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 +4130,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 +4152,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 +4204,7 @@ var __exports__ = (() => {
     }
     return null;
   }
-  var FileAPISource = class {
+  var FileSource = class {
     constructor(file) {
       this.file = file;
     }
@@ -4109,39 +4220,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 +4288,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 +4298,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 +4370,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 +4381,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 +4392,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 +4420,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 +4448,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 +4470,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 +4493,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 +4504,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 +4547,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 +4566,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 +4594,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 +4642,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 +4662,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 +4695,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 +4731,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 +4777,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
@@ -4673,10 +4813,13 @@ var __exports__ = (() => {
   // src/lib/blob-source.ts
   var BlobSource = class {
+    blob;
+    key;
     constructor(blob, key) {
       this.blob = blob;
       this.key = key;
     }
+    // TODO - how is this used?
     getKey() {
       return this.blob.url || "";
     }
@@ -4685,16 +4828,21 @@ 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 {
+    data;
+    props;
     mimeType = null;
+    pmtiles;
+    metadata;
     constructor(props) {
       super(props);
       this.props = props;
@@ -4707,9 +4855,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 +4870,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 +4878,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 +4910,7 @@ var __exports__ = (() => {
       return arrayBuffer ? await MVTLoader.parse(arrayBuffer, loadOptions) : null;
     }
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: