@loaders.gl/zip 4.0.0-alpha.9 → 4.0.0-beta.1

package/dist/es5/zip-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip-loader.js","names":["_jszip","_interopRequireDefault","require","VERSION","ZipLoader","id","module","name","version","extensions","mimeTypes","category","tests","options","parse","parseZipAsync","exports","_x","_parseZipAsync","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","data","promises","fileMap","jsZip","zip","_args","wrap","_callee$","_context","prev","next","length","undefined","JSZip","loadAsync","sent","forEach","relativePath","zipEntry","subFilename","promise","loadZipEntry","then","arrayBufferOrError","push","Promise","all","abrupt","t0","log","error","concat","stop","_x2","_x3","_loadZipEntry","_callee2","arrayBuffer","_args2","_callee2$","_context2","file","async","dataType","_typecheckZipLoader"],"sources":["../../src/zip-loader.ts"],"sourcesContent":["// Zip loader\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport JSZip from 'jszip';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\ntype FileMap = Record<string, ArrayBuffer>;\n\nexport const ZipLoader: LoaderWithParser<FileMap, never, LoaderOptions> = {\n  id: 'zip',\n  module: 'zip',\n  name: 'Zip Archive',\n  version: VERSION,\n  extensions: ['zip'],\n  mimeTypes: ['application/zip'],\n  category: 'archive',\n  tests: ['PK'],\n  options: {},\n  parse: parseZipAsync\n};\n\n// TODO - Could return a map of promises, perhaps as an option...\nasync function parseZipAsync(data: any, options = {}): Promise<FileMap> {\n  const promises: Promise<any>[] = [];\n  const fileMap: Record<string, ArrayBuffer> = {};\n\n  try {\n    const jsZip = new JSZip();\n\n    const zip = await jsZip.loadAsync(data, options);\n\n    // start to load each file in this zip\n    zip.forEach((relativePath, zipEntry) => {\n      const subFilename = zipEntry.name;\n\n      const promise = loadZipEntry(jsZip, subFilename, options).then((arrayBufferOrError) => {\n        fileMap[relativePath] = arrayBufferOrError;\n      });\n\n      // Ensure Promise.all doesn't ignore rejected promises.\n      promises.push(promise);\n    });\n\n    await Promise.all(promises);\n    return fileMap;\n  } catch (error) {\n    // @ts-ignore\n    options.log.error(`Unable to read zip archive: ${error}`);\n    throw error;\n  }\n}\n\nasync function loadZipEntry(jsZip: any, subFilename: string, options: any = {}) {\n  // jszip supports both arraybuffer and text, the main loaders.gl types\n  // https://stuk.github.io/jszip/documentation/api_zipobject/async.html\n  try {\n    const arrayBuffer = await jsZip.file(subFilename).async(options.dataType || 'arraybuffer');\n    return arrayBuffer;\n  } catch (error) {\n    options.log.error(`Unable to read ${subFilename} from zip archive: ${error}`);\n    // Store error in place of data in map\n    return error;\n  }\n}\n\nexport const _typecheckZipLoader: LoaderWithParser = ZipLoader;\n"],"mappings":"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"}
+{"version":3,"file":"zip-loader.js","names":["_jszip","_interopRequireDefault","require","VERSION","ZipLoader","id","module","name","version","extensions","mimeTypes","category","tests","options","parse","parseZipAsync","exports","_x","_parseZipAsync","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","data","promises","fileMap","jsZip","zip","_args","wrap","_callee$","_context","prev","next","length","undefined","JSZip","loadAsync","sent","forEach","relativePath","zipEntry","subFilename","promise","loadZipEntry","then","arrayBufferOrError","push","Promise","all","abrupt","t0","log","error","concat","stop","_x2","_x3","_loadZipEntry","_callee2","arrayBuffer","_args2","_callee2$","_context2","file","async","dataType"],"sources":["../../src/zip-loader.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport JSZip from 'jszip';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\ntype FileMap = Record<string, ArrayBuffer>;\n\nexport const ZipLoader: LoaderWithParser<FileMap, never, LoaderOptions> = {\n  id: 'zip',\n  module: 'zip',\n  name: 'Zip Archive',\n  version: VERSION,\n  extensions: ['zip'],\n  mimeTypes: ['application/zip'],\n  category: 'archive',\n  tests: ['PK'],\n  options: {},\n  parse: parseZipAsync\n};\n\n// TODO - Could return a map of promises, perhaps as an option...\nasync function parseZipAsync(data: any, options = {}): Promise<FileMap> {\n  const promises: Promise<any>[] = [];\n  const fileMap: Record<string, ArrayBuffer> = {};\n\n  try {\n    const jsZip = new JSZip();\n\n    const zip = await jsZip.loadAsync(data, options);\n\n    // start to load each file in this zip\n    zip.forEach((relativePath, zipEntry) => {\n      const subFilename = zipEntry.name;\n\n      const promise = loadZipEntry(jsZip, subFilename, options).then((arrayBufferOrError) => {\n        fileMap[relativePath] = arrayBufferOrError;\n      });\n\n      // Ensure Promise.all doesn't ignore rejected promises.\n      promises.push(promise);\n    });\n\n    await Promise.all(promises);\n    return fileMap;\n  } catch (error) {\n    // @ts-ignore\n    options.log.error(`Unable to read zip archive: ${error}`);\n    throw error;\n  }\n}\n\nasync function loadZipEntry(jsZip: any, subFilename: string, options: any = {}) {\n  // jszip supports both arraybuffer and text, the main loaders.gl types\n  // https://stuk.github.io/jszip/documentation/api_zipobject/async.html\n  try {\n    const arrayBuffer = await jsZip.file(subFilename).async(options.dataType || 'arraybuffer');\n    return arrayBuffer;\n  } catch (error) {\n    options.log.error(`Unable to read ${subFilename} from zip archive: ${error}`);\n    // Store error in place of data in map\n    return error;\n  }\n}\n"],"mappings":"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"}

package/dist/es5/zip-writer.js

@@ -6,8 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ZipWriter = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _jszip = _interopRequireDefault(require("jszip"));
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var ZipWriter = {
   name: 'Zip Archive',
   extensions: ['zip'],
@@ -25,7 +28,7 @@ function _encodeZipAsync() {
       jsZip,
       subFileName,
       subFileData,
-      _options,
+      jszipOptions,
       _options$onUpdate,
       onUpdate,
       _args = arguments;
@@ -36,21 +39,27 @@ function _encodeZipAsync() {
           jsZip = new _jszip.default();
           for (subFileName in fileMap) {
             subFileData = fileMap[subFileName];
-            jsZip.file(subFileName, subFileData, options);
+            jsZip.file(subFileName, subFileData, (options === null || options === void 0 ? void 0 : options.jszip) || {});
           }
-          options = Object.assign({}, options, {
+          jszipOptions = _objectSpread(_objectSpread({}, options === null || options === void 0 ? void 0 : options.jszip), {}, {
             type: 'arraybuffer'
           });
-          _options = options, _options$onUpdate = _options.onUpdate, onUpdate = _options$onUpdate === void 0 ? function () {} : _options$onUpdate;
-          return _context.abrupt("return", jsZip.generateAsync(options, onUpdate).catch(function (error) {
-            options.log.error("Unable to write zip archive: ".concat(error));
-            throw error;
-          }));
-        case 6:
+          _options$onUpdate = options.onUpdate, onUpdate = _options$onUpdate === void 0 ? function () {} : _options$onUpdate;
+          _context.prev = 5;
+          _context.next = 8;
+          return jsZip.generateAsync(jszipOptions, onUpdate);
+        case 8:
+          return _context.abrupt("return", _context.sent);
+        case 11:
+          _context.prev = 11;
+          _context.t0 = _context["catch"](5);
+          options.log.error("Unable to write zip archive: ".concat(_context.t0));
+          throw _context.t0;
+        case 15:
         case "end":
           return _context.stop();
       }
-    }, _callee);
+    }, _callee, null, [[5, 11]]);
   }));
   return _encodeZipAsync.apply(this, arguments);
 }

