maplibre-tilepackage-protocol 1.1.0 → 1.2.0

package/dist/index.esm.js

@@ -0,0 +1,2031 @@
+import { VectorTile, VectorTileFeature, VectorTileLayer } from '@mapbox/vector-tile';
+import Protobuf from 'pbf';
+import Point from '@mapbox/point-geometry';
+import { fromVectorTileJs } from '@maplibre/vt-pbf';
+import protocolGlyphs from 'maplibre-local-glyphs';
+
+function stringEndsIn(string, endings) {
+  for (let i = 0; i < endings.length; i++) {
+    if (string.slice(-endings[i].length) == endings[i]) return endings[i];
+  }
+  return false;
+}
+
+const converter = (getData) => (requestParameters, arg2) => {
+  if (arg2 instanceof AbortController) {
+    return getData(requestParameters, arg2);
+  }
+  const abortController = new AbortController();
+  getData(requestParameters, abortController)
+    .then(
+      (result) => {
+        return arg2(
+          undefined,
+          result.data,
+          result.cacheControl || "",
+          result.expires || "",
+        );
+      },
+      (err) => {
+        return arg2(err);
+      },
+    )
+    .catch((e) => {
+      return arg2(e);
+    });
+  return { cancel: () => abortController.abort() };
+};
+
+/**
+ * MapLibre GL JS protocol. Must be added once globally.
+ */
+class Protocol {
+  /**
+   * Initialize the MapLibre TilePackage protocol.
+   *
+   * * metadata: also load the metadata section of the TilePackage. required for some "inspect" functionality
+   * and to automatically populate the map attribution. Requires an extra HTTP request.
+   * * errorOnMissingTile: When a vector MVT tile is missing from the archive, raise an error instead of
+   * returning the empty array. Not recommended. This is only to reproduce the behavior of ZXY tile APIs
+   * which some applications depend on when overzooming.
+   */
+  constructor(options) {
+    this.tiles = new Map();
+    this.metadata = options ? options.metadata || false : false;
+    this.errorOnMissingTile = options
+      ? options.errorOnMissingTile || false
+      : false;
+    this.debug = options ? options.debug || false : false;
+    this.getData = async (params, abortController) => {
+      if (params.type === "json") {
+        let tilePackageUrl = params.url.substr(14); // TODO fix this to be more robust
+        // at the moment we depend on that the tilePackage URL starts with tilepackage://
+
+        let spriteCheck = stringEndsIn(params.url, [
+          "/sprite",
+          "/sprite.json",
+          "/sprite@2x.json",
+        ]);
+        if (spriteCheck) {
+          // For some reason spirit and glyphs urls might loose the : in http://
+          tilePackageUrl = tilePackageUrl.replace(/(https?)\/\/?/g, "$1://");
+          tilePackageUrl = tilePackageUrl.slice(0, -spriteCheck.length);
+          if (spriteCheck == "/sprite") {
+            spriteCheck = "/sprite.json";
+          }
+        }
+
+        let instance = this.tiles.get(tilePackageUrl);
+        if (!instance) {
+          instance = new TilePackage(tilePackageUrl);
+          this.tiles.set(tilePackageUrl, instance);
+        }
+
+        if (spriteCheck) {
+          // This is a request for a sprite json
+          const file = `p12/resources/sprites${spriteCheck}`;
+          const resp = await instance.getResource(file, abortController.signal);
+          if (resp) {
+            const decoder = new TextDecoder("utf-8");
+            const json = JSON.parse(decoder.decode(resp.data));
+            return {
+              data: json,
+            };
+          }
+        }
+        // This is a request for a tile json
+        if (this.metadata) {
+          const tj = await instance.getTileJson(params.url);
+          if (this.debug)
+            console.debug("[tilepackage] tilejson (metadata)", tj);
+          return { data: tj };
+        }
+        const h = await instance.getHeader();
+        if (h.minLon >= h.maxLon || h.minLat >= h.maxLat) {
+          console.error(
+            `Bounds of TilePackage archive ${h.minLon},${h.minLat},${h.maxLon},${h.maxLat} are not valid.`,
+          );
+        }
+
+        const synthesized = {
+          tiles: [`${params.url}/{z}/{x}/{y}`],
+          minzoom: h.minZoom,
+          maxzoom: h.maxZoom,
+          bounds: [h.minLon, h.minLat, h.maxLon, h.maxLat],
+        };
+        if (this.debug)
+          console.debug("[tilepackage] tilejson (synthesized)", synthesized);
+        return { data: synthesized };
+        //}
+      }
+      // TODO handle other paths ???
+      let re = new RegExp(/tilepackage:\/\/(.+)\/(\d+)\/(\d+)\/(\d+)/);
+      let result = params.url.match(re);
+      if (!result) {
+        // This might be a request for glyphs or spirit
+        let tilePackageUrl = params.url.substr(14);
+        // For some reason spirit and glyphs urls might loose the : in http://
+        tilePackageUrl = tilePackageUrl.replace(/(https?)\/\/?/g, "$1://");
+        let spriteCheck = stringEndsIn(params.url, [
+          "/sprite",
+          "/sprite.png",
+          "/sprite@2x.png",
+        ]);
+        if (spriteCheck) {
+          // It looks like we are looking for a spirit png
+          tilePackageUrl = tilePackageUrl.slice(0, -spriteCheck.length);
+          if (spriteCheck == "/sprite") {
+            spriteCheck = "/sprite.png";
+          }
+          let instance = this.tiles.get(tilePackageUrl);
+          if (!instance) {
+            instance = new TilePackage(tilePackageUrl);
+            this.tiles.set(tilePackageUrl, instance);
+          }
+          const file = `p12/resources/sprites${spriteCheck}`;
+          const resp = await instance.getResource(file, abortController.signal);
+          if (resp) {
+            return {
+              data: new Uint8Array(resp.data),
+              cacheControl: resp.cacheControl,
+              expires: resp.expires,
+            };
+          }
+        } else {
+          // This is more likely a glyph url
+          re = new RegExp(/^tilepackage:\/\/(.+?)\/([^/]+)\/([^/]+)$/);
+          result = params.url.match(re);
+          if (result && isNaN(result[2])) {
+            const tilePackageUrl = result[1];
+            let instance = this.tiles.get(tilePackageUrl);
+            if (!instance) {
+              instance = new TilePackage(tilePackageUrl);
+              this.tiles.set(tilePackageUrl, instance);
+            }
+            const file = `p12/resources/fonts/${result[2]}/${result[3]}.pbf`;
+            const resp = await instance.getResource(
+              file,
+              abortController.signal,
+            );
+            if (resp) {
+              return {
+                data: new Uint8Array(resp.data),
+                cacheControl: resp.cacheControl,
+                expires: resp.expires,
+              };
+            }
+
+            // Fallback to local glyphs since we couldn't load the coorect from the vtpk
+            const fallback = await protocolGlyphs({
+              url: `glyphs://${result[2]}/${result[3]}`,
+            });
+            if (fallback) {
+              return fallback;
+            }
+
+            return { data: null };
+          }
+        }
+      }
+
+      if (!result) {
+        throw new Error("Invalid TilePackage protocol URL");
+      }
+      const tilePackageUrl = result[1];
+
+      let instance = this.tiles.get(tilePackageUrl);
+      if (!instance) {
+        instance = new TilePackage(tilePackageUrl);
+        this.tiles.set(tilePackageUrl, instance);
+      }
+      const z = result[2];
+      const x = result[3];
+      const y = result[4];
+      const header = await instance.getHeader();
+      const resp = await instance.getZxy(+z, +x, +y, abortController.signal);
+      if (this.debug)
+        console.debug("[tilepackage] tile fetch", {
+          z: +z,
+          x: +x,
+          y: +y,
+          found: !!resp,
+        });
+      if (resp) {
+        return {
+          data: new Uint8Array(resp.data),
+          cacheControl: resp.cacheControl,
+          expires: resp.expires,
+        };
+      }
+      if (header.tileType === "pbf") {
+        if (this.errorOnMissingTile) {
+          //*
+          const e = new Error(
+            `Tile [${z},${x},${y}] not found in Tile Package, normal for VTPK with variable depth.`,
+          );
+          e.name = "TileError";
+          if (this.debug)
+            console.debug("[tilepackage] missing tile", { z, x, y });
+          throw e;
+        }
+        return { data: new Uint8Array() };
+      } else {
+        return { data: null };
+      }
+    };
+
+    this.package = converter(this.getData);
+  }
+
+  /**
+   * Add a {@link TilePackage} instance to the global protocol instance.
+   *
+   * For remote fetch sources, references in MapLibre styles like tilePackage://http://...
+   * will resolve to the same instance if the URLs match.
+   */
+  add(p) {
+    this.tiles.set(p.source.getKey(), p);
+    if (this.debug)
+      console.debug("[tilepackage] add instance", p.source.getKey());
+  }
+
+  /**
+   * Fetch a {@link TilePackage} instance by URL, for remote TilePackage instances.
+   */
+  get(url) {
+    if (this.debug) console.debug("[tilepackage] get instance", url);
+    return this.tiles.get(url);
+  }
+}
+
+/* global globalThis */
+
+/**
+ * Interface for retrieving an archive from remote or local storage.
+ */
+class Source {
+  async getBytes() {
+    throw new Error("Not implemented");
+  }
+
+  getKey() {
+    throw new Error("Not implemented");
+  }
+}
+
+/**
+ * Use the Browser's File API, which is different from the NodeJS file API.
+ * see https://developer.mozilla.org/en-US/docs/Web/API/File_API
+ */
+class FileSource extends Source {
+  constructor(file, options) {
+    super();
+    this.file = file;
+    if (options && options.coverageCheck) {
+      this.coverageCheck = options.coverageCheck;
+    }
+  }
+
+  getKey() {
+    return this.file.name;
+  }
+
+  async getSize() {
+    return this.file.size;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async getBytes(offset, length, passedSignal, etag) {
+    const blob = this.file.slice(offset, offset + length);
+    const a = await blob.arrayBuffer();
+    return { data: a };
+  }
+}
+
+/**
+ * Uses the browser Fetch API to make tile requests via HTTP.
+ *
+ * This method does not send conditional request headers If-Match because of CORS.
+ * Instead, it detects ETag mismatches via the response ETag or the 416 response code.
+ *
+ * This also works around browser and storage-specific edge cases.
+ */
+class FetchSource extends Source {
+  constructor(url, options, customHeaders = new Headers()) {
+    super();
+    this.url = url;
+    this.customHeaders = customHeaders;
+    this.mustReload = false;
+    let userAgent = "";
+    if ("navigator" in globalThis) {
+      userAgent = globalThis.navigator.userAgent || "";
+    }
+    const isWindows = userAgent.indexOf("Windows") > -1;
+    const isChromiumBased = /Chrome|Chromium|Edg|OPR|Brave/.test(userAgent);
+    this.chromeWindowsNoCache = false;
+    if (isWindows && isChromiumBased) {
+      this.chromeWindowsNoCache = true;
+    }
+    if (options && options.coverageCheck) {
+      this.coverageCheck = options.coverageCheck;
+    }
+  }
+
+  getKey() {
+    return this.url;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async getSize(passedSignal, etag) {
+    if (this.size) return this.size;
+
+    let controller;
+    let signal;
+    if (passedSignal) {
+      signal = passedSignal;
+    } else {
+      controller = new AbortController();
+      signal = controller.signal;
+    }
+
+    const requestHeaders = new Headers(this.customHeaders);
+    requestHeaders.set("range", `bytes=${0}-${4}`);
+
+    let cache;
+    if (this.mustReload) {
+      cache = "reload";
+    } else if (this.chromeWindowsNoCache) {
+      cache = "no-store";
+    }
+
+    const resp = await fetch(this.url, {
+      signal: signal,
+      cache: cache,
+      headers: requestHeaders,
+    });
+
+    //Making sure that the server supports content-range and getting the file size
+    const contentRange = resp.headers.get("Content-Range");
+    if (resp.status === 206 && contentRange) {
+      const fileSize = contentRange.split("/")[1];
+      if (fileSize) {
+        this.size = fileSize;
+        return fileSize;
+      }
+    }
+    if (resp.status === 206 && !contentRange) {
+      // We didn't get a content-range response, getting head instead
+      // Getting head is much slower but works. We need to get the size
+      // of the file in some way since zip files has the catalog
+      // directory at the end.
+      const response = await fetch(this.url, {
+        method: "HEAD",
+      });
+      if (response.ok) {
+        const fileSize = response.headers.get("Content-Length");
+        this.size = fileSize;
+        return fileSize;
+      }
+    }
+
+    if (resp.status === 200 && !contentRange) {
+      if (controller) controller.abort();
+      throw new Error(
+        "Server returned no content-length header or content-length exceeding request. Check that your storage backend supports HTTP Byte Serving.",
+      );
+    }
+    //const requestHeaders = new Headers(this.customHeaders);
+    //requestHeaders.set("method", "HEAD");
+
+    /*
+    let controller;
+    let signal;
+    if (passedSignal) {
+      signal = passedSignal;
+    } else {
+      controller = new AbortController();
+      signal = controller.signal;
+    }
+    */
+    /*
+    try {
+      const response = await fetch(this.url, { method: "HEAD" });
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const contentLength = response.headers.get("content-length");
+      if (contentLength) {
+        console.log(contentLength);
+        this.size = contentLength;
+        return contentLength;
+      } else {
+        console.error("Content-Length header is not available.");
+      }
+    } catch (error) {
+      console.error("Error fetching headers:", error);
+    }*/
+  }
+
+  setHeaders(customHeaders) {
+    this.customHeaders = customHeaders;
+  }
+
+  async getBytes(offset, length, passedSignal, etag) {
+    let controller;
+    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 + length - 1}`);
+
+    let cache;
+    if (this.mustReload) {
+      cache = "reload";
+    } else if (this.chromeWindowsNoCache) {
+      cache = "no-store";
+    }
+
+    let resp = await fetch(this.url, {
+      signal: signal,
+      cache: cache,
+      headers: requestHeaders,
+    });
+
+    if (offset === 0 && resp.status === 416) {
+      const contentRange = resp.headers.get("Content-Range");
+      if (!contentRange || !contentRange.startsWith("bytes */")) {
+        throw new Error("Missing content-length on 416 response");
+      }
+      const actualLength = +contentRange.substr(8);
+      resp = await fetch(this.url, {
+        signal: signal,
+        cache: "reload",
+        headers: { range: `bytes=0-${actualLength - 1}` },
+      });
+    }
+
+    let newEtag = resp.headers.get("Etag");
+    if (newEtag && newEtag.startsWith("W/")) {
+      newEtag = null;
+    }
+
+    if (resp.status === 416 || (etag && newEtag && newEtag !== etag)) {
+      this.mustReload = true;
+      throw new Error(
+        `Server returned non-matching ETag ${etag} after one retry. Check browser extensions and servers for issues that may affect correct ETag headers.`,
+      );
+    }
+
+    if (resp.status >= 300) {
+      throw new Error(`Bad response code: ${resp.status}`);
+    }
+
+    const contentLength = resp.headers.get("Content-Length");
+    if (resp.status === 200 && (!contentLength || +contentLength > length)) {
+      if (controller) controller.abort();
+      throw new Error(
+        "Server returned no content-length header or content-length exceeding request. Check that your storage backend supports HTTP Byte Serving.",
+      );
+    }
+    const a = await resp.arrayBuffer();
+    return {
+      data: a,
+      etag: newEtag || undefined,
+      cacheControl: resp.headers.get("Cache-Control") || undefined,
+      expires: resp.headers.get("Expires") || undefined,
+    };
+  }
+}
+
+// Phase A: Subdivide a parent vector tile into a higher zoom target tile.
+// Minimal dependency implementation using @mapbox/vector-tile for decode and @maplibre/vt-pbf for encode.
+// Public API: subdivideVectorTile(parentPbf, parentZ, parentX, parentY, targetZ, targetX, targetY, options)
+// Returns { data: Uint8Array, stats }
+
+
+/**
+ * Subdivide parent tile PBF into higher zoom target tile.
+ * @param {ArrayBuffer|Uint8Array} parentPbf - Raw parent tile PBF bytes.
+ * @param {number} parentZ
+ * @param {number} parentX
+ * @param {number} parentY
+ * @param {number} targetZ
+ * @param {number} targetX
+ * @param {number} targetY
+ * @param {object} options
+ * @param {number} [options.buffer=128] - Clip buffer.
+ * @param {string[]|RegExp} [options.includeLayers] - Layer filter.
+ * @param {number} [options.maxDzWarn=8] - Warn if dz larger.
+ * @returns {{ data: Uint8Array, stats: any }}
+ */
+function subdivideVectorTile(
+  parentPbf,
+  parentZ,
+  parentX,
+  parentY,
+  targetZ,
+  targetX,
+  targetY,
+  options = {},
+) {
+  const t0 = performance.now ? performance.now() : Date.now();
+  const { buffer = 128, includeLayers, maxDzWarn = 8 } = options;
+  const dz = targetZ - parentZ;
+  if (dz <= 0) {
+    // Nothing to subdivide, caller should just use original bytes.
+    return { data: toUint8(parentPbf), stats: { dz, passthrough: true } };
+  }
+  if (dz > maxDzWarn && console && console.warn) {
+    console.warn(
+      `subdivideVectorTile: high dz=${dz}, performance may degrade.`,
+    );
+  }
+  // Validate containment.
+  const scale = Math.pow(2, dz);
+  const expectedParentX = Math.floor(targetX / scale);
+  const expectedParentY = Math.floor(targetY / scale);
+  if (expectedParentX !== parentX || expectedParentY !== parentY) {
+    throw new Error(
+      "Target tile not contained within parent tile coordinates.",
+    );
+  }
+
+  const vt = new VectorTile(new Protobuf(toUint8(parentPbf)));
+
+  const overzoomed = new OverzoomedVectorTile();
+  let featuresIn = 0;
+  let featuresOut = 0;
+  for (const layerName in vt.layers) {
+    if (!Object.prototype.hasOwnProperty.call(vt.layers, layerName)) continue;
+    if (includeLayers) {
+      if (Array.isArray(includeLayers) && !includeLayers.includes(layerName))
+        continue;
+      if (includeLayers instanceof RegExp && !includeLayers.test(layerName))
+        continue;
+    }
+    const sourceLayer = vt.layers[layerName];
+    const extent = sourceLayer.extent;
+    const offsetX = (targetX - parentX * scale) * extent;
+    const offsetY = (targetY - parentY * scale) * extent;
+
+    const featureWrappers = [];
+    for (let i = 0; i < sourceLayer.length; i++) {
+      const feature = sourceLayer.feature(i);
+      featuresIn++;
+      let geometry = feature.loadGeometry(); // Array of rings (Point[])
+      // Transform
+      for (const ring of geometry) {
+        for (const pt of ring) {
+          pt.x = pt.x * scale - offsetX;
+          pt.y = pt.y * scale - offsetY;
+        }
+      }
+      // Clip
+      geometry = clipGeometry(geometry, feature.type, -buffer, extent + buffer);
+      if (!geometry || geometry.length === 0) continue;
+      featureWrappers.push(
+        new OverzoomedFeatureWrapper(
+          feature.type,
+          geometry,
+          feature.properties,
+          feature.id,
+          extent,
+        ),
+      );
+      featuresOut++;
+    }
+    if (featureWrappers.length > 0) {
+      overzoomed.addLayer(
+        new OverzoomedTileLayer(featureWrappers, layerName, extent),
+      );
+    }
+  }
+  const pbf = fromVectorTileJs(overzoomed);
+  const data =
+    pbf.byteOffset === 0 && pbf.byteLength === pbf.buffer.byteLength
+      ? pbf
+      : new Uint8Array(pbf);
+  const t1 = performance.now ? performance.now() : Date.now();
+  return { data, stats: { dz, featuresIn, featuresOut, ms: t1 - t0 } };
+}
+
+// --- Internal wrappers (adapted from overzoomed-geojson-vector-tile.ts) ---
+class OverzoomedFeatureWrapper extends VectorTileFeature {
+  constructor(type, geometry, properties, id, extent) {
+    super(new Protobuf(), 0, extent, [], []);
+    this.type = type; // 1=Point,2=LineString,3=Polygon
+    this.properties = properties ? properties : {};
+    this.extent = extent;
+    this.myGeometry = geometry;
+    this.id = id;
+  }
+  loadGeometry() {
+    return this.myGeometry.map((ring) => ring.map((p) => new Point(p.x, p.y)));
+  }
+}
+
+class OverzoomedTileLayer extends VectorTileLayer {
+  constructor(features, name, extent) {
+    super(new Protobuf());
+    this._myFeatures = features;
+    this.name = name;
+    this.length = features.length;
+    this.extent = extent;
+    this.version = 2;
+  }
+  feature(i) {
+    return this._myFeatures[i];
+  }
+}
+
+class OverzoomedVectorTile {
+  constructor() {
+    this.layers = {};
+  }
+  addLayer(layer) {
+    this.layers[layer.name] = layer;
+  }
+}
+
+// --- Clipping helpers ---
+function clipGeometry(geometry, type, min, max) {
+  switch (type) {
+    case 1:
+      return clipPoints(geometry, min, max); // POINT
+    case 2:
+      return clipLinesWrapper(geometry, min, max, false); // LINESTRING
+    case 3:
+      return clipLinesWrapper(geometry, min, max, true); // POLYGON
+    default:
+      return [];
+  }
+}
+function clipPoints(geometry, min, max) {
+  const out = [];
+  for (const ring of geometry) {
+    for (const p of ring) {
+      if (p.x >= min && p.x <= max && p.y >= min && p.y <= max) {
+        out.push([p]);
+      }
+    }
+  }
+  return out;
+}
+function clipLinesWrapper(geometry, min, max, isPolygon) {
+  const out = [];
+  for (const line of geometry) {
+    const clipped = clipAxis(line, min, max, 0, isPolygon);
+    for (const seg of clipped) {
+      const clippedY = clipAxis(seg, min, max, 1, isPolygon);
+      for (const finalSeg of clippedY) out.push(finalSeg);
+    }
+  }
+  return out;
+}
+function clipAxis(line, start, end, axis, isPolygon) {
+  const intersect = axis === 0 ? intersectX : intersectY;
+  let slice = [];
+  const out = [];
+  for (let i = 0; i < line.length - 1; i++) {
+    const p1 = line[i];
+    const p2 = line[i + 1];
+    const a = axis === 0 ? p1.x : p1.y;
+    const b = axis === 0 ? p2.x : p2.y;
+    let exited = false;
+    if (a < start && b > start) slice.push(intersect(p1, p2, start));
+    else if (a > end && b < end) slice.push(intersect(p1, p2, end));
+    else if (a >= start && a <= end) slice.push(p1);
+    if (b < start && a >= start) {
+      slice.push(intersect(p1, p2, start));
+      exited = true;
+    }
+    if (b > end && a <= end) {
+      slice.push(intersect(p1, p2, end));
+      exited = true;
+    }
+    if (!isPolygon && exited) {
+      out.push(slice);
+      slice = [];
+    }
+  }
+  const last = line[line.length - 1];
+  const lastVal = axis === 0 ? last.x : last.y;
+  if (lastVal >= start && lastVal <= end) slice.push(last);
+  if (
+    isPolygon &&
+    slice.length > 0 &&
+    !slice[0].equals(slice[slice.length - 1])
+  ) {
+    slice.push(new Point(slice[0].x, slice[0].y));
+  }
+  if (slice.length > 0) out.push(slice);
+  return out;
+}
+function intersectX(p1, p2, x) {
+  const t = (x - p1.x) / (p2.x - p1.x);
+  return new Point(x, p1.y + (p2.y - p1.y) * t);
+}
+function intersectY(p1, p2, y) {
+  const t = (y - p1.y) / (p2.y - p1.y);
+  return new Point(p1.x + (p2.x - p1.x) * t, y);
+}
+
+function toUint8(data) {
+  if (data instanceof Uint8Array) return data;
+  return new Uint8Array(data);
+}
+
+// DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+// https://tools.ietf.org/html/rfc1951
+// You may also wish to take a look at the guide I made about this program:
+// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
+// Some of the following code is similar to that of UZIP.js:
+// https://github.com/photopea/UZIP.js
+// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
+// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
+// is better for memory in most engines (I *think*).
+
+// aliases for shorter compressed code (most minifers don't do this)
+var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+// fixed length extra bits
+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]);
+// fixed distance extra bits
+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]);
+// code length index map
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+// get base, reverse index map from extra bits
+var freb = function (eb, start) {
+    var b = new u16(31);
+    for (var i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+    }
+    // numbers here are at max 18 bits
+    var r = new i32(b[30]);
+    for (var i = 1; i < 30; ++i) {
+        for (var j = b[i]; j < b[i + 1]; ++j) {
+            r[j] = ((j - b[i]) << 5) | i;
+        }
+    }
+    return { b: b, r: r };
+};
+var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+// we can ignore the fact that the other numbers are wrong; they never happen anyway
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0), fd = _b.b;
+// map of value to reverse (assuming 16 bits)
+var rev = new u16(32768);
+for (var i = 0; i < 32768; ++i) {
+    // reverse table algorithm from SO
+    var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+    x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+    x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+    rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
+}
+// create huffman tree from u8 "map": index -> code length for code index
+// mb (max bits) must be at most 15
+// TODO: optimize/split up?
+var hMap = (function (cd, mb, r) {
+    var s = cd.length;
+    // index
+    var i = 0;
+    // u16 "map": index -> # of codes with bit length = index
+    var l = new u16(mb);
+    // length of cd must be 288 (total # of codes)
+    for (; i < s; ++i) {
+        if (cd[i])
+            ++l[cd[i] - 1];
+    }
+    // u16 "map": index -> minimum code for bit length = index
+    var le = new u16(mb);
+    for (i = 1; i < mb; ++i) {
+        le[i] = (le[i - 1] + l[i - 1]) << 1;
+    }
+    var co;
+    if (r) {
+        // u16 "map": index -> number of actual bits, symbol for code
+        co = new u16(1 << mb);
+        // bits to remove for reverser
+        var rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+            // ignore 0 lengths
+            if (cd[i]) {
+                // num encoding both symbol and bits read
+                var sv = (i << 4) | cd[i];
+                // free bits
+                var r_1 = mb - cd[i];
+                // start value
+                var v = le[cd[i] - 1]++ << r_1;
+                // m is end value
+                for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                    // every 16 bit value starting with the code yields the same result
+                    co[rev[v] >> rvb] = sv;
+                }
+            }
+        }
+    }
+    else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i) {
+            if (cd[i]) {
+                co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
+            }
+        }
+    }
+    return co;
+});
+// fixed length tree
+var flt = new u8(288);
+for (var i = 0; i < 144; ++i)
+    flt[i] = 8;
+for (var i = 144; i < 256; ++i)
+    flt[i] = 9;
+for (var i = 256; i < 280; ++i)
+    flt[i] = 7;
+for (var i = 280; i < 288; ++i)
+    flt[i] = 8;
+// fixed distance tree
+var fdt = new u8(32);
+for (var i = 0; i < 32; ++i)
+    fdt[i] = 5;
+// fixed length map
+var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+// fixed distance map
+var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+// find max of array
+var max = function (a) {
+    var m = a[0];
+    for (var i = 1; i < a.length; ++i) {
+        if (a[i] > m)
+            m = a[i];
+    }
+    return m;
+};
+// read d, starting at bit p and mask with m
+var bits = function (d, p, m) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
+};
+// read d, starting at bit p continuing for at least 16 bits
+var bits16 = function (d, p) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
+};
+// get end of byte
+var shft = function (p) { return ((p + 7) / 8) | 0; };
+// typed array slice - allows garbage collector to free original reference,
+// while being more compatible than .slice
+var slc = function (v, s, e) {
+    if (e == null || e > v.length)
+        e = v.length;
+    // can't use .constructor in case user-supplied
+    return new u8(v.subarray(s, e));
+};
+// error codes
+var ec = [
+    'unexpected EOF',
+    'invalid block type',
+    'invalid length/literal',
+    'invalid distance',
+    'stream finished',
+    'no stream handler',
+    ,
+    'no callback',
+    'invalid UTF-8 data',
+    'extra field too long',
+    'date not in range 1980-2099',
+    '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]);
+    e.code = ind;
+    if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+    if (!nt)
+        throw e;
+    return e;
+};
+// expands raw DEFLATE data
+var inflt = function (dat, st, buf, dict) {
+    // source length       dict length
+    var sl = dat.length, dl = 0;
+    if (!sl || st.f && !st.l)
+        return buf || new u8(0);
+    var noBuf = !buf;
+    // have to estimate size
+    var resize = noBuf || st.i != 2;
+    // no state
+    var noSt = st.i;
+    // Assumes roughly 33% compression ratio average
+    if (noBuf)
+        buf = new u8(sl * 3);
+    // ensure buffer can fit at least l elements
+    var cbuf = function (l) {
+        var bl = buf.length;
+        // need to increase size to fit
+        if (l > bl) {
+            // Double or set to necessary, whichever is greater
+            var nbuf = new u8(Math.max(bl * 2, l));
+            nbuf.set(buf);
+            buf = nbuf;
+        }
+    };
+    //  last chunk         bitpos           bytes
+    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+    // total bits
+    var tbts = sl * 8;
+    do {
+        if (!lm) {
+            // BFINAL - this is only 1 when last chunk is next
+            final = bits(dat, pos, 1);
+            // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+            var type = bits(dat, pos + 1, 3);
+            pos += 3;
+            if (!type) {
+                // go to end of byte boundary
+                var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                if (t > sl) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                // ensure size
+                if (resize)
+                    cbuf(bt + l);
+                // Copy over uncompressed data
+                buf.set(dat.subarray(s, t), bt);
+                // Get new bitpos, update byte count
+                st.b = bt += l, st.p = pos = t * 8, st.f = final;
+                continue;
+            }
+            else if (type == 1)
+                lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+            else if (type == 2) {
+                //  literal                            lengths
+                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                pos += 14;
+                // length+distance tree
+                var ldt = new u8(tl);
+                // code length tree
+                var clt = new u8(19);
+                for (var i = 0; i < hcLen; ++i) {
+                    // use index map to get real code
+                    clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                }
+                pos += hcLen * 3;
+                // code lengths bits
+                var clb = max(clt), clbmsk = (1 << clb) - 1;
+                // code lengths map
+                var clm = hMap(clt, clb, 1);
+                for (var i = 0; i < tl;) {
+                    var r = clm[bits(dat, pos, clbmsk)];
+                    // bits read
+                    pos += r & 15;
+                    // symbol
+                    var s = r >> 4;
+                    // code length to copy
+                    if (s < 16) {
+                        ldt[i++] = s;
+                    }
+                    else {
+                        //  copy   count
+                        var c = 0, n = 0;
+                        if (s == 16)
+                            n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                        else if (s == 17)
+                            n = 3 + bits(dat, pos, 7), pos += 3;
+                        else if (s == 18)
+                            n = 11 + bits(dat, pos, 127), pos += 7;
+                        while (n--)
+                            ldt[i++] = c;
+                    }
+                }
+                //    length tree                 distance tree
+                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                // max length bits
+                lbt = max(lt);
+                // max dist bits
+                dbt = max(dt);
+                lm = hMap(lt, lbt, 1);
+                dm = hMap(dt, dbt, 1);
+            }
+            else
+                err(1);
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+        }
+        // Make sure the buffer can hold this + the largest possible addition
+        // Maximum chunk size (practically, theoretically infinite) is 2^17
+        if (resize)
+            cbuf(bt + 131072);
+        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        var lpos = pos;
+        for (;; lpos = pos) {
+            // bits read, code
+            var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+            pos += c & 15;
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+            if (!c)
+                err(2);
+            if (sym < 256)
+                buf[bt++] = sym;
+            else if (sym == 256) {
+                lpos = pos, lm = null;
+                break;
+            }
+            else {
+                var add = sym - 254;
+                // no extra bits needed if less
+                if (sym > 264) {
+                    // index
+                    var i = sym - 257, b = fleb[i];
+                    add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                    pos += b;
+                }
+                // dist
+                var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+                if (!d)
+                    err(3);
+                pos += d & 15;
+                var dt = fd[dsym];
+                if (dsym > 3) {
+                    var b = fdeb[dsym];
+                    dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+                }
+                if (pos > tbts) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                if (resize)
+                    cbuf(bt + 131072);
+                var end = bt + add;
+                if (bt < dt) {
+                    var shift = dl - dt, dend = Math.min(dt, end);
+                    if (shift + bt < 0)
+                        err(3);
+                    for (; bt < dend; ++bt)
+                        buf[bt] = dict[shift + bt];
+                }
+                for (; bt < end; ++bt)
+                    buf[bt] = buf[bt - dt];
+            }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm)
+            final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+    } while (!final);
+    // don't reallocate for streams or user buffers
+    return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+// empty
+var et = /*#__PURE__*/ new u8(0);
+// gzip footer: -8 to -4 = CRC, -4 to -0 is length
+// gzip start
+var gzs = function (d) {
+    if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+        err(6, 'invalid gzip data');
+    var flg = d[3];
+    var st = 10;
+    if (flg & 4)
+        st += (d[10] | d[11] << 8) + 2;
+    for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+        ;
+    return st + (flg & 2);
+};
+// gzip length
+var gzl = function (d) {
+    var l = d.length;
+    return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+};
+// zlib start
+var zls = function (d, dict) {
+    if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31))
+        err(6, 'invalid zlib data');
+    if ((d[1] >> 5 & 1) == 1)
+        err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary');
+    return (d[1] >> 3 & 4) + 2;
+};
+/**
+ * Expands DEFLATE data with no wrapper
+ * @param data The data to decompress
+ * @param opts The decompression options
+ * @returns The decompressed version of the data
+ */
+function inflateSync(data, opts) {
+    return inflt(data, { i: 2 }, opts, opts);
+}
+/**
+ * Expands GZIP data
+ * @param data The data to decompress
+ * @param opts The decompression options
+ * @returns The decompressed version of the data
+ */
+function gunzipSync(data, opts) {
+    var st = gzs(data);
+    if (st + 8 > data.length)
+        err(6, 'invalid gzip data');
+    return inflt(data.subarray(st, -8), { i: 2 }, new u8(gzl(data)), opts);
+}
+/**
+ * Expands Zlib data
+ * @param data The data to decompress
+ * @param opts The decompression options
+ * @returns The decompressed version of the data
+ */
+function unzlibSync(data, opts) {
+    return inflt(data.subarray(zls(data), -4), { i: 2 }, opts, opts);
+}
+/**
+ * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format
+ * @param data The data to decompress
+ * @param opts The decompression options
+ * @returns The decompressed version of the data
+ */
+function decompressSync(data, opts) {
+    return (data[0] == 31 && data[1] == 139 && data[2] == 8)
+        ? gunzipSync(data, opts)
+        : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))
+            ? inflateSync(data, opts)
+            : unzlibSync(data, opts);
+}
+// text decoder
+var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
+// text decoder stream
+var tds = 0;
+try {
+    td.decode(et, { stream: true });
+    tds = 1;
+}
+catch (e) { }
+
+/* global globalThis */
+
+/**
+ * Provide a decompression implementation that acts on `buf` and returns decompressed data.
+ *
+ * Should use the native DecompressionStream on browsers, zlib on node.
+ * Should throw if the compression algorithm is not supported.
+ */
+async function defaultDecompress(buf, compression) {
+  if (compression === "none" || compression === undefined) {
+    return buf;
+  }
+  if (compression === "gzip") {
+    if (typeof globalThis.DecompressionStream === "undefined") {
+      return decompressSync(new Uint8Array(buf));
+    }
+    const stream = new Response(buf).body;
+    if (!stream) {
+      throw new Error("Failed to read response stream");
+    }
+    const result = stream.pipeThrough(
+      new globalThis.DecompressionStream("gzip"),
+    );
+    return new Response(result).arrayBuffer();
+  }
+  throw new Error("Compression method not supported");
+}
+
+async function getJsonFromFile(file, tilePackageFiles, source) {
+  const decoder = new TextDecoder("utf-8");
+  if (tilePackageFiles[file]) {
+    const fileOffset = tilePackageFiles[file].absoluteOffset;
+    const fileJSON = await source.getBytes(
+      fileOffset,
+      tilePackageFiles[file].size,
+    );
+    return JSON.parse(decoder.decode(fileJSON.data));
+  }
+  return {};
+}
+
+function xmlToJson(xmlString) {
+  const parser = new DOMParser();
+  const xmlDoc = parser.parseFromString(xmlString, "application/xml");
+  const obj = {};
+
+  function traverse(node, obj) {
+    if (node.nodeType === 1) {
+      // element
+      const nodeName = node.nodeName;
+      if (!obj[nodeName] && node.childNodes.length > 0) {
+        obj[nodeName] = {};
+      }
+      if (node.childNodes.length == 1 && node.childNodes[0].nodeType == 3) {
+        obj[nodeName] = node.childNodes[0].nodeValue.trim();
+        return;
+      }
+      for (let i = 0; i < node.childNodes.length; i++) {
+        traverse(node.childNodes[i], obj[nodeName]);
+      }
+    }
+  }
+
+  traverse(xmlDoc.documentElement, obj);
+  return obj;
+}
+
+/**
+ * Parse json into a Header object.
+ */
+function jsonToHeader(json, files, etag) {
+  let spatialReference;
+  try {
+    spatialReference = json.tileInfo.spatialReference.latestWkid;
+    // eslint-disable-next-line no-unused-vars
+  } catch (e) {
+    spatialReference = undefined;
+  }
+  return {
+    type: json.type,
+    name: json.name,
+    description: json.serviceDescription,
+    attribution: json.copyrightText,
+    version: json.version,
+    metadataOffset: json.metadataOffset || 0,
+    metadataLength: json.metadataLength || 0,
+    packageType: json.tileInfo.format ? "vtpk" : "tpkx",
+    spatialReference: spatialReference,
+    tileCompression: json.resourceInfo
+      ? json.resourceInfo.tileCompression || "none"
+      : "none",
+    tileType: json.tileInfo.format || json.tileImageInfo.format,
+    tileSize: json.tileInfo.rows,
+    minZoom: json.minZoom || json.minLOD,
+    maxZoom: json.maxZoom || json.maxLOD,
+    minLon: Number(json.extent.xmin),
+    minLat: Number(json.extent.ymin),
+    maxLon: Number(json.extent.xmax),
+    maxLat: Number(json.extent.ymax),
+    files: files,
+    coverageMap: json.coverageMap,
+    etag: etag,
+  };
+}
+
+/**
+ * Retrieve the header and root directory of a TilePackage archive.
+ *
+ * @param {Source} source - The source of the TilePackage archive.
+ */
+async function getHeaderAndFileList(source) {
+  const key = source.getKey();
+  const fileSize = await source.getSize();
+  const resp = await source.getBytes(fileSize - 98, 98);
+  let v = new DataView(resp.data, 0, 98);
+  let entriesCentralDirectory, sizeCentralDirectory, offsetCentralDirectory;
+  //let bigZip64 = false;
+  if (v.getUint32(0, true) === 0x06064b50) {
+    // This is a ZIP64 tilepackage
+    //bigZip64 = true;
+    entriesCentralDirectory = Number(v.getBigUint64(32, true));
+    sizeCentralDirectory = Number(v.getBigUint64(40, true));
+    offsetCentralDirectory = Number(v.getBigUint64(48, true));
+  } else {
+    v = new DataView(resp.data, 98 - 22, 22);
+    if (v.getUint32(0, true) === 0x06054b50) {
+      // This is a ordinary zip archive
+      entriesCentralDirectory = Number(v.getUint16(10, true));
+      sizeCentralDirectory = Number(v.getUint32(12, true));
+      offsetCentralDirectory = Number(v.getUint32(16, true));
+    } else {
+      throw new Error("Wrong magic number for Zip archive");
+    }
+  }
+
+  const centralDirectory = await source.getBytes(
+    offsetCentralDirectory,
+    sizeCentralDirectory,
+  );
+
+  v = new DataView(centralDirectory.data, 0, sizeCentralDirectory);
+  if (v.getUint32(0, true) !== 0x02014b50) {
+    throw new Error("Wrong magic number for Central Directory archive");
+  }
+
+  let entryStart = 0;
+  const tilePackageFiles = {};
+  for (let i = 0; i < entriesCentralDirectory; i++) {
+    if (entryStart >= sizeCentralDirectory) break;
+    /*
+        central file header signature   4 bytes  (0x02014b50)
+        version made by                 2 bytes
+        version needed to extract       2 bytes
+        general purpose bit flag        2 bytes
+        compression method              2 bytes
+        last mod file time              2 bytes
+        last mod file date              2 bytes
+        crc-32                          4 bytes
+        compressed size                 4 bytes
+        uncompressed size               4 bytes
+        file name length                2 bytes
+        extra field length              2 bytes
+        file comment length             2 bytes
+        disk number start               2 bytes
+        internal file attributes        2 bytes
+        external file attributes        4 bytes
+        relative offset of local header 4 bytes
+
+        file name (variable size)
+        extra field (variable size)
+        file comment (variable size)
+    */
+    let sizeFile = v.getUint32(entryStart + 20, true);
+
+    const sizeFileName = v.getUint16(entryStart + 28, true);
+
+    const sizeExtraField = v.getUint16(entryStart + 30, true);
+
+    const sizeComment = v.getUint16(entryStart + 32, true);
+
+    let relativeOffset = v.getUint32(entryStart + 42, true);
+
+    const vFilename = new DataView(
+      centralDirectory.data,
+      entryStart + 46,
+      sizeFileName,
+    );
+    const decoder = new TextDecoder("utf-8");
+    const filename = decoder.decode(vFilename);
+
+    if (
+      (sizeFile == 0xffffffff || relativeOffset == 0xffffffff) &&
+      sizeExtraField > 0
+    ) {
+      const vExtended = new DataView(
+        centralDirectory.data,
+        entryStart + 46 + sizeFileName,
+        32,
+      );
+      if (vExtended.getUint16(0, true) == 0x0001) {
+        /*
+        Value      Size       Description
+        -----      ----       -----------
+(ZIP64) 0x0001     2 bytes    Tag for this "extra" block type
+        Size       2 bytes    Size of this "extra" block
+        Original 
+        Size       8 bytes    Original uncompressed file size
+        Compressed
+        Size       8 bytes    Size of compressed data
+        Relative Header
+        Offset     8 bytes    Offset of local header record
+        Disk Start
+        Number     4 bytes    Number of the disk on which
+                              this file starts
+      */
+
+        let j = 0;
+        if (sizeFile == 0xffffffff) {
+          sizeFile = Number(vExtended.getBigUint64(4, true));
+          j += 8;
+        }
+        if (relativeOffset == 0xffffffff) {
+          relativeOffset = Number(vExtended.getBigUint64(4 + j, true));
+        }
+      }
+    }
+
+    tilePackageFiles[filename] = {
+      filename: filename,
+      size: sizeFile,
+      relativeOffset: relativeOffset,
+      absoluteOffset: relativeOffset + 30 + filename.length,
+    };
+    entryStart += 46 + sizeFileName + sizeExtraField + sizeComment;
+  }
+
+  let root = {};
+
+  if (key.indexOf(".tpkx") !== -1) {
+    // TPKX
+    root = await getJsonFromFile("root.json", tilePackageFiles, source);
+    root.type = "tpkx";
+    const iteminfo = await getJsonFromFile(
+      "iteminfo.json",
+      tilePackageFiles,
+      source,
+    );
+    Object.keys(iteminfo).forEach((key) => {
+      if (key !== "type") {
+        root[key] = iteminfo[key];
+      }
+    });
+  } else {
+    // VTPK
+    root = await getJsonFromFile("p12/root.json", tilePackageFiles, source);
+    root.type = "vtpk";
+
+    const iteminfoFile = "esriinfo/iteminfo.xml";
+    if (tilePackageFiles[iteminfoFile]) {
+      const iteminfoOffset = tilePackageFiles[iteminfoFile].absoluteOffset;
+
+      const iteminfoData = await source.getBytes(
+        iteminfoOffset,
+        tilePackageFiles[iteminfoFile].size,
+      );
+      const decoder = new TextDecoder("utf-8");
+      const iteminfoString = decoder.decode(iteminfoData.data);
+      const iteminfo = xmlToJson(iteminfoString);
+      Object.keys(iteminfo.ESRI_ItemInformation).forEach((key) => {
+        if (key !== "type") {
+          root[key] = iteminfo.ESRI_ItemInformation[key];
+        }
+      });
+    }
+
+    if (tilePackageFiles["p12/metadata.json"]) {
+      const metadataOffset =
+        tilePackageFiles["p12/metadata.json"].absoluteOffset;
+      root.metadataOffset = metadataOffset;
+      root.metadataLength = tilePackageFiles["p12/metadata.json"].size;
+    }
+
+    async function calculateCoverage(z, x, y, tilemap, coverageMap) {
+      z = z + 1;
+      x = x * 2;
+      y = y * 2;
+      if (coverageMap[z] == undefined) coverageMap[z] = {};
+      if (coverageMap[z][x] == undefined) coverageMap[z][x] = {};
+      if (coverageMap[z][x + 1] == undefined) coverageMap[z][x + 1] = {};
+      coverageMap[z][x][y] = tilemap[0];
+      if (isNaN(tilemap[0])) {
+        calculateCoverage(z, x, y, tilemap[0], coverageMap);
+      }
+      coverageMap[z][x + 1][y] = tilemap[1];
+      if (isNaN(tilemap[1])) {
+        calculateCoverage(z, x + 1, y, tilemap[1], coverageMap);
+      }
+      coverageMap[z][x][y + 1] = tilemap[2];
+      if (isNaN(tilemap[2])) {
+        calculateCoverage(z, x, y + 1, tilemap[2], coverageMap);
+      }
+      coverageMap[z][x + 1][y + 1] = tilemap[3];
+      if (isNaN(tilemap[3])) {
+        calculateCoverage(z, x + 1, y + 1, tilemap[3], coverageMap);
+      }
+    }
+    // Get and calculate the tilemap
+    if (source.coverageCheck > 0 && tilePackageFiles["p12/tilemap/root.json"]) {
+      const tilemap = await getJsonFromFile(
+        "p12/tilemap/root.json",
+        tilePackageFiles,
+        source,
+      );
+      const coverageMap = {};
+      coverageMap[0] = {};
+      coverageMap[0][0] = {};
+      coverageMap[0][0][0] = "blob";
+      calculateCoverage(0, 0, 0, tilemap.index, coverageMap);
+      root.coverageMap = coverageMap;
+    }
+  }
+
+  const header = jsonToHeader(root, tilePackageFiles, resp.etag);
+  return [header, ""];
+}
+
+function deserializeIndex(dataView) {
+  const index = [];
+
+  //const M = BigInt(Math.pow(2, 40));
+  for (let row = 0; row < 128; row++) {
+    index[row] = [];
+    for (let col = 0; col < 128; col++) {
+      const tileIndexOffset = 8 * (128 * (row % 128) + (col % 128));
+      // eslint-disable-next-line no-undef
+      let tileOffset = BigInt(0);
+      for (let i = 4; i >= 0; i--) {
+        // Start from the last byte for little-endian
+        tileOffset =
+          // eslint-disable-next-line no-undef
+          (tileOffset << BigInt(8)) |
+          // eslint-disable-next-line no-undef
+          BigInt(dataView.getUint8(tileIndexOffset + i));
+      }
+      // eslint-disable-next-line no-undef
+      let tileSize = BigInt(0);
+      for (let i = 2; i >= 0; i--) {
+        // Start from the last byte for little-endian
+        tileSize =
+          // eslint-disable-next-line no-undef
+          (tileSize << BigInt(8)) |
+          // eslint-disable-next-line no-undef
+          BigInt(dataView.getUint8(tileIndexOffset + 5 + i));
+      }
+      if (tileSize > 0) {
+        index[row][col] = {
+          row: row,
+          col: col,
+          tileOffset: Number(tileOffset),
+          tileSize: Number(tileSize),
+        };
+      }
+    }
+  }
+
+  return index;
+}
+
+async function getResource(source, file, header, signal) {
+  const resp = await source.getBytes(
+    header.files[file].absoluteOffset,
+    header.files[file].size,
+    signal,
+    header.etag,
+  );
+  return resp;
+}
+
+async function getTileIndex(source, file, header, signal) {
+  const offset = header.files[file].absoluteOffset + 64; // File header 64bytes
+  const resp = await source.getBytes(
+    offset,
+    128 * 128 * 8,
+    signal,
+    header.etag,
+  );
+  const dataView = new DataView(resp.data, 0, 128 * 128 * 8);
+  const directory = deserializeIndex(dataView);
+  if (directory.length === 0) {
+    throw new Error("Empty directory is invalid");
+  }
+  return directory;
+}
+
+/**
+ * A cache for parts of a TilePackage archive where promises can be shared between requests.
+ *
+ * Only caches headers, resource files, and directories, not individual tile contents.
+ */
+class SharedPromiseCache {
+  constructor(maxCacheEntries = 100) {
+    this.cache = new Map();
+    this.invalidations = new Map();
+    this.maxCacheEntries = maxCacheEntries;
+    this.counter = 1;
+    //this.decompress = decompress;
+    this.subdivided = new Map(); // key: sourceKey|z|x|y -> Uint8Array
+  }
+
+  async getHeader(source) {
+    const cacheKey = source.getKey();
+    const cacheValue = this.cache.get(cacheKey);
+    if (cacheValue) {
+      cacheValue.lastUsed = this.counter++;
+      const data = await cacheValue.data;
+      return data;
+    }
+
+    const p = new Promise((resolve, reject) => {
+      getHeaderAndFileList(source)
+        .then((res) => {
+          /*
+          if (res[1]) {
+            this.cache.set(res[1][0], {
+              lastUsed: this.counter++,
+              data: Promise.resolve(res[1][2]),
+            });
+          }*/
+          resolve(res[0]);
+          this.prune();
+        })
+        .catch((e) => {
+          reject(e);
+        });
+    });
+    this.cache.set(cacheKey, { lastUsed: this.counter++, data: p });
+    return p;
+  }
+
+  async getResource(source, file, header, signal) {
+    const cacheKey = `${source.getKey()}|${header.etag || ""}|${file}|Resource`;
+    const cacheValue = this.cache.get(cacheKey);
+    if (cacheValue) {
+      cacheValue.lastUsed = this.counter++;
+      const data = await cacheValue.data;
+      return data;
+    }
+    const p = new Promise((resolve, reject) => {
+      getResource(source, file, header, signal)
+        .then((resource) => {
+          resolve(resource);
+          this.prune();
+        })
+        .catch((e) => {
+          reject(e);
+        });
+    });
+    this.cache.set(cacheKey, { lastUsed: this.counter++, data: p });
+    return p;
+  }
+
+  async getTileIndex(source, file, header, signal) {
+    const cacheKey = `${source.getKey()}|${
+      header.etag || ""
+    }|${file}|TileIndex`;
+    const cacheValue = this.cache.get(cacheKey);
+    if (cacheValue) {
+      cacheValue.lastUsed = this.counter++;
+      const data = await cacheValue.data;
+      return data;
+    }
+    const p = new Promise((resolve, reject) => {
+      getTileIndex(source, file, header, signal)
+        .then((directory) => {
+          resolve(directory);
+          this.prune();
+        })
+        .catch((e) => {
+          reject(e);
+        });
+    });
+    this.cache.set(cacheKey, { lastUsed: this.counter++, data: p });
+    return p;
+  }
+
+  prune() {
+    if (this.cache.size >= this.maxCacheEntries) {
+      let minUsed = Infinity;
+      let minKey = undefined;
+      this.cache.forEach((cacheValue, key) => {
+        if (cacheValue.lastUsed < minUsed) {
+          minUsed = cacheValue.lastUsed;
+          minKey = key;
+        }
+      });
+      if (minKey) {
+        this.cache.delete(minKey);
+      }
+    }
+  }
+
+  getSubdivided(source, z, x, y) {
+    const key = `${source.getKey()}|${z}|${x}|${y}|Subdivided`;
+    return this.subdivided.get(key);
+  }
+
+  setSubdivided(source, z, x, y, bytes) {
+    const key = `${source.getKey()}|${z}|${x}|${y}|Subdivided`;
+    if (!this.subdivided.has(key)) {
+      this.subdivided.set(key, bytes);
+      // Optional lightweight prune if huge:
+      if (this.subdivided.size > this.maxCacheEntries * 2) {
+        // Remove oldest half (no usage tracking kept; iterate arbitrary)
+        let toRemove = Math.floor(this.subdivided.size / 2);
+        for (const k of this.subdivided.keys()) {
+          this.subdivided.delete(k);
+          toRemove--;
+          if (toRemove <= 0) break;
+        }
+      }
+    }
+  }
+
+  async invalidate(source) {
+    const key = source.getKey();
+    if (this.invalidations.get(key)) {
+      return await this.invalidations.get(key);
+    }
+    this.cache.delete(source.getKey());
+    const p = new Promise((resolve, reject) => {
+      this.getHeader(source)
+        .then(() => {
+          resolve();
+          this.invalidations.delete(key);
+        })
+        .catch((e) => {
+          reject(e);
+        });
+    });
+    this.invalidations.set(key, p);
+  }
+}
+
+function calculateFilename(z, x, y, header) {
+  const zoom = z.toString().padStart(2, "0");
+  const baseRow = Math.floor(y / 128) * 128;
+  const baseCol = Math.floor(x / 128) * 128;
+  const rowHex = baseRow.toString(16).padStart(4, "0");
+  const colHex = baseCol.toString(16).padStart(4, "0");
+  let basePath = header.type === "tpkx" ? "tile" : "p12/tile";
+  return `${basePath}/L${zoom}/R${rowHex}C${colHex}.bundle`;
+}
+
+function getTileInfoFromTileIndex(tileIndex, z, x, y) {
+  const row = y % 128;
+  const col = x % 128;
+  return tileIndex[row][col];
+}
+
+class EtagMismatch extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EtagMismatch";
+  }
+}
+
+class TilePackage {
+  constructor(source, options) {
+    // Default coverageCheck enabled; disable with coverageCheck:false
+    this.coverageCheck = 1;
+    if (options && options.coverageCheck === false) this.coverageCheck = 0;
+    // Max dz guard (skip subdivision beyond this): default 8
+    this.maxDz =
+      options && typeof options.maxDz === "number" ? options.maxDz : 8;
+    if (typeof source === "string") {
+      const opts = this.coverageCheck
+        ? { coverageCheck: this.coverageCheck }
+        : undefined;
+      this.source = new FetchSource(source, opts);
+    } else {
+      this.source = source;
+      // Propagate default coverageCheck to existing Source instances if undefined
+      if (this.source && this.source.coverageCheck === undefined) {
+        this.source.coverageCheck = this.coverageCheck;
+      }
+    }
+    this.decompress =
+      options && options.decompress ? options.decompress : defaultDecompress;
+    this.cache =
+      options && options.cache ? options.cache : new SharedPromiseCache();
+  }
+
+  async getHeader() {
+    return await this.cache.getHeader(this.source);
+  }
+
+  async getZxyAttempt(z, x, y, signal) {
+    const header = await this.cache.getHeader(this.source);
+    if (z < header.minZoom || z > header.maxZoom) return undefined;
+    const file = calculateFilename(z, x, y, header);
+    let tileInfo = null;
+    if (header.files[file]) {
+      const tileIndex = await this.cache.getTileIndex(
+        this.source,
+        file,
+        header,
+        signal,
+      );
+      tileInfo = getTileInfoFromTileIndex(tileIndex, z, x, y);
+      if (tileInfo && tileInfo.tileSize > 0) {
+        const tileOffset =
+          header.files[file].absoluteOffset + tileInfo.tileOffset;
+        const resp = await this.source.getBytes(
+          tileOffset,
+          tileInfo.tileSize,
+          signal,
+          header.etag,
+        );
+        const data = await this.decompress(resp.data, header.tileCompression);
+        return { data, cacheControl: resp.cacheControl, expires: resp.expires };
+      }
+    }
+    if (header.packageType === "vtpk" && header.coverageMap) {
+      // Ascend to find parent with value 1
+      let pz = z,
+        px = x,
+        py = y,
+        foundParent = null;
+      while (pz > header.minZoom) {
+        pz -= 1;
+        px = Math.floor(px / 2);
+        py = Math.floor(py / 2);
+        const level = header.coverageMap[pz];
+        const val = level && level[px] ? level[px][py] : undefined;
+        if (val === 1) {
+          foundParent = { pz, px, py };
+          break;
+        }
+      }
+      if (foundParent) {
+        const parent = await this.getZxyAttempt(
+          foundParent.pz,
+          foundParent.px,
+          foundParent.py,
+          signal,
+        );
+        if (parent && parent.data) {
+          const cached = this.cache.getSubdivided(this.source, z, x, y);
+          if (cached) {
+            return {
+              data: cached,
+              cacheControl: parent.cacheControl,
+              expires: parent.expires,
+            };
+          }
+          const dz = z - foundParent.pz;
+          if (dz > this.maxDz) {
+            return undefined; // exceed hard cap
+          }
+          try {
+            const { data: overzoomed } = subdivideVectorTile(
+              parent.data,
+              foundParent.pz,
+              foundParent.px,
+              foundParent.py,
+              z,
+              x,
+              y,
+              { buffer: 128, maxDzWarn: this.maxDz - 1 },
+            );
+            this.cache.setSubdivided(this.source, z, x, y, overzoomed);
+            return {
+              data: overzoomed,
+              cacheControl: parent.cacheControl,
+              expires: parent.expires,
+            };
+          } catch (e) {
+            console.warn(
+              `[tilepackage subdivide] failed for z=${z} x=${x} y=${y}:`,
+              e,
+            );
+          }
+        } else {
+          console.warn(
+            `[tilepackage subdivide] parent tile missing at z=${foundParent.pz} x=${foundParent.px} y=${foundParent.py}`,
+          );
+        }
+      }
+    }
+    return undefined;
+  }
+
+  async getZxy(z, x, y, signal) {
+    try {
+      return await this.getZxyAttempt(z, x, y, signal);
+    } catch (e) {
+      if (e instanceof EtagMismatch) {
+        this.cache.invalidate(this.source);
+        return await this.getZxyAttempt(z, x, y, signal);
+      }
+      throw e;
+    }
+  }
+
+  async getMetadataAttempt() {
+    const header = await this.cache.getHeader(this.source);
+    let metadata = {};
+    if (header.packageType === "vtpk") {
+      const resp = await this.source.getBytes(
+        header.jsonMetadataOffset,
+        header.jsonMetadataLength,
+        undefined,
+        header.etag,
+      );
+      const decoder = new TextDecoder("utf-8");
+      metadata = JSON.parse(decoder.decode(resp.data));
+    }
+    metadata.name = header.name;
+    return metadata;
+  }
+
+  async getMetadata() {
+    try {
+      return await this.getMetadataAttempt();
+    } catch (e) {
+      if (e instanceof EtagMismatch) {
+        this.cache.invalidate(this.source);
+        return await this.getMetadataAttempt();
+      }
+      throw e;
+    }
+  }
+
+  async getResourceAttempt(file, signal) {
+    const header = await this.cache.getHeader(this.source);
+    if (!header.files[file]) return undefined;
+    const resource = await this.cache.getResource(
+      this.source,
+      file,
+      header,
+      signal,
+    );
+    return {
+      data: resource.data,
+      cacheControl: resource.cacheControl,
+      expires: resource.expires,
+    };
+  }
+
+  async getResource(file, signal) {
+    try {
+      return await this.getResourceAttempt(file, signal);
+    } catch (e) {
+      if (e instanceof EtagMismatch) {
+        this.cache.invalidate(this.source);
+        return await this.getResourceAttempt(file, signal);
+      }
+      throw e;
+    }
+  }
+
+  async getStyleAttempt() {
+    const header = await this.cache.getHeader(this.source);
+    const sourceKey = this.source.getKey();
+    if (header.packageType === "vtpk") {
+      const metadata = await getJsonFromFile(
+        "p12/root.json",
+        header.files,
+        this.source,
+      );
+      const style = await getJsonFromFile(
+        "p12/resources/styles/root.json",
+        header.files,
+        this.source,
+      );
+      if (style.sources && style.sources.esri) {
+        delete style.sources.esri.url;
+        style.sources.esri.tiles = [`tilepackage://${sourceKey}/{z}/{x}/{y}`];
+        style.sources.esri.type = style.sources.esri.type || "vector";
+        style.sources.esri.minzoom = header.minZoom || 0;
+        style.sources.esri.maxzoom = header.maxZoom || 22;
+      }
+      for (const k in style.sources) {
+        const src = style.sources[k];
+        if (
+          src &&
+          typeof src.url === "string" &&
+          src.url.startsWith("tilepackage://")
+        ) {
+          delete src.url;
+          if (!src.tiles)
+            src.tiles = [`tilepackage://${sourceKey}/{z}/{x}/{y}`];
+        }
+      }
+      if (metadata.copyrightText)
+        style.sources.esri.attribution = metadata.copyrightText;
+      style.glyphs = `tilepackage://${sourceKey}/{fontstack}/{range}`;
+      style.sprite = `tilepackage://${sourceKey}/sprite`;
+      if (this.debug)
+        console.debug(
+          "[tilepackage style] rewritten esri source",
+          style.sources.esri,
+        );
+      return style;
+    }
+    return {
+      version: 8,
+      sources: {
+        esri: {
+          type: "raster",
+          tileSize: header.tileSize || 256,
+          tiles: [`tilepackage://${sourceKey}/{z}/{x}/{y}`],
+          maxzoom: header.maxZoom || 22,
+          minzoom: header.minZoom || 0,
+        },
+      },
+      layers: [{ id: "tilepackageraster", type: "raster", source: "esri" }],
+    };
+  }
+
+  async getStyle() {
+    try {
+      return await this.getStyleAttempt();
+    } catch (e) {
+      if (e instanceof EtagMismatch) {
+        this.cache.invalidate(this.source);
+        return await this.getStyleAttempt();
+      }
+      throw e;
+    }
+  }
+
+  async getTileJson(baseTilesUrl) {
+    const header = await this.getHeader();
+    const metadata = await this.getMetadata();
+    const ext = header.tileType;
+    const tileJson = {
+      tilejson: "3.0.0",
+      scheme: "xyz",
+      tiles: [`${baseTilesUrl}/{z}/{x}/{y}${ext}`],
+      name: metadata.name,
+      version: header.version,
+      bounds: [header.minLon, header.minLat, header.maxLon, header.maxLat],
+    };
+    if (metadata.vector_layers) tileJson.vector_layers = metadata.vector_layers;
+    if (metadata.attribution) tileJson.attribution = metadata.attribution;
+    if (metadata.description) tileJson.description = metadata.description;
+    if (header.minZoom) tileJson.minzoom = header.minZoom;
+    if (header.maxZoom) tileJson.maxzoom = header.maxZoom;
+    return tileJson;
+  }
+}
+
+export { FetchSource, FileSource, Protocol, Source, TilePackage };
+//# sourceMappingURL=index.esm.js.map