@loaders.gl/gltf 4.0.0-alpha.24 → 4.0.0-alpha.26

package/dist/dist.min.js

@@ -78,15 +78,24 @@
   });
 
   // ../worker-utils/src/lib/env-utils/version.ts
-  var DEFAULT_VERSION, VERSION2;
-  var init_version2 = __esm({
-    "../worker-utils/src/lib/env-utils/version.ts"() {
-      DEFAULT_VERSION = "beta";
-      VERSION2 = 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, VERSION2;
+  var init_version2 = __esm({
+    "../worker-utils/src/lib/env-utils/version.ts"() {
+      NPM_TAG = "beta";
+      VERSION2 = getVersion();
+    }
   });
 
   // ../worker-utils/src/lib/env-utils/assert.ts
@@ -150,7 +159,7 @@
     }
     if (options.CDN) {
       assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION3}/dist/libs/${libraryName}`;
+      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${libraryName}`;
     }
     if (isWorker) {
       return `../src/libs/${libraryName}`;
@@ -206,15 +215,13 @@
     }
     return await node.readFileAsText(url);
   }
-  var node, LATEST, VERSION3, 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_version2();
-      LATEST = "beta";
-      VERSION3 = typeof VERSION2 !== "undefined" ? VERSION2 : LATEST;
       loadLibraryPromises = {};
     }
   });
@@ -858,6 +865,30 @@
     }
   });
 
+  // src/lib/gltf-utils/gltf-constants.ts
+  var COMPONENTS, BYTES;
+  var init_gltf_constants = __esm({
+    "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
+      };
+    }
+  });
+
   // src/lib/gltf-utils/gltf-utils.ts
   function getAccessorTypeFromSize(size) {
     const type = TYPES[size - 1];
@@ -879,6 +910,27 @@
     assert3(byteLength >= 0 && byteLength <= bufferView.byteLength);
     return { ArrayType, length, 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 } = getAccessorArrayTypeAndLength(accessor, bufferView);
+        const bytes = BYTES[accessor.componentType];
+        const components = COMPONENTS[accessor.type];
+        const elementAddressScale = bufferView.byteStride || bytes * components;
+        const result = new Float32Array(length);
+        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 || [];
@@ -896,6 +948,7 @@
   var init_gltf_utils = __esm({
     "src/lib/gltf-utils/gltf-utils.ts"() {
       init_assert3();
+      init_gltf_constants();
       MIPMAP_FACTOR = 1.33;
       TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
       ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
@@ -2565,9 +2618,10 @@
     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") {
@@ -2585,8 +2639,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);
@@ -2610,12 +2665,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;
@@ -2624,7 +2679,7 @@
     const offset = coordinatesToOffset(u, v, parsedImage, components);
     let value = 0;
     for (const c of channels) {
-      const map = CHANNELS_MAP[c];
+      const map = typeof c === "number" ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
       const imageOffset = offset + map.offset;
       const imageData = getImageData(parsedImage);
       if (imageData.data.length <= imageOffset) {
@@ -2691,17 +2746,91 @@
     }
   });
 
+  // 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({
+    "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;
+    }
+  });
+
   // 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];
@@ -2712,33 +2841,47 @@
     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 (let i2 = 0, len = propertyTables.length; i2 < len; i2++) {
-      const propertyTable = propertyTables[i2];
+    for (const propertyTable of propertyTables) {
       if (propertyTable.class === schemaClassName) {
         return propertyTable;
       }
@@ -2767,9 +2910,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;
       }
@@ -2835,14 +2978,14 @@
     return data;
   }
   function getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
-    if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined" && typeof propertyTableProperty.arrayOffsetType !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType, 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" && typeof propertyTableProperty.stringOffsetType !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType, numberOfElements);
+    if (typeof propertyTableProperty.stringOffsets !== "undefined") {
+      return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType || "UINT32", numberOfElements);
     }
     return null;
   }
@@ -3006,79 +3149,13 @@
     }
     return null;
   }
-  var EXT_STRUCTURAL_METADATA_NAME, name;
+  var EXT_STRUCTURAL_METADATA_NAME, name2;
   var init_EXT_structural_metadata = __esm({
     "src/lib/extensions/EXT_structural_metadata.ts"() {
       init_gltf_scenegraph();
       init_d_tiles_utils();
       EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
-      name = EXT_STRUCTURAL_METADATA_NAME;
-    }
-  });
-
-  // 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({
-    "src/lib/extensions/EXT_mesh_features.ts"() {
-      init_gltf_scenegraph();
-      init_d_tiles_utils();
-      init_EXT_structural_metadata();
-      EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
-      name2 = EXT_MESH_FEATURES_NAME;
+      name2 = EXT_STRUCTURAL_METADATA_NAME;
     }
   });
 
