@loaders.gl/3d-tiles 4.0.0-alpha.21 → 4.0.0-alpha.22

package/dist/dist.min.js

@@ -29,6 +29,15 @@
     return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
   };
 
+  // ../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 assert2(condition, message) {
     if (!condition) {
@@ -1181,9 +1190,16 @@
     }
   });
 
+  // (disabled):fs
+  var require_fs = __commonJS({
+    "(disabled):fs"() {
+    }
+  });
+
   // ../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();
@@ -6257,6 +6273,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];
@@ -6337,17 +6358,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;
-      };
     }
   });
 
@@ -6468,8 +6483,10 @@
     reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
     reason = reason || (loader ? `matched initial data ${getFirstCharacters2(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}.`);
     }
@@ -6565,7 +6582,7 @@
     }
     switch (typeof test) {
       case "function":
-        return test(data, loader);
+        return test(data);
       case "string":
         const magic = getMagicString2(data, byteOffset, test.length);
         return test === magic;
@@ -6838,7 +6855,7 @@
     return newContext;
   }
   function getLoadersFromContext(loaders, context) {
-    if (!context && loaders && !Array.isArray(loaders)) {
+    if (loaders && !Array.isArray(loaders)) {
       return loaders;
     }
     let candidateLoaders;
@@ -6849,7 +6866,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"() {
@@ -6861,7 +6878,6 @@
 
   // ../core/src/lib/api/parse.ts
   async function parse(data, loaders, options, context) {
-    assert3(!context || typeof context === "object");
     if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
       options = loaders;
@@ -6877,7 +6893,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) {
@@ -6955,6 +6971,7 @@
     "../core/src/index.ts"() {
       init_fetch_file();
       init_load();
+      init_src2();
     }
   });
 
@@ -8823,7 +8840,6 @@
     if (!context) {
       return;
     }
-    const { parse: parse5 } = context;
     const dracoOptions = {
       ...options,
       draco: {
@@ -8832,7 +8848,7 @@
       }
     };
     delete dracoOptions["3d-tiles"];
-    const data = await parse5(dracoData.buffer, DracoLoader2, dracoOptions);
+    const data = await parseFromContext(dracoData.buffer, DracoLoader2, dracoOptions, context);
     const decodedPositions = data.attributes.POSITION && data.attributes.POSITION.value;
     const decodedColors = data.attributes.COLOR_0 && data.attributes.COLOR_0.value;
     const decodedNormals = data.attributes.NORMAL && data.attributes.NORMAL.value;
@@ -8870,6 +8886,7 @@
   var init_parse_3d_tile_point_cloud = __esm({
     "src/lib/parsers/parse-3d-tile-point-cloud.ts"() {
       init_src6();
+      init_src2();
       init_src7();
       init_esm();
       init_tile_3d_feature_table();
@@ -10932,10 +10949,9 @@
     }
     const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
     const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset);
-    const { parse: parse5 } = context;
     const dracoOptions = { ...options };
     delete dracoOptions["3d-tiles"];
-    const decodedData = await parse5(bufferCopy, DracoLoader2, dracoOptions, context);
+    const decodedData = await parseFromContext(bufferCopy, DracoLoader2, dracoOptions, context);
     const decodedAttributes = getGLTFAccessors(decodedData.attributes);
     for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
       if (attributeName in primitive.attributes) {
@@ -10993,8 +11009,8 @@
   var KHR_DRACO_MESH_COMPRESSION, name4;
   var init_KHR_draco_mesh_compression = __esm({
     "../gltf/src/lib/extensions/KHR_draco_mesh_compression.ts"() {
-      init_src6();
       init_src2();
+      init_src6();
       init_gltf_scenegraph();
       init_gltf_attribute_utils();
       KHR_DRACO_MESH_COMPRESSION = "KHR_draco_mesh_compression";
@@ -11920,10 +11936,10 @@
     return Array.from(imageIndices).sort();
   }
   async function loadImage(gltf, image, index, options, context) {
-    const { fetch: fetch2, parse: parse5 } = context;
     let arrayBuffer;
     if (image.uri && !image.hasOwnProperty("bufferView")) {
       const uri = resolveUrl(image.uri, options);
+      const { fetch: fetch2 } = context;
       const response = await fetch2(uri);
       arrayBuffer = await response.arrayBuffer();
       image.bufferView = {
@@ -11935,7 +11951,7 @@
       arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
     }
     assert7(arrayBuffer, "glTF image has no data");
-    let parsedImage = await parse5(arrayBuffer, [ImageLoader, BasisLoader], {
+    let parsedImage = await parseFromContext(arrayBuffer, [ImageLoader, BasisLoader], {
       ...options,
       mimeType: image.mimeType,
       basis: options.basis || { format: selectSupportedBasisFormat() }
@@ -12420,14 +12436,14 @@
       if (!context) {
         return;
       }
-      const { parse: parse5, fetch: fetch2 } = context;
       if (tile.gltfUrl) {
+        const { fetch: fetch2 } = context;
         const response = await fetch2(tile.gltfUrl, options);
         tile.gltfArrayBuffer = await response.arrayBuffer();
         tile.gltfByteOffset = 0;
       }
       if (tile.gltfArrayBuffer) {
-        const gltfWithBuffers = await parse5(tile.gltfArrayBuffer, GLTFLoader, options, context);
+        const gltfWithBuffers = await parseFromContext(tile.gltfArrayBuffer, GLTFLoader, options, context);
         tile.gltf = postProcessGLTF(gltfWithBuffers);
         tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
         delete tile.gltfArrayBuffer;
@@ -12661,13 +12677,12 @@
   // src/lib/parsers/parse-3d-tile-gltf.ts
   async function parseGltf3DTile(tile, arrayBuffer, options, context) {
     tile.rotateYtoZ = true;
-    tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+    tile.gltfUpAxis = options?.["3d-tiles"]?.assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
     if (options?.["3d-tiles"]?.loadGLTF) {
       if (!context) {
         return;
       }
-      const { parse: parse5 } = context;
-      const gltfWithBuffers = await parse5(arrayBuffer, GLTFLoader, options, context);
+      const gltfWithBuffers = await parseFromContext(arrayBuffer, GLTFLoader, options, context);
       tile.gltf = postProcessGLTF(gltfWithBuffers);
       tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
     } else {
@@ -12676,6 +12691,7 @@
   }
   var init_parse_3d_tile_gltf = __esm({
     "src/lib/parsers/parse-3d-tile-gltf.ts"() {
+      init_src2();
       init_src10();
     }
   });
@@ -14903,7 +14919,7 @@
     } else if (uri.startsWith("/")) {
       return uri;
     }
-    return `${basePath}/${uri}`;
+    return path_exports.resolve(basePath, uri);
   }
   function normalizeTileData(tile, basePath) {
     if (!tile) {
@@ -15028,6 +15044,7 @@
   }
   var init_parse_3d_tile_header2 = __esm({
     "src/lib/parsers/parse-3d-tile-header.ts"() {
+      init_src2();
       init_tile_3d_subtree_loader();
       init_src3();
       init_src4();
@@ -15201,6 +15218,105 @@
     }
   });
 
+  // ../zip/src/file-provider/file-handle.ts
+  var import_fs, _FileHandle, FileHandle;
+  var init_file_handle = __esm({
+    "../zip/src/file-provider/file-handle.ts"() {
+      import_fs = __toModule(require_fs());
+      _FileHandle = class {
+        constructor(fileDescriptor, stats) {
+          this.read = (buffer, offset, length4, position) => {
+            return new Promise((s2) => {
+              (0, import_fs.read)(this.fileDescriptor, buffer, offset, length4, position, (_err, bytesRead, buffer2) => s2({ bytesRead, buffer: buffer2 }));
+            });
+          };
+          this.fileDescriptor = fileDescriptor;
+          this.stats = stats;
+        }
+        async close() {
+          return new Promise((resolve2) => {
+            (0, import_fs.close)(this.fileDescriptor, (_err) => resolve2());
+          });
+        }
+        get stat() {
+          return this.stats;
+        }
+      };
+      FileHandle = _FileHandle;
+      FileHandle.open = async (path) => {
+        const [fd, stats] = await Promise.all([
+          new Promise((s2) => {
+            (0, import_fs.open)(path, void 0, void 0, (_err, fd2) => s2(fd2));
+          }),
+          new Promise((s2) => {
+            (0, import_fs.stat)(path, { bigint: true }, (_err, stats2) => s2(stats2));
+          })
+        ]);
+        return new _FileHandle(fd, stats);
+      };
+    }
+  });
+
+  // ../zip/src/file-provider/file-handle-file.ts
+  var FileHandleFile;
+  var init_file_handle_file = __esm({
+    "../zip/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 length4 = Number(bigLength);
+          return (await this.fileDescriptor.read(Buffer.alloc(length4), 0, length4, startOffsset)).buffer.buffer;
+        }
+        get length() {
+          return this.size;
+        }
+      };
+    }
+  });
+
   // ../zip/src/file-provider/data-view-file.ts
   var toNumber2, DataViewFile;
   var init_data_view_file = __esm({
@@ -15707,14 +15823,13 @@
     }
   });
 
-  // ../zip/src/index.ts
-  var init_src11 = __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();
+  // ../zip/src/file-provider/file-provider.ts
+  var isFileProvider;
+  var init_file_provider = __esm({
+    "../zip/src/file-provider/file-provider.ts"() {
+      isFileProvider = (fileProvider) => {
+        return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
+      };
     }
   });
 
@@ -15766,6 +15881,36 @@
     }
   });
 
+  // ../compression/src/lib/no-compression.ts
+  var NoCompression;
+  var init_no_compression = __esm({
+    "../compression/src/lib/no-compression.ts"() {
+      init_compression();
+      NoCompression = class extends Compression {
+        constructor(options) {
+          super(options);
+          this.name = "uncompressed";
+          this.extensions = [];
+          this.contentEncodings = [];
+          this.isSupported = true;
+          this.options = options || {};
+        }
+        compressSync(input) {
+          return input;
+        }
+        decompressSync(input) {
+          return input;
+        }
+        async *compressBatches(asyncIterator) {
+          return yield* asyncIterator;
+        }
+        async *decompressBatches(asyncIterator) {
+          return yield* asyncIterator;
+        }
+      };
+    }
+  });
+
   // ../../node_modules/pako/lib/utils/common.js
   var require_common = __commonJS({
     "../../node_modules/pako/lib/utils/common.js"(exports) {
@@ -19984,19 +20129,23 @@
   });
 
   // ../compression/src/index.ts
-  var init_src12 = __esm({
+  var init_src11 = __esm({
     "../compression/src/index.ts"() {
+      init_no_compression();
       init_deflate_compression();
     }
   });
 
-  // src/tz3/tz3-archive.ts
-  var import_md52, COMPRESSION_METHODS, TZ3Archive;
-  var init_tz3_archive = __esm({
-    "src/tz3/tz3-archive.ts"() {
-      import_md52 = __toModule(require_md5());
+  // ../zip/src/filesystems/zip-filesystem.ts
+  var COMPRESSION_METHODS, ZipFileSystem;
+  var init_zip_filesystem = __esm({
+    "../zip/src/filesystems/zip-filesystem.ts"() {
+      init_src3();
+      init_file_provider();
+      init_file_handle_file();
+      init_cd_file_header();
+      init_local_file_header();
       init_src11();
-      init_src12();
       COMPRESSION_METHODS = {
         0: async (compressedFile) => compressedFile,
         8: async (compressedFile) => {
@@ -20005,9 +20154,110 @@
           return decompressedData;
         }
       };
-      TZ3Archive = class {
-        constructor(tz3Archive, hashFile) {
-          this.tz3Archive = tz3Archive;
+      ZipFileSystem = class {
+        constructor(file) {
+          this.fileProvider = Promise.resolve(null);
+          if (typeof file === "string") {
+            this.fileName = file;
+            if (!isBrowser) {
+              this.fileProvider = FileHandleFile.from(file);
+            } else {
+              throw new Error("Cannot open file for random access in a WEB browser");
+            }
+          } else if (isFileProvider(file)) {
+            this.fileProvider = Promise.resolve(file);
+          }
+        }
+        async destroy() {
+          const fileProvider = await this.fileProvider;
+          if (fileProvider) {
+            await fileProvider.destroy();
+          }
+        }
+        async readdir() {
+          const fileProvider = await this.fileProvider;
+          if (!fileProvider) {
+            throw new Error("No data detected in the zip archive");
+          }
+          const fileNames = [];
+          const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+          for await (const cdHeader of zipCDIterator) {
+            fileNames.push(cdHeader.fileName);
+          }
+          return fileNames;
+        }
+        async stat(filename2) {
+          const cdFileHeader = await this.getCDFileHeader(filename2);
+          return { ...cdFileHeader, size: Number(cdFileHeader.uncompressedSize) };
+        }
+        async fetch(filename2) {
+          const fileProvider = await this.fileProvider;
+          if (!fileProvider) {
+            throw new Error("No data detected in the zip archive");
+          }
+          const cdFileHeader = await this.getCDFileHeader(filename2);
+          const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, fileProvider);
+          if (!localFileHeader) {
+            throw new Error("Local file header has not been found in the zip archive`");
+          }
+          const compressionHandler = COMPRESSION_METHODS[localFileHeader.compressionMethod.toString()];
+          if (!compressionHandler) {
+            throw Error("Only Deflation compression is supported");
+          }
+          const compressedFile = await fileProvider.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+          const uncompressedFile = await compressionHandler(compressedFile);
+          const response = new Response(uncompressedFile);
+          Object.defineProperty(response, "url", { value: `${this.fileName || ""}/${filename2}` });
+          return response;
+        }
+        async getCDFileHeader(filename2) {
+          const fileProvider = await this.fileProvider;
+          if (!fileProvider) {
+            throw new Error("No data detected in the zip archive");
+          }
+          const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+          let result = null;
+          for await (const cdHeader of zipCDIterator) {
+            if (cdHeader.fileName === filename2) {
+              result = cdHeader;
+              break;
+            }
+          }
+          if (!result) {
+            throw new Error("File has not been found in the zip archive");
+          }
+          return result;
+        }
+      };
+    }
+  });
+
+  // ../zip/src/index.ts
+  var init_src12 = __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();
+      init_zip_filesystem();
+    }
+  });
+
+  // src/3d-tiles-archive/3d-tiles-archive-archive.ts
+  var import_md52, COMPRESSION_METHODS2, Tiles3DArchive;
+  var init_d_tiles_archive_archive = __esm({
+    "src/3d-tiles-archive/3d-tiles-archive-archive.ts"() {
+      import_md52 = __toModule(require_md5());
+      init_src12();
+      init_src11();
+      COMPRESSION_METHODS2 = {
+        0: (data) => new NoCompression().decompress(data),
+        8: (data) => new DeflateCompression({ raw: true }).decompress(data)
+      };
+      Tiles3DArchive = class {
+        constructor(fileProvider, hashFile) {
+          this.fileProvider = fileProvider;
           this.hashArray = hashFile;
         }
         async getFile(path) {
@@ -20016,10 +20266,9 @@
             data = await this.getFileBytes(path);
           }
           if (!data) {
-            throw new Error("No such file in the archieve");
+            throw new Error("No such file in the archive");
           }
-          const decompressedFile = Buffer.from(data);
-          return decompressedFile;
+          return data;
         }
         async getFileBytes(path) {
           const nameHash = Buffer.from((0, import_md52.default)(path), "hex");
@@ -20027,12 +20276,12 @@
           if (!fileInfo) {
             return null;
           }
-          const localFileHeader = await parseZipLocalFileHeader(fileInfo.offset, this.tz3Archive);
+          const localFileHeader = await parseZipLocalFileHeader(fileInfo.offset, this.fileProvider);
           if (!localFileHeader) {
             return null;
           }
-          const compressedFile = await this.tz3Archive.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
-          const compressionMethod = COMPRESSION_METHODS[localFileHeader.compressionMethod];
+          const compressedFile = await this.fileProvider.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+          const compressionMethod = COMPRESSION_METHODS2[localFileHeader.compressionMethod];
           if (!compressionMethod) {
             throw Error("Only Deflation compression is supported");
           }
@@ -20042,13 +20291,13 @@
     }
   });
 
-  // src/tz3/tz3-parser.ts
-  var parse3tz;
-  var init_tz3_parser = __esm({
-    "src/tz3/tz3-parser.ts"() {
-      init_src11();
-      init_tz3_archive();
-      parse3tz = async (fileProvider, cb) => {
+  // src/3d-tiles-archive/3d-tiles-archive-parser.ts
+  var parse3DTilesArchive;
+  var init_d_tiles_archive_parser = __esm({
+    "src/3d-tiles-archive/3d-tiles-archive-parser.ts"() {
+      init_src12();
+      init_d_tiles_archive_archive();
+      parse3DTilesArchive = async (fileProvider, cb) => {
         const hashCDOffset = await searchFromTheEnd(fileProvider, signature);
         const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
         let hashData;
@@ -20066,34 +20315,86 @@
           const hashFile = await fileProvider.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
           hashData = parseHashFile(hashFile);
         }
-        return new TZ3Archive(fileProvider, hashData);
+        return new Tiles3DArchive(fileProvider, hashData);
       };
     }
   });
 
-  // src/tz3-loader.ts
-  async function parse3tz2(data, options = {}) {
-    return (await parse3tz(new DataViewFile(new DataView(data)))).getFile(options.tz3?.path ?? "");
+  // src/3d-tiles-archive-loader.ts
+  async function parse3DTilesArchive2(data, options = {}) {
+    const archive = await parse3DTilesArchive(new DataViewFile(new DataView(data)));
+    return archive.getFile(options["3d-tiles-archive"]?.path ?? "");
   }
-  var VERSION10, TZ3Loader;
-  var init_tz3_loader = __esm({
-    "src/tz3-loader.ts"() {
-      init_src11();
-      init_tz3_parser();
+  var VERSION10, Tiles3DArchiveFileLoader;
+  var init_d_tiles_archive_loader = __esm({
+    "src/3d-tiles-archive-loader.ts"() {
+      init_src12();
+      init_d_tiles_archive_parser();
       VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      TZ3Loader = {
+      Tiles3DArchiveFileLoader = {
         name: "3tz",
         id: "3tz",
-        module: "i3s",
+        module: "3d-tiles",
         version: VERSION10,
-        mimeTypes: ["application/octet-stream"],
-        parse: parse3tz2,
+        mimeTypes: ["application/octet-stream", "application/vnd.maxar.archive.3tz+zip"],
+        parse: parse3DTilesArchive2,
         extensions: ["3tz"],
         options: {}
       };
     }
   });
 
+  // src/lib/filesystems/tiles-3d-archive-file-system.ts
+  var Tiles3DArchiveFileSystem;
+  var init_tiles_3d_archive_file_system = __esm({
+    "src/lib/filesystems/tiles-3d-archive-file-system.ts"() {
+      init_src12();
+      init_d_tiles_archive_archive();
+      Tiles3DArchiveFileSystem = class extends ZipFileSystem {
+        constructor(file) {
+          super(file);
+        }
+        async fetch(filename2) {
+          const fileProvider = await this.fileProvider;
+          if (!fileProvider) {
+            throw new Error("No data detected in the zip archive");
+          }
+          await this.parseHashFile();
+          if (this.hashData) {
+            const archive = new Tiles3DArchive(fileProvider, this.hashData);
+            const fileData = await archive.getFile(filename2);
+            const response = new Response(fileData);
+            Object.defineProperty(response, "url", { value: `${this.fileName || ""}/${filename2}` });
+            return response;
+          }
+          return super.fetch(filename2);
+        }
+        async parseHashFile() {
+          if (this.hashData !== void 0) {
+            return;
+          }
+          const fileProvider = await this.fileProvider;
+          if (!fileProvider) {
+            throw new Error("No data detected in the zip archive");
+          }
+          const hashCDOffset = await searchFromTheEnd(fileProvider, signature);
+          const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
+          if (cdFileHeader?.fileName === "@3dtilesIndex1@") {
+            const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, fileProvider);
+            if (!localFileHeader) {
+              throw new Error("corrupted 3tz");
+            }
+            const fileDataOffset = localFileHeader.fileDataOffset;
+            const hashFile = await fileProvider.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
+            this.hashData = parseHashFile(hashFile);
+          } else {
+            this.hashData = null;
+          }
+        }
+      };
+    }
+  });
+
   // src/lib/encoders/helpers/encode-3d-tile-header.ts
   function encode3DTileHeader(tile, dataView, byteOffset) {
     const HEADER_SIZE = 12;
@@ -20320,11 +20621,12 @@
   __export(src_exports, {
     CesiumIonLoader: () => CesiumIonLoader,
     TILE3D_TYPE: () => TILE3D_TYPE,
-    TZ3Loader: () => TZ3Loader,
     Tile3DBatchTable: () => Tile3DBatchTableParser,
     Tile3DFeatureTable: () => Tile3DFeatureTable,
     Tile3DSubtreeLoader: () => Tile3DSubtreeLoader,
     Tile3DWriter: () => Tile3DWriter,
+    Tiles3DArchiveFileLoader: () => Tiles3DArchiveFileLoader,
+    Tiles3DArchiveFileSystem: () => Tiles3DArchiveFileSystem,
     Tiles3DLoader: () => Tiles3DLoader,
     _getIonTilesetMetadata: () => getIonTilesetMetadata
   });
@@ -20333,7 +20635,8 @@
       init_tiles_3d_loader();
       init_cesium_ion_loader();
       init_tile_3d_subtree_loader();
-      init_tz3_loader();
+      init_d_tiles_archive_loader();
+      init_tiles_3d_archive_file_system();
       init_tile_3d_writer();
       init_tile_3d_feature_table();
       init_tile_3d_batch_table();