package/dist/es5/zip-writer.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip-writer.js","names":["_jszip","_interopRequireDefault","require","ZipWriter","name","extensions","category","mimeTypes","encode","encodeZipAsync","exports","_x","_encodeZipAsync","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","fileMap","options","jsZip","subFileName","subFileData","_options","_options$onUpdate","onUpdate","_args","wrap","_callee$","_context","prev","next","length","undefined","JSZip","file","Object","assign","type","abrupt","generateAsync","catch","error","log","concat","stop"],"sources":["../../src/zip-writer.ts"],"sourcesContent":["import type {Writer} from '@loaders.gl/loader-utils';\nimport JSZip from 'jszip';\n\n/**\n * Zip exporter\n */\nexport const ZipWriter: Writer = {\n  name: 'Zip Archive',\n  extensions: ['zip'],\n  category: 'archive',\n  mimeTypes: ['application/zip'],\n  // @ts-ignore\n  encode: encodeZipAsync\n};\n\nasync function encodeZipAsync(fileMap: any, options: any = {}) {\n  const jsZip = new JSZip();\n  // add files to the zip\n  for (const subFileName in fileMap) {\n    const subFileData = fileMap[subFileName];\n\n    // jszip supports both arraybuffer and string data (the main loaders.gl types)\n    // https://stuk.github.io/jszip/documentation/api_zipobject/async.html\n    jsZip.file(subFileName, subFileData, options);\n  }\n\n  // always generate the full zip as an arraybuffer\n  options = Object.assign({}, options, {\n    type: 'arraybuffer'\n  });\n  const {onUpdate = () => {}} = options;\n\n  return jsZip.generateAsync(options, onUpdate).catch((error) => {\n    options.log.error(`Unable to write zip archive: ${error}`);\n    throw error;\n  });\n}\n"],"mappings":";;;;;;;;;AACA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAKO,IAAMC,SAAiB,GAAG;EAC/BC,IAAI,EAAE,aAAa;EACnBC,UAAU,EAAE,CAAC,KAAK,CAAC;EACnBC,QAAQ,EAAE,SAAS;EACnBC,SAAS,EAAE,CAAC,iBAAiB,CAAC;EAE9BC,MAAM,EAAEC;AACV,CAAC;AAACC,OAAA,CAAAP,SAAA,GAAAA,SAAA;AAAA,SAEaM,cAAcA,CAAAE,EAAA;EAAA,OAAAC,eAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,gBAAA;EAAAA,eAAA,OAAAG,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAA7B,SAAAC,QAA8BC,OAAY;IAAA,IAAAC,OAAA;MAAAC,KAAA;MAAAC,WAAA;MAAAC,WAAA;MAAAC,QAAA;MAAAC,iBAAA;MAAAC,QAAA;MAAAC,KAAA,GAAAd,SAAA;IAAA,OAAAG,YAAA,CAAAD,OAAA,CAAAa,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAAEZ,OAAY,GAAAO,KAAA,CAAAM,MAAA,QAAAN,KAAA,QAAAO,SAAA,GAAAP,KAAA,MAAG,CAAC,CAAC;UACrDN,KAAK,GAAG,IAAIc,cAAK,CAAC,CAAC;UAEzB,KAAWb,WAAW,IAAIH,OAAO,EAAE;YAC3BI,WAAW,GAAGJ,OAAO,CAACG,WAAW,CAAC;YAIxCD,KAAK,CAACe,IAAI,CAACd,WAAW,EAAEC,WAAW,EAAEH,OAAO,CAAC;UAC/C;UAGAA,OAAO,GAAGiB,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,EAAElB,OAAO,EAAE;YACnCmB,IAAI,EAAE;UACR,CAAC,CAAC;UAACf,QAAA,GAC2BJ,OAAO,EAAAK,iBAAA,GAAAD,QAAA,CAA9BE,QAAQ,EAARA,QAAQ,GAAAD,iBAAA,cAAG,YAAM,CAAC,CAAC,GAAAA,iBAAA;UAAA,OAAAK,QAAA,CAAAU,MAAA,WAEnBnB,KAAK,CAACoB,aAAa,CAACrB,OAAO,EAAEM,QAAQ,CAAC,CAACgB,KAAK,CAAC,UAACC,KAAK,EAAK;YAC7DvB,OAAO,CAACwB,GAAG,CAACD,KAAK,iCAAAE,MAAA,CAAiCF,KAAK,CAAE,CAAC;YAC1D,MAAMA,KAAK;UACb,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAb,QAAA,CAAAgB,IAAA;MAAA;IAAA,GAAA5B,OAAA;EAAA,CACH;EAAA,OAAAP,eAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}
+{"version":3,"file":"zip-writer.js","names":["_jszip","_interopRequireDefault","require","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","ZipWriter","name","extensions","category","mimeTypes","encode","encodeZipAsync","exports","_x","_encodeZipAsync","_asyncToGenerator2","_regenerator","mark","_callee","fileMap","options","jsZip","subFileName","subFileData","jszipOptions","_options$onUpdate","onUpdate","_args","wrap","_callee$","_context","prev","next","undefined","JSZip","file","jszip","type","generateAsync","abrupt","sent","t0","log","error","concat","stop"],"sources":["../../src/zip-writer.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Writer, WriterOptions} from '@loaders.gl/loader-utils';\nimport JSZip, {JSZipGeneratorOptions} from 'jszip';\n\nexport type ZipWriterOptions = WriterOptions & {\n  zip?: {\n    onUpdate?: (metadata: {percent: number}) => void;\n  };\n  /** Passthrough options to jszip */\n  jszip?: JSZipGeneratorOptions;\n};\n\n/**\n * Zip exporter\n */\nexport const ZipWriter: Writer<FileReaderEventMap, never, ZipWriterOptions> = {\n  name: 'Zip Archive',\n  extensions: ['zip'],\n  category: 'archive',\n  mimeTypes: ['application/zip'],\n  // @ts-ignore\n  encode: encodeZipAsync\n};\n\nasync function encodeZipAsync(\n  fileMap: Record<string, ArrayBuffer>,\n  options: ZipWriterOptions = {}\n) {\n  const jsZip = new JSZip();\n  // add files to the zip\n  for (const subFileName in fileMap) {\n    const subFileData = fileMap[subFileName];\n\n    // jszip supports both arraybuffer and string data (the main loaders.gl types)\n    // https://stuk.github.io/jszip/documentation/api_zipobject/async.html\n    jsZip.file(subFileName, subFileData, options?.jszip || {});\n  }\n\n  // always generate the full zip as an arraybuffer\n  const jszipOptions: JSZipGeneratorOptions = {...options?.jszip, type: 'arraybuffer'};\n  const {onUpdate = () => {}} = options;\n\n  try {\n    return await jsZip.generateAsync(jszipOptions, onUpdate);\n  } catch (error) {\n    options.log.error(`Unable to write zip archive: ${error}`);\n    throw error;\n  }\n}\n"],"mappings":"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"}

package/dist/esm/filesystems/zip-filesystem.js

@@ -0,0 +1,99 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { isBrowser } from '@loaders.gl/loader-utils';
+import { isFileProvider } from '@loaders.gl/loader-utils';
+import { FileHandleFile } from '@loaders.gl/loader-utils';
+import { zipCDFileHeaderGenerator } from '../parse-zip/cd-file-header';
+import { parseZipLocalFileHeader } from '../parse-zip/local-file-header';
+import { DeflateCompression } from '@loaders.gl/compression';
+const COMPRESSION_METHODS = {
+  0: async compressedFile => compressedFile,
+  8: async compressedFile => {
+    const compression = new DeflateCompression({
+      raw: true
+    });
+    const decompressedData = await compression.decompress(compressedFile);
+    return decompressedData;
+  }
+};
+export class ZipFileSystem {
+  constructor(file) {
+    _defineProperty(this, "fileProvider", Promise.resolve(null));
+    _defineProperty(this, "fileName", void 0);
+    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);
+    }
+  }
+  async destroy() {
+    const fileProvider = await this.fileProvider;
+    if (fileProvider) {
+      await fileProvider.destroy();
+    }
+  }
+  async readdir() {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error('No data detected in the zip archive');
+    }
+    const fileNames = [];
+    const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+    for await (const cdHeader of zipCDIterator) {
+      fileNames.push(cdHeader.fileName);
+    }
+    return fileNames;
+  }
+  async stat(filename) {
+    const cdFileHeader = await this.getCDFileHeader(filename);
+    return {
+      ...cdFileHeader,
+      size: Number(cdFileHeader.uncompressedSize)
+    };
+  }
+  async fetch(filename) {
+    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: "".concat(this.fileName || '', "/").concat(filename)
+    });
+    return response;
+  }
+  async getCDFileHeader(filename) {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error('No data detected in the zip archive');
+    }
+    const zipCDIterator = zipCDFileHeaderGenerator(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;
+  }
+}
+//# sourceMappingURL=zip-filesystem.js.map

package/dist/esm/filesystems/zip-filesystem.js.map

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

package/dist/esm/hash-file-utility.js

