maplibre-tilepackage-protocol 1.2.1 → 1.2.2

package/dist/index.esm.js

@@ -2,7 +2,6 @@ import { VectorTile, VectorTileFeature, VectorTileLayer } from '@mapbox/vector-t
 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++) {
@@ -175,14 +174,6 @@ class Protocol {
               };
             }
 
-            // 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 };
           }
         }
@@ -281,9 +272,11 @@ class FileSource extends Source {
   constructor(file, options) {
     super();
     this.file = file;
+    this.coverageCheck = 1;
     if (options && options.coverageCheck) {
       this.coverageCheck = options.coverageCheck;
     }
+    //console.log("Tilepackage FileSource initialized", this.file);
   }
 
   getKey() {
@@ -316,18 +309,9 @@ class FetchSource extends Source {
     this.url = url;
     this.customHeaders = customHeaders;
     this.mustReload = false;
-    // Safe global detection for legacy environments without globalThis
-    const g =
-      typeof globalThis !== "undefined"
-        ? globalThis
-        : typeof window !== "undefined"
-        ? window
-        : typeof self !== "undefined"
-        ? self
-        : {};
     let userAgent = "";
-    if (g && typeof g.navigator !== "undefined") {
-      userAgent = g.navigator.userAgent || "";
+    if ("navigator" in globalThis) {
+      userAgent = globalThis.navigator.userAgent || "";
     }
     const isWindows = userAgent.indexOf("Windows") > -1;
     const isChromiumBased = /Chrome|Chromium|Edg|OPR|Brave/.test(userAgent);
@@ -335,6 +319,7 @@ class FetchSource extends Source {
     if (isWindows && isChromiumBased) {
       this.chromeWindowsNoCache = true;
     }
+    this.coverageCheck = 1;
     if (options && options.coverageCheck) {
       this.coverageCheck = options.coverageCheck;
     }
@@ -902,7 +887,7 @@ var ec = [
     'invalid distance',
     'stream finished',
     'no stream handler',
-    ,
+    , // determined by compression function
     'no callback',
     'invalid UTF-8 data',
     'extra field too long',
@@ -1130,33 +1115,15 @@ var zls = function (d, dict) {
         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);
 }
@@ -1196,41 +1163,420 @@ async function defaultDecompress(buf, compression) {
     return buf;
   }
   if (compression === "gzip") {
-    // Safe global detection for DecompressionStream feature test
-    const g =
-      typeof globalThis !== "undefined"
-        ? globalThis
-        : typeof window !== "undefined"
-        ? window
-        : typeof self !== "undefined"
-        ? self
-        : {};
-    if (typeof g.DecompressionStream === "undefined") {
+    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 g.DecompressionStream("gzip"));
+    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) {
+async function getJsonFromZip(file, zipFiles, source) {
+  //console.log("getJsonFromZip:", file);
   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));
+  if (zipFiles[file]) {
+    const fileOffset = zipFiles[file].absoluteOffset;
+    const fileJSON = await source.getBytes(fileOffset, zipFiles[file].size);
+    let text;
+    try {
+      text = decoder.decode(fileJSON.data);
+    } catch (error) {
+      throw new Error(
+        "Failed to decode JSON bytes from " + file + ": " + error.message,
+      );
+    }
+
+    const trimmed = text.trim();
+    if (!trimmed) {
+      throw new Error("JSON file " + file + " is empty or whitespace only");
+    }
+
+    const firstChar = trimmed[0];
+    const lastChar = trimmed[trimmed.length - 1];
+    const looksLikeJsonObject = firstChar === "{" && lastChar === "}";
+    const looksLikeJsonArray = firstChar === "[" && lastChar === "]";
+    if (!looksLikeJsonObject && !looksLikeJsonArray) {
+      throw new Error(
+        "File " +
+          file +
+          " does not appear to contain JSON (starts with '" +
+          firstChar +
+          "' and ends with '" +
+          lastChar +
+          "')",
+      );
+    }
+
+    try {
+      return JSON.parse(trimmed);
+    } catch (error) {
+      throw new Error(
+        "Failed to parse JSON from " + file + ": " + error.message,
+      );
+    }
   }
+  console.warn(`File ${file} not found in Zip file`);
   return {};
 }
 
+const ZIP64_EOCD_SIGNATURE = 0x06064b50;
+const EOCD_SIGNATURE = 0x06054b50;
+const CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+const MIN_EOCD_SIZE = 22;
+const ZIP64_EOCD_SIZE = 56;
+const MAX_TAIL_SCAN = 65536; // 64KB
+const MAX_CENTRAL_DIR_SIZE = 500 * 1024 * 1024; // 500MB
+const MAX_DIRECTORY_ENTRIES = 1000000;
+const LOCAL_FILE_HEADER_BASE = 30;
+
+function scanForSignature(view, signature, minSize) {
+  for (let i = view.byteLength - minSize; i >= 0; i--) {
+    if (view.getUint32(i, true) === signature) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function parseZip64EndOfCentralDirectory(view, position) {
+  return {
+    entries: Number(view.getBigUint64(position + 32, true)),
+    size: Number(view.getBigUint64(position + 40, true)),
+    offset: Number(view.getBigUint64(position + 48, true)),
+  };
+}
+
+function parseEndOfCentralDirectory(view, position) {
+  return {
+    entries: view.getUint16(position + 10, true),
+    size: view.getUint32(position + 12, true),
+    offset: view.getUint32(position + 16, true),
+  };
+}
+
+async function readLocalFileHeader(source, offset, decoder) {
+  const headerResp = await source.getBytes(offset, LOCAL_FILE_HEADER_BASE);
+  if (headerResp.data.byteLength < LOCAL_FILE_HEADER_BASE) {
+    throw new Error("Local file header truncated before 30 bytes");
+  }
+
+  const headerView = new DataView(headerResp.data, 0, LOCAL_FILE_HEADER_BASE);
+  const signature = headerView.getUint32(0, true);
+  if (signature !== LOCAL_FILE_HEADER_SIGNATURE) {
+    throw new Error(
+      `Local file header signature mismatch (0x${signature.toString(16)})`,
+    );
+  }
+
+  const filenameLength = headerView.getUint16(26, true);
+  const extraFieldLength = headerView.getUint16(28, true);
+  const trailingLength = filenameLength + extraFieldLength;
+  let filename = "";
+
+  if (filenameLength > 0) {
+    const trailingResp = await source.getBytes(
+      offset + LOCAL_FILE_HEADER_BASE,
+      trailingLength,
+    );
+    if (trailingResp.data.byteLength < trailingLength) {
+      throw new Error("Local header filename/extra data truncated");
+    }
+    const filenameView = new DataView(trailingResp.data, 0, filenameLength);
+    filename = decoder.decode(filenameView);
+  }
+
+  return {
+    filename,
+    filenameLength,
+    extraFieldLength,
+    dataOffset:
+      offset + LOCAL_FILE_HEADER_BASE + filenameLength + extraFieldLength,
+  };
+}
+
+async function verifyLocalHeaderOffset({
+  source,
+  filename,
+  relativeOffset,
+  computedOffset,
+  decoder,
+  logger,
+}) {
+  try {
+    const localHeader = await readLocalFileHeader(
+      source,
+      relativeOffset,
+      decoder,
+    );
+    if (localHeader.filename !== filename) {
+      logger(
+        `Local header filename mismatch for ${filename}: found ${localHeader.filename} at offset ${relativeOffset}`,
+      );
+    }
+    if (localHeader.dataOffset !== computedOffset) {
+      logger(
+        `Data offset mismatch for ${filename}: calculated ${computedOffset}, actual ${localHeader.dataOffset}`,
+      );
+    }
+    return localHeader;
+  } catch (error) {
+    logger(
+      `Failed to verify local header for ${filename} at ${relativeOffset}: ${error.message}`,
+    );
+    return null;
+  }
+}
+
+async function getFilelistFromZip(source, options) {
+  const resolvedOptions = {};
+  const verifyOffsets =
+    typeof resolvedOptions.verifyOffsets === "boolean"
+      ? resolvedOptions.verifyOffsets
+      : false;
+  const verificationLogger =
+    typeof resolvedOptions.verificationLogger === "function"
+      ? resolvedOptions.verificationLogger
+      : console.warn;
+  const fileSize = await source.getSize();
+  if (fileSize < MIN_EOCD_SIZE) {
+    throw new Error(
+      "File too small to be a valid ZIP archive (minimum 22 bytes)",
+    );
+  }
+
+  const tailReadSize = Math.min(MAX_TAIL_SCAN, fileSize);
+  const tailOffset = fileSize - tailReadSize;
+  const tailResp = await source.getBytes(tailOffset, tailReadSize);
+  const tailView = new DataView(tailResp.data, 0, tailReadSize);
+
+  let entriesCentralDirectory;
+  let sizeCentralDirectory;
+  let offsetCentralDirectory;
+
+  const zip64Pos = scanForSignature(
+    tailView,
+    ZIP64_EOCD_SIGNATURE,
+    ZIP64_EOCD_SIZE,
+  );
+  if (zip64Pos !== -1) {
+    const zip64Data = parseZip64EndOfCentralDirectory(tailView, zip64Pos);
+    entriesCentralDirectory = zip64Data.entries;
+    sizeCentralDirectory = zip64Data.size;
+    offsetCentralDirectory = zip64Data.offset;
+  } else {
+    const eocdPos = scanForSignature(tailView, EOCD_SIGNATURE, MIN_EOCD_SIZE);
+    if (eocdPos === -1) {
+      throw new Error("End of Central Directory record not found in zip");
+    }
+    const eocdData = parseEndOfCentralDirectory(tailView, eocdPos);
+    entriesCentralDirectory = eocdData.entries;
+    sizeCentralDirectory = eocdData.size;
+    offsetCentralDirectory = eocdData.offset;
+  }
+
+  if (sizeCentralDirectory > MAX_CENTRAL_DIR_SIZE) {
+    throw new Error("Central directory size exceeds maximum allowed (500MB)");
+  }
+  if (entriesCentralDirectory > MAX_DIRECTORY_ENTRIES) {
+    throw new Error("Too many entries in central directory (max 1000000)");
+  }
+
+  if (offsetCentralDirectory < 0) {
+    throw new Error("Central directory offset is negative, file is corrupted");
+  }
+
+  const availableBytes = fileSize - offsetCentralDirectory;
+  if (availableBytes < 0) {
+    throw new Error("Central directory offset is beyond file size");
+  }
+
+  let safeCentralDirectorySize = sizeCentralDirectory;
+  if (safeCentralDirectorySize > availableBytes) {
+    console.warn(
+      "Central directory size extends past end of file, clamping to available bytes",
+    );
+    safeCentralDirectorySize = availableBytes;
+  }
+  if (safeCentralDirectorySize <= 0) {
+    throw new Error(
+      "Central directory size is zero or negative after validation",
+    );
+  }
+
+  const centralDirectory = await source.getBytes(
+    offsetCentralDirectory,
+    safeCentralDirectorySize,
+  );
+  const v = new DataView(centralDirectory.data, 0, safeCentralDirectorySize);
+
+  if (v.getUint32(0, true) !== CENTRAL_DIRECTORY_SIGNATURE) {
+    throw new Error("Wrong magic number for Central Directory archive");
+  }
+
+  const zipFiles = {};
+  let entryStart = 0;
+  const decoder = new TextDecoder("utf-8");
+
+  for (let i = 0; i < entriesCentralDirectory; i++) {
+    if (entryStart + 46 > safeCentralDirectorySize) {
+      break;
+    }
+
+    const generalPurposeFlag = v.getUint16(entryStart + 8, true);
+    const compressionMethod = v.getUint16(entryStart + 10, true);
+    if (compressionMethod !== 0 && compressionMethod !== 8) {
+      throw new Error(
+        "Unsupported compression method: " +
+          compressionMethod +
+          " only STORE(0) and DEFLATE(8) are supported",
+      );
+    }
+    let sizeFile = v.getUint32(entryStart + 20, true);
+    const uncompressedSize = v.getUint32(entryStart + 24, 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 headerLength = 46 + sizeFileName + sizeExtraField + sizeComment;
+    if (entryStart + headerLength > safeCentralDirectorySize) {
+      break;
+    }
+
+    const filenameView = new DataView(
+      centralDirectory.data,
+      entryStart + 46,
+      sizeFileName,
+    );
+    let filename;
+    try {
+      filename = decoder.decode(filenameView);
+    } catch (error) {
+      throw new Error(
+        "Failed to decode filename in ZIP entry: " + error.message,
+      );
+    }
+
+    const zip64SizeOverflow = sizeFile === 0xffffffff;
+    const zip64UncompressedOverflow = uncompressedSize === 0xffffffff;
+    const zip64OffsetOverflow = relativeOffset === 0xffffffff;
+    const hasZip64Marker =
+      zip64SizeOverflow || zip64UncompressedOverflow || zip64OffsetOverflow;
+    let localExtraFieldZip64Length = 0;
+
+    if (hasZip64Marker && sizeExtraField > 0) {
+      const extraStart = entryStart + 46 + sizeFileName;
+      const extraEnd = extraStart + sizeExtraField;
+      if (extraEnd <= safeCentralDirectorySize) {
+        const extraView = new DataView(
+          centralDirectory.data,
+          extraStart,
+          sizeExtraField,
+        );
+        let extraOffset = 0;
+        let iterations = 100;
+        while (extraOffset + 4 <= sizeExtraField && iterations > 0) {
+          iterations--;
+          const headerId = extraView.getUint16(extraOffset, true);
+          const dataSize = extraView.getUint16(extraOffset + 2, true);
+
+          if (headerId === 0x0001) {
+            // APPNOTE.TXT (4.5.3) – local header ZIP64 field only stores
+            // the compressed/uncompressed sizes when a 64-bit value is needed.
+            const dataStart = extraOffset + 4;
+            const dataEnd = dataStart + dataSize;
+            let cursor = dataStart;
+            let localZip64DataSize = 0;
+
+            if (zip64UncompressedOverflow) {
+              if (cursor + 8 > dataEnd) {
+                throw new Error(
+                  "ZIP64 extra field truncated while reading uncompressed size",
+                );
+              }
+              extraView.getBigUint64(cursor, true);
+              cursor += 8;
+              localZip64DataSize += 8;
+            }
+
+            if (zip64SizeOverflow) {
+              if (cursor + 8 > dataEnd) {
+                throw new Error(
+                  "ZIP64 extra field truncated while reading compressed size",
+                );
+              }
+              sizeFile = Number(extraView.getBigUint64(cursor, true));
+              cursor += 8;
+              localZip64DataSize += 8;
+            }
+
+            if (zip64OffsetOverflow) {
+              if (cursor + 8 > dataEnd) {
+                throw new Error(
+                  "ZIP64 extra field truncated while reading relative offset",
+                );
+              }
+              relativeOffset = Number(extraView.getBigUint64(cursor, true));
+              cursor += 8;
+            }
+
+            if (localZip64DataSize > 0) {
+              localExtraFieldZip64Length = 4 + localZip64DataSize;
+            }
+            break;
+          }
+
+          if (dataSize === 0) {
+            extraOffset += 4;
+          } else {
+            extraOffset += 4 + dataSize;
+          }
+        }
+      }
+    }
+    let absoluteOffset =
+      relativeOffset + 30 + sizeFileName + localExtraFieldZip64Length;
+
+    if (verifyOffsets) {
+      const verification = await verifyLocalHeaderOffset({
+        source,
+        filename,
+        relativeOffset,
+        computedOffset: absoluteOffset,
+        decoder,
+        logger: verificationLogger,
+      });
+      if (verification && typeof verification.dataOffset === "number") {
+        absoluteOffset = verification.dataOffset;
+      }
+    }
+    zipFiles[filename] = {
+      filename,
+      size: sizeFile,
+      generalPurposeFlag,
+      compressionMethod,
+      uncompressedSize,
+      relativeOffset,
+      absoluteOffset,
+    };
+
+    entryStart += headerLength;
+  }
+
+  return {
+    files: zipFiles,
+    etag: tailResp.etag,
+  };
+}
+
 function xmlToJson(xmlString) {
   const parser = new DOMParser();
   const xmlDoc = parser.parseFromString(xmlString, "application/xml");
@@ -1302,137 +1648,14 @@ function jsonToHeader(json, files, etag) {
  */
 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;
-  }
-
+  const { files: tilePackageFiles, etag } =
+    await getFilelistFromZip(source);
   let root = {};
-
   if (key.indexOf(".tpkx") !== -1) {
     // TPKX
-    root = await getJsonFromFile("root.json", tilePackageFiles, source);
+    root = await getJsonFromZip("root.json", tilePackageFiles, source);
     root.type = "tpkx";
-    const iteminfo = await getJsonFromFile(
+    const iteminfo = await getJsonFromZip(
       "iteminfo.json",
       tilePackageFiles,
       source,
@@ -1444,7 +1667,7 @@ async function getHeaderAndFileList(source) {
     });
   } else {
     // VTPK
-    root = await getJsonFromFile("p12/root.json", tilePackageFiles, source);
+    root = await getJsonFromZip("p12/root.json", tilePackageFiles, source);
     root.type = "vtpk";
 
     const iteminfoFile = "esriinfo/iteminfo.xml";
@@ -1498,7 +1721,7 @@ async function getHeaderAndFileList(source) {
     }
     // Get and calculate the tilemap
     if (source.coverageCheck > 0 && tilePackageFiles["p12/tilemap/root.json"]) {
-      const tilemap = await getJsonFromFile(
+      const tilemap = await getJsonFromZip(
         "p12/tilemap/root.json",
         tilePackageFiles,
         source,
@@ -1512,7 +1735,7 @@ async function getHeaderAndFileList(source) {
     }
   }
 
-  const header = jsonToHeader(root, tilePackageFiles, resp.etag);
+  const header = jsonToHeader(root, tilePackageFiles, etag);
   return [header, ""];
 }
 
@@ -1733,23 +1956,18 @@ class SharedPromiseCache {
   }
 }
 
-/**
- * Escape literal newlines in JSON text.
- * Replaces actual newline characters with the JSON escape sequence.
- */
-function escapeJsonNewlines(text) {
-  // Replace literal newlines with JSON escape sequences
-  // This handles \r\n, \n, and \r
-  return text.replace(/\r\n/g, "\\n").replace(/[\r\n]/g, "\\n");
-}
-
 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");
-  const basePath = header.type === "tpkx" ? "tile" : "p12/tile";
+  let basePath;
+  if (header.type === "tpkx") {
+    basePath = `tile`;
+  } else {
+    basePath = `p12/tile`;
+  }
   return `${basePath}/L${zoom}/R${rowHex}C${colHex}.bundle`;
 }
 
@@ -1759,6 +1977,10 @@ function getTileInfoFromTileIndex(tileIndex, z, x, y) {
   return tileIndex[row][col];
 }
 
+/**
+ * Error thrown when a response for TilePackage over HTTP does not match previous, cached parts of the archive.
+ * The default TilePackage implementation will catch this error once internally and retry a request.
+ */
 class EtagMismatch extends Error {
   constructor(message) {
     super(message);
@@ -1771,25 +1993,23 @@ class TilePackage {
     // 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);
+      this.source = new FetchSource(source, this.coverageCheck);
     } 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();
+
+    if (options && options.decompress) {
+      this.decompress = options.decompress;
+    } else {
+      this.decompress = defaultDecompress;
+    }
+
+    if (options && options.cache) {
+      this.cache = options.cache;
+    } else {
+      this.cache = new SharedPromiseCache();
+    }
   }
 
   async getHeader() {
@@ -1906,21 +2126,21 @@ class TilePackage {
 
   async getMetadataAttempt() {
     const header = await this.cache.getHeader(this.source);
+
     let metadata = {};
     if (header.packageType === "vtpk") {
       const resp = await this.source.getBytes(
-        header.metadataOffset,
-        header.metadataLength,
+        header.jsonMetadataOffset,
+        header.jsonMetadataLength,
         undefined,
         header.etag,
       );
+
       const decoder = new TextDecoder("utf-8");
-      const jsonText = decoder.decode(resp.data);
-      console.log("test", jsonText);
-      console.log("escaped text", escapeJsonNewlines(jsonText));
-      metadata = JSON.parse(escapeJsonNewlines(jsonText));
+      metadata = JSON.parse(decoder.decode(resp.data));
     }
     metadata.name = header.name;
+
     return metadata;
   }
 
@@ -1938,7 +2158,10 @@ class TilePackage {
 
   async getResourceAttempt(file, signal) {
     const header = await this.cache.getHeader(this.source);
-    if (!header.files[file]) return undefined;
+    if (!header.files[file]) {
+      return undefined;
+    }
+
     const resource = await this.cache.getResource(
       this.source,
       file,
@@ -1968,59 +2191,46 @@ class TilePackage {
     const header = await this.cache.getHeader(this.source);
     const sourceKey = this.source.getKey();
     if (header.packageType === "vtpk") {
-      const metadata = await getJsonFromFile(
+      const metadata = await getJsonFromZip(
         "p12/root.json",
         header.files,
         this.source,
       );
-      const style = await getJsonFromFile(
+      const style = await getJsonFromZip(
         "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.url = `tilepackage://${sourceKey}`;
+      style.sources.esri.minzoom = 0; //header.maxZoom || 22;
+      style.sources.esri.maxzoom = header.maxZoom || 22;
+      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,
+    } else {
+      const style = {
+        version: 8,
+        sources: {
+          esri: {
+            type: "raster",
+            tileSize: header.tileSize || 256,
+            url: `tilepackage://${sourceKey}`,
+            maxzoom: header.maxZoom || 22,
+          },
         },
-      },
-      layers: [{ id: "tilepackageraster", type: "raster", source: "esri" }],
-    };
+        layers: [
+          {
+            id: "tilepackageraster",
+            type: "raster",
+            source: "esri",
+          },
+        ],
+      };
+      return style;
+    }
   }
 
   async getStyle() {
@@ -2039,6 +2249,7 @@ class TilePackage {
     const header = await this.getHeader();
     const metadata = await this.getMetadata();
     const ext = header.tileType;
+
     const tileJson = {
       tilejson: "3.0.0",
       scheme: "xyz",
@@ -2047,11 +2258,21 @@ class TilePackage {
       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;
+    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;
   }
 }