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

package/dist/index.cjs

@@ -55,7 +55,7 @@ module.exports = __toCommonJS(dist_exports);
 
 // dist/zip-loader.js
 var import_jszip = __toESM(require("jszip"), 1);
-var VERSION = true ? "4.2.0" : "latest";
+var VERSION = true ? "4.3.0-alpha.1" : "latest";
 var ZipLoader = {
   dataType: null,
   batchType: null,
@@ -102,7 +102,7 @@ async function loadZipEntry(jsZip, subFilename, options = {}) {
 
 // dist/zip-writer.js
 var import_jszip2 = __toESM(require("jszip"), 1);
-var VERSION2 = true ? "4.2.0" : "latest";
+var VERSION2 = true ? "4.3.0-alpha.1" : "latest";
 var ZipWriter = {
   name: "Zip Archive",
   id: "zip",
@@ -366,6 +366,7 @@ var import_loader_utils3 = require("@loaders.gl/loader-utils");
 var import_loader_utils2 = require("@loaders.gl/loader-utils");
 
 // dist/parse-zip/search-from-the-end.js
+var buffLength = 1024;
 var searchFromTheEnd = async (file, target) => {
   const searchWindow = [
     await file.getUint8(file.length - 1n),
@@ -373,18 +374,25 @@ var searchFromTheEnd = async (file, target) => {
     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);
 };
 
 // dist/parse-zip/zip64-info-generation.js
@@ -466,6 +474,7 @@ var ZIP64_COMMENT_OFFSET = 56n;
 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;
@@ -477,6 +486,7 @@ var parseEoCDRecord = async (file) => {
       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;
@@ -484,6 +494,7 @@ var parseEoCDRecord = async (file) => {
   return {
     cdRecordsNumber,
     cdStartOffset,
+    cdByteSize,
     offsets: {
       zip64EoCDOffset,
       zip64EoCDLocatorOffset,
@@ -677,30 +688,35 @@ var ZIP64_EOCD_FIELDS = [
 ];
 
 // dist/parse-zip/cd-file-header.js
-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 (!(0, import_loader_utils3.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(headerOffset + CD_FILE_NAME_OFFSET, headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength));
+  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 + 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)));
+  const extraField = new DataView(additionalHeader.slice(fileNameLength, additionalHeader.byteLength));
   const zip64data = {
     uncompressedSize,
     compressedSize,
@@ -718,11 +734,12 @@ var parseZipCDFileHeader = async (headerOffset, file) => {
   };
 };
 async function* makeZipCDHeaderIterator(fileProvider) {
-  const { cdStartOffset } = await parseEoCDRecord(fileProvider);
-  let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);
+  const { cdStartOffset, cdByteSize } = await parseEoCDRecord(fileProvider);
+  const centralDirectory = new import_loader_utils3.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);
+    cdHeader = await parseZipCDFileHeader(cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength), centralDirectory);
   }
 }
 var getUint16 = (...bytes) => {
@@ -895,37 +912,40 @@ var ZIP_HEADER_FIELDS = [
 
 // dist/parse-zip/local-file-header.js
 var import_loader_utils4 = require("@loaders.gl/loader-utils");
-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 (!(0, import_loader_utils4.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,