@loaders.gl/3d-tiles 4.2.1 → 4.3.0-alpha.2

package/dist/3d-tiles-archive-loader.js

@@ -5,7 +5,7 @@ import { DataViewFile } from '@loaders.gl/loader-utils';
 import { parse3DTilesArchive as parse3DTilesArchiveFromProvider } from "./3d-tiles-archive/3d-tiles-archive-parser.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.2.0" !== 'undefined' ? "4.2.0" : 'latest';
+const VERSION = typeof "4.3.0-alpha.1" !== 'undefined' ? "4.3.0-alpha.1" : 'latest';
 /**
  * Loader for 3tz packages
  */

package/dist/dist.dev.js

@@ -20501,6 +20501,7 @@ var __exports__ = (() => {
   };
 
   // ../zip/src/parse-zip/search-from-the-end.ts
+  var buffLength = 1024;
   var searchFromTheEnd = async (file, target) => {
     const searchWindow = [
       await file.getUint8(file.length - 1n),
@@ -20508,18 +20509,25 @@ var __exports__ = (() => {
       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;
+    let targetOffset = -1;
+    let point = file.length - 4n;
+    do {
+      const prevPoint = point;
+      point -= BigInt(buffLength);
+      point = point >= 0n ? point : 0n;
+      const buff = new Uint8Array(await file.slice(point, prevPoint));
+      for (let i2 = buff.length - 1; i2 > -1; i2--) {
+        searchWindow[3] = searchWindow[2];
+        searchWindow[2] = searchWindow[1];
+        searchWindow[1] = searchWindow[0];
+        searchWindow[0] = buff[i2];
+        if (searchWindow.every((val, index) => val === target[index])) {
+          targetOffset = i2;
+          break;
+        }
       }
-    }
-    return targetOffset;
+    } while (targetOffset === -1 && point > 0n);
+    return point + BigInt(targetOffset);
   };
 
   // ../zip/src/parse-zip/end-of-central-directory.ts
@@ -20527,13 +20535,16 @@ var __exports__ = (() => {
   var zip64EoCDLocatorSignature = new Uint8Array([80, 75, 6, 7]);
   var zip64EoCDSignature = new Uint8Array([80, 75, 6, 6]);
   var CD_RECORDS_NUMBER_OFFSET = 8n;
+  var CD_CD_BYTE_SIZE_OFFSET = 12n;
   var CD_START_OFFSET_OFFSET = 16n;
   var ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
   var ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+  var ZIP64_CD_CD_BYTE_SIZE_OFFSET = 40n;
   var ZIP64_CD_START_OFFSET_OFFSET = 48n;
   var parseEoCDRecord = async (file) => {
     const zipEoCDOffset = await searchFromTheEnd(file, eoCDSignature);
     let cdRecordsNumber = BigInt(await file.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
+    let cdByteSize = BigInt(await file.getUint32(zipEoCDOffset + CD_CD_BYTE_SIZE_OFFSET));
     let cdStartOffset = BigInt(await file.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
     let zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
     let zip64EoCDOffset = 0n;
@@ -20547,6 +20558,7 @@ var __exports__ = (() => {
         throw new Error("zip64 EoCD not found");
       }
       cdRecordsNumber = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+      cdByteSize = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_CD_BYTE_SIZE_OFFSET);
       cdStartOffset = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
     } else {
       zip64EoCDLocatorOffset = 0n;
@@ -20554,6 +20566,7 @@ var __exports__ = (() => {
     return {
       cdRecordsNumber,
       cdStartOffset,
+      cdByteSize,
       offsets: {
         zip64EoCDOffset,
         zip64EoCDLocatorOffset,
@@ -20701,34 +20714,41 @@ var __exports__ = (() => {
   ];
 
   // ../zip/src/parse-zip/cd-file-header.ts
-  var CD_COMPRESSED_SIZE_OFFSET = 20n;
-  var CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
-  var CD_FILE_NAME_LENGTH_OFFSET = 28n;
-  var CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;
-  var CD_START_DISK_OFFSET = 32n;
-  var CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;
+  var CD_COMPRESSED_SIZE_OFFSET = 20;
+  var CD_UNCOMPRESSED_SIZE_OFFSET = 24;
+  var CD_FILE_NAME_LENGTH_OFFSET = 28;
+  var CD_EXTRA_FIELD_LENGTH_OFFSET = 30;
+  var CD_START_DISK_OFFSET = 32;
+  var CD_LOCAL_HEADER_OFFSET_OFFSET = 42;
   var CD_FILE_NAME_OFFSET = 46n;
   var signature = new Uint8Array([80, 75, 1, 2]);
   var parseZipCDFileHeader = async (headerOffset, file) => {
-    const magicBytes = await file.slice(headerOffset, headerOffset + 4n);
+    if (headerOffset >= file.length) {
+      return null;
+    }
+    const mainHeader = new DataView(
+      await file.slice(headerOffset, headerOffset + CD_FILE_NAME_OFFSET)
+    );
+    const magicBytes = mainHeader.buffer.slice(0, 4);
     if (!compareArrayBuffers(magicBytes, signature.buffer)) {
       return null;
     }
-    const compressedSize = BigInt(await file.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));
-    const uncompressedSize = BigInt(await file.getUint32(headerOffset + CD_UNCOMPRESSED_SIZE_OFFSET));
-    const extraFieldLength = await file.getUint16(headerOffset + CD_EXTRA_FIELD_LENGTH_OFFSET);
-    const startDisk = BigInt(await file.getUint16(headerOffset + CD_START_DISK_OFFSET));
-    const fileNameLength = await file.getUint16(headerOffset + CD_FILE_NAME_LENGTH_OFFSET);
-    const filenameBytes = await file.slice(
+    const compressedSize = BigInt(mainHeader.getUint32(CD_COMPRESSED_SIZE_OFFSET, true));
+    const uncompressedSize = BigInt(mainHeader.getUint32(CD_UNCOMPRESSED_SIZE_OFFSET, true));
+    const extraFieldLength = mainHeader.getUint16(CD_EXTRA_FIELD_LENGTH_OFFSET, true);
+    const startDisk = BigInt(mainHeader.getUint16(CD_START_DISK_OFFSET, true));
+    const fileNameLength = mainHeader.getUint16(CD_FILE_NAME_LENGTH_OFFSET, true);
+    const additionalHeader = await file.slice(
       headerOffset + CD_FILE_NAME_OFFSET,
-      headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength)
+      headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
     );
+    const filenameBytes = additionalHeader.slice(0, fileNameLength);
     const fileName = new TextDecoder().decode(filenameBytes);
     const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
-    const oldFormatOffset = await file.getUint32(headerOffset + CD_LOCAL_HEADER_OFFSET_OFFSET);
+    const oldFormatOffset = mainHeader.getUint32(CD_LOCAL_HEADER_OFFSET_OFFSET, true);
     const localHeaderOffset = BigInt(oldFormatOffset);
     const extraField = new DataView(
-      await file.slice(extraOffset, extraOffset + BigInt(extraFieldLength))
+      additionalHeader.slice(fileNameLength, additionalHeader.byteLength)
     );
     const zip64data = {
       uncompressedSize,
@@ -20747,13 +20767,16 @@ var __exports__ = (() => {
     };
   };
   async function* makeZipCDHeaderIterator(fileProvider) {
-    const { cdStartOffset } = await parseEoCDRecord(fileProvider);
-    let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);
+    const { cdStartOffset, cdByteSize } = await parseEoCDRecord(fileProvider);
+    const centralDirectory = new DataViewFile(
+      new DataView(await fileProvider.slice(cdStartOffset, cdStartOffset + cdByteSize))
+    );
+    let cdHeader = await parseZipCDFileHeader(0n, centralDirectory);
     while (cdHeader) {
       yield cdHeader;
       cdHeader = await parseZipCDFileHeader(
         cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength),
-        fileProvider
+        centralDirectory
       );
     }
   }
@@ -20900,42 +20923,45 @@ var __exports__ = (() => {
   ];
 
   // ../zip/src/parse-zip/local-file-header.ts
-  var COMPRESSION_METHOD_OFFSET = 8n;
-  var COMPRESSED_SIZE_OFFSET = 18n;
-  var UNCOMPRESSED_SIZE_OFFSET = 22n;
-  var FILE_NAME_LENGTH_OFFSET = 26n;
-  var EXTRA_FIELD_LENGTH_OFFSET = 28n;
+  var COMPRESSION_METHOD_OFFSET = 8;
+  var COMPRESSED_SIZE_OFFSET = 18;
+  var UNCOMPRESSED_SIZE_OFFSET = 22;
+  var FILE_NAME_LENGTH_OFFSET = 26;
+  var EXTRA_FIELD_LENGTH_OFFSET = 28;
   var FILE_NAME_OFFSET = 30n;
   var signature2 = new Uint8Array([80, 75, 3, 4]);
-  var parseZipLocalFileHeader = async (headerOffset, buffer) => {
-    const magicBytes = await buffer.slice(headerOffset, headerOffset + 4n);
+  var parseZipLocalFileHeader = async (headerOffset, file) => {
+    const mainHeader = new DataView(await file.slice(headerOffset, headerOffset + FILE_NAME_OFFSET));
+    const magicBytes = mainHeader.buffer.slice(0, 4);
     if (!compareArrayBuffers(magicBytes, signature2)) {
       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);
+    const fileNameLength = mainHeader.getUint16(FILE_NAME_LENGTH_OFFSET, true);
+    const extraFieldLength = mainHeader.getUint16(EXTRA_FIELD_LENGTH_OFFSET, true);
+    const additionalHeader = await file.slice(
+      headerOffset + FILE_NAME_OFFSET,
+      headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
+    );
+    const fileNameBuffer = additionalHeader.slice(0, fileNameLength);
+    const extraDataBuffer = new DataView(
+      additionalHeader.slice(fileNameLength, additionalHeader.byteLength)
+    );
+    const fileName = new TextDecoder().decode(fileNameBuffer).split("\\").join("/");
     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;
+    const compressionMethod = mainHeader.getUint16(COMPRESSION_METHOD_OFFSET, true);
+    let compressedSize = BigInt(mainHeader.getUint32(COMPRESSED_SIZE_OFFSET, true));
+    let uncompressedSize = BigInt(mainHeader.getUint32(UNCOMPRESSED_SIZE_OFFSET, true));
+    let offsetInZip64Data = 4;
     if (uncompressedSize === BigInt(4294967295)) {
-      uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
-      offsetInZip64Data += 8n;
+      uncompressedSize = extraDataBuffer.getBigUint64(offsetInZip64Data, true);
+      offsetInZip64Data += 8;
     }
     if (compressedSize === BigInt(4294967295)) {
-      compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
-      offsetInZip64Data += 8n;
+      compressedSize = extraDataBuffer.getBigUint64(offsetInZip64Data, true);
+      offsetInZip64Data += 8;
     }
     if (fileDataOffset === BigInt(4294967295)) {
-      fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+      fileDataOffset = extraDataBuffer.getBigUint64(offsetInZip64Data, true);
     }
     return {
       fileNameLength,