@loaders.gl/zip 4.1.0-alpha.9 → 4.2.0-alpha.1

package/dist/dist.dev.js

@@ -6958,6 +6958,7 @@ var __exports__ = (() => {
     ZipWriter: () => ZipWriter,
     addOneFile: () => addOneFile,
     composeHashFile: () => composeHashFile,
+    createZip: () => createZip,
     generateCDHeader: () => generateCDHeader,
     generateLocalHeader: () => generateLocalHeader,
     localHeaderSignature: () => signature3,
@@ -6972,7 +6973,7 @@ var __exports__ = (() => {
 
   // src/zip-loader.ts
   var import_jszip = __toESM(require_jszip_min(), 1);
-  var VERSION = true ? "4.1.0-alpha.9" : "latest";
+  var VERSION = true ? "4.2.0-alpha.1" : "latest";
   var ZipLoader = {
     id: "zip",
     module: "zip",
@@ -7017,7 +7018,7 @@ var __exports__ = (() => {
 
   // src/zip-writer.ts
   var import_jszip2 = __toESM(require_jszip_min(), 1);
-  var VERSION2 = true ? "4.1.0-alpha.9" : "latest";
+  var VERSION2 = true ? "4.2.0-alpha.1" : "latest";
   var ZipWriter = {
     name: "Zip Archive",
     id: "zip",
@@ -7256,8 +7257,8 @@ var __exports__ = (() => {
       };
       this.tape = new tar_default(this.options.recordsPerBlock);
     }
-    addFile(filename, buffer) {
-      this.tape.append(filename, new Uint8Array(buffer));
+    addFile(filename2, buffer) {
+      this.tape.append(filename2, new Uint8Array(buffer));
       this.count++;
     }
     async build() {
@@ -7296,6 +7297,9 @@ var __exports__ = (() => {
     return true;
   }
   function concatenateArrayBuffers(...sources) {
+    return concatenateArrayBuffersFromArray(sources);
+  }
+  function concatenateArrayBuffersFromArray(sources) {
     const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
     const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
     const result = new Uint8Array(byteLength);
@@ -7316,6 +7320,22 @@ var __exports__ = (() => {
     return concatenateArrayBuffers(...arrayBuffers);
   }
 
+  // ../loader-utils/src/lib/path-utils/file-aliases.ts
+  var pathPrefix = "";
+  var fileAliases = {};
+  function resolvePath(filename2) {
+    for (const alias in fileAliases) {
+      if (filename2.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename2 = filename2.replace(alias, replacement);
+      }
+    }
+    if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) {
+      filename2 = `${pathPrefix}${filename2}`;
+    }
+    return filename2;
+  }
+
   // ../loader-utils/src/lib/node/buffer.browser.ts
   function toArrayBuffer(buffer) {
     return buffer;
@@ -7351,7 +7371,150 @@ var __exports__ = (() => {
 
   // ../loader-utils/src/lib/node/promisify.ts
   function promisify1(fn) {
-    return (args) => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+    return (args) => new Promise((resolve2, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
+  }
+
+  // ../loader-utils/src/lib/path-utils/path.ts
+  var path_exports = {};
+  __export(path_exports, {
+    dirname: () => dirname,
+    filename: () => filename,
+    join: () => join,
+    resolve: () => resolve
+  });
+
+  // ../loader-utils/src/lib/path-utils/get-cwd.ts
+  function getCWD() {
+    if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+      return process.cwd();
+    }
+    const pathname = window.location?.pathname;
+    return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
+  }
+
+  // ../loader-utils/src/lib/path-utils/path.ts
+  function filename(url) {
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
+    return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
+  }
+  function dirname(url) {
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
+    return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
+  }
+  function join(...parts) {
+    const separator = "/";
+    parts = parts.map((part, index) => {
+      if (index) {
+        part = part.replace(new RegExp(`^${separator}`), "");
+      }
+      if (index !== parts.length - 1) {
+        part = part.replace(new RegExp(`${separator}$`), "");
+      }
+      return part;
+    });
+    return parts.join(separator);
+  }
+  function resolve(...components) {
+    const paths = [];
+    for (let _i = 0; _i < components.length; _i++) {
+      paths[_i] = components[_i];
+    }
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      let path;
+      if (i >= 0) {
+        path = paths[i];
+      } else {
+        if (cwd === void 0) {
+          cwd = getCWD();
+        }
+        path = cwd;
+      }
+      if (path.length === 0) {
+        continue;
+      }
+      resolvedPath = `${path}/${resolvedPath}`;
+      resolvedAbsolute = path.charCodeAt(0) === SLASH;
+    }
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+      return `/${resolvedPath}`;
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    }
+    return ".";
+  }
+  var SLASH = 47;
+  var DOT = 46;
+  function normalizeStringPosix(path, allowAboveRoot) {
+    let res = "";
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    let isAboveRoot = false;
+    for (let i = 0; i <= path.length; ++i) {
+      if (i < path.length) {
+        code = path.charCodeAt(i);
+      } else if (code === SLASH) {
+        break;
+      } else {
+        code = SLASH;
+      }
+      if (code === SLASH) {
+        if (lastSlash === i - 1 || dots === 1) {
+        } else if (lastSlash !== i - 1 && dots === 2) {
+          if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+            if (res.length > 2) {
+              const start = res.length - 1;
+              let j = start;
+              for (; j >= 0; --j) {
+                if (res.charCodeAt(j) === SLASH) {
+                  break;
+                }
+              }
+              if (j !== start) {
+                res = j === -1 ? "" : res.slice(0, j);
+                lastSlash = i;
+                dots = 0;
+                isAboveRoot = false;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSlash = i;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            isAboveRoot = true;
+          }
+        } else {
+          const slice = path.slice(lastSlash + 1, i);
+          if (res.length > 0) {
+            res += `/${slice}`;
+          } else {
+            res = slice;
+          }
+          isAboveRoot = false;
+        }
+        lastSlash = i;
+        dots = 0;
+      } else if (code === DOT && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
+      }
+    }
+    return res;
   }
 
   // ../loader-utils/src/lib/files/node-file-facade.ts
@@ -7388,6 +7551,40 @@ var __exports__ = (() => {
     }
   };
 
+  // ../loader-utils/src/lib/filesystems/node-filesystem-facade.ts
+  var NOT_IMPLEMENTED2 = new Error("Not implemented");
+  var NodeFileSystemFacade = class {
+    constructor(options) {
+      if (globalThis.loaders?.NodeFileSystem) {
+        return new globalThis.loaders.NodeFileSystem(options);
+      }
+      if (isBrowser) {
+        throw new Error("Can't instantiate NodeFileSystem in browser.");
+      }
+      throw new Error("Can't instantiate NodeFileSystem. Make sure to import @loaders.gl/polyfills first.");
+    }
+    readable = true;
+    writable = true;
+    async openReadableFile(path, flags) {
+      throw NOT_IMPLEMENTED2;
+    }
+    async openWritableFile(path, flags, mode) {
+      throw NOT_IMPLEMENTED2;
+    }
+    async readdir(dirname2 = ".", options) {
+      throw NOT_IMPLEMENTED2;
+    }
+    async stat(path, options) {
+      throw NOT_IMPLEMENTED2;
+    }
+    async unlink(path) {
+      throw NOT_IMPLEMENTED2;
+    }
+    async fetch(path, options) {
+      throw NOT_IMPLEMENTED2;
+    }
+  };
+
   // ../loader-utils/src/lib/file-provider/file-provider.ts
   var isFileProvider = (fileProvider) => {
     return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
@@ -7492,10 +7689,10 @@ var __exports__ = (() => {
   }
   var NUMBER_SETTERS = {
     2: (header, offset, value) => {
-      header.setUint16(offset, Number(value), true);
+      header.setUint16(offset, Number(value > 65535 ? 65535 : value), true);
     },
     4: (header, offset, value) => {
-      header.setUint32(offset, Number(value), true);
+      header.setUint32(offset, Number(value > 4294967295 ? 4294967295 : value), true);
     },
     8: (header, offset, value) => {
       header.setBigUint64(offset, BigInt(value), true);
@@ -7526,11 +7723,13 @@ var __exports__ = (() => {
   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));
@@ -7559,7 +7758,7 @@ var __exports__ = (() => {
       }
     };
   };
-  async function updateEoCD(eocdBody, oldEoCDOffsets, newCDStartOffset, eocdStartOffset, newCDRecordsNumber) {
+  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) {
@@ -7582,6 +7781,120 @@ var __exports__ = (() => {
     }
     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 concatenateArrayBuffers(zip64Record, locator, header.buffer);
+  }
+  var EOCD_FIELDS = [{
+    offset: 0,
+    size: 4,
+    default: new DataView(eoCDSignature.buffer).getUint32(0, true)
+  }, {
+    offset: 4,
+    size: 2,
+    default: 0
+  }, {
+    offset: 6,
+    size: 2,
+    default: 0
+  }, {
+    offset: 8,
+    size: 2,
+    name: "recordsNumber"
+  }, {
+    offset: 10,
+    size: 2,
+    name: "recordsNumber"
+  }, {
+    offset: 12,
+    size: 4,
+    name: "cdSize"
+  }, {
+    offset: 16,
+    size: 4,
+    name: "cdOffset"
+  }, {
+    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 = [{
+    offset: 0,
+    size: 4,
+    default: new DataView(zip64EoCDLocatorSignature.buffer).getUint32(0, true)
+  }, {
+    offset: 4,
+    size: 4,
+    default: 0
+  }, {
+    offset: 8,
+    size: 8,
+    name: "eoCDStart"
+  }, {
+    offset: 16,
+    size: 4,
+    default: 1
+  }];
+  var ZIP64_EOCD_FIELDS = [{
+    offset: 0,
+    size: 4,
+    default: new DataView(zip64EoCDSignature.buffer).getUint32(0, true)
+  }, {
+    offset: 4,
+    size: 8,
+    default: 44
+  }, {
+    offset: 12,
+    size: 2,
+    default: 45
+  }, {
+    offset: 14,
+    size: 2,
+    default: 45
+  }, {
+    offset: 16,
+    size: 4,
+    default: 0
+  }, {
+    offset: 20,
+    size: 4,
+    default: 0
+  }, {
+    offset: 24,
+    size: 8,
+    name: "recordsNumber"
+  }, {
+    offset: 32,
+    size: 8,
+    name: "recordsNumber"
+  }, {
+    offset: 40,
+    size: 8,
+    name: "cdSize"
+  }, {
+    offset: 48,
+    size: 8,
+    name: "cdOffset"
+  }];
 
   // src/parse-zip/cd-file-header.ts
   var CD_COMPRESSED_SIZE_OFFSET = 20n;
@@ -8474,13 +8787,175 @@ var __exports__ = (() => {
       this.options = options;
     }
     async hash(input, encoding) {
-      const md5Promise = new Promise((resolve, reject) => md5WASM(input).then(resolve).catch(reject));
+      const md5Promise = new Promise((resolve2, reject) => md5WASM(input).then(resolve2).catch(reject));
       const hex = await md5Promise;
       return encodeHex(hex, encoding);
     }
   };
 
-  // src/parse-zip/zip-compozition.ts
+  // ../core/src/javascript-utils/is-type.ts
+  var isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
+  var isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
+
+  // ../core/src/lib/utils/mime-type-utils.ts
+  var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
+  var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
+  function parseMIMEType(mimeString) {
+    const matches2 = MIME_TYPE_PATTERN.exec(mimeString);
+    if (matches2) {
+      return matches2[1];
+    }
+    return mimeString;
+  }
+  function parseMIMETypeFromURL(url) {
+    const matches2 = DATA_URL_PATTERN.exec(url);
+    if (matches2) {
+      return matches2[1];
+    }
+    return "";
+  }
+
+  // ../core/src/lib/utils/url-utils.ts
+  var QUERY_STRING_PATTERN = /\?.*/;
+  function stripQueryString(url) {
+    return url.replace(QUERY_STRING_PATTERN, "");
+  }
+
+  // ../core/src/lib/utils/resource-utils.ts
+  function getResourceUrl(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      return response.url;
+    }
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.name || "";
+    }
+    if (typeof resource === "string") {
+      return resource;
+    }
+    return "";
+  }
+  function getResourceMIMEType(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      const contentTypeHeader = response.headers.get("content-type") || "";
+      const noQueryUrl = stripQueryString(response.url);
+      return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+    }
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.type || "";
+    }
+    if (typeof resource === "string") {
+      return parseMIMETypeFromURL(resource);
+    }
+    return "";
+  }
+  function getResourceContentLength(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      return response.headers["content-length"] || -1;
+    }
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.size;
+    }
+    if (typeof resource === "string") {
+      return resource.length;
+    }
+    if (resource instanceof ArrayBuffer) {
+      return resource.byteLength;
+    }
+    if (ArrayBuffer.isView(resource)) {
+      return resource.byteLength;
+    }
+    return -1;
+  }
+
+  // ../core/src/lib/utils/response-utils.ts
+  async function makeResponse(resource) {
+    if (isResponse(resource)) {
+      return resource;
+    }
+    const headers = {};
+    const contentLength = getResourceContentLength(resource);
+    if (contentLength >= 0) {
+      headers["content-length"] = String(contentLength);
+    }
+    const url = getResourceUrl(resource);
+    const type = getResourceMIMEType(resource);
+    if (type) {
+      headers["content-type"] = type;
+    }
+    const initialDataUrl = await getInitialDataUrl(resource);
+    if (initialDataUrl) {
+      headers["x-first-bytes"] = initialDataUrl;
+    }
+    if (typeof resource === "string") {
+      resource = new TextEncoder().encode(resource);
+    }
+    const response = new Response(resource, {
+      headers
+    });
+    Object.defineProperty(response, "url", {
+      value: url
+    });
+    return response;
+  }
+  async function getInitialDataUrl(resource) {
+    const INITIAL_DATA_LENGTH = 5;
+    if (typeof resource === "string") {
+      return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;
+    }
+    if (resource instanceof Blob) {
+      const blobSlice = resource.slice(0, 5);
+      return await new Promise((resolve2) => {
+        const reader = new FileReader();
+        reader.onload = (event) => resolve2(event?.target?.result);
+        reader.readAsDataURL(blobSlice);
+      });
+    }
+    if (resource instanceof ArrayBuffer) {
+      const slice = resource.slice(0, INITIAL_DATA_LENGTH);
+      const base64 = arrayBufferToBase64(slice);
+      return `data:base64,${base64}`;
+    }
+    return null;
+  }
+  function arrayBufferToBase64(buffer) {
+    let binary = "";
+    const bytes = new Uint8Array(buffer);
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+
+  // ../core/src/lib/fetch/fetch-file.ts
+  function isNodePath(url) {
+    return !isRequestURL(url) && !isDataURL(url);
+  }
+  function isRequestURL(url) {
+    return url.startsWith("http:") || url.startsWith("https:");
+  }
+  function isDataURL(url) {
+    return url.startsWith("data:");
+  }
+  async function fetchFile(urlOrData, fetchOptions) {
+    if (typeof urlOrData === "string") {
+      const url = resolvePath(urlOrData);
+      if (isNodePath(url)) {
+        if (globalThis.loaders?.fetchNode) {
+          return globalThis.loaders?.fetchNode(url, fetchOptions);
+        }
+      }
+      return await fetch(url, fetchOptions);
+    }
+    return await makeResponse(urlOrData);
+  }
+
+  // src/parse-zip/zip-composition.ts
   async function cutTheTailOff(provider) {
     const oldEoCDinfo = await parseEoCDRecord(provider);
     const oldCDStartOffset = oldEoCDinfo.cdStartOffset;
@@ -8516,7 +8991,72 @@ var __exports__ = (() => {
     const newCDStartOffset = provider.length;
     await provider.append(new Uint8Array(newCDBody));
     const eocdOffset = provider.length;
-    await provider.append(await updateEoCD(eocdBody, oldEoCDinfo.offsets, newCDStartOffset, eocdOffset, oldEoCDinfo.cdRecordsNumber + 1n));
+    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 NodeFileFacade(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);
+      await addFile(additionaldata, resFile, cdArray);
+    }
+    const cdOffset = (await resFile.stat()).bigsize;
+    const cd = 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?.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 fetchFile(path_exports.join(inputPath, filePath))).arrayBuffer();
+        yield {
+          path: filePath,
+          file
+        };
+      }
+    }
+    return iterable();
+  }
+  async function getAllFiles(basePath, subfolder = "", fsPassed) {
+    const fs = fsPassed ? fsPassed : new NodeFileSystemFacade({});
+    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 path_exports.join(...resPaths);
   }
 
   // src/hash-file-utility.ts
@@ -8535,21 +9075,32 @@ var __exports__ = (() => {
   }
   async function makeHashTableFromZipHeaders(fileProvider) {
     const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
+    return getHashTable(zipCDIterator);
+  }
+  async function getHashTable(zipCDIterator) {
     const md5Hash = new MD5Hash();
     const textEncoder = new TextEncoder();
     const hashTable = {};
     for await (const cdHeader of zipCDIterator) {
-      const filename = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
-      const arrayBuffer = textEncoder.encode(filename).buffer;
+      const filename2 = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
+      const arrayBuffer = textEncoder.encode(filename2).buffer;
       const md5 = await md5Hash.hash(arrayBuffer, "hex");
       hashTable[md5] = cdHeader.localHeaderOffset;
     }
     return hashTable;
   }
-  async function composeHashFile(fileProvider) {
-    const hashArray = await makeHashTableFromZipHeaders(fileProvider);
-    const bufferArray = Object.entries(hashArray).map(([key, value]) => concatenateArrayBuffers(hexStringToBuffer(key), bigintToBuffer(value))).sort(compareHashes);
-    return concatenateArrayBuffers(...bufferArray);
+  async function composeHashFile(zipCDIterator) {
+    const md5Hash = new MD5Hash();
+    const textEncoder = new TextEncoder();
+    const hashArray = [];
+    for await (const cdHeader of zipCDIterator) {
+      const filename2 = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
+      const arrayBuffer = textEncoder.encode(filename2).buffer;
+      const md5 = await md5Hash.hash(arrayBuffer, "hex");
+      hashArray.push(concatenateArrayBuffers(hexStringToBuffer(md5), bigintToBuffer(cdHeader.localHeaderOffset)));
+    }
+    const bufferArray = hashArray.sort(compareHashes);
+    return concatenateArrayBuffersFromArray(bufferArray);
   }
   function compareHashes(arrA, arrB) {
     const a = new BigUint64Array(arrA);
@@ -8752,18 +9303,18 @@ var __exports__ = (() => {
       }
       return fileNames;
     }
-    async stat(filename) {
-      const cdFileHeader = await this.getCDFileHeader(filename);
+    async stat(filename2) {
+      const cdFileHeader = await this.getCDFileHeader(filename2);
       return {
         ...cdFileHeader,
         size: Number(cdFileHeader.uncompressedSize)
       };
     }
-    async fetch(filename) {
+    async fetch(filename2) {
       if (!this.fileProvider) {
         throw new Error("No data detected in the zip archive");
       }
-      const cdFileHeader = await this.getCDFileHeader(filename);
+      const cdFileHeader = await this.getCDFileHeader(filename2);
       const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, this.fileProvider);
       if (!localFileHeader) {
         throw new Error("Local file header has not been found in the zip archive`");
@@ -8776,18 +9327,18 @@ var __exports__ = (() => {
       const uncompressedFile = await compressionHandler(compressedFile);
       const response = new Response(uncompressedFile);
       Object.defineProperty(response, "url", {
-        value: `${this.fileName || ""}/${filename}`
+        value: `${this.fileName || ""}/${filename2}`
       });
       return response;
     }
-    async getCDFileHeader(filename) {
+    async getCDFileHeader(filename2) {
       if (!this.fileProvider) {
         throw new Error("No data detected in the zip archive");
       }
       const zipCDIterator = makeZipCDHeaderIterator(this.fileProvider);
       let result = null;
       for await (const cdHeader of zipCDIterator) {
-        if (cdHeader.fileName === filename) {
+        if (cdHeader.fileName === filename2) {
           result = cdHeader;
           break;
         }