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

package/dist/dist.min.js

@@ -3027,18 +3027,280 @@
     }
   });
 
+  // src/parse-zip/cd-file-header.ts
+  var offsets, signature, parseZipCDFileHeader;
+  var init_cd_file_header = __esm({
+    "src/parse-zip/cd-file-header.ts"() {
+      offsets = {
+        CD_COMPRESSED_SIZE_OFFSET: 20n,
+        CD_UNCOMPRESSED_SIZE_OFFSET: 24n,
+        CD_FILE_NAME_LENGTH_OFFSET: 28n,
+        CD_EXTRA_FIELD_LENGTH_OFFSET: 30n,
+        CD_LOCAL_HEADER_OFFSET_OFFSET: 42n,
+        CD_FILE_NAME_OFFSET: 46n
+      };
+      signature = [80, 75, 1, 2];
+      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 + offsets.CD_COMPRESSED_SIZE_OFFSET));
+        let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + offsets.CD_UNCOMPRESSED_SIZE_OFFSET));
+        const extraFieldLength = await buffer.getUint16(headerOffset + offsets.CD_EXTRA_FIELD_LENGTH_OFFSET);
+        const fileNameLength = await buffer.getUint16(headerOffset + offsets.CD_FILE_NAME_LENGTH_OFFSET);
+        const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + offsets.CD_FILE_NAME_OFFSET, headerOffset + offsets.CD_FILE_NAME_OFFSET + BigInt(fileNameLength)));
+        const extraOffset = headerOffset + offsets.CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
+        const oldFormatOffset = await buffer.getUint32(headerOffset + offsets.CD_LOCAL_HEADER_OFFSET_OFFSET);
+        let fileDataOffset = BigInt(oldFormatOffset);
+        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);
+        }
+        const localHeaderOffset = fileDataOffset;
+        return {
+          compressedSize,
+          uncompressedSize,
+          extraFieldLength,
+          fileNameLength,
+          fileName,
+          extraOffset,
+          localHeaderOffset
+        };
+      };
+    }
+  });
+
+  // src/parse-zip/local-file-header.ts
+  var offsets2, signature2, parseZipLocalFileHeader;
+  var init_local_file_header = __esm({
+    "src/parse-zip/local-file-header.ts"() {
+      offsets2 = {
+        COMPRESSED_SIZE_OFFSET: 18n,
+        UNCOMPRESSED_SIZE_OFFSET: 22n,
+        FILE_NAME_LENGTH_OFFSET: 26n,
+        EXTRA_FIELD_LENGTH_OFFSET: 28n,
+        FILE_NAME_OFFSET: 30n
+      };
+      signature2 = Buffer.from([80, 75, 3, 4]);
+      parseZipLocalFileHeader = async (headerOffset, buffer) => {
+        if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(signature2) !== 0) {
+          return null;
+        }
+        const fileNameLength = await buffer.getUint16(headerOffset + offsets2.FILE_NAME_LENGTH_OFFSET);
+        const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + offsets2.FILE_NAME_OFFSET, headerOffset + offsets2.FILE_NAME_OFFSET + BigInt(fileNameLength))).split("\\").join("/");
+        const extraFieldLength = await buffer.getUint16(headerOffset + offsets2.EXTRA_FIELD_LENGTH_OFFSET);
+        let fileDataOffset = headerOffset + offsets2.FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
+        let compressedSize = BigInt(await buffer.getUint32(headerOffset + offsets2.COMPRESSED_SIZE_OFFSET));
+        let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + offsets2.UNCOMPRESSED_SIZE_OFFSET));
+        const extraOffset = headerOffset + offsets2.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
+        };
+      };
+    }
+  });
+
+  // src/parse-zip/search-from-the-end.ts
+  var searchFromTheEnd;
+  var init_search_from_the_end = __esm({
+    "src/parse-zip/search-from-the-end.ts"() {
+      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, zip64EoCDLocatorSignature, zip64EoCDSignature, offsets3, parseEoCDRecord;
+  var init_end_of_central_directory = __esm({
+    "src/parse-zip/end-of-central-directory.ts"() {
+      init_search_from_the_end();
+      eoCDSignature = [80, 75, 5, 6];
+      zip64EoCDLocatorSignature = Buffer.from([80, 75, 6, 7]);
+      zip64EoCDSignature = Buffer.from([80, 75, 6, 6]);
+      offsets3 = {
+        CD_RECORDS_NUMBER_OFFSET: 8n,
+        CD_START_OFFSET_OFFSET: 16n,
+        ZIP64_EOCD_START_OFFSET_OFFSET: 8n,
+        ZIP64_CD_RECORDS_NUMBER_OFFSET: 24n,
+        ZIP64_CD_START_OFFSET_OFFSET: 48n
+      };
+      parseEoCDRecord = async (fileProvider) => {
+        const zipEoCDOffset = await searchFromTheEnd(fileProvider, eoCDSignature);
+        let cdRecordsNumber = BigInt(await fileProvider.getUint16(zipEoCDOffset + offsets3.CD_RECORDS_NUMBER_OFFSET));
+        let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + offsets3.CD_START_OFFSET_OFFSET));
+        if (cdStartOffset === BigInt(4294967295) || cdRecordsNumber === BigInt(4294967295)) {
+          const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+          if (Buffer.from(await fileProvider.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n)).compare(zip64EoCDLocatorSignature) !== 0) {
+            throw new Error("zip64 EoCD locator not found");
+          }
+          const zip64EoCDOffset = await fileProvider.getBigUint64(zip64EoCDLocatorOffset + offsets3.ZIP64_EOCD_START_OFFSET_OFFSET);
+          if (Buffer.from(await fileProvider.slice(zip64EoCDOffset, zip64EoCDOffset + 4n)).compare(zip64EoCDSignature) !== 0) {
+            throw new Error("zip64 EoCD not found");
+          }
+          cdRecordsNumber = await fileProvider.getBigUint64(zip64EoCDOffset + offsets3.ZIP64_CD_RECORDS_NUMBER_OFFSET);
+          cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + offsets3.ZIP64_CD_START_OFFSET_OFFSET);
+        }
+        return {
+          cdRecordsNumber,
+          cdStartOffset
+        };
+      };
+    }
+  });
+
+  // src/parse-zip/data-view-file.ts
+  var toNumber, DataViewFile;
+  var init_data_view_file = __esm({
+    "src/parse-zip/data-view-file.ts"() {
+      toNumber = (bigint) => {
+        if (bigint > Number.MAX_SAFE_INTEGER) {
+          throw new Error("Offset is out of bounds");
+        }
+        return Number(bigint);
+      };
+      DataViewFile = class {
+        constructor(file) {
+          this.file = file;
+        }
+        async getUint8(offset) {
+          return this.file.getUint8(toNumber(offset));
+        }
+        async getUint16(offset) {
+          return this.file.getUint16(toNumber(offset), true);
+        }
+        async getUint32(offset) {
+          return this.file.getUint32(toNumber(offset), true);
+        }
+        async getBigUint64(offset) {
+          return this.file.getBigUint64(toNumber(offset), true);
+        }
+        async slice(startOffset, endOffset) {
+          return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+        }
+        get length() {
+          return BigInt(this.file.byteLength);
+        }
+      };
+    }
+  });
+
+  // src/hash-file-utility.ts
+  var compareHashes, parseHashFile, findBin;
+  var init_hash_file_utility = __esm({
+    "src/hash-file-utility.ts"() {
+      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;
+      };
+      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;
+      };
+      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 void 0;
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    DataViewFile: () => DataViewFile,
     TarBuilder: () => TARBuilder,
     ZipLoader: () => ZipLoader,
-    ZipWriter: () => ZipWriter
+    ZipWriter: () => ZipWriter,
+    cdSignature: () => signature,
+    compareHashes: () => compareHashes,
+    findBin: () => findBin,
+    localHeaderSignature: () => signature2,
+    parseEoCDRecord: () => parseEoCDRecord,
+    parseHashFile: () => parseHashFile,
+    parseZipCDFileHeader: () => parseZipCDFileHeader,
+    parseZipLocalFileHeader: () => parseZipLocalFileHeader,
+    searchFromTheEnd: () => searchFromTheEnd
   });
   var init_src = __esm({
     "src/index.ts"() {
       init_zip_loader();
       init_zip_writer();
       init_tar_builder();
+      init_cd_file_header();
+      init_local_file_header();
+      init_end_of_central_directory();
+      init_search_from_the_end();
+      init_data_view_file();
+      init_hash_file_utility();
     }
   });
 

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

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseHashFile = exports.findBin = exports.compareHashes = void 0;
+var compareHashes = function compareHashes(hash1, hash2) {
+  var h1 = new BigUint64Array(hash1.buffer, hash1.byteOffset, 2);
+  var h2 = new BigUint64Array(hash2.buffer, hash2.byteOffset, 2);
+  var 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;
+};
+exports.compareHashes = compareHashes;
+var parseHashFile = function parseHashFile(hashFile) {
+  var hashFileBuffer = Buffer.from(hashFile);
+  var hashArray = [];
+  for (var i = 0; i < hashFileBuffer.buffer.byteLength; i = i + 24) {
+    var offsetBuffer = new DataView(hashFileBuffer.buffer.slice(hashFileBuffer.byteOffset + i + 16, hashFileBuffer.byteOffset + i + 24));
+    var offset = offsetBuffer.getBigUint64(offsetBuffer.byteOffset, true);
+    hashArray.push({
+      hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i, hashFileBuffer.byteOffset + i + 16)),
+      offset: offset
+    });
+  }
+  return hashArray;
+};
+exports.parseHashFile = parseHashFile;
+var findBin = function findBin(hashToSearch, hashArray) {
+  var lowerBorder = 0;
+  var upperBorder = hashArray.length;
+  while (upperBorder - lowerBorder > 1) {
+    var middle = lowerBorder + Math.floor((upperBorder - lowerBorder) / 2);
+    var value = compareHashes(hashArray[middle].hash, hashToSearch);
+    if (value === 0) {
+      return hashArray[middle];
+    } else if (value < 0) {
+      lowerBorder = middle;
+    } else {
+      upperBorder = middle;
+    }
+  }
+  return undefined;
+};
+exports.findBin = findBin;
+//# sourceMappingURL=hash-file-utility.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash-file-utility.js","names":["compareHashes","hash1","hash2","h1","BigUint64Array","buffer","byteOffset","h2","diff","exports","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"],"sources":["../../src/hash-file-utility.ts"],"sourcesContent":["/** 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"],"mappings":";;;;;;AAcO,IAAMA,aAAa,GAAG,SAAhBA,aAAaA,CAAIC,KAAa,EAAEC,KAAa,EAAa;EACrE,IAAMC,EAAE,GAAG,IAAIC,cAAc,CAACH,KAAK,CAACI,MAAM,EAAEJ,KAAK,CAACK,UAAU,EAAE,CAAC,CAAC;EAChE,IAAMC,EAAE,GAAG,IAAIH,cAAc,CAACF,KAAK,CAACG,MAAM,EAAEH,KAAK,CAACI,UAAU,EAAE,CAAC,CAAC;EAEhE,IAAME,IAAI,GAAGL,EAAE,CAAC,CAAC,CAAC,KAAKI,EAAE,CAAC,CAAC,CAAC,GAAGJ,EAAE,CAAC,CAAC,CAAC,GAAGI,EAAE,CAAC,CAAC,CAAC,GAAGJ,EAAE,CAAC,CAAC,CAAC,GAAGI,EAAE,CAAC,CAAC,CAAC;EAE5D,IAAIC,IAAI,GAAG,EAAE,EAAE;IACb,OAAO,CAAC,CAAC;EACX,CAAC,MAAM,IAAIA,IAAI,KAAK,EAAE,EAAE;IACtB,OAAO,CAAC;EACV;EACA,OAAO,CAAC;AACV,CAAC;AAACC,OAAA,CAAAT,aAAA,GAAAA,aAAA;AAOK,IAAMU,aAAa,GAAG,SAAhBA,aAAaA,CAAIC,QAAqB,EAAoB;EACrE,IAAMC,cAAc,GAAGC,MAAM,CAACC,IAAI,CAACH,QAAQ,CAAC;EAC5C,IAAMI,SAAwB,GAAG,EAAE;EACnC,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGJ,cAAc,CAACP,MAAM,CAACY,UAAU,EAAED,CAAC,GAAGA,CAAC,GAAG,EAAE,EAAE;IAChE,IAAME,YAAY,GAAG,IAAIC,QAAQ,CAC/BP,cAAc,CAACP,MAAM,CAACe,KAAK,CACzBR,cAAc,CAACN,UAAU,GAAGU,CAAC,GAAG,EAAE,EAClCJ,cAAc,CAACN,UAAU,GAAGU,CAAC,GAAG,EAClC,CACF,CAAC;IACD,IAAMK,MAAM,GAAGH,YAAY,CAACI,YAAY,CAACJ,YAAY,CAACZ,UAAU,EAAE,IAAI,CAAC;IACvES,SAAS,CAACQ,IAAI,CAAC;MACbC,IAAI,EAAEX,MAAM,CAACC,IAAI,CACfF,cAAc,CAACa,QAAQ,CAACb,cAAc,CAACN,UAAU,GAAGU,CAAC,EAAEJ,cAAc,CAACN,UAAU,GAAGU,CAAC,GAAG,EAAE,CAC3F,CAAC;MACDK,MAAM,EAANA;IACF,CAAC,CAAC;EACJ;EACA,OAAON,SAAS;AAClB,CAAC;AAACN,OAAA,CAAAC,aAAA,GAAAA,aAAA;AAOK,IAAMgB,OAAO,GAAG,SAAVA,OAAOA,CAClBC,YAAoB,EACpBZ,SAAwB,EACI;EAC5B,IAAIa,WAAW,GAAG,CAAC;EACnB,IAAIC,WAAW,GAAGd,SAAS,CAACe,MAAM;EAElC,OAAOD,WAAW,GAAGD,WAAW,GAAG,CAAC,EAAE;IACpC,IAAMG,MAAM,GAAGH,WAAW,GAAGI,IAAI,CAACC,KAAK,CAAC,CAACJ,WAAW,GAAGD,WAAW,IAAI,CAAC,CAAC;IACxE,IAAMM,KAAK,GAAGlC,aAAa,CAACe,SAAS,CAACgB,MAAM,CAAC,CAACP,IAAI,EAAEG,YAAY,CAAC;IACjE,IAAIO,KAAK,KAAK,CAAC,EAAE;MACf,OAAOnB,SAAS,CAACgB,MAAM,CAAC;IAC1B,CAAC,MAAM,IAAIG,KAAK,GAAG,CAAC,EAAE;MACpBN,WAAW,GAAGG,MAAM;IACtB,CAAC,MAAM;MACLF,WAAW,GAAGE,MAAM;IACtB;EACF;EACA,OAAOI,SAAS;AAClB,CAAC;AAAC1B,OAAA,CAAAiB,OAAA,GAAAA,OAAA"}

