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

package/dist/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var dist_exports = {};
 __export(dist_exports, {
   CD_HEADER_SIGNATURE: () => signature2,
+  DataViewReadableFile: () => DataViewReadableFile,
   IndexedArchive: () => IndexedArchive,
   TarBuilder: () => TarBuilder,
   ZIP_COMPRESSION_HANDLERS: () => ZIP_COMPRESSION_HANDLERS,
@@ -42,6 +43,7 @@ __export(dist_exports, {
   createZip: () => createZip,
   generateCDHeader: () => generateCDHeader,
   generateLocalHeader: () => generateLocalHeader,
+  getReadableFileSize: () => getReadableFileSize,
   localHeaderSignature: () => signature3,
   makeHashTableFromZipHeaders: () => makeHashTableFromZipHeaders,
   makeZipCDHeaderIterator: () => makeZipCDHeaderIterator,
@@ -49,13 +51,14 @@ __export(dist_exports, {
   parseHashTable: () => parseHashTable,
   parseZipCDFileHeader: () => parseZipCDFileHeader,
   parseZipLocalFileHeader: () => parseZipLocalFileHeader,
+  readRange: () => readRange,
   searchFromTheEnd: () => searchFromTheEnd
 });
 module.exports = __toCommonJS(dist_exports);
 
 // dist/zip-loader.js
 var import_jszip = __toESM(require("jszip"), 1);
-var VERSION = true ? "4.4.0-alpha.0" : "latest";
+var VERSION = true ? "4.4.0-alpha.9" : "latest";
 var ZipLoader = {
   dataType: null,
   batchType: null,
@@ -102,7 +105,7 @@ async function loadZipEntry(jsZip, subFilename, options = {}) {
 
 // dist/zip-writer.js
 var import_jszip2 = __toESM(require("jszip"), 1);
-var VERSION2 = true ? "4.4.0-alpha.0" : "latest";
+var VERSION2 = true ? "4.4.0-alpha.9" : "latest";
 var ZipWriter = {
   name: "Zip Archive",
   id: "zip",
@@ -121,7 +124,7 @@ var ZipWriter = {
   encode: encodeZipAsync
 };
 async function encodeZipAsync(fileMap, options = {}) {
-  var _a;
+  var _a, _b, _c;
   const jsZip = new import_jszip2.default();
   for (const subFileName in fileMap) {
     const subFileData = fileMap[subFileName];
@@ -136,7 +139,7 @@ async function encodeZipAsync(fileMap, options = {}) {
       zipOptions.onUpdate
     );
   } catch (error) {
-    options.log.error(`Unable to encode zip archive: ${error}`);
+    (_c = (_b = options.core) == null ? void 0 : _b.log) == null ? void 0 : _c.error(`Unable to encode zip archive: ${error}`);
     throw error;
   }
 }
@@ -360,27 +363,115 @@ var TarBuilder = class {
 };
 
 // dist/parse-zip/cd-file-header.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 
 // dist/parse-zip/end-of-central-directory.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
+
+// dist/parse-zip/readable-file-utils.js
+var import_loader_utils = require("@loaders.gl/loader-utils");
+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");
+  }
+  return numberValue;
+}
+function normalizeOffset(offset, size) {
+  if (offset < 0) {
+    return Math.max(size + offset, 0);
+  }
+  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;
+  }
+  if (file.size > 0) {
+    return BigInt(file.size);
+  }
+  if (file.stat) {
+    const stats = await file.stat();
+    if ((stats == null ? void 0 : stats.bigsize) !== void 0) {
+      return stats.bigsize;
+    }
+    if ((stats == null ? void 0 : stats.size) !== void 0) {
+      return BigInt(stats.size);
+    }
+  }
+  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;
+  }
+  async close() {
+  }
+  async stat() {
+    return { size: this.size, bigsize: this.bigsize, isDirectory: false };
+  }
+  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 (0, import_loader_utils.copyToArrayBuffer)(this.handle.buffer, normalizedStart, lengthToRead);
+  }
+};
 
 // dist/parse-zip/search-from-the-end.js
 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];
@@ -396,7 +487,7 @@ var searchFromTheEnd = async (file, target) => {
 };
 
 // dist/parse-zip/zip64-info-generation.js
-var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
 var signature = new Uint8Array([1, 0]);
 function createZip64Info(options) {
   const optionsToUse = {
@@ -412,7 +503,7 @@ function createZip64Info(options) {
     NUMBER_SETTERS[field.size](newValue, 0, optionsToUse[field.name ?? ""] ?? field.default);
     arraysToConcat.push(newValue.buffer);
   }
-  return (0, import_loader_utils.concatenateArrayBuffers)(...arraysToConcat);
+  return (0, import_loader_utils2.concatenateArrayBuffers)(...arraysToConcat);
 }
 function setFieldToNumber(header, fieldSize, fieldOffset, value) {
   NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);
@@ -473,21 +564,21 @@ 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 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 ((0, import_loader_utils2.compareArrayBuffers)(magicBytes, zip64EoCDLocatorSignature)) {
-    zip64EoCDOffset = await file.getBigUint64(zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET);
-    const endOfCDMagicBytes = await file.slice(zip64EoCDOffset, zip64EoCDOffset + 4n);
-    if (!(0, import_loader_utils2.compareArrayBuffers)(endOfCDMagicBytes, zip64EoCDSignature.buffer)) {
+  const magicBytes = await readRange(file, zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
+  if ((0, import_loader_utils3.compareArrayBuffers)(magicBytes, zip64EoCDLocatorSignature.buffer)) {
+    zip64EoCDOffset = await readBigUint64(file, zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET);
+    const endOfCDMagicBytes = await readRange(file, zip64EoCDOffset, zip64EoCDOffset + 4n);
+    if (!(0, import_loader_utils3.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;
   }
@@ -532,7 +623,7 @@ function generateEoCD(options) {
   }
   const locator = generateZip64InfoLocator(options);
   const zip64Record = generateZip64Info(options);
-  return (0, import_loader_utils2.concatenateArrayBuffers)(zip64Record, locator, header.buffer);
+  return (0, import_loader_utils3.concatenateArrayBuffers)(zip64Record, locator, header.buffer);
 }
 var EOCD_FIELDS = [
   // End of central directory signature = 0x06054b50
@@ -697,12 +788,13 @@ var CD_LOCAL_HEADER_OFFSET_OFFSET = 42;
 var CD_FILE_NAME_OFFSET = 46n;
 var signature2 = new Uint8Array([80, 75, 1, 2]);
 var parseZipCDFileHeader = async (headerOffset, file) => {
-  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 (!(0, import_loader_utils3.compareArrayBuffers)(magicBytes, signature2.buffer)) {
+  if (!(0, import_loader_utils4.compareArrayBuffers)(magicBytes, signature2.buffer)) {
     return null;
   }
   const compressedSize = BigInt(mainHeader.getUint32(CD_COMPRESSED_SIZE_OFFSET, true));
@@ -710,7 +802,7 @@ var parseZipCDFileHeader = async (headerOffset, file) => {
   const extraFieldLength = mainHeader.getUint16(CD_EXTRA_FIELD_LENGTH_OFFSET, true);
   const startDisk = BigInt(mainHeader.getUint16(CD_START_DISK_OFFSET, true));
   const fileNameLength = mainHeader.getUint16(CD_FILE_NAME_LENGTH_OFFSET, true);
-  const additionalHeader = await file.slice(headerOffset + CD_FILE_NAME_OFFSET, headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength));
+  const additionalHeader = await readRange(file, headerOffset + CD_FILE_NAME_OFFSET, headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength));
   const filenameBytes = additionalHeader.slice(0, fileNameLength);
   const fileName = new TextDecoder().decode(filenameBytes);
   const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
@@ -735,7 +827,7 @@ var parseZipCDFileHeader = async (headerOffset, file) => {
 };
 async function* makeZipCDHeaderIterator(fileProvider) {
   const { cdStartOffset, cdByteSize } = await parseEoCDRecord(fileProvider);
-  const centralDirectory = new import_loader_utils3.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) {
     yield cdHeader;
@@ -801,7 +893,7 @@ function generateCDHeader(options) {
     setFieldToNumber(header, field.size, field.offset, optionsToUse[field.name ?? ""] ?? field.default ?? 0);
   }
   const encodedName = new TextEncoder().encode(optionsToUse.fileName);
-  const resHeader = (0, import_loader_utils3.concatenateArrayBuffers)(header.buffer, encodedName, zip64header);
+  const resHeader = (0, import_loader_utils4.concatenateArrayBuffers)(header.buffer, encodedName, zip64header);
   return resHeader;
 }
 var ZIP_HEADER_FIELDS = [
@@ -911,7 +1003,7 @@ var ZIP_HEADER_FIELDS = [
 ];
 
 // dist/parse-zip/local-file-header.js
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
 var COMPRESSION_METHOD_OFFSET = 8;
 var COMPRESSED_SIZE_OFFSET = 18;
 var UNCOMPRESSED_SIZE_OFFSET = 22;
@@ -920,14 +1012,14 @@ var EXTRA_FIELD_LENGTH_OFFSET = 28;
 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 (!(0, import_loader_utils4.compareArrayBuffers)(magicBytes, signature3)) {
+  if (!(0, import_loader_utils5.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(headerOffset + FILE_NAME_OFFSET, headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength));
+  const additionalHeader = await readRange(file, headerOffset + FILE_NAME_OFFSET, headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength));
   const fileNameBuffer = additionalHeader.slice(0, fileNameLength);
   const extraDataBuffer = new DataView(additionalHeader.slice(fileNameLength, additionalHeader.byteLength));
   const fileName = new TextDecoder().decode(fileNameBuffer).split("\\").join("/");
@@ -977,7 +1069,7 @@ function generateLocalHeader(options) {
     setFieldToNumber(header, field.size, field.offset, optionsToUse[field.name ?? ""] ?? field.default ?? 0);
   }
   const encodedName = new TextEncoder().encode(optionsToUse.fileName);
-  const resHeader = (0, import_loader_utils4.concatenateArrayBuffers)(header.buffer, encodedName, zip64header);
+  const resHeader = (0, import_loader_utils5.concatenateArrayBuffers)(header.buffer, encodedName, zip64header);
   return resHeader;
 }
 var ZIP_HEADER_FIELDS2 = [
@@ -1051,14 +1143,15 @@ var ZIP_HEADER_FIELDS2 = [
 ];
 
 // dist/parse-zip/zip-composition.js
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
 var import_crypto = require("@loaders.gl/crypto");
 var import_core = require("@loaders.gl/core");
 async function cutTheTailOff(provider) {
   const oldEoCDinfo = await parseEoCDRecord(provider);
   const oldCDStartOffset = oldEoCDinfo.cdStartOffset;
+  const 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);
@@ -1078,25 +1171,30 @@ async function generateFileHeaders(fileName, fileToAdd, localFileHeaderOffset) {
     length: fileToAdd.byteLength
   });
   return [
-    new Uint8Array((0, import_loader_utils5.concatenateArrayBuffers)(newFileLocalHeader, fileToAdd)),
+    new Uint8Array((0, import_loader_utils6.concatenateArrayBuffers)(newFileLocalHeader, fileToAdd)),
     new Uint8Array(newFileCDHeader)
   ];
 }
 async function addOneFile(zipUrl, fileToAdd, fileName) {
-  const provider = new import_loader_utils5.FileHandleFile(zipUrl, true);
+  const provider = new import_loader_utils6.NodeFile(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);
-  const newCDBody = (0, import_loader_utils5.concatenateArrayBuffers)(oldCDBody, cdHeaderPart);
-  const newCDStartOffset = provider.length;
+  currentOffset += BigInt(localPart.byteLength);
+  const newCDBody = (0, import_loader_utils6.concatenateArrayBuffers)(oldCDBody, cdHeaderPart);
+  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);
-  const resFile = new import_loader_utils5.NodeFile(outputPath, "w");
+  const resFile = new import_loader_utils6.NodeFile(outputPath, "w");
   const fileList = [];
   const cdArray = [];
   for await (const file of fileIterator) {
@@ -1107,7 +1205,7 @@ async function createZip(inputPath, outputPath, createAdditionalData) {
     await addFile(additionaldata, resFile, cdArray);
   }
   const cdOffset = (await resFile.stat()).bigsize;
-  const cd = (0, import_loader_utils5.concatenateArrayBuffers)(...cdArray);
+  const cd = (0, import_loader_utils6.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 })));
@@ -1117,20 +1215,20 @@ async function addFile(file, resFile, cdArray, fileList) {
   fileList == null ? void 0 : fileList.push({ fileName: file.path, localHeaderOffset: size });
   const [localPart, cdHeaderPart] = await generateFileHeaders(file.path, file.file, size);
   await resFile.append(localPart);
-  cdArray.push(cdHeaderPart);
+  cdArray.push((0, import_loader_utils6.toArrayBuffer)(cdHeaderPart));
 }
 function getFileIterator(inputPath) {
   async function* iterable() {
     const fileList = await getAllFiles(inputPath);
     for (const filePath of fileList) {
-      const file = await (await (0, import_core.fetchFile)(import_loader_utils5.path.join(inputPath, filePath))).arrayBuffer();
+      const file = await (await (0, import_core.fetchFile)(import_loader_utils6.path.join(inputPath, filePath))).arrayBuffer();
       yield { path: filePath, file };
     }
   }
   return iterable();
 }
 async function getAllFiles(basePath, subfolder = "", fsPassed) {
-  const fs = fsPassed ? fsPassed : new import_loader_utils5.NodeFilesystem({});
+  const fs = fsPassed ? fsPassed : new import_loader_utils6.NodeFilesystem({});
   const files = await fs.readdir(pathJoin(basePath, subfolder));
   const arrayOfFiles = [];
   for (const file of files) {
@@ -1146,11 +1244,11 @@ async function getAllFiles(basePath, subfolder = "", fsPassed) {
 }
 function pathJoin(...paths) {
   const resPaths = paths.filter((val) => val.length);
-  return import_loader_utils5.path.join(...resPaths);
+  return import_loader_utils6.path.join(...resPaths);
 }
 
 // dist/filesystems/zip-filesystem.js
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
+var import_loader_utils7 = require("@loaders.gl/loader-utils");
 var import_compression = require("@loaders.gl/compression");
 var ZIP_COMPRESSION_HANDLERS = {
   /** No compression */
@@ -1163,34 +1261,35 @@ var ZIP_COMPRESSION_HANDLERS = {
   }
 };
 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 (!import_loader_utils6.isBrowser) {
-        this.fileProvider = new import_loader_utils6.FileHandleFile(file);
-      } else {
-        throw new Error("Cannot open file for random access in a WEB browser");
+      if (import_loader_utils7.isBrowser) {
+        throw new Error("ZipFileSystem cannot open file paths in browser environments");
       }
+      this.file = new import_loader_utils7.NodeFile(file);
+    } else if (file instanceof Blob || file instanceof ArrayBuffer) {
+      this.file = new import_loader_utils7.BlobFile(file);
     } else if (file instanceof IndexedArchive) {
-      this.fileProvider = file.fileProvider;
+      this.file = file.file;
       this.archive = file;
       this.fileName = file.fileName;
-    } else if ((0, import_loader_utils6.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();
     }
   }
   /**
@@ -1198,11 +1297,11 @@ var ZipFileSystem = class {
    * @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);
     }
@@ -1230,11 +1329,11 @@ var ZipFileSystem = class {
     if (this.archive) {
       uncompressedFile = await this.archive.getFile(filename, "http");
     } else {
-      if (!this.fileProvider) {
+      if (!this.file) {
         throw new Error("No data detected in the zip archive");
       }
       const cdFileHeader = await this.getCDFileHeader(filename);
-      const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, this.fileProvider);
+      const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, this.file);
       if (!localFileHeader) {
         throw new Error("Local file header has not been found in the zip archive`");
       }
@@ -1242,7 +1341,7 @@ var ZipFileSystem = class {
       if (!compressionHandler) {
         throw Error("Only Deflation compression is supported");
       }
-      const compressedFile = await this.fileProvider.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+      const compressedFile = await readRange(this.file, localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
       uncompressedFile = await compressionHandler(compressedFile);
     }
     const response = new Response(uncompressedFile);
@@ -1257,10 +1356,10 @@ var ZipFileSystem = class {
    * @returns central directory file header
    */
   async getCDFileHeader(filename) {
-    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 === filename) {
@@ -1277,16 +1376,16 @@ var ZipFileSystem = class {
 
 // dist/filesystems/IndexedArchive.js
 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;
   }
   /**
@@ -1295,7 +1394,7 @@ var IndexedArchive = class {
    * @returns
    */
   async getFileWithoutHash(filename) {
-    const zipFS = new ZipFileSystem(this.fileProvider);
+    const zipFS = new ZipFileSystem(this.file);
     const response = await zipFS.fetch(filename);
     return await response.arrayBuffer();
   }
@@ -1303,7 +1402,7 @@ var IndexedArchive = class {
 
 // dist/hash-file-utility.js
 var import_crypto2 = require("@loaders.gl/crypto");
-var import_loader_utils7 = require("@loaders.gl/loader-utils");
+var import_loader_utils8 = require("@loaders.gl/loader-utils");
 function parseHashTable(arrayBuffer) {
   const dataView = new DataView(arrayBuffer);
   const hashMap = {};
@@ -1344,10 +1443,10 @@ async function composeHashFile(zipCDIterator) {
     }
     const arrayBuffer = textEncoder.encode(filename).buffer;
     const md5 = await md5Hash.hash(arrayBuffer, "hex");
-    hashArray.push((0, import_loader_utils7.concatenateArrayBuffers)(hexStringToBuffer(md5), bigintToBuffer(cdHeader.localHeaderOffset)));
+    hashArray.push((0, import_loader_utils8.concatenateArrayBuffers)(hexStringToBuffer(md5), bigintToBuffer(cdHeader.localHeaderOffset)));
   }
   const bufferArray = hashArray.sort(compareHashes);
-  return (0, import_loader_utils7.concatenateArrayBuffersFromArray)(bufferArray);
+  return (0, import_loader_utils8.concatenateArrayBuffersFromArray)(bufferArray);
 }
 function compareHashes(arrA, arrB) {
   const a = new BigUint64Array(arrA);