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

package/dist/dist.min.js

@@ -14,8 +14,8 @@
   };
   var __export = (target, all) => {
     __markAsModule(target);
-    for (var name10 in all)
-      __defProp(target, name10, { get: all[name10], enumerable: true });
+    for (var name12 in all)
+      __defProp(target, name12, { get: all[name12], enumerable: true });
   };
   var __reExport = (target, module, desc) => {
     if (module && typeof module === "object" || typeof module === "function") {
@@ -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) {
@@ -254,9 +263,9 @@
         constructor(props) {
           this.terminated = false;
           this._loadableURL = "";
-          const { name: name10, source, url } = props;
+          const { name: name12, source, url } = props;
           assert3(source || url);
-          this.name = name10;
+          this.name = name12;
           this.source = source;
           this.url = url;
           this.onMessage = NOOP;
@@ -381,9 +390,9 @@
             this.onDebug = props.onDebug;
           }
         }
-        async startJob(name10, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+        async startJob(name12, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
           const startPromise = new Promise((onStart) => {
-            this.jobQueue.push({ name: name10, onMessage: onMessage2, onError, onStart });
+            this.jobQueue.push({ name: name12, onMessage: onMessage2, onError, onStart });
             return this;
           });
           this._startQueuedJob();
@@ -434,8 +443,8 @@
           }
           if (this.count < this._getMaxConcurrency()) {
             this.count++;
-            const name10 = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-            return new WorkerThread({ name: name10, source: this.source, url: this.url });
+            const name12 = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+            return new WorkerThread({ name: name12, source: this.source, url: this.url });
           }
           return null;
         }
@@ -487,16 +496,16 @@
           }
         }
         getWorkerPool(options) {
-          const { name: name10, source, url } = options;
-          let workerPool = this.workerPools.get(name10);
+          const { name: name12, source, url } = options;
+          let workerPool = this.workerPools.get(name12);
           if (!workerPool) {
             workerPool = new WorkerPool({
-              name: name10,
+              name: name12,
               source,
               url
             });
             workerPool.setProps(this._getWorkerPoolProps());
-            this.workerPools.set(name10, workerPool);
+            this.workerPools.set(name12, workerPool);
           }
           return workerPool;
         }
@@ -679,10 +688,10 @@
     return loader.worker && options?.worker;
   }
   async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
-    const name10 = loader.id;
+    const name12 = loader.id;
     const url = getWorkerURL(loader, options);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const workerPool = workerFarm.getWorkerPool({ name: name10, url });
+    const workerPool = workerFarm.getWorkerPool({ name: name12, url });
     options = JSON.parse(JSON.stringify(options));
     context = JSON.parse(JSON.stringify(context || {}));
     const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread));
@@ -1181,9 +1190,164 @@
     }
   });
 
+  // (disabled):fs
+  var require_fs = __commonJS({
+    "(disabled):fs"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/file-provider/file-provider.ts
+  var isFileProvider;
+  var init_file_provider = __esm({
+    "../loader-utils/src/lib/file-provider/file-provider.ts"() {
+      isFileProvider = (fileProvider) => {
+        return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
+      };
+    }
+  });
+
+  // ../loader-utils/src/lib/file-provider/file-handle.ts
+  var import_fs, FileHandle;
+  var init_file_handle = __esm({
+    "../loader-utils/src/lib/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;
+        }
+        static async open(path) {
+          const [fd, stats] = await Promise.all([
+            new Promise((resolve2, reject) => {
+              (0, import_fs.open)(path, void 0, void 0, (_err, fd2) => _err ? reject(_err) : resolve2(fd2));
+            }),
+            new Promise((resolve2, reject) => {
+              (0, import_fs.stat)(path, { bigint: true }, (_err, stats2) => _err ? reject(_err) : resolve2(stats2));
+            })
+          ]);
+          return new FileHandle(fd, stats);
+        }
+        async close() {
+          return new Promise((resolve2) => {
+            (0, import_fs.close)(this.fileDescriptor, (_err) => resolve2());
+          });
+        }
+        get stat() {
+          return this.stats;
+        }
+      };
+    }
+  });
+
+  // ../loader-utils/src/lib/file-provider/file-handle-file.ts
+  var FileHandleFile;
+  var init_file_handle_file = __esm({
+    "../loader-utils/src/lib/file-provider/file-handle-file.ts"() {
+      init_file_handle();
+      init_file_aliases();
+      FileHandleFile = class {
+        static async from(path) {
+          path = resolvePath(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;
+        }
+      };
+    }
+  });
+
+  // ../loader-utils/src/lib/file-provider/data-view-file.ts
+  var toNumber, DataViewFile;
+  var init_data_view_file = __esm({
+    "../loader-utils/src/lib/file-provider/data-view-file.ts"() {
+      toNumber = (bigint) => {
+        if (bigint > Number.MAX_SAFE_INTEGER) {
+          throw new Error("Offset is out of bounds");
+        }
+        return Number(bigint);
+      };
+      DataViewFile = class {
+        constructor(file) {
+          this.file = file;
+        }
+        async destroy() {
+        }
+        async getUint8(offset) {
+          return this.file.getUint8(toNumber(offset));
+        }
+        async getUint16(offset) {
+          return this.file.getUint16(toNumber(offset), true);
+        }
+        async getUint32(offset) {
+          return this.file.getUint32(toNumber(offset), true);
+        }
+        async getBigUint64(offset) {
+          return this.file.getBigUint64(toNumber(offset), true);
+        }
+        async slice(startOffset, endOffset) {
+          return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+        }
+        get length() {
+          return BigInt(this.file.byteLength);
+        }
+      };
+    }
+  });
+
   // ../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();
@@ -1196,6 +1360,9 @@
       init_memory_conversion_utils();
       init_promisify();
       init_path();
+      init_file_provider();
+      init_file_handle_file();
+      init_data_view_file();
     }
   });
 
@@ -5759,7 +5926,7 @@
     for (const key of propNames) {
       const value = object[key];
       if (typeof value === "function") {
-        if (!predefined.find((name10) => key === name10)) {
+        if (!predefined.find((name12) => key === name12)) {
           object[key] = value.bind(obj);
         }
       }
@@ -6257,6 +6424,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 +6509,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 +6634,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 +6733,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 +7006,7 @@
     return newContext;
   }
   function getLoadersFromContext(loaders, context) {
-    if (!context && loaders && !Array.isArray(loaders)) {
+    if (loaders && !Array.isArray(loaders)) {
       return loaders;
     }
     let candidateLoaders;
@@ -6849,7 +7017,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 +7029,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 +7044,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) {
@@ -7136,11 +7303,11 @@
   });
 
   // ../schema/src/lib/mesh/deduce-mesh-schema.ts
-  function deduceMeshField(name10, attribute, optionalMetadata) {
+  function deduceMeshField(name12, attribute, optionalMetadata) {
     const type = getDataTypeFromTypedArray(attribute.value);
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
     return {
-      name: name10,
+      name: name12,
       type: { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] },
       nullable: false,
       metadata
@@ -7716,8 +7883,8 @@
           }
           throw new Error(ERR_TYPE_CONVERSION);
         }
-        static fromName(name10) {
-          const glType = NAME_TO_GL_TYPE[name10];
+        static fromName(name12) {
+          const glType = NAME_TO_GL_TYPE[name12];
           if (!glType) {
             throw new Error(ERR_TYPE_CONVERSION);
           }
@@ -7820,6 +7987,15 @@
     }
   });
 
+  // ../math/src/geometry/utils/coordinates.ts
+  function emod(n2) {
+    return (n2 % 1 + 1) % 1;
+  }
+  var init_coordinates = __esm({
+    "../math/src/geometry/utils/coordinates.ts"() {
+    }
+  });
+
   // ../math/src/index.ts
   var init_src7 = __esm({
     "../math/src/index.ts"() {
@@ -7827,6 +8003,7 @@
       init_gl_type();
       init_rgb565();
       init_attribute_compression();
+      init_coordinates();
     }
   });
 
@@ -8276,10 +8453,10 @@
           }
           return void 0;
         }
-        hasProperty(batchId, name10) {
+        hasProperty(batchId, name12) {
           this._checkBatchId(batchId);
-          assert2(typeof name10 === "string", name10);
-          return defined2(this._properties[name10]) || this._hasPropertyInHierarchy(batchId, name10);
+          assert2(typeof name12 === "string", name12);
+          return defined2(this._properties[name12]) || this._hasPropertyInHierarchy(batchId, name12);
         }
         getPropertyNames(batchId, results) {
           this._checkBatchId(batchId);
@@ -8292,47 +8469,47 @@
           }
           return results;
         }
