@loaders.gl/zip 4.0.0-alpha.19 → 4.0.0-alpha.21

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipCDFileHeaderGenerator = exports.parseZipCDFileHeader = exports.signature = void 0;
+const end_of_central_directory_1 = require("./end-of-central-directory");
+// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)
+const CD_COMPRESSED_SIZE_OFFSET = 20n;
+const CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
+const CD_FILE_NAME_LENGTH_OFFSET = 28n;
+const CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;
+const CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;
+const CD_FILE_NAME_OFFSET = 46n;
+exports.signature = [0x50, 0x4b, 0x01, 0x02];
+/**
+ * Parses central directory file header of zip file
+ * @param headerOffset - offset in the archive where header starts
+ * @param buffer - buffer containing whole array
+ * @returns Info from the header
+ */
+const parseZipCDFileHeader = async (headerOffset, buffer) => {
+    if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(Buffer.from(exports.signature)) !== 0) {
+        return null;
+    }
+    let compressedSize = BigInt(await buffer.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));
+    let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + CD_UNCOMPRESSED_SIZE_OFFSET));
+    const extraFieldLength = await buffer.getUint16(headerOffset + CD_EXTRA_FIELD_LENGTH_OFFSET);
+    const fileNameLength = await buffer.getUint16(headerOffset + CD_FILE_NAME_LENGTH_OFFSET);
+    const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + CD_FILE_NAME_OFFSET, headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength)));
+    const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
+    const oldFormatOffset = await buffer.getUint32(headerOffset + CD_LOCAL_HEADER_OFFSET_OFFSET);
+    let fileDataOffset = BigInt(oldFormatOffset);
+    let offsetInZip64Data = 4n;
+    // looking for info that might be also be in zip64 extra field
+    if (uncompressedSize === BigInt(0xffffffff)) {
+        uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        offsetInZip64Data += 8n;
+    }
+    if (compressedSize === BigInt(0xffffffff)) {
+        compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        offsetInZip64Data += 8n;
+    }
+    if (fileDataOffset === BigInt(0xffffffff)) {
+        fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data); // setting it to the one from zip64
+    }
+    const localHeaderOffset = fileDataOffset;
+    return {
+        compressedSize,
+        uncompressedSize,
+        extraFieldLength,
+        fileNameLength,
+        fileName,
+        extraOffset,
+        localHeaderOffset
+    };
+};
+exports.parseZipCDFileHeader = parseZipCDFileHeader;
+/**
+ * Create iterator over files of zip archive
+ * @param fileProvider - file provider that provider random access to the file
+ */
+async function* zipCDFileHeaderGenerator(fileProvider) {
+    const { cdStartOffset } = await (0, end_of_central_directory_1.parseEoCDRecord)(fileProvider);
+    let cdHeader = await (0, exports.parseZipCDFileHeader)(cdStartOffset, fileProvider);
+    while (cdHeader) {
+        yield cdHeader;
+        cdHeader = await (0, exports.parseZipCDFileHeader)(cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength), fileProvider);
+    }
+}
+exports.zipCDFileHeaderGenerator = zipCDFileHeaderGenerator;

package/dist/parse-zip/end-of-central-directory.d.ts

@@ -0,0 +1,18 @@
+import { FileProvider } from '../file-provider/file-provider';
+/**
+ * End of central directory info
+ * according to https://en.wikipedia.org/wiki/ZIP_(file_format)
+ */
+export type ZipEoCDRecord = {
+    /** Relative offset of local file header */
+    cdStartOffset: bigint;
+    /** Relative offset of local file header */
+    cdRecordsNumber: bigint;
+};
+/**
+ * Parses end of central directory record of zip file
+ * @param fileProvider - FileProvider instance
+ * @returns Info from the header
+ */
+export declare const parseEoCDRecord: (fileProvider: FileProvider) => Promise<ZipEoCDRecord>;
+//# sourceMappingURL=end-of-central-directory.d.ts.map

package/dist/parse-zip/end-of-central-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"end-of-central-directory.d.ts","sourceRoot":"","sources":["../../src/parse-zip/end-of-central-directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AAG5D;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,2CAA2C;IAC3C,aAAa,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAaF;;;;GAIG;AACH,eAAO,MAAM,eAAe,iBAAwB,YAAY,KAAG,QAAQ,aAAa,CAwCvF,CAAC"}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEoCDRecord = void 0;
+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]);
+// 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
+ * @returns Info from the header
+ */
+const parseEoCDRecord = async (fileProvider) => {
+    const zipEoCDOffset = await (0, search_from_the_end_1.searchFromTheEnd)(fileProvider, eoCDSignature);
+    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 + 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 + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+        cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+    }
+    return {
+        cdRecordsNumber,
+        cdStartOffset
+    };
+};
+exports.parseEoCDRecord = parseEoCDRecord;

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { FileProvider } from '../file-provider/file-provider';
+/**
+ * zip local file header info
+ * according to https://en.wikipedia.org/wiki/ZIP_(file_format)
+ */
+export type ZipLocalFileHeader = {
+    /** File name length */
+    fileNameLength: number;
+    /** File name */
+    fileName: string;
+    /** Extra field length */
+    extraFieldLength: number;
+    /** Offset of the file data */
+    fileDataOffset: bigint;
+    /** Compressed size */
+    compressedSize: bigint;
+    /** Compression method */
+    compressionMethod: number;
+};
+export declare const signature: Buffer;
+/**
+ * Parses local file header of zip file
+ * @param headerOffset - offset in the archive where header starts
+ * @param buffer - buffer containing whole array
+ * @returns Info from the header
+ */
+export declare const parseZipLocalFileHeader: (headerOffset: bigint, buffer: FileProvider) => Promise<ZipLocalFileHeader | null>;
+//# sourceMappingURL=local-file-header.d.ts.map

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

