@loaders.gl/zip 4.0.0-alpha.20 → 4.0.0-alpha.22

package/dist/parse-zip/end-of-central-directory.js

@@ -5,13 +5,12 @@ const search_from_the_end_1 = require("./search-from-the-end");
 const eoCDSignature = [0x50, 0x4b, 0x05, 0x06];
 const zip64EoCDLocatorSignature = Buffer.from([0x50, 0x4b, 0x06, 0x07]);
 const zip64EoCDSignature = Buffer.from([0x50, 0x4b, 0x06, 0x06]);
-const offsets = {
-    CD_RECORDS_NUMBER_OFFSET: 8n,
-    CD_START_OFFSET_OFFSET: 16n,
-    ZIP64_EOCD_START_OFFSET_OFFSET: 8n,
-    ZIP64_CD_RECORDS_NUMBER_OFFSET: 24n,
-    ZIP64_CD_START_OFFSET_OFFSET: 48n
-};
+// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)
+const CD_RECORDS_NUMBER_OFFSET = 8n;
+const CD_START_OFFSET_OFFSET = 16n;
+const ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
+const ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+const ZIP64_CD_START_OFFSET_OFFSET = 48n;
 /**
  * Parses end of central directory record of zip file
  * @param fileProvider - FileProvider instance
@@ -19,19 +18,19 @@ const offsets = {
  */
 const parseEoCDRecord = async (fileProvider) => {
     const zipEoCDOffset = await (0, search_from_the_end_1.searchFromTheEnd)(fileProvider, eoCDSignature);
-    let cdRecordsNumber = BigInt(await fileProvider.getUint16(zipEoCDOffset + offsets.CD_RECORDS_NUMBER_OFFSET));
-    let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + offsets.CD_START_OFFSET_OFFSET));
+    let cdRecordsNumber = BigInt(await fileProvider.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
+    let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
     if (cdStartOffset === BigInt(0xffffffff) || cdRecordsNumber === BigInt(0xffffffff)) {
         const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
         if (Buffer.from(await fileProvider.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n)).compare(zip64EoCDLocatorSignature) !== 0) {
             throw new Error('zip64 EoCD locator not found');
         }
-        const zip64EoCDOffset = await fileProvider.getBigUint64(zip64EoCDLocatorOffset + offsets.ZIP64_EOCD_START_OFFSET_OFFSET);
+        const zip64EoCDOffset = await fileProvider.getBigUint64(zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET);
         if (Buffer.from(await fileProvider.slice(zip64EoCDOffset, zip64EoCDOffset + 4n)).compare(zip64EoCDSignature) !== 0) {
             throw new Error('zip64 EoCD not found');
         }
-        cdRecordsNumber = await fileProvider.getBigUint64(zip64EoCDOffset + offsets.ZIP64_CD_RECORDS_NUMBER_OFFSET);
-        cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + offsets.ZIP64_CD_START_OFFSET_OFFSET);
+        cdRecordsNumber = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+        cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
     }
     return {
         cdRecordsNumber,

package/dist/parse-zip/local-file-header.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { FileProvider } from './file-provider';
+import { FileProvider } from '../file-provider/file-provider';
 /**
  * zip local file header info
  * according to https://en.wikipedia.org/wiki/ZIP_(file_format)
@@ -15,6 +15,8 @@ export type ZipLocalFileHeader = {
     fileDataOffset: bigint;
     /** Compressed size */
     compressedSize: bigint;
+    /** Compression method */
+    compressionMethod: number;
 };
 export declare const signature: Buffer;
 /**

package/dist/parse-zip/local-file-header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-file-header.d.ts","sourceRoot":"","sources":["../../src/parse-zip/local-file-header.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,uBAAuB;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,yBAAyB;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,sBAAsB;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAUF,eAAO,MAAM,SAAS,QAAwC,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,iBACpB,MAAM,UACZ,YAAY,KACnB,QAAQ,kBAAkB,GAAG,IAAI,CAoDnC,CAAC"}
+{"version":3,"file":"local-file-header.d.ts","sourceRoot":"","sources":["../../src/parse-zip/local-file-header.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AAE5D;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,uBAAuB;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,yBAAyB;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,sBAAsB;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,yBAAyB;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAUF,eAAO,MAAM,SAAS,QAAwC,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,iBACpB,MAAM,UACZ,YAAY,KACnB,QAAQ,kBAAkB,GAAG,IAAI,CAkDnC,CAAC"}

package/dist/parse-zip/local-file-header.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseZipLocalFileHeader = exports.signature = void 0;
-const offsets = {
-    COMPRESSED_SIZE_OFFSET: 18n,
-    UNCOMPRESSED_SIZE_OFFSET: 22n,
-    FILE_NAME_LENGTH_OFFSET: 26n,
-    EXTRA_FIELD_LENGTH_OFFSET: 28n,
-    FILE_NAME_OFFSET: 30n
-};
+// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)
+const COMPRESSION_METHOD_OFFSET = 8n;
+const COMPRESSED_SIZE_OFFSET = 18n;
+const UNCOMPRESSED_SIZE_OFFSET = 22n;
+const FILE_NAME_LENGTH_OFFSET = 26n;
+const EXTRA_FIELD_LENGTH_OFFSET = 28n;
+const FILE_NAME_OFFSET = 30n;
 exports.signature = Buffer.from([0x50, 0x4b, 0x03, 0x04]);
 /**
  * Parses local file header of zip file
@@ -19,16 +19,17 @@ const parseZipLocalFileHeader = async (headerOffset, buffer) => {
     if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(exports.signature) !== 0) {
         return null;
     }
-    const fileNameLength = await buffer.getUint16(headerOffset + offsets.FILE_NAME_LENGTH_OFFSET);
+    const fileNameLength = await buffer.getUint16(headerOffset + FILE_NAME_LENGTH_OFFSET);
     const fileName = new TextDecoder()
-        .decode(await buffer.slice(headerOffset + offsets.FILE_NAME_OFFSET, headerOffset + offsets.FILE_NAME_OFFSET + BigInt(fileNameLength)))
+        .decode(await buffer.slice(headerOffset + FILE_NAME_OFFSET, headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength)))
         .split('\\')
         .join('/');
-    const extraFieldLength = await buffer.getUint16(headerOffset + offsets.EXTRA_FIELD_LENGTH_OFFSET);
-    let fileDataOffset = headerOffset + offsets.FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
-    let compressedSize = BigInt(await buffer.getUint32(headerOffset + offsets.COMPRESSED_SIZE_OFFSET)); // add zip 64 logic
-    let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + offsets.UNCOMPRESSED_SIZE_OFFSET)); // add zip 64 logic
-    const extraOffset = headerOffset + offsets.FILE_NAME_OFFSET + BigInt(fileNameLength);
+    const extraFieldLength = await buffer.getUint16(headerOffset + EXTRA_FIELD_LENGTH_OFFSET);
+    let fileDataOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
+    const compressionMethod = await buffer.getUint16(headerOffset + COMPRESSION_METHOD_OFFSET);
+    let compressedSize = BigInt(await buffer.getUint32(headerOffset + COMPRESSED_SIZE_OFFSET)); // add zip 64 logic
+    let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET)); // add zip 64 logic
+    const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);
     let offsetInZip64Data = 4n;
     // looking for info that might be also be in zip64 extra field
     if (uncompressedSize === BigInt(0xffffffff)) {
@@ -47,7 +48,8 @@ const parseZipLocalFileHeader = async (headerOffset, buffer) => {
         fileName,
         extraFieldLength,
         fileDataOffset,
-        compressedSize
+        compressedSize,
+        compressionMethod
     };
 };
 exports.parseZipLocalFileHeader = parseZipLocalFileHeader;

package/dist/parse-zip/search-from-the-end.d.ts

@@ -1,4 +1,4 @@
-import { FileProvider } from './file-provider';
+import { FileProvider } from '../file-provider/file-provider';
 /** Description of zip signature type */
 export type ZipSignature = [number, number, number, number];
 /**

package/dist/parse-zip/search-from-the-end.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-from-the-end.d.ts","sourceRoot":"","sources":["../../src/parse-zip/search-from-the-end.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAE7C,wCAAwC;AACxC,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,SACrB,YAAY,2BAEjB,QAAQ,MAAM,CAuBhB,CAAC"}
+{"version":3,"file":"search-from-the-end.d.ts","sourceRoot":"","sources":["../../src/parse-zip/search-from-the-end.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AAE5D,wCAAwC;AACxC,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,SACrB,YAAY,2BAEjB,QAAQ,MAAM,CAuBhB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/zip",
-  "version": "4.0.0-alpha.20",
+  "version": "4.0.0-alpha.22",
   "description": "Zip Archive Loader",
   "license": "MIT",
   "publishConfig": {
@@ -25,12 +25,19 @@
     "dist",
     "README.md"
   ],
+  "browser": {
+    "fs": false
+  },
   "scripts": {
     "pre-build": "npm run build-bundle",
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
   },
   "dependencies": {
+    "@loaders.gl/compression": "4.0.0-alpha.22",
     "jszip": "^3.1.5"
   },
-  "gitHead": "ac122e83102657c38207d59c631a5ce4e7aa46bd"
+  "peerDependencies": {
+    "@loaders.gl/core": "^4.0.0-alpha.21"
+  },
+  "gitHead": "0da838c506d1275383f2fd3d244d9c72b25397d2"
 }

package/src/{parse-zip → file-provider}/data-view-file.ts

@@ -21,6 +21,9 @@ export class DataViewFile implements FileProvider {
     this.file = file;
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async destroy(): Promise<void> {}
+
   /**
    * 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.

package/src/file-provider/file-handle-file.ts

@@ -0,0 +1,114 @@
+import {FileProvider} from '@loaders.gl/zip';
+import {FileHandle} from './file-handle';
+
+/**
+ * Provides file data using node fs library
+ */
+export class FileHandleFile implements FileProvider {
+  /**
+   * Returns a new copy of FileHandleFile
+   * @param path The path to the file in file system
+   */
+  static async from(path: string): Promise<FileHandleFile> {
+    const fileDescriptor = await FileHandle.open(path);
+    return new FileHandleFile(fileDescriptor, fileDescriptor.stat.size);
+  }
+
+  /**
+   * The FileHandle from which data is provided
+   */
+  private fileDescriptor: FileHandle;
+
+  /**
+   * The file length in bytes
+   */
+  private size: bigint;
+
+  private constructor(fileDescriptor: FileHandle, size: bigint) {
+    this.fileDescriptor = fileDescriptor;
+    this.size = size;
+  }
+
+  /** Close file */
+  async destroy(): Promise<void> {
+    await this.fileDescriptor.close();
+  }
+
+  /**
+   * 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: bigint): Promise<number> {
+    const val = new Uint8Array(
+      (await this.fileDescriptor.read(Buffer.alloc(1), 0, 1, offset)).buffer.buffer
+    ).at(0);
+    if (val === undefined) {
+      throw new Error('something went wrong');
+    }
+    return val;
+  }
+
+  /**
+   * 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: bigint): Promise<number> {
+    const val = new Uint16Array(
+      (await this.fileDescriptor.read(Buffer.alloc(2), 0, 2, offset)).buffer.buffer
+    ).at(0);
+    if (val === undefined) {
+      throw new Error('something went wrong');
+    }
+    return val;
+  }
+
+  /**
+   * 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: bigint): Promise<number> {
+    const val = new Uint32Array(
+      (await this.fileDescriptor.read(Buffer.alloc(4), 0, 4, offset)).buffer.buffer
+    ).at(0);
+    if (val === undefined) {
+      throw new Error('something went wrong');
+    }
+    return val;
+  }
+
+  /**
+   * 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: bigint): Promise<bigint> {
+    const val = new BigInt64Array(
+      (await this.fileDescriptor.read(Buffer.alloc(8), 0, 8, offset)).buffer.buffer
+    ).at(0);
+    if (val === undefined) {
+      throw new Error('something went wrong');
+    }
+    return val;
+  }
+
+  /**
+   * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
+   * @param startOffsset 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(startOffsset: bigint, endOffset: bigint): Promise<ArrayBuffer> {
+    const bigLength = endOffset - startOffsset;
+    if (bigLength > Number.MAX_SAFE_INTEGER) {
+      throw new Error('too big slice');
+    }
+    const length = Number(bigLength);
+    return (await this.fileDescriptor.read(Buffer.alloc(length), 0, length, startOffsset)).buffer
+      .buffer;
+  }
+
+  /**
+   * the length (in bytes) of the data.
+   */
+  get length(): bigint {
+    return this.size;
+  }
+}