@@ -0,0 +1,55 @@
+import md5 from 'md5';
+import { zipCDFileHeaderGenerator } from './parse-zip/cd-file-header';
+export const compareHashes = (hash1, hash2) => {
+  const h1 = new BigUint64Array(hash1.buffer, hash1.byteOffset, 2);
+  const h2 = new BigUint64Array(hash2.buffer, hash2.byteOffset, 2);
+  const diff = h1[0] === h2[0] ? h1[1] - h2[1] : h1[0] - h2[0];
+  if (diff < 0n) {
+    return -1;
+  } else if (diff === 0n) {
+    return 0;
+  }
+  return 1;
+};
+export const parseHashFile = hashFile => {
+  const hashFileBuffer = Buffer.from(hashFile);
+  const hashArray = [];
+  for (let i = 0; i < hashFileBuffer.buffer.byteLength; i = i + 24) {
+    const offsetBuffer = new DataView(hashFileBuffer.buffer.slice(hashFileBuffer.byteOffset + i + 16, hashFileBuffer.byteOffset + i + 24));
+    const offset = offsetBuffer.getBigUint64(offsetBuffer.byteOffset, true);
+    hashArray.push({
+      hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i, hashFileBuffer.byteOffset + i + 16)),
+      offset
+    });
+  }
+  return hashArray;
+};
+export const findBin = (hashToSearch, hashArray) => {
+  let lowerBorder = 0;
+  let upperBorder = hashArray.length;
+  while (upperBorder - lowerBorder > 1) {
+    const middle = lowerBorder + Math.floor((upperBorder - lowerBorder) / 2);
+    const value = compareHashes(hashArray[middle].hash, hashToSearch);
+    if (value === 0) {
+      return hashArray[middle];
+    } else if (value < 0) {
+      lowerBorder = middle;
+    } else {
+      upperBorder = middle;
+    }
+  }
+  return undefined;
+};
+export const generateHashInfo = async fileProvider => {
+  const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+  const hashInfo = [];
+  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;
+};
+//# sourceMappingURL=hash-file-utility.js.map

package/dist/esm/hash-file-utility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-file-utility.js","names":["md5","zipCDFileHeaderGenerator","compareHashes","hash1","hash2","h1","BigUint64Array","buffer","byteOffset","h2","diff","parseHashFile","hashFile","hashFileBuffer","Buffer","from","hashArray","i","byteLength","offsetBuffer","DataView","slice","offset","getBigUint64","push","hash","subarray","findBin","hashToSearch","lowerBorder","upperBorder","length","middle","Math","floor","value","undefined","generateHashInfo","fileProvider","zipCDIterator","hashInfo","cdHeader","fileName","split","join","toLocaleLowerCase","localHeaderOffset","sort","a","b"],"sources":["../../src/hash-file-utility.ts"],"sourcesContent":["import md5 from 'md5';\nimport {FileProvider} from '@loaders.gl/loader-utils';\nimport {zipCDFileHeaderGenerator} from './parse-zip/cd-file-header';\n\n/** Element of hash array */\nexport type HashElement = {\n  /** File name hash */\n  hash: Buffer;\n  /** File offset in the archive */\n  offset: bigint;\n};\n\n/**\n * Comparing md5 hashes according to https://github.com/Esri/i3s-spec/blob/master/docs/2.0/slpk_hashtable.pcsl.md step 5\n * @param hash1 hash to compare\n * @param hash2 hash to compare\n * @returns -1 if hash1 < hash2, 0 of hash1 === hash2, 1 if hash1 > hash2\n */\nexport const compareHashes = (hash1: Buffer, hash2: Buffer): number => {\n  const h1 = new BigUint64Array(hash1.buffer, hash1.byteOffset, 2);\n  const h2 = new BigUint64Array(hash2.buffer, hash2.byteOffset, 2);\n\n  const diff = h1[0] === h2[0] ? h1[1] - h2[1] : h1[0] - h2[0];\n\n  if (diff < 0n) {\n    return -1;\n  } else if (diff === 0n) {\n    return 0;\n  }\n  return 1;\n};\n\n/**\n * Reads hash file from buffer and returns it in ready-to-use form\n * @param hashFile - bufer containing hash file\n * @returns Array containing file info\n */\nexport const parseHashFile = (hashFile: ArrayBuffer): HashElement[] => {\n  const hashFileBuffer = Buffer.from(hashFile);\n  const hashArray: HashElement[] = [];\n  for (let i = 0; i < hashFileBuffer.buffer.byteLength; i = i + 24) {\n    const offsetBuffer = new DataView(\n      hashFileBuffer.buffer.slice(\n        hashFileBuffer.byteOffset + i + 16,\n        hashFileBuffer.byteOffset + i + 24\n      )\n    );\n    const offset = offsetBuffer.getBigUint64(offsetBuffer.byteOffset, true);\n    hashArray.push({\n      hash: Buffer.from(\n        hashFileBuffer.subarray(hashFileBuffer.byteOffset + i, hashFileBuffer.byteOffset + i + 16)\n      ),\n      offset\n    });\n  }\n  return hashArray;\n};\n\n/**\n * Binary search in the hash info\n * @param hashToSearch hash that we need to find\n * @returns required hash element or undefined if not found\n */\nexport const findBin = (\n  hashToSearch: Buffer,\n  hashArray: HashElement[]\n): HashElement | undefined => {\n  let lowerBorder = 0;\n  let upperBorder = hashArray.length;\n\n  while (upperBorder - lowerBorder > 1) {\n    const middle = lowerBorder + Math.floor((upperBorder - lowerBorder) / 2);\n    const value = compareHashes(hashArray[middle].hash, hashToSearch);\n    if (value === 0) {\n      return hashArray[middle];\n    } else if (value < 0) {\n      lowerBorder = middle;\n    } else {\n      upperBorder = middle;\n    }\n  }\n  return undefined;\n};\n\n/**\n * generates hash info from central directory\n * @param fileProvider - provider of the archive\n * @returns ready to use hash info\n */\nexport const generateHashInfo = async (fileProvider: FileProvider): Promise<HashElement[]> => {\n  const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);\n  const hashInfo: HashElement[] = [];\n  for await (const cdHeader of zipCDIterator) {\n    hashInfo.push({\n      hash: Buffer.from(md5(cdHeader.fileName.split('\\\\').join('/').toLocaleLowerCase()), 'hex'),\n      offset: cdHeader.localHeaderOffset\n    });\n  }\n  hashInfo.sort((a, b) => compareHashes(a.hash, b.hash));\n  return hashInfo;\n};\n"],"mappings":"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"}

package/dist/esm/index.js

@@ -1,4 +1,10 @@
 export { ZipLoader } from './zip-loader';
 export { ZipWriter } from './zip-writer';
-export { default as TarBuilder } from './tar-builder';
+export { TarBuilder } from './tar-builder';
+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 { compareHashes, parseHashFile, findBin, generateHashInfo } from './hash-file-utility';
+export { ZipFileSystem } from './filesystems/zip-filesystem';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["ZipLoader","ZipWriter","default","TarBuilder"],"sources":["../../src/index.ts"],"sourcesContent":["export {ZipLoader} from './zip-loader';\nexport {ZipWriter} from './zip-writer';\nexport {default as TarBuilder} from './tar-builder';\n"],"mappings":"AAAA,SAAQA,SAAS,QAAO,cAAc;AACtC,SAAQC,SAAS,QAAO,cAAc;AACtC,SAAQC,OAAO,IAAIC,UAAU,QAAO,eAAe"}
+{"version":3,"file":"index.js","names":["ZipLoader","ZipWriter","TarBuilder","parseZipCDFileHeader","zipCDFileHeaderGenerator","signature","cdSignature","parseZipLocalFileHeader","localHeaderSignature","parseEoCDRecord","searchFromTheEnd","compareHashes","parseHashFile","findBin","generateHashInfo","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  zipCDFileHeaderGenerator,\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\nexport type {HashElement} from './hash-file-utility';\nexport {compareHashes, parseHashFile, findBin, generateHashInfo} from './hash-file-utility';\n\nexport {ZipFileSystem} from './filesystems/zip-filesystem';\n"],"mappings":"AAEA,SAAQA,SAAS,QAAO,cAAc;AACtC,SAAQC,SAAS,QAAO,cAAc;AACtC,SAAQC,UAAU,QAAO,eAAe;AAExC,SACEC,oBAAoB,EACpBC,wBAAwB,EACxBC,SAAS,IAAIC,WAAW,QACnB,4BAA4B;AACnC,SACEC,uBAAuB,EACvBF,SAAS,IAAIG,oBAAoB,QAC5B,+BAA+B;AACtC,SAAQC,eAAe,QAAO,sCAAsC;AACpE,SAAQC,gBAAgB,QAAO,iCAAiC;AAGhE,SAAQC,aAAa,EAAEC,aAAa,EAAEC,OAAO,EAAEC,gBAAgB,QAAO,qBAAqB;AAE3F,SAAQC,aAAa,QAAO,8BAA8B"}

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