@@ -0,0 +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,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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseZipLocalFileHeader = exports.signature = void 0;
+// 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
+ * @param headerOffset - offset in the archive where header starts
+ * @param buffer - buffer containing whole array
+ * @returns Info from the header
+ */
+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 + FILE_NAME_LENGTH_OFFSET);
+    const fileName = new TextDecoder()
+        .decode(await buffer.slice(headerOffset + FILE_NAME_OFFSET, headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength)))
+        .split('\\')
+        .join('/');
+    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)) {
+        uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        offsetInZip64Data += 8n;
+    }
+    if (compressedSize === BigInt(0xffffffff)) {
+        compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        offsetInZip64Data += 8n;
+    }
+    if (fileDataOffset === BigInt(0xffffffff)) {
+        fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data); // setting it to the one from zip64
+    }
+    return {
+        fileNameLength,
+        fileName,
+        extraFieldLength,
+        fileDataOffset,
+        compressedSize,
+        compressionMethod
+    };
+};
+exports.parseZipLocalFileHeader = parseZipLocalFileHeader;

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

@@ -0,0 +1,11 @@
+import { FileProvider } from '../file-provider/file-provider';
+/** Description of zip signature type */
+export type ZipSignature = [number, number, number, number];
+/**
+ * looking for the last occurrence of the provided
+ * @param file
+ * @param target
+ * @returns
+ */
+export declare const searchFromTheEnd: (file: FileProvider, target: ZipSignature) => Promise<bigint>;
+//# sourceMappingURL=search-from-the-end.d.ts.map

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

@@ -0,0 +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,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/dist/parse-zip/search-from-the-end.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchFromTheEnd = void 0;
+/**
+ * looking for the last occurrence of the provided
+ * @param file
+ * @param target
+ * @returns
+ */
+const searchFromTheEnd = async (file, target) => {
+    const searchWindow = [
+        await file.getUint8(file.length - 1n),
+        await file.getUint8(file.length - 2n),
+        await file.getUint8(file.length - 3n),
+        undefined
+    ];
+    let targetOffset = 0n;
+    // looking for the last record in the central directory
+    for (let i = file.length - 4n; i > -1; i--) {
+        searchWindow[3] = searchWindow[2];
+        searchWindow[2] = searchWindow[1];
+        searchWindow[1] = searchWindow[0];
+        searchWindow[0] = await file.getUint8(i);
+        if (searchWindow.every((val, index) => val === target[index])) {
+            targetOffset = i;
+            break;
+        }
+    }
+    return targetOffset;
+};
+exports.searchFromTheEnd = searchFromTheEnd;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/zip",
-  "version": "4.0.0-alpha.19",
+  "version": "4.0.0-alpha.21",
   "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.21",
     "jszip": "^3.1.5"
   },
-  "gitHead": "2ca50ec4e1d312c124eb7c93c60ab6fd17ee833e"
+  "peerDependencies": {
+    "@loaders.gl/core": "^4.0.0"
+  },
+  "gitHead": "df5d670b136192b26941396e944f9c46be788e83"
 }

package/src/file-provider/data-view-file.ts

@@ -0,0 +1,72 @@
+import {FileProvider} from './file-provider';
+
+/**
+ * Checks if bigint can be converted to number and convert it if possible
+ * @param bigint bigint to be converted
+ * @returns number
+ */
+const toNumber = (bigint: bigint) => {
+  if (bigint > Number.MAX_SAFE_INTEGER) {
+    throw new Error('Offset is out of bounds');
+  }
+  return Number(bigint);
+};
+
+/** Provides file data using DataView */
+export class DataViewFile implements FileProvider {
+  /** The DataView from which data is provided */
+  private file: DataView;
+
+  constructor(file: DataView) {
+    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.
+   */
+  async getUint8(offset: bigint): Promise<number> {
+    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: bigint): Promise<number> {
+    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: bigint): Promise<number> {
+    return this.file.getUint32(toNumber(offset), true);
+  }
+
+  /**
+   * 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: bigint): Promise<bigint> {
+    return this.file.getBigUint64(toNumber(offset), true);
+  }
+
+  /**
+   * 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: bigint, endOffset: bigint): Promise<ArrayBuffer> {
+    return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+  }
+
+  /** the length (in bytes) of the data. */
+  get length() {
+    return BigInt(this.file.byteLength);
+  }
+}

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/file-provider/file-provider.ts

@@ -0,0 +1,56 @@
+/**
+ * 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.
+   */
+  getUint8(offset: bigint): Promise<number>;
+
+  /**
+   * 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.
+   */
+  getUint16(offset: bigint): Promise<number>;
+
+  /**
+   * 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 file of the view where to read the data.
+   */
+  getUint32(offset: bigint): Promise<number>;
+
+  /**
+   * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
+   * @param offset The offset, in byte, from the file of the view where to read the data.
+   */
+  getBigUint64(offset: bigint): Promise<bigint>;
+
+  /**
+   * 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.
+   */
+  slice(startOffset: bigint, endOffset: bigint): Promise<ArrayBuffer>;
+
+  /**
+   * the length (in bytes) of the data.
+   */
+  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
+  );
+};