package/src/file-provider/file-handle.ts

@@ -0,0 +1,73 @@
+import {read, open, close, stat, BigIntStats} from 'fs';
+
+/** file reading result */
+export type FileReadResult = {
+  /** amount of the bytes read */
+  bytesRead: number;
+  /** the buffer filled with data from file*/
+  buffer: Buffer;
+};
+
+/** Object handling file info */
+export class FileHandle {
+  private fileDescriptor: number;
+  private stats: BigIntStats;
+  private constructor(fileDescriptor: number, stats: BigIntStats) {
+    this.fileDescriptor = fileDescriptor;
+    this.stats = stats;
+  }
+  /**
+   * Opens a `FileHandle`.
+   *
+   * @param path path to the file
+   * @return Fulfills with a {FileHandle} object.
+   */
+
+  static open = async (path: string): Promise<FileHandle> => {
+    const [fd, stats] = await Promise.all([
+      new Promise<number>((s) => {
+        open(path, undefined, undefined, (_err, fd) => s(fd));
+      }),
+      new Promise<BigIntStats>((s) => {
+        stat(path, {bigint: true}, (_err, stats) => s(stats));
+      })
+    ]);
+    return new FileHandle(fd, stats);
+  };
+
+  /** Close file */
+  async close(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      close(this.fileDescriptor, (_err) => resolve());
+    });
+  }
+
+  /**
+   * Reads data from the file and stores that in the given buffer.
+   *
+   * If the file is not modified concurrently, the end-of-file is reached when the
+   * number of bytes read is zero.
+   * @param buffer A buffer that will be filled with the file data read.
+   * @param offset The location in the buffer at which to start filling.
+   * @param length The number of bytes to read.
+   * @param position The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an
+   * integer, the current file position will remain unchanged.
+   * @return Fulfills upon success with a FileReadResult object
+   */
+  read = (
+    buffer: Buffer,
+    offset: number,
+    length: number,
+    position: number | bigint
+  ): Promise<FileReadResult> => {
+    return new Promise((s) => {
+      read(this.fileDescriptor, buffer, offset, length, position, (_err, bytesRead, buffer) =>
+        s({bytesRead, buffer})
+      );
+    });
+  };
+
+  get stat(): BigIntStats {
+    return this.stats;
+  }
+}