@@ -0,0 +1,54 @@
+import { parseEoCDRecord } from './end-of-central-directory';
+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;
+export const signature = [0x50, 0x4b, 0x01, 0x02];
+export const parseZipCDFileHeader = async (headerOffset, buffer) => {
+  if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(Buffer.from(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;
+  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);
+  }
+  const localHeaderOffset = fileDataOffset;
+  return {
+    compressedSize,
+    uncompressedSize,
+    extraFieldLength,
+    fileNameLength,
+    fileName,
+    extraOffset,
+    localHeaderOffset
+  };
+};
+export async function* zipCDFileHeaderGenerator(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);
+  }
+}
+//# sourceMappingURL=cd-file-header.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cd-file-header.js","names":["parseEoCDRecord","CD_COMPRESSED_SIZE_OFFSET","CD_UNCOMPRESSED_SIZE_OFFSET","CD_FILE_NAME_LENGTH_OFFSET","CD_EXTRA_FIELD_LENGTH_OFFSET","CD_LOCAL_HEADER_OFFSET_OFFSET","CD_FILE_NAME_OFFSET","signature","parseZipCDFileHeader","headerOffset","buffer","Buffer","from","slice","compare","compressedSize","BigInt","getUint32","uncompressedSize","extraFieldLength","getUint16","fileNameLength","fileName","TextDecoder","decode","extraOffset","oldFormatOffset","fileDataOffset","offsetInZip64Data","getBigUint64","localHeaderOffset","zipCDFileHeaderGenerator","fileProvider","cdStartOffset","cdHeader"],"sources":["../../../src/parse-zip/cd-file-header.ts"],"sourcesContent":["import {FileProvider} from '@loaders.gl/loader-utils';\nimport {parseEoCDRecord} from './end-of-central-directory';\nimport {ZipSignature} from './search-from-the-end';\n\n/**\n * zip central directory file header info\n * according to https://en.wikipedia.org/wiki/ZIP_(file_format)\n */\nexport type ZipCDFileHeader = {\n  /** Compressed size */\n  compressedSize: bigint;\n  /** Uncompressed size */\n  uncompressedSize: bigint;\n  /** Extra field size */\n  extraFieldLength: number;\n  /** File name length */\n  fileNameLength: number;\n  /** File name */\n  fileName: string;\n  /** Extra field offset */\n  extraOffset: bigint;\n  /** Relative offset of local file header */\n  localHeaderOffset: bigint;\n};\n\n// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)\nconst CD_COMPRESSED_SIZE_OFFSET = 20n;\nconst CD_UNCOMPRESSED_SIZE_OFFSET = 24n;\nconst CD_FILE_NAME_LENGTH_OFFSET = 28n;\nconst CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;\nconst CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;\nconst CD_FILE_NAME_OFFSET = 46n;\n\nexport const signature: ZipSignature = [0x50, 0x4b, 0x01, 0x02];\n\n/**\n * Parses central directory file header of zip file\n * @param headerOffset - offset in the archive where header starts\n * @param buffer - buffer containing whole array\n * @returns Info from the header\n */\nexport const parseZipCDFileHeader = async (\n  headerOffset: bigint,\n  buffer: FileProvider\n): Promise<ZipCDFileHeader | null> => {\n  if (\n    Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(\n      Buffer.from(signature)\n    ) !== 0\n  ) {\n    return null;\n  }\n\n  let compressedSize = BigInt(await buffer.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));\n\n  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + CD_UNCOMPRESSED_SIZE_OFFSET));\n\n  const extraFieldLength = await buffer.getUint16(headerOffset + CD_EXTRA_FIELD_LENGTH_OFFSET);\n\n  const fileNameLength = await buffer.getUint16(headerOffset + CD_FILE_NAME_LENGTH_OFFSET);\n\n  const fileName = new TextDecoder().decode(\n    await buffer.slice(\n      headerOffset + CD_FILE_NAME_OFFSET,\n      headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength)\n    )\n  );\n\n  const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);\n\n  const oldFormatOffset = await buffer.getUint32(headerOffset + CD_LOCAL_HEADER_OFFSET_OFFSET);\n\n  let fileDataOffset = BigInt(oldFormatOffset);\n  let offsetInZip64Data = 4n;\n  // looking for info that might be also be in zip64 extra field\n  if (uncompressedSize === BigInt(0xffffffff)) {\n    uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);\n    offsetInZip64Data += 8n;\n  }\n  if (compressedSize === BigInt(0xffffffff)) {\n    compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);\n    offsetInZip64Data += 8n;\n  }\n  if (fileDataOffset === BigInt(0xffffffff)) {\n    fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data); // setting it to the one from zip64\n  }\n  const localHeaderOffset = fileDataOffset;\n\n  return {\n    compressedSize,\n    uncompressedSize,\n    extraFieldLength,\n    fileNameLength,\n    fileName,\n    extraOffset,\n    localHeaderOffset\n  };\n};\n\n/**\n * Create iterator over files of zip archive\n * @param fileProvider - file provider that provider random access to the file\n */\nexport async function* zipCDFileHeaderGenerator(fileProvider: FileProvider) {\n  const {cdStartOffset} = await parseEoCDRecord(fileProvider);\n  let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);\n  while (cdHeader) {\n    yield cdHeader;\n    cdHeader = await parseZipCDFileHeader(\n      cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength),\n      fileProvider\n    );\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,31 @@
+import { searchFromTheEnd } from './search-from-the-end';
+const eoCDSignature = [0x50, 0x4b, 0x05, 0x06];
+const zip64EoCDLocatorSignature = [0x50, 0x4b, 0x06, 0x07];
+const zip64EoCDSignature = [0x50, 0x4b, 0x06, 0x06];
+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;
+export const parseEoCDRecord = async fileProvider => {
+  const zipEoCDOffset = await 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(Buffer.from(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(Buffer.from(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
+  };
+};
+//# sourceMappingURL=end-of-central-directory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"end-of-central-directory.js","names":["searchFromTheEnd","eoCDSignature","zip64EoCDLocatorSignature","zip64EoCDSignature","CD_RECORDS_NUMBER_OFFSET","CD_START_OFFSET_OFFSET","ZIP64_EOCD_START_OFFSET_OFFSET","ZIP64_CD_RECORDS_NUMBER_OFFSET","ZIP64_CD_START_OFFSET_OFFSET","parseEoCDRecord","fileProvider","zipEoCDOffset","cdRecordsNumber","BigInt","getUint16","cdStartOffset","getUint32","zip64EoCDLocatorOffset","Buffer","from","slice","compare","Error","zip64EoCDOffset","getBigUint64"],"sources":["../../../src/parse-zip/end-of-central-directory.ts"],"sourcesContent":["import {FileProvider} from '@loaders.gl/loader-utils';\nimport {ZipSignature, searchFromTheEnd} from './search-from-the-end';\n\n/**\n * End of central directory info\n * according to https://en.wikipedia.org/wiki/ZIP_(file_format)\n */\nexport type ZipEoCDRecord = {\n  /** Relative offset of local file header */\n  cdStartOffset: bigint;\n  /** Relative offset of local file header */\n  cdRecordsNumber: bigint;\n};\n\nconst eoCDSignature: ZipSignature = [0x50, 0x4b, 0x05, 0x06];\nconst zip64EoCDLocatorSignature = [0x50, 0x4b, 0x06, 0x07];\nconst zip64EoCDSignature = [0x50, 0x4b, 0x06, 0x06];\n\n// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)\nconst CD_RECORDS_NUMBER_OFFSET = 8n;\nconst CD_START_OFFSET_OFFSET = 16n;\nconst ZIP64_EOCD_START_OFFSET_OFFSET = 8n;\nconst ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;\nconst ZIP64_CD_START_OFFSET_OFFSET = 48n;\n\n/**\n * Parses end of central directory record of zip file\n * @param fileProvider - FileProvider instance\n * @returns Info from the header\n */\nexport const parseEoCDRecord = async (fileProvider: FileProvider): Promise<ZipEoCDRecord> => {\n  const zipEoCDOffset = await searchFromTheEnd(fileProvider, eoCDSignature);\n\n  let cdRecordsNumber = BigInt(\n    await fileProvider.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET)\n  );\n  let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));\n\n  if (cdStartOffset === BigInt(0xffffffff) || cdRecordsNumber === BigInt(0xffffffff)) {\n    const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;\n\n    if (\n      Buffer.from(\n        await fileProvider.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n)\n      ).compare(Buffer.from(zip64EoCDLocatorSignature)) !== 0\n    ) {\n      throw new Error('zip64 EoCD locator not found');\n    }\n    const zip64EoCDOffset = await fileProvider.getBigUint64(\n      zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET\n    );\n\n    if (\n      Buffer.from(await fileProvider.slice(zip64EoCDOffset, zip64EoCDOffset + 4n)).compare(\n        Buffer.from(zip64EoCDSignature)\n      ) !== 0\n    ) {\n      throw new Error('zip64 EoCD not found');\n    }\n\n    cdRecordsNumber = await fileProvider.getBigUint64(\n      zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET\n    );\n    cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);\n  }\n\n  return {\n    cdRecordsNumber,\n    cdStartOffset\n  };\n};\n"],"mappings":"AACA,SAAsBA,gBAAgB,QAAO,uBAAuB;AAapE,MAAMC,aAA2B,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;AAC5D,MAAMC,yBAAyB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;AAC1D,MAAMC,kBAAkB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;AAGnD,MAAMC,wBAAwB,GAAG,EAAE;AACnC,MAAMC,sBAAsB,GAAG,GAAG;AAClC,MAAMC,8BAA8B,GAAG,EAAE;AACzC,MAAMC,8BAA8B,GAAG,GAAG;AAC1C,MAAMC,4BAA4B,GAAG,GAAG;AAOxC,OAAO,MAAMC,eAAe,GAAG,MAAOC,YAA0B,IAA6B;EAC3F,MAAMC,aAAa,GAAG,MAAMX,gBAAgB,CAACU,YAAY,EAAET,aAAa,CAAC;EAEzE,IAAIW,eAAe,GAAGC,MAAM,CAC1B,MAAMH,YAAY,CAACI,SAAS,CAACH,aAAa,GAAGP,wBAAwB,CACvE,CAAC;EACD,IAAIW,aAAa,GAAGF,MAAM,CAAC,MAAMH,YAAY,CAACM,SAAS,CAACL,aAAa,GAAGN,sBAAsB,CAAC,CAAC;EAEhG,IAAIU,aAAa,KAAKF,MAAM,CAAC,UAAU,CAAC,IAAID,eAAe,KAAKC,MAAM,CAAC,UAAU,CAAC,EAAE;IAClF,MAAMI,sBAAsB,GAAGN,aAAa,GAAG,GAAG;IAElD,IACEO,MAAM,CAACC,IAAI,CACT,MAAMT,YAAY,CAACU,KAAK,CAACH,sBAAsB,EAAEA,sBAAsB,GAAG,EAAE,CAC9E,CAAC,CAACI,OAAO,CAACH,MAAM,CAACC,IAAI,CAACjB,yBAAyB,CAAC,CAAC,KAAK,CAAC,EACvD;MACA,MAAM,IAAIoB,KAAK,CAAC,8BAA8B,CAAC;IACjD;IACA,MAAMC,eAAe,GAAG,MAAMb,YAAY,CAACc,YAAY,CACrDP,sBAAsB,GAAGX,8BAC3B,CAAC;IAED,IACEY,MAAM,CAACC,IAAI,CAAC,MAAMT,YAAY,CAACU,KAAK,CAACG,eAAe,EAAEA,eAAe,GAAG,EAAE,CAAC,CAAC,CAACF,OAAO,CAClFH,MAAM,CAACC,IAAI,CAAChB,kBAAkB,CAChC,CAAC,KAAK,CAAC,EACP;MACA,MAAM,IAAImB,KAAK,CAAC,sBAAsB,CAAC;IACzC;IAEAV,eAAe,GAAG,MAAMF,YAAY,CAACc,YAAY,CAC/CD,eAAe,GAAGhB,8BACpB,CAAC;IACDQ,aAAa,GAAG,MAAML,YAAY,CAACc,YAAY,CAACD,eAAe,GAAGf,4BAA4B,CAAC;EACjG;EAEA,OAAO;IACLI,eAAe;IACfG;EACF,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,41 @@
+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;
+export const signature = [0x50, 0x4b, 0x03, 0x04];
+export const parseZipLocalFileHeader = async (headerOffset, buffer) => {
+  if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(Buffer.from(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));
+  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET));
+  const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);
+  let offsetInZip64Data = 4n;
+  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);
+  }
+  return {
+    fileNameLength,
+    fileName,
+    extraFieldLength,
+    fileDataOffset,
+    compressedSize,
+    compressionMethod
+  };
+};
+//# sourceMappingURL=local-file-header.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-file-header.js","names":["COMPRESSION_METHOD_OFFSET","COMPRESSED_SIZE_OFFSET","UNCOMPRESSED_SIZE_OFFSET","FILE_NAME_LENGTH_OFFSET","EXTRA_FIELD_LENGTH_OFFSET","FILE_NAME_OFFSET","signature","parseZipLocalFileHeader","headerOffset","buffer","Buffer","from","slice","compare","fileNameLength","getUint16","fileName","TextDecoder","decode","BigInt","split","join","extraFieldLength","fileDataOffset","compressionMethod","compressedSize","getUint32","uncompressedSize","extraOffset","offsetInZip64Data","getBigUint64"],"sources":["../../../src/parse-zip/local-file-header.ts"],"sourcesContent":["import {FileProvider} from '@loaders.gl/loader-utils';\n\n/**\n * zip local file header info\n * according to https://en.wikipedia.org/wiki/ZIP_(file_format)\n */\nexport type ZipLocalFileHeader = {\n  /** File name length */\n  fileNameLength: number;\n  /** File name */\n  fileName: string;\n  /** Extra field length */\n  extraFieldLength: number;\n  /** Offset of the file data */\n  fileDataOffset: bigint;\n  /** Compressed size */\n  compressedSize: bigint;\n  /** Compression method */\n  compressionMethod: number;\n};\n\n// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)\nconst COMPRESSION_METHOD_OFFSET = 8n;\nconst COMPRESSED_SIZE_OFFSET = 18n;\nconst UNCOMPRESSED_SIZE_OFFSET = 22n;\nconst FILE_NAME_LENGTH_OFFSET = 26n;\nconst EXTRA_FIELD_LENGTH_OFFSET = 28n;\nconst FILE_NAME_OFFSET = 30n;\n\nexport const signature = [0x50, 0x4b, 0x03, 0x04];\n\n/**\n * Parses local file header of zip file\n * @param headerOffset - offset in the archive where header starts\n * @param buffer - buffer containing whole array\n * @returns Info from the header\n */\nexport const parseZipLocalFileHeader = async (\n  headerOffset: bigint,\n  buffer: FileProvider\n): Promise<ZipLocalFileHeader | null> => {\n  if (\n    Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(\n      Buffer.from(signature)\n    ) !== 0\n  ) {\n    return null;\n  }\n\n  const fileNameLength = await buffer.getUint16(headerOffset + FILE_NAME_LENGTH_OFFSET);\n\n  const fileName = new TextDecoder()\n    .decode(\n      await buffer.slice(\n        headerOffset + FILE_NAME_OFFSET,\n        headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength)\n      )\n    )\n    .split('\\\\')\n    .join('/');\n  const extraFieldLength = await buffer.getUint16(headerOffset + EXTRA_FIELD_LENGTH_OFFSET);\n\n  let fileDataOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);\n\n  const compressionMethod = await buffer.getUint16(headerOffset + COMPRESSION_METHOD_OFFSET);\n\n  let compressedSize = BigInt(await buffer.getUint32(headerOffset + COMPRESSED_SIZE_OFFSET)); // add zip 64 logic\n\n  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET)); // add zip 64 logic\n\n  const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);\n\n  let offsetInZip64Data = 4n;\n  // looking for info that might be also be in zip64 extra field\n  if (uncompressedSize === BigInt(0xffffffff)) {\n    uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);\n    offsetInZip64Data += 8n;\n  }\n  if (compressedSize === BigInt(0xffffffff)) {\n    compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);\n    offsetInZip64Data += 8n;\n  }\n  if (fileDataOffset === BigInt(0xffffffff)) {\n    fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data); // setting it to the one from zip64\n  }\n\n  return {\n    fileNameLength,\n    fileName,\n    extraFieldLength,\n    fileDataOffset,\n    compressedSize,\n    compressionMethod\n  };\n};\n"],"mappings":"AAsBA,MAAMA,yBAAyB,GAAG,EAAE;AACpC,MAAMC,sBAAsB,GAAG,GAAG;AAClC,MAAMC,wBAAwB,GAAG,GAAG;AACpC,MAAMC,uBAAuB,GAAG,GAAG;AACnC,MAAMC,yBAAyB,GAAG,GAAG;AACrC,MAAMC,gBAAgB,GAAG,GAAG;AAE5B,OAAO,MAAMC,SAAS,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;AAQjD,OAAO,MAAMC,uBAAuB,GAAG,MAAAA,CACrCC,YAAoB,EACpBC,MAAoB,KACmB;EACvC,IACEC,MAAM,CAACC,IAAI,CAAC,MAAMF,MAAM,CAACG,KAAK,CAACJ,YAAY,EAAEA,YAAY,GAAG,EAAE,CAAC,CAAC,CAACK,OAAO,CACtEH,MAAM,CAACC,IAAI,CAACL,SAAS,CACvB,CAAC,KAAK,CAAC,EACP;IACA,OAAO,IAAI;EACb;EAEA,MAAMQ,cAAc,GAAG,MAAML,MAAM,CAACM,SAAS,CAACP,YAAY,GAAGL,uBAAuB,CAAC;EAErF,MAAMa,QAAQ,GAAG,IAAIC,WAAW,CAAC,CAAC,CAC/BC,MAAM,CACL,MAAMT,MAAM,CAACG,KAAK,CAChBJ,YAAY,GAAGH,gBAAgB,EAC/BG,YAAY,GAAGH,gBAAgB,GAAGc,MAAM,CAACL,cAAc,CACzD,CACF,CAAC,CACAM,KAAK,CAAC,IAAI,CAAC,CACXC,IAAI,CAAC,GAAG,CAAC;EACZ,MAAMC,gBAAgB,GAAG,MAAMb,MAAM,CAACM,SAAS,CAACP,YAAY,GAAGJ,yBAAyB,CAAC;EAEzF,IAAImB,cAAc,GAAGf,YAAY,GAAGH,gBAAgB,GAAGc,MAAM,CAACL,cAAc,GAAGQ,gBAAgB,CAAC;EAEhG,MAAME,iBAAiB,GAAG,MAAMf,MAAM,CAACM,SAAS,CAACP,YAAY,GAAGR,yBAAyB,CAAC;EAE1F,IAAIyB,cAAc,GAAGN,MAAM,CAAC,MAAMV,MAAM,CAACiB,SAAS,CAAClB,YAAY,GAAGP,sBAAsB,CAAC,CAAC;EAE1F,IAAI0B,gBAAgB,GAAGR,MAAM,CAAC,MAAMV,MAAM,CAACiB,SAAS,CAAClB,YAAY,GAAGN,wBAAwB,CAAC,CAAC;EAE9F,MAAM0B,WAAW,GAAGpB,YAAY,GAAGH,gBAAgB,GAAGc,MAAM,CAACL,cAAc,CAAC;EAE5E,IAAIe,iBAAiB,GAAG,EAAE;EAE1B,IAAIF,gBAAgB,KAAKR,MAAM,CAAC,UAAU,CAAC,EAAE;IAC3CQ,gBAAgB,GAAG,MAAMlB,MAAM,CAACqB,YAAY,CAACF,WAAW,GAAGC,iBAAiB,CAAC;IAC7EA,iBAAiB,IAAI,EAAE;EACzB;EACA,IAAIJ,cAAc,KAAKN,MAAM,CAAC,UAAU,CAAC,EAAE;IACzCM,cAAc,GAAG,MAAMhB,MAAM,CAACqB,YAAY,CAACF,WAAW,GAAGC,iBAAiB,CAAC;IAC3EA,iBAAiB,IAAI,EAAE;EACzB;EACA,IAAIN,cAAc,KAAKJ,MAAM,CAAC,UAAU,CAAC,EAAE;IACzCI,cAAc,GAAG,MAAMd,MAAM,CAACqB,YAAY,CAACF,WAAW,GAAGC,iBAAiB,CAAC;EAC7E;EAEA,OAAO;IACLf,cAAc;IACdE,QAAQ;IACRM,gBAAgB;IAChBC,cAAc;IACdE,cAAc;IACdD;EACF,CAAC;AACH,CAAC"}

