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

package/dist/dist.min.js

@@ -69,16 +69,45 @@
     }
   });
 
+  // ../loader-utils/src/lib/option-utils/merge-loader-options.ts
+  function mergeLoaderOptions(baseOptions, newOptions) {
+    return mergeOptionsRecursively(baseOptions || {}, newOptions);
+  }
+  function mergeOptionsRecursively(baseOptions, newOptions) {
+    const options = { ...baseOptions };
+    for (const [key, newValue] of Object.entries(newOptions)) {
+      if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+        options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
+      } else {
+        options[key] = newOptions[key];
+      }
+    }
+    return options;
+  }
+  var init_merge_loader_options = __esm({
+    "../loader-utils/src/lib/option-utils/merge-loader-options.ts"() {
+    }
+  });
+
   // ../worker-utils/src/lib/env-utils/version.ts
-  var DEFAULT_VERSION, VERSION;
-  var init_version = __esm({
-    "../worker-utils/src/lib/env-utils/version.ts"() {
-      DEFAULT_VERSION = "beta";
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
       if (typeof __VERSION__ === "undefined") {
         console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+        globalThis._loadersgl_.version = NPM_TAG;
+      } else {
+        globalThis._loadersgl_.version = __VERSION__;
       }
     }
+    return globalThis._loadersgl_.version;
+  }
+  var NPM_TAG, VERSION;
+  var init_version = __esm({
+    "../worker-utils/src/lib/env-utils/version.ts"() {
+      NPM_TAG = "beta";
+      VERSION = getVersion();
+    }
   });
 
   // ../worker-utils/src/lib/env-utils/assert.ts
@@ -543,12 +572,11 @@
     assert3(url);
     return url;
   }
-  var NPM_TAG;
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert2();
       init_globals2();
-      NPM_TAG = "beta";
+      init_version();
     }
   });
 