package/src/{parse-zip → file-provider}/file-provider.ts

@@ -2,6 +2,10 @@
  * Interface for providing file data
  */
 export interface FileProvider {
+  /**
+   * Cleanup class data
+   */
+  destroy(): Promise<void>;
   /**
    * 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.
@@ -38,3 +42,15 @@ export interface FileProvider {
    */
   length: bigint;
 }
+
+/**
+ * Check is the object has FileProvider members
+ * @param fileProvider - tested object
+ */
+export const isFileProvider = (fileProvider: unknown) => {
+  return (
+    (fileProvider as FileProvider)?.getUint8 &&
+    (fileProvider as FileProvider)?.slice &&
+    (fileProvider as FileProvider)?.length
+  );
+};

package/src/filesystems/zip-filesystem.ts

@@ -0,0 +1,142 @@
+import {FileSystem, isBrowser} from '@loaders.gl/core';
+import {FileProvider, isFileProvider} from '../file-provider/file-provider';
+import {FileHandleFile} from '../file-provider/file-handle-file';
+import {ZipCDFileHeader, zipCDFileHeaderGenerator} from '../parse-zip/cd-file-header';
+import {parseZipLocalFileHeader} from '../parse-zip/local-file-header';
+import {DeflateCompression} from '@loaders.gl/compression';
+
+type CompressionHandler = (compressedFile: ArrayBuffer) => Promise<ArrayBuffer>;
+/** Handling different compression types in zip */
+const COMPRESSION_METHODS: {[key: number]: CompressionHandler} = {
+  /** No compression */
+  0: async (compressedFile) => compressedFile,
+  /** Deflation */
+  8: async (compressedFile) => {
+    const compression = new DeflateCompression({raw: true});
+    const decompressedData = await compression.decompress(compressedFile);
+    return decompressedData;
+  }
+};
+
+/**
+ * FileSystem adapter for a ZIP file
+ * Holds FileProvider object that provides random access to archived files
+ */
+export class ZipFileSystem implements FileSystem {
+  /** FileProvider instance promise */
+  protected fileProvider: Promise<FileProvider | null> = Promise.resolve(null);
+  public fileName?: string;
+
+  /**
+   * Constructor
+   * @param file - instance of FileProvider or file path string
+   */
+  constructor(file: FileProvider | string) {
+    // Try to open file in NodeJS
+    if (typeof file === 'string') {
+      this.fileName = file;
+      if (!isBrowser) {
+        this.fileProvider = FileHandleFile.from(file);
+      } else {
+        throw new Error('Cannot open file for random access in a WEB browser');
+      }
+    } else if (isFileProvider(file)) {
+      this.fileProvider = Promise.resolve(file);
+    }
+  }
+
+  /** Clean up resources */
+  async destroy() {
+    const fileProvider = await this.fileProvider;
+    if (fileProvider) {
+      await fileProvider.destroy();
+    }
+  }
+
+  /**
+   * Get file names list from zip archive
+   * @returns array of file names
+   */
+  async readdir(): Promise<string[]> {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error('No data detected in the zip archive');
+    }
+    const fileNames: string[] = [];
+    const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+    for await (const cdHeader of zipCDIterator) {
+      fileNames.push(cdHeader.fileName);
+    }
+    return fileNames;
+  }
+
+  /**
+   * Get file metadata
+   * @param filename - name of a file
+   * @returns central directory data
+   */
+  async stat(filename: string): Promise<ZipCDFileHeader & {size: number}> {
+    const cdFileHeader = await this.getCDFileHeader(filename);
+    return {...cdFileHeader, size: Number(cdFileHeader.uncompressedSize)};
+  }
+
+  /**
+   * Implementation of fetch against this file system
+   * @param filename - name of a file
+   * @returns - Response with file data
+   */
+  async fetch(filename: string): Promise<Response> {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error('No data detected in the zip archive');
+    }
+    const cdFileHeader = await this.getCDFileHeader(filename);
+    const localFileHeader = await parseZipLocalFileHeader(
+      cdFileHeader.localHeaderOffset,
+      fileProvider
+    );
+    if (!localFileHeader) {
+      throw new Error('Local file header has not been found in the zip archive`');
+    }
+
+    const compressionHandler = COMPRESSION_METHODS[localFileHeader.compressionMethod.toString()];
+    if (!compressionHandler) {
+      throw Error('Only Deflation compression is supported');
+    }
+
+    const compressedFile = await fileProvider.slice(
+      localFileHeader.fileDataOffset,
+      localFileHeader.fileDataOffset + localFileHeader.compressedSize
+    );
+
+    const uncompressedFile = await compressionHandler(compressedFile);
+
+    const response = new Response(uncompressedFile);
+    Object.defineProperty(response, 'url', {value: `${this.fileName || ''}/${filename}`});
+    return response;
+  }
+
+  /**
+   * Get central directory file header
+   * @param filename - name of a file
+   * @returns central directory file header
+   */
+  private async getCDFileHeader(filename: string): Promise<ZipCDFileHeader> {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error('No data detected in the zip archive');
+    }
+    const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+    let result: ZipCDFileHeader | null = null;
+    for await (const cdHeader of zipCDIterator) {
+      if (cdHeader.fileName === filename) {
+        result = cdHeader;
+        break;
+      }
+    }
+    if (!result) {
+      throw new Error('File has not been found in the zip archive');
+    }
+    return result;
+  }
+}