@@ -3086,12 +3163,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)
@@ -3197,9 +3307,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;
@@ -3317,18 +3428,18 @@
   });
 
   // src/lib/utils/version.ts
-  var VERSION4;
+  var VERSION3;
   var init_version3 = __esm({
     "src/lib/utils/version.ts"() {
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION5;
+  var VERSION4;
   var init_version4 = __esm({
     "../textures/src/lib/utils/version.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
     }
   });
 
@@ -3767,7 +3878,7 @@
         name: "Basis",
         id: "basis",
         module: "textures",
-        version: VERSION5,
+        version: VERSION4,
         worker: true,
         extensions: ["basis", "ktx2"],
         mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -4243,10 +4354,10 @@
   });
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION6;
+  var VERSION5;
   var init_version5 = __esm({
     "../draco/src/lib/utils/version.ts"() {
-      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -4267,7 +4378,7 @@
         name: "Draco",
         id: "draco",
         module: "draco",
-        version: VERSION6,
+        version: VERSION5,
         worker: true,
         extensions: ["drc"],
         mimeTypes: ["application/octet-stream"],
@@ -5022,30 +5133,6 @@
     }
   });
 
-  // src/lib/gltf-utils/gltf-constants.ts
-  var COMPONENTS, BYTES;
-  var init_gltf_constants = __esm({
-    "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
-      };
-    }
-  });
-
   // src/lib/extensions/KHR_texture_transform.ts
   var KHR_texture_transform_exports = {};
   __export(KHR_texture_transform_exports, {
@@ -5401,8 +5488,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,
@@ -5794,7 +5881,7 @@
         name: "glTF",
         id: "gltf",
         module: "gltf",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["gltf", "glb"],
         mimeTypes: ["model/gltf+json", "model/gltf-binary"],
         text: true,
@@ -5911,7 +5998,7 @@
         name: "glTF",
         id: "gltf",
         module: "gltf",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["glb"],
         mimeTypes: ["model/gltf-binary"],
         binary: true,
@@ -5942,7 +6029,7 @@
         name: "GLB",
         id: "glb",
         module: "gltf",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["glb"],
         mimeTypes: ["model/gltf-binary"],
         binary: true,
@@ -5975,7 +6062,7 @@
         name: "GLB",
         id: "glb",
         module: "gltf",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["glb"],
         mimeTypes: ["model/gltf-binary"],
         binary: true,
@@ -6365,14 +6452,16 @@
   var src_exports = {};
   __export(src_exports, {
     EXT_FEATURE_METADATA: () => name3,
-    EXT_MESH_FEATURES: () => name2,
-    EXT_STRUCTURAL_METADATA: () => name,
+    EXT_MESH_FEATURES: () => name,
+    EXT_STRUCTURAL_METADATA: () => name2,
     GLBLoader: () => GLBLoader,
     GLBWriter: () => GLBWriter,
     GLTFLoader: () => GLTFLoader,
     GLTFScenegraph: () => GLTFScenegraph,
     GLTFWriter: () => GLTFWriter,
     _getMemoryUsageGLTF: () => getMemoryUsageGLTF,
+    getPropertyTableFromExtFeatureMetadata: () => getPropertyTableFromExtFeatureMetadata,
+    getPropertyTableFromExtStructuralMetadata: () => getPropertyTableFromExtStructuralMetadata,
     postProcessGLTF: () => postProcessGLTF
   });
   var init_src8 = __esm({
@@ -6380,6 +6469,8 @@
       init_EXT_mesh_features();
       init_EXT_structural_metadata();
       init_EXT_feature_metadata();
+      init_EXT_feature_metadata();
+      init_EXT_structural_metadata();
       init_gltf_loader();
       init_gltf_writer();
       init_glb_loader();

package/dist/es5/index.js

@@ -57,6 +57,18 @@ Object.defineProperty(exports, "_getMemoryUsageGLTF", {
     return _gltfUtils.getMemoryUsageGLTF;
   }
 });
+Object.defineProperty(exports, "getPropertyTableFromExtFeatureMetadata", {
+  enumerable: true,
+  get: function get() {
+    return _EXT_feature_metadata.getPropertyTableFromExtFeatureMetadata;
+  }
+});
+Object.defineProperty(exports, "getPropertyTableFromExtStructuralMetadata", {
+  enumerable: true,
+  get: function get() {
+    return _EXT_structural_metadata.getPropertyTableFromExtStructuralMetadata;
+  }
+});
 Object.defineProperty(exports, "postProcessGLTF", {
   enumerable: true,
   get: function get() {