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

package/dist/dist.dev.js

@@ -6956,7 +6956,11 @@ var __exports__ = (() => {
     ZipFileSystem: () => ZipFileSystem,
     ZipLoader: () => ZipLoader,
     ZipWriter: () => ZipWriter,
+    addOneFile: () => addOneFile,
+    composeHashFile: () => composeHashFile,
+    createZip: () => createZip,
     generateCDHeader: () => generateCDHeader,
+    generateLocalHeader: () => generateLocalHeader,
     localHeaderSignature: () => signature3,
     makeHashTableFromZipHeaders: () => makeHashTableFromZipHeaders,
     makeZipCDHeaderIterator: () => makeZipCDHeaderIterator,
@@ -6969,7 +6973,7 @@ var __exports__ = (() => {
 
   // src/zip-loader.ts
   var import_jszip = __toESM(require_jszip_min(), 1);
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION = true ? "4.1.0-alpha.11" : "latest";
   var ZipLoader = {
     id: "zip",
     module: "zip",
@@ -7014,11 +7018,22 @@ var __exports__ = (() => {
 
   // src/zip-writer.ts
   var import_jszip2 = __toESM(require_jszip_min(), 1);
+  var VERSION2 = true ? "4.1.0-alpha.11" : "latest";
   var ZipWriter = {
     name: "Zip Archive",
+    id: "zip",
+    module: "zip",
+    version: VERSION2,
     extensions: ["zip"],
     category: "archive",
     mimeTypes: ["application/zip"],
+    options: {
+      zip: {
+        onUpdate: () => {
+        }
+      },
+      jszip: {}
+    },
     encode: encodeZipAsync
   };
   async function encodeZipAsync(fileMap, options = {}) {
@@ -7027,18 +7042,21 @@ var __exports__ = (() => {
       const subFileData = fileMap[subFileName];
       jsZip.file(subFileName, subFileData, options?.jszip || {});
     }
+    const zipOptions = {
+      ...ZipWriter.options.zip,
+      ...options?.zip
+    };
     const jszipOptions = {
-      ...options?.jszip,
-      type: "arraybuffer"
+      ...ZipWriter.options?.jszip,
+      ...options.jszip
     };
-    const {
-      onUpdate = () => {
-      }
-    } = options;
     try {
-      return await jsZip.generateAsync(jszipOptions, onUpdate);
+      return await jsZip.generateAsync({
+        ...jszipOptions,
+        type: "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;
     }
   }
@@ -7239,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() {
@@ -7279,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);
@@ -7299,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;
@@ -7334,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
@@ -7361,10 +7541,50 @@ var __exports__ = (() => {
     async stat() {
       throw NOT_IMPLEMENTED;
     }
+    async truncate(length) {
+      throw NOT_IMPLEMENTED;
+    }
+    async append(data) {
+      throw NOT_IMPLEMENTED;
+    }
     async close() {
     }
   };
 
+  // ../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;
@@ -7372,9 +7592,14 @@ var __exports__ = (() => {
 
   // ../loader-utils/src/lib/file-provider/file-handle-file.ts
   var FileHandleFile = class {
-    constructor(path) {
-      this.file = new NodeFileFacade(path, "r");
-      this.size = this.file.bigsize;
+    constructor(path, append = false) {
+      this.file = new NodeFileFacade(path, append ? "a+" : "r");
+    }
+    async truncate(length) {
+      await this.file.truncate(length);
+    }
+    async append(buffer) {
+      await this.file.append(buffer);
     }
     async destroy() {
       await this.file.close();
@@ -7420,7 +7645,7 @@ var __exports__ = (() => {
       return await this.file.read(startOffset, length);
     }
     get length() {
-      return this.size;
+      return this.file.bigsize;
     }
   };
 
@@ -7441,39 +7666,6 @@ var __exports__ = (() => {
     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 (!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 (!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 signature = new Uint8Array([1, 0]);
   function createZip64Info(options) {
@@ -7492,12 +7684,15 @@ var __exports__ = (() => {
     }
     return 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);
@@ -7520,6 +7715,187 @@ var __exports__ = (() => {
     name: "offset"
   }];
 
+  // 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 (compareArrayBuffers(magicBytes, zip64EoCDLocatorSignature)) {
+      zip64EoCDOffset = await file.getBigUint64(zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET);
+      const endOfCDMagicBytes = await file.slice(zip64EoCDOffset, zip64EoCDOffset + 4n);
+      if (!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 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;
   var CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
@@ -7627,7 +8003,7 @@ var __exports__ = (() => {
     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;
@@ -7637,9 +8013,9 @@ var __exports__ = (() => {
       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](header, field.offset, optionsToUse[field.name ?? ""] ?? field.default ?? 0);
+      setFieldToNumber(header, field.size, field.offset, optionsToUse[field.name ?? ""] ?? field.default ?? 0);
     }
     const encodedName = new TextEncoder().encode(optionsToUse.fileName);
     const resHeader = concatenateArrayBuffers(header.buffer, encodedName, zip64header);
@@ -7758,6 +8134,76 @@ var __exports__ = (() => {
       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 = concatenateArrayBuffers(header.buffer, encodedName, zip64header);
+    return resHeader;
+  }
+  var ZIP_HEADER_FIELDS2 = [{
+    offset: 0,
+    size: 4,
+    default: new DataView(signature3.buffer).getUint32(0, true)
+  }, {
+    offset: 4,
+    size: 2,
+    default: 45
+  }, {
+    offset: 6,
+    size: 2,
+    default: 0
+  }, {
+    offset: 8,
+    size: 2,
+    default: 0
+  }, {
+    offset: 10,
+    size: 2,
+    default: 0
+  }, {
+    offset: 12,
+    size: 2,
+    default: 0
+  }, {
+    offset: 14,
+    size: 4,
+    name: "crc32"
+  }, {
+    offset: 18,
+    size: 4,
+    name: "length"
+  }, {
+    offset: 22,
+    size: 4,
+    name: "length"
+  }, {
+    offset: 26,
+    size: 2,
+    name: "fnlength"
+  }, {
+    offset: 28,
+    size: 2,
+    default: 0,
+    name: "extraLength"
+  }];
 
   // ../crypto/src/lib/hash.ts
   var Hash = class {
@@ -7784,6 +8230,29 @@ var __exports__ = (() => {
     }
   };
 
+  // ../crypto/src/lib/algorithms/crc32.ts
+  var CRC32 = class {
+    constructor() {
+      this.crc = ~0;
+    }
+    update(arrayBuffer) {
+      const CRC32_TABLE = getCRC32Table();
+      const byteArray = new Uint8Array(arrayBuffer);
+      for (let i = 0; i < byteArray.byteLength; i++) {
+        this.crc = this.crc >>> 8 ^ CRC32_TABLE[(this.crc ^ byteArray[i]) & 255];
+      }
+      return this;
+    }
+    finalize() {
+      this.crc = (this.crc ^ -1) >>> 0;
+      return this.crc;
+    }
+  };
+  var CRC32TAB = Uint32Array.of(0, 1996959894, 3993919788, 2567524794, 124634137, 1886057615, 3915621685, 2657392035, 249268274, 2044508324, 3772115230, 2547177864, 162941995, 2125561021, 3887607047, 2428444049, 498536548, 1789927666, 4089016648, 2227061214, 450548861, 1843258603, 4107580753, 2211677639, 325883990, 1684777152, 4251122042, 2321926636, 335633487, 1661365465, 4195302755, 2366115317, 997073096, 1281953886, 3579855332, 2724688242, 1006888145, 1258607687, 3524101629, 2768942443, 901097722, 1119000684, 3686517206, 2898065728, 853044451, 1172266101, 3705015759, 2882616665, 651767980, 1373503546, 3369554304, 3218104598, 565507253, 1454621731, 3485111705, 3099436303, 671266974, 1594198024, 3322730930, 2970347812, 795835527, 1483230225, 3244367275, 3060149565, 1994146192, 31158534, 2563907772, 4023717930, 1907459465, 112637215, 2680153253, 3904427059, 2013776290, 251722036, 2517215374, 3775830040, 2137656763, 141376813, 2439277719, 3865271297, 1802195444, 476864866, 2238001368, 4066508878, 1812370925, 453092731, 2181625025, 4111451223, 1706088902, 314042704, 2344532202, 4240017532, 1658658271, 366619977, 2362670323, 4224994405, 1303535960, 984961486, 2747007092, 3569037538, 1256170817, 1037604311, 2765210733, 3554079995, 1131014506, 879679996, 2909243462, 3663771856, 1141124467, 855842277, 2852801631, 3708648649, 1342533948, 654459306, 3188396048, 3373015174, 1466479909, 544179635, 3110523913, 3462522015, 1591671054, 702138776, 2966460450, 3352799412, 1504918807, 783551873, 3082640443, 3233442989, 3988292384, 2596254646, 62317068, 1957810842, 3939845945, 2647816111, 81470997, 1943803523, 3814918930, 2489596804, 225274430, 2053790376, 3826175755, 2466906013, 167816743, 2097651377, 4027552580, 2265490386, 503444072, 1762050814, 4150417245, 2154129355, 426522225, 1852507879, 4275313526, 2312317920, 282753626, 1742555852, 4189708143, 2394877945, 397917763, 1622183637, 3604390888, 2714866558, 953729732, 1340076626, 3518719985, 2797360999, 1068828381, 1219638859, 3624741850, 2936675148, 906185462, 1090812512, 3747672003, 2825379669, 829329135, 1181335161, 3412177804, 3160834842, 628085408, 1382605366, 3423369109, 3138078467, 570562233, 1426400815, 3317316542, 2998733608, 733239954, 1555261956, 3268935591, 3050360625, 752459403, 1541320221, 2607071920, 3965973030, 1969922972, 40735498, 2617837225, 3943577151, 1913087877, 83908371, 2512341634, 3803740692, 2075208622, 213261112, 2463272603, 3855990285, 2094854071, 198958881, 2262029012, 4057260610, 1759359992, 534414190, 2176718541, 4139329115, 1873836001, 414664567, 2282248934, 4279200368, 1711684554, 285281116, 2405801727, 4167216745, 1634467795, 376229701, 2685067896, 3608007406, 1308918612, 956543938, 2808555105, 3495958263, 1231636301, 1047427035, 2932959818, 3654703836, 1088359270, 936918e3, 2847714899, 3736837829, 1202900863, 817233897, 3183342108, 3401237130, 1404277552, 615818150, 3134207493, 3453421203, 1423857449, 601450431, 3009837614, 3294710456, 1567103746, 711928724, 3020668471, 3272380065, 1510334235, 755167117);
+  function getCRC32Table() {
+    return CRC32TAB;
+  }
+
   // ../crypto/src/lib/utils/base64-utils.ts
   function asciiToBase64(string) {
     string = `${string}`;
@@ -7835,6 +8304,16 @@ var __exports__ = (() => {
   }
 
   // ../crypto/src/lib/utils/digest-utils.ts
+  function encodeNumber(number, encoding) {
+    switch (encoding) {
+      case "hex":
+        return convertNumberToHex(number);
+      case "base64":
+        return convertHexToBase64(convertNumberToHex(number));
+      default:
+        throw new Error(encoding);
+    }
+  }
   function encodeHex(hex, encoding) {
     switch (encoding) {
       case "hex":
@@ -7853,6 +8332,43 @@ var __exports__ = (() => {
     const string = matches2.map((a) => String.fromCharCode(parseInt(a, 16))).join("");
     return asciiToBase64(string) || "";
   }
+  function convertNumberToHex(cipher) {
+    const hexString = cipher.toString(16);
+    return hexString === "0" ? `0${hexString}` : hexString;
+  }
+
+  // ../crypto/src/lib/crc32-hash.ts
+  var CRC32Hash = class extends Hash {
+    name = "crc32";
+    constructor(options = {}) {
+      super();
+      this.options = {
+        crypto: {},
+        ...options
+      };
+      this.hashBatches = this.hashBatches.bind(this);
+    }
+    async hash(input, encoding) {
+      return this.hashSync(input, encoding);
+    }
+    hashSync(input, encoding) {
+      const hash = new CRC32();
+      hash.update(input);
+      const digest = hash.finalize();
+      return encodeNumber(digest, encoding);
+    }
+    async *hashBatches(asyncIterator, encoding = "base64") {
+      const hash = new CRC32();
+      for await (const chunk of asyncIterator) {
+        hash.update(chunk);
+        yield chunk;
+      }
+      const digest = hash.finalize();
+      this.options.crypto?.onEnd?.({
+        hash: encodeNumber(digest, encoding)
+      });
+    }
+  };
 
   // ../crypto/src/lib/algorithms/md5-wasm.ts
   var atb = typeof atob === "function" ? atob : typeof Buffer === "function" ? nodeATOB : identity;
@@ -8271,12 +8787,279 @@ 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);
     }
   };
 
+  // ../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;
+    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 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(concatenateArrayBuffers(newFileLocalHeader, fileToAdd)), new Uint8Array(newFileCDHeader)];
+  }
+  async function addOneFile(zipUrl, fileToAdd, fileName) {
+    const provider = new 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 = 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 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);
+      console.log(additionaldata);
+      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
   function parseHashTable(arrayBuffer) {
     const dataView = new DataView(arrayBuffer);
@@ -8293,17 +9076,45 @@ 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(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);
+    const b = new BigUint64Array(arrB);
+    return Number(a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+  }
+  function hexStringToBuffer(str) {
+    const byteArray = str.match(/../g)?.map((h) => parseInt(h, 16));
+    return new Uint8Array(byteArray ?? new Array(16)).buffer;
+  }
+  function bigintToBuffer(n) {
+    return new BigUint64Array([n]).buffer;
+  }
 
   // ../compression/src/lib/compression.ts
   var Compression = class {
@@ -8493,18 +9304,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`");
@@ -8517,18 +9328,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;
         }