package/src/hash-file-utility.ts

@@ -1,3 +1,7 @@
+import md5 from 'md5';
+import {zipCDFileHeaderGenerator} from './parse-zip/cd-file-header';
+import {FileProvider} from './file-provider/file-provider';
+
 /** Element of hash array */
 export type HashElement = {
   /** File name hash */
@@ -77,3 +81,21 @@ export const findBin = (
   }
   return undefined;
 };
+
+/**
+ * generates hash info from central directory
+ * @param fileProvider - provider of the archive
+ * @returns ready to use hash info
+ */
+export const generateHashInfo = async (fileProvider: FileProvider): Promise<HashElement[]> => {
+  const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+  const hashInfo: HashElement[] = [];
+  for await (const cdHeader of zipCDIterator) {
+    hashInfo.push({
+      hash: Buffer.from(md5(cdHeader.fileName.split('\\').join('/').toLocaleLowerCase()), 'hex'),
+      offset: cdHeader.localHeaderOffset
+    });
+  }
+  hashInfo.sort((a, b) => compareHashes(a.hash, b.hash));
+  return hashInfo;
+};

package/src/index.ts

@@ -2,15 +2,23 @@ export {ZipLoader} from './zip-loader';
 export {ZipWriter} from './zip-writer';
 export {default as TarBuilder} from './tar-builder';
 
-export type {FileProvider} from './parse-zip/file-provider';
-export {parseZipCDFileHeader, signature as cdSignature} from './parse-zip/cd-file-header';
+export type {FileProvider} from './file-provider/file-provider';
+export {FileHandleFile} from './file-provider/file-handle-file';
+export {DataViewFile} from './file-provider/data-view-file';
+
+export {
+  parseZipCDFileHeader,
+  zipCDFileHeaderGenerator,
+  signature as cdSignature
+} from './parse-zip/cd-file-header';
 export {
   parseZipLocalFileHeader,
   signature as localHeaderSignature
 } 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 {DataViewFile} from './parse-zip/data-view-file';
 
 export type {HashElement} from './hash-file-utility';
-export {compareHashes, parseHashFile, findBin} from './hash-file-utility';
+export {compareHashes, parseHashFile, findBin, generateHashInfo} from './hash-file-utility';
+
+export {ZipFileSystem} from './filesystems/zip-filesystem';