-        getProperty(batchId, name10) {
+        getProperty(batchId, name12) {
           this._checkBatchId(batchId);
-          assert2(typeof name10 === "string", name10);
+          assert2(typeof name12 === "string", name12);
           if (this._binaryProperties) {
-            const binaryProperty = this._binaryProperties[name10];
+            const binaryProperty = this._binaryProperties[name12];
             if (defined2(binaryProperty)) {
               return this._getBinaryProperty(binaryProperty, batchId);
             }
           }
-          const propertyValues = this._properties[name10];
+          const propertyValues = this._properties[name12];
           if (defined2(propertyValues)) {
             return clone3(propertyValues[batchId], true);
           }
           if (this._hierarchy) {
-            const hierarchyProperty = this._getHierarchyProperty(batchId, name10);
+            const hierarchyProperty = this._getHierarchyProperty(batchId, name12);
             if (defined2(hierarchyProperty)) {
               return hierarchyProperty;
             }
           }
           return void 0;
         }
-        setProperty(batchId, name10, value) {
+        setProperty(batchId, name12, value) {
           const featureCount = this.featureCount;
           this._checkBatchId(batchId);
-          assert2(typeof name10 === "string", name10);
+          assert2(typeof name12 === "string", name12);
           if (this._binaryProperties) {
-            const binaryProperty = this._binaryProperties[name10];
+            const binaryProperty = this._binaryProperties[name12];
             if (binaryProperty) {
               this._setBinaryProperty(binaryProperty, batchId, value);
               return;
             }
           }
           if (this._hierarchy) {
-            if (this._setHierarchyProperty(this, batchId, name10, value)) {
+            if (this._setHierarchyProperty(this, batchId, name12, value)) {
               return;
             }
           }
-          let propertyValues = this._properties[name10];
+          let propertyValues = this._properties[name12];
           if (!defined2(propertyValues)) {
-            this._properties[name10] = new Array(featureCount);
-            propertyValues = this._properties[name10];
+            this._properties[name12] = new Array(featureCount);
+            propertyValues = this._properties[name12];
           }
           propertyValues[batchId] = clone3(value, true);
         }
@@ -8350,21 +8527,21 @@
         }
         _initializeBinaryProperties() {
           let binaryProperties = null;
-          for (const name10 in this._properties) {
-            const property = this._properties[name10];
-            const binaryProperty = this._initializeBinaryProperty(name10, property);
+          for (const name12 in this._properties) {
+            const property = this._properties[name12];
+            const binaryProperty = this._initializeBinaryProperty(name12, property);
             if (binaryProperty) {
               binaryProperties = binaryProperties || {};
-              binaryProperties[name10] = binaryProperty;
+              binaryProperties[name12] = binaryProperty;
             }
           }
           return binaryProperties;
         }
-        _initializeBinaryProperty(name10, property) {
+        _initializeBinaryProperty(name12, property) {
           if ("byteOffset" in property) {
             const tile3DAccessor = property;
-            assert2(this.binary, `Property ${name10} requires a batch table binary.`);
-            assert2(tile3DAccessor.type, `Property ${name10} requires a type.`);
+            assert2(this.binary, `Property ${name12} requires a batch table binary.`);
+            assert2(tile3DAccessor.type, `Property ${name12} requires a type.`);
             const accessor = createTypedArrayFromAccessor(tile3DAccessor, this.binary.buffer, this.binary.byteOffset | 0, this.featureCount);
             return {
               typedArray: accessor.values,
@@ -8375,14 +8552,14 @@
           }
           return null;
         }
-        _hasPropertyInHierarchy(batchId, name10) {
+        _hasPropertyInHierarchy(batchId, name12) {
           if (!this._hierarchy) {
             return false;
           }
           const result = traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
             const classId = hierarchy.classIds[instanceIndex];
             const instances = hierarchy.classes[classId].instances;
-            return defined2(instances[name10]);
+            return defined2(instances[name12]);
           });
           return defined2(result);
         }
@@ -8390,21 +8567,21 @@
           traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
             const classId = hierarchy.classIds[instanceIndex];
             const instances = hierarchy.classes[classId].instances;
-            for (const name10 in instances) {
-              if (instances.hasOwnProperty(name10)) {
-                if (results.indexOf(name10) === -1) {
-                  results.push(name10);
+            for (const name12 in instances) {
+              if (instances.hasOwnProperty(name12)) {
+                if (results.indexOf(name12) === -1) {
+                  results.push(name12);
                 }
               }
             }
           });
         }
-        _getHierarchyProperty(batchId, name10) {
+        _getHierarchyProperty(batchId, name12) {
           return traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
             const classId = hierarchy.classIds[instanceIndex];
             const instanceClass = hierarchy.classes[classId];
             const indexInClass = hierarchy.classIndexes[instanceIndex];
-            const propertyValues = instanceClass.instances[name10];
+            const propertyValues = instanceClass.instances[name12];
             if (defined2(propertyValues)) {
               if (defined2(propertyValues.typedArray)) {
                 return this._getBinaryProperty(propertyValues, indexInClass);
@@ -8414,14 +8591,14 @@
             return null;
           });
         }
-        _setHierarchyProperty(batchTable, batchId, name10, value) {
+        _setHierarchyProperty(batchTable, batchId, name12, value) {
           const result = traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
             const classId = hierarchy.classIds[instanceIndex];
             const instanceClass = hierarchy.classes[classId];
             const indexInClass = hierarchy.classIndexes[instanceIndex];
-            const propertyValues = instanceClass.instances[name10];
+            const propertyValues = instanceClass.instances[name12];
             if (defined2(propertyValues)) {
-              assert2(instanceIndex === batchId, `Inherited property "${name10}" is read-only.`);
+              assert2(instanceIndex === batchId, `Inherited property "${name12}" is read-only.`);
               if (defined2(propertyValues.typedArray)) {
                 this._setBinaryProperty(propertyValues, indexInClass, value);
               } else {
@@ -8823,7 +9000,6 @@
     if (!context) {
       return;
     }
-    const { parse: parse5 } = context;
     const dracoOptions = {
       ...options,
       draco: {
@@ -8832,7 +9008,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 +9046,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();
@@ -8882,19 +9059,11 @@
     }
   });
 
-  // ../gltf/src/lib/utils/version.ts
+  // ../images/src/lib/utils/version.ts
   var VERSION6;
   var init_version4 = __esm({
-    "../gltf/src/lib/utils/version.ts"() {
-      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    }
-  });
-
-  // ../images/src/lib/utils/version.ts
-  var VERSION7;
-  var init_version5 = __esm({
     "../images/src/lib/utils/version.ts"() {
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -9319,7 +9488,7 @@
   var EXTENSIONS, MIME_TYPES, DEFAULT_IMAGE_LOADER_OPTIONS, ImageLoader;
   var init_image_loader = __esm({
     "../images/src/image-loader.ts"() {
-      init_version5();
+      init_version4();
       init_parse_image();
       init_binary_image_api();
       EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
@@ -9343,7 +9512,7 @@
         id: "image",
         module: "images",
         name: "Images",
-        version: VERSION7,
+        version: VERSION6,
         mimeTypes: MIME_TYPES,
         extensions: EXTENSIONS,
         parse: parseImage,
@@ -9402,845 +9571,226 @@
     }
   });
 
-  // ../textures/src/lib/utils/version.ts
-  var VERSION8;
-  var init_version6 = __esm({
-    "../textures/src/lib/utils/version.ts"() {
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
-    }
-  });
-
-  // ../textures/src/lib/parsers/basis-module-loader.ts
-  async function loadBasisTranscoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basis) {
-      return modules.basis;
+  // ../gltf/src/lib/utils/assert.ts
+  function assert7(condition, message) {
+    if (!condition) {
+      throw new Error(message || "assert failed: gltf");
     }
-    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTranscoder(options);
-    return await loadBasisTranscoderPromise;
-  }
-  async function loadBasisTranscoder(options) {
-    let BASIS = null;
-    let wasmBinary = null;
-    [BASIS, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
-    ]);
-    BASIS = BASIS || globalThis.BASIS;
-    return await initializeBasisTranscoderModule(BASIS, wasmBinary);
   }
-  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  var init_assert6 = __esm({
+    "../gltf/src/lib/utils/assert.ts"() {
     }
-    return new Promise((resolve2) => {
-      BasisModule(options).then((module) => {
-        const { BasisFile, initializeBasis } = module;
-        initializeBasis();
-        resolve2({ BasisFile });
-      });
-    });
+  });
+
+  // ../gltf/src/lib/gltf-utils/gltf-utils.ts
+  function getAccessorTypeFromSize(size) {
+    const type = TYPES[size - 1];
+    return type || TYPES[0];
   }
-  async function loadBasisEncoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basisEncoder) {
-      return modules.basisEncoder;
+  function getComponentTypeFromArray(typedArray) {
+    const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+    if (!componentType) {
+      throw new Error("Illegal typed array");
     }
-    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
-    return await loadBasisEncoderPromise;
+    return componentType;
   }
-  async function loadBasisEncoder(options) {
-    let BASIS_ENCODER = null;
-    let wasmBinary = null;
-    [BASIS_ENCODER, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
-    ]);
-    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
-    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+  function getAccessorArrayTypeAndLength(accessor, bufferView) {
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+    const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+    const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+    const length4 = accessor.count * components;
+    const byteLength = accessor.count * components * bytesPerComponent;
+    assert7(byteLength >= 0 && byteLength <= bufferView.byteLength);
+    return { ArrayType, length: length4, byteLength };
   }
-  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
-    }
-    return new Promise((resolve2) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
-        initializeBasis();
-        resolve2({ BasisFile, KTX2File, BasisEncoder });
-      });
-    });
+  function getMemoryUsageGLTF(gltf) {
+    let { images, bufferViews } = gltf;
+    images = images || [];
+    bufferViews = bufferViews || [];
+    const imageBufferViews = images.map((i2) => i2.bufferView);
+    bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
+    const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
+    const pixelCount = images.reduce((acc, image) => {
+      const { width, height } = image.image;
+      return acc + width * height;
+    }, 0);
+    return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
   }
-  var BASIS_EXTERNAL_LIBRARIES, loadBasisTranscoderPromise, loadBasisEncoderPromise;
-  var init_basis_module_loader = __esm({
-    "../textures/src/lib/parsers/basis-module-loader.ts"() {
-      init_src();
-      BASIS_EXTERNAL_LIBRARIES = {
-        TRANSCODER: "basis_transcoder.js",
-        TRANSCODER_WASM: "basis_transcoder.wasm",
-        ENCODER: "basis_encoder.js",
-        ENCODER_WASM: "basis_encoder.wasm"
+  var MIPMAP_FACTOR, TYPES, ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT, ARRAY_TO_COMPONENT_TYPE, ATTRIBUTE_TYPE_TO_COMPONENTS, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY;
+  var init_gltf_utils = __esm({
+    "../gltf/src/lib/gltf-utils/gltf-utils.ts"() {
+      init_assert6();
+      MIPMAP_FACTOR = 1.33;
+      TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
+      ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
+        [Int8Array, 5120],
+        [Uint8Array, 5121],
+        [Int16Array, 5122],
+        [Uint16Array, 5123],
+        [Uint32Array, 5125],
+        [Float32Array, 5126],
+        [Float64Array, 5130]
+      ];
+      ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
+      ATTRIBUTE_TYPE_TO_COMPONENTS = {
+        SCALAR: 1,
+        VEC2: 2,
+        VEC3: 3,
+        VEC4: 4,
+        MAT2: 4,
+        MAT3: 9,
+        MAT4: 16
+      };
+      ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+        5120: 1,
+        5121: 1,
+        5122: 2,
+        5123: 2,
+        5125: 4,
+        5126: 4
+      };
+      ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+        5120: Int8Array,
+        5121: Uint8Array,
+        5122: Int16Array,
+        5123: Uint16Array,
+        5125: Uint32Array,
+        5126: Float32Array
       };
     }
   });
 
-  // ../textures/src/lib/gl-extensions.ts
-  var GL_EXTENSIONS_CONSTANTS;
-  var init_gl_extensions = __esm({
-    "../textures/src/lib/gl-extensions.ts"() {
-      GL_EXTENSIONS_CONSTANTS = {
-        COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
-        COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
-        COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
-        COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
-        COMPRESSED_R11_EAC: 37488,
-        COMPRESSED_SIGNED_R11_EAC: 37489,
-        COMPRESSED_RG11_EAC: 37490,
-        COMPRESSED_SIGNED_RG11_EAC: 37491,
-        COMPRESSED_RGB8_ETC2: 37492,
-        COMPRESSED_RGBA8_ETC2_EAC: 37493,
-        COMPRESSED_SRGB8_ETC2: 37494,
-        COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
-        COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
-        COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
-        COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
-        COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
-        COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
-        COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
-        COMPRESSED_RGB_ETC1_WEBGL: 36196,
-        COMPRESSED_RGB_ATC_WEBGL: 35986,
-        COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
-        COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
-        COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
-        COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
-        COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
-        COMPRESSED_RGBA_ASTC_6X5_KHR: 37811,
-        COMPRESSED_RGBA_ASTC_6X6_KHR: 37812,
-        COMPRESSED_RGBA_ASTC_8X5_KHR: 37813,
-        COMPRESSED_RGBA_ASTC_8X6_KHR: 37814,
-        COMPRESSED_RGBA_ASTC_8X8_KHR: 37815,
-        COMPRESSED_RGBA_ASTC_10X5_KHR: 37816,
-        COMPRESSED_RGBA_ASTC_10X6_KHR: 37817,
-        COMPRESSED_RGBA_ASTC_10X8_KHR: 37818,
-        COMPRESSED_RGBA_ASTC_10X10_KHR: 37819,
-        COMPRESSED_RGBA_ASTC_12X10_KHR: 37820,
-        COMPRESSED_RGBA_ASTC_12X12_KHR: 37821,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 37840,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: 37841,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: 37842,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: 37843,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: 37844,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: 37845,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: 37846,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: 37847,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: 37848,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: 37849,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: 37850,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
-        COMPRESSED_RED_RGTC1_EXT: 36283,
-        COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
-        COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
-        COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
-        COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
-        COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
-        COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
-        COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
-      };
-    }
-  });
-
-  // ../textures/src/lib/utils/texture-formats.ts
-  function getSupportedGPUTextureFormats(gl) {
-    if (!formats) {
-      gl = gl || getWebGLContext() || void 0;
-      formats = new Set();
-      for (const prefix of BROWSER_PREFIXES) {
-        for (const extension in WEBGL_EXTENSIONS) {
-          if (gl && gl.getExtension(`${prefix}${extension}`)) {
-            const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
-            formats.add(gpuTextureFormat);
+  // ../gltf/src/lib/api/gltf-scenegraph.ts
+  function makeDefaultGLTFJson() {
+    return {
+      asset: {
+        version: "2.0",
+        generator: "loaders.gl"
+      },
+      buffers: [],
+      extensions: {},
+      extensionsRequired: [],
+      extensionsUsed: []
+    };
+  }
+  var GLTFScenegraph;
+  var init_gltf_scenegraph = __esm({
+    "../gltf/src/lib/api/gltf-scenegraph.ts"() {
+      init_src8();
+      init_src2();
+      init_assert6();
+      init_gltf_utils();
+      GLTFScenegraph = class {
+        constructor(gltf) {
+          this.gltf = {
+            json: gltf?.json || makeDefaultGLTFJson(),
+            buffers: gltf?.buffers || [],
+            images: gltf?.images || []
+          };
+          this.sourceBuffers = [];
+          this.byteLength = 0;
+          if (this.gltf.buffers && this.gltf.buffers[0]) {
+            this.byteLength = this.gltf.buffers[0].byteLength;
+            this.sourceBuffers = [this.gltf.buffers[0]];
           }
         }
-      }
-    }
-    return formats;
-  }
-  function getWebGLContext() {
-    try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
-    } catch (error) {
-      return null;
-    }
-  }
-  var BROWSER_PREFIXES, WEBGL_EXTENSIONS, formats;
-  var init_texture_formats = __esm({
-    "../textures/src/lib/utils/texture-formats.ts"() {
-      BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
-      WEBGL_EXTENSIONS = {
-        WEBGL_compressed_texture_s3tc: "dxt",
-        WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
-        WEBGL_compressed_texture_etc1: "etc1",
-        WEBGL_compressed_texture_etc: "etc2",
-        WEBGL_compressed_texture_pvrtc: "pvrtc",
-        WEBGL_compressed_texture_atc: "atc",
-        WEBGL_compressed_texture_astc: "astc",
-        EXT_texture_compression_rgtc: "rgtc"
-      };
-      formats = null;
-    }
-  });
-
-  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
-  var t, n, i, s, a, r, o, l, f;
-  var init_ktx_parse_modern = __esm({
-    "../../node_modules/ktx-parse/dist/ktx-parse.modern.js"() {
-      t = new Uint8Array([0]);
-      !function(t2) {
-        t2[t2.NONE = 0] = "NONE", t2[t2.BASISLZ = 1] = "BASISLZ", t2[t2.ZSTD = 2] = "ZSTD", t2[t2.ZLIB = 3] = "ZLIB";
-      }(n || (n = {})), function(t2) {
-        t2[t2.BASICFORMAT = 0] = "BASICFORMAT";
-      }(i || (i = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.ETC1S = 163] = "ETC1S", t2[t2.UASTC = 166] = "UASTC";
-      }(s || (s = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.SRGB = 1] = "SRGB";
-      }(a || (a = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.LINEAR = 1] = "LINEAR", t2[t2.SRGB = 2] = "SRGB", t2[t2.ITU = 3] = "ITU", t2[t2.NTSC = 4] = "NTSC", t2[t2.SLOG = 5] = "SLOG", t2[t2.SLOG2 = 6] = "SLOG2";
-      }(r || (r = {})), function(t2) {
-        t2[t2.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t2[t2.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
-      }(o || (o = {})), function(t2) {
-        t2[t2.RGB = 0] = "RGB", t2[t2.RRR = 3] = "RRR", t2[t2.GGG = 4] = "GGG", t2[t2.AAA = 15] = "AAA";
-      }(l || (l = {})), function(t2) {
-        t2[t2.RGB = 0] = "RGB", t2[t2.RGBA = 3] = "RGBA", t2[t2.RRR = 4] = "RRR", t2[t2.RRRG = 5] = "RRRG";
-      }(f || (f = {}));
-    }
-  });
-
-  // ../textures/src/lib/parsers/parse-ktx.ts
-  function isKTX(data) {
-    const id = new Uint8Array(data);
-    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
-    return !notKTX;
-  }
-  var KTX2_ID;
-  var init_parse_ktx = __esm({
-    "../textures/src/lib/parsers/parse-ktx.ts"() {
-      init_ktx_parse_modern();
-      KTX2_ID = [
-        171,
-        75,
-        84,
-        88,
-        32,
-        50,
-        48,
-        187,
-        13,
-        10,
-        26,
-        10
-      ];
-    }
-  });
-
-  // ../textures/src/lib/parsers/parse-basis.ts
-  async function parseBasis(data, options) {
-    if (options.basis.containerFormat === "auto") {
-      if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(options);
-        return parseKTX2File(fileConstructors.KTX2File, data, options);
-      }
-      const { BasisFile } = await loadBasisTranscoderModule(options);
-      return parseBasisFile(BasisFile, data, options);
-    }
-    switch (options.basis.module) {
-      case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(options);
-        switch (options.basis.containerFormat) {
-          case "ktx2":
-            return parseKTX2File(fileConstructors.KTX2File, data, options);
-          case "basis":
-          default:
-            return parseBasisFile(fileConstructors.BasisFile, data, options);
+        get json() {
+          return this.gltf.json;
         }
-      case "transcoder":
-      default:
-        const { BasisFile } = await loadBasisTranscoderModule(options);
-        return parseBasisFile(BasisFile, data, options);
-    }
-  }
-  function parseBasisFile(BasisFile, data, options) {
-    const basisFile = new BasisFile(new Uint8Array(data));
-    try {
-      if (!basisFile.startTranscoding()) {
-        throw new Error("Failed to start basis transcoding");
-      }
-      const imageCount = basisFile.getNumImages();
-      const images = [];
-      for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
-        const levelsCount = basisFile.getNumLevels(imageIndex);
-        const levels = [];
-        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-          levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
+        getApplicationData(key) {
+          const data = this.json[key];
+          return data;
         }
-        images.push(levels);
-      }
-      return images;
-    } finally {
-      basisFile.close();
-      basisFile.delete();
-    }
-  }
-  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
-    const width = basisFile.getImageWidth(imageIndex, levelIndex);
-    const height = basisFile.getImageHeight(imageIndex, levelIndex);
-    const hasAlpha = basisFile.getHasAlpha();
-    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
-    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-      throw new Error("failed to start Basis transcoding");
-    }
-    return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      format,
-      hasAlpha
-    };
-  }
-  function parseKTX2File(KTX2File, data, options) {
-    const ktx2File = new KTX2File(new Uint8Array(data));
-    try {
-      if (!ktx2File.startTranscoding()) {
-        throw new Error("failed to start KTX2 transcoding");
-      }
-      const levelsCount = ktx2File.getLevels();
-      const levels = [];
-      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
-        break;
-      }
-      return [levels];
-    } finally {
-      ktx2File.close();
-      ktx2File.delete();
-    }
-  }
-  function transcodeKTX2Image(ktx2File, levelIndex, options) {
-    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
-    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
-    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
-      throw new Error("Failed to transcode KTX2 image");
-    }
-    return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      levelSize: decodedSize,
-      hasAlpha: alphaFlag,
-      format
-    };
-  }
-  function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
-    if (format === "auto") {
-      format = selectSupportedBasisFormat();
-    }
-    if (typeof format === "object") {
-      format = hasAlpha ? format.alpha : format.noAlpha;
-    }
-    format = format.toLowerCase();
-    return OutputFormat[format];
-  }
-  function selectSupportedBasisFormat() {
-    const supportedFormats = getSupportedGPUTextureFormats();
-    if (supportedFormats.has("astc")) {
-      return "astc-4x4";
-    } else if (supportedFormats.has("dxt")) {
-      return {
-        alpha: "bc3",
-        noAlpha: "bc1"
-      };
-    } else if (supportedFormats.has("pvrtc")) {
-      return {
-        alpha: "pvrtc1-4-rgba",
-        noAlpha: "pvrtc1-4-rgb"
-      };
-    } else if (supportedFormats.has("etc1")) {
-      return "etc1";
-    } else if (supportedFormats.has("etc2")) {
-      return "etc2";
-    }
-    return "rgb565";
-  }
-  var OutputFormat;
-  var init_parse_basis = __esm({
-    "../textures/src/lib/parsers/parse-basis.ts"() {
-      init_basis_module_loader();
-      init_gl_extensions();
-      init_texture_formats();
-      init_parse_ktx();
-      OutputFormat = {
-        etc1: {
-          basisFormat: 0,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
-        },
-        etc2: { basisFormat: 1, compressed: true },
-        bc1: {
-          basisFormat: 2,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
-        },
-        bc3: {
-          basisFormat: 3,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
-        },
-        bc4: { basisFormat: 4, compressed: true },
-        bc5: { basisFormat: 5, compressed: true },
-        "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
-        "bc7-m5": { basisFormat: 7, compressed: true },
-        "pvrtc1-4-rgb": {
-          basisFormat: 8,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
-        },
-        "pvrtc1-4-rgba": {
-          basisFormat: 9,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
-        },
-        "astc-4x4": {
-          basisFormat: 10,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
-        },
-        "atc-rgb": { basisFormat: 11, compressed: true },
-        "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
-        rgba32: { basisFormat: 13, compressed: false },
-        rgb565: { basisFormat: 14, compressed: false },
-        bgr565: { basisFormat: 15, compressed: false },
-        rgba4444: { basisFormat: 16, compressed: false }
-      };
-    }
-  });
-
-  // ../textures/src/basis-loader.ts
-  var BasisWorkerLoader, BasisLoader;
-  var init_basis_loader = __esm({
-    "../textures/src/basis-loader.ts"() {
-      init_version6();
-      init_parse_basis();
-      BasisWorkerLoader = {
-        name: "Basis",
-        id: "basis",
-        module: "textures",
-        version: VERSION8,
-        worker: true,
-        extensions: ["basis", "ktx2"],
-        mimeTypes: ["application/octet-stream", "image/ktx2"],
-        tests: ["sB"],
-        binary: true,
-        options: {
-          basis: {
-            format: "auto",
-            libraryPath: "libs/",
-            containerFormat: "auto",
-            module: "transcoder"
+        getExtraData(key) {
+          const extras = this.json.extras || {};
+          return extras[key];
+        }
+        hasExtension(extensionName) {
+          const isUsedExtension = this.getUsedExtensions().find((name12) => name12 === extensionName);
+          const isRequiredExtension = this.getRequiredExtensions().find((name12) => name12 === extensionName);
+          return typeof isUsedExtension === "string" || typeof isRequiredExtension === "string";
+        }
+        getExtension(extensionName) {
+          const isExtension = this.getUsedExtensions().find((name12) => name12 === extensionName);
+          const extensions = this.json.extensions || {};
+          return isExtension ? extensions[extensionName] : null;
+        }
+        getRequiredExtension(extensionName) {
+          const isRequired = this.getRequiredExtensions().find((name12) => name12 === extensionName);
+          return isRequired ? this.getExtension(extensionName) : null;
+        }
+        getRequiredExtensions() {
+          return this.json.extensionsRequired || [];
+        }
+        getUsedExtensions() {
+          return this.json.extensionsUsed || [];
+        }
+        getRemovedExtensions() {
+          return this.json.extensionsRemoved || [];
+        }
+        getObjectExtension(object, extensionName) {
+          const extensions = object.extensions || {};
+          return extensions[extensionName];
+        }
+        getScene(index) {
+          return this.getObject("scenes", index);
+        }
+        getNode(index) {
+          return this.getObject("nodes", index);
+        }
+        getSkin(index) {
+          return this.getObject("skins", index);
+        }
+        getMesh(index) {
+          return this.getObject("meshes", index);
+        }
+        getMaterial(index) {
+          return this.getObject("materials", index);
+        }
+        getAccessor(index) {
+          return this.getObject("accessors", index);
+        }
+        getTexture(index) {
+          return this.getObject("textures", index);
+        }
+        getSampler(index) {
+          return this.getObject("samplers", index);
+        }
+        getImage(index) {
+          return this.getObject("images", index);
+        }
+        getBufferView(index) {
+          return this.getObject("bufferViews", index);
+        }
+        getBuffer(index) {
+          return this.getObject("buffers", index);
+        }
+        getObject(array, index) {
+          if (typeof index === "object") {
+            return index;
+          }
+          const object = this.json[array] && this.json[array][index];
+          if (!object) {
+            throw new Error(`glTF file error: Could not find ${array}[${index}]`);
           }
+          return object;
         }
-      };
-      BasisLoader = {
-        ...BasisWorkerLoader,
-        parse: parseBasis
-      };
-    }
-  });
-
-  // ../textures/src/index.ts
-  var init_src9 = __esm({
-    "../textures/src/index.ts"() {
-      init_basis_loader();
-      init_parse_basis();
-    }
-  });
-
-  // ../gltf/src/lib/utils/assert.ts
-  function assert7(condition, message) {
-    if (!condition) {
-      throw new Error(message || "assert failed: gltf");
-    }
-  }
-  var init_assert6 = __esm({
-    "../gltf/src/lib/utils/assert.ts"() {
-    }
-  });
-
-  // ../gltf/src/lib/parsers/parse-glb.ts
-  function getMagicString4(dataView, byteOffset = 0) {
-    return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
-  }
-  function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
-    const dataView = new DataView(arrayBuffer);
-    const { magic = MAGIC_glTF } = options;
-    const magic1 = dataView.getUint32(byteOffset, false);
-    return magic1 === magic || magic1 === MAGIC_glTF;
-  }
-  function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
-    const dataView = new DataView(arrayBuffer);
-    const type = getMagicString4(dataView, byteOffset + 0);
-    const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
-    const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
-    Object.assign(glb, {
-      header: {
-        byteOffset,
-        byteLength,
-        hasBinChunk: false
-      },
-      type,
-      version,
-      json: {},
-      binChunks: []
-    });
-    byteOffset += GLB_FILE_HEADER_SIZE;
-    switch (glb.version) {
-      case 1:
-        return parseGLBV1(glb, dataView, byteOffset);
-      case 2:
-        return parseGLBV2(glb, dataView, byteOffset, options = {});
-      default:
-        throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);
-    }
-  }
-  function parseGLBV1(glb, dataView, byteOffset) {
-    assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-    const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
-    const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
-    byteOffset += GLB_CHUNK_HEADER_SIZE;
-    assert2(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
-    parseJSONChunk(glb, dataView, byteOffset, contentLength);
-    byteOffset += contentLength;
-    byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
-    return byteOffset;
-  }
-  function parseGLBV2(glb, dataView, byteOffset, options) {
-    assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-    parseGLBChunksSync(glb, dataView, byteOffset, options);
-    return byteOffset + glb.header.byteLength;
-  }
-  function parseGLBChunksSync(glb, dataView, byteOffset, options) {
-    while (byteOffset + 8 <= glb.header.byteLength) {
-      const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
-      const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
-      byteOffset += GLB_CHUNK_HEADER_SIZE;
-      switch (chunkFormat) {
-        case GLB_CHUNK_TYPE_JSON:
-          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-          break;
-        case GLB_CHUNK_TYPE_BIN:
-          parseBINChunk(glb, dataView, byteOffset, chunkLength);
-          break;
-        case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
-          if (!options.strict) {
-            parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-          }
-          break;
-        case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
-          if (!options.strict) {
-            parseBINChunk(glb, dataView, byteOffset, chunkLength);
-          }
-          break;
-        default:
-          break;
-      }
-      byteOffset += padToNBytes(chunkLength, 4);
-    }
-    return byteOffset;
-  }
-  function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
-    const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
-    const textDecoder = new TextDecoder("utf8");
-    const jsonText = textDecoder.decode(jsonChunk);
-    glb.json = JSON.parse(jsonText);
-    return padToNBytes(chunkLength, 4);
-  }
-  function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
-    glb.header.hasBinChunk = true;
-    glb.binChunks.push({
-      byteOffset,
-      byteLength: chunkLength,
-      arrayBuffer: dataView.buffer
-    });
-    return padToNBytes(chunkLength, 4);
-  }
-  var LITTLE_ENDIAN2, MAGIC_glTF, GLB_FILE_HEADER_SIZE, GLB_CHUNK_HEADER_SIZE, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLB_V1_CONTENT_FORMAT_JSON, GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED, GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED;
-  var init_parse_glb = __esm({
-    "../gltf/src/lib/parsers/parse-glb.ts"() {
-      init_src2();
-      LITTLE_ENDIAN2 = true;
-      MAGIC_glTF = 1735152710;
-      GLB_FILE_HEADER_SIZE = 12;
-      GLB_CHUNK_HEADER_SIZE = 8;
-      GLB_CHUNK_TYPE_JSON = 1313821514;
-      GLB_CHUNK_TYPE_BIN = 5130562;
-      GLB_V1_CONTENT_FORMAT_JSON = 0;
-      GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
-      GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
-    }
-  });
-
-  // ../gltf/src/lib/gltf-utils/resolve-url.ts
-  function resolveUrl(url, options) {
-    const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
-    if (absolute) {
-      return url;
-    }
-    const baseUrl = options.baseUri || options.uri;
-    if (!baseUrl) {
-      throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
-    }
-    return baseUrl.substr(0, baseUrl.lastIndexOf("/") + 1) + url;
-  }
-  var init_resolve_url = __esm({
-    "../gltf/src/lib/gltf-utils/resolve-url.ts"() {
-    }
-  });
-
-  // ../gltf/src/lib/gltf-utils/get-typed-array.ts
-  function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
-    const bufferView = json.bufferViews[bufferViewIndex];
-    assert7(bufferView);
-    const bufferIndex = bufferView.buffer;
-    const binChunk = buffers[bufferIndex];
-    assert7(binChunk);
-    const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
-    return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
-  }
-  var init_get_typed_array = __esm({
-    "../gltf/src/lib/gltf-utils/get-typed-array.ts"() {
-      init_assert6();
-    }
-  });
-
-  // ../gltf/src/lib/gltf-utils/gltf-utils.ts
-  function getAccessorTypeFromSize(size) {
-    const type = TYPES[size - 1];
-    return type || TYPES[0];
-  }
-  function getComponentTypeFromArray(typedArray) {
-    const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
-    if (!componentType) {
-      throw new Error("Illegal typed array");
-    }
-    return componentType;
-  }
-  function getAccessorArrayTypeAndLength(accessor, bufferView) {
-    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
-    const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
-    const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
-    const length4 = accessor.count * components;
-    const byteLength = accessor.count * components * bytesPerComponent;
-    assert7(byteLength >= 0 && byteLength <= bufferView.byteLength);
-    return { ArrayType, length: length4, byteLength };
-  }
-  function getMemoryUsageGLTF(gltf) {
-    let { images, bufferViews } = gltf;
-    images = images || [];
-    bufferViews = bufferViews || [];
-    const imageBufferViews = images.map((i2) => i2.bufferView);
-    bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
-    const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
-    const pixelCount = images.reduce((acc, image) => {
-      const { width, height } = image.image;
-      return acc + width * height;
-    }, 0);
-    return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
-  }
-  var MIPMAP_FACTOR, TYPES, ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT, ARRAY_TO_COMPONENT_TYPE, ATTRIBUTE_TYPE_TO_COMPONENTS, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY;
-  var init_gltf_utils = __esm({
-    "../gltf/src/lib/gltf-utils/gltf-utils.ts"() {
-      init_assert6();
-      MIPMAP_FACTOR = 1.33;
-      TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
-      ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
-        [Int8Array, 5120],
-        [Uint8Array, 5121],
-        [Int16Array, 5122],
-        [Uint16Array, 5123],
-        [Uint32Array, 5125],
-        [Float32Array, 5126],
-        [Float64Array, 5130]
-      ];
-      ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
-      ATTRIBUTE_TYPE_TO_COMPONENTS = {
-        SCALAR: 1,
-        VEC2: 2,
-        VEC3: 3,
-        VEC4: 4,
-        MAT2: 4,
-        MAT3: 9,
-        MAT4: 16
-      };
-      ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
-        5120: 1,
-        5121: 1,
-        5122: 2,
-        5123: 2,
-        5125: 4,
-        5126: 4
-      };
-      ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-        5120: Int8Array,
-        5121: Uint8Array,
-        5122: Int16Array,
-        5123: Uint16Array,
-        5125: Uint32Array,
-        5126: Float32Array
-      };
-    }
-  });
-
-  // ../gltf/src/lib/api/gltf-scenegraph.ts
-  function makeDefaultGLTFJson() {
-    return {
-      asset: {
-        version: "2.0",
-        generator: "loaders.gl"
-      },
-      buffers: [],
-      extensions: {},
-      extensionsRequired: [],
-      extensionsUsed: []
-    };
-  }
-  var GLTFScenegraph;
-  var init_gltf_scenegraph = __esm({
-    "../gltf/src/lib/api/gltf-scenegraph.ts"() {
-      init_src8();
-      init_src2();
-      init_assert6();
-      init_gltf_utils();
-      GLTFScenegraph = class {
-        constructor(gltf) {
-          this.gltf = {
-            json: gltf?.json || makeDefaultGLTFJson(),
-            buffers: gltf?.buffers || [],
-            images: gltf?.images || []
-          };
-          this.sourceBuffers = [];
-          this.byteLength = 0;
-          if (this.gltf.buffers && this.gltf.buffers[0]) {
-            this.byteLength = this.gltf.buffers[0].byteLength;
-            this.sourceBuffers = [this.gltf.buffers[0]];
-          }
+        getTypedArrayForBufferView(bufferView) {
+          bufferView = this.getBufferView(bufferView);
+          const bufferIndex = bufferView.buffer;
+          const binChunk = this.gltf.buffers[bufferIndex];
+          assert7(binChunk);
+          const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+          return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
         }
-        get json() {
-          return this.gltf.json;
-        }
-        getApplicationData(key) {
-          const data = this.json[key];
-          return data;
-        }
-        getExtraData(key) {
-          const extras = this.json.extras || {};
-          return extras[key];
-        }
-        hasExtension(extensionName) {
-          const isUsedExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
-          const isRequiredExtension = this.getRequiredExtensions().find((name10) => name10 === extensionName);
-          return typeof isUsedExtension === "string" || typeof isRequiredExtension === "string";
-        }
-        getExtension(extensionName) {
-          const isExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
-          const extensions = this.json.extensions || {};
-          return isExtension ? extensions[extensionName] : null;
-        }
-        getRequiredExtension(extensionName) {
-          const isRequired = this.getRequiredExtensions().find((name10) => name10 === extensionName);
-          return isRequired ? this.getExtension(extensionName) : null;
-        }
-        getRequiredExtensions() {
-          return this.json.extensionsRequired || [];
-        }
-        getUsedExtensions() {
-          return this.json.extensionsUsed || [];
-        }
-        getRemovedExtensions() {
-          return this.json.extensionsRemoved || [];
-        }
-        getObjectExtension(object, extensionName) {
-          const extensions = object.extensions || {};
-          return extensions[extensionName];
-        }
-        getScene(index) {
-          return this.getObject("scenes", index);
-        }
-        getNode(index) {
-          return this.getObject("nodes", index);
-        }
-        getSkin(index) {
-          return this.getObject("skins", index);
-        }
-        getMesh(index) {
-          return this.getObject("meshes", index);
-        }
-        getMaterial(index) {
-          return this.getObject("materials", index);
-        }
-        getAccessor(index) {
-          return this.getObject("accessors", index);
-        }
-        getTexture(index) {
-          return this.getObject("textures", index);
-        }
-        getSampler(index) {
-          return this.getObject("samplers", index);
-        }
-        getImage(index) {
-          return this.getObject("images", index);
-        }
-        getBufferView(index) {
-          return this.getObject("bufferViews", index);
-        }
-        getBuffer(index) {
-          return this.getObject("buffers", index);
-        }
-        getObject(array, index) {
-          if (typeof index === "object") {
-            return index;
-          }
-          const object = this.json[array] && this.json[array][index];
-          if (!object) {
-            throw new Error(`glTF file error: Could not find ${array}[${index}]`);
-          }
-          return object;
-        }
-        getTypedArrayForBufferView(bufferView) {
-          bufferView = this.getBufferView(bufferView);
-          const bufferIndex = bufferView.buffer;
-          const binChunk = this.gltf.buffers[bufferIndex];
-          assert7(binChunk);
-          const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
-          return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
-        }
-        getTypedArrayForAccessor(accessor) {
-          accessor = this.getAccessor(accessor);
-          const bufferView = this.getBufferView(accessor.bufferView);
-          const buffer = this.getBuffer(bufferView.buffer);
-          const arrayBuffer = buffer.data;
-          const { ArrayType, length: length4 } = getAccessorArrayTypeAndLength(accessor, bufferView);
-          const byteOffset = bufferView.byteOffset + accessor.byteOffset;
-          return new ArrayType(arrayBuffer, byteOffset, length4);
+        getTypedArrayForAccessor(accessor) {
+          accessor = this.getAccessor(accessor);
+          const bufferView = this.getBufferView(accessor.bufferView);
+          const buffer = this.getBuffer(bufferView.buffer);
+          const arrayBuffer = buffer.data;
+          const { ArrayType, length: length4 } = getAccessorArrayTypeAndLength(accessor, bufferView);
+          const byteOffset = bufferView.byteOffset + accessor.byteOffset;
+          return new ArrayType(arrayBuffer, byteOffset, length4);
         }
         getTypedArrayForImageData(image) {
           image = this.getAccessor(image);
@@ -10476,66 +10026,1432 @@
             }
           }
         }
-        _addAttributes(attributes = {}) {
-          const result = {};
-          for (const attributeKey in attributes) {
-            const attributeData = attributes[attributeKey];
-            const attrName = this._getGltfAttributeName(attributeKey);
-            const accessor = this.addBinaryBuffer(attributeData.value, attributeData);
-            result[attrName] = accessor;
-          }
-          return result;
+        _addAttributes(attributes = {}) {
+          const result = {};
+          for (const attributeKey in attributes) {
+            const attributeData = attributes[attributeKey];
+            const attrName = this._getGltfAttributeName(attributeKey);
+            const accessor = this.addBinaryBuffer(attributeData.value, attributeData);
+            result[attrName] = accessor;
+          }
+          return result;
+        }
+        _addIndices(indices) {
+          return this.addBinaryBuffer(indices, { size: 1 });
+        }
+        _getGltfAttributeName(attributeName) {
+          switch (attributeName.toLowerCase()) {
+            case "position":
+            case "positions":
+            case "vertices":
+              return "POSITION";
+            case "normal":
+            case "normals":
+              return "NORMAL";
+            case "color":
+            case "colors":
+              return "COLOR_0";
+            case "texcoord":
+            case "texcoords":
+              return "TEXCOORD_0";
+            default:
+              return attributeName;
+          }
+        }
+        _getAccessorMinMax(buffer, size) {
+          const result = { min: null, max: null };
+          if (buffer.length < size) {
+            return result;
+          }
+          result.min = [];
+          result.max = [];
+          const initValues = buffer.subarray(0, size);
+          for (const value of initValues) {
+            result.min.push(value);
+            result.max.push(value);
+          }
+          for (let index = size; index < buffer.length; index += size) {
+            for (let componentIndex = 0; componentIndex < size; componentIndex++) {
+              result.min[0 + componentIndex] = Math.min(result.min[0 + componentIndex], buffer[index + componentIndex]);
+              result.max[0 + componentIndex] = Math.max(result.max[0 + componentIndex], buffer[index + componentIndex]);
+            }
+          }
+          return result;
+        }
+      };
+    }
+  });
+
+  // ../gltf/src/lib/extensions/data-processing.ts
+  function getArrayElementByteSize(attributeType, componentType) {
+    return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
+  }
+  function convertRawBufferToMetadataArray(typedArray, attributeType, componentType, elementCount = 1) {
+    const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2[componentType];
+    const length4 = elementCount * numberOfComponents;
+    const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType];
+    const offset = typedArray.byteOffset % size ? Math.ceil(typedArray.byteOffset / size) * size : typedArray.byteOffset;
+    return new ArrayType(typedArray.buffer, offset, length4);
+  }
+  function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
+    const json = scenegraph.gltf.json;
+    const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
+    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
+    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+    const textureIndex = textureInfo.index;
+    const imageIndex = json.textures?.[textureIndex]?.source;
+    if (typeof imageIndex !== "undefined") {
+      const mimeType = json.images?.[imageIndex]?.mimeType;
+      const parsedImage = scenegraph.gltf.images?.[imageIndex];
+      if (parsedImage && typeof parsedImage.width !== "undefined") {
+        const textureData = [];
+        for (let index = 0; index < textureCoordinates.length; index += 2) {
+          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
+          textureData.push(value);
+        }
+        return textureData;
+      }
+    }
+    return null;
+  }
+  function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
+    if (propertyData === null)
+      return;
+    const featureIndices = [];
+    for (const texelData of propertyData) {
+      let index = featureTable.findIndex((item) => item === texelData);
+      if (index === -1) {
+        index = featureTable.push(texelData) - 1;
+      }
+      featureIndices.push(index);
+    }
+    const typedArray = new Uint32Array(featureIndices);
+    const bufferIndex = scenegraph.gltf.buffers.push({
+      arrayBuffer: typedArray.buffer,
+      byteOffset: typedArray.byteOffset,
+      byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+      size: 1,
+      componentType: getComponentTypeFromArray(typedArray),
+      count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+  }
+  function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
+    const CHANNELS_MAP = [
+      { offset: 0, shift: 0 },
+      { offset: 1, shift: 8 },
+      { offset: 2, shift: 16 },
+      { offset: 3, shift: 24 }
+    ];
+    const u = textureCoordinates[index];
+    const v = textureCoordinates[index + 1];
+    let components = 1;
+    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
+      components = 4;
+    const offset = coordinatesToOffset(u, v, parsedImage, components);
+    let value = 0;
+    for (const c of channels) {
+      const map2 = CHANNELS_MAP[c];
+      const imageOffset = offset + map2.offset;
+      const imageData = getImageData(parsedImage);
+      if (imageData.data.length <= imageOffset) {
+        throw new Error(`${imageData.data.length} <= ${imageOffset}`);
+      }
+      const imageValue = imageData.data[imageOffset];
+      value |= imageValue << map2.shift;
+    }
+    return value;
+  }
+  function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
+    const w = parsedImage.width;
+    const iX = emod(u) * (w - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = emod(v) * (h - 1);
+    const indY = Math.round(iY);
+    const components = parsedImage.components ? parsedImage.components : componentsCount;
+    const offset = (indY * w + indX) * components;
+    return offset;
+  }
+  var ATTRIBUTE_TYPE_TO_COMPONENTS2, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2;
+  var init_data_processing = __esm({
+    "../gltf/src/lib/extensions/data-processing.ts"() {
+      init_gltf_utils();
+      init_src8();
+      init_src7();
+      ATTRIBUTE_TYPE_TO_COMPONENTS2 = {
+        SCALAR: 1,
+        VEC2: 2,
+        VEC3: 3,
+        VEC4: 4,
+        MAT2: 4,
+        MAT3: 9,
+        MAT4: 16,
+        BOOLEAN: 1,
+        STRING: 1,
+        ENUM: 1
+      };
+      ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2 = {
+        INT8: Int8Array,
+        UINT8: Uint8Array,
+        INT16: Int16Array,
+        UINT16: Uint16Array,
+        INT32: Int32Array,
+        UINT32: Uint32Array,
+        INT64: BigInt64Array,
+        UINT64: BigUint64Array,
+        FLOAT32: Float32Array,
+        FLOAT64: Float64Array
+      };
+      ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2 = {
+        INT8: 1,
+        UINT8: 1,
+        INT16: 2,
+        UINT16: 2,
+        INT32: 4,
+        UINT32: 4,
+        INT64: 8,
+        UINT64: 8,
+        FLOAT32: 4,
+        FLOAT64: 8
+      };
+    }
+  });
+
+  // ../gltf/src/lib/extensions/EXT_structural_metadata.ts
+  var EXT_structural_metadata_exports = {};
+  __export(EXT_structural_metadata_exports, {
+    decode: () => decode,
+    getPropertyTablePopulated: () => getPropertyTablePopulated,
+    name: () => name
+  });
+  async function decode(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtStructuralMetadata(scenegraph, options);
+  }
+  function getPropertyTablePopulated(scenegraph, propertyTableIndex) {
+    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    const propertyTable = extension?.propertyTables?.[propertyTableIndex];
+    if (extension?.schema && propertyTable) {
+      processPropertyTable(scenegraph, extension.schema, propertyTable);
+      return propertyTable;
+    }
+    throw new Error(`Incorrect data in the EXT_structural_metadata extension: no property table with index ${propertyTableIndex}`);
+  }
+  function decodeExtStructuralMetadata(scenegraph, options) {
+    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    if (!extension?.schema) {
+      return;
+    }
+    const propertyTextures = extension.propertyTextures;
+    const json = scenegraph.gltf.json;
+    if (propertyTextures && json.meshes && options?.gltf?.loadImages) {
+      for (const mesh of json.meshes) {
+        for (const primitive of mesh.primitives) {
+          processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension);
+        }
+      }
+    }
+    const schemaClasses = extension.schema.classes;
+    const propertyTables = extension.propertyTables;
+    if (schemaClasses && propertyTables) {
+      for (const schemaName in schemaClasses) {
+        const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
+        if (propertyTable) {
+          processPropertyTable(scenegraph, extension.schema, propertyTable);
+        }
+      }
+    }
+  }
+  function processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension) {
+    if (!propertyTextures) {
+      return;
+    }
+    const primitiveExtension = primitive.extensions?.[EXT_STRUCTURAL_METADATA_NAME];
+    const primitivePropertyTextureIndices = primitiveExtension?.propertyTextures;
+    if (!primitivePropertyTextureIndices) {
+      return;
+    }
+    for (const primitivePropertyTextureIndex of primitivePropertyTextureIndices) {
+      const propertyTexture = propertyTextures[primitivePropertyTextureIndex];
+      processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension);
+    }
+  }
+  function processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension) {
+    if (!propertyTexture.properties) {
+      return;
+    }
+    if (!extension.dataAttributeNames) {
+      extension.dataAttributeNames = [];
+    }
+    const className = propertyTexture.class;
+    for (const propName in propertyTexture.properties) {
+      const attributeName = `${className}_${propName}`;
+      const textureInfoTopLevel = propertyTexture.properties?.[propName];
+      if (!textureInfoTopLevel) {
+        continue;
+      }
+      if (!textureInfoTopLevel.data) {
+        textureInfoTopLevel.data = [];
+      }
+      const featureTextureTable = textureInfoTopLevel.data;
+      const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
+      if (propertyData === null) {
+        continue;
+      }
+      primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
+      textureInfoTopLevel.data = featureTextureTable;
+      extension.dataAttributeNames.push(attributeName);
+    }
+  }
+  function processPropertyTable(scenegraph, schema, propertyTable) {
+    const schemaClass = schema.classes?.[propertyTable.class];
+    if (!schemaClass) {
+      throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
+    }
+    const numberOfElements = propertyTable.count;
+    for (const propertyName in schemaClass.properties) {
+      const classProperty = schemaClass.properties[propertyName];
+      const propertyTableProperty = propertyTable.properties?.[propertyName];
+      if (propertyTableProperty) {
+        const data = getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
+        propertyTableProperty.data = data;
+      }
+    }
+  }
+  function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty) {
+    let data = [];
+    const valuesBufferView = propertyTableProperty.values;
+    const valuesDataBytes = scenegraph.getTypedArrayForBufferView(valuesBufferView);
+    let arrayOffsets = null;
+    if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined" && typeof propertyTableProperty.arrayOffsetType !== "undefined") {
+      arrayOffsets = getOffsetArray(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType, numberOfElements);
+    }
+    let stringOffsets = null;
+    if (typeof propertyTableProperty.stringOffsets !== "undefined" && typeof propertyTableProperty.stringOffsetType !== "undefined") {
+      stringOffsets = getOffsetArray(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType, numberOfElements);
+    }
+    switch (classProperty.type) {
+      case "SCALAR":
+      case "VEC2":
+      case "VEC3":
+      case "VEC4":
+      case "MAT2":
+      case "MAT3":
+      case "MAT4": {
+        data = getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+        break;
+      }
+      case "BOOLEAN": {
+        throw new Error(`Not implemented - classProperty.type=${classProperty.type}`);
+      }
+      case "STRING": {
+        data = getPropertyDataString(classProperty, numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets);
+        break;
+      }
+      case "ENUM": {
+        data = getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+        break;
+      }
+      default:
+        throw new Error(`Unknown classProperty type ${classProperty.type}`);
+    }
+    return data;
+  }
+  function getOffsetArray(scenegraph, offsets, offsetType, numberOfElements) {
+    const arrayOffsetsBufferView = offsets;
+    const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(arrayOffsetsBufferView);
+    const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, "SCALAR", offsetType, numberOfElements + 1);
+    return arrayOffsets;
+  }
+  function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+    const isArray2 = classProperty.array;
+    const arrayCount = classProperty.count;
+    const elementSize = getArrayElementByteSize(classProperty.type, classProperty.componentType);
+    const elementCount = valuesDataBytes.byteLength / elementSize;
+    let valuesData;
+    if (classProperty.componentType) {
+      valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, classProperty.componentType, elementCount);
+    } else {
+      valuesData = valuesDataBytes;
+    }
+    if (isArray2) {
+      if (arrayOffsets) {
+        return handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+      }
+      if (arrayCount) {
+        return handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+      }
+      return [];
+    }
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+      const value = valuesData[index];
+      attributeValueArray.push(value);
+    }
+    return attributeValueArray;
+  }
+  function handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+      const array = [];
+      const arrayOffset = arrayOffsets[index];
+      const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
+      if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
+        const typedArrayOffset = arrayOffset / elementSize;
+        const elementCount = arrayByteSize / elementSize;
+        for (let i2 = 0; i2 < elementCount; i2++) {
+          const value = valuesData[typedArrayOffset + i2];
+          array.push(value);
+        }
+      }
+      attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+  }
+  function handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+      const array = [];
+      for (let i2 = 0; i2 < arrayCount; i2++) {
+        const value = valuesData[i2];
+        array.push(value);
+      }
+      attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+  }
+  function getPropertyDataString(classProperty, numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets) {
+    if (arrayOffsets) {
+      throw new Error(`Not implemented - classProperty.type=${classProperty.type}`);
+    }
+    if (stringOffsets) {
+      const stringsArray = [];
+      const textDecoder = new TextDecoder("utf8");
+      let stringOffset = 0;
+      for (let index = 0; index < numberOfElements; index++) {
+        const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];
+        if (stringByteSize + stringOffset <= valuesDataBytes.length) {
+          const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);
+          const stringAttribute = textDecoder.decode(stringData);
+          stringsArray.push(stringAttribute);
+          stringOffset += stringByteSize;
+        }
+      }
+      return stringsArray;
+    }
+    return [];
+  }
+  function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+    const data = [];
+    const isArray2 = classProperty.array;
+    const arrayCount = classProperty.count;
+    const enumType = classProperty.enumType;
+    if (!enumType) {
+      throw new Error("Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM");
+    }
+    const enumEntry = schema.enums?.[enumType];
+    if (!enumEntry) {
+      throw new Error(`Incorrect data in the EXT_structural_metadata extension: schema.enums does't contain ${enumType}`);
+    }
+    const enumValueType = enumEntry.valueType || "UINT16";
+    const elementSize = getArrayElementByteSize(classProperty.type, enumValueType);
+    const elementCount = valuesDataBytes.byteLength / elementSize;
+    const valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
+    if (isArray2) {
+      if (arrayOffsets) {
+        return handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize, enumEntry);
+      }
+      if (arrayCount) {
+        return handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
+      }
+      return [];
+    }
+    for (let index = 0; index < numberOfElements; index++) {
+      const enumValue = valuesData[index];
+      const enumObject = getEnumByValue(enumEntry, enumValue);
+      if (enumObject) {
+        data.push(enumObject.name);
+      }
+    }
+    return data;
+  }
+  function handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+      const array = [];
+      const arrayOffset = arrayOffsets[index];
+      const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
+      if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
+        const typedArrayOffset = arrayOffset / elementSize;
+        const elementCount = arrayByteSize / elementSize;
+        for (let i2 = 0; i2 < elementCount; i2++) {
+          const value = valuesData[typedArrayOffset + i2];
+          const enumObject = getEnumByValue(enumEntry, value);
+          if (enumObject) {
+            array.push(enumObject.name);
+          }
+        }
+      }
+      attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+  }
+  function handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+      const array = [];
+      for (let i2 = 0; i2 < arrayCount; i2++) {
+        const value = valuesData[i2];
+        const enumObject = getEnumByValue(enumEntry, value);
+        if (enumObject) {
+          array.push(enumObject.name);
+        }
+      }
+      attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+  }
+  function findPropertyTableByClass(propertyTables, schemaClassName) {
+    for (let i2 = 0, len2 = propertyTables.length; i2 < len2; i2++) {
+      const propertyTable = propertyTables[i2];
+      if (propertyTable.class === schemaClassName) {
+        return propertyTable;
+      }
+    }
+    return null;
+  }
+  function getEnumByValue(enumEntry, value) {
+    for (const enumValue of enumEntry.values) {
+      if (enumValue.value === value) {
+        return enumValue;
+      }
+    }
+    return null;
+  }
+  var EXT_STRUCTURAL_METADATA_NAME, name;
+  var init_EXT_structural_metadata = __esm({
+    "../gltf/src/lib/extensions/EXT_structural_metadata.ts"() {
+      init_gltf_scenegraph();
+      init_data_processing();
+      EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
+      name = EXT_STRUCTURAL_METADATA_NAME;
+    }
+  });
+
+  // ../gltf/src/lib/extensions/EXT_mesh_features.ts
+  var EXT_mesh_features_exports = {};
+  __export(EXT_mesh_features_exports, {
+    decode: () => decode2,
+    name: () => name2
+  });
+  async function decode2(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtMeshFeatures(scenegraph, options);
+  }
+  function decodeExtMeshFeatures(scenegraph, options) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
+      return;
+    }
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processMeshPrimitiveFeatures(scenegraph, primitive, options);
+      }
+    }
+  }
+  function processMeshPrimitiveFeatures(scenegraph, primitive, options) {
+    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
+    const featureIds = extension?.featureIds;
+    if (!featureIds)
+      return;
+    if (!extension.dataAttributeNames) {
+      extension.dataAttributeNames = [];
+    }
+    let featureIdCount = 0;
+    for (const featureId of featureIds) {
+      let propertyTable = null;
+      if (typeof featureId.propertyTable === "number") {
+        propertyTable = getPropertyTablePopulated(scenegraph, featureId.propertyTable);
+      }
+      let propertyData = null;
+      if (typeof featureId.attribute !== "undefined") {
+        const accessorKey = `_FEATURE_ID_${featureId.attribute}`;
+        const accessorIndex = primitive.attributes[accessorKey];
+        const propertyDataTypedArray = scenegraph.getTypedArrayForAccessor(accessorIndex);
+        propertyData = Array.prototype.slice.call(propertyDataTypedArray);
+      } else if (typeof featureId.texture !== "undefined" && options?.gltf?.loadImages) {
+        propertyData = getPrimitiveTextureData(scenegraph, featureId.texture, primitive);
+      } else {
+      }
+      const attributeName = featureId.label || propertyTable?.name || `featureAttribute${featureIdCount}`;
+      const featureTable = [];
+      if (propertyData) {
+        primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive);
+      }
+      extension.dataAttributeNames.push(attributeName);
+      featureId.data = featureTable;
+      featureIdCount++;
+    }
+  }
+  var EXT_MESH_FEATURES_NAME, name2;
+  var init_EXT_mesh_features = __esm({
+    "../gltf/src/lib/extensions/EXT_mesh_features.ts"() {
+      init_gltf_scenegraph();
+      init_data_processing();
+      init_EXT_structural_metadata();
+      EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
+      name2 = EXT_MESH_FEATURES_NAME;
+    }
+  });
+
+  // ../gltf/src/lib/extensions/deprecated/EXT_feature_metadata.ts
+  var EXT_feature_metadata_exports = {};
+  __export(EXT_feature_metadata_exports, {
+    decode: () => decode3,
+    name: () => name3
+  });
+  async function decode3(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtFeatureMetadata(scenegraph, options);
+  }
+  function decodeExtFeatureMetadata(scenegraph, options) {
+    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
+    if (!extension)
+      return;
+    const schemaClasses = extension.schema?.classes;
+    const { featureTables } = extension;
+    if (schemaClasses && featureTables) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTable = findFeatureTableByName(featureTables, schemaName);
+        if (featureTable) {
+          handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+        }
+      }
+    }
+    const { featureTextures } = extension;
+    if (schemaClasses && featureTextures && options.gltf?.loadImages) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
+        if (featureTexture) {
+          handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
+        }
+      }
+    }
+  }
+  function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
+    for (const propertyName in schemaClass.properties) {
+      const schemaProperty = schemaClass.properties[propertyName];
+      const featureTableProperty = featureTable?.properties?.[propertyName];
+      const numberOfFeatures = featureTable.count;
+      if (featureTableProperty) {
+        const data = getPropertyDataFromBinarySource2(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
+        featureTableProperty.data = data;
+      }
+    }
+  }
+  function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass) {
+    const attributeName = featureTexture.class;
+    for (const propertyName in schemaClass.properties) {
+      const featureTextureProperty = featureTexture?.properties?.[propertyName];
+      if (featureTextureProperty) {
+        const data = getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName);
+        featureTextureProperty.data = data;
+      }
+    }
+  }
+  function getPropertyDataFromBinarySource2(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
+    const bufferView = featureTableProperty.bufferView;
+    const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
+    switch (schemaProperty.type) {
+      case "STRING": {
+        const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
+        const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+        return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+      }
+      default:
+    }
+    return dataArray;
+  }
+  function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
+      return [];
+    }
+    const featureTextureTable = [];
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
+      }
+    }
+    return featureTextureTable;
+  }
+  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
+    const json = scenegraph.gltf.json;
+    const textureData = [];
+    const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
+    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
+    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+    const textureIndex = featureTextureProperty.texture.index;
+    const texture = json.textures?.[textureIndex];
+    const imageIndex = texture?.source;
+    if (typeof imageIndex !== "undefined") {
+      const image = json.images?.[imageIndex];
+      const mimeType = image?.mimeType;
+      const parsedImage = scenegraph.gltf.images?.[imageIndex];
+      if (parsedImage) {
+        for (let index = 0; index < textureCoordinates.length; index += 2) {
+          const value = getImageValueByCoordinates2(parsedImage, mimeType, textureCoordinates, index, featureTextureProperty.channels);
+          textureData.push(value);
+        }
+      }
+    }
+    const featureIndices = [];
+    for (const texelData of textureData) {
+      let index = featureTextureTable.findIndex((item) => item === texelData);
+      if (index === -1) {
+        index = featureTextureTable.push(texelData) - 1;
+      }
+      featureIndices.push(index);
+    }
+    const typedArray = new Uint32Array(featureIndices);
+    const bufferIndex = scenegraph.gltf.buffers.push({
+      arrayBuffer: typedArray.buffer,
+      byteOffset: 0,
+      byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+      size: 1,
+      componentType: getComponentTypeFromArray(typedArray),
+      count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+  }
+  function getImageValueByCoordinates2(parsedImage, mimeType, textureCoordinates, index, channels) {
+    const CHANNELS_MAP = {
+      r: { offset: 0, shift: 0 },
+      g: { offset: 1, shift: 8 },
+      b: { offset: 2, shift: 16 },
+      a: { offset: 3, shift: 24 }
+    };
+    const u = textureCoordinates[index];
+    const v = textureCoordinates[index + 1];
+    let components = 1;
+    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
+      components = 4;
+    const offset = coordinatesToOffset2(u, v, parsedImage, components);
+    let value = 0;
+    for (const c of channels) {
+      const map2 = CHANNELS_MAP[c];
+      const val = getVal(parsedImage, offset + map2.offset);
+      value |= val << map2.shift;
+    }
+    return value;
+  }
+  function getVal(parsedImage, offset) {
+    const imageData = getImageData(parsedImage);
+    if (imageData.data.length <= offset) {
+      throw new Error(`${imageData.data.length} <= ${offset}`);
+    }
+    return imageData.data[offset];
+  }
+  function coordinatesToOffset2(u, v, parsedImage, componentsCount = 1) {
+    const w = parsedImage.width;
+    const iX = emod(u) * (w - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = emod(v) * (h - 1);
+    const indY = Math.round(iY);
+    const components = parsedImage.components ? parsedImage.components : componentsCount;
+    const offset = (indY * w + indX) * components;
+    return offset;
+  }
+  function findFeatureTableByName(featureTables, schemaClassName) {
+    for (const featureTableName in featureTables) {
+      const featureTable = featureTables[featureTableName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
+    }
+    return null;
+  }
+  function findFeatureTextureByName(featureTextures, schemaClassName) {
+    for (const featureTexturesName in featureTextures) {
+      const featureTable = featureTextures[featureTexturesName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
+    }
+    return null;
+  }
+  function getStringAttributes(data, offsetsData, stringsCount) {
+    const stringsArray = [];
+    const textDecoder = new TextDecoder("utf8");
+    let stringOffset = 0;
+    const bytesPerStringSize = 4;
+    for (let index = 0; index < stringsCount; index++) {
+      const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+      const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+      const stringAttribute = textDecoder.decode(stringData);
+      stringsArray.push(stringAttribute);
+      stringOffset += stringByteSize;
+    }
+    return stringsArray;
+  }
+  var EXT_FEATURE_METADATA_NAME, name3;
+  var init_EXT_feature_metadata = __esm({
+    "../gltf/src/lib/extensions/deprecated/EXT_feature_metadata.ts"() {
+      init_gltf_scenegraph();
+      init_src8();
+      init_gltf_utils();
+      init_src7();
+      EXT_FEATURE_METADATA_NAME = "EXT_feature_metadata";
+      name3 = EXT_FEATURE_METADATA_NAME;
+    }
+  });
+
+  // ../gltf/src/lib/utils/version.ts
+  var VERSION7;
+  var init_version5 = __esm({
+    "../gltf/src/lib/utils/version.ts"() {
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    }
+  });
+
+  // ../textures/src/lib/utils/version.ts
+  var VERSION8;
+  var init_version6 = __esm({
+    "../textures/src/lib/utils/version.ts"() {
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+    }
+  });
+
+  // ../textures/src/lib/parsers/basis-module-loader.ts
+  async function loadBasisTranscoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basis) {
+      return modules.basis;
+    }
+    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTranscoder(options);
+    return await loadBasisTranscoderPromise;
+  }
+  async function loadBasisTranscoder(options) {
+    let BASIS = null;
+    let wasmBinary = null;
+    [BASIS, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
+    ]);
+    BASIS = BASIS || globalThis.BASIS;
+    return await initializeBasisTranscoderModule(BASIS, wasmBinary);
+  }
+  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve2) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
+        initializeBasis();
+        resolve2({ BasisFile });
+      });
+    });
+  }
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
+    }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
+  }
+  async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
+    ]);
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+  }
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve2) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve2({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
+  }
+  var BASIS_EXTERNAL_LIBRARIES, loadBasisTranscoderPromise, loadBasisEncoderPromise;
+  var init_basis_module_loader = __esm({
+    "../textures/src/lib/parsers/basis-module-loader.ts"() {
+      init_src();
+      BASIS_EXTERNAL_LIBRARIES = {
+        TRANSCODER: "basis_transcoder.js",
+        TRANSCODER_WASM: "basis_transcoder.wasm",
+        ENCODER: "basis_encoder.js",
+        ENCODER_WASM: "basis_encoder.wasm"
+      };
+    }
+  });
+
+  // ../textures/src/lib/gl-extensions.ts
+  var GL_EXTENSIONS_CONSTANTS;
+  var init_gl_extensions = __esm({
+    "../textures/src/lib/gl-extensions.ts"() {
+      GL_EXTENSIONS_CONSTANTS = {
+        COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
+        COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
+        COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
+        COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
+        COMPRESSED_R11_EAC: 37488,
+        COMPRESSED_SIGNED_R11_EAC: 37489,
+        COMPRESSED_RG11_EAC: 37490,
+        COMPRESSED_SIGNED_RG11_EAC: 37491,
+        COMPRESSED_RGB8_ETC2: 37492,
+        COMPRESSED_RGBA8_ETC2_EAC: 37493,
+        COMPRESSED_SRGB8_ETC2: 37494,
+        COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
+        COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
+        COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
+        COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
+        COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
+        COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
+        COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
+        COMPRESSED_RGB_ETC1_WEBGL: 36196,
+        COMPRESSED_RGB_ATC_WEBGL: 35986,
+        COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
+        COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
+        COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
+        COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
+        COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
+        COMPRESSED_RGBA_ASTC_6X5_KHR: 37811,
+        COMPRESSED_RGBA_ASTC_6X6_KHR: 37812,
+        COMPRESSED_RGBA_ASTC_8X5_KHR: 37813,
+        COMPRESSED_RGBA_ASTC_8X6_KHR: 37814,
+        COMPRESSED_RGBA_ASTC_8X8_KHR: 37815,
+        COMPRESSED_RGBA_ASTC_10X5_KHR: 37816,
+        COMPRESSED_RGBA_ASTC_10X6_KHR: 37817,
+        COMPRESSED_RGBA_ASTC_10X8_KHR: 37818,
+        COMPRESSED_RGBA_ASTC_10X10_KHR: 37819,
+        COMPRESSED_RGBA_ASTC_12X10_KHR: 37820,
+        COMPRESSED_RGBA_ASTC_12X12_KHR: 37821,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 37840,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: 37841,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: 37842,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: 37843,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: 37844,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: 37845,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: 37846,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: 37847,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: 37848,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: 37849,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: 37850,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
+        COMPRESSED_RED_RGTC1_EXT: 36283,
+        COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
+        COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
+        COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
+        COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
+        COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
+        COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
+        COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
+      };
+    }
+  });
+
+  // ../textures/src/lib/utils/texture-formats.ts
+  function getSupportedGPUTextureFormats(gl) {
+    if (!formats) {
+      gl = gl || getWebGLContext() || void 0;
+      formats = new Set();
+      for (const prefix of BROWSER_PREFIXES) {
+        for (const extension in WEBGL_EXTENSIONS) {
+          if (gl && gl.getExtension(`${prefix}${extension}`)) {
+            const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
+            formats.add(gpuTextureFormat);
+          }
+        }
+      }
+    }
+    return formats;
+  }
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
+    }
+  }
+  var BROWSER_PREFIXES, WEBGL_EXTENSIONS, formats;
+  var init_texture_formats = __esm({
+    "../textures/src/lib/utils/texture-formats.ts"() {
+      BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
+      WEBGL_EXTENSIONS = {
+        WEBGL_compressed_texture_s3tc: "dxt",
+        WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
+        WEBGL_compressed_texture_etc1: "etc1",
+        WEBGL_compressed_texture_etc: "etc2",
+        WEBGL_compressed_texture_pvrtc: "pvrtc",
+        WEBGL_compressed_texture_atc: "atc",
+        WEBGL_compressed_texture_astc: "astc",
+        EXT_texture_compression_rgtc: "rgtc"
+      };
+      formats = null;
+    }
+  });
+
+  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
+  var t, n, i, s, a, r, o, l, f;
+  var init_ktx_parse_modern = __esm({
+    "../../node_modules/ktx-parse/dist/ktx-parse.modern.js"() {
+      t = new Uint8Array([0]);
+      !function(t2) {
+        t2[t2.NONE = 0] = "NONE", t2[t2.BASISLZ = 1] = "BASISLZ", t2[t2.ZSTD = 2] = "ZSTD", t2[t2.ZLIB = 3] = "ZLIB";
+      }(n || (n = {})), function(t2) {
+        t2[t2.BASICFORMAT = 0] = "BASICFORMAT";
+      }(i || (i = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.ETC1S = 163] = "ETC1S", t2[t2.UASTC = 166] = "UASTC";
+      }(s || (s = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.SRGB = 1] = "SRGB";
+      }(a || (a = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.LINEAR = 1] = "LINEAR", t2[t2.SRGB = 2] = "SRGB", t2[t2.ITU = 3] = "ITU", t2[t2.NTSC = 4] = "NTSC", t2[t2.SLOG = 5] = "SLOG", t2[t2.SLOG2 = 6] = "SLOG2";
+      }(r || (r = {})), function(t2) {
+        t2[t2.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t2[t2.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
+      }(o || (o = {})), function(t2) {
+        t2[t2.RGB = 0] = "RGB", t2[t2.RRR = 3] = "RRR", t2[t2.GGG = 4] = "GGG", t2[t2.AAA = 15] = "AAA";
+      }(l || (l = {})), function(t2) {
+        t2[t2.RGB = 0] = "RGB", t2[t2.RGBA = 3] = "RGBA", t2[t2.RRR = 4] = "RRR", t2[t2.RRRG = 5] = "RRRG";
+      }(f || (f = {}));
+    }
+  });
+
+  // ../textures/src/lib/parsers/parse-ktx.ts
+  function isKTX(data) {
+    const id = new Uint8Array(data);
+    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
+    return !notKTX;
+  }
+  var KTX2_ID;
+  var init_parse_ktx = __esm({
+    "../textures/src/lib/parsers/parse-ktx.ts"() {
+      init_ktx_parse_modern();
+      KTX2_ID = [
+        171,
+        75,
+        84,
+        88,
+        32,
+        50,
+        48,
+        187,
+        13,
+        10,
+        26,
+        10
+      ];
+    }
+  });
+
+  // ../textures/src/lib/parsers/parse-basis.ts
+  async function parseBasis(data, options) {
+    if (options.basis.containerFormat === "auto") {
+      if (isKTX(data)) {
+        const fileConstructors = await loadBasisEncoderModule(options);
+        return parseKTX2File(fileConstructors.KTX2File, data, options);
+      }
+      const { BasisFile } = await loadBasisTranscoderModule(options);
+      return parseBasisFile(BasisFile, data, options);
+    }
+    switch (options.basis.module) {
+      case "encoder":
+        const fileConstructors = await loadBasisEncoderModule(options);
+        switch (options.basis.containerFormat) {
+          case "ktx2":
+            return parseKTX2File(fileConstructors.KTX2File, data, options);
+          case "basis":
+          default:
+            return parseBasisFile(fileConstructors.BasisFile, data, options);
         }
-        _addIndices(indices) {
-          return this.addBinaryBuffer(indices, { size: 1 });
+      case "transcoder":
+      default:
+        const { BasisFile } = await loadBasisTranscoderModule(options);
+        return parseBasisFile(BasisFile, data, options);
+    }
+  }
+  function parseBasisFile(BasisFile, data, options) {
+    const basisFile = new BasisFile(new Uint8Array(data));
+    try {
+      if (!basisFile.startTranscoding()) {
+        throw new Error("Failed to start basis transcoding");
+      }
+      const imageCount = basisFile.getNumImages();
+      const images = [];
+      for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
+        const levelsCount = basisFile.getNumLevels(imageIndex);
+        const levels = [];
+        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+          levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
         }
-        _getGltfAttributeName(attributeName) {
-          switch (attributeName.toLowerCase()) {
-            case "position":
-            case "positions":
-            case "vertices":
-              return "POSITION";
-            case "normal":
-            case "normals":
-              return "NORMAL";
-            case "color":
-            case "colors":
-              return "COLOR_0";
-            case "texcoord":
-            case "texcoords":
-              return "TEXCOORD_0";
-            default:
-              return attributeName;
+        images.push(levels);
+      }
+      return images;
+    } finally {
+      basisFile.close();
+      basisFile.delete();
+    }
+  }
+  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
+    const width = basisFile.getImageWidth(imageIndex, levelIndex);
+    const height = basisFile.getImageHeight(imageIndex, levelIndex);
+    const hasAlpha = basisFile.getHasAlpha();
+    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
+    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
+      throw new Error("failed to start Basis transcoding");
+    }
+    return {
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      format,
+      hasAlpha
+    };
+  }
+  function parseKTX2File(KTX2File, data, options) {
+    const ktx2File = new KTX2File(new Uint8Array(data));
+    try {
+      if (!ktx2File.startTranscoding()) {
+        throw new Error("failed to start KTX2 transcoding");
+      }
+      const levelsCount = ktx2File.getLevels();
+      const levels = [];
+      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
+        break;
+      }
+      return [levels];
+    } finally {
+      ktx2File.close();
+      ktx2File.delete();
+    }
+  }
+  function transcodeKTX2Image(ktx2File, levelIndex, options) {
+    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
+    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
+    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
+      throw new Error("Failed to transcode KTX2 image");
+    }
+    return {
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      levelSize: decodedSize,
+      hasAlpha: alphaFlag,
+      format
+    };
+  }
+  function getBasisOptions(options, hasAlpha) {
+    let format = options && options.basis && options.basis.format;
+    if (format === "auto") {
+      format = selectSupportedBasisFormat();
+    }
+    if (typeof format === "object") {
+      format = hasAlpha ? format.alpha : format.noAlpha;
+    }
+    format = format.toLowerCase();
+    return OutputFormat[format];
+  }
+  function selectSupportedBasisFormat() {
+    const supportedFormats = getSupportedGPUTextureFormats();
+    if (supportedFormats.has("astc")) {
+      return "astc-4x4";
+    } else if (supportedFormats.has("dxt")) {
+      return {
+        alpha: "bc3",
+        noAlpha: "bc1"
+      };
+    } else if (supportedFormats.has("pvrtc")) {
+      return {
+        alpha: "pvrtc1-4-rgba",
+        noAlpha: "pvrtc1-4-rgb"
+      };
+    } else if (supportedFormats.has("etc1")) {
+      return "etc1";
+    } else if (supportedFormats.has("etc2")) {
+      return "etc2";
+    }
+    return "rgb565";
+  }
+  var OutputFormat;
+  var init_parse_basis = __esm({
+    "../textures/src/lib/parsers/parse-basis.ts"() {
+      init_basis_module_loader();
+      init_gl_extensions();
+      init_texture_formats();
+      init_parse_ktx();
+      OutputFormat = {
+        etc1: {
+          basisFormat: 0,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+        },
+        etc2: { basisFormat: 1, compressed: true },
+        bc1: {
+          basisFormat: 2,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+        },
+        bc3: {
+          basisFormat: 3,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+        },
+        bc4: { basisFormat: 4, compressed: true },
+        bc5: { basisFormat: 5, compressed: true },
+        "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
+        "bc7-m5": { basisFormat: 7, compressed: true },
+        "pvrtc1-4-rgb": {
+          basisFormat: 8,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+        },
+        "pvrtc1-4-rgba": {
+          basisFormat: 9,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+        },
+        "astc-4x4": {
+          basisFormat: 10,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+        },
+        "atc-rgb": { basisFormat: 11, compressed: true },
+        "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
+        rgba32: { basisFormat: 13, compressed: false },
+        rgb565: { basisFormat: 14, compressed: false },
+        bgr565: { basisFormat: 15, compressed: false },
+        rgba4444: { basisFormat: 16, compressed: false }
+      };
+    }
+  });
+
+  // ../textures/src/basis-loader.ts
+  var BasisWorkerLoader, BasisLoader;
+  var init_basis_loader = __esm({
+    "../textures/src/basis-loader.ts"() {
+      init_version6();
+      init_parse_basis();
+      BasisWorkerLoader = {
+        name: "Basis",
+        id: "basis",
+        module: "textures",
+        version: VERSION8,
+        worker: true,
+        extensions: ["basis", "ktx2"],
+        mimeTypes: ["application/octet-stream", "image/ktx2"],
+        tests: ["sB"],
+        binary: true,
+        options: {
+          basis: {
+            format: "auto",
+            libraryPath: "libs/",
+            containerFormat: "auto",
+            module: "transcoder"
           }
         }
-        _getAccessorMinMax(buffer, size) {
-          const result = { min: null, max: null };
-          if (buffer.length < size) {
-            return result;
-          }
-          result.min = [];
-          result.max = [];
-          const initValues = buffer.subarray(0, size);
-          for (const value of initValues) {
-            result.min.push(value);
-            result.max.push(value);
+      };
+      BasisLoader = {
+        ...BasisWorkerLoader,
+        parse: parseBasis
+      };
+    }
+  });
+
+  // ../textures/src/index.ts
+  var init_src9 = __esm({
+    "../textures/src/index.ts"() {
+      init_basis_loader();
+      init_parse_basis();
+    }
+  });
+
+  // ../gltf/src/lib/parsers/parse-glb.ts
+  function getMagicString4(dataView, byteOffset = 0) {
+    return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
+  }
+  function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
+    const dataView = new DataView(arrayBuffer);
+    const { magic = MAGIC_glTF } = options;
+    const magic1 = dataView.getUint32(byteOffset, false);
+    return magic1 === magic || magic1 === MAGIC_glTF;
+  }
+  function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
+    const dataView = new DataView(arrayBuffer);
+    const type = getMagicString4(dataView, byteOffset + 0);
+    const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+    const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
+    Object.assign(glb, {
+      header: {
+        byteOffset,
+        byteLength,
+        hasBinChunk: false
+      },
+      type,
+      version,
+      json: {},
+      binChunks: []
+    });
+    byteOffset += GLB_FILE_HEADER_SIZE;
+    switch (glb.version) {
+      case 1:
+        return parseGLBV1(glb, dataView, byteOffset);
+      case 2:
+        return parseGLBV2(glb, dataView, byteOffset, options = {});
+      default:
+        throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);
+    }
+  }
+  function parseGLBV1(glb, dataView, byteOffset) {
+    assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
+    const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+    byteOffset += GLB_CHUNK_HEADER_SIZE;
+    assert2(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
+    parseJSONChunk(glb, dataView, byteOffset, contentLength);
+    byteOffset += contentLength;
+    byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
+    return byteOffset;
+  }
+  function parseGLBV2(glb, dataView, byteOffset, options) {
+    assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    parseGLBChunksSync(glb, dataView, byteOffset, options);
+    return byteOffset + glb.header.byteLength;
+  }
+  function parseGLBChunksSync(glb, dataView, byteOffset, options) {
+    while (byteOffset + 8 <= glb.header.byteLength) {
+      const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
+      const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+      byteOffset += GLB_CHUNK_HEADER_SIZE;
+      switch (chunkFormat) {
+        case GLB_CHUNK_TYPE_JSON:
+          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+          break;
+        case GLB_CHUNK_TYPE_BIN:
+          parseBINChunk(glb, dataView, byteOffset, chunkLength);
+          break;
+        case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
+          if (!options.strict) {
+            parseJSONChunk(glb, dataView, byteOffset, chunkLength);
           }
-          for (let index = size; index < buffer.length; index += size) {
-            for (let componentIndex = 0; componentIndex < size; componentIndex++) {
-              result.min[0 + componentIndex] = Math.min(result.min[0 + componentIndex], buffer[index + componentIndex]);
-              result.max[0 + componentIndex] = Math.max(result.max[0 + componentIndex], buffer[index + componentIndex]);
-            }
+          break;
+        case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
+          if (!options.strict) {
+            parseBINChunk(glb, dataView, byteOffset, chunkLength);
           }
-          return result;
-        }
-      };
+          break;
+        default:
+          break;
+      }
+      byteOffset += padToNBytes(chunkLength, 4);
+    }
+    return byteOffset;
+  }
+  function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
+    const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
+    const textDecoder = new TextDecoder("utf8");
+    const jsonText = textDecoder.decode(jsonChunk);
+    glb.json = JSON.parse(jsonText);
+    return padToNBytes(chunkLength, 4);
+  }
+  function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
+    glb.header.hasBinChunk = true;
+    glb.binChunks.push({
+      byteOffset,
+      byteLength: chunkLength,
+      arrayBuffer: dataView.buffer
+    });
+    return padToNBytes(chunkLength, 4);
+  }
+  var LITTLE_ENDIAN2, MAGIC_glTF, GLB_FILE_HEADER_SIZE, GLB_CHUNK_HEADER_SIZE, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLB_V1_CONTENT_FORMAT_JSON, GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED, GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED;
+  var init_parse_glb = __esm({
+    "../gltf/src/lib/parsers/parse-glb.ts"() {
+      init_src2();
+      LITTLE_ENDIAN2 = true;
+      MAGIC_glTF = 1735152710;
+      GLB_FILE_HEADER_SIZE = 12;
+      GLB_CHUNK_HEADER_SIZE = 8;
+      GLB_CHUNK_TYPE_JSON = 1313821514;
+      GLB_CHUNK_TYPE_BIN = 5130562;
+      GLB_V1_CONTENT_FORMAT_JSON = 0;
+      GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+      GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
+    }
+  });
+
+  // ../gltf/src/lib/gltf-utils/resolve-url.ts
+  function resolveUrl(url, options) {
+    const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
+    if (absolute) {
+      return url;
+    }
+    const baseUrl = options.baseUri || options.uri;
+    if (!baseUrl) {
+      throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+    }
+    return baseUrl.substr(0, baseUrl.lastIndexOf("/") + 1) + url;
+  }
+  var init_resolve_url = __esm({
+    "../gltf/src/lib/gltf-utils/resolve-url.ts"() {
+    }
+  });
+
+  // ../gltf/src/lib/gltf-utils/get-typed-array.ts
+  function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
+    const bufferView = json.bufferViews[bufferViewIndex];
+    assert7(bufferView);
+    const bufferIndex = bufferView.buffer;
+    const binChunk = buffers[bufferIndex];
+    assert7(binChunk);
+    const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+    return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+  }
+  var init_get_typed_array = __esm({
+    "../gltf/src/lib/gltf-utils/get-typed-array.ts"() {
+      init_assert6();
     }
   });
 
   // ../gltf/src/meshopt/meshopt-decoder.ts
   async function meshoptDecodeGltfBuffer(target, count, size, source, mode, filter = "NONE") {
     const instance = await loadWasmInstance();
-    decode(instance, instance.exports[DECODERS[mode]], target, count, size, source, instance.exports[FILTERS[filter || "NONE"]]);
+    decode4(instance, instance.exports[DECODERS[mode]], target, count, size, source, instance.exports[FILTERS[filter || "NONE"]]);
   }
   async function loadWasmInstance() {
     if (!wasmPromise) {
@@ -10565,7 +11481,7 @@
     }
     return result.buffer.slice(0, write);
   }