package/dist/es5/index.js

@@ -4,6 +4,12 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "DataViewFile", {
+  enumerable: true,
+  get: function get() {
+    return _dataViewFile.DataViewFile;
+  }
+});
 Object.defineProperty(exports, "TarBuilder", {
   enumerable: true,
   get: function get() {
@@ -22,7 +28,67 @@ Object.defineProperty(exports, "ZipWriter", {
     return _zipWriter.ZipWriter;
   }
 });
+Object.defineProperty(exports, "cdSignature", {
+  enumerable: true,
+  get: function get() {
+    return _cdFileHeader.signature;
+  }
+});
+Object.defineProperty(exports, "compareHashes", {
+  enumerable: true,
+  get: function get() {
+    return _hashFileUtility.compareHashes;
+  }
+});
+Object.defineProperty(exports, "findBin", {
+  enumerable: true,
+  get: function get() {
+    return _hashFileUtility.findBin;
+  }
+});
+Object.defineProperty(exports, "localHeaderSignature", {
+  enumerable: true,
+  get: function get() {
+    return _localFileHeader.signature;
+  }
+});
+Object.defineProperty(exports, "parseEoCDRecord", {
+  enumerable: true,
+  get: function get() {
+    return _endOfCentralDirectory.parseEoCDRecord;
+  }
+});
+Object.defineProperty(exports, "parseHashFile", {
+  enumerable: true,
+  get: function get() {
+    return _hashFileUtility.parseHashFile;
+  }
+});
+Object.defineProperty(exports, "parseZipCDFileHeader", {
+  enumerable: true,
+  get: function get() {
+    return _cdFileHeader.parseZipCDFileHeader;
+  }
+});
+Object.defineProperty(exports, "parseZipLocalFileHeader", {
+  enumerable: true,
+  get: function get() {
+    return _localFileHeader.parseZipLocalFileHeader;
+  }
+});
+Object.defineProperty(exports, "searchFromTheEnd", {
+  enumerable: true,
+  get: function get() {
+    return _searchFromTheEnd.searchFromTheEnd;
+  }
+});
 var _zipLoader = require("./zip-loader");
 var _zipWriter = require("./zip-writer");
 var _tarBuilder = _interopRequireDefault(require("./tar-builder"));
+var _cdFileHeader = require("./parse-zip/cd-file-header");
+var _localFileHeader = require("./parse-zip/local-file-header");
+var _endOfCentralDirectory = require("./parse-zip/end-of-central-directory");
+var _searchFromTheEnd = require("./parse-zip/search-from-the-end");
+var _dataViewFile = require("./parse-zip/data-view-file");
+var _hashFileUtility = require("./hash-file-utility");
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_zipLoader","require","_zipWriter","_tarBuilder","_interopRequireDefault"],"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,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAC,sBAAA,CAAAH,OAAA"}
+{"version":3,"file":"index.js","names":["_zipLoader","require","_zipWriter","_tarBuilder","_interopRequireDefault","_cdFileHeader","_localFileHeader","_endOfCentralDirectory","_searchFromTheEnd","_dataViewFile","_hashFileUtility"],"sources":["../../src/index.ts"],"sourcesContent":["export {ZipLoader} from './zip-loader';\nexport {ZipWriter} from './zip-writer';\nexport {default as TarBuilder} from './tar-builder';\n\nexport type {FileProvider} from './parse-zip/file-provider';\nexport {parseZipCDFileHeader, signature as cdSignature} 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';\nexport {DataViewFile} from './parse-zip/data-view-file';\n\nexport type {HashElement} from './hash-file-utility';\nexport {compareHashes, parseHashFile, findBin} from './hash-file-utility';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAC,sBAAA,CAAAH,OAAA;AAGA,IAAAI,aAAA,GAAAJ,OAAA;AACA,IAAAK,gBAAA,GAAAL,OAAA;AAIA,IAAAM,sBAAA,GAAAN,OAAA;AACA,IAAAO,iBAAA,GAAAP,OAAA;AACA,IAAAQ,aAAA,GAAAR,OAAA;AAGA,IAAAS,gBAAA,GAAAT,OAAA"}

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

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.signature = exports.parseZipCDFileHeader = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var offsets = {
+  CD_COMPRESSED_SIZE_OFFSET: 20n,
+  CD_UNCOMPRESSED_SIZE_OFFSET: 24n,
+  CD_FILE_NAME_LENGTH_OFFSET: 28n,
+  CD_EXTRA_FIELD_LENGTH_OFFSET: 30n,
+  CD_LOCAL_HEADER_OFFSET_OFFSET: 42n,
+  CD_FILE_NAME_OFFSET: 46n
+};
+var signature = [0x50, 0x4b, 0x01, 0x02];
+exports.signature = signature;
+var parseZipCDFileHeader = function () {
+  var _ref = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(headerOffset, buffer) {
+    var compressedSize, uncompressedSize, extraFieldLength, fileNameLength, fileName, extraOffset, oldFormatOffset, fileDataOffset, offsetInZip64Data, localHeaderOffset;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.t0 = Buffer;
+          _context.next = 3;
+          return buffer.slice(headerOffset, headerOffset + 4n);
+        case 3:
+          _context.t1 = _context.sent;
+          _context.t2 = _context.t0.from.call(_context.t0, _context.t1).compare(Buffer.from(signature));
+          if (!(_context.t2 !== 0)) {
+            _context.next = 7;
+            break;
+          }
+          return _context.abrupt("return", null);
+        case 7:
+          _context.t3 = BigInt;
+          _context.next = 10;
+          return buffer.getUint32(headerOffset + offsets.CD_COMPRESSED_SIZE_OFFSET);
+        case 10:
+          _context.t4 = _context.sent;
+          compressedSize = (0, _context.t3)(_context.t4);
+          _context.t5 = BigInt;
+          _context.next = 15;
+          return buffer.getUint32(headerOffset + offsets.CD_UNCOMPRESSED_SIZE_OFFSET);
+        case 15:
+          _context.t6 = _context.sent;
+          uncompressedSize = (0, _context.t5)(_context.t6);
+          _context.next = 19;
+          return buffer.getUint16(headerOffset + offsets.CD_EXTRA_FIELD_LENGTH_OFFSET);
+        case 19:
+          extraFieldLength = _context.sent;
+          _context.next = 22;
+          return buffer.getUint16(headerOffset + offsets.CD_FILE_NAME_LENGTH_OFFSET);
+        case 22:
+          fileNameLength = _context.sent;
+          _context.t7 = new TextDecoder();
+          _context.next = 26;
+          return buffer.slice(headerOffset + offsets.CD_FILE_NAME_OFFSET, headerOffset + offsets.CD_FILE_NAME_OFFSET + BigInt(fileNameLength));
+        case 26:
+          _context.t8 = _context.sent;
+          fileName = _context.t7.decode.call(_context.t7, _context.t8);
+          extraOffset = headerOffset + offsets.CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
+          _context.next = 31;
+          return buffer.getUint32(headerOffset + offsets.CD_LOCAL_HEADER_OFFSET_OFFSET);
+        case 31:
+          oldFormatOffset = _context.sent;
+          fileDataOffset = BigInt(oldFormatOffset);
+          offsetInZip64Data = 4n;
+          if (!(uncompressedSize === BigInt(0xffffffff))) {
+            _context.next = 39;
+            break;
+          }
+          _context.next = 37;
+          return buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        case 37:
+          uncompressedSize = _context.sent;
+          offsetInZip64Data += 8n;
+        case 39:
+          if (!(compressedSize === BigInt(0xffffffff))) {
+            _context.next = 44;
+            break;
+          }
+          _context.next = 42;
+          return buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        case 42:
+          compressedSize = _context.sent;
+          offsetInZip64Data += 8n;
+        case 44:
+          if (!(fileDataOffset === BigInt(0xffffffff))) {
+            _context.next = 48;
+            break;
+          }
+          _context.next = 47;
+          return buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        case 47:
+          fileDataOffset = _context.sent;
+        case 48:
+          localHeaderOffset = fileDataOffset;
+          return _context.abrupt("return", {
+            compressedSize: compressedSize,
+            uncompressedSize: uncompressedSize,
+            extraFieldLength: extraFieldLength,
+            fileNameLength: fileNameLength,
+            fileName: fileName,
+            extraOffset: extraOffset,
+            localHeaderOffset: localHeaderOffset
+          });
+        case 50:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function parseZipCDFileHeader(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+exports.parseZipCDFileHeader = parseZipCDFileHeader;
+//# sourceMappingURL=cd-file-header.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cd-file-header.js","names":["offsets","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","exports","parseZipCDFileHeader","_ref","_asyncToGenerator2","default","_regenerator","mark","_callee","headerOffset","buffer","compressedSize","uncompressedSize","extraFieldLength","fileNameLength","fileName","extraOffset","oldFormatOffset","fileDataOffset","offsetInZip64Data","localHeaderOffset","wrap","_callee$","_context","prev","next","t0","Buffer","slice","t1","sent","t2","from","call","compare","abrupt","t3","BigInt","getUint32","t4","t5","t6","getUint16","t7","TextDecoder","t8","decode","getBigUint64","stop","_x","_x2","apply","arguments"],"sources":["../../../src/parse-zip/cd-file-header.ts"],"sourcesContent":["import {FileProvider} from './file-provider';\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\nconst offsets = {\n  CD_COMPRESSED_SIZE_OFFSET: 20n,\n  CD_UNCOMPRESSED_SIZE_OFFSET: 24n,\n  CD_FILE_NAME_LENGTH_OFFSET: 28n,\n  CD_EXTRA_FIELD_LENGTH_OFFSET: 30n,\n  CD_LOCAL_HEADER_OFFSET_OFFSET: 42n,\n  CD_FILE_NAME_OFFSET: 46n\n};\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(\n    await buffer.getUint32(headerOffset + offsets.CD_COMPRESSED_SIZE_OFFSET)\n  );\n\n  let uncompressedSize = BigInt(\n    await buffer.getUint32(headerOffset + offsets.CD_UNCOMPRESSED_SIZE_OFFSET)\n  );\n\n  const extraFieldLength = await buffer.getUint16(\n    headerOffset + offsets.CD_EXTRA_FIELD_LENGTH_OFFSET\n  );\n\n  const fileNameLength = await buffer.getUint16(headerOffset + offsets.CD_FILE_NAME_LENGTH_OFFSET);\n\n  const fileName = new TextDecoder().decode(\n    await buffer.slice(\n      headerOffset + offsets.CD_FILE_NAME_OFFSET,\n      headerOffset + offsets.CD_FILE_NAME_OFFSET + BigInt(fileNameLength)\n    )\n  );\n\n  const extraOffset = headerOffset + offsets.CD_FILE_NAME_OFFSET + BigInt(fileNameLength);\n\n  const oldFormatOffset = await buffer.getUint32(\n    headerOffset + offsets.CD_LOCAL_HEADER_OFFSET_OFFSET\n  );\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"],"mappings":"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"}