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

package/dist/zip-writer.js

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 import JSZip from 'jszip';
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.4.0-alpha.0" !== 'undefined' ? "4.4.0-alpha.0" : 'latest';
+const VERSION = typeof "4.4.0-alpha.9" !== 'undefined' ? "4.4.0-alpha.9" : 'latest';
 /**
  * Zip exporter
  */
@@ -39,7 +39,8 @@ async function encodeZipAsync(fileMap, options = {}) {
         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;
     }
 }
+//# sourceMappingURL=zip-writer.js.map

package/dist/zip-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-writer.js","sourceRoot":"","sources":["../src/zip-writer.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,KAA8B,MAAM,OAAO,CAAC;AAEnD,qDAAqD;AACrD,MAAM,OAAO,GAAG,sBAAkB,KAAK,WAAW,CAAC,CAAC,iBAAa,CAAC,CAAC,QAAQ,CAAC;AAU5E;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,aAAa;IACnB,EAAE,EAAE,KAAK;IACT,MAAM,EAAE,KAAK;IACb,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,CAAC,KAAK,CAAC;IACnB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,CAAC,iBAAiB,CAAC;IAC9B,OAAO,EAAE;QACP,GAAG,EAAE;YACH,QAAQ,EAAE,GAAG,EAAE,GAAE,CAAC;SACnB;QACD,KAAK,EAAE,EAAE;KACV;IACD,MAAM,EAAE,cAAc;CACoE,CAAC;AAE7F,KAAK,UAAU,cAAc,CAC3B,OAAoC,EACpC,UAA4B,EAAE;IAE9B,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;IAC1B,uBAAuB;IACvB,KAAK,MAAM,WAAW,IAAI,OAAO,EAAE,CAAC;QAClC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QAEzC,8EAA8E;QAC9E,sEAAsE;QACtE,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED,MAAM,UAAU,GAAG,EAAC,GAAG,SAAS,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,EAAC,CAAC;IAC/D,MAAM,YAAY,GAA0B,EAAC,GAAG,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,KAAK,EAAC,CAAC;IAE5F,IAAI,CAAC;QACH,OAAO,MAAM,KAAK,CAAC,aAAa,CAC9B,EAAC,GAAG,YAAY,EAAE,IAAI,EAAE,aAAa,EAAC,EAAE,0BAA0B;QAClE,UAAU,CAAC,QAAQ,CACpB,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,iCAAiC,KAAK,EAAE,CAAC,CAAC;QACnE,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/zip",
-  "version": "4.4.0-alpha.1",
+  "version": "4.4.0-alpha.9",
   "description": "Zip Archive Loader",
   "license": "MIT",
   "type": "module",
@@ -39,14 +39,14 @@
     "build-bundle-dev": "ocular-bundle ./bundle.ts --env=dev --output=dist/dist.dev.js"
   },
   "dependencies": {
-    "@loaders.gl/compression": "4.4.0-alpha.1",
-    "@loaders.gl/crypto": "4.4.0-alpha.1",
-    "@loaders.gl/loader-utils": "4.4.0-alpha.1",
+    "@loaders.gl/compression": "4.4.0-alpha.9",
+    "@loaders.gl/crypto": "4.4.0-alpha.9",
+    "@loaders.gl/loader-utils": "4.4.0-alpha.9",
     "jszip": "^3.1.5",
     "md5": "^2.3.0"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "4.4.0-alpha.0"
+    "@loaders.gl/core": "4.4.0-alpha.1"
   },
-  "gitHead": "f1732de45907bd500bf4eedb4803beca8bf4bfb0"
+  "gitHead": "e9e6710379718c7663e97eba868c76e15de4cb84"
 }

package/src/filesystems/IndexedArchive.ts

