@loaders.gl/i3s 4.0.0-alpha.20 → 4.0.0-alpha.22

package/dist/dist.min.js

@@ -713,6 +713,15 @@
     }
   });
 
+  // ../loader-utils/src/loader-types.ts
+  async function parseFromContext(data, loaders, options, context) {
+    return context._parse(data, loaders, options, context);
+  }
+  var init_loader_types = __esm({
+    "../loader-utils/src/loader-types.ts"() {
+    }
+  });
+
   // ../loader-utils/src/lib/env-utils/assert.ts
   function assert(condition, message) {
     if (!condition) {
@@ -1768,6 +1777,7 @@
   // ../loader-utils/src/index.ts
   var init_src2 = __esm({
     "../loader-utils/src/index.ts"() {
+      init_loader_types();
       init_assert();
       init_globals();
       init_parse_with_worker();
@@ -1789,7 +1799,7 @@
       isFunction = (x) => typeof x === "function";
       isObject = (x) => x !== null && typeof x === "object";
       isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
-      isIterable = (x) => x && typeof x[Symbol.iterator] === "function";
+      isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
       isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
       isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
       isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
@@ -2715,6 +2725,11 @@
     loaders._state = loaders._state || {};
     return loaders._state;
   }
+  function getGlobalLoaderOptions() {
+    const state = getGlobalLoaderState();
+    state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
+    return state.globalOptions;
+  }
   function normalizeOptions(options, loader, loaders, url) {
     loaders = loaders || [];
     loaders = Array.isArray(loaders) ? loaders : [loaders];
@@ -2795,17 +2810,11 @@
       options.baseUri = url;
     }
   }
-  var getGlobalLoaderOptions;
   var init_option_utils = __esm({
     "../core/src/lib/loader-utils/option-utils.ts"() {
       init_is_type();
       init_loggers();
       init_option_defaults();
-      getGlobalLoaderOptions = () => {
-        const state = getGlobalLoaderState();
-        state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
-        return state.globalOptions;
-      };
     }
   });
 
@@ -2926,8 +2935,10 @@
     reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
     reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
-    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    if (options?.fallbackMimeType) {
+      loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+      reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    }
     if (reason) {
       log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
     }
@@ -3023,7 +3034,7 @@
     }
     switch (typeof test) {
       case "function":
-        return test(data, loader);
+        return test(data);
       case "string":
         const magic = getMagicString(data, byteOffset, test.length);
         return test === magic;
@@ -3296,7 +3307,7 @@
     return newContext;
   }
   function getLoadersFromContext(loaders, context) {
-    if (!context && loaders && !Array.isArray(loaders)) {
+    if (loaders && !Array.isArray(loaders)) {
       return loaders;
     }
     let candidateLoaders;
@@ -3307,7 +3318,7 @@
       const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
       candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
     }
-    return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+    return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
   }
   var init_loader_context = __esm({
     "../core/src/lib/loader-utils/loader-context.ts"() {
@@ -3319,7 +3330,6 @@
 
   // ../core/src/lib/api/parse.ts
   async function parse(data, loaders, options, context) {
-    assert2(!context || typeof context === "object");
     if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
       options = loaders;
@@ -3335,7 +3345,7 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
+    context = getLoaderContext({ url, _parse: parse, loaders: candidateLoaders }, options, context || null);
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
@@ -3347,26 +3357,26 @@
       context.response = { headers, ok, redirected, status, statusText, type, url };
     }
     data = await getArrayBufferOrStringFromData(data, loader, options);
-    if (loader.parseTextSync && typeof data === "string") {
-      options.dataType = "text";
-      return loader.parseTextSync(data, options, context, loader);
+    const loaderWithParser = loader;
+    if (loaderWithParser.parseTextSync && typeof data === "string") {
+      return loaderWithParser.parseTextSync(data, options, context);
     }
     if (canParseWithWorker(loader, options)) {
       return await parseWithWorker(loader, data, options, context, parse);
     }
-    if (loader.parseText && typeof data === "string") {
-      return await loader.parseText(data, options, context, loader);
+    if (loaderWithParser.parseText && typeof data === "string") {
+      return await loaderWithParser.parseText(data, options, context);
     }
-    if (loader.parse) {
-      return await loader.parse(data, options, context, loader);
+    if (loaderWithParser.parse) {
+      return await loaderWithParser.parse(data, options, context);
     }
-    assert2(!loader.parseSync);
+    assert2(!loaderWithParser.parseSync);
     throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
   }
   var init_parse = __esm({
     "../core/src/lib/api/parse.ts"() {
-      init_src();
       init_src2();
+      init_src();
       init_normalize_loader();
       init_is_type();
       init_option_utils();
@@ -9168,9 +9178,11 @@
         if (loader === ImageLoader) {
           const options2 = { ...tileOptions.textureLoaderOptions, image: { type: "data" } };
           try {
-            content.texture = await context.parse(arrayBuffer2, options2);
+            const texture = await parseFromContext(arrayBuffer2, [], options2, context);
+            content.texture = texture;
           } catch (e2) {
-            content.texture = await parse(arrayBuffer2, loader, options2);
+            const texture = await parse(arrayBuffer2, loader, options2, context);
+            content.texture = texture;
           }
         } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
           let texture = await load(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
@@ -9512,6 +9524,7 @@
       init_src3();
       init_esm2();
       init_esm3();
+      init_src2();
       init_src4();
       init_src6();
       init_src7();
@@ -10532,99 +10545,40 @@
     }
   });
 
-  // ../zip/src/parse-zip/cd-file-header.ts
-  var offsets, signature, parseZipCDFileHeader;
-  var init_cd_file_header = __esm({
-    "../zip/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
+  // ../zip/src/file-provider/data-view-file.ts
+  var toNumber, DataViewFile;
+  var init_data_view_file = __esm({
+    "../zip/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);
       };
-      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;
+      DataViewFile = class {
+        constructor(file) {
+          this.file = file;
         }
-        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;
+        async destroy() {
         }
-        if (compressedSize === BigInt(4294967295)) {
-          compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
-          offsetInZip64Data += 8n;
+        async getUint8(offset) {
+          return this.file.getUint8(toNumber(offset));
         }
-        if (fileDataOffset === BigInt(4294967295)) {
-          fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        async getUint16(offset) {
+          return this.file.getUint16(toNumber(offset), true);
         }
-        const localHeaderOffset = fileDataOffset;
-        return {
-          compressedSize,
-          uncompressedSize,
-          extraFieldLength,
-          fileNameLength,
-          fileName,
-          extraOffset,
-          localHeaderOffset
-        };
-      };
-    }
-  });
-
-  // ../zip/src/parse-zip/local-file-header.ts
-  var offsets2, signature2, parseZipLocalFileHeader;
-  var init_local_file_header = __esm({
-    "../zip/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;
+        async getUint32(offset) {
+          return this.file.getUint32(toNumber(offset), true);
         }
-        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;
+        async getBigUint64(offset) {
+          return this.file.getBigUint64(toNumber(offset), true);
         }
-        if (compressedSize === BigInt(4294967295)) {
-          compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
-          offsetInZip64Data += 8n;
+        async slice(startOffset, endOffset) {
+          return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
         }
-        if (fileDataOffset === BigInt(4294967295)) {
-          fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        get length() {
+          return BigInt(this.file.byteLength);
         }
-        return {
-          fileNameLength,
-          fileName,
-          extraFieldLength,
-          fileDataOffset,
-          compressedSize
-        };
       };
     }
   });
@@ -10657,35 +10611,33 @@
   });
 
   // ../zip/src/parse-zip/end-of-central-directory.ts
-  var eoCDSignature, zip64EoCDLocatorSignature, zip64EoCDSignature, offsets3, parseEoCDRecord;
+  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({
     "../zip/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
-      };
+      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));
+        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 + offsets3.ZIP64_EOCD_START_OFFSET_OFFSET);
+          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 + offsets3.ZIP64_CD_RECORDS_NUMBER_OFFSET);
-          cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + offsets3.ZIP64_CD_START_OFFSET_OFFSET);
+          cdRecordsNumber = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+          cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
         }
         return {
           cdRecordsNumber,
@@ -10695,101 +10647,111 @@
     }
   });
 
-  // ../zip/src/parse-zip/data-view-file.ts
-  var toNumber, DataViewFile;
-  var init_data_view_file = __esm({
-    "../zip/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);
+  // ../zip/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({
+    "../zip/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;
         }
-        async getBigUint64(offset) {
-          return this.file.getBigUint64(toNumber(offset), true);
+        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;
         }
-        async slice(startOffset, endOffset) {
-          return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+        if (compressedSize === BigInt(4294967295)) {
+          compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+          offsetInZip64Data += 8n;
         }
-        get length() {
-          return BigInt(this.file.byteLength);
+        if (fileDataOffset === BigInt(4294967295)) {
+          fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
         }
+        const localHeaderOffset = fileDataOffset;
+        return {
+          compressedSize,
+          uncompressedSize,
+          extraFieldLength,
+          fileNameLength,
+          fileName,
+          extraOffset,
+          localHeaderOffset
+        };
       };
     }
   });
 