-  function decode(instance, fun, target, count, size, source, filter) {
+  function decode4(instance, fun, target, count, size, source, filter) {
     const sbrk = instance.exports.sbrk;
     const count4 = count + 3 & ~3;
     const tp = sbrk(count4 * size);
@@ -10726,10 +11642,10 @@
   // ../gltf/src/lib/extensions/EXT_meshopt_compression.ts
   var EXT_meshopt_compression_exports = {};
   __export(EXT_meshopt_compression_exports, {
-    decode: () => decode2,
-    name: () => name
+    decode: () => decode5,
+    name: () => name4
   });
-  async function decode2(gltfData, options) {
+  async function decode5(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     if (!options?.gltf?.decompressMeshes || !options.gltf?.loadBuffers) {
       return;
@@ -10760,20 +11676,20 @@
       scenegraph.removeObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
     }
   }
-  var EXT_MESHOPT_COMPRESSION, name;
+  var EXT_MESHOPT_COMPRESSION, name4;
   var init_EXT_meshopt_compression = __esm({
     "../gltf/src/lib/extensions/EXT_meshopt_compression.ts"() {
       init_gltf_scenegraph();
       init_meshopt_decoder();
       EXT_MESHOPT_COMPRESSION = "EXT_meshopt_compression";
-      name = EXT_MESHOPT_COMPRESSION;
+      name4 = EXT_MESHOPT_COMPRESSION;
     }
   });
 
   // ../gltf/src/lib/extensions/EXT_texture_webp.ts
   var EXT_texture_webp_exports = {};
   __export(EXT_texture_webp_exports, {
-    name: () => name2,
+    name: () => name5,
     preprocess: () => preprocess
   });
   function preprocess(gltfData, options) {
@@ -10794,20 +11710,20 @@
     }
     scenegraph.removeExtension(EXT_TEXTURE_WEBP);
   }
-  var EXT_TEXTURE_WEBP, name2;
+  var EXT_TEXTURE_WEBP, name5;
   var init_EXT_texture_webp = __esm({
     "../gltf/src/lib/extensions/EXT_texture_webp.ts"() {
       init_src8();
       init_gltf_scenegraph();
       EXT_TEXTURE_WEBP = "EXT_texture_webp";
-      name2 = EXT_TEXTURE_WEBP;
+      name5 = EXT_TEXTURE_WEBP;
     }
   });
 
   // ../gltf/src/lib/extensions/KHR_texture_basisu.ts
   var KHR_texture_basisu_exports = {};
   __export(KHR_texture_basisu_exports, {
-    name: () => name3,
+    name: () => name6,
     preprocess: () => preprocess2
   });
   function preprocess2(gltfData, options) {
@@ -10822,23 +11738,23 @@
     }
     scene.removeExtension(KHR_TEXTURE_BASISU);
   }
-  var KHR_TEXTURE_BASISU, name3;
+  var KHR_TEXTURE_BASISU, name6;
   var init_KHR_texture_basisu = __esm({
     "../gltf/src/lib/extensions/KHR_texture_basisu.ts"() {
       init_gltf_scenegraph();
       KHR_TEXTURE_BASISU = "KHR_texture_basisu";
-      name3 = KHR_TEXTURE_BASISU;
+      name6 = KHR_TEXTURE_BASISU;
     }
   });
 
   // ../gltf/src/lib/gltf-utils/gltf-attribute-utils.ts
   function getGLTFAccessors(attributes) {
     const accessors = {};
-    for (const name10 in attributes) {
-      const attribute = attributes[name10];
-      if (name10 !== "indices") {
+    for (const name12 in attributes) {
+      const attribute = attributes[name12];
+      if (name12 !== "indices") {
         const glTFAccessor = getGLTFAccessor(attribute);
-        accessors[name10] = glTFAccessor;
+        accessors[name12] = glTFAccessor;
       }
     }
     return accessors;
@@ -10892,9 +11808,9 @@
   // ../gltf/src/lib/extensions/KHR_draco_mesh_compression.ts
   var KHR_draco_mesh_compression_exports = {};
   __export(KHR_draco_mesh_compression_exports, {
-    decode: () => decode3,
+    decode: () => decode6,
     encode: () => encode,
-    name: () => name4,
+    name: () => name7,
     preprocess: () => preprocess3
   });
   function preprocess3(gltfData, options, context) {
@@ -10904,7 +11820,7 @@
       }
     }
   }
-  async function decode3(gltfData, options, context) {
+  async function decode6(gltfData, options, context) {
     if (!options?.gltf?.decompressMeshes) {
       return;
     }
@@ -10932,10 +11848,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) {
@@ -10990,15 +11905,15 @@
       }
     }
   }
-  var KHR_DRACO_MESH_COMPRESSION, name4;
+  var KHR_DRACO_MESH_COMPRESSION, name7;
   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";
-      name4 = KHR_DRACO_MESH_COMPRESSION;
+      name7 = KHR_DRACO_MESH_COMPRESSION;
     }
   });
 
@@ -11029,10 +11944,10 @@
   // ../gltf/src/lib/extensions/KHR_texture_transform.ts
   var KHR_texture_transform_exports = {};
   __export(KHR_texture_transform_exports, {
-    decode: () => decode4,
-    name: () => name5
+    decode: () => decode7,
+    name: () => name8
   });
-  async function decode4(gltfData, options) {
+  async function decode7(gltfData, options) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const hasExtension = gltfScenegraph.hasExtension(EXT_MESHOPT_TRANSFORM);
     if (!hasExtension || !options.gltf?.loadBuffers) {
@@ -11174,7 +12089,7 @@
     const scaleMatrix = scratchScaleMatrix.set(scale5[0], 0, 0, 0, scale5[1], 0, 0, 0, 1);
     return translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix);
   }
-  var EXT_MESHOPT_TRANSFORM, name5, scratchVector7, scratchRotationMatrix, scratchScaleMatrix;
+  var EXT_MESHOPT_TRANSFORM, name8, scratchVector7, scratchRotationMatrix, scratchScaleMatrix;
   var init_KHR_texture_transform = __esm({
     "../gltf/src/lib/extensions/KHR_texture_transform.ts"() {
       init_esm();
@@ -11182,7 +12097,7 @@
       init_gltf_constants();
       init_gltf_scenegraph();
       EXT_MESHOPT_TRANSFORM = "KHR_texture_transform";
-      name5 = EXT_MESHOPT_TRANSFORM;
+      name8 = EXT_MESHOPT_TRANSFORM;
       scratchVector7 = new Vector3();
       scratchRotationMatrix = new Matrix3();
       scratchScaleMatrix = new Matrix3();
@@ -11192,11 +12107,11 @@
   // ../gltf/src/lib/extensions/deprecated/KHR_lights_punctual.ts
   var KHR_lights_punctual_exports = {};
   __export(KHR_lights_punctual_exports, {
-    decode: () => decode5,
+    decode: () => decode8,
     encode: () => encode2,
-    name: () => name6
+    name: () => name9
   });
-  async function decode5(gltfData) {
+  async function decode8(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);
@@ -11229,24 +12144,24 @@
       delete gltfScenegraph.json.lights;
     }
   }
-  var KHR_LIGHTS_PUNCTUAL, name6;
+  var KHR_LIGHTS_PUNCTUAL, name9;
   var init_KHR_lights_punctual = __esm({
     "../gltf/src/lib/extensions/deprecated/KHR_lights_punctual.ts"() {
       init_assert6();
       init_gltf_scenegraph();
       KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
-      name6 = KHR_LIGHTS_PUNCTUAL;
+      name9 = KHR_LIGHTS_PUNCTUAL;
     }
   });
 
   // ../gltf/src/lib/extensions/deprecated/KHR_materials_unlit.ts
   var KHR_materials_unlit_exports = {};
   __export(KHR_materials_unlit_exports, {
-    decode: () => decode6,
+    decode: () => decode9,
     encode: () => encode3,
-    name: () => name7
+    name: () => name10
   });
-  async function decode6(gltfData) {
+  async function decode9(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     for (const material of json.materials || []) {
@@ -11264,300 +12179,87 @@
     if (gltfScenegraph.materials) {
       for (const material of json.materials || []) {
         if (material.unlit) {
-          delete material.unlit;
-          gltfScenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
-          gltfScenegraph.addExtension(KHR_MATERIALS_UNLIT);
-        }
-      }
-    }
-  }
-  var KHR_MATERIALS_UNLIT, name7;
-  var init_KHR_materials_unlit = __esm({
-    "../gltf/src/lib/extensions/deprecated/KHR_materials_unlit.ts"() {
-      init_gltf_scenegraph();
-      KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
-      name7 = KHR_MATERIALS_UNLIT;
-    }
-  });
-
-  // ../gltf/src/lib/extensions/deprecated/KHR_techniques_webgl.ts
-  var KHR_techniques_webgl_exports = {};
-  __export(KHR_techniques_webgl_exports, {
-    decode: () => decode7,
-    encode: () => encode4,
-    name: () => name8
-  });
-  async function decode7(gltfData) {
-    const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const { json } = gltfScenegraph;
-    const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
-    if (extension) {
-      const techniques = resolveTechniques(extension, gltfScenegraph);
-      for (const material of json.materials || []) {
-        const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);
-        if (materialExtension) {
-          material.technique = Object.assign({}, materialExtension, techniques[materialExtension.technique]);
-          material.technique.values = resolveValues(material.technique, gltfScenegraph);
-        }
-        gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
-      }
-      gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
-    }
-  }
-  async function encode4(gltfData, options) {
-  }
-  function resolveTechniques(techniquesExtension, gltfScenegraph) {
-    const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
-    const textDecoder = new TextDecoder();
-    shaders.forEach((shader) => {
-      if (Number.isFinite(shader.bufferView)) {
-        shader.code = textDecoder.decode(gltfScenegraph.getTypedArrayForBufferView(shader.bufferView));
-      } else {
-        throw new Error("KHR_techniques_webgl: no shader code");
-      }
-    });
-    programs.forEach((program) => {
-      program.fragmentShader = shaders[program.fragmentShader];
-      program.vertexShader = shaders[program.vertexShader];
-    });
-    techniques.forEach((technique) => {
-      technique.program = programs[technique.program];
-    });
-    return techniques;
-  }
-  function resolveValues(technique, gltfScenegraph) {
-    const values = Object.assign({}, technique.values);
-    Object.keys(technique.uniforms || {}).forEach((uniform) => {
-      if (technique.uniforms[uniform].value && !(uniform in values)) {
-        values[uniform] = technique.uniforms[uniform].value;
-      }
-    });
-    Object.keys(values).forEach((uniform) => {
-      if (typeof values[uniform] === "object" && values[uniform].index !== void 0) {
-        values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);
-      }
-    });
-    return values;
-  }
-  var KHR_TECHNIQUES_WEBGL, name8;
-  var init_KHR_techniques_webgl = __esm({
-    "../gltf/src/lib/extensions/deprecated/KHR_techniques_webgl.ts"() {
-      init_gltf_scenegraph();
-      KHR_TECHNIQUES_WEBGL = "KHR_techniques_webgl";
-      name8 = KHR_TECHNIQUES_WEBGL;
-    }
-  });
-
-  // ../gltf/src/lib/extensions/deprecated/EXT_feature_metadata.ts
-  var EXT_feature_metadata_exports = {};
-  __export(EXT_feature_metadata_exports, {
-    decode: () => decode8,
-    name: () => name9
-  });
-  async function decode8(gltfData, options) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    decodeExtFeatureMetadata(scenegraph, options);
-  }
-  function decodeExtFeatureMetadata(scenegraph, options) {
-    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
-    if (!extension)
-      return;
-    const schemaClasses = extension.schema?.classes;
-    const { featureTables } = extension;
-    if (schemaClasses && featureTables) {
-      for (const schemaName in schemaClasses) {
-        const schemaClass = schemaClasses[schemaName];
-        const featureTable = findFeatureTableByName(featureTables, schemaName);
-        if (featureTable) {
-          handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
-        }
-      }
-    }
-    const { featureTextures } = extension;
-    if (schemaClasses && featureTextures && options.gltf?.loadImages) {
-      for (const schemaName in schemaClasses) {
-        const schemaClass = schemaClasses[schemaName];
-        const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
-        if (featureTexture) {
-          handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
-        }
-      }
-    }
-  }
-  function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
-    for (const propertyName in schemaClass.properties) {
-      const schemaProperty = schemaClass.properties[propertyName];
-      const featureTableProperty = featureTable?.properties?.[propertyName];
-      const numberOfFeatures = featureTable.count;
-      if (featureTableProperty) {
-        const data = getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
-        featureTableProperty.data = data;
-      }
-    }
-  }
-  function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass) {
-    const attributeName = featureTexture.class;
-    for (const propertyName in schemaClass.properties) {
-      const featureTextureProperty = featureTexture?.properties?.[propertyName];
-      if (featureTextureProperty) {
-        const data = getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName);
-        featureTextureProperty.data = data;
-      }
-    }
-  }
-  function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
-    const bufferView = featureTableProperty.bufferView;
-    const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
-    switch (schemaProperty.type) {
-      case "STRING": {
-        const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
-        const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-        return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
-      }
-      default:
-    }
-    return dataArray;
-  }
-  function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
-    const json = scenegraph.gltf.json;
-    if (!json.meshes) {
-      return [];
-    }
-    const featureTextureTable = [];
-    for (const mesh of json.meshes) {
-      for (const primitive of mesh.primitives) {
-        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
-      }
-    }
-    return featureTextureTable;
-  }
-  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
-    const json = scenegraph.gltf.json;
-    const textureData = [];
-    const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
-    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
-    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
-    const textureIndex = featureTextureProperty.texture.index;
-    const texture = json.textures?.[textureIndex];
-    const imageIndex = texture?.source;
-    if (typeof imageIndex !== "undefined") {
-      const image = json.images?.[imageIndex];
-      const mimeType = image?.mimeType;
-      const parsedImage = scenegraph.gltf.images?.[imageIndex];
-      if (parsedImage) {
-        for (let index = 0; index < textureCoordinates.length; index += 2) {
-          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, featureTextureProperty.channels);
-          textureData.push(value);
-        }
-      }
-    }
-    const featureIndices = [];
-    for (const texelData of textureData) {
-      let index = featureTextureTable.findIndex((item) => item === texelData);
-      if (index === -1) {
-        index = featureTextureTable.push(texelData) - 1;
-      }
-      featureIndices.push(index);
-    }
-    const typedArray = new Uint32Array(featureIndices);
-    const bufferIndex = scenegraph.gltf.buffers.push({
-      arrayBuffer: typedArray.buffer,
-      byteOffset: 0,
-      byteLength: typedArray.byteLength
-    }) - 1;
-    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
-    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
-      size: 1,
-      componentType: getComponentTypeFromArray(typedArray),
-      count: typedArray.length
-    });
-    primitive.attributes[attributeName] = accessorIndex;
-  }
-  function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels) {
-    const CHANNELS_MAP = {
-      r: { offset: 0, shift: 0 },
-      g: { offset: 1, shift: 8 },
-      b: { offset: 2, shift: 16 },
-      a: { offset: 3, shift: 24 }
-    };
-    const u = textureCoordinates[index];
-    const v = textureCoordinates[index + 1];
-    let components = 1;
-    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
-      components = 4;
-    const offset = coordinatesToOffset(u, v, parsedImage, components);
-    let value = 0;
-    for (const c of channels) {
-      const map2 = CHANNELS_MAP[c];
-      const val = getVal(parsedImage, offset + map2.offset);
-      value |= val << map2.shift;
+          delete material.unlit;
+          gltfScenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
+          gltfScenegraph.addExtension(KHR_MATERIALS_UNLIT);
+        }
+      }
     }