@@ -1,4 +1,4 @@
-import {FileProviderInterface} from '@loaders.gl/loader-utils';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
 import {ZipFileSystem} from './zip-filesystem';
 
 /**
@@ -6,21 +6,17 @@ import {ZipFileSystem} from './zip-filesystem';
  * a hash file inside that allows to increase reading speed
  */
 export abstract class IndexedArchive {
-  public fileProvider: FileProviderInterface;
+  public file: ReadableFile;
   public fileName?: string;
 
   /**
    * 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: FileProviderInterface,
-    hashTable?: Record<string, bigint>,
-    fileName?: string
-  ) {
-    this.fileProvider = fileProvider;
+  constructor(file: ReadableFile, hashTable?: Record<string, bigint>, fileName?: string) {
+    this.file = file;
     this.fileName = fileName;
   }
 
@@ -37,7 +33,7 @@ export abstract class IndexedArchive {
    * @returns
    */
   protected async getFileWithoutHash(filename: string): Promise<ArrayBuffer> {
-    const zipFS = new ZipFileSystem(this.fileProvider);
+    const zipFS = new ZipFileSystem(this.file);
     const response = await zipFS.fetch(filename);
     return await response.arrayBuffer();
   }

package/src/filesystems/zip-filesystem.ts

@@ -2,17 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {
-  FileSystem,
-  isBrowser,
-  FileProviderInterface,
-  isFileProvider,
-  FileHandleFile
-} from '@loaders.gl/loader-utils';
+import {FileSystem, isBrowser, BlobFile, NodeFile} from '@loaders.gl/loader-utils';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
 import {ZipCDFileHeader, makeZipCDHeaderIterator} from '../parse-zip/cd-file-header';
 import {parseZipLocalFileHeader} from '../parse-zip/local-file-header';
 import {DeflateCompression} from '@loaders.gl/compression';
 import {IndexedArchive} from './IndexedArchive';
+import {readRange} from '../parse-zip/readable-file-utils';
 
 export type CompressionHandler = (compressedFile: ArrayBuffer) => Promise<ArrayBuffer>;
 /** Handling different compression types in zip */
@@ -29,40 +25,41 @@ export const ZIP_COMPRESSION_HANDLERS: {[key: number]: CompressionHandler} = {
 
 /**
  * FileSystem adapter for a ZIP file
- * Holds FileProvider object that provides random access to archived files
+ * Holds a ReadableFile object that provides random access to archived files
  */
 export class ZipFileSystem implements FileSystem {
-  /** FileProvider instance promise */
-  public fileProvider: FileProviderInterface | null = null;
+  /** File instance */
+  public file: ReadableFile | null = null;
   public fileName?: string;
   public archive: IndexedArchive | null = null;
 
   /**
    * Constructor
-   * @param file - instance of FileProvider or file path string
+   * @param file - instance of ReadableFile or file path string
    */
-  constructor(file: FileProviderInterface | IndexedArchive | string) {
+  constructor(file: ReadableFile | IndexedArchive | string | Blob | ArrayBuffer) {
     // Try to open file in NodeJS
     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 NodeFile(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();
     }
   }
 
@@ -71,11 +68,11 @@ export class ZipFileSystem implements FileSystem {
    * @returns array of file names
    */
   async readdir(): Promise<string[]> {
-    if (!this.fileProvider) {
+    if (!this.file) {
       throw new Error('No data detected in the zip archive');
     }
     const fileNames: string[] = [];
-    const zipCDIterator = makeZipCDHeaderIterator(this.fileProvider);
+    const zipCDIterator = makeZipCDHeaderIterator(this.file);
     for await (const cdHeader of zipCDIterator) {
       fileNames.push(cdHeader.fileName);
     }
@@ -106,13 +103,13 @@ export class ZipFileSystem implements FileSystem {
     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
+        this.file
       );
       if (!localFileHeader) {
         throw new Error('Local file header has not been found in the zip archive`');
@@ -124,7 +121,8 @@ export class ZipFileSystem implements FileSystem {
         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
       );
@@ -145,10 +143,10 @@ export class ZipFileSystem implements FileSystem {
    * @returns central directory file header
    */
   private async getCDFileHeader(filename: string): Promise<ZipCDFileHeader> {
-    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: ZipCDFileHeader | null = null;
     for await (const cdHeader of zipCDIterator) {
       if (cdHeader.fileName === filename) {

package/src/hash-file-utility.ts

@@ -3,11 +3,8 @@
 // Copyright (c) vis.gl contributors
 
 import {MD5Hash} from '@loaders.gl/crypto';
-import {
-  FileProviderInterface,
-  concatenateArrayBuffers,
-  concatenateArrayBuffersFromArray
-} from '@loaders.gl/loader-utils';
+import {concatenateArrayBuffers, concatenateArrayBuffersFromArray} from '@loaders.gl/loader-utils';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
 import {ZipCDFileHeader, makeZipCDHeaderIterator} from './parse-zip/cd-file-header';
 
 /**
@@ -38,11 +35,11 @@ function bufferToHex(buffer: ArrayBuffer, start: number, length: number): string
 
 /**
  * generates hash info from zip files "central directory"
- * @param fileProvider - provider of the archive
+ * @param fileProvider - readable archive source
  * @returns ready to use hash info
  */
 export async function makeHashTableFromZipHeaders(
-  fileProvider: FileProviderInterface
+  fileProvider: ReadableFile
 ): Promise<Record<string, bigint>> {
   const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
   return getHashTable(zipCDIterator);

package/src/index.ts

@@ -19,6 +19,11 @@ export {
 } from './parse-zip/local-file-header';
 export {parseEoCDRecord} from './parse-zip/end-of-central-directory';
 export {searchFromTheEnd} from './parse-zip/search-from-the-end';
+export {
+  readRange,
+  getReadableFileSize,
+  DataViewReadableFile
+} from './parse-zip/readable-file-utils';
 export {addOneFile, createZip} from './parse-zip/zip-composition';
 
 // export type {HashElement} from './hash-file-utility';

package/src/parse-zip/cd-file-header.ts

@@ -2,15 +2,17 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {
-  DataViewFile,
-  FileProviderInterface,
-  compareArrayBuffers,
-  concatenateArrayBuffers
-} from '@loaders.gl/loader-utils';
+import {compareArrayBuffers, concatenateArrayBuffers} from '@loaders.gl/loader-utils';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
 import {parseEoCDRecord} from './end-of-central-directory';
 import {ZipSignature} from './search-from-the-end';
 import {createZip64Info, setFieldToNumber} from './zip64-info-generation';
+import {
+  DataViewReadableFile,
+  getReadableFileSize,
+  readDataView,
+  readRange
+} from './readable-file-utils';
 
 /**
  * zip central directory file header info
@@ -66,14 +68,13 @@ export const signature: ZipSignature = new Uint8Array([0x50, 0x4b, 0x01, 0x02]);
  */
 export const parseZipCDFileHeader = async (
   headerOffset: bigint,
-  file: FileProviderInterface
+  file: ReadableFile
 ): Promise<ZipCDFileHeader | null> => {
-  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, signature.buffer)) {
@@ -86,7 +87,8 @@ export const parseZipCDFileHeader = async (
   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)
   );
@@ -124,14 +126,14 @@ export const parseZipCDFileHeader = async (
 
 /**
  * Create iterator over files of zip archive
- * @param fileProvider - file provider that provider random access to the file
+ * @param fileProvider - readable file that provides random access to the file
  */
 export async function* makeZipCDHeaderIterator(
-  fileProvider: FileProviderInterface
+  fileProvider: ReadableFile
 ): AsyncIterable<ZipCDFileHeader> {
   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) {

package/src/parse-zip/end-of-central-directory.ts

@@ -2,12 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {
-  FileProviderInterface,
-  compareArrayBuffers,
-  concatenateArrayBuffers
-} from '@loaders.gl/loader-utils';
+import {compareArrayBuffers, concatenateArrayBuffers} from '@loaders.gl/loader-utils';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
 import {ZipSignature, searchFromTheEnd} from './search-from-the-end';
+import {readBigUint64, readUint16, readUint32, readRange} from './readable-file-utils';
 import {setFieldToNumber} from './zip64-info-generation';
 
 /**
@@ -65,33 +63,34 @@ const ZIP64_COMMENT_OFFSET = 56n;
 
 /**
  * Parses end of central directory record of zip file
- * @param file - FileProvider instance
+ * @param file - ReadableFile instance
  * @returns Info from the header
  */
-export const parseEoCDRecord = async (file: FileProviderInterface): Promise<ZipEoCDRecord> => {
+export const parseEoCDRecord = async (file: ReadableFile): Promise<ZipEoCDRecord> => {
   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;
   }

package/src/parse-zip/local-file-header.ts

@@ -2,13 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {
-  FileProviderInterface,
-  compareArrayBuffers,
-  concatenateArrayBuffers
-} from '@loaders.gl/loader-utils';
+import {compareArrayBuffers, concatenateArrayBuffers} from '@loaders.gl/loader-utils';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
 import {ZipSignature} from './search-from-the-end';
 import {createZip64Info, setFieldToNumber} from './zip64-info-generation';
+import {readDataView, readRange} from './readable-file-utils';
 
 /**
  * zip local file header info
@@ -47,12 +45,12 @@ export const signature: ZipSignature = new Uint8Array([0x50, 0x4b, 0x03, 0x04]);
  */
 export const parseZipLocalFileHeader = async (
   headerOffset: bigint,
-  file: FileProviderInterface
+  file: ReadableFile
 ): Promise<ZipLocalFileHeader | null> => {
-  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, signature)) {
+  if (!compareArrayBuffers(magicBytes, signature.buffer)) {
     return null;
   }
 
@@ -60,7 +58,8 @@ export const parseZipLocalFileHeader = async (
 
   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)
   );

package/src/parse-zip/readable-file-utils.ts

@@ -0,0 +1,134 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {copyToArrayBuffer, type ReadableFile, type Stat} from '@loaders.gl/loader-utils';
+
+function toBigInt(value: number | bigint): bigint {
+  return typeof value === 'bigint' ? value : BigInt(value);
+}
+
+function toNumber(value: number | bigint): number {
+  const numberValue = Number(value);
+  if (!Number.isFinite(numberValue)) {
+    throw new Error('Offset is out of bounds');
+  }
+  return numberValue;
+}
+
+function normalizeOffset(offset: number, size: number): number {
+  if (offset < 0) {
+    return Math.max(size + offset, 0);
+  }
+  return Math.min(offset, size);
+}
+
+/**
+ * Read a byte range from a readable file.
+ * @param file readable file handle
+ * @param start inclusive start offset
+ * @param end exclusive end offset
+ * @returns requested slice
+ */
+export async function readRange(
+  file: ReadableFile,
+  start: number | bigint,
+  end: number | bigint
+): Promise<ArrayBuffer> {
+  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));
+}
+
+export async function readDataView(
+  file: ReadableFile,
+  start: number | bigint,
+  end: number | bigint
+): Promise<DataView> {
+  const arrayBuffer = await readRange(file, start, end);
+  return new DataView(arrayBuffer);
+}
+
+export async function readUint8(file: ReadableFile, offset: number | bigint): Promise<number> {
+  const dataView = await readDataView(file, offset, toBigInt(offset) + 1n);
+  return dataView.getUint8(0);
+}
+
+export async function readUint16(file: ReadableFile, offset: number | bigint): Promise<number> {
+  const dataView = await readDataView(file, offset, toBigInt(offset) + 2n);
+  return dataView.getUint16(0, true);
+}
+
+export async function readUint32(file: ReadableFile, offset: number | bigint): Promise<number> {
+  const dataView = await readDataView(file, offset, toBigInt(offset) + 4n);
+  return dataView.getUint32(0, true);
+}
+
+export async function readBigUint64(file: ReadableFile, offset: number | bigint): Promise<bigint> {
+  const dataView = await readDataView(file, offset, toBigInt(offset) + 8n);
+  return dataView.getBigUint64(0, true);
+}
+
+/**
+ * Resolve the size of a readable file.
+ * @param file readable file handle
+ * @returns file size as bigint
+ */
+export async function getReadableFileSize(file: ReadableFile): Promise<bigint> {
+  if (file.bigsize > 0n) {
+    return file.bigsize;
+  }
+  if (file.size > 0) {
+    return BigInt(file.size);
+  }
+  if (file.stat) {
+    const stats: Stat = await file.stat();
+    if (stats?.bigsize !== undefined) {
+      return stats.bigsize;
+    }
+    if (stats?.size !== undefined) {
+      return BigInt(stats.size);
+    }
+  }
+  return 0n;
+}
+
+/**
+ * Minimal readable file backed by a DataView.
+ */
+export class DataViewReadableFile implements ReadableFile {
+  readonly handle: DataView;
+  readonly size: number;
+  readonly bigsize: bigint;
+  readonly url: string;
+
+  constructor(dataView: DataView, url: string = '') {
+    this.handle = dataView;
+    this.size = dataView.byteLength;
+    this.bigsize = BigInt(dataView.byteLength);
+    this.url = url;
+  }
+
+  async close(): Promise<void> {}
+
+  async stat(): Promise<Stat> {
+    return {size: this.size, bigsize: this.bigsize, isDirectory: false};
+  }
+
+  async read(start: number | bigint = 0, length?: number): Promise<ArrayBuffer> {
+    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 copyToArrayBuffer(this.handle.buffer, normalizedStart, lengthToRead);
+  }
+}

package/src/parse-zip/search-from-the-end.ts

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {FileProviderInterface} from '@loaders.gl/loader-utils';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
+import {getReadableFileSize, readRange} from './readable-file-utils';
 
 /** Description of zip signature type */
 export type ZipSignature = Uint8Array;
@@ -16,25 +17,22 @@ const buffLength = 1024;
  * @returns
  */
 export const searchFromTheEnd = async (
-  file: FileProviderInterface,
+  file: ReadableFile,
   target: ZipSignature
 ): Promise<bigint> => {
-  const searchWindow = [
-    await file.getUint8(file.length - 1n),
-    await file.getUint8(file.length - 2n),
-    await file.getUint8(file.length - 3n),
-    undefined
-  ];
+  const fileLength = await getReadableFileSize(file);
+  const lastBytes = new Uint8Array(await readRange(file, fileLength - 3n, fileLength + 1n));
+  const searchWindow = [lastBytes[3], lastBytes[2], lastBytes[1], undefined];
 
   let targetOffset = -1;
 
   // looking for the last record in the central directory
-  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];