@loaders.gl/gltf 4.0.0-alpha.23 → 4.0.0-alpha.25

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 = [
@@ -2531,25 +2584,44 @@
     }
   });
 
-  // src/lib/extensions/data-processing.ts
+  // 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 length = 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, length);
+    const length = elementCount * numberOfComponents;
+    const byteLength = length * 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, length);
   }
   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") {
@@ -2567,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);
@@ -2592,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;
@@ -2606,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) {
@@ -2629,8 +2702,8 @@
     return offset;
   }
   var ATTRIBUTE_TYPE_TO_COMPONENTS2, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2;
-  var init_data_processing = __esm({
-    "src/lib/extensions/data-processing.ts"() {
+  var init_d_tiles_utils = __esm({
+    "src/lib/extensions/utils/3d-tiles-utils.ts"() {
       init_gltf_utils();
       init_src3();
       init_src4();
@@ -2673,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];
@@ -2694,30 +2841,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;
@@ -2740,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;
       }
@@ -2778,14 +2948,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":
@@ -2813,11 +2977,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;
@@ -2827,52 +2997,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;
   }
@@ -2898,9 +3058,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");
@@ -2912,69 +3069,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;
-  }
-  function handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry) {
+    return getEnumsArray(valuesData, 0, numberOfElements, 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, len = propertyTables.length; i2 < len; 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) {
@@ -2984,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_data_processing();
+      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_data_processing();
-      init_EXT_structural_metadata();
-      EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
-      name2 = EXT_MESH_FEATURES_NAME;
+      name2 = EXT_STRUCTURAL_METADATA_NAME;
     }
   });
 
@@ -3064,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)
@@ -3120,16 +3252,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) {
@@ -3148,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;
@@ -3247,14 +3407,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;
   }
@@ -3265,24 +3421,25 @@
       init_src3();
       init_gltf_utils();
       init_src4();
+      init_d_tiles_utils();
       EXT_FEATURE_METADATA_NAME = "EXT_feature_metadata";
       name3 = EXT_FEATURE_METADATA_NAME;
     }
   });
 
   // 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";
     }
   });
 
@@ -3721,7 +3878,7 @@
         name: "Basis",
         id: "basis",
         module: "textures",
-        version: VERSION5,
+        version: VERSION4,
         worker: true,
         extensions: ["basis", "ktx2"],
         mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -4197,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";
     }
   });
 
@@ -4221,7 +4378,7 @@
         name: "Draco",
         id: "draco",
         module: "draco",
-        version: VERSION6,
+        version: VERSION5,
         worker: true,
         extensions: ["drc"],
         mimeTypes: ["application/octet-stream"],
@@ -4765,7 +4922,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 = {
@@ -4976,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, {
@@ -5355,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,
@@ -5748,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,
@@ -5865,7 +5998,7 @@
         name: "glTF",
         id: "gltf",
         module: "gltf",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["glb"],
         mimeTypes: ["model/gltf-binary"],
         binary: true,
@@ -5896,7 +6029,7 @@
         name: "GLB",
         id: "glb",
         module: "gltf",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["glb"],
         mimeTypes: ["model/gltf-binary"],
         binary: true,
@@ -5929,7 +6062,7 @@
         name: "GLB",
         id: "glb",
         module: "gltf",
-        version: VERSION4,
+        version: VERSION3,
         extensions: ["glb"],
         mimeTypes: ["model/gltf-binary"],
         binary: true,
@@ -6319,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({
@@ -6334,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();