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

package/dist/dist.min.js

@@ -3027,18 +3027,649 @@
     }
   });
 
+  // (disabled):fs
+  var init_fs = __esm({
+    "(disabled):fs"() {
+    }
+  });
+
+  // src/file-provider/file-handle.ts
+  var _FileHandle, FileHandle;
+  var init_file_handle = __esm({
+    "src/file-provider/file-handle.ts"() {
+      init_fs();
+      _FileHandle = class {
+        constructor(fileDescriptor, stats) {
+          this.read = (buffer, offset, length, position) => {
+            return new Promise((s) => {
+              (0, import_fs.read)(this.fileDescriptor, buffer, offset, length, position, (_err, bytesRead, buffer2) => s({ bytesRead, buffer: buffer2 }));
+            });
+          };
+          this.fileDescriptor = fileDescriptor;
+          this.stats = stats;
+        }
+        async close() {
+          return new Promise((resolve) => {
+            (0, import_fs.close)(this.fileDescriptor, (_err) => resolve());
+          });
+        }
+        get stat() {
+          return this.stats;
+        }
+      };
+      FileHandle = _FileHandle;
+      FileHandle.open = async (path) => {
+        const [fd, stats] = await Promise.all([
+          new Promise((s) => {
+            (0, import_fs.open)(path, void 0, void 0, (_err, fd2) => s(fd2));
+          }),
+          new Promise((s) => {
+            (0, import_fs.stat)(path, { bigint: true }, (_err, stats2) => s(stats2));
+          })
+        ]);
+        return new _FileHandle(fd, stats);
+      };
+    }
+  });
+
+  // src/file-provider/file-handle-file.ts
+  var FileHandleFile;
+  var init_file_handle_file = __esm({
+    "src/file-provider/file-handle-file.ts"() {
+      init_file_handle();
+      FileHandleFile = class {
+        static async from(path) {
+          const fileDescriptor = await FileHandle.open(path);
+          return new FileHandleFile(fileDescriptor, fileDescriptor.stat.size);
+        }
+        constructor(fileDescriptor, size) {
+          this.fileDescriptor = fileDescriptor;
+          this.size = size;
+        }
+        async destroy() {
+          await this.fileDescriptor.close();
+        }
+        async getUint8(offset) {
+          const val = new Uint8Array((await this.fileDescriptor.read(Buffer.alloc(1), 0, 1, offset)).buffer.buffer).at(0);
+          if (val === void 0) {
+            throw new Error("something went wrong");
+          }
+          return val;
+        }
+        async getUint16(offset) {
+          const val = new Uint16Array((await this.fileDescriptor.read(Buffer.alloc(2), 0, 2, offset)).buffer.buffer).at(0);
+          if (val === void 0) {
+            throw new Error("something went wrong");
+          }
+          return val;
+        }
+        async getUint32(offset) {
+          const val = new Uint32Array((await this.fileDescriptor.read(Buffer.alloc(4), 0, 4, offset)).buffer.buffer).at(0);
+          if (val === void 0) {
+            throw new Error("something went wrong");
+          }
+          return val;
+        }
+        async getBigUint64(offset) {
+          const val = new BigInt64Array((await this.fileDescriptor.read(Buffer.alloc(8), 0, 8, offset)).buffer.buffer).at(0);
+          if (val === void 0) {
+            throw new Error("something went wrong");
+          }
+          return val;
+        }
+        async slice(startOffsset, endOffset) {
+          const bigLength = endOffset - startOffsset;
+          if (bigLength > Number.MAX_SAFE_INTEGER) {
+            throw new Error("too big slice");
+          }
+          const length = Number(bigLength);
+          return (await this.fileDescriptor.read(Buffer.alloc(length), 0, length, startOffsset)).buffer.buffer;
+        }
+        get length() {
+          return this.size;
+        }
+      };
+    }
+  });
+
+  // src/file-provider/data-view-file.ts
+  var toNumber, DataViewFile;
+  var init_data_view_file = __esm({
+    "src/file-provider/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 destroy() {
+        }
+        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/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, CD_RECORDS_NUMBER_OFFSET, CD_START_OFFSET_OFFSET, ZIP64_EOCD_START_OFFSET_OFFSET, ZIP64_CD_RECORDS_NUMBER_OFFSET, ZIP64_CD_START_OFFSET_OFFSET, 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]);
+      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 + CD_RECORDS_NUMBER_OFFSET));
+        let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + 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 + ZIP64_EOCD_START_OFFSET_OFFSET);
+          if (Buffer.from(await fileProvider.slice(zip64EoCDOffset, zip64EoCDOffset + 4n)).compare(zip64EoCDSignature) !== 0) {
+            throw new Error("zip64 EoCD not found");
+          }
+          cdRecordsNumber = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+          cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+        }
+        return {
+          cdRecordsNumber,
+          cdStartOffset
+        };
+      };
+    }
+  });
+
+  // src/parse-zip/cd-file-header.ts
+  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);
+    }
+  }
+  var 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;
+  var init_cd_file_header = __esm({
+    "src/parse-zip/cd-file-header.ts"() {
+      init_end_of_central_directory();
+      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 + 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(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 COMPRESSION_METHOD_OFFSET, COMPRESSED_SIZE_OFFSET, UNCOMPRESSED_SIZE_OFFSET, FILE_NAME_LENGTH_OFFSET, EXTRA_FIELD_LENGTH_OFFSET, FILE_NAME_OFFSET, signature2, parseZipLocalFileHeader;
+  var init_local_file_header = __esm({
+    "src/parse-zip/local-file-header.ts"() {
+      COMPRESSION_METHOD_OFFSET = 8n;
+      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 + FILE_NAME_LENGTH_OFFSET);
+        const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + FILE_NAME_OFFSET, headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength))).split("\\").join("/");
+        const extraFieldLength = await buffer.getUint16(headerOffset + EXTRA_FIELD_LENGTH_OFFSET);
+        let fileDataOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
+        const compressionMethod = await buffer.getUint16(headerOffset + COMPRESSION_METHOD_OFFSET);
+        let compressedSize = BigInt(await buffer.getUint32(headerOffset + COMPRESSED_SIZE_OFFSET));
+        let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET));
+        const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);
+        let offsetInZip64Data = 4n;
+        if (uncompressedSize === BigInt(4294967295)) {
+          uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+          offsetInZip64Data += 8n;
+        }
+        if (compressedSize === BigInt(4294967295)) {
+          compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+          offsetInZip64Data += 8n;
+        }
+        if (fileDataOffset === BigInt(4294967295)) {
+          fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        }
+        return {
+          fileNameLength,
+          fileName,
+          extraFieldLength,
+          fileDataOffset,
+          compressedSize,
+          compressionMethod
+        };
+      };
+    }
+  });
+
+  // ../../node_modules/crypt/crypt.js
+  var require_crypt = __commonJS({
+    "../../node_modules/crypt/crypt.js"(exports, module) {
+      (function() {
+        var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", crypt = {
+          rotl: function(n, b) {
+            return n << b | n >>> 32 - b;
+          },
+          rotr: function(n, b) {
+            return n << 32 - b | n >>> b;
+          },
+          endian: function(n) {
+            if (n.constructor == Number) {
+              return crypt.rotl(n, 8) & 16711935 | crypt.rotl(n, 24) & 4278255360;
+            }
+            for (var i = 0; i < n.length; i++)
+              n[i] = crypt.endian(n[i]);
+            return n;
+          },
+          randomBytes: function(n) {
+            for (var bytes = []; n > 0; n--)
+              bytes.push(Math.floor(Math.random() * 256));
+            return bytes;
+          },
+          bytesToWords: function(bytes) {
+            for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)
+              words[b >>> 5] |= bytes[i] << 24 - b % 32;
+            return words;
+          },
+          wordsToBytes: function(words) {
+            for (var bytes = [], b = 0; b < words.length * 32; b += 8)
+              bytes.push(words[b >>> 5] >>> 24 - b % 32 & 255);
+            return bytes;
+          },
+          bytesToHex: function(bytes) {
+            for (var hex = [], i = 0; i < bytes.length; i++) {
+              hex.push((bytes[i] >>> 4).toString(16));
+              hex.push((bytes[i] & 15).toString(16));
+            }
+            return hex.join("");
+          },
+          hexToBytes: function(hex) {
+            for (var bytes = [], c = 0; c < hex.length; c += 2)
+              bytes.push(parseInt(hex.substr(c, 2), 16));
+            return bytes;
+          },
+          bytesToBase64: function(bytes) {
+            for (var base64 = [], i = 0; i < bytes.length; i += 3) {
+              var triplet = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+              for (var j = 0; j < 4; j++)
+                if (i * 8 + j * 6 <= bytes.length * 8)
+                  base64.push(base64map.charAt(triplet >>> 6 * (3 - j) & 63));
+                else
+                  base64.push("=");
+            }
+            return base64.join("");
+          },
+          base64ToBytes: function(base64) {
+            base64 = base64.replace(/[^A-Z0-9+\/]/ig, "");
+            for (var bytes = [], i = 0, imod4 = 0; i < base64.length; imod4 = ++i % 4) {
+              if (imod4 == 0)
+                continue;
+              bytes.push((base64map.indexOf(base64.charAt(i - 1)) & Math.pow(2, -2 * imod4 + 8) - 1) << imod4 * 2 | base64map.indexOf(base64.charAt(i)) >>> 6 - imod4 * 2);
+            }
+            return bytes;
+          }
+        };
+        module.exports = crypt;
+      })();
+    }
+  });
+
+  // ../../node_modules/charenc/charenc.js
+  var require_charenc = __commonJS({
+    "../../node_modules/charenc/charenc.js"(exports, module) {
+      var charenc = {
+        utf8: {
+          stringToBytes: function(str) {
+            return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+          },
+          bytesToString: function(bytes) {
+            return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+          }
+        },
+        bin: {
+          stringToBytes: function(str) {
+            for (var bytes = [], i = 0; i < str.length; i++)
+              bytes.push(str.charCodeAt(i) & 255);
+            return bytes;
+          },
+          bytesToString: function(bytes) {
+            for (var str = [], i = 0; i < bytes.length; i++)
+              str.push(String.fromCharCode(bytes[i]));
+            return str.join("");
+          }
+        }
+      };
+      module.exports = charenc;
+    }
+  });
+
+  // ../../node_modules/is-buffer/index.js
+  var require_is_buffer = __commonJS({
+    "../../node_modules/is-buffer/index.js"(exports, module) {
+      module.exports = function(obj) {
+        return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+      };
+      function isBuffer(obj) {
+        return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+      }
+      function isSlowBuffer(obj) {
+        return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
+      }
+    }
+  });
+
+  // ../../node_modules/md5/md5.js
+  var require_md5 = __commonJS({
+    "../../node_modules/md5/md5.js"(exports, module) {
+      (function() {
+        var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer = require_is_buffer(), bin = require_charenc().bin, md52 = function(message, options) {
+          if (message.constructor == String)
+            if (options && options.encoding === "binary")
+              message = bin.stringToBytes(message);
+            else
+              message = utf8.stringToBytes(message);
+          else if (isBuffer(message))
+            message = Array.prototype.slice.call(message, 0);
+          else if (!Array.isArray(message) && message.constructor !== Uint8Array)
+            message = message.toString();
+          var m = crypt.bytesToWords(message), l = message.length * 8, a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
+          for (var i = 0; i < m.length; i++) {
+            m[i] = (m[i] << 8 | m[i] >>> 24) & 16711935 | (m[i] << 24 | m[i] >>> 8) & 4278255360;
+          }
+          m[l >>> 5] |= 128 << l % 32;
+          m[(l + 64 >>> 9 << 4) + 14] = l;
+          var FF = md52._ff, GG = md52._gg, HH = md52._hh, II = md52._ii;
+          for (var i = 0; i < m.length; i += 16) {
+            var aa = a, bb = b, cc = c, dd = d;
+            a = FF(a, b, c, d, m[i + 0], 7, -680876936);
+            d = FF(d, a, b, c, m[i + 1], 12, -389564586);
+            c = FF(c, d, a, b, m[i + 2], 17, 606105819);
+            b = FF(b, c, d, a, m[i + 3], 22, -1044525330);
+            a = FF(a, b, c, d, m[i + 4], 7, -176418897);
+            d = FF(d, a, b, c, m[i + 5], 12, 1200080426);
+            c = FF(c, d, a, b, m[i + 6], 17, -1473231341);
+            b = FF(b, c, d, a, m[i + 7], 22, -45705983);
+            a = FF(a, b, c, d, m[i + 8], 7, 1770035416);
+            d = FF(d, a, b, c, m[i + 9], 12, -1958414417);
+            c = FF(c, d, a, b, m[i + 10], 17, -42063);
+            b = FF(b, c, d, a, m[i + 11], 22, -1990404162);
+            a = FF(a, b, c, d, m[i + 12], 7, 1804603682);
+            d = FF(d, a, b, c, m[i + 13], 12, -40341101);
+            c = FF(c, d, a, b, m[i + 14], 17, -1502002290);
+            b = FF(b, c, d, a, m[i + 15], 22, 1236535329);
+            a = GG(a, b, c, d, m[i + 1], 5, -165796510);
+            d = GG(d, a, b, c, m[i + 6], 9, -1069501632);
+            c = GG(c, d, a, b, m[i + 11], 14, 643717713);
+            b = GG(b, c, d, a, m[i + 0], 20, -373897302);
+            a = GG(a, b, c, d, m[i + 5], 5, -701558691);
+            d = GG(d, a, b, c, m[i + 10], 9, 38016083);
+            c = GG(c, d, a, b, m[i + 15], 14, -660478335);
+            b = GG(b, c, d, a, m[i + 4], 20, -405537848);
+            a = GG(a, b, c, d, m[i + 9], 5, 568446438);
+            d = GG(d, a, b, c, m[i + 14], 9, -1019803690);
+            c = GG(c, d, a, b, m[i + 3], 14, -187363961);
+            b = GG(b, c, d, a, m[i + 8], 20, 1163531501);
+            a = GG(a, b, c, d, m[i + 13], 5, -1444681467);
+            d = GG(d, a, b, c, m[i + 2], 9, -51403784);
+            c = GG(c, d, a, b, m[i + 7], 14, 1735328473);
+            b = GG(b, c, d, a, m[i + 12], 20, -1926607734);
+            a = HH(a, b, c, d, m[i + 5], 4, -378558);
+            d = HH(d, a, b, c, m[i + 8], 11, -2022574463);
+            c = HH(c, d, a, b, m[i + 11], 16, 1839030562);
+            b = HH(b, c, d, a, m[i + 14], 23, -35309556);
+            a = HH(a, b, c, d, m[i + 1], 4, -1530992060);
+            d = HH(d, a, b, c, m[i + 4], 11, 1272893353);
+            c = HH(c, d, a, b, m[i + 7], 16, -155497632);
+            b = HH(b, c, d, a, m[i + 10], 23, -1094730640);
+            a = HH(a, b, c, d, m[i + 13], 4, 681279174);
+            d = HH(d, a, b, c, m[i + 0], 11, -358537222);
+            c = HH(c, d, a, b, m[i + 3], 16, -722521979);
+            b = HH(b, c, d, a, m[i + 6], 23, 76029189);
+            a = HH(a, b, c, d, m[i + 9], 4, -640364487);
+            d = HH(d, a, b, c, m[i + 12], 11, -421815835);
+            c = HH(c, d, a, b, m[i + 15], 16, 530742520);
+            b = HH(b, c, d, a, m[i + 2], 23, -995338651);
+            a = II(a, b, c, d, m[i + 0], 6, -198630844);
+            d = II(d, a, b, c, m[i + 7], 10, 1126891415);
+            c = II(c, d, a, b, m[i + 14], 15, -1416354905);
+            b = II(b, c, d, a, m[i + 5], 21, -57434055);
+            a = II(a, b, c, d, m[i + 12], 6, 1700485571);
+            d = II(d, a, b, c, m[i + 3], 10, -1894986606);
+            c = II(c, d, a, b, m[i + 10], 15, -1051523);
+            b = II(b, c, d, a, m[i + 1], 21, -2054922799);
+            a = II(a, b, c, d, m[i + 8], 6, 1873313359);
+            d = II(d, a, b, c, m[i + 15], 10, -30611744);
+            c = II(c, d, a, b, m[i + 6], 15, -1560198380);
+            b = II(b, c, d, a, m[i + 13], 21, 1309151649);
+            a = II(a, b, c, d, m[i + 4], 6, -145523070);
+            d = II(d, a, b, c, m[i + 11], 10, -1120210379);
+            c = II(c, d, a, b, m[i + 2], 15, 718787259);
+            b = II(b, c, d, a, m[i + 9], 21, -343485551);
+            a = a + aa >>> 0;
+            b = b + bb >>> 0;
+            c = c + cc >>> 0;
+            d = d + dd >>> 0;
+          }
+          return crypt.endian([a, b, c, d]);
+        };
+        md52._ff = function(a, b, c, d, x, s, t) {
+          var n = a + (b & c | ~b & d) + (x >>> 0) + t;
+          return (n << s | n >>> 32 - s) + b;
+        };
+        md52._gg = function(a, b, c, d, x, s, t) {
+          var n = a + (b & d | c & ~d) + (x >>> 0) + t;
+          return (n << s | n >>> 32 - s) + b;
+        };
+        md52._hh = function(a, b, c, d, x, s, t) {
+          var n = a + (b ^ c ^ d) + (x >>> 0) + t;
+          return (n << s | n >>> 32 - s) + b;
+        };
+        md52._ii = function(a, b, c, d, x, s, t) {
+          var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+          return (n << s | n >>> 32 - s) + b;
+        };
+        md52._blocksize = 16;
+        md52._digestsize = 16;
+        module.exports = function(message, options) {
+          if (message === void 0 || message === null)
+            throw new Error("Illegal argument " + message);
+          var digestbytes = crypt.wordsToBytes(md52(message, options));
+          return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
+        };
+      })();
+    }
+  });
+
+  // src/hash-file-utility.ts
+  var import_md5, compareHashes, parseHashFile, findBin, generateHashInfo;
+  var init_hash_file_utility = __esm({
+    "src/hash-file-utility.ts"() {
+      import_md5 = __toModule(require_md5());
+      init_cd_file_header();
+      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;
+      };
+      generateHashInfo = async (fileProvider) => {
+        const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+        const hashInfo = [];
+        for await (const cdHeader of zipCDIterator) {
+          hashInfo.push({
+            hash: Buffer.from((0, import_md5.default)(cdHeader.fileName.split("\\").join("/").toLocaleLowerCase()), "hex"),
+            offset: cdHeader.localHeaderOffset
+          });
+        }
+        hashInfo.sort((a, b) => compareHashes(a.hash, b.hash));
+        return hashInfo;
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    DataViewFile: () => DataViewFile,
+    FileHandleFile: () => FileHandleFile,
     TarBuilder: () => TARBuilder,
     ZipLoader: () => ZipLoader,
-    ZipWriter: () => ZipWriter
+    ZipWriter: () => ZipWriter,
+    cdSignature: () => signature,
+    compareHashes: () => compareHashes,
+    findBin: () => findBin,
+    generateHashInfo: () => generateHashInfo,
+    localHeaderSignature: () => signature2,
+    parseEoCDRecord: () => parseEoCDRecord,
+    parseHashFile: () => parseHashFile,
+    parseZipCDFileHeader: () => parseZipCDFileHeader,
+    parseZipLocalFileHeader: () => parseZipLocalFileHeader,
+    searchFromTheEnd: () => searchFromTheEnd,
+    zipCDFileHeaderGenerator: () => zipCDFileHeaderGenerator
   });
   var init_src = __esm({
     "src/index.ts"() {
       init_zip_loader();
       init_zip_writer();
       init_tar_builder();
+      init_file_handle_file();
+      init_data_view_file();
+      init_cd_file_header();
+      init_local_file_header();
+      init_end_of_central_directory();
+      init_search_from_the_end();
+      init_hash_file_utility();
     }
   });
 
@@ -3063,3 +3694,9 @@ Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/js
 JSZip uses the library pako released under the MIT license :
 https://github.com/nodeca/pako/blob/main/LICENSE
 */
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */