@loaders.gl/zip 4.2.1 → 4.3.0-alpha.2

package/dist/dist.dev.js

@@ -7720,7 +7720,65 @@ var __exports__ = (() => {
     }
   };
 
+  // ../loader-utils/src/lib/file-provider/data-view-file.ts
+  var toNumber = (bigint) => {
+    if (bigint > Number.MAX_SAFE_INTEGER) {
+      throw new Error("Offset is out of bounds");
+    }
+    return Number(bigint);
+  };
+  var DataViewFile = class {
+    /** The DataView from which data is provided */
+    file;
+    constructor(file) {
+      this.file = file;
+    }
+    async destroy() {
+    }
+    /**
+     * Gets an unsigned 8-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint8(offset) {
+      return this.file.getUint8(toNumber(offset));
+    }
+    /**
+     * Gets an unsigned 16-bit intege at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint16(offset) {
+      return this.file.getUint16(toNumber(offset), true);
+    }
+    /**
+     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint32(offset) {
+      return this.file.getUint32(toNumber(offset), true);
+    }
+    /**
+     * Gets an unsigned 64-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getBigUint64(offset) {
+      return this.file.getBigUint64(toNumber(offset), true);
+    }
+    /**
+     * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
+     * @param startOffset The offset, in bytes, from the start of the file where to start reading the data.
+     * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
+     */
+    async slice(startOffset, endOffset) {
+      return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+    }
+    /** the length (in bytes) of the data. */
+    get length() {
+      return BigInt(this.file.byteLength);
+    }
+  };
+
   // src/parse-zip/search-from-the-end.ts