-  // ../zip/src/hash-file-utility.ts
-  var compareHashes, parseHashFile, findBin;
-  var init_hash_file_utility = __esm({
-    "../zip/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;
+  // ../zip/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({
+    "../zip/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;
         }
-        return 1;
-      };
-      parseHashFile = (hashFile) => {
-        const hashFileBuffer = Buffer.from(hashFile);
-        const hashArray = [];
-        for (let i2 = 0; i2 < hashFileBuffer.buffer.byteLength; i2 = i2 + 24) {
-          const offsetBuffer = new DataView(hashFileBuffer.buffer.slice(hashFileBuffer.byteOffset + i2 + 16, hashFileBuffer.byteOffset + i2 + 24));
-          const offset = offsetBuffer.getBigUint64(offsetBuffer.byteOffset, true);
-          hashArray.push({
-            hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i2, hashFileBuffer.byteOffset + i2 + 16)),
-            offset
-          });
+        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;
         }
-        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;
-          }
+        if (compressedSize === BigInt(4294967295)) {
+          compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+          offsetInZip64Data += 8n;
         }
-        return void 0;
+        if (fileDataOffset === BigInt(4294967295)) {
+          fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+        }
+        return {
+          fileNameLength,
+          fileName,
+          extraFieldLength,
+          fileDataOffset,
+          compressedSize,
+          compressionMethod
+        };
       };
     }
   });
 
