@loaders.gl/i3s 4.0.0-alpha.14 → 4.0.0-alpha.16

package/dist/dist.min.js

@@ -652,40 +652,18 @@
     }
   });
 
-  // src/types.ts
-  var DATA_TYPE, HeaderAttributeProperty;
-  var init_types = __esm({
-    "src/types.ts"() {
-      (function(DATA_TYPE2) {
-        DATA_TYPE2["UInt8"] = "UInt8";
-        DATA_TYPE2["UInt16"] = "UInt16";
-        DATA_TYPE2["UInt32"] = "UInt32";
-        DATA_TYPE2["UInt64"] = "UInt64";
-        DATA_TYPE2["Int16"] = "Int16";
-        DATA_TYPE2["Int32"] = "Int32";
-        DATA_TYPE2["Int64"] = "Int64";
-        DATA_TYPE2["Float32"] = "Float32";
-        DATA_TYPE2["Float64"] = "Float64";
-      })(DATA_TYPE || (DATA_TYPE = {}));
-      (function(HeaderAttributeProperty2) {
-        HeaderAttributeProperty2["vertexCount"] = "vertexCount";
-        HeaderAttributeProperty2["featureCount"] = "featureCount";
-      })(HeaderAttributeProperty || (HeaderAttributeProperty = {}));
-    }
-  });
-
   // src/lib/parsers/constants.ts
   function getConstructorForDataFormat(dataType) {
     switch (dataType) {
-      case DATA_TYPE.UInt8:
+      case "UInt8":
         return Uint8Array;
-      case DATA_TYPE.UInt16:
+      case "UInt16":
         return Uint16Array;
-      case DATA_TYPE.UInt32:
+      case "UInt32":
         return Uint32Array;
-      case DATA_TYPE.Float32:
+      case "Float32":
         return Float32Array;
-      case DATA_TYPE.UInt64:
+      case "UInt64":
         return Float64Array;
       default:
         throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
@@ -693,18 +671,18 @@
   }
   function sizeOf(dataType) {
     switch (dataType) {
-      case DATA_TYPE.UInt8:
+      case "UInt8":
         return 1;
-      case DATA_TYPE.UInt16:
-      case DATA_TYPE.Int16:
+      case "UInt16":
+      case "Int16":
         return 2;
-      case DATA_TYPE.UInt32:
-      case DATA_TYPE.Int32:
-      case DATA_TYPE.Float32:
+      case "UInt32":
+      case "Int32":
+      case "Float32":
         return 4;
-      case DATA_TYPE.UInt64:
-      case DATA_TYPE.Int64:
-      case DATA_TYPE.Float64:
+      case "UInt64":
+      case "Int64":
+      case "Float64":
         return 8;
       default:
         throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
@@ -714,7 +692,6 @@
   var init_constants = __esm({
     "src/lib/parsers/constants.ts"() {
       init_esm();
-      init_types();
       GL_TYPE_MAP = {
         UInt8: esm_default.UNSIGNED_BYTE,
         UInt16: esm_default.UNSIGNED_SHORT,
@@ -8833,6 +8810,17 @@
     }
   });
 
+  // src/types.ts
+  var HeaderAttributeProperty;
+  var init_types = __esm({
+    "src/types.ts"() {
+      (function(HeaderAttributeProperty2) {
+        HeaderAttributeProperty2["vertexCount"] = "vertexCount";
+        HeaderAttributeProperty2["featureCount"] = "featureCount";
+      })(HeaderAttributeProperty || (HeaderAttributeProperty = {}));
+    }
+  });
+
   // src/lib/utils/url-utils.ts
   function getUrlWithToken(url, token = null) {
     return token ? `${url}?token=${token}` : url;
@@ -10491,107 +10479,6 @@
     }
   });
 
-  // src/lib/parsers/parse-zip/buffer-file-provider.ts
-  var DataViewFileProvider;
-  var init_buffer_file_provider = __esm({
-    "src/lib/parsers/parse-zip/buffer-file-provider.ts"() {
-      DataViewFileProvider = class {
-        constructor(file) {
-          this.file = file;
-        }
-        getUint8(offset) {
-          return Promise.resolve(this.file.getUint8(offset));
-        }
-        getUint16(offset) {
-          return Promise.resolve(this.file.getUint16(offset, true));
-        }
-        getUint32(offset) {
-          return Promise.resolve(this.file.getUint32(offset, true));
-        }
-        slice(startOffset, endOffset) {
-          return Promise.resolve(this.file.buffer.slice(startOffset, endOffset));
-        }
-        get length() {
-          return this.file.byteLength;
-        }
-      };
-    }
-  });
-
-  // src/lib/parsers/parse-zip/cd-file-header.ts
-  var parseZipCDFileHeader;
-  var init_cd_file_header = __esm({
-    "src/lib/parsers/parse-zip/cd-file-header.ts"() {
-      parseZipCDFileHeader = async (headerOffset, buffer) => {
-        const offsets2 = {
-          CD_COMPRESSED_SIZE_OFFSET: 20,
-          CD_UNCOMPRESSED_SIZE_OFFSET: 24,
-          CD_FILE_NAME_LENGTH_OFFSET: 28,
-          CD_EXTRA_FIELD_LENGTH_OFFSET: 30,
-          CD_LOCAL_HEADER_OFFSET_OFFSET: 42,
-          CD_FILE_NAME_OFFSET: 46
-        };
-        const compressedSize = await buffer.getUint32(headerOffset + offsets2.CD_COMPRESSED_SIZE_OFFSET);
-        const uncompressedSize = await buffer.getUint32(headerOffset + offsets2.CD_UNCOMPRESSED_SIZE_OFFSET);
-        const fileNameLength = await buffer.getUint16(headerOffset + offsets2.CD_FILE_NAME_LENGTH_OFFSET);
-        const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + offsets2.CD_FILE_NAME_OFFSET, headerOffset + offsets2.CD_FILE_NAME_OFFSET + fileNameLength));
-        const extraOffset = headerOffset + offsets2.CD_FILE_NAME_OFFSET + fileNameLength;
-        const oldFormatOffset = await buffer.getUint32(headerOffset + offsets2.CD_LOCAL_HEADER_OFFSET_OFFSET);
-        let fileDataOffset = oldFormatOffset;
-        if (fileDataOffset === 4294967295) {
-          let offsetInZip64Data = 4;
-          if (compressedSize === 4294967295) {
-            offsetInZip64Data += 8;
-          }
-          if (uncompressedSize === 4294967295) {
-            offsetInZip64Data += 8;
-          }
-          fileDataOffset = await buffer.getUint32(extraOffset + offsetInZip64Data);
-        }
-        const localHeaderOffset = fileDataOffset;
-        return {
-          compressedSize,
-          uncompressedSize,
-          fileNameLength,
-          fileName,
-          extraOffset,
-          localHeaderOffset
-        };
-      };
-    }
-  });
-
-  // src/lib/parsers/parse-zip/local-file-header.ts
-  var offsets, signature, parseZipLocalFileHeader;
-  var init_local_file_header = __esm({
-    "src/lib/parsers/parse-zip/local-file-header.ts"() {
-      offsets = {
-        COMPRESSED_SIZE_OFFSET: 18,
-        FILE_NAME_LENGTH_OFFSET: 26,
-        EXTRA_FIELD_LENGTH_OFFSET: 28,
-        FILE_NAME_OFFSET: 30
-      };
-      signature = Buffer.from([80, 75, 3, 4]);
-      parseZipLocalFileHeader = async (headerOffset, buffer) => {
-        if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4)).compare(signature) !== 0) {
-          return Promise.resolve(void 0);
-        }
-        const fileNameLength = await buffer.getUint16(headerOffset + offsets.FILE_NAME_LENGTH_OFFSET);
-        const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + offsets.FILE_NAME_OFFSET, headerOffset + offsets.FILE_NAME_OFFSET + fileNameLength));
-        const extraFieldLength = await buffer.getUint16(headerOffset + offsets.EXTRA_FIELD_LENGTH_OFFSET);
-        const fileDataOffset = headerOffset + offsets.FILE_NAME_OFFSET + fileNameLength + extraFieldLength;
-        const compressedSize = await buffer.getUint32(headerOffset + offsets.COMPRESSED_SIZE_OFFSET);
-        return {
-          fileNameLength,
-          fileName,
-          extraFieldLength,
-          fileDataOffset,
-          compressedSize
-        };
-      };
-    }
-  });
-
   // ../../node_modules/crypt/crypt.js
   var require_crypt = __commonJS({
     "../../node_modules/crypt/crypt.js"(exports, module) {
@@ -10712,7 +10599,7 @@
   var require_md5 = __commonJS({
     "../../node_modules/md5/md5.js"(exports, module) {
       (function() {
-        var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer3 = require_is_buffer(), bin = require_charenc().bin, md52 = function(message, options) {
+        var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer3 = require_is_buffer(), bin = require_charenc().bin, md53 = function(message, options) {
           if (message.constructor == String)
             if (options && options.encoding === "binary")
               message = bin.stringToBytes(message);
@@ -10728,7 +10615,7 @@
           }
           m[l2 >>> 5] |= 128 << l2 % 32;
           m[(l2 + 64 >>> 9 << 4) + 14] = l2;
-          var FF = md52._ff, GG = md52._gg, HH = md52._hh, II = md52._ii;
+          var FF = md53._ff, GG = md53._gg, HH = md53._hh, II = md53._ii;
           for (var i2 = 0; i2 < m.length; i2 += 16) {
             var aa = a2, bb = b, cc = c2, dd = d;
             a2 = FF(a2, b, c2, d, m[i2 + 0], 7, -680876936);
@@ -10802,34 +10689,197 @@
           }
           return crypt.endian([a2, b, c2, d]);
         };
-        md52._ff = function(a2, b, c2, d, x, s2, t2) {
+        md53._ff = function(a2, b, c2, d, x, s2, t2) {
           var n2 = a2 + (b & c2 | ~b & d) + (x >>> 0) + t2;
           return (n2 << s2 | n2 >>> 32 - s2) + b;
         };
-        md52._gg = function(a2, b, c2, d, x, s2, t2) {
+        md53._gg = function(a2, b, c2, d, x, s2, t2) {
           var n2 = a2 + (b & d | c2 & ~d) + (x >>> 0) + t2;
           return (n2 << s2 | n2 >>> 32 - s2) + b;
         };
-        md52._hh = function(a2, b, c2, d, x, s2, t2) {
+        md53._hh = function(a2, b, c2, d, x, s2, t2) {
           var n2 = a2 + (b ^ c2 ^ d) + (x >>> 0) + t2;
           return (n2 << s2 | n2 >>> 32 - s2) + b;
         };
-        md52._ii = function(a2, b, c2, d, x, s2, t2) {
+        md53._ii = function(a2, b, c2, d, x, s2, t2) {
           var n2 = a2 + (c2 ^ (b | ~d)) + (x >>> 0) + t2;
           return (n2 << s2 | n2 >>> 32 - s2) + b;
         };
-        md52._blocksize = 16;
-        md52._digestsize = 16;
+        md53._blocksize = 16;
+        md53._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));
+          var digestbytes = crypt.wordsToBytes(md53(message, options));
           return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
         };
       })();
     }
   });
 
+  // src/lib/parsers/parse-zip/cd-file-header.ts
+  var offsets, signature, parseZipCDFileHeader;
+  var init_cd_file_header = __esm({
+    "src/lib/parsers/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/lib/parsers/parse-zip/search-from-the-end.ts
+  var searchFromTheEnd;
+  var init_search_from_the_end = __esm({
+    "src/lib/parsers/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 i2 = file.length - 4n; i2 > -1; i2--) {
+          searchWindow[3] = searchWindow[2];
+          searchWindow[2] = searchWindow[1];
+          searchWindow[1] = searchWindow[0];
+          searchWindow[0] = await file.getUint8(i2);
+          if (searchWindow.every((val, index) => val === target[index])) {
+            targetOffset = i2;
+            break;
+          }
+        }
+        return targetOffset;
+      };
+    }
+  });
+
+  // src/lib/parsers/parse-zip/end-of-central-directory.ts
+  var eoCDSignature, zip64EoCDLocatorSignature, zip64EoCDSignature, offsets2, parseEoCDRecord;
+  var init_end_of_central_directory = __esm({
+    "src/lib/parsers/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]);
+      offsets2 = {
+        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 + offsets2.CD_RECORDS_NUMBER_OFFSET));
+        let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + offsets2.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 + offsets2.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 + offsets2.ZIP64_CD_RECORDS_NUMBER_OFFSET);
+          cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + offsets2.ZIP64_CD_START_OFFSET_OFFSET);
+        }
+        return {
+          cdRecordsNumber,
+          cdStartOffset
+        };
+      };
+    }
+  });
+
+  // src/lib/parsers/parse-zip/local-file-header.ts
+  var offsets3, signature2, parseZipLocalFileHeader;
+  var init_local_file_header = __esm({
+    "src/lib/parsers/parse-zip/local-file-header.ts"() {
+      offsets3 = {
+        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 + offsets3.FILE_NAME_LENGTH_OFFSET);
+        const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + offsets3.FILE_NAME_OFFSET, headerOffset + offsets3.FILE_NAME_OFFSET + BigInt(fileNameLength))).split("\\").join("/");
+        const extraFieldLength = await buffer.getUint16(headerOffset + offsets3.EXTRA_FIELD_LENGTH_OFFSET);
+        let fileDataOffset = headerOffset + offsets3.FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
+        let compressedSize = BigInt(await buffer.getUint32(headerOffset + offsets3.COMPRESSED_SIZE_OFFSET));
+        let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + offsets3.UNCOMPRESSED_SIZE_OFFSET));
+        const extraOffset = headerOffset + offsets3.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
+        };
+      };
+    }
+  });
+
   // ../compression/src/lib/compression.ts
   var Compression;
   var init_compression = __esm({
@@ -15118,13 +15168,23 @@
   });
 
   // src/lib/parsers/parse-slpk/slpk-archieve.ts
