@loaders.gl/zip 4.1.0-alpha.1 → 4.1.0-alpha.11

package/dist/index.cjs

@@ -35,7 +35,11 @@ __export(src_exports, {
   ZipFileSystem: () => ZipFileSystem,
   ZipLoader: () => ZipLoader,
   ZipWriter: () => ZipWriter,
+  addOneFile: () => addOneFile,
+  composeHashFile: () => composeHashFile,
+  createZip: () => createZip,
   generateCDHeader: () => generateCDHeader,
+  generateLocalHeader: () => generateLocalHeader,
   localHeaderSignature: () => signature3,
   makeHashTableFromZipHeaders: () => makeHashTableFromZipHeaders,
   makeZipCDHeaderIterator: () => makeZipCDHeaderIterator,
@@ -94,27 +98,41 @@ async function loadZipEntry(jsZip, subFilename, options = {}) {
 
 // src/zip-writer.ts
 var import_jszip2 = __toESM(require("jszip"), 1);
+var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var ZipWriter = {
   name: "Zip Archive",
+  id: "zip",
+  module: "zip",
+  version: VERSION2,
   extensions: ["zip"],
   category: "archive",
   mimeTypes: ["application/zip"],
-  // @ts-ignore
+  options: {
+    zip: {
+      onUpdate: () => {
+      }
+    },
+    jszip: {}
+  },
   encode: encodeZipAsync
 };
 async function encodeZipAsync(fileMap, options = {}) {
+  var _a;
   const jsZip = new import_jszip2.default();
   for (const subFileName in fileMap) {
     const subFileData = fileMap[subFileName];
     jsZip.file(subFileName, subFileData, (options == null ? void 0 : options.jszip) || {});
   }
-  const jszipOptions = { ...options == null ? void 0 : options.jszip, type: "arraybuffer" };
-  const { onUpdate = () => {
-  } } = options;
+  const zipOptions = { ...ZipWriter.options.zip, ...options == null ? void 0 : options.zip };
+  const jszipOptions = { ...(_a = ZipWriter.options) == null ? void 0 : _a.jszip, ...options.jszip };
   try {
-    return await jsZip.generateAsync(jszipOptions, onUpdate);
+    return await jsZip.generateAsync(
+      { ...jszipOptions, type: "arraybuffer" },
+      // generate an arraybuffer
+      zipOptions.onUpdate
+    );
   } catch (error) {
-    options.log.error(`Unable to write zip archive: ${error}`);
+    options.log.error(`Unable to encode zip archive: ${error}`);
     throw error;
   }
 }
@@ -338,7 +356,7 @@ var TarBuilder = class {
 var import_loader_utils3 = require("@loaders.gl/loader-utils");
 
 // src/parse-zip/end-of-central-directory.ts
-var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
 
 // src/parse-zip/search-from-the-end.ts
 var searchFromTheEnd = async (file, target) => {
@@ -362,43 +380,8 @@ var searchFromTheEnd = async (file, target) => {
   return targetOffset;
 };
 
-// src/parse-zip/end-of-central-directory.ts
-var eoCDSignature = new Uint8Array([80, 75, 5, 6]);
-var zip64EoCDLocatorSignature = new Uint8Array([80, 75, 6, 7]);
-var zip64EoCDSignature = new Uint8Array([80, 75, 6, 6]);
-var CD_RECORDS_NUMBER_OFFSET = 8n;
-var CD_START_OFFSET_OFFSET = 16n;
-var ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
-var ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
-var ZIP64_CD_START_OFFSET_OFFSET = 48n;
-var parseEoCDRecord = async (file) => {
-  const zipEoCDOffset = await searchFromTheEnd(file, eoCDSignature);
-  let cdRecordsNumber = BigInt(await file.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
-  let cdStartOffset = BigInt(await file.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
-  if (cdStartOffset === BigInt(4294967295) || cdRecordsNumber === BigInt(4294967295)) {
-    const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
-    const magicBytes = await file.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
-    if (!(0, import_loader_utils.compareArrayBuffers)(magicBytes, zip64EoCDLocatorSignature)) {
-      throw new Error("zip64 EoCD locator not found");
-    }
-    const zip64EoCDOffset = await file.getBigUint64(
-      zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
-    );
-    const endOfCDMagicBytes = await file.slice(zip64EoCDOffset, zip64EoCDOffset + 4n);
-    if (!(0, import_loader_utils.compareArrayBuffers)(endOfCDMagicBytes, zip64EoCDSignature.buffer)) {
-      throw new Error("zip64 EoCD not found");
-    }
-    cdRecordsNumber = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
-    cdStartOffset = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
-  }
-  return {
-    cdRecordsNumber,
-    cdStartOffset
-  };
-};
-
 // src/parse-zip/zip64-info-generation.ts
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+var import_loader_utils = require("@loaders.gl/loader-utils");
 var signature = new Uint8Array([1, 0]);
 function createZip64Info(options) {
   const optionsToUse = {
@@ -414,14 +397,17 @@ function createZip64Info(options) {
     NUMBER_SETTERS[field.size](newValue, 0, optionsToUse[field.name ?? ""] ?? field.default);
     arraysToConcat.push(newValue.buffer);
   }
-  return (0, import_loader_utils2.concatenateArrayBuffers)(...arraysToConcat);
+  return (0, import_loader_utils.concatenateArrayBuffers)(...arraysToConcat);
+}
+function setFieldToNumber(header, fieldSize, fieldOffset, value) {
+  NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);
 }
 var NUMBER_SETTERS = {
   2: (header, offset, value) => {
-    header.setUint16(offset, value, true);
+    header.setUint16(offset, Number(value > 65535 ? 65535 : value), true);
   },
   4: (header, offset, value) => {
-    header.setUint32(offset, value, true);
+    header.setUint32(offset, Number(value > 4294967295 ? 4294967295 : value), true);
   },
   8: (header, offset, value) => {
     header.setBigUint64(offset, BigInt(value), true);
@@ -455,6 +441,261 @@ var ZIP64_FIELDS = [
   }
 ];
 
+// src/parse-zip/end-of-central-directory.ts
+var eoCDSignature = new Uint8Array([80, 75, 5, 6]);
+var zip64EoCDLocatorSignature = new Uint8Array([80, 75, 6, 7]);
+var zip64EoCDSignature = new Uint8Array([80, 75, 6, 6]);
+var CD_RECORDS_NUMBER_OFFSET = 8n;
+var CD_RECORDS_NUMBER_ON_DISC_OFFSET = 10n;
+var CD_CD_BYTE_SIZE_OFFSET = 12n;
+var CD_START_OFFSET_OFFSET = 16n;
+var CD_COMMENT_OFFSET = 22n;
+var ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
+var ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+var ZIP64_CD_RECORDS_NUMBER_ON_DISC_OFFSET = 32n;
+var ZIP64_CD_CD_BYTE_SIZE_OFFSET = 40n;
+var ZIP64_CD_START_OFFSET_OFFSET = 48n;
+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 cdStartOffset = BigInt(await file.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
+  let zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+  let zip64EoCDOffset = 0n;
+  const magicBytes = await file.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
+  if ((0, import_loader_utils2.compareArrayBuffers)(magicBytes, zip64EoCDLocatorSignature)) {
+    zip64EoCDOffset = await file.getBigUint64(
+      zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
+    );
+    const endOfCDMagicBytes = await file.slice(zip64EoCDOffset, zip64EoCDOffset + 4n);
+    if (!(0, import_loader_utils2.compareArrayBuffers)(endOfCDMagicBytes, zip64EoCDSignature.buffer)) {
+      throw new Error("zip64 EoCD not found");
+    }
+    cdRecordsNumber = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+    cdStartOffset = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+  } else {
+    zip64EoCDLocatorOffset = 0n;
+  }
+  return {
+    cdRecordsNumber,
+    cdStartOffset,
+    offsets: {
+      zip64EoCDOffset,
+      zip64EoCDLocatorOffset,
+      zipEoCDOffset
+    }
+  };
+};
+function updateEoCD(eocdBody, oldEoCDOffsets, newCDStartOffset, eocdStartOffset, newCDRecordsNumber) {
+  const eocd = new DataView(eocdBody);
+  const classicEoCDOffset = oldEoCDOffsets.zip64EoCDOffset ? oldEoCDOffsets.zipEoCDOffset - oldEoCDOffsets.zip64EoCDOffset : 0n;
+  if (Number(newCDRecordsNumber) <= 65535) {
+    setFieldToNumber(eocd, 2, classicEoCDOffset + CD_RECORDS_NUMBER_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(
+      eocd,
+      2,
+      classicEoCDOffset + CD_RECORDS_NUMBER_ON_DISC_OFFSET,
+      newCDRecordsNumber
+    );
+  }
+  if (eocdStartOffset - newCDStartOffset <= 4294967295) {
+    setFieldToNumber(
+      eocd,
+      4,
+      classicEoCDOffset + CD_CD_BYTE_SIZE_OFFSET,
+      eocdStartOffset - newCDStartOffset
+    );
+  }
+  if (newCDStartOffset < 4294967295) {
+    setFieldToNumber(eocd, 4, classicEoCDOffset + CD_START_OFFSET_OFFSET, newCDStartOffset);
+  }
+  if (oldEoCDOffsets.zip64EoCDLocatorOffset && oldEoCDOffsets.zip64EoCDOffset) {
+    const locatorOffset = oldEoCDOffsets.zip64EoCDLocatorOffset - oldEoCDOffsets.zip64EoCDOffset;
+    setFieldToNumber(eocd, 8, locatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET, eocdStartOffset);
+    setFieldToNumber(eocd, 8, ZIP64_CD_START_OFFSET_OFFSET, newCDStartOffset);
+    setFieldToNumber(eocd, 8, ZIP64_CD_RECORDS_NUMBER_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(eocd, 8, ZIP64_CD_RECORDS_NUMBER_ON_DISC_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(eocd, 8, ZIP64_CD_CD_BYTE_SIZE_OFFSET, eocdStartOffset - newCDStartOffset);
+  }
+  return new Uint8Array(eocd.buffer);
+}
+function generateEoCD(options) {
+  const header = new DataView(new ArrayBuffer(Number(CD_COMMENT_OFFSET)));
+  for (const field of EOCD_FIELDS) {
+    setFieldToNumber(
+      header,
+      field.size,
+      field.offset,
+      options[field.name ?? ""] ?? field.default ?? 0
+    );
+  }
+  const locator = generateZip64InfoLocator(options);
+  const zip64Record = generateZip64Info(options);
+  return (0, import_loader_utils2.concatenateArrayBuffers)(zip64Record, locator, header.buffer);
+}
+var EOCD_FIELDS = [
+  // End of central directory signature = 0x06054b50
+  {
+    offset: 0,
+    size: 4,
+    default: new DataView(eoCDSignature.buffer).getUint32(0, true)
+  },
+  // Number of this disk (or 0xffff for ZIP64)
+  {
+    offset: 4,
+    size: 2,
+    default: 0
+  },
+  // Disk where central directory starts (or 0xffff for ZIP64)
+  {
+    offset: 6,
+    size: 2,
+    default: 0
+  },
+  // Number of central directory records on this disk (or 0xffff for ZIP64)
+  {
+    offset: 8,
+    size: 2,
+    name: "recordsNumber"
+  },
+  // Total number of central directory records (or 0xffff for ZIP64)
+  {
+    offset: 10,
+    size: 2,
+    name: "recordsNumber"
+  },
+  // Size of central directory (bytes) (or 0xffffffff for ZIP64)
+  {
+    offset: 12,
+    size: 4,
+    name: "cdSize"
+  },
+  // Offset of start of central directory, relative to start of archive (or 0xffffffff for ZIP64)
+  {
+    offset: 16,
+    size: 4,
+    name: "cdOffset"
+  },
+  // Comment length (n)
+  {
+    offset: 20,
+    size: 2,
+    default: 0
+  }
+];
+function generateZip64Info(options) {
+  const record = new DataView(new ArrayBuffer(Number(ZIP64_COMMENT_OFFSET)));
+  for (const field of ZIP64_EOCD_FIELDS) {
+    setFieldToNumber(
+      record,
+      field.size,
+      field.offset,
+      options[field.name ?? ""] ?? field.default ?? 0
+    );
+  }
+  return record.buffer;
+}
+function generateZip64InfoLocator(options) {
+  const locator = new DataView(new ArrayBuffer(Number(20)));
+  for (const field of ZIP64_EOCD_LOCATOR_FIELDS) {
+    setFieldToNumber(
+      locator,
+      field.size,
+      field.offset,
+      options[field.name ?? ""] ?? field.default ?? 0
+    );
+  }
+  return locator.buffer;
+}
+var ZIP64_EOCD_LOCATOR_FIELDS = [
+  // zip64 end of central dir locator signature
+  {
+    offset: 0,
+    size: 4,
+    default: new DataView(zip64EoCDLocatorSignature.buffer).getUint32(0, true)
+  },
+  // number of the disk with the start of the zip64 end of
+  {
+    offset: 4,
+    size: 4,
+    default: 0
+  },
+  // start of the zip64 end of central directory
+  {
+    offset: 8,
+    size: 8,
+    name: "eoCDStart"
+  },
+  // total number of disks
+  {
+    offset: 16,
+    size: 4,
+    default: 1
+  }
+];
+var ZIP64_EOCD_FIELDS = [
+  // End of central directory signature = 0x06064b50
+  {
+    offset: 0,
+    size: 4,
+    default: new DataView(zip64EoCDSignature.buffer).getUint32(0, true)
+  },
+  // Size of the EOCD64 minus 12
+  {
+    offset: 4,
+    size: 8,
+    default: 44
+  },
+  // Version made by
+  {
+    offset: 12,
+    size: 2,
+    default: 45
+  },
+  // Version needed to extract (minimum)
+  {
+    offset: 14,
+    size: 2,
+    default: 45
+  },
+  // Number of this disk
+  {
+    offset: 16,
+    size: 4,
+    default: 0
+  },
+  // Disk where central directory starts
+  {
+    offset: 20,
+    size: 4,
+    default: 0
+  },
+  // Number of central directory records on this disk
+  {
+    offset: 24,
+    size: 8,
+    name: "recordsNumber"
+  },
+  // Total number of central directory records
+  {
+    offset: 32,
+    size: 8,
+    name: "recordsNumber"
+  },
+  // Size of central directory (bytes)
+  {
+    offset: 40,
+    size: 8,
+    name: "cdSize"
+  },
+  // Offset of start of central directory, relative to start of archive
+  {
+    offset: 48,
+    size: 8,
+    name: "cdOffset"
+  }
+];
+
 // src/parse-zip/cd-file-header.ts
 var CD_COMPRESSED_SIZE_OFFSET = 20n;
 var CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
@@ -558,7 +799,7 @@ function generateCDHeader(options) {
   const optionsToZip64 = {};
   if (optionsToUse.offset >= 4294967295) {
     optionsToZip64.offset = optionsToUse.offset;
-    optionsToUse.offset = 4294967295;
+    optionsToUse.offset = BigInt(4294967295);
   }
   if (optionsToUse.length >= 4294967295) {
     optionsToZip64.size = optionsToUse.length;
@@ -568,10 +809,11 @@ function generateCDHeader(options) {
     zip64header = createZip64Info(optionsToZip64);
     optionsToUse.extraLength = zip64header.byteLength;
   }
-  const header = new DataView(new ArrayBuffer(46));
+  const header = new DataView(new ArrayBuffer(Number(CD_FILE_NAME_OFFSET)));
   for (const field of ZIP_HEADER_FIELDS) {
-    NUMBER_SETTERS[field.size](
+    setFieldToNumber(
       header,
+      field.size,
       field.offset,
       optionsToUse[field.name ?? ""] ?? field.default ?? 0
     );
@@ -734,9 +976,222 @@ var parseZipLocalFileHeader = async (headerOffset, buffer) => {
     compressionMethod
   };
 };
+function generateLocalHeader(options) {
+  const optionsToUse = {
+    ...options,
+    extraLength: 0,
+    fnlength: options.fileName.length
+  };
+  let zip64header = new ArrayBuffer(0);
+  const optionsToZip64 = {};
+  if (optionsToUse.length >= 4294967295) {
+    optionsToZip64.size = optionsToUse.length;
+    optionsToUse.length = 4294967295;
+  }
+  if (Object.keys(optionsToZip64).length) {
+    zip64header = createZip64Info(optionsToZip64);
+    optionsToUse.extraLength = zip64header.byteLength;
+  }
+  const header = new DataView(new ArrayBuffer(Number(FILE_NAME_OFFSET)));
+  for (const field of ZIP_HEADER_FIELDS2) {
+    setFieldToNumber(
+      header,
+      field.size,
+      field.offset,
+      optionsToUse[field.name ?? ""] ?? field.default ?? 0
+    );
+  }
+  const encodedName = new TextEncoder().encode(optionsToUse.fileName);
+  const resHeader = (0, import_loader_utils4.concatenateArrayBuffers)(header.buffer, encodedName, zip64header);
+  return resHeader;
+}
+var ZIP_HEADER_FIELDS2 = [
+  // Local file header signature = 0x04034b50
+  {
+    offset: 0,
+    size: 4,
+    default: new DataView(signature3.buffer).getUint32(0, true)
+  },
+  // Version needed to extract (minimum)
+  {
+    offset: 4,
+    size: 2,
+    default: 45
+  },
+  // General purpose bit flag
+  {
+    offset: 6,
+    size: 2,
+    default: 0
+  },
+  // Compression method
+  {
+    offset: 8,
+    size: 2,
+    default: 0
+  },
+  // File last modification time
+  {
+    offset: 10,
+    size: 2,
+    default: 0
+  },
+  // File last modification date
+  {
+    offset: 12,
+    size: 2,
+    default: 0
+  },
+  // CRC-32 of uncompressed data
+  {
+    offset: 14,
+    size: 4,
+    name: "crc32"
+  },
+  // Compressed size (or 0xffffffff for ZIP64)
+  {
+    offset: 18,
+    size: 4,
+    name: "length"
+  },
+  // Uncompressed size (or 0xffffffff for ZIP64)
+  {
+    offset: 22,
+    size: 4,
+    name: "length"
+  },
+  // File name length (n)
+  {
+    offset: 26,
+    size: 2,
+    name: "fnlength"
+  },
+  // Extra field length (m)
+  {
+    offset: 28,
+    size: 2,
+    default: 0,
+    name: "extraLength"
+  }
+];
 
-// src/hash-file-utility.ts
+// src/parse-zip/zip-composition.ts
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
 var import_crypto = require("@loaders.gl/crypto");
+var import_core = require("@loaders.gl/core");
+async function cutTheTailOff(provider) {
+  const oldEoCDinfo = await parseEoCDRecord(provider);
+  const oldCDStartOffset = oldEoCDinfo.cdStartOffset;
+  const oldCDLength = Number(
+    oldEoCDinfo.offsets.zip64EoCDOffset ? oldEoCDinfo.offsets.zip64EoCDOffset - oldCDStartOffset : oldEoCDinfo.offsets.zipEoCDOffset - oldCDStartOffset
+  );
+  const zipEnding = await provider.slice(oldCDStartOffset, provider.length);
+  await provider.truncate(Number(oldCDStartOffset));
+  const oldCDBody = zipEnding.slice(0, oldCDLength);
+  const eocdBody = zipEnding.slice(oldCDLength, zipEnding.byteLength);
+  return [oldCDBody, eocdBody, oldEoCDinfo];
+}
+async function generateFileHeaders(fileName, fileToAdd, localFileHeaderOffset) {
+  const newFileCRC322 = parseInt(await new import_crypto.CRC32Hash().hash(fileToAdd, "hex"), 16);
+  const newFileLocalHeader = generateLocalHeader({
+    crc32: newFileCRC322,
+    fileName,
+    length: fileToAdd.byteLength
+  });
+  const newFileCDHeader = generateCDHeader({
+    crc32: newFileCRC322,
+    fileName,
+    offset: localFileHeaderOffset,
+    length: fileToAdd.byteLength
+  });
+  return [
+    new Uint8Array((0, import_loader_utils5.concatenateArrayBuffers)(newFileLocalHeader, fileToAdd)),
+    new Uint8Array(newFileCDHeader)
+  ];
+}
+async function addOneFile(zipUrl, fileToAdd, fileName) {
+  const provider = new import_loader_utils5.FileHandleFile(zipUrl, true);
+  const [oldCDBody, eocdBody, oldEoCDinfo] = await cutTheTailOff(provider);
+  const newFileOffset = provider.length;
+  const [localPart, cdHeaderPart] = await generateFileHeaders(fileName, fileToAdd, newFileOffset);
+  await provider.append(localPart);
+  const newCDBody = (0, import_loader_utils5.concatenateArrayBuffers)(oldCDBody, cdHeaderPart);
+  const newCDStartOffset = provider.length;
+  await provider.append(new Uint8Array(newCDBody));
+  const eocdOffset = provider.length;
+  await provider.append(
+    updateEoCD(
+      eocdBody,
+      oldEoCDinfo.offsets,
+      newCDStartOffset,
+      eocdOffset,
+      oldEoCDinfo.cdRecordsNumber + 1n
+    )
+  );
+}
+async function createZip(inputPath, outputPath, createAdditionalData) {
+  const fileIterator = getFileIterator(inputPath);
+  const resFile = new import_loader_utils5.NodeFile(outputPath, "w");
+  const fileList = [];
+  const cdArray = [];
+  for await (const file of fileIterator) {
+    await addFile(file, resFile, cdArray, fileList);
+  }
+  if (createAdditionalData) {
+    const additionaldata = await createAdditionalData(fileList);
+    console.log(additionaldata);
+    await addFile(additionaldata, resFile, cdArray);
+  }
+  const cdOffset = (await resFile.stat()).bigsize;
+  const cd = (0, import_loader_utils5.concatenateArrayBuffers)(...cdArray);
+  await resFile.append(new Uint8Array(cd));
+  const eoCDStart = (await resFile.stat()).bigsize;
+  await resFile.append(
+    new Uint8Array(
+      generateEoCD({ recordsNumber: cdArray.length, cdSize: cd.byteLength, cdOffset, eoCDStart })
+    )
+  );
+}
+async function addFile(file, resFile, cdArray, fileList) {
+  const size = (await resFile.stat()).bigsize;
+  fileList == null ? void 0 : fileList.push({ fileName: file.path, localHeaderOffset: size });
+  const [localPart, cdHeaderPart] = await generateFileHeaders(file.path, file.file, size);
+  await resFile.append(localPart);
+  cdArray.push(cdHeaderPart);
+}
+function getFileIterator(inputPath) {
+  async function* iterable() {
+    const fileList = await getAllFiles(inputPath);
+    for (const filePath of fileList) {
+      const file = await (await (0, import_core.fetchFile)(import_loader_utils5.path.join(inputPath, filePath))).arrayBuffer();
+      yield { path: filePath, file };
+    }
+  }
+  return iterable();
+}
+async function getAllFiles(basePath, subfolder = "", fsPassed) {
+  const fs = fsPassed ? fsPassed : new import_loader_utils5.NodeFilesystem({});
+  const files = await fs.readdir(pathJoin(basePath, subfolder));
+  const arrayOfFiles = [];
+  for (const file of files) {
+    const fullPath = pathJoin(basePath, subfolder, file);
+    if ((await fs.stat(fullPath)).isDirectory) {
+      const files2 = await getAllFiles(basePath, pathJoin(subfolder, file));
+      arrayOfFiles.push(...files2);
+    } else {
+      arrayOfFiles.push(pathJoin(subfolder, file));
+    }
+  }
+  return arrayOfFiles;
+}
+function pathJoin(...paths) {
+  const resPaths = paths.filter((val) => val.length);
+  return import_loader_utils5.path.join(...resPaths);
+}
+
+// src/hash-file-utility.ts
+var import_crypto2 = require("@loaders.gl/crypto");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
 function parseHashTable(arrayBuffer) {
   const dataView = new DataView(arrayBuffer);
   const hashMap = {};
@@ -752,7 +1207,10 @@ function bufferToHex(buffer, start, length) {
 }
 async function makeHashTableFromZipHeaders(fileProvider) {
   const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
-  const md5Hash = new import_crypto.MD5Hash();
+  return getHashTable(zipCDIterator);
+}
+async function getHashTable(zipCDIterator) {
+  const md5Hash = new import_crypto2.MD5Hash();
   const textEncoder = new TextEncoder();
   const hashTable = {};
   for await (const cdHeader of zipCDIterator) {
@@ -763,11 +1221,39 @@ async function makeHashTableFromZipHeaders(fileProvider) {
   }
   return hashTable;
 }
+async function composeHashFile(zipCDIterator) {
+  const md5Hash = new import_crypto2.MD5Hash();
+  const textEncoder = new TextEncoder();
+  const hashArray = [];
+  for await (const cdHeader of zipCDIterator) {
+    const filename = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
+    const arrayBuffer = textEncoder.encode(filename).buffer;
+    const md5 = await md5Hash.hash(arrayBuffer, "hex");
+    hashArray.push(
+      (0, import_loader_utils6.concatenateArrayBuffers)(hexStringToBuffer(md5), bigintToBuffer(cdHeader.localHeaderOffset))
+    );
+  }
+  const bufferArray = hashArray.sort(compareHashes);
+  return (0, import_loader_utils6.concatenateArrayBuffersFromArray)(bufferArray);
+}
+function compareHashes(arrA, arrB) {
+  const a = new BigUint64Array(arrA);
+  const b = new BigUint64Array(arrB);
+  return Number(a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+}
+function hexStringToBuffer(str) {
+  var _a;
+  const byteArray = (_a = str.match(/../g)) == null ? void 0 : _a.map((h) => parseInt(h, 16));
+  return new Uint8Array(byteArray ?? new Array(16)).buffer;
+}
+function bigintToBuffer(n) {
+  return new BigUint64Array([n]).buffer;
+}
 
 // src/filesystems/zip-filesystem.ts
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
 var import_loader_utils7 = require("@loaders.gl/loader-utils");
+var import_loader_utils8 = require("@loaders.gl/loader-utils");
+var import_loader_utils9 = require("@loaders.gl/loader-utils");
 var import_compression = require("@loaders.gl/compression");
 var COMPRESSION_METHODS = {
   /** No compression */
@@ -789,12 +1275,12 @@ var ZipFileSystem = class {
     this.fileProvider = null;
     if (typeof file === "string") {
       this.fileName = file;
-      if (!import_loader_utils5.isBrowser) {
-        this.fileProvider = new import_loader_utils7.FileHandleFile(file);
+      if (!import_loader_utils7.isBrowser) {
+        this.fileProvider = new import_loader_utils9.FileHandleFile(file);
       } else {
         throw new Error("Cannot open file for random access in a WEB browser");
       }
-    } else if ((0, import_loader_utils6.isFileProvider)(file)) {
+    } else if ((0, import_loader_utils8.isFileProvider)(file)) {
       this.fileProvider = file;
     }
   }