-  // ../zip/src/index.ts
-  var init_src9 = __esm({
-    "../zip/src/index.ts"() {
-      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();
-    }
-  });
-
   // ../../node_modules/crypt/crypt.js
   var require_crypt = __commonJS({
     "../../node_modules/crypt/crypt.js"(exports, module) {
@@ -11028,6 +10990,67 @@
     }
   });
 
+  // ../zip/src/hash-file-utility.ts
+  var import_md5, compareHashes, parseHashFile, findBin, generateHashInfo;
+  var init_hash_file_utility = __esm({
+    "../zip/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 i2 = 0; i2 < hashFileBuffer.buffer.byteLength; i2 = i2 + 24) {
+          const offsetBuffer = new DataView(hashFileBuffer.buffer.slice(hashFileBuffer.byteOffset + i2 + 16, hashFileBuffer.byteOffset + i2 + 24));
+          const offset = offsetBuffer.getBigUint64(offsetBuffer.byteOffset, true);
+          hashArray.push({
+            hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i2, hashFileBuffer.byteOffset + i2 + 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((a2, b) => compareHashes(a2.hash, b.hash));
+        return hashInfo;
+      };
+    }
+  });
+
   // ../compression/src/lib/compression.ts
   var Compression;
   var init_compression = __esm({
@@ -15220,7 +15243,8 @@
           }
           const pakoOptions = this.options?.deflate || {};
           const inputArray = new Uint8Array(input);
-          return import_pako.default.deflate(inputArray, pakoOptions).buffer;
+          const deflate = this.options?.raw ? import_pako.default.deflateRaw : import_pako.default.deflate;
+          return deflate(inputArray, pakoOptions).buffer;
         }
         decompressSync(input) {
           if (!isBrowser && this.options.deflate?.useZlib) {
@@ -15229,7 +15253,8 @@
           }
           const pakoOptions = this.options?.deflate || {};
           const inputArray = new Uint8Array(input);
-          return import_pako.default.inflate(inputArray, pakoOptions).buffer;
+          const inflate = this.options?.raw ? import_pako.default.inflateRaw : import_pako.default.inflate;
+          return inflate(inputArray, pakoOptions).buffer;
         }
         async *compressBatches(asyncIterator) {
           const pakoOptions = this.options?.deflate || {};
@@ -15309,19 +15334,30 @@
   });
 
   // ../compression/src/index.ts