@@ -596,7 +624,7 @@
     }
     if (options.CDN) {
       assert3(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${libraryName}`;
+      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
     }
     if (isWorker) {
       return `../src/libs/${libraryName}`;
@@ -652,15 +680,13 @@
     }
     return await node.readFileAsText(url);
   }
-  var node, LATEST, VERSION2, loadLibraryPromises;
+  var node, loadLibraryPromises;
   var init_library_utils = __esm({
     "../worker-utils/src/lib/library-utils/library-utils.ts"() {
       init_globals2();
       node = __toModule(require_require_utils());
       init_assert2();
       init_version();
-      LATEST = "beta";
-      VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
       loadLibraryPromises = {};
     }
   });
@@ -1190,9 +1216,9 @@
     }
   });
 
-  // (disabled):fs
-  var require_fs = __commonJS({
-    "(disabled):fs"() {
+  // ../loader-utils/src/lib/node/fs.browser.ts
+  var init_fs_browser = __esm({
+    "../loader-utils/src/lib/node/fs.browser.ts"() {
     }
   });
 
@@ -1207,15 +1233,15 @@
   });
 
   // ../loader-utils/src/lib/file-provider/file-handle.ts
-  var import_fs, FileHandle;
+  var FileHandle;
   var init_file_handle = __esm({
     "../loader-utils/src/lib/file-provider/file-handle.ts"() {
-      import_fs = __toModule(require_fs());
+      init_fs_browser();
       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 }));
+              (void 0)(this.fileDescriptor, buffer, offset, length4, position, (_err, bytesRead, buffer2) => s2({ bytesRead, buffer: buffer2 }));
             });
           };
           this.fileDescriptor = fileDescriptor;
@@ -1224,18 +1250,14 @@
         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));
+              (void 0)(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));
-            })
+            (void 0)(path, { bigint: true })
           ]);
           return new FileHandle(fd, stats);
         }
         async close() {
-          return new Promise((resolve2) => {
-            (0, import_fs.close)(this.fileDescriptor, (_err) => resolve2());
-          });
+          return (void 0)(this.fileDescriptor);
         }
         get stat() {
           return this.stats;
@@ -1350,6 +1372,7 @@
       init_loader_types();
       init_assert();
       init_globals();
+      init_merge_loader_options();
       init_parse_with_worker();
       init_parse_json();
       init_array_buffer_utils();
@@ -5767,11 +5790,11 @@
   });
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION3, isBrowser4;
+  var VERSION2, isBrowser4;
   var init_globals4 = __esm({
     "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser();
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
@@ -6108,7 +6131,7 @@
             id: ""
           };
           _defineProperty(this, "id", void 0);
-          _defineProperty(this, "VERSION", VERSION3);
+          _defineProperty(this, "VERSION", VERSION2);
           _defineProperty(this, "_startTs", getHiResTimestamp());
           _defineProperty(this, "_deltaTs", getHiResTimestamp());
           _defineProperty(this, "_storage", void 0);
@@ -6311,7 +6334,7 @@
           return noop;
         }
       };
-      _defineProperty(Log, "VERSION", VERSION3);
+      _defineProperty(Log, "VERSION", VERSION2);
     }
   });
 
@@ -7049,6 +7072,7 @@
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    options = mergeLoaderOptions(loader.options, options);
     if (isResponse(data)) {
       const response = data;
       const { ok, redirected, status, statusText, type, url } = response;
@@ -7079,6 +7103,7 @@
       init_normalize_loader();
       init_is_type();
       init_option_utils();
+      init_src2();
       init_get_data();
       init_loader_context();
       init_resource_utils();
@@ -7158,10 +7183,10 @@
   });
 
   // src/lib/utils/version.ts
-  var VERSION4;
+  var VERSION3;
   var init_version2 = __esm({
     "src/lib/utils/version.ts"() {
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -7207,10 +7232,10 @@
   });
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION5;
+  var VERSION4;
   var init_version3 = __esm({
     "../draco/src/lib/utils/version.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -7231,7 +7256,7 @@
         name: "Draco",
         id: "draco",
         module: "draco",
-        version: VERSION5,
+        version: VERSION4,
         worker: true,
         extensions: ["drc"],
         mimeTypes: ["application/octet-stream"],
@@ -7775,7 +7800,7 @@
   var init_draco_module_loader = __esm({
     "../draco/src/lib/draco-module-loader.ts"() {
       init_src();
-      DRACO_DECODER_VERSION = "1.5.5";
+      DRACO_DECODER_VERSION = "1.5.6";
       DRACO_ENCODER_VERSION = "1.4.1";
       STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
       DRACO_EXTERNAL_LIBRARIES = {
@@ -9060,10 +9085,10 @@
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION6;
+  var VERSION5;
   var init_version4 = __esm({
     "../images/src/lib/utils/version.ts"() {
-      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -9512,7 +9537,7 @@
         id: "image",
         module: "images",
         name: "Images",
-        version: VERSION6,
+        version: VERSION5,
         mimeTypes: MIME_TYPES,
         extensions: EXTENSIONS,
         parse: parseImage,
@@ -9582,6 +9607,30 @@
     }
   });
 
+  // ../gltf/src/lib/gltf-utils/gltf-constants.ts
+  var COMPONENTS, BYTES;
+  var init_gltf_constants = __esm({
+    "../gltf/src/lib/gltf-utils/gltf-constants.ts"() {
+      COMPONENTS = {
+        SCALAR: 1,
+        VEC2: 2,
+        VEC3: 3,
+        VEC4: 4,
+        MAT2: 4,
+        MAT3: 9,
+        MAT4: 16
+      };
+      BYTES = {
+        5120: 1,
+        5121: 1,
+        5122: 2,
+        5123: 2,
+        5125: 4,
+        5126: 4
+      };
+    }
+  });
+
   // ../gltf/src/lib/gltf-utils/gltf-utils.ts
   function getAccessorTypeFromSize(size) {
     const type = TYPES[size - 1];
@@ -9603,6 +9652,27 @@
     assert7(byteLength >= 0 && byteLength <= bufferView.byteLength);
     return { ArrayType, length: length4, byteLength };
   }
+  function getFloat32ArrayForAccessor(gltfData, texCoordAccessor) {
+    const accessor = gltfData.json.accessors?.[texCoordAccessor];
+    if (accessor && typeof accessor.bufferView !== "undefined") {
+      const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
+      if (bufferView) {
+        const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
+        const byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+        const { ArrayType, length: length4 } = getAccessorArrayTypeAndLength(accessor, bufferView);
+        const bytes = BYTES[accessor.componentType];
+        const components = COMPONENTS[accessor.type];
+        const elementAddressScale = bufferView.byteStride || bytes * components;
+        const result = new Float32Array(length4);
+        for (let i2 = 0; i2 < accessor.count; i2++) {
+          const uv = new ArrayType(arrayBuffer, byteOffset + i2 * elementAddressScale, 2);
+          result.set(uv, i2 * components);
+        }
+        return result;
+      }
+    }
+    return null;
+  }
   function getMemoryUsageGLTF(gltf) {
     let { images, bufferViews } = gltf;
     images = images || [];
@@ -9620,6 +9690,7 @@
   var init_gltf_utils = __esm({
     "../gltf/src/lib/gltf-utils/gltf-utils.ts"() {
       init_assert6();
+      init_gltf_constants();
       MIPMAP_FACTOR = 1.33;
       TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
       ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
@@ -10082,25 +10153,44 @@
     }
   });
 
-  // ../gltf/src/lib/extensions/data-processing.ts
+  // ../gltf/src/lib/extensions/utils/3d-tiles-utils.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) {
+  function getOffsetsForProperty(scenegraph, bufferViewIndex, offsetType, numberOfElements) {
+    if (offsetType !== "UINT8" && offsetType !== "UINT16" && offsetType !== "UINT32" && offsetType !== "UINT64") {
+      return null;
+    }
+    const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+    const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, "SCALAR", offsetType, numberOfElements + 1);
+    if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+      return null;
+    }
+    return arrayOffsets;
+  }
+  function convertRawBufferToMetadataArray(data, 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);
+    const length4 = elementCount * numberOfComponents;
+    const byteLength = length4 * size;
+    let buffer = data.buffer;
+    let offset = data.byteOffset;
+    if (offset % size !== 0) {
+      const bufferArray = new Uint8Array(buffer);
+      buffer = bufferArray.slice(offset, offset + byteLength).buffer;
+      offset = 0;
+    }
+    return new ArrayType(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 textureCoordinates = getFloat32ArrayForAccessor(scenegraph.gltf, texCoordAccessorIndex);
+    if (!textureCoordinates) {
+      return null;
+    }
     const textureIndex = textureInfo.index;
     const imageIndex = json.textures?.[textureIndex]?.source;
     if (typeof imageIndex !== "undefined") {
@@ -10118,8 +10208,9 @@
     return null;
   }
   function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
-    if (propertyData === null)
+    if (!propertyData?.length) {
       return;
+    }
     const featureIndices = [];
     for (const texelData of propertyData) {
       let index = featureTable.findIndex((item) => item === texelData);
@@ -10143,12 +10234,12 @@
     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 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;
@@ -10157,7 +10248,7 @@
     const offset = coordinatesToOffset(u, v, parsedImage, components);
     let value = 0;
     for (const c of channels) {
-      const map2 = CHANNELS_MAP[c];
+      const map2 = typeof c === "number" ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
       const imageOffset = offset + map2.offset;
       const imageData = getImageData(parsedImage);
       if (imageData.data.length <= imageOffset) {
@@ -10180,8 +10271,8 @@
     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"() {
+  var init_d_tiles_utils = __esm({
+    "../gltf/src/lib/extensions/utils/3d-tiles-utils.ts"() {
       init_gltf_utils();
       init_src8();
       init_src7();
@@ -10224,17 +10315,91 @@
     }
   });
 
+  // ../gltf/src/lib/extensions/EXT_mesh_features.ts
+  var EXT_mesh_features_exports = {};
+  __export(EXT_mesh_features_exports, {
+    decode: () => decode,
+    name: () => name
+  });
+  async function decode(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) {
+    if (!options?.gltf?.loadBuffers) {
+      return;
+    }
+    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
+    const featureIds = extension?.featureIds;
+    if (!featureIds) {
+      return;
+    }
+    for (const featureId of featureIds) {
+      let featureIdData = null;
+      if (typeof featureId.attribute !== "undefined") {
+        const accessorKey = `_FEATURE_ID_${featureId.attribute}`;
+        const accessorIndex = primitive.attributes[accessorKey];
+        featureIdData = scenegraph.getTypedArrayForAccessor(accessorIndex);
+      } else if (typeof featureId.texture !== "undefined" && options?.gltf?.loadImages) {
+        featureIdData = getPrimitiveTextureData(scenegraph, featureId.texture, primitive);
+      } else {
+      }
+      featureId.data = featureIdData;
+    }
+  }
+  var EXT_MESH_FEATURES_NAME, name;
+  var init_EXT_mesh_features = __esm({
+    "../gltf/src/lib/extensions/EXT_mesh_features.ts"() {
+      init_gltf_scenegraph();
+      init_d_tiles_utils();
+      EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
+      name = EXT_MESH_FEATURES_NAME;
+    }
+  });
+
   // ../gltf/src/lib/extensions/EXT_structural_metadata.ts
   var EXT_structural_metadata_exports = {};
   __export(EXT_structural_metadata_exports, {
-    decode: () => decode,
+    decode: () => decode2,
+    getPropertyTableFromExtStructuralMetadata: () => getPropertyTableFromExtStructuralMetadata,
     getPropertyTablePopulated: () => getPropertyTablePopulated,
-    name: () => name
+    name: () => name2
   });
-  async function decode(gltfData, options) {
+  async function decode2(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     decodeExtStructuralMetadata(scenegraph, options);
   }
+  function getPropertyTableFromExtStructuralMetadata(extension, metadataClass) {
+    if (extension.propertyTables) {
+      const firstPropertyTable = extension?.propertyTables[0];
+      const propertyTableWithData = {};
+      for (const propertyName in firstPropertyTable.properties) {
+        propertyTableWithData[propertyName] = firstPropertyTable.properties[propertyName].data;
+      }
+      return propertyTableWithData;
+    }
+    if (extension.propertyTextures) {
+      const firstPropertyTexture = extension?.propertyTextures[0];
+      const propertyTableWithData = {};
+      for (const propertyName in firstPropertyTexture.properties) {
+        propertyTableWithData[propertyName] = firstPropertyTexture.properties[propertyName].data;
+      }
+      return propertyTableWithData;
+    }
+    console.warn("Cannot get property table from EXT_structural_metadata extension. There is neither propertyTables, nor propertyTextures in the extension.");
+    return null;
+  }
   function getPropertyTablePopulated(scenegraph, propertyTableIndex) {
     const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
     const propertyTable = extension?.propertyTables?.[propertyTableIndex];
@@ -10245,30 +10410,53 @@
     throw new Error(`Incorrect data in the EXT_structural_metadata extension: no property table with index ${propertyTableIndex}`);
   }
   function decodeExtStructuralMetadata(scenegraph, options) {
+    if (!options.gltf?.loadBuffers) {
+      return;
+    }
     const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
-    if (!extension?.schema) {
+    if (!extension) {
       return;
     }
+    if (options.gltf?.loadImages) {
+      decodePropertyTextures(scenegraph, extension);
+    }
+    decodePropertyTables(scenegraph, extension);
+  }
+  function decodePropertyTextures(scenegraph, extension) {
     const propertyTextures = extension.propertyTextures;
     const json = scenegraph.gltf.json;
-    if (propertyTextures && json.meshes && options?.gltf?.loadImages) {
+    if (propertyTextures && json.meshes) {
       for (const mesh of json.meshes) {
         for (const primitive of mesh.primitives) {
           processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension);
         }
       }
     }
-    const schemaClasses = extension.schema.classes;
+  }
+  function decodePropertyTables(scenegraph, extension) {
+    const schema = extension.schema;
+    if (!schema) {
+      return;
+    }
+    const schemaClasses = 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);
+          processPropertyTable(scenegraph, schema, propertyTable);
         }
       }
     }
   }
+  function findPropertyTableByClass(propertyTables, schemaClassName) {
+    for (const propertyTable of propertyTables) {
+      if (propertyTable.class === schemaClassName) {
+        return propertyTable;
+      }
+    }
+    return null;
+  }
   function processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension) {
     if (!propertyTextures) {
       return;
@@ -10291,9 +10479,9 @@
       extension.dataAttributeNames = [];
     }
     const className = propertyTexture.class;
-    for (const propName in propertyTexture.properties) {
-      const attributeName = `${className}_${propName}`;
-      const textureInfoTopLevel = propertyTexture.properties?.[propName];
+    for (const propertyName in propertyTexture.properties) {
+      const attributeName = `${className}_${propertyName}`;
+      const textureInfoTopLevel = propertyTexture.properties?.[propertyName];
       if (!textureInfoTopLevel) {
         continue;
       }
@@ -10329,14 +10517,8 @@
     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);
-    }
+    const arrayOffsets = getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements);
+    const stringOffsets = getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements);
     switch (classProperty.type) {
       case "SCALAR":
       case "VEC2":
@@ -10364,11 +10546,17 @@
     }
     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 getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
+    if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined") {
+      return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType || "UINT32", numberOfElements);
+    }
+    return null;
+  }
+  function getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements) {
+    if (typeof propertyTableProperty.stringOffsets !== "undefined") {
+      return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType || "UINT32", numberOfElements);
+    }
+    return null;
   }
   function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
     const isArray2 = classProperty.array;
@@ -10378,52 +10566,42 @@
     let valuesData;
     if (classProperty.componentType) {
       valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, classProperty.componentType, elementCount);
+      if (!valuesData) {
+        valuesData = valuesDataBytes;
+      }
     } else {
       valuesData = valuesDataBytes;
     }
     if (isArray2) {
       if (arrayOffsets) {
-        return handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+        return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
       }
       if (arrayCount) {
-        return handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+        return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
       }
       return [];
     }
-    const attributeValueArray = [];
-    for (let index = 0; index < numberOfElements; index++) {
-      const value = valuesData[index];
-      attributeValueArray.push(value);
-    }
-    return attributeValueArray;
+    return valuesData;
   }
-  function handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize) {
+  function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, valueSize) {
     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);
-        }
+      if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+        break;
       }
-      attributeValueArray.push(array);
+      const typedArrayOffset = arrayOffset / valueSize;
+      const elementCount = arrayByteSize / valueSize;
+      attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
     }
     return attributeValueArray;
   }
-  function handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+  function parseFixedLengthArrayNumeric(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);
+      const elementOffset = index * arrayCount;
+      attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
     }
     return attributeValueArray;
   }
@@ -10449,9 +10627,6 @@
     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");
@@ -10463,69 +10638,77 @@
     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) {
+    let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
+    if (!valuesData) {
+      valuesData = valuesDataBytes;
+    }
+    if (classProperty.array) {
       if (arrayOffsets) {
-        return handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize, enumEntry);
-      }
+        return parseVariableLengthArrayENUM({
+          valuesData,
+          numberOfElements,
+          arrayOffsets,
+          valuesDataBytesLength: valuesDataBytes.length,
+          elementSize,
+          enumEntry
+        });
+      }
+      const arrayCount = classProperty.count;
       if (arrayCount) {
-        return handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
+        return parseFixedLengthArrayENUM(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;
+    return getEnumsArray(valuesData, 0, numberOfElements, enumEntry);
   }
-  function handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry) {
+  function parseVariableLengthArrayENUM(params) {
+    const {
+      valuesData,
+      numberOfElements,
+      arrayOffsets,
+      valuesDataBytesLength,
+      elementSize,
+      enumEntry
+    } = params;
     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);
-          }
-        }
+      if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+        break;
       }
+      const typedArrayOffset = arrayOffset / elementSize;
+      const elementCount = arrayByteSize / elementSize;
+      const array = getEnumsArray(valuesData, typedArrayOffset, elementCount, enumEntry);
       attributeValueArray.push(array);
     }
     return attributeValueArray;
   }
-  function handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
+  function parseFixedLengthArrayENUM(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);
-        }
-      }
+      const elementOffset = arrayCount * index;
+      const array = getEnumsArray(valuesData, elementOffset, arrayCount, enumEntry);
       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;
+  function getEnumsArray(valuesData, offset, count, enumEntry) {
+    const array = [];
+    for (let i2 = 0; i2 < count; i2++) {
+      if (valuesData instanceof BigInt64Array || valuesData instanceof BigUint64Array) {
+        array.push("");
+      } else {
+        const value = valuesData[offset + i2];
+        const enumObject = getEnumByValue(enumEntry, value);
+        if (enumObject) {
+          array.push(enumObject.name);
+        } else {
+          array.push("");
+        }
       }
     }
-    return null;
+    return array;
   }
   function getEnumByValue(enumEntry, value) {
     for (const enumValue of enumEntry.values) {
@@ -10535,79 +10718,13 @@
     }
     return null;
   }
-  var EXT_STRUCTURAL_METADATA_NAME, name;
+  var EXT_STRUCTURAL_METADATA_NAME, name2;
   var init_EXT_structural_metadata = __esm({
     "../gltf/src/lib/extensions/EXT_structural_metadata.ts"() {
       init_gltf_scenegraph();
-      init_data_processing();
+      init_d_tiles_utils();
       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;
+      name2 = EXT_STRUCTURAL_METADATA_NAME;
     }
   });
 
@@ -10615,12 +10732,45 @@
   var EXT_feature_metadata_exports = {};
   __export(EXT_feature_metadata_exports, {
     decode: () => decode3,
+    getPropertyTableFromExtFeatureMetadata: () => getPropertyTableFromExtFeatureMetadata,
     name: () => name3
   });
   async function decode3(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     decodeExtFeatureMetadata(scenegraph, options);
   }
+  function getPropertyTableFromExtFeatureMetadata(extension, metadataClass) {
+    if (extension.featureTables) {
+      const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
+      if (firstFeatureTableName) {
+        const featureTable = extension.featureTables[firstFeatureTableName];
+        const propertyTable = {};
+        for (const propertyName in featureTable.properties) {
+          propertyTable[propertyName] = featureTable.properties[propertyName].data;
+        }
+        return propertyTable;
+      }
+    }
+    if (extension.featureTextures) {
+      let featureTexture;
+      for (const textureKey in extension.featureTextures) {
+        const texture = extension.featureTextures[textureKey];
+        if (texture.class === metadataClass) {
+          featureTexture = textureKey;
+        }
+      }
+      if (typeof featureTexture === "string") {
+        const featureTable = extension.featureTextures[featureTexture];
+        const propertyTable = {};
+        for (const propertyName in featureTable.properties) {
+          propertyTable[propertyName] = featureTable.properties[propertyName].data;
+        }
+        return propertyTable;
+      }
+    }
+    console.warn("Cannot get property table from EXT_feature_metadata extension. There is neither featureTables, nor featureTextures in the extension.");
+    return null;
+  }
   function decodeExtFeatureMetadata(scenegraph, options) {
     const extension = scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
     if (!extension)
@@ -10671,16 +10821,43 @@
   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);
+    if (schemaProperty.type === "STRING") {
+      const offsetsData = getStringOffsets(scenegraph, featureTableProperty, numberOfFeatures);
+      if (!offsetsData) {
+        return [];
       }
-      default:
+      return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+    } else if (isNumericProperty(schemaProperty.type)) {
+      return getNumericAttributes(dataArray, schemaProperty.type, numberOfFeatures);
     }
     return dataArray;
   }
+  function isNumericProperty(schemaPropertyType) {
+    return [
+      "UINT8",
+      "INT16",
+      "UINT16",
+      "INT32",
+      "UINT32",
+      "INT64",
+      "UINT64",
+      "FLOAT32",
+      "FLOAT64"
+    ].includes(schemaPropertyType);
+  }
+  function getStringOffsets(scenegraph, featureTableProperty, numberOfElements) {
+    if (typeof featureTableProperty.stringOffsetBufferView !== "undefined") {
+      return getOffsetsForProperty(scenegraph, featureTableProperty.stringOffsetBufferView, featureTableProperty.offsetType || "UINT32", numberOfElements);
+    }
+    return null;
+  }
+  function getNumericAttributes(valuesDataBytes, propertyType, elementCount) {
+    let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, "SCALAR", propertyType, elementCount);
+    if (!valuesData) {
+      valuesData = valuesDataBytes;
+    }
+    return valuesData;
+  }
   function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
     const json = scenegraph.gltf.json;
     if (!json.meshes) {
@@ -10699,9 +10876,10 @@
     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 textureCoordinates = getFloat32ArrayForAccessor(scenegraph.gltf, texCoordAccessorIndex);
+    if (!textureCoordinates) {
+      return;
+    }
     const textureIndex = featureTextureProperty.texture.index;
     const texture = json.textures?.[textureIndex];
     const imageIndex = texture?.source;
@@ -10798,14 +10976,10 @@
   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 stringData = data.slice(offsetsData[index], offsetsData[index + 1]);
       const stringAttribute = textDecoder.decode(stringData);
       stringsArray.push(stringAttribute);
-      stringOffset += stringByteSize;
     }
     return stringsArray;
   }
@@ -10816,24 +10990,25 @@
       init_src8();
       init_gltf_utils();
       init_src7();
+      init_d_tiles_utils();
       EXT_FEATURE_METADATA_NAME = "EXT_feature_metadata";
       name3 = EXT_FEATURE_METADATA_NAME;
     }
   });
 
   // ../gltf/src/lib/utils/version.ts
-  var VERSION7;
+  var VERSION6;
   var init_version5 = __esm({
     "../gltf/src/lib/utils/version.ts"() {
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION8;
+  var VERSION7;
   var init_version6 = __esm({
     "../textures/src/lib/utils/version.ts"() {
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
     }
   });
 
@@ -11272,7 +11447,7 @@
         name: "Basis",
         id: "basis",
         module: "textures",
-        version: VERSION8,
+        version: VERSION7,
         worker: true,
         extensions: ["basis", "ktx2"],
         mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -11917,30 +12092,6 @@
     }
   });
 
-  // ../gltf/src/lib/gltf-utils/gltf-constants.ts
-  var COMPONENTS, BYTES;
-  var init_gltf_constants = __esm({
-    "../gltf/src/lib/gltf-utils/gltf-constants.ts"() {
-      COMPONENTS = {
-        SCALAR: 1,
-        VEC2: 2,
-        VEC3: 3,
-        VEC4: 4,
-        MAT2: 4,
-        MAT3: 9,
-        MAT4: 16
-      };
-      BYTES = {
-        5120: 1,
-        5121: 1,
-        5122: 2,
-        5123: 2,
-        5125: 4,
-        5126: 4
-      };
-    }
-  });
-
   // ../gltf/src/lib/extensions/KHR_texture_transform.ts
   var KHR_texture_transform_exports = {};
   __export(KHR_texture_transform_exports, {
@@ -12296,8 +12447,8 @@
       init_KHR_techniques_webgl();
       init_EXT_feature_metadata();
       EXTENSIONS2 = [
-        EXT_mesh_features_exports,
         EXT_structural_metadata_exports,
+        EXT_mesh_features_exports,
         EXT_meshopt_compression_exports,
         EXT_texture_webp_exports,
         KHR_texture_basisu_exports,
@@ -12689,7 +12840,7 @@
         name: "glTF",
         id: "gltf",
         module: "gltf",
-        version: VERSION7,
+        version: VERSION6,
         extensions: ["gltf", "glb"],
         mimeTypes: ["model/gltf+json", "model/gltf-binary"],
         text: true,
@@ -13495,7 +13646,7 @@
         id: "3d-tiles-subtree",
         name: "3D Tiles Subtree",
         module: "3d-tiles",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["subtree"],
         mimeTypes: ["application/octet-stream"],
         tests: ["subtree"],
@@ -13550,11 +13701,11 @@
   });
 
   // node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION9, isBrowser6;
+  var VERSION8, isBrowser6;
   var init_globals6 = __esm({
     "node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser2();
-      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser6 = isBrowser5();
     }
   });
@@ -13889,7 +14040,7 @@
             id: ""
           };
           this.id = void 0;
-          this.VERSION = VERSION9;
+          this.VERSION = VERSION8;
           this._startTs = getHiResTimestamp2();
           this._deltaTs = getHiResTimestamp2();
           this._storage = void 0;
@@ -14092,7 +14243,7 @@
           return noop2;
         }
       };
-      Log2.VERSION = VERSION9;
+      Log2.VERSION = VERSION8;
     }
   });
 
@@ -15800,7 +15951,7 @@
         id: "3d-tiles",
         name: "3D Tiles",
         module: "3d-tiles",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
         mimeTypes: ["application/octet-stream"],
         tests: ["cmpt", "pnts", "b3dm", "i3dm"],
@@ -20870,17 +21021,17 @@
     const archive = await parse3DTilesArchive(new DataViewFile(new DataView(data)));
     return archive.getFile(options["3d-tiles-archive"]?.path ?? "");
   }
-  var VERSION10, Tiles3DArchiveFileLoader;
+  var VERSION9, 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";
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       Tiles3DArchiveFileLoader = {
         name: "3tz",
         id: "3tz",
         module: "3d-tiles",
-        version: VERSION10,
+        version: VERSION9,
         mimeTypes: ["application/octet-stream", "application/vnd.maxar.archive.3tz+zip"],
         parse: parse3DTilesArchive2,
         extensions: ["3tz"],
@@ -21149,7 +21300,7 @@
         name: "3D Tile",
         id: "3d-tiles",
         module: "3d-tiles",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
         mimeTypes: ["application/octet-stream"],
         encodeSync,