@loaders.gl/zip 4.4.0-alpha.1 → 4.4.0-alpha.9

package/dist/dist.dev.js

@@ -6960,6 +6960,7 @@ var __exports__ = (() => {
   var bundle_exports = {};
   __export(bundle_exports, {
     CD_HEADER_SIGNATURE: () => signature2,
+    DataViewReadableFile: () => DataViewReadableFile,
     IndexedArchive: () => IndexedArchive,
     TarBuilder: () => TarBuilder,
     ZIP_COMPRESSION_HANDLERS: () => ZIP_COMPRESSION_HANDLERS,
@@ -6971,6 +6972,7 @@ var __exports__ = (() => {
     createZip: () => createZip,
     generateCDHeader: () => generateCDHeader,
     generateLocalHeader: () => generateLocalHeader,
+    getReadableFileSize: () => getReadableFileSize,
     localHeaderSignature: () => signature3,
     makeHashTableFromZipHeaders: () => makeHashTableFromZipHeaders,
     makeZipCDHeaderIterator: () => makeZipCDHeaderIterator,
@@ -6978,6 +6980,7 @@ var __exports__ = (() => {
     parseHashTable: () => parseHashTable,
     parseZipCDFileHeader: () => parseZipCDFileHeader,
     parseZipLocalFileHeader: () => parseZipLocalFileHeader,
+    readRange: () => readRange,
     searchFromTheEnd: () => searchFromTheEnd
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
@@ -7064,7 +7067,7 @@ var __exports__ = (() => {
         zipOptions.onUpdate
       );
     } catch (error) {
-      options.log.error(`Unable to encode zip archive: ${error}`);
+      options.core?.log?.error(`Unable to encode zip archive: ${error}`);
       throw error;
     }
   }
@@ -7307,6 +7310,9 @@ var __exports__ = (() => {
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
+  // ../loader-utils/src/lib/javascript-utils/is-type.ts
+  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+
   // ../loader-utils/src/lib/module-utils/js-module-utils.ts
   function registerJSModules(modules) {
     globalThis.loaders ||= {};
@@ -7350,10 +7356,26 @@ var __exports__ = (() => {
   async function concatenateArrayBuffersAsync(asyncIterator) {
     const arrayBuffers = [];
     for await (const chunk of asyncIterator) {
-      arrayBuffers.push(chunk);
+      arrayBuffers.push(copyToArrayBuffer(chunk));
     }
     return concatenateArrayBuffers(...arrayBuffers);
   }
+  function copyToArrayBuffer(chunk) {
+    if (chunk instanceof ArrayBuffer) {
+      return chunk;
+    }
+    if (ArrayBuffer.isView(chunk)) {
+      const { buffer, byteOffset, byteLength } = chunk;
+      return copyFromBuffer(buffer, byteOffset, byteLength);
+    }
+    return copyFromBuffer(chunk);
+  }
+  function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
+  }
 
   // ../loader-utils/src/lib/node/buffer.browser.ts
   function toArrayBuffer(buffer) {
@@ -7371,11 +7393,15 @@ var __exports__ = (() => {
     if (data instanceof ArrayBuffer) {
       return data;
     }
+    if (isSharedArrayBuffer(data)) {
+      return copyToArrayBuffer2(data);
+    }
     if (ArrayBuffer.isView(data)) {
+      const buffer = data.buffer;
       if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return data.buffer;
+        return buffer;
       }
-      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
     }
     if (typeof data === "string") {
       const text = data;
@@ -7387,6 +7413,12 @@ var __exports__ = (() => {
     }
     throw new Error("toArrayBuffer");
   }
+  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
+  }
 
   // ../loader-utils/src/lib/node/promisify.ts
   function promisify1(fn) {
@@ -7416,7 +7448,7 @@ var __exports__ = (() => {
   // ../loader-utils/src/lib/path-utils/path.ts
   function filename(url) {
     const slashIndex = url ? url.lastIndexOf("/") : -1;
-    return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
+    return slashIndex >= 0 ? url.substr(slashIndex + 1) : url;
   }
   function dirname(url) {
     const slashIndex = url ? url.lastIndexOf("/") : -1;
@@ -7538,6 +7570,33 @@ var __exports__ = (() => {
     return res;
   }
 
+  // ../loader-utils/src/lib/files/blob-file.ts
+  var BlobFile = class {
+    handle;
+    size;
+    bigsize;
+    url;
+    constructor(blob) {
+      this.handle = blob instanceof ArrayBuffer ? new Blob([blob]) : blob;
+      this.size = blob instanceof ArrayBuffer ? blob.byteLength : blob.size;
+      this.bigsize = BigInt(this.size);
+      this.url = blob instanceof File ? blob.name : "";
+    }
+    async close() {
+    }
+    async stat() {
+      return {
+        size: this.handle.size,
+        bigsize: BigInt(this.handle.size),
+        isDirectory: false
+      };
+    }
+    async read(start, length) {
+      const arrayBuffer = await this.handle.slice(Number(start), Number(start) + Number(length)).arrayBuffer();
+      return arrayBuffer;
+    }
+  };
+
   // ../loader-utils/src/lib/files/node-file-facade.ts
   var NOT_IMPLEMENTED = new Error("Not implemented");
   var NodeFileFacade = class {
@@ -7620,179 +7679,109 @@ var __exports__ = (() => {
     }
   };
 
-  // ../loader-utils/src/lib/file-provider/file-provider-interface.ts
-  var isFileProvider = (fileProvider) => {
-    return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
-  };
-
-  // ../loader-utils/src/lib/file-provider/file-handle-file.ts
-  var FileHandleFile = class {
-    /** The FileHandle from which data is provided */
-    file;
-    /** Create a new FileHandleFile */
-    constructor(path, append = false) {
-      this.file = new NodeFileFacade(path, append ? "a+" : "r");
-    }
-    /**
-     * Truncates the file descriptor.
-     * @param length desired file lenght
-     */
-    async truncate(length) {
-      await this.file.truncate(length);
-    }
-    /**
-     * Append data to a file.
-     * @param buffer data to append
-     */
-    async append(buffer) {
-      await this.file.append(buffer);
-    }
-    /** Close file */
-    async destroy() {
-      await this.file.close();
+  // src/parse-zip/readable-file-utils.ts
+  function toBigInt(value) {
+    return typeof value === "bigint" ? value : BigInt(value);
+  }
+  function toNumber(value) {
+    const numberValue = Number(value);
+    if (!Number.isFinite(numberValue)) {
+      throw new Error("Offset is out of bounds");
     }
-    /**
-     * Gets an unsigned 8-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint8(offset) {
-      const arrayBuffer = await this.file.read(offset, 1);
-      const val = new Uint8Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
-      }
-      return val;
+    return numberValue;
+  }
+  function normalizeOffset(offset, size) {
+    if (offset < 0) {
+      return Math.max(size + offset, 0);
     }
-    /**
-     * Gets an unsigned 16-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint16(offset) {
-      const arrayBuffer = await this.file.read(offset, 2);
-      const val = new Uint16Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
-      }
-      return val;
+    return Math.min(offset, size);
+  }
+  async function readRange(file, start, end) {
+    const startOffset = toBigInt(start);
+    const endOffset = toBigInt(end);
+    const length = endOffset - startOffset;
+    if (length < 0) {
+      throw new Error("Invalid range requested");
+    }
+    return await file.read(startOffset, toNumber(length));
+  }
+  async function readDataView(file, start, end) {
+    const arrayBuffer = await readRange(file, start, end);
+    return new DataView(arrayBuffer);
+  }
+  async function readUint16(file, offset) {
+    const dataView = await readDataView(file, offset, toBigInt(offset) + 2n);
+    return dataView.getUint16(0, true);
+  }
+  async function readUint32(file, offset) {
+    const dataView = await readDataView(file, offset, toBigInt(offset) + 4n);
+    return dataView.getUint32(0, true);
+  }
+  async function readBigUint64(file, offset) {
+    const dataView = await readDataView(file, offset, toBigInt(offset) + 8n);
+    return dataView.getBigUint64(0, true);
+  }
+  async function getReadableFileSize(file) {
+    if (file.bigsize > 0n) {
+      return file.bigsize;
     }
-    /**
-     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint32(offset) {
-      const arrayBuffer = await this.file.read(offset, 4);
-      const val = new Uint32Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
-      }
-      return val;
+    if (file.size > 0) {
+      return BigInt(file.size);
     }
-    /**
-     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getBigUint64(offset) {
-      const arrayBuffer = await this.file.read(offset, 8);
-      const val = new BigInt64Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
+    if (file.stat) {
+      const stats = await file.stat();
+      if (stats?.bigsize !== void 0) {
+        return stats.bigsize;
       }
-      return val;
-    }
-    /**
-     * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
-     * @param startOffset The offset, in byte, from the start of the file where to start reading the data.
-     * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
-     */
-    async slice(startOffset, endOffset) {
-      const bigLength = endOffset - startOffset;
-      if (bigLength > Number.MAX_SAFE_INTEGER) {
-        throw new Error("too big slice");
+      if (stats?.size !== void 0) {
+        return BigInt(stats.size);
       }
-      const length = Number(bigLength);
-      return await this.file.read(startOffset, length);
     }
-    /**
-     * the length (in bytes) of the data.
-     */
-    get length() {
-      return this.file.bigsize;
-    }
-  };
-
-  // ../loader-utils/src/lib/file-provider/data-view-file.ts
-  var toNumber = (bigint) => {
-    if (bigint > Number.MAX_SAFE_INTEGER) {
-      throw new Error("Offset is out of bounds");
-    }
-    return Number(bigint);
-  };
-  var DataViewFile = class {
-    /** The DataView from which data is provided */
-    file;
-    constructor(file) {
-      this.file = file;
-    }
-    async destroy() {
-    }
-    /**
-     * Gets an unsigned 8-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint8(offset) {
-      return this.file.getUint8(toNumber(offset));
-    }
-    /**
-     * Gets an unsigned 16-bit intege at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint16(offset) {
-      return this.file.getUint16(toNumber(offset), true);
-    }
-    /**
-     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint32(offset) {
-      return this.file.getUint32(toNumber(offset), true);
+    return 0n;
+  }
+  var DataViewReadableFile = class {
+    handle;
+    size;
+    bigsize;
+    url;
+    constructor(dataView, url = "") {
+      this.handle = dataView;
+      this.size = dataView.byteLength;
+      this.bigsize = BigInt(dataView.byteLength);
+      this.url = url;
     }
-    /**
-     * Gets an unsigned 64-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getBigUint64(offset) {
-      return this.file.getBigUint64(toNumber(offset), true);
+    async close() {
     }
-    /**
-     * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
-     * @param startOffset The offset, in bytes, from the start of the file where to start reading the data.
-     * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
-     */
-    async slice(startOffset, endOffset) {
-      return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+    async stat() {
+      return { size: this.size, bigsize: this.bigsize, isDirectory: false };
     }
-    /** the length (in bytes) of the data. */
-    get length() {
-      return BigInt(this.file.byteLength);
+    async read(start = 0, length) {
+      const offset = toNumber(start);
+      const end = length ? offset + length : this.size;
+      const normalizedStart = normalizeOffset(offset, this.size);
+      const normalizedEnd = normalizeOffset(end, this.size);
+      const clampedEnd = Math.max(normalizedEnd, normalizedStart);
+      const lengthToRead = clampedEnd - normalizedStart;
+      if (lengthToRead <= 0) {
+        return new ArrayBuffer(0);
+      }
+      return copyToArrayBuffer2(this.handle.buffer, normalizedStart, lengthToRead);
     }
   };
 
   // src/parse-zip/search-from-the-end.ts
   var buffLength = 1024;
   var searchFromTheEnd = async (file, target) => {
-    const searchWindow = [
-      await file.getUint8(file.length - 1n),
-      await file.getUint8(file.length - 2n),
-      await file.getUint8(file.length - 3n),
-      void 0
-    ];
+    const fileLength = await getReadableFileSize(file);
+    const lastBytes = new Uint8Array(await readRange(file, fileLength - 3n, fileLength + 1n));
+    const searchWindow = [lastBytes[3], lastBytes[2], lastBytes[1], void 0];
     let targetOffset = -1;
-    let point = file.length - 4n;
+    let point = fileLength - 4n;
     do {
       const prevPoint = point;
       point -= BigInt(buffLength);
       point = point >= 0n ? point : 0n;
-      const buff = new Uint8Array(await file.slice(point, prevPoint));
+      const buff = new Uint8Array(await readRange(file, point, prevPoint));
       for (let i = buff.length - 1; i > -1; i--) {
         searchWindow[3] = searchWindow[2];
         searchWindow[2] = searchWindow[1];
@@ -7884,23 +7873,24 @@ var __exports__ = (() => {
   var ZIP64_COMMENT_OFFSET = 56n;
   var parseEoCDRecord = async (file) => {
     const zipEoCDOffset = await searchFromTheEnd(file, eoCDSignature);
-    let cdRecordsNumber = BigInt(await file.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
-    let cdByteSize = BigInt(await file.getUint32(zipEoCDOffset + CD_CD_BYTE_SIZE_OFFSET));
-    let cdStartOffset = BigInt(await file.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
+    let cdRecordsNumber = BigInt(await readUint16(file, zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
+    let cdByteSize = BigInt(await readUint32(file, zipEoCDOffset + CD_CD_BYTE_SIZE_OFFSET));
+    let cdStartOffset = BigInt(await readUint32(file, 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(
+    const magicBytes = await readRange(file, zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
+    if (compareArrayBuffers(magicBytes, zip64EoCDLocatorSignature.buffer)) {
+      zip64EoCDOffset = await readBigUint64(
+        file,
         zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
       );
-      const endOfCDMagicBytes = await file.slice(zip64EoCDOffset, zip64EoCDOffset + 4n);
+      const endOfCDMagicBytes = await readRange(file, 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);
-      cdByteSize = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_CD_BYTE_SIZE_OFFSET);
-      cdStartOffset = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+      cdRecordsNumber = await readBigUint64(file, zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+      cdByteSize = await readBigUint64(file, zip64EoCDOffset + ZIP64_CD_CD_BYTE_SIZE_OFFSET);
+      cdStartOffset = await readBigUint64(file, zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
     } else {
       zip64EoCDLocatorOffset = 0n;
     }
@@ -8135,12 +8125,11 @@ var __exports__ = (() => {
   var CD_FILE_NAME_OFFSET = 46n;
   var signature2 = new Uint8Array([80, 75, 1, 2]);
   var parseZipCDFileHeader = async (headerOffset, file) => {
-    if (headerOffset >= file.length) {
+    const fileLength = await getReadableFileSize(file);
+    if (headerOffset >= fileLength) {
       return null;
     }
-    const mainHeader = new DataView(
-      await file.slice(headerOffset, headerOffset + CD_FILE_NAME_OFFSET)
-    );
+    const mainHeader = await readDataView(file, headerOffset, headerOffset + CD_FILE_NAME_OFFSET);
     const magicBytes = mainHeader.buffer.slice(0, 4);
     if (!compareArrayBuffers(magicBytes, signature2.buffer)) {
       return null;
@@ -8150,7 +8139,8 @@ var __exports__ = (() => {
     const extraFieldLength = mainHeader.getUint16(CD_EXTRA_FIELD_LENGTH_OFFSET, true);
     const startDisk = BigInt(mainHeader.getUint16(CD_START_DISK_OFFSET, true));
     const fileNameLength = mainHeader.getUint16(CD_FILE_NAME_LENGTH_OFFSET, true);
-    const additionalHeader = await file.slice(
+    const additionalHeader = await readRange(
+      file,
       headerOffset + CD_FILE_NAME_OFFSET,
       headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
     );
@@ -8180,8 +8170,8 @@ var __exports__ = (() => {
   };
   async function* makeZipCDHeaderIterator(fileProvider) {
     const { cdStartOffset, cdByteSize } = await parseEoCDRecord(fileProvider);
-    const centralDirectory = new DataViewFile(
-      new DataView(await fileProvider.slice(cdStartOffset, cdStartOffset + cdByteSize))
+    const centralDirectory = new DataViewReadableFile(
+      new DataView(await readRange(fileProvider, cdStartOffset, cdStartOffset + cdByteSize))
     );
     let cdHeader = await parseZipCDFileHeader(0n, centralDirectory);
     while (cdHeader) {
@@ -8376,14 +8366,15 @@ var __exports__ = (() => {
   var FILE_NAME_OFFSET = 30n;
   var signature3 = new Uint8Array([80, 75, 3, 4]);
   var parseZipLocalFileHeader = async (headerOffset, file) => {
-    const mainHeader = new DataView(await file.slice(headerOffset, headerOffset + FILE_NAME_OFFSET));
+    const mainHeader = await readDataView(file, headerOffset, headerOffset + FILE_NAME_OFFSET);
     const magicBytes = mainHeader.buffer.slice(0, 4);
-    if (!compareArrayBuffers(magicBytes, signature3)) {
+    if (!compareArrayBuffers(magicBytes, signature3.buffer)) {
       return null;
     }
     const fileNameLength = mainHeader.getUint16(FILE_NAME_LENGTH_OFFSET, true);
     const extraFieldLength = mainHeader.getUint16(EXTRA_FIELD_LENGTH_OFFSET, true);
-    const additionalHeader = await file.slice(
+    const additionalHeader = await readRange(
+      file,
       headerOffset + FILE_NAME_OFFSET,
       headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
     );
@@ -8939,16 +8930,16 @@ var __exports__ = (() => {
   };
 
   // ../crypto/src/lib/algorithms/md5-wasm.ts
-  var atb = typeof atob === "function" ? atob : typeof Buffer === "function" ? nodeATOB : identity;
-  var wasmB64 = atb(
+  var BASE64_LOOKUP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  var wasmB64Bytes = decodeBase64Safely(
     "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"
   );
-  var wasm = WebAssembly && atb !== identity ? str2AB(wasmB64).buffer : false;
+  var wasm = typeof WebAssembly !== "undefined" && wasmB64Bytes ? wasmB64Bytes.buffer : false;
   var crypt = makeCrypt();
   var biteSize = 240 * 16 * 16;
   var bounder = Math.floor(biteSize * 16 * 1.066666667);
   var upperLimit = 268435456 - 65536;
-  var parmTypeErrStr = "Parameter must be Buffer, ArrayBuffer or Uint8Array";
+  var parmTypeErrStr = "Parameter must be ArrayBuffer, ArrayBufferView or string";
   var tooBigErrStr = "Parameter exceeds max size of 255.9 Mbytes";
   if (!wasm) {
     console.log(
@@ -8967,20 +8958,9 @@ var __exports__ = (() => {
       catchFun = fun;
       return returnObj;
     };
-    if (true) {
-      if (data && typeof data === "object") {
-        if (typeof Buffer === "function" && data.constructor === Buffer) {
-          buff = data;
-        } else {
-          if (data.constructor === Uint8Array || data.constructor === ArrayBuffer) {
-            buff = data.constructor === ArrayBuffer ? new Uint8Array(data) : data;
-          } else {
-            getCatch(new TypeError(parmTypeErrStr));
-          }
-        }
-      } else {
-        getCatch(new TypeError(parmTypeErrStr));
-      }
+    buff = normalizeInput(data);
+    if (!buff) {
+      getCatch(new TypeError(parmTypeErrStr));
     }
     if (buff) {
       len = buff.length;
@@ -9296,21 +9276,62 @@ var __exports__ = (() => {
       return result;
     };
   }
-  function str2AB(str) {
-    var l, buff, buffView, i = -1;
-    l = str.length - 1;
-    buff = new ArrayBuffer(str.length);
-    buffView = new Uint8Array(buff);
-    while (l > i++) {
-      buffView[i] = str.charCodeAt(i);
-    }
-    return buffView;
+  function decodeBase64Safely(str) {
+    try {
+      return decodeBase64ToUint8Array(str);
+    } catch (error) {
+      return null;
+    }
   }
-  function nodeATOB(str) {
-    return Buffer.from(str, "base64").toString("binary");
+  function decodeBase64ToUint8Array(base64) {
+    var sanitized = base64.replace(/-/g, "+").replace(/_/g, "/");
+    if (typeof atob === "function") {
+      return binaryStringToUint8Array(atob(sanitized));
+    }
+    return decodeBase64WithoutAtob(sanitized);
   }
-  function identity(x) {
-    return x;
+  function decodeBase64WithoutAtob(base64) {
+    var paddingLength = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0, byteLength = base64.length * 3 / 4 - paddingLength, bytes = new Uint8Array(byteLength), byteIndex = 0, i = 0, enc1, enc2, enc3, enc4;
+    while (i < base64.length) {
+      enc1 = BASE64_LOOKUP.indexOf(base64.charAt(i++));
+      enc2 = BASE64_LOOKUP.indexOf(base64.charAt(i++));
+      enc3 = BASE64_LOOKUP.indexOf(base64.charAt(i++));
+      enc4 = BASE64_LOOKUP.indexOf(base64.charAt(i++));
+      if (enc1 < 0 || enc2 < 0 || enc3 < 0 || enc4 < 0) {
+        throw new TypeError("Invalid base64 input");
+      }
+      bytes[byteIndex++] = enc1 << 2 | enc2 >> 4;
+      if (enc3 < 64 && byteIndex < byteLength) {
+        bytes[byteIndex++] = (enc2 & 15) << 4 | enc3 >> 2;
+      }
+      if (enc4 < 64 && byteIndex < byteLength) {
+        bytes[byteIndex++] = (enc3 & 3) << 6 | enc4;
+      }
+    }
+    return bytes;
+  }
+  function binaryStringToUint8Array(str) {
+    var length = str.length, view = new Uint8Array(length), i = 0;
+    while (i < length) {
+      view[i] = str.charCodeAt(i);
+      i++;
+    }
+    return view;
+  }
+  function normalizeInput(data) {
+    if (data instanceof Uint8Array) {
+      return data;
+    }
+    if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
+      return new Uint8Array(data);
+    }
+    if (data && typeof data === "object" && ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    if (typeof data === "string") {
+      return new TextEncoder().encode(data);
+    }
+    return null;
   }
   function makeCrypt() {
     var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -9375,10 +9396,11 @@ var __exports__ = (() => {
   async function cutTheTailOff(provider) {
     const oldEoCDinfo = await parseEoCDRecord(provider);
     const oldCDStartOffset = oldEoCDinfo.cdStartOffset;
+    const providerSize = (await provider.stat()).bigsize;
     const oldCDLength = Number(
       oldEoCDinfo.offsets.zip64EoCDOffset ? oldEoCDinfo.offsets.zip64EoCDOffset - oldCDStartOffset : oldEoCDinfo.offsets.zipEoCDOffset - oldCDStartOffset
     );
-    const zipEnding = await provider.slice(oldCDStartOffset, provider.length);
+    const zipEnding = await readRange(provider, oldCDStartOffset, providerSize);
     await provider.truncate(Number(oldCDStartOffset));
     const oldCDBody = zipEnding.slice(0, oldCDLength);
     const eocdBody = zipEnding.slice(oldCDLength, zipEnding.byteLength);
@@ -9403,24 +9425,27 @@ var __exports__ = (() => {
     ];
   }
   async function addOneFile(zipUrl, fileToAdd, fileName) {
-    const provider = new FileHandleFile(zipUrl, true);
+    const provider = new NodeFileFacade(zipUrl, "a+");
     const [oldCDBody, eocdBody, oldEoCDinfo] = await cutTheTailOff(provider);
-    const newFileOffset = provider.length;
+    let currentOffset = (await provider.stat()).bigsize;
+    const newFileOffset = currentOffset;
     const [localPart, cdHeaderPart] = await generateFileHeaders(fileName, fileToAdd, newFileOffset);
     await provider.append(localPart);
+    currentOffset += BigInt(localPart.byteLength);
     const newCDBody = concatenateArrayBuffers(oldCDBody, cdHeaderPart);
-    const newCDStartOffset = provider.length;
+    const newCDStartOffset = currentOffset;
     await provider.append(new Uint8Array(newCDBody));
-    const eocdOffset = provider.length;
-    await provider.append(
-      updateEoCD(
-        eocdBody,
-        oldEoCDinfo.offsets,
-        newCDStartOffset,
-        eocdOffset,
-        oldEoCDinfo.cdRecordsNumber + 1n
-      )
+    currentOffset += BigInt(newCDBody.byteLength);
+    const eocdOffset = currentOffset;
+    const updatedEoCD = updateEoCD(
+      eocdBody,
+      oldEoCDinfo.offsets,
+      newCDStartOffset,
+      eocdOffset,
+      oldEoCDinfo.cdRecordsNumber + 1n
     );
+    await provider.append(updatedEoCD);
+    currentOffset += BigInt(updatedEoCD.byteLength);
   }
   async function createZip(inputPath, outputPath, createAdditionalData) {
     const fileIterator = getFileIterator(inputPath);
@@ -9449,7 +9474,7 @@ var __exports__ = (() => {
     fileList?.push({ fileName: file.path, localHeaderOffset: size });
     const [localPart, cdHeaderPart] = await generateFileHeaders(file.path, file.file, size);
     await resFile.append(localPart);
-    cdArray.push(cdHeaderPart);
+    cdArray.push(toArrayBuffer2(cdHeaderPart));
   }
   function getFileIterator(inputPath) {
     async function* iterable() {
@@ -9568,7 +9593,7 @@ var __exports__ = (() => {
       const pakoOptions = this.options?.deflate || {};
       const inputArray = new Uint8Array(input);
       const deflate = this.options?.raw ? import_pako.default.deflateRaw : import_pako.default.deflate;
-      return deflate(inputArray, pakoOptions).buffer;
+      return toArrayBuffer2(deflate(inputArray, pakoOptions).buffer);
     }
     decompressSync(input) {
       if (!isBrowser && this.options.deflate?.useZlib) {
@@ -9578,7 +9603,7 @@ var __exports__ = (() => {
       const pakoOptions = this.options?.deflate || {};
       const inputArray = new Uint8Array(input);
       const inflate = this.options?.raw ? import_pako.default.inflateRaw : import_pako.default.inflate;
-      return inflate(inputArray, pakoOptions).buffer;
+      return toArrayBuffer2(inflate(inputArray, pakoOptions).buffer);
     }
     async *compressBatches(asyncIterator) {
       const pakoOptions = this.options?.deflate || {};
@@ -9660,34 +9685,35 @@ var __exports__ = (() => {
     }
   };
   var ZipFileSystem = class {
-    /** FileProvider instance promise */
-    fileProvider = null;
+    /** File instance */
+    file = null;
     fileName;
     archive = null;
     /**
      * Constructor
-     * @param file - instance of FileProvider or file path string
+     * @param file - instance of ReadableFile or file path string
      */
     constructor(file) {
       if (typeof file === "string") {
         this.fileName = file;
-        if (!isBrowser) {
-          this.fileProvider = new FileHandleFile(file);
-        } else {
-          throw new Error("Cannot open file for random access in a WEB browser");
+        if (isBrowser) {
+          throw new Error("ZipFileSystem cannot open file paths in browser environments");
         }
+        this.file = new NodeFileFacade(file);
+      } else if (file instanceof Blob || file instanceof ArrayBuffer) {
+        this.file = new BlobFile(file);
       } else if (file instanceof IndexedArchive) {
-        this.fileProvider = file.fileProvider;
+        this.file = file.file;
         this.archive = file;
         this.fileName = file.fileName;
-      } else if (isFileProvider(file)) {
-        this.fileProvider = file;
+      } else {
+        this.file = file;
       }
     }
     /** Clean up resources */
     async destroy() {
-      if (this.fileProvider) {
-        await this.fileProvider.destroy();
+      if (this.file) {
+        await this.file.close();
       }
     }
     /**
@@ -9695,11 +9721,11 @@ var __exports__ = (() => {
      * @returns array of file names
      */
     async readdir() {
-      if (!this.fileProvider) {
+      if (!this.file) {
         throw new Error("No data detected in the zip archive");
       }
       const fileNames = [];
-      const zipCDIterator = makeZipCDHeaderIterator(this.fileProvider);
+      const zipCDIterator = makeZipCDHeaderIterator(this.file);
       for await (const cdHeader of zipCDIterator) {
         fileNames.push(cdHeader.fileName);
       }
@@ -9727,13 +9753,13 @@ var __exports__ = (() => {
       if (this.archive) {
         uncompressedFile = await this.archive.getFile(filename2, "http");
       } else {
-        if (!this.fileProvider) {
+        if (!this.file) {
           throw new Error("No data detected in the zip archive");
         }
         const cdFileHeader = await this.getCDFileHeader(filename2);
         const localFileHeader = await parseZipLocalFileHeader(
           cdFileHeader.localHeaderOffset,
-          this.fileProvider
+          this.file
         );
         if (!localFileHeader) {
           throw new Error("Local file header has not been found in the zip archive`");
@@ -9742,7 +9768,8 @@ var __exports__ = (() => {
         if (!compressionHandler) {
           throw Error("Only Deflation compression is supported");
         }
-        const compressedFile = await this.fileProvider.slice(
+        const compressedFile = await readRange(
+          this.file,
           localFileHeader.fileDataOffset,
           localFileHeader.fileDataOffset + localFileHeader.compressedSize
         );
@@ -9760,10 +9787,10 @@ var __exports__ = (() => {
      * @returns central directory file header
      */
     async getCDFileHeader(filename2) {
-      if (!this.fileProvider) {
+      if (!this.file) {
         throw new Error("No data detected in the zip archive");
       }
-      const zipCDIterator = makeZipCDHeaderIterator(this.fileProvider);
+      const zipCDIterator = makeZipCDHeaderIterator(this.file);
       let result = null;
       for await (const cdHeader of zipCDIterator) {
         if (cdHeader.fileName === filename2) {
@@ -9780,16 +9807,16 @@ var __exports__ = (() => {
 
   // src/filesystems/IndexedArchive.ts
   var IndexedArchive = class {
-    fileProvider;
+    file;
     fileName;
     /**
      * Constructor
-     * @param fileProvider - instance of a binary data reader
+     * @param fileProvider - readable file instance for random access
      * @param hashTable - pre-loaded hashTable. If presented, getFile will skip reading the hash file
      * @param fileName - name of the archive. It is used to add to an URL of a loader context
      */
-    constructor(fileProvider, hashTable, fileName) {
-      this.fileProvider = fileProvider;
+    constructor(file, hashTable, fileName) {
+      this.file = file;
       this.fileName = fileName;
     }
     /**
@@ -9798,7 +9825,7 @@ var __exports__ = (() => {
      * @returns
      */
     async getFileWithoutHash(filename2) {
-      const zipFS = new ZipFileSystem(this.fileProvider);
+      const zipFS = new ZipFileSystem(this.file);
       const response = await zipFS.fetch(filename2);
       return await response.arrayBuffer();
     }