-  var import_md5, PATH_DESCRIPTIONS, SLPKArchive;
+  var import_md5, compareHashes, PATH_DESCRIPTIONS, SLPKArchive;
   var init_slpk_archieve = __esm({
     "src/lib/parsers/parse-slpk/slpk-archieve.ts"() {
       import_md5 = __toModule(require_md5());
       init_local_file_header();
-      init_buffer_file_provider();
       init_src9();
+      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;
+      };
       PATH_DESCRIPTIONS = [
         {
           test: /^$/,
@@ -15135,7 +15195,7 @@
           extensions: [".json.gz"]
         },
         {
-          test: /^nodes\/\d+$/,
+          test: /^nodes\/(\d+|root)$/,
           extensions: ["/3dNodeIndexDocument.json.gz"]
         },
         {
@@ -15160,22 +15220,25 @@
         }
       ];
       SLPKArchive = class {
-        constructor(slpkArchiveBuffer, hashFile) {
-          this.slpkArchive = new DataView(slpkArchiveBuffer);
-          this.hashArray = this.parseHashFile(hashFile);
-        }
-        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.getUint32(offsetBuffer.byteOffset, true);
-            hashArray.push({
-              hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i2, hashFileBuffer.byteOffset + i2 + 16)),
-              offset
-            });
-          }
-          return hashArray;
+        constructor(slpkArchive, hashFile) {
+          this.findBin = (hashToSearch) => {
+            let lowerBorder = 0;
+            let upperBorder = this.hashArray.length;
+            while (upperBorder - lowerBorder > 1) {
+              const middle = lowerBorder + Math.floor((upperBorder - lowerBorder) / 2);
+              const value = compareHashes(this.hashArray[middle].hash, hashToSearch);
+              if (value === 0) {
+                return this.hashArray[middle];
+              } else if (value < 0) {
+                lowerBorder = middle;
+              } else {
+                upperBorder = middle;
+              }
+            }
+            return void 0;
+          };
+          this.slpkArchive = slpkArchive;
+          this.hashArray = hashFile;
         }
         async getFile(path, mode = "raw") {
           if (mode === "http") {
@@ -15206,7 +15269,10 @@
           throw new Error("No such file in the archieve");
         }
         async getDataByPath(path) {
-          const data = await this.getFileBytes(path);
+          let data = await this.getFileBytes(path.toLocaleLowerCase());
+          if (!data) {
+            data = await this.getFileBytes(path);
+          }
           if (!data) {
             return void 0;
           }
@@ -15219,15 +15285,15 @@
         }
         async getFileBytes(path) {
           const nameHash = Buffer.from((0, import_md5.default)(path), "hex");
-          const fileInfo = this.hashArray.find((val) => Buffer.compare(val.hash, nameHash) === 0);
+          const fileInfo = this.findBin(nameHash);
           if (!fileInfo) {
             return void 0;
           }
-          const localFileHeader = await parseZipLocalFileHeader(this.slpkArchive.byteOffset + fileInfo?.offset, new DataViewFileProvider(this.slpkArchive));
+          const localFileHeader = await parseZipLocalFileHeader(fileInfo.offset, this.slpkArchive);
           if (!localFileHeader) {
             return void 0;
           }
-          const compressedFile = this.slpkArchive.buffer.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+          const compressedFile = this.slpkArchive.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
           return compressedFile;
         }
       };