+  var buffLength = 1024;
   var searchFromTheEnd = async (file, target) => {
     const searchWindow = [
       await file.getUint8(file.length - 1n),
@@ -7728,18 +7786,25 @@ var __exports__ = (() => {
       await file.getUint8(file.length - 3n),
       void 0
     ];
-    let targetOffset = 0n;
-    for (let i = file.length - 4n; i > -1; i--) {
-      searchWindow[3] = searchWindow[2];
-      searchWindow[2] = searchWindow[1];
-      searchWindow[1] = searchWindow[0];
-      searchWindow[0] = await file.getUint8(i);
-      if (searchWindow.every((val, index) => val === target[index])) {
-        targetOffset = i;
-        break;
+    let targetOffset = -1;
+    let point = file.length - 4n;
+    do {
+      const prevPoint = point;
+      point -= BigInt(buffLength);
+      point = point >= 0n ? point : 0n;
+      const buff = new Uint8Array(await file.slice(point, prevPoint));
+      for (let i = buff.length - 1; i > -1; i--) {
+        searchWindow[3] = searchWindow[2];
+        searchWindow[2] = searchWindow[1];
+        searchWindow[1] = searchWindow[0];
+        searchWindow[0] = buff[i];
+        if (searchWindow.every((val, index) => val === target[index])) {
+          targetOffset = i;
+          break;
+        }
       }
-    }
-    return targetOffset;
+    } while (targetOffset === -1 && point > 0n);
+    return point + BigInt(targetOffset);
   };
 
   // src/parse-zip/zip64-info-generation.ts
@@ -7820,6 +7885,7 @@ var __exports__ = (() => {
   var parseEoCDRecord = async (file) => {
     const zipEoCDOffset = await searchFromTheEnd(file, eoCDSignature);
     let cdRecordsNumber = BigInt(await file.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
+    let cdByteSize = BigInt(await file.getUint32(zipEoCDOffset + CD_CD_BYTE_SIZE_OFFSET));
     let cdStartOffset = BigInt(await file.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
     let zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
     let zip64EoCDOffset = 0n;
@@ -7833,6 +7899,7 @@ var __exports__ = (() => {
         throw new Error("zip64 EoCD not found");
       }
       cdRecordsNumber = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+      cdByteSize = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_CD_BYTE_SIZE_OFFSET);
       cdStartOffset = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
     } else {
       zip64EoCDLocatorOffset = 0n;
@@ -7840,6 +7907,7 @@ var __exports__ = (() => {
     return {
       cdRecordsNumber,
       cdStartOffset,
+      cdByteSize,
       offsets: {
         zip64EoCDOffset,
         zip64EoCDLocatorOffset,
@@ -8058,34 +8126,41 @@ var __exports__ = (() => {
   ];
 
   // src/parse-zip/cd-file-header.ts
-  var CD_COMPRESSED_SIZE_OFFSET = 20n;
-  var CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
-  var CD_FILE_NAME_LENGTH_OFFSET = 28n;
-  var CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;
-  var CD_START_DISK_OFFSET = 32n;
-  var CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;
+  var CD_COMPRESSED_SIZE_OFFSET = 20;
+  var CD_UNCOMPRESSED_SIZE_OFFSET = 24;
+  var CD_FILE_NAME_LENGTH_OFFSET = 28;
+  var CD_EXTRA_FIELD_LENGTH_OFFSET = 30;
+  var CD_START_DISK_OFFSET = 32;
+  var CD_LOCAL_HEADER_OFFSET_OFFSET = 42;
   var CD_FILE_NAME_OFFSET = 46n;
   var signature2 = new Uint8Array([80, 75, 1, 2]);
   var parseZipCDFileHeader = async (headerOffset, file) => {
-    const magicBytes = await file.slice(headerOffset, headerOffset + 4n);
+    if (headerOffset >= file.length) {
+      return null;
+    }
+    const mainHeader = new DataView(
+      await file.slice(headerOffset, headerOffset + CD_FILE_NAME_OFFSET)
+    );
+    const magicBytes = mainHeader.buffer.slice(0, 4);
     if (!compareArrayBuffers(magicBytes, signature2.buffer)) {
       return null;
     }
-    const compressedSize = BigInt(await file.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));
-    const uncompressedSize = BigInt(await file.getUint32(headerOffset + CD_UNCOMPRESSED_SIZE_OFFSET));
-    const extraFieldLength = await file.getUint16(headerOffset + CD_EXTRA_FIELD_LENGTH_OFFSET);
-    const startDisk = BigInt(await file.getUint16(headerOffset + CD_START_DISK_OFFSET));
-    const fileNameLength = await file.getUint16(headerOffset + CD_FILE_NAME_LENGTH_OFFSET);
-    const filenameBytes = await file.slice(
+    const compressedSize = BigInt(mainHeader.getUint32(CD_COMPRESSED_SIZE_OFFSET, true));
+    const uncompressedSize = BigInt(mainHeader.getUint32(CD_UNCOMPRESSED_SIZE_OFFSET, true));
+    const extraFieldLength = mainHeader.getUint16(CD_EXTRA_FIELD_LENGTH_OFFSET, true);
+    const startDisk = BigInt(mainHeader.getUint16(CD_START_DISK_OFFSET, true));
+    const fileNameLength = mainHeader.getUint16(CD_FILE_NAME_LENGTH_OFFSET, true);
+    const additionalHeader = await file.slice(
       headerOffset + CD_FILE_NAME_OFFSET,
-      headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength)
+      headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
     );
+    const filenameBytes = additionalHeader.slice(0, fileNameLength);
     const fileName = new TextDecoder().decode(filenameBytes);
     const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
-    const oldFormatOffset = await file.getUint32(headerOffset + CD_LOCAL_HEADER_OFFSET_OFFSET);
+    const oldFormatOffset = mainHeader.getUint32(CD_LOCAL_HEADER_OFFSET_OFFSET, true);
     const localHeaderOffset = BigInt(oldFormatOffset);
     const extraField = new DataView(
-      await file.slice(extraOffset, extraOffset + BigInt(extraFieldLength))
+      additionalHeader.slice(fileNameLength, additionalHeader.byteLength)
     );
     const zip64data = {
       uncompressedSize,
@@ -8104,13 +8179,16 @@ var __exports__ = (() => {
     };
   };
   async function* makeZipCDHeaderIterator(fileProvider) {
-    const { cdStartOffset } = await parseEoCDRecord(fileProvider);
-    let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);
+    const { cdStartOffset, cdByteSize } = await parseEoCDRecord(fileProvider);
+    const centralDirectory = new DataViewFile(
+      new DataView(await fileProvider.slice(cdStartOffset, cdStartOffset + cdByteSize))
+    );
+    let cdHeader = await parseZipCDFileHeader(0n, centralDirectory);
     while (cdHeader) {
       yield cdHeader;
       cdHeader = await parseZipCDFileHeader(
         cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength),
-        fileProvider
+        centralDirectory
       );
     }
   }
@@ -8290,42 +8368,45 @@ var __exports__ = (() => {
   ];
 
   // src/parse-zip/local-file-header.ts
-  var COMPRESSION_METHOD_OFFSET = 8n;
-  var COMPRESSED_SIZE_OFFSET = 18n;
-  var UNCOMPRESSED_SIZE_OFFSET = 22n;
-  var FILE_NAME_LENGTH_OFFSET = 26n;
-  var EXTRA_FIELD_LENGTH_OFFSET = 28n;
+  var COMPRESSION_METHOD_OFFSET = 8;
+  var COMPRESSED_SIZE_OFFSET = 18;
+  var UNCOMPRESSED_SIZE_OFFSET = 22;
+  var FILE_NAME_LENGTH_OFFSET = 26;
+  var EXTRA_FIELD_LENGTH_OFFSET = 28;
   var FILE_NAME_OFFSET = 30n;
   var signature3 = new Uint8Array([80, 75, 3, 4]);
-  var parseZipLocalFileHeader = async (headerOffset, buffer) => {
-    const magicBytes = await buffer.slice(headerOffset, headerOffset + 4n);
+  var parseZipLocalFileHeader = async (headerOffset, file) => {
+    const mainHeader = new DataView(await file.slice(headerOffset, headerOffset + FILE_NAME_OFFSET));
+    const magicBytes = mainHeader.buffer.slice(0, 4);
     if (!compareArrayBuffers(magicBytes, signature3)) {
       return null;
     }
-    const fileNameLength = await buffer.getUint16(headerOffset + FILE_NAME_LENGTH_OFFSET);
-    const fileName = new TextDecoder().decode(
-      await buffer.slice(
-        headerOffset + FILE_NAME_OFFSET,
-        headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength)
-      )
-    ).split("\\").join("/");
-    const extraFieldLength = await buffer.getUint16(headerOffset + EXTRA_FIELD_LENGTH_OFFSET);
+    const fileNameLength = mainHeader.getUint16(FILE_NAME_LENGTH_OFFSET, true);
+    const extraFieldLength = mainHeader.getUint16(EXTRA_FIELD_LENGTH_OFFSET, true);
+    const additionalHeader = await file.slice(
+      headerOffset + FILE_NAME_OFFSET,
+      headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
+    );
+    const fileNameBuffer = additionalHeader.slice(0, fileNameLength);
+    const extraDataBuffer = new DataView(
+      additionalHeader.slice(fileNameLength, additionalHeader.byteLength)
+    );
+    const fileName = new TextDecoder().decode(fileNameBuffer).split("\\").join("/");
     let fileDataOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
-    const compressionMethod = await buffer.getUint16(headerOffset + COMPRESSION_METHOD_OFFSET);
-    let compressedSize = BigInt(await buffer.getUint32(headerOffset + COMPRESSED_SIZE_OFFSET));
-    let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET));
-    const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);
-    let offsetInZip64Data = 4n;
+    const compressionMethod = mainHeader.getUint16(COMPRESSION_METHOD_OFFSET, true);
+    let compressedSize = BigInt(mainHeader.getUint32(COMPRESSED_SIZE_OFFSET, true));
+    let uncompressedSize = BigInt(mainHeader.getUint32(UNCOMPRESSED_SIZE_OFFSET, true));
+    let offsetInZip64Data = 4;
     if (uncompressedSize === BigInt(4294967295)) {
-      uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
-      offsetInZip64Data += 8n;
+      uncompressedSize = extraDataBuffer.getBigUint64(offsetInZip64Data, true);
+      offsetInZip64Data += 8;
     }
     if (compressedSize === BigInt(4294967295)) {
-      compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
-      offsetInZip64Data += 8n;
+      compressedSize = extraDataBuffer.getBigUint64(offsetInZip64Data, true);
+      offsetInZip64Data += 8;
     }
     if (fileDataOffset === BigInt(4294967295)) {
-      fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+      fileDataOffset = extraDataBuffer.getBigUint64(offsetInZip64Data, true);
     }
     return {
       fileNameLength,