package/dist/esm/parse-zip/search-from-the-end.js

@@ -0,0 +1,16 @@
+export 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;
+  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;
+};
+//# sourceMappingURL=search-from-the-end.js.map

package/dist/esm/parse-zip/search-from-the-end.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-from-the-end.js","names":["searchFromTheEnd","file","target","searchWindow","getUint8","length","undefined","targetOffset","i","every","val","index"],"sources":["../../../src/parse-zip/search-from-the-end.ts"],"sourcesContent":["import {FileProvider} from '@loaders.gl/loader-utils';\n\n/** Description of zip signature type */\nexport type ZipSignature = [number, number, number, number];\n\n/**\n * looking for the last occurrence of the provided\n * @param file\n * @param target\n * @returns\n */\nexport const searchFromTheEnd = async (\n  file: FileProvider,\n  target: ZipSignature\n): Promise<bigint> => {\n  const searchWindow = [\n    await file.getUint8(file.length - 1n),\n    await file.getUint8(file.length - 2n),\n    await file.getUint8(file.length - 3n),\n    undefined\n  ];\n\n  let targetOffset = 0n;\n\n  // looking for the last record in the central directory\n  for (let i = file.length - 4n; i > -1; i--) {\n    searchWindow[3] = searchWindow[2];\n    searchWindow[2] = searchWindow[1];\n    searchWindow[1] = searchWindow[0];\n    searchWindow[0] = await file.getUint8(i);\n    if (searchWindow.every((val, index) => val === target[index])) {\n      targetOffset = i;\n      break;\n    }\n  }\n\n  return targetOffset;\n};\n"],"mappings":"AAWA,OAAO,MAAMA,gBAAgB,GAAG,MAAAA,CAC9BC,IAAkB,EAClBC,MAAoB,KACA;EACpB,MAAMC,YAAY,GAAG,CACnB,MAAMF,IAAI,CAACG,QAAQ,CAACH,IAAI,CAACI,MAAM,GAAG,EAAE,CAAC,EACrC,MAAMJ,IAAI,CAACG,QAAQ,CAACH,IAAI,CAACI,MAAM,GAAG,EAAE,CAAC,EACrC,MAAMJ,IAAI,CAACG,QAAQ,CAACH,IAAI,CAACI,MAAM,GAAG,EAAE,CAAC,EACrCC,SAAS,CACV;EAED,IAAIC,YAAY,GAAG,EAAE;EAGrB,KAAK,IAAIC,CAAC,GAAGP,IAAI,CAACI,MAAM,GAAG,EAAE,EAAEG,CAAC,GAAG,CAAC,CAAC,EAAEA,CAAC,EAAE,EAAE;IAC1CL,YAAY,CAAC,CAAC,CAAC,GAAGA,YAAY,CAAC,CAAC,CAAC;IACjCA,YAAY,CAAC,CAAC,CAAC,GAAGA,YAAY,CAAC,CAAC,CAAC;IACjCA,YAAY,CAAC,CAAC,CAAC,GAAGA,YAAY,CAAC,CAAC,CAAC;IACjCA,YAAY,CAAC,CAAC,CAAC,GAAG,MAAMF,IAAI,CAACG,QAAQ,CAACI,CAAC,CAAC;IACxC,IAAIL,YAAY,CAACM,KAAK,CAAC,CAACC,GAAG,EAAEC,KAAK,KAAKD,GAAG,KAAKR,MAAM,CAACS,KAAK,CAAC,CAAC,EAAE;MAC7DJ,YAAY,GAAGC,CAAC;MAChB;IACF;EACF;EAEA,OAAOD,YAAY;AACrB,CAAC"}

package/dist/esm/tar-builder.js

@@ -3,14 +3,14 @@ import Tar from './lib/tar/tar';
 const TAR_BUILDER_OPTIONS = {
   recordsPerBlock: 20
 };
-export default class TARBuilder {
+export class TarBuilder {
   static get properties() {
     return {
       id: 'tar',
       name: 'TAR',
       extensions: ['tar'],
       mimeTypes: ['application/x-tar'],
-      builder: TARBuilder,
+      builder: TarBuilder,
       options: TAR_BUILDER_OPTIONS
     };
   }

package/dist/esm/tar-builder.js.map

@@ -1 +1 @@
-{"version":3,"file":"tar-builder.js","names":["Tar","TAR_BUILDER_OPTIONS","recordsPerBlock","TARBuilder","properties","id","name","extensions","mimeTypes","builder","options","constructor","_defineProperty","tape","addFile","filename","buffer","append","Uint8Array","count","build","Response","save","arrayBuffer"],"sources":["../../src/tar-builder.ts"],"sourcesContent":["import Tar from './lib/tar/tar';\n\nconst TAR_BUILDER_OPTIONS = {\n  recordsPerBlock: 20\n};\n\ntype TarBuilderOptions = {\n  recordsPerBlock?: number;\n};\n\n/**\n * Build a tar file by adding files\n */\nexport default class TARBuilder {\n  static get properties() {\n    return {\n      id: 'tar',\n      name: 'TAR',\n      extensions: ['tar'],\n      mimeTypes: ['application/x-tar'],\n      builder: TARBuilder,\n      options: TAR_BUILDER_OPTIONS\n    };\n  }\n\n  options: TarBuilderOptions;\n  tape: Tar;\n  count: number = 0;\n\n  constructor(options?: Partial<TarBuilderOptions>) {\n    this.options = {...TAR_BUILDER_OPTIONS, ...options};\n    this.tape = new Tar(this.options.recordsPerBlock);\n  }\n  /** Adds a file to the archive. */\n  addFile(filename: string, buffer: ArrayBuffer) {\n    this.tape.append(filename, new Uint8Array(buffer));\n    this.count++;\n  }\n\n  async build(): Promise<ArrayBuffer> {\n    return new Response(this.tape.save()).arrayBuffer();\n  }\n}\n"],"mappings":";AAAA,OAAOA,GAAG,MAAM,eAAe;AAE/B,MAAMC,mBAAmB,GAAG;EAC1BC,eAAe,EAAE;AACnB,CAAC;AASD,eAAe,MAAMC,UAAU,CAAC;EAC9B,WAAWC,UAAUA,CAAA,EAAG;IACtB,OAAO;MACLC,EAAE,EAAE,KAAK;MACTC,IAAI,EAAE,KAAK;MACXC,UAAU,EAAE,CAAC,KAAK,CAAC;MACnBC,SAAS,EAAE,CAAC,mBAAmB,CAAC;MAChCC,OAAO,EAAEN,UAAU;MACnBO,OAAO,EAAET;IACX,CAAC;EACH;EAMAU,WAAWA,CAACD,OAAoC,EAAE;IAAAE,eAAA;IAAAA,eAAA;IAAAA,eAAA,gBAFlC,CAAC;IAGf,IAAI,CAACF,OAAO,GAAG;MAAC,GAAGT,mBAAmB;MAAE,GAAGS;IAAO,CAAC;IACnD,IAAI,CAACG,IAAI,GAAG,IAAIb,GAAG,CAAC,IAAI,CAACU,OAAO,CAACR,eAAe,CAAC;EACnD;EAEAY,OAAOA,CAACC,QAAgB,EAAEC,MAAmB,EAAE;IAC7C,IAAI,CAACH,IAAI,CAACI,MAAM,CAACF,QAAQ,EAAE,IAAIG,UAAU,CAACF,MAAM,CAAC,CAAC;IAClD,IAAI,CAACG,KAAK,EAAE;EACd;EAEA,MAAMC,KAAKA,CAAA,EAAyB;IAClC,OAAO,IAAIC,QAAQ,CAAC,IAAI,CAACR,IAAI,CAACS,IAAI,CAAC,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC;EACrD;AACF"}
+{"version":3,"file":"tar-builder.js","names":["Tar","TAR_BUILDER_OPTIONS","recordsPerBlock","TarBuilder","properties","id","name","extensions","mimeTypes","builder","options","constructor","_defineProperty","tape","addFile","filename","buffer","append","Uint8Array","count","build","Response","save","arrayBuffer"],"sources":["../../src/tar-builder.ts"],"sourcesContent":["import Tar from './lib/tar/tar';\n\nconst TAR_BUILDER_OPTIONS = {\n  recordsPerBlock: 20\n};\n\ntype TarBuilderOptions = {\n  recordsPerBlock?: number;\n};\n\n/**\n * Build a tar file by adding files\n */\nexport class TarBuilder {\n  static get properties() {\n    return {\n      id: 'tar',\n      name: 'TAR',\n      extensions: ['tar'],\n      mimeTypes: ['application/x-tar'],\n      builder: TarBuilder,\n      options: TAR_BUILDER_OPTIONS\n    };\n  }\n\n  options: TarBuilderOptions;\n  tape: Tar;\n  count: number = 0;\n\n  constructor(options?: Partial<TarBuilderOptions>) {\n    this.options = {...TAR_BUILDER_OPTIONS, ...options};\n    this.tape = new Tar(this.options.recordsPerBlock);\n  }\n  /** Adds a file to the archive. */\n  addFile(filename: string, buffer: ArrayBuffer) {\n    this.tape.append(filename, new Uint8Array(buffer));\n    this.count++;\n  }\n\n  async build(): Promise<ArrayBuffer> {\n    return new Response(this.tape.save()).arrayBuffer();\n  }\n}\n"],"mappings":";AAAA,OAAOA,GAAG,MAAM,eAAe;AAE/B,MAAMC,mBAAmB,GAAG;EAC1BC,eAAe,EAAE;AACnB,CAAC;AASD,OAAO,MAAMC,UAAU,CAAC;EACtB,WAAWC,UAAUA,CAAA,EAAG;IACtB,OAAO;MACLC,EAAE,EAAE,KAAK;MACTC,IAAI,EAAE,KAAK;MACXC,UAAU,EAAE,CAAC,KAAK,CAAC;MACnBC,SAAS,EAAE,CAAC,mBAAmB,CAAC;MAChCC,OAAO,EAAEN,UAAU;MACnBO,OAAO,EAAET;IACX,CAAC;EACH;EAMAU,WAAWA,CAACD,OAAoC,EAAE;IAAAE,eAAA;IAAAA,eAAA;IAAAA,eAAA,gBAFlC,CAAC;IAGf,IAAI,CAACF,OAAO,GAAG;MAAC,GAAGT,mBAAmB;MAAE,GAAGS;IAAO,CAAC;IACnD,IAAI,CAACG,IAAI,GAAG,IAAIb,GAAG,CAAC,IAAI,CAACU,OAAO,CAACR,eAAe,CAAC;EACnD;EAEAY,OAAOA,CAACC,QAAgB,EAAEC,MAAmB,EAAE;IAC7C,IAAI,CAACH,IAAI,CAACI,MAAM,CAACF,QAAQ,EAAE,IAAIG,UAAU,CAACF,MAAM,CAAC,CAAC;IAClD,IAAI,CAACG,KAAK,EAAE;EACd;EAEA,MAAMC,KAAKA,CAAA,EAAyB;IAClC,OAAO,IAAIC,QAAQ,CAAC,IAAI,CAACR,IAAI,CAACS,IAAI,CAAC,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC;EACrD;AACF"}

package/dist/esm/zip-loader.js

@@ -1,5 +1,5 @@
 import JSZip from 'jszip';
-const VERSION = typeof "4.0.0-alpha.9" !== 'undefined' ? "4.0.0-alpha.9" : 'latest';
+const VERSION = typeof "4.0.0-beta.1" !== 'undefined' ? "4.0.0-beta.1" : 'latest';
 export const ZipLoader = {
   id: 'zip',
   module: 'zip',
@@ -43,5 +43,4 @@ async function loadZipEntry(jsZip, subFilename) {
     return error;
   }
 }
-export const _typecheckZipLoader = ZipLoader;
 //# sourceMappingURL=zip-loader.js.map

package/dist/esm/zip-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip-loader.js","names":["JSZip","VERSION","ZipLoader","id","module","name","version","extensions","mimeTypes","category","tests","options","parse","parseZipAsync","data","arguments","length","undefined","promises","fileMap","jsZip","zip","loadAsync","forEach","relativePath","zipEntry","subFilename","promise","loadZipEntry","then","arrayBufferOrError","push","Promise","all","error","log","concat","arrayBuffer","file","async","dataType","_typecheckZipLoader"],"sources":["../../src/zip-loader.ts"],"sourcesContent":["// Zip loader\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport JSZip from 'jszip';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\ntype FileMap = Record<string, ArrayBuffer>;\n\nexport const ZipLoader: LoaderWithParser<FileMap, never, LoaderOptions> = {\n  id: 'zip',\n  module: 'zip',\n  name: 'Zip Archive',\n  version: VERSION,\n  extensions: ['zip'],\n  mimeTypes: ['application/zip'],\n  category: 'archive',\n  tests: ['PK'],\n  options: {},\n  parse: parseZipAsync\n};\n\n// TODO - Could return a map of promises, perhaps as an option...\nasync function parseZipAsync(data: any, options = {}): Promise<FileMap> {\n  const promises: Promise<any>[] = [];\n  const fileMap: Record<string, ArrayBuffer> = {};\n\n  try {\n    const jsZip = new JSZip();\n\n    const zip = await jsZip.loadAsync(data, options);\n\n    // start to load each file in this zip\n    zip.forEach((relativePath, zipEntry) => {\n      const subFilename = zipEntry.name;\n\n      const promise = loadZipEntry(jsZip, subFilename, options).then((arrayBufferOrError) => {\n        fileMap[relativePath] = arrayBufferOrError;\n      });\n\n      // Ensure Promise.all doesn't ignore rejected promises.\n      promises.push(promise);\n    });\n\n    await Promise.all(promises);\n    return fileMap;\n  } catch (error) {\n    // @ts-ignore\n    options.log.error(`Unable to read zip archive: ${error}`);\n    throw error;\n  }\n}\n\nasync function loadZipEntry(jsZip: any, subFilename: string, options: any = {}) {\n  // jszip supports both arraybuffer and text, the main loaders.gl types\n  // https://stuk.github.io/jszip/documentation/api_zipobject/async.html\n  try {\n    const arrayBuffer = await jsZip.file(subFilename).async(options.dataType || 'arraybuffer');\n    return arrayBuffer;\n  } catch (error) {\n    options.log.error(`Unable to read ${subFilename} from zip archive: ${error}`);\n    // Store error in place of data in map\n    return error;\n  }\n}\n\nexport const _typecheckZipLoader: LoaderWithParser = ZipLoader;\n"],"mappings":"AAEA,OAAOA,KAAK,MAAM,OAAO;AAIzB,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAI3E,OAAO,MAAMC,SAA0D,GAAG;EACxEC,EAAE,EAAE,KAAK;EACTC,MAAM,EAAE,KAAK;EACbC,IAAI,EAAE,aAAa;EACnBC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,KAAK,CAAC;EACnBC,SAAS,EAAE,CAAC,iBAAiB,CAAC;EAC9BC,QAAQ,EAAE,SAAS;EACnBC,KAAK,EAAE,CAAC,IAAI,CAAC;EACbC,OAAO,EAAE,CAAC,CAAC;EACXC,KAAK,EAAEC;AACT,CAAC;AAGD,eAAeA,aAAaA,CAACC,IAAS,EAAkC;EAAA,IAAhCH,OAAO,GAAAI,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAClD,MAAMG,QAAwB,GAAG,EAAE;EACnC,MAAMC,OAAoC,GAAG,CAAC,CAAC;EAE/C,IAAI;IACF,MAAMC,KAAK,GAAG,IAAIpB,KAAK,CAAC,CAAC;IAEzB,MAAMqB,GAAG,GAAG,MAAMD,KAAK,CAACE,SAAS,CAACR,IAAI,EAAEH,OAAO,CAAC;IAGhDU,GAAG,CAACE,OAAO,CAAC,CAACC,YAAY,EAAEC,QAAQ,KAAK;MACtC,MAAMC,WAAW,GAAGD,QAAQ,CAACpB,IAAI;MAEjC,MAAMsB,OAAO,GAAGC,YAAY,CAACR,KAAK,EAAEM,WAAW,EAAEf,OAAO,CAAC,CAACkB,IAAI,CAAEC,kBAAkB,IAAK;QACrFX,OAAO,CAACK,YAAY,CAAC,GAAGM,kBAAkB;MAC5C,CAAC,CAAC;MAGFZ,QAAQ,CAACa,IAAI,CAACJ,OAAO,CAAC;IACxB,CAAC,CAAC;IAEF,MAAMK,OAAO,CAACC,GAAG,CAACf,QAAQ,CAAC;IAC3B,OAAOC,OAAO;EAChB,CAAC,CAAC,OAAOe,KAAK,EAAE;IAEdvB,OAAO,CAACwB,GAAG,CAACD,KAAK,gCAAAE,MAAA,CAAgCF,KAAK,CAAE,CAAC;IACzD,MAAMA,KAAK;EACb;AACF;AAEA,eAAeN,YAAYA,CAACR,KAAU,EAAEM,WAAmB,EAAqB;EAAA,IAAnBf,OAAY,GAAAI,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAG5E,IAAI;IACF,MAAMsB,WAAW,GAAG,MAAMjB,KAAK,CAACkB,IAAI,CAACZ,WAAW,CAAC,CAACa,KAAK,CAAC5B,OAAO,CAAC6B,QAAQ,IAAI,aAAa,CAAC;IAC1F,OAAOH,WAAW;EACpB,CAAC,CAAC,OAAOH,KAAK,EAAE;IACdvB,OAAO,CAACwB,GAAG,CAACD,KAAK,mBAAAE,MAAA,CAAmBV,WAAW,yBAAAU,MAAA,CAAsBF,KAAK,CAAE,CAAC;IAE7E,OAAOA,KAAK;EACd;AACF;AAEA,OAAO,MAAMO,mBAAqC,GAAGvC,SAAS"}
+{"version":3,"file":"zip-loader.js","names":["JSZip","VERSION","ZipLoader","id","module","name","version","extensions","mimeTypes","category","tests","options","parse","parseZipAsync","data","arguments","length","undefined","promises","fileMap","jsZip","zip","loadAsync","forEach","relativePath","zipEntry","subFilename","promise","loadZipEntry","then","arrayBufferOrError","push","Promise","all","error","log","concat","arrayBuffer","file","async","dataType"],"sources":["../../src/zip-loader.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport JSZip from 'jszip';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\ntype FileMap = Record<string, ArrayBuffer>;\n\nexport const ZipLoader: LoaderWithParser<FileMap, never, LoaderOptions> = {\n  id: 'zip',\n  module: 'zip',\n  name: 'Zip Archive',\n  version: VERSION,\n  extensions: ['zip'],\n  mimeTypes: ['application/zip'],\n  category: 'archive',\n  tests: ['PK'],\n  options: {},\n  parse: parseZipAsync\n};\n\n// TODO - Could return a map of promises, perhaps as an option...\nasync function parseZipAsync(data: any, options = {}): Promise<FileMap> {\n  const promises: Promise<any>[] = [];\n  const fileMap: Record<string, ArrayBuffer> = {};\n\n  try {\n    const jsZip = new JSZip();\n\n    const zip = await jsZip.loadAsync(data, options);\n\n    // start to load each file in this zip\n    zip.forEach((relativePath, zipEntry) => {\n      const subFilename = zipEntry.name;\n\n      const promise = loadZipEntry(jsZip, subFilename, options).then((arrayBufferOrError) => {\n        fileMap[relativePath] = arrayBufferOrError;\n      });\n\n      // Ensure Promise.all doesn't ignore rejected promises.\n      promises.push(promise);\n    });\n\n    await Promise.all(promises);\n    return fileMap;\n  } catch (error) {\n    // @ts-ignore\n    options.log.error(`Unable to read zip archive: ${error}`);\n    throw error;\n  }\n}\n\nasync function loadZipEntry(jsZip: any, subFilename: string, options: any = {}) {\n  // jszip supports both arraybuffer and text, the main loaders.gl types\n  // https://stuk.github.io/jszip/documentation/api_zipobject/async.html\n  try {\n    const arrayBuffer = await jsZip.file(subFilename).async(options.dataType || 'arraybuffer');\n    return arrayBuffer;\n  } catch (error) {\n    options.log.error(`Unable to read ${subFilename} from zip archive: ${error}`);\n    // Store error in place of data in map\n    return error;\n  }\n}\n"],"mappings":"AAGA,OAAOA,KAAK,MAAM,OAAO;AAIzB,MAAMC,OAAO,GAAG,qBAAkB,KAAK,WAAW,oBAAiB,QAAQ;AAI3E,OAAO,MAAMC,SAA0D,GAAG;EACxEC,EAAE,EAAE,KAAK;EACTC,MAAM,EAAE,KAAK;EACbC,IAAI,EAAE,aAAa;EACnBC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,KAAK,CAAC;EACnBC,SAAS,EAAE,CAAC,iBAAiB,CAAC;EAC9BC,QAAQ,EAAE,SAAS;EACnBC,KAAK,EAAE,CAAC,IAAI,CAAC;EACbC,OAAO,EAAE,CAAC,CAAC;EACXC,KAAK,EAAEC;AACT,CAAC;AAGD,eAAeA,aAAaA,CAACC,IAAS,EAAkC;EAAA,IAAhCH,OAAO,GAAAI,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAClD,MAAMG,QAAwB,GAAG,EAAE;EACnC,MAAMC,OAAoC,GAAG,CAAC,CAAC;EAE/C,IAAI;IACF,MAAMC,KAAK,GAAG,IAAIpB,KAAK,CAAC,CAAC;IAEzB,MAAMqB,GAAG,GAAG,MAAMD,KAAK,CAACE,SAAS,CAACR,IAAI,EAAEH,OAAO,CAAC;IAGhDU,GAAG,CAACE,OAAO,CAAC,CAACC,YAAY,EAAEC,QAAQ,KAAK;MACtC,MAAMC,WAAW,GAAGD,QAAQ,CAACpB,IAAI;MAEjC,MAAMsB,OAAO,GAAGC,YAAY,CAACR,KAAK,EAAEM,WAAW,EAAEf,OAAO,CAAC,CAACkB,IAAI,CAAEC,kBAAkB,IAAK;QACrFX,OAAO,CAACK,YAAY,CAAC,GAAGM,kBAAkB;MAC5C,CAAC,CAAC;MAGFZ,QAAQ,CAACa,IAAI,CAACJ,OAAO,CAAC;IACxB,CAAC,CAAC;IAEF,MAAMK,OAAO,CAACC,GAAG,CAACf,QAAQ,CAAC;IAC3B,OAAOC,OAAO;EAChB,CAAC,CAAC,OAAOe,KAAK,EAAE;IAEdvB,OAAO,CAACwB,GAAG,CAACD,KAAK,gCAAAE,MAAA,CAAgCF,KAAK,CAAE,CAAC;IACzD,MAAMA,KAAK;EACb;AACF;AAEA,eAAeN,YAAYA,CAACR,KAAU,EAAEM,WAAmB,EAAqB;EAAA,IAAnBf,OAAY,GAAAI,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAG5E,IAAI;IACF,MAAMsB,WAAW,GAAG,MAAMjB,KAAK,CAACkB,IAAI,CAACZ,WAAW,CAAC,CAACa,KAAK,CAAC5B,OAAO,CAAC6B,QAAQ,IAAI,aAAa,CAAC;IAC1F,OAAOH,WAAW;EACpB,CAAC,CAAC,OAAOH,KAAK,EAAE;IACdvB,OAAO,CAACwB,GAAG,CAACD,KAAK,mBAAAE,MAAA,CAAmBV,WAAW,yBAAAU,MAAA,CAAsBF,KAAK,CAAE,CAAC;IAE7E,OAAOA,KAAK;EACd;AACF"}