-  var init_src10 = __esm({
+  var init_src9 = __esm({
     "../compression/src/index.ts"() {
       init_gzip_compression();
     }
   });
 
+  // ../zip/src/index.ts
+  var init_src10 = __esm({
+    "../zip/src/index.ts"() {
+      init_data_view_file();
+      init_cd_file_header();
+      init_local_file_header();
+      init_search_from_the_end();
+      init_hash_file_utility();
+    }
+  });
+
   // src/lib/parsers/parse-slpk/slpk-archieve.ts
-  var import_md5, PATH_DESCRIPTIONS, SLPKArchive;
+  var import_md52, PATH_DESCRIPTIONS, SLPKArchive;
   var init_slpk_archieve = __esm({
     "src/lib/parsers/parse-slpk/slpk-archieve.ts"() {
-      import_md5 = __toModule(require_md5());
-      init_src9();
+      import_md52 = __toModule(require_md5());
       init_src10();
+      init_src9();
       PATH_DESCRIPTIONS = [
         {
           test: /^$/,
@@ -15405,7 +15441,7 @@
           return Buffer.from(data);
         }
         async getFileBytes(path) {
-          const nameHash = Buffer.from((0, import_md5.default)(path), "hex");
+          const nameHash = Buffer.from((0, import_md52.default)(path), "hex");
           const fileInfo = findBin(nameHash, this.hashArray);
           if (!fileInfo) {
             return void 0;
@@ -15425,11 +15461,10 @@
   });
 
   // src/lib/parsers/parse-slpk/parse-slpk.ts
-  var import_md52, parseSLPK, generateHashInfo;
+  var parseSLPK;
   var init_parse_slpk = __esm({
     "src/lib/parsers/parse-slpk/parse-slpk.ts"() {
-      import_md52 = __toModule(require_md5());
-      init_src9();
+      init_src10();
       init_slpk_archieve();
       parseSLPK = async (fileProvider, cb) => {
         const hashCDOffset = await searchFromTheEnd(fileProvider, signature);
@@ -15451,20 +15486,6 @@
         }
         return new SLPKArchive(fileProvider, hashData);
       };
-      generateHashInfo = async (fileProvider) => {
-        const { cdStartOffset } = await parseEoCDRecord(fileProvider);
-        let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);
-        const hashInfo = [];
-        while (cdHeader) {
-          hashInfo.push({
-            hash: Buffer.from((0, import_md52.default)(cdHeader.fileName.split("\\").join("/").toLocaleLowerCase()), "hex"),
-            offset: cdHeader.localHeaderOffset
-          });
-          cdHeader = await parseZipCDFileHeader(cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength), fileProvider);
-        }
-        hashInfo.sort((a2, b) => compareHashes(a2.hash, b.hash));
-        return hashInfo;
-      };
     }
   });
 
@@ -15475,7 +15496,7 @@
   var VERSION12, SLPKLoader;
   var init_i3s_slpk_loader = __esm({
     "src/i3s-slpk-loader.ts"() {
-      init_src9();
+      init_src10();
       init_parse_slpk();
       VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       SLPKLoader = {