@loaders.gl/zip 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/index.cjs

@@ -0,0 +1,653 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TarBuilder: () => TarBuilder,
+  ZipFileSystem: () => ZipFileSystem,
+  ZipLoader: () => ZipLoader,
+  ZipWriter: () => ZipWriter,
+  cdSignature: () => signature,
+  localHeaderSignature: () => signature2,
+  makeHashTableFromZipHeaders: () => makeHashTableFromZipHeaders,
+  makeZipCDHeaderIterator: () => makeZipCDHeaderIterator,
+  parseEoCDRecord: () => parseEoCDRecord,
+  parseHashTable: () => parseHashTable,
+  parseZipCDFileHeader: () => parseZipCDFileHeader,
+  parseZipLocalFileHeader: () => parseZipLocalFileHeader,
+  searchFromTheEnd: () => searchFromTheEnd
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/zip-loader.ts
+var import_jszip = __toESM(require("jszip"), 1);
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var ZipLoader = {
+  id: "zip",
+  module: "zip",
+  name: "Zip Archive",
+  version: VERSION,
+  extensions: ["zip"],
+  mimeTypes: ["application/zip"],
+  category: "archive",
+  tests: ["PK"],
+  options: {},
+  parse: parseZipAsync
+};
+async function parseZipAsync(data, options = {}) {
+  const promises = [];
+  const fileMap = {};
+  try {
+    const jsZip = new import_jszip.default();
+    const zip = await jsZip.loadAsync(data, options);
+    zip.forEach((relativePath, zipEntry) => {
+      const subFilename = zipEntry.name;
+      const promise = loadZipEntry(jsZip, subFilename, options).then((arrayBufferOrError) => {
+        fileMap[relativePath] = arrayBufferOrError;
+      });
+      promises.push(promise);
+    });
+    await Promise.all(promises);
+    return fileMap;
+  } catch (error) {
+    options.log.error(`Unable to read zip archive: ${error}`);
+    throw error;
+  }
+}
+async function loadZipEntry(jsZip, subFilename, options = {}) {
+  try {
+    const arrayBuffer = await jsZip.file(subFilename).async(options.dataType || "arraybuffer");
+    return arrayBuffer;
+  } catch (error) {
+    options.log.error(`Unable to read ${subFilename} from zip archive: ${error}`);
+    return error;
+  }
+}
+
+// src/zip-writer.ts
+var import_jszip2 = __toESM(require("jszip"), 1);
+var ZipWriter = {
+  name: "Zip Archive",
+  extensions: ["zip"],
+  category: "archive",
+  mimeTypes: ["application/zip"],
+  // @ts-ignore
+  encode: encodeZipAsync
+};
+async function encodeZipAsync(fileMap, options = {}) {
+  const jsZip = new import_jszip2.default();
+  for (const subFileName in fileMap) {
+    const subFileData = fileMap[subFileName];
+    jsZip.file(subFileName, subFileData, (options == null ? void 0 : options.jszip) || {});
+  }
+  const jszipOptions = { ...options == null ? void 0 : options.jszip, type: "arraybuffer" };
+  const { onUpdate = () => {
+  } } = options;
+  try {
+    return await jsZip.generateAsync(jszipOptions, onUpdate);
+  } catch (error) {
+    options.log.error(`Unable to write zip archive: ${error}`);
+    throw error;
+  }
+}
+
+// src/lib/tar/utils.ts
+function clean(length) {
+  let i;
+  const buffer = new Uint8Array(length);
+  for (i = 0; i < length; i += 1) {
+    buffer[i] = 0;
+  }
+  return buffer;
+}
+function pad(num, bytes, base) {
+  const numStr = num.toString(base || 8);
+  return "000000000000".substr(numStr.length + 12 - bytes) + numStr;
+}
+function stringToUint8(input, out, offset) {
+  let i;
+  let length;
+  out = out || clean(input.length);
+  offset = offset || 0;
+  for (i = 0, length = input.length; i < length; i += 1) {
+    out[offset] = input.charCodeAt(i);
+    offset += 1;
+  }
+  return out;
+}
+
+// src/lib/tar/header.ts
+var structure = {
+  fileName: 100,
+  fileMode: 8,
+  uid: 8,
+  gid: 8,
+  fileSize: 12,
+  mtime: 12,
+  checksum: 8,
+  type: 1,
+  linkName: 100,
+  ustar: 8,
+  owner: 32,
+  group: 32,
+  majorNumber: 8,
+  minorNumber: 8,
+  filenamePrefix: 155,
+  padding: 12
+};
+function format(data, cb) {
+  const buffer = clean(512);
+  let offset = 0;
+  Object.entries(structure).forEach(([field, length]) => {
+    const str = data[field] || "";
+    let i;
+    let fieldLength;
+    for (i = 0, fieldLength = str.length; i < fieldLength; i += 1) {
+      buffer[offset] = str.charCodeAt(i);
+      offset += 1;
+    }
+    offset += length - i;
+  });
+  if (typeof cb === "function") {
+    return cb(buffer, offset);
+  }
+  return buffer;
+}
+
+// src/lib/tar/tar.ts
+var blockSize;
+var headerLength;
+var inputLength;
+var recordSize = 512;
+var Tar = class {
+  /**
+   * @param [recordsPerBlock]
+   */
+  constructor(recordsPerBlock) {
+    this.blocks = [];
+    this.written = 0;
+    blockSize = (recordsPerBlock || 20) * recordSize;
+    this.out = clean(blockSize);
+    this.blocks = [];
+    this.length = 0;
+    this.save = this.save.bind(this);
+    this.clear = this.clear.bind(this);
+    this.append = this.append.bind(this);
+  }
+  /**
+   * Append a file to the tar archive
+   * @param filepath
+   * @param input
+   * @param [opts]
+   */
+  // eslint-disable-next-line complexity
+  append(filepath, input, opts) {
+    let checksum;
+    if (typeof input === "string") {
+      input = stringToUint8(input);
+    } else if (input.constructor && input.constructor !== Uint8Array.prototype.constructor) {
+      const errorInputMatch = /function\s*([$A-Za-z_][0-9A-Za-z_]*)\s*\(/.exec(
+        input.constructor.toString()
+      );
+      const errorInput = errorInputMatch && errorInputMatch[1];
+      const errorMessage = `Invalid input type. You gave me: ${errorInput}`;
+      throw errorMessage;
+    }
+    opts = opts || {};
+    const mode = opts.mode || parseInt("777", 8) & 4095;
+    const mtime = opts.mtime || Math.floor(Number(new Date()) / 1e3);
+    const uid = opts.uid || 0;
+    const gid = opts.gid || 0;
+    const data = {
+      fileName: filepath,
+      fileMode: pad(mode, 7),
+      uid: pad(uid, 7),
+      gid: pad(gid, 7),
+      fileSize: pad(input.length, 11),
+      mtime: pad(mtime, 11),
+      checksum: "        ",
+      // 0 = just a file
+      type: "0",
+      ustar: "ustar  ",
+      owner: opts.owner || "",
+      group: opts.group || ""
+    };
+    checksum = 0;
+    Object.keys(data).forEach((key) => {
+      let i;
+      const value = data[key];
+      let length;
+      for (i = 0, length = value.length; i < length; i += 1) {
+        checksum += value.charCodeAt(i);
+      }
+    });
+    data.checksum = `${pad(checksum, 6)}\0 `;
+    const headerArr = format(data);
+    headerLength = Math.ceil(headerArr.length / recordSize) * recordSize;
+    inputLength = Math.ceil(input.length / recordSize) * recordSize;
+    this.blocks.push({
+      header: headerArr,
+      input,
+      headerLength,
+      inputLength
+    });
+  }
+  /**
+   * Compiling data to a Blob object
+   * @returns {Blob}
+   */
+  save() {
+    const buffers = [];
+    const chunks = new Array();
+    let length = 0;
+    const max = Math.pow(2, 20);
+    let chunk = new Array();
+    this.blocks.forEach((b = []) => {
+      if (length + b.headerLength + b.inputLength > max) {
+        chunks.push({ blocks: chunk, length });
+        chunk = [];
+        length = 0;
+      }
+      chunk.push(b);
+      length += b.headerLength + b.inputLength;
+    });
+    chunks.push({ blocks: chunk, length });
+    chunks.forEach((c = []) => {
+      const buffer = new Uint8Array(c.length);
+      let written = 0;
+      c.blocks.forEach((b = []) => {
+        buffer.set(b.header, written);
+        written += b.headerLength;
+        buffer.set(b.input, written);
+        written += b.inputLength;
+      });
+      buffers.push(buffer);
+    });
+    buffers.push(new Uint8Array(2 * recordSize));
+    return new Blob(buffers, { type: "octet/stream" });
+  }
+  /**
+   * Clear the data by its blocksize
+   */
+  clear() {
+    this.written = 0;
+    this.out = clean(blockSize);
+  }
+};
+var tar_default = Tar;
+
+// src/tar-builder.ts
+var TAR_BUILDER_OPTIONS = {
+  recordsPerBlock: 20
+};
+var TarBuilder = class {
+  constructor(options) {
+    this.count = 0;
+    this.options = { ...TAR_BUILDER_OPTIONS, ...options };
+    this.tape = new tar_default(this.options.recordsPerBlock);
+  }
+  static get properties() {
+    return {
+      id: "tar",
+      name: "TAR",
+      extensions: ["tar"],
+      mimeTypes: ["application/x-tar"],
+      builder: TarBuilder,
+      options: TAR_BUILDER_OPTIONS
+    };
+  }
+  /** Adds a file to the archive. */
+  addFile(filename, buffer) {
+    this.tape.append(filename, new Uint8Array(buffer));
+    this.count++;
+  }
+  async build() {
+    return new Response(this.tape.save()).arrayBuffer();
+  }
+};
+
+// src/parse-zip/cd-file-header.ts
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
+
+// src/parse-zip/end-of-central-directory.ts
+var import_loader_utils = require("@loaders.gl/loader-utils");
+
+// src/parse-zip/search-from-the-end.ts
+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
+  ];
+  let targetOffset = 0n;
+  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;
+};
+
+// src/parse-zip/end-of-central-directory.ts
+var eoCDSignature = new Uint8Array([80, 75, 5, 6]);
+var zip64EoCDLocatorSignature = new Uint8Array([80, 75, 6, 7]);
+var zip64EoCDSignature = new Uint8Array([80, 75, 6, 6]);
+var CD_RECORDS_NUMBER_OFFSET = 8n;
+var CD_START_OFFSET_OFFSET = 16n;
+var ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
+var ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+var ZIP64_CD_START_OFFSET_OFFSET = 48n;
+var parseEoCDRecord = async (file) => {
+  const zipEoCDOffset = await searchFromTheEnd(file, eoCDSignature);
+  let cdRecordsNumber = BigInt(await file.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
+  let cdStartOffset = BigInt(await file.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
+  if (cdStartOffset === BigInt(4294967295) || cdRecordsNumber === BigInt(4294967295)) {
+    const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+    const magicBytes = await file.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
+    if (!(0, import_loader_utils.compareArrayBuffers)(magicBytes, zip64EoCDLocatorSignature)) {
+      throw new Error("zip64 EoCD locator not found");
+    }
+    const zip64EoCDOffset = await file.getBigUint64(
+      zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
+    );
+    const endOfCDMagicBytes = await file.slice(zip64EoCDOffset, zip64EoCDOffset + 4n);
+    if (!(0, import_loader_utils.compareArrayBuffers)(endOfCDMagicBytes, zip64EoCDSignature.buffer)) {
+      throw new Error("zip64 EoCD not found");
+    }
+    cdRecordsNumber = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+    cdStartOffset = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+  }
+  return {
+    cdRecordsNumber,
+    cdStartOffset
+  };
+};
+
+// src/parse-zip/cd-file-header.ts
+var CD_COMPRESSED_SIZE_OFFSET = 20n;
+var CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
+var CD_FILE_NAME_LENGTH_OFFSET = 28n;
+var CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;
+var CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;
+var CD_FILE_NAME_OFFSET = 46n;
+var signature = new Uint8Array([80, 75, 1, 2]);
+var parseZipCDFileHeader = async (headerOffset, file) => {
+  const magicBytes = await file.slice(headerOffset, headerOffset + 4n);
+  if (!(0, import_loader_utils2.compareArrayBuffers)(magicBytes, signature.buffer)) {
+    return null;
+  }
+  let compressedSize = BigInt(await file.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));
+  let uncompressedSize = BigInt(await file.getUint32(headerOffset + CD_UNCOMPRESSED_SIZE_OFFSET));
+  const extraFieldLength = await file.getUint16(headerOffset + CD_EXTRA_FIELD_LENGTH_OFFSET);
+  const fileNameLength = await file.getUint16(headerOffset + CD_FILE_NAME_LENGTH_OFFSET);
+  const filenameBytes = await file.slice(
+    headerOffset + CD_FILE_NAME_OFFSET,
+    headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength)
+  );
+  const fileName = new TextDecoder().decode(filenameBytes);
+  const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
+  const oldFormatOffset = await file.getUint32(headerOffset + CD_LOCAL_HEADER_OFFSET_OFFSET);
+  let fileDataOffset = BigInt(oldFormatOffset);
+  let offsetInZip64Data = 4n;
+  if (uncompressedSize === BigInt(4294967295)) {
+    uncompressedSize = await file.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (compressedSize === BigInt(4294967295)) {
+    compressedSize = await file.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (fileDataOffset === BigInt(4294967295)) {
+    fileDataOffset = await file.getBigUint64(extraOffset + offsetInZip64Data);
+  }
+  const localHeaderOffset = fileDataOffset;
+  return {
+    compressedSize,
+    uncompressedSize,
+    extraFieldLength,
+    fileNameLength,
+    fileName,
+    extraOffset,
+    localHeaderOffset
+  };
+};
+async function* makeZipCDHeaderIterator(fileProvider) {
+  const { cdStartOffset } = await parseEoCDRecord(fileProvider);
+  let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);
+  while (cdHeader) {
+    yield cdHeader;
+    cdHeader = await parseZipCDFileHeader(
+      cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength),
+      fileProvider
+    );
+  }
+}
+
+// src/parse-zip/local-file-header.ts
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var COMPRESSION_METHOD_OFFSET = 8n;
+var COMPRESSED_SIZE_OFFSET = 18n;
+var UNCOMPRESSED_SIZE_OFFSET = 22n;
+var FILE_NAME_LENGTH_OFFSET = 26n;
+var EXTRA_FIELD_LENGTH_OFFSET = 28n;
+var FILE_NAME_OFFSET = 30n;
+var signature2 = new Uint8Array([80, 75, 3, 4]);
+var parseZipLocalFileHeader = async (headerOffset, buffer) => {
+  const magicBytes = await buffer.slice(headerOffset, headerOffset + 4n);
+  if (!(0, import_loader_utils3.compareArrayBuffers)(magicBytes, signature2)) {
+    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));
+  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET));
+  const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);
+  let offsetInZip64Data = 4n;
+  if (uncompressedSize === BigInt(4294967295)) {
+    uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (compressedSize === BigInt(4294967295)) {
+    compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (fileDataOffset === BigInt(4294967295)) {
+    fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+  }
+  return {
+    fileNameLength,
+    fileName,
+    extraFieldLength,
+    fileDataOffset,
+    compressedSize,
+    compressionMethod
+  };
+};
+
+// src/hash-file-utility.ts
+var import_crypto = require("@loaders.gl/crypto");
+function parseHashTable(arrayBuffer) {
+  const dataView = new DataView(arrayBuffer);
+  const hashMap = {};
+  for (let i = 0; i < arrayBuffer.byteLength; i = i + 24) {
+    const offset = dataView.getBigUint64(i + 16, true);
+    const hash = bufferToHex(arrayBuffer, i, 16);
+    hashMap[hash] = offset;
+  }
+  return hashMap;
+}
+function bufferToHex(buffer, start, length) {
+  return [...new Uint8Array(buffer, start, length)].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+async function makeHashTableFromZipHeaders(fileProvider) {
+  const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
+  const md5Hash = new import_crypto.MD5Hash();
+  const textEncoder = new TextEncoder();
+  const hashTable = {};
+  for await (const cdHeader of zipCDIterator) {
+    const filename = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
+    const arrayBuffer = textEncoder.encode(filename).buffer;
+    const md5 = await md5Hash.hash(arrayBuffer, "hex");
+    hashTable[md5] = cdHeader.localHeaderOffset;
+  }
+  return hashTable;
+}
+
+// src/filesystems/zip-filesystem.ts
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
+var import_compression = require("@loaders.gl/compression");
+var COMPRESSION_METHODS = {
+  /** No compression */
+  0: async (compressedFile) => compressedFile,
+  /** Deflation */
+  8: async (compressedFile) => {
+    const compression = new import_compression.DeflateCompression({ raw: true });
+    const decompressedData = await compression.decompress(compressedFile);
+    return decompressedData;
+  }
+};
+var ZipFileSystem = class {
+  /**
+   * Constructor
+   * @param file - instance of FileProvider or file path string
+   */
+  constructor(file) {
+    /** FileProvider instance promise */
+    this.fileProvider = null;
+    if (typeof file === "string") {
+      this.fileName = file;
+      if (!import_loader_utils4.isBrowser) {
+        this.fileProvider = new import_loader_utils6.FileHandleFile(file);
+      } else {
+        throw new Error("Cannot open file for random access in a WEB browser");
+      }
+    } else if ((0, import_loader_utils5.isFileProvider)(file)) {
+      this.fileProvider = file;
+    }
+  }
+  /** Clean up resources */
+  async destroy() {
+    if (this.fileProvider) {
+      await this.fileProvider.destroy();
+    }
+  }
+  /**
+   * Get file names list from zip archive
+   * @returns array of file names
+   */
+  async readdir() {
+    if (!this.fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    const fileNames = [];
+    const zipCDIterator = makeZipCDHeaderIterator(this.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) {
+    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) {
+    if (!this.fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    const cdFileHeader = await this.getCDFileHeader(filename);
+    const localFileHeader = await parseZipLocalFileHeader(
+      cdFileHeader.localHeaderOffset,
+      this.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 this.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
+   */
+  async getCDFileHeader(filename) {
+    if (!this.fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    const zipCDIterator = makeZipCDHeaderIterator(this.fileProvider);
+    let result = 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/dist/index.d.ts

@@ -1,11 +1,10 @@
 export { ZipLoader } from './zip-loader';
 export { ZipWriter } from './zip-writer';
 export { TarBuilder } from './tar-builder';
-export { parseZipCDFileHeader, zipCDFileHeaderGenerator, signature as cdSignature } from './parse-zip/cd-file-header';
+export { parseZipCDFileHeader, makeZipCDHeaderIterator, 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 type { HashElement } from './hash-file-utility';
-export { compareHashes, parseHashFile, findBin, generateHashInfo } from './hash-file-utility';
+export { parseHashTable, makeHashTableFromZipHeaders } from './hash-file-utility';
 export { ZipFileSystem } from './filesystems/zip-filesystem';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACxB,SAAS,IAAI,WAAW,EACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,uBAAuB,EACvB,SAAS,IAAI,oBAAoB,EAClC,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAC,eAAe,EAAC,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAC,gBAAgB,EAAC,MAAM,iCAAiC,CAAC;AAEjE,YAAY,EAAC,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAE5F,OAAO,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,SAAS,IAAI,WAAW,EACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,uBAAuB,EACvB,SAAS,IAAI,oBAAoB,EAClC,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAC,eAAe,EAAC,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAC,gBAAgB,EAAC,MAAM,iCAAiC,CAAC;AAGjE,OAAO,EAAC,cAAc,EAAE,2BAA2B,EAAC,MAAM,qBAAqB,CAAC;AAEhF,OAAO,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { ZipLoader } from "./zip-loader.js";
+export { ZipWriter } from "./zip-writer.js";
+export { TarBuilder } from "./tar-builder.js";
+export { parseZipCDFileHeader, makeZipCDHeaderIterator, signature as cdSignature } from "./parse-zip/cd-file-header.js";
+export { parseZipLocalFileHeader, signature as localHeaderSignature } from "./parse-zip/local-file-header.js";
+export { parseEoCDRecord } from "./parse-zip/end-of-central-directory.js";
+export { searchFromTheEnd } from "./parse-zip/search-from-the-end.js";
+export { parseHashTable, makeHashTableFromZipHeaders } from "./hash-file-utility.js";
+export { ZipFileSystem } from "./filesystems/zip-filesystem.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["ZipLoader","ZipWriter","TarBuilder","parseZipCDFileHeader","makeZipCDHeaderIterator","signature","cdSignature","parseZipLocalFileHeader","localHeaderSignature","parseEoCDRecord","searchFromTheEnd","parseHashTable","makeHashTableFromZipHeaders","ZipFileSystem"],"sources":["../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nexport {ZipLoader} from './zip-loader';\nexport {ZipWriter} from './zip-writer';\nexport {TarBuilder} from './tar-builder';\n\nexport {\n  parseZipCDFileHeader,\n  makeZipCDHeaderIterator,\n  signature as cdSignature\n} from './parse-zip/cd-file-header';\nexport {\n  parseZipLocalFileHeader,\n  signature as localHeaderSignature\n} from './parse-zip/local-file-header';\nexport {parseEoCDRecord} from './parse-zip/end-of-central-directory';\nexport {searchFromTheEnd} from './parse-zip/search-from-the-end';\n\n// export type {HashElement} from './hash-file-utility';\nexport {parseHashTable, makeHashTableFromZipHeaders} from './hash-file-utility';\n\nexport {ZipFileSystem} from './filesystems/zip-filesystem';\n"],"mappings":"SAEQA,SAAS;AAAA,SACTC,SAAS;AAAA,SACTC,UAAU;AAAA,SAGhBC,oBAAoB,EACpBC,uBAAuB,EACvBC,SAAS,IAAIC,WAAW;AAAA,SAGxBC,uBAAuB,EACvBF,SAAS,IAAIG,oBAAoB;AAAA,SAE3BC,eAAe;AAAA,SACfC,gBAAgB;AAAA,SAGhBC,cAAc,EAAEC,2BAA2B;AAAA,SAE3CC,aAAa"}

package/dist/{esm/lib → lib}/tar/header.js

@@ -1,4 +1,4 @@
-import * as utils from './utils';
+import * as utils from "./utils.js";
 const structure = {
   fileName: 100,
   fileMode: 8,