@@ -15235,60 +15301,110 @@
   });
 
   // src/lib/parsers/parse-slpk/parse-slpk.ts
-  async function parseSLPK(data, options = {}) {
-    const archive = new DataView(data);
-    const cdFileHeaderSignature = [80, 75, 1, 2];
-    const searchWindow = [
-      getByteAt(archive.byteLength - 1, archive),
-      getByteAt(archive.byteLength - 2, archive),
-      getByteAt(archive.byteLength - 3, archive),
-      void 0
-    ];
-    let hashCDOffset = 0;
-    for (let i2 = archive.byteLength - 4; i2 > -1; i2--) {
-      searchWindow[3] = searchWindow[2];
-      searchWindow[2] = searchWindow[1];
-      searchWindow[1] = searchWindow[0];
-      searchWindow[0] = getByteAt(i2, archive);
-      if (searchWindow.every((val, index) => val === cdFileHeaderSignature[index])) {
-        hashCDOffset = i2;
-        break;
-      }
-    }
-    const fileProvider = new DataViewFileProvider(archive);
-    const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
-    if (cdFileHeader.fileName !== "@specialIndexFileHASH128@") {
-      throw new Error("No hash file in slpk");
-    }
-    const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, fileProvider);
-    if (!localFileHeader) {
-      throw new Error("No hash file in slpk");
-    }
-    const fileDataOffset = localFileHeader.fileDataOffset;
-    const hashFile = archive.buffer.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
-    if (!hashFile) {
-      throw new Error("No hash file in slpk");
-    }
-    return await new SLPKArchive(data, hashFile).getFile(options.slpk?.path ?? "", options.slpk?.pathMode);
-  }
-  var getByteAt;
+  var import_md52, parseSLPK, generateHashInfo, parseHashFile;
   var init_parse_slpk = __esm({
     "src/lib/parsers/parse-slpk/parse-slpk.ts"() {
-      init_buffer_file_provider();
+      import_md52 = __toModule(require_md5());
       init_cd_file_header();
+      init_end_of_central_directory();
       init_local_file_header();
+      init_search_from_the_end();
       init_slpk_archieve();
-      getByteAt = (offset, buffer) => {
-        return buffer.getUint8(buffer.byteOffset + offset);
+      parseSLPK = async (fileProvider, cb) => {
+        const hashCDOffset = await searchFromTheEnd(fileProvider, signature);
+        const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
+        let hashData;
+        if (cdFileHeader?.fileName !== "@specialIndexFileHASH128@") {
+          cb?.("SLPK doesnt contain hash file");
+          hashData = await generateHashInfo(fileProvider);
+          cb?.("hash info has been composed according to central directory records");
+        } else {
+          cb?.("SLPK contains hash file");
+          const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, fileProvider);
+          if (!localFileHeader) {
+            throw new Error("corrupted SLPK");
+          }
+          const fileDataOffset = localFileHeader.fileDataOffset;
+          const hashFile = await fileProvider.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
+          hashData = parseHashFile(hashFile);
+        }
+        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;
+      };
+      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;
+      };
+    }
+  });
+
+  // src/lib/parsers/parse-zip/data-view-file-provider.ts
+  var toNumber, DataViewFileProvider;
+  var init_data_view_file_provider = __esm({
+    "src/lib/parsers/parse-zip/data-view-file-provider.ts"() {
+      toNumber = (bigint) => {
+        if (bigint > Number.MAX_SAFE_INTEGER) {
+          throw new Error("Offset is out of bounds");
+        }
+        return Number(bigint);
+      };
+      DataViewFileProvider = 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/i3s-slpk-loader.ts
+  async function parseSLPK2(data, options = {}) {
+    return (await parseSLPK(new DataViewFileProvider(new DataView(data)))).getFile(options.slpk?.path ?? "", options.slpk?.pathMode);
+  }
   var VERSION13, SLPKLoader;
   var init_i3s_slpk_loader = __esm({
     "src/i3s-slpk-loader.ts"() {
       init_parse_slpk();
+      init_data_view_file_provider();
       VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       SLPKLoader = {
         name: "I3S SLPK (Scene Layer Package)",
@@ -15296,7 +15412,7 @@
         module: "i3s",
         version: VERSION13,
         mimeTypes: ["application/octet-stream"],
-        parse: parseSLPK,
+        parse: parseSLPK2,
         extensions: ["slpk"],
         options: {}
       };
@@ -15467,6 +15583,7 @@
     I3SNodePageLoader: () => I3SNodePageLoader,
     SLPKLoader: () => SLPKLoader,
     loadFeatureAttributes: () => loadFeatureAttributes,
+    parseSLPK: () => parseSLPK,
     parseZipLocalFileHeader: () => parseZipLocalFileHeader
   });
   var init_src10 = __esm({
@@ -15480,6 +15597,7 @@
       init_i3s_node_page_loader();
       init_arcgis_webscene_loader();
       init_local_file_header();
+      init_parse_slpk();
     }
   });