-    return value;
   }
-  function getVal(parsedImage, offset) {
-    const imageData = getImageData(parsedImage);
-    if (imageData.data.length <= offset) {
-      throw new Error(`${imageData.data.length} <= ${offset}`);
+  var KHR_MATERIALS_UNLIT, name10;
+  var init_KHR_materials_unlit = __esm({
+    "../gltf/src/lib/extensions/deprecated/KHR_materials_unlit.ts"() {
+      init_gltf_scenegraph();
+      KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
+      name10 = KHR_MATERIALS_UNLIT;
     }
-    return imageData.data[offset];
-  }
-  function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
-    const w = parsedImage.width;
-    const iX = emod(u) * (w - 1);
-    const indX = Math.round(iX);
-    const h = parsedImage.height;
-    const iY = emod(v) * (h - 1);
-    const indY = Math.round(iY);
-    const components = parsedImage.components ? parsedImage.components : componentsCount;
-    const offset = (indY * w + indX) * components;
-    return offset;
-  }
-  function emod(n2) {
-    const a2 = (n2 % 1 + 1) % 1;
-    return a2;
-  }
-  function findFeatureTableByName(featureTables, schemaClassName) {
-    for (const featureTableName in featureTables) {
-      const featureTable = featureTables[featureTableName];
-      if (featureTable.class === schemaClassName) {
-        return featureTable;
+  });
+
+  // ../gltf/src/lib/extensions/deprecated/KHR_techniques_webgl.ts
+  var KHR_techniques_webgl_exports = {};
+  __export(KHR_techniques_webgl_exports, {
+    decode: () => decode10,
+    encode: () => encode4,
+    name: () => name11
+  });
+  async function decode10(gltfData) {
+    const gltfScenegraph = new GLTFScenegraph(gltfData);
+    const { json } = gltfScenegraph;
+    const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
+    if (extension) {
+      const techniques = resolveTechniques(extension, gltfScenegraph);
+      for (const material of json.materials || []) {
+        const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+        if (materialExtension) {
+          material.technique = Object.assign({}, materialExtension, techniques[materialExtension.technique]);
+          material.technique.values = resolveValues(material.technique, gltfScenegraph);
+        }
+        gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
       }
+      gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
     }
-    return null;
   }
-  function findFeatureTextureByName(featureTextures, schemaClassName) {
-    for (const featureTexturesName in featureTextures) {
-      const featureTable = featureTextures[featureTexturesName];
-      if (featureTable.class === schemaClassName) {
-        return featureTable;
+  async function encode4(gltfData, options) {
+  }
+  function resolveTechniques(techniquesExtension, gltfScenegraph) {
+    const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
+    const textDecoder = new TextDecoder();
+    shaders.forEach((shader) => {
+      if (Number.isFinite(shader.bufferView)) {
+        shader.code = textDecoder.decode(gltfScenegraph.getTypedArrayForBufferView(shader.bufferView));
+      } else {
+        throw new Error("KHR_techniques_webgl: no shader code");
       }
-    }
-    return null;
+    });
+    programs.forEach((program) => {
+      program.fragmentShader = shaders[program.fragmentShader];
+      program.vertexShader = shaders[program.vertexShader];
+    });
+    techniques.forEach((technique) => {
+      technique.program = programs[technique.program];
+    });
+    return techniques;
   }
-  function getStringAttributes(data, offsetsData, stringsCount) {
-    const stringsArray = [];
-    const textDecoder = new TextDecoder("utf8");
-    let stringOffset = 0;
-    const bytesPerStringSize = 4;
-    for (let index = 0; index < stringsCount; index++) {
-      const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
-      const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
-      const stringAttribute = textDecoder.decode(stringData);
-      stringsArray.push(stringAttribute);
-      stringOffset += stringByteSize;
-    }
-    return stringsArray;
+  function resolveValues(technique, gltfScenegraph) {
+    const values = Object.assign({}, technique.values);
+    Object.keys(technique.uniforms || {}).forEach((uniform) => {
+      if (technique.uniforms[uniform].value && !(uniform in values)) {
+        values[uniform] = technique.uniforms[uniform].value;
+      }
+    });
+    Object.keys(values).forEach((uniform) => {
+      if (typeof values[uniform] === "object" && values[uniform].index !== void 0) {
+        values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);
+      }
+    });
+    return values;
   }
-  var EXT_FEATURE_METADATA, name9;
-  var init_EXT_feature_metadata = __esm({
-    "../gltf/src/lib/extensions/deprecated/EXT_feature_metadata.ts"() {
+  var KHR_TECHNIQUES_WEBGL, name11;
+  var init_KHR_techniques_webgl = __esm({
+    "../gltf/src/lib/extensions/deprecated/KHR_techniques_webgl.ts"() {
       init_gltf_scenegraph();
-      init_src8();
-      init_gltf_utils();
-      EXT_FEATURE_METADATA = "EXT_feature_metadata";
-      name9 = EXT_FEATURE_METADATA;
+      KHR_TECHNIQUES_WEBGL = "KHR_techniques_webgl";
+      name11 = KHR_TECHNIQUES_WEBGL;
     }
   });
 
@@ -11582,6 +12284,8 @@
   var EXTENSIONS2;
   var init_gltf_extensions = __esm({
     "../gltf/src/lib/api/gltf-extensions.ts"() {
+      init_EXT_mesh_features();
+      init_EXT_structural_metadata();
       init_EXT_meshopt_compression();
       init_EXT_texture_webp();
       init_KHR_texture_basisu();
@@ -11592,6 +12296,8 @@
       init_KHR_techniques_webgl();
       init_EXT_feature_metadata();
       EXTENSIONS2 = [
+        EXT_mesh_features_exports,
+        EXT_structural_metadata_exports,
         EXT_meshopt_compression_exports,
         EXT_texture_webp_exports,
         KHR_texture_basisu_exports,
@@ -11920,10 +12626,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 +12641,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() }
@@ -11977,13 +12683,13 @@
   var GLTFLoader;
   var init_gltf_loader = __esm({
     "../gltf/src/gltf-loader.ts"() {
-      init_version4();
+      init_version5();
       init_parse_gltf();
       GLTFLoader = {
         name: "glTF",
         id: "gltf",
         module: "gltf",
-        version: VERSION6,
+        version: VERSION7,
         extensions: ["gltf", "glb"],
         mimeTypes: ["model/gltf+json", "model/gltf-binary"],
         text: true,
@@ -12420,14 +13126,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;
@@ -12646,7 +13352,7 @@
     byteOffset += 4;
     tile.tiles = [];
     while (tile.tiles.length < tile.tilesLength && (tile.byteLength || 0) - byteOffset > 12) {
-      const subtile = {};
+      const subtile = { shape: "tile3d" };
       tile.tiles.push(subtile);
       byteOffset = await parse3DTile2(arrayBuffer, byteOffset, options, context, subtile);
     }
@@ -12661,27 +13367,28 @@
   // 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;
+        return arrayBuffer.byteLength;
       }
-      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 {
       tile.gltfArrayBuffer = arrayBuffer;
     }
+    return arrayBuffer.byteLength;
   }
   var init_parse_3d_tile_gltf = __esm({
     "src/lib/parsers/parse-3d-tile-gltf.ts"() {
+      init_src2();
       init_src10();
     }
   });
 
   // src/lib/parsers/parse-3d-tile.ts
-  async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = {}) {
+  async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = { shape: "tile3d" }) {
     tile.byteOffset = byteOffset;
     tile.type = getMagicString3(arrayBuffer, byteOffset);
     switch (tile.type) {
@@ -13001,7 +13708,7 @@
     for (const key of propNames) {
       const value = object[key];
       if (typeof value === "function") {
-        if (!predefined.find((name10) => key === name10)) {
+        if (!predefined.find((name12) => key === name12)) {
           object[key] = value.bind(obj);
         }
       }
@@ -13834,7 +14541,7 @@
       LongPrototype.toInt = function toInt() {
         return this.unsigned ? this.low >>> 0 : this.low;
       };
-      LongPrototype.toNumber = function toNumber() {
+      LongPrototype.toNumber = function toNumber2() {
         if (this.unsigned)
           return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
         return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
@@ -14903,7 +15610,7 @@
     } else if (uri.startsWith("/")) {
       return uri;
     }
-    return `${basePath}/${uri}`;
+    return path_exports.resolve(basePath, uri);
   }
   function normalizeTileData(tile, basePath) {
     if (!tile) {
@@ -15028,6 +15735,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();
@@ -15054,6 +15762,7 @@
     const normalizedRoot = await normalizeTileHeaders(tilesetJson, basePath, options || {});
     const tilesetJsonPostprocessed = {
       ...tilesetJson,
+      shape: "tileset3d",
       loader: Tiles3DLoader,
       url: tilesetUrl,
       queryString: context?.queryString || "",
@@ -15068,6 +15777,7 @@
   async function parseTile(arrayBuffer, options, context) {
     const tile = {
       content: {
+        shape: "tile3d",
         featureIds: null
       }
     };
@@ -15201,44 +15911,6 @@
     }
   });
 
-  // ../zip/src/file-provider/data-view-file.ts
-  var toNumber2, DataViewFile;
-  var init_data_view_file = __esm({
-    "../zip/src/file-provider/data-view-file.ts"() {
-      toNumber2 = (bigint) => {
-        if (bigint > Number.MAX_SAFE_INTEGER) {
-          throw new Error("Offset is out of bounds");
-        }
-        return Number(bigint);
-      };
-      DataViewFile = class {
-        constructor(file) {
-          this.file = file;
-        }
-        async destroy() {
-        }
-        async getUint8(offset) {
-          return this.file.getUint8(toNumber2(offset));
-        }
-        async getUint16(offset) {
-          return this.file.getUint16(toNumber2(offset), true);
-        }
-        async getUint32(offset) {
-          return this.file.getUint32(toNumber2(offset), true);
-        }
-        async getBigUint64(offset) {
-          return this.file.getBigUint64(toNumber2(offset), true);
-        }
-        async slice(startOffset, endOffset) {
-          return this.file.buffer.slice(toNumber2(startOffset), toNumber2(endOffset));
-        }
-        get length() {
-          return BigInt(this.file.byteLength);
-        }
-      };
-    }
-  });
-
   // ../zip/src/parse-zip/search-from-the-end.ts
   var searchFromTheEnd;
   var init_search_from_the_end = __esm({
@@ -15707,17 +16379,6 @@
     }
   });
 
-  // ../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();
-    }
-  });
-
   // ../compression/src/lib/compression.ts
   var Compression;
   var init_compression = __esm({
@@ -15766,6 +16427,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 +20675,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_src2();
+      init_src2();
+      init_src2();
+      init_cd_file_header();
+      init_local_file_header();
       init_src11();
-      init_src12();
       COMPRESSION_METHODS = {
         0: async (compressedFile) => compressedFile,
         8: async (compressedFile) => {
@@ -20005,9 +20700,109 @@
           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_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 +20811,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 +20821,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 +20836,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 +20860,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_src2();
+      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 +21166,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 +21180,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();