@loaders.gl/scene 5.0.0-alpha.9 → 5.0.0-beta.10

package/dist/gltf/lib/extensions/EXT_structural_metadata.cjs

@@ -0,0 +1,684 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/extensions/EXT_structural_metadata.ts
+var EXT_structural_metadata_exports = {};
+__export(EXT_structural_metadata_exports, {
+  createExtStructuralMetadata: () => createExtStructuralMetadata,
+  decode: () => decode,
+  encode: () => encode,
+  name: () => name
+});
+module.exports = __toCommonJS(EXT_structural_metadata_exports);
+var import_gltf_scenegraph = require("../api/gltf-scenegraph.cjs");
+var import_gltf_iterator = require("../api/gltf-iterator.cjs");
+var import_d_tiles_utils = require("./utils/3d-tiles-utils.cjs");
+var import_resolve_url = require("../gltf-utils/resolve-url.cjs");
+var EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
+var name = EXT_STRUCTURAL_METADATA_NAME;
+async function decode(gltfData, options, context) {
+  const iterator = new import_gltf_iterator.GLTFIterator(gltfData);
+  const extension = iterator.getExtension(
+    EXT_STRUCTURAL_METADATA_NAME
+  );
+  if (options.gltf?.loadBuffers && extension?.schemaUri && !extension.schema) {
+    if (!context?.fetch) {
+      throw new Error("EXT_structural_metadata: a loader context is required to load schemaUri");
+    }
+    const schemaUrl = (0, import_resolve_url.resolveUrl)(extension.schemaUri, options, context);
+    const response = await context.fetch(schemaUrl);
+    if (!response.ok) {
+      throw new Error(
+        `EXT_structural_metadata: failed to load schemaUri ${schemaUrl} (${response.status})`
+      );
+    }
+    extension.schema = await response.json();
+  }
+  decodeExtStructuralMetadata(iterator, options);
+}
+function encode(gltfData, options) {
+  const scenegraph = new import_gltf_scenegraph.GLTFScenegraph(gltfData);
+  encodeExtStructuralMetadata(scenegraph, options);
+  scenegraph.createBinaryChunk();
+  return scenegraph.gltf;
+}
+function decodeExtStructuralMetadata(iterator, options) {
+  if (!options.gltf?.loadBuffers) {
+    return;
+  }
+  const extension = iterator.getExtension(
+    EXT_STRUCTURAL_METADATA_NAME
+  );
+  if (!extension) {
+    return;
+  }
+  if (options.gltf?.loadImages) {
+    decodePropertyTextures(iterator, extension);
+  }
+  decodePropertyTables(iterator, extension);
+}
+function decodePropertyTextures(iterator, extension) {
+  const propertyTextures = extension.propertyTextures;
+  const json = iterator.data;
+  if (propertyTextures && json.meshes) {
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processPrimitivePropertyTextures(iterator, propertyTextures, primitive, extension);
+      }
+    }
+  }
+}
+function decodePropertyTables(iterator, extension) {
+  const schema = extension.schema;
+  if (!schema) {
+    return;
+  }
+  const schemaClasses = schema.classes;
+  const propertyTables = extension.propertyTables;
+  if (schemaClasses && propertyTables) {
+    for (const propertyTable of propertyTables) {
+      if (propertyTable.class && schemaClasses[propertyTable.class]) {
+        processPropertyTable(iterator, schema, propertyTable);
+      }
+    }
+  }
+}
+function processPrimitivePropertyTextures(iterator, propertyTextures, primitive, extension) {
+  if (!propertyTextures) {
+    return;
+  }
+  const primitiveExtension = primitive.extensions?.[EXT_STRUCTURAL_METADATA_NAME];
+  const primitivePropertyTextureIndices = primitiveExtension?.propertyTextures;
+  if (!primitivePropertyTextureIndices) {
+    return;
+  }
+  for (const primitivePropertyTextureIndex of primitivePropertyTextureIndices) {
+    const propertyTexture = propertyTextures[primitivePropertyTextureIndex];
+    processPrimitivePropertyTexture(iterator, propertyTexture, primitive, extension);
+  }
+}
+function processPrimitivePropertyTexture(iterator, propertyTexture, primitive, extension) {
+  if (!propertyTexture.properties) {
+    return;
+  }
+  if (!extension.dataAttributeNames) {
+    extension.dataAttributeNames = [];
+  }
+  const className = propertyTexture.class;
+  for (const propertyName in propertyTexture.properties) {
+    const attributeName = `${className}_${propertyName}`;
+    const textureInfoTopLevel = propertyTexture.properties?.[propertyName];
+    if (!textureInfoTopLevel) {
+      continue;
+    }
+    if (!textureInfoTopLevel.data) {
+      textureInfoTopLevel.data = [];
+    }
+    const featureTextureTable = textureInfoTopLevel.data;
+    const propertyData = (0, import_d_tiles_utils.getPrimitiveTextureData)(
+      iterator,
+      textureInfoTopLevel,
+      primitive
+    );
+    if (propertyData === null) {
+      continue;
+    }
+    (0, import_d_tiles_utils.primitivePropertyDataToAttributes)(
+      iterator,
+      attributeName,
+      propertyData,
+      featureTextureTable,
+      primitive
+    );
+    textureInfoTopLevel.data = featureTextureTable;
+    extension.dataAttributeNames.push(attributeName);
+  }
+}
+function processPropertyTable(iterator, schema, propertyTable) {
+  const schemaClass = schema.classes?.[propertyTable.class];
+  if (!schemaClass) {
+    throw new Error(
+      `Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`
+    );
+  }
+  const numberOfElements = propertyTable.count;
+  for (const propertyName in schemaClass.properties) {
+    const classProperty = schemaClass.properties[propertyName];
+    const propertyTableProperty = propertyTable.properties?.[propertyName];
+    if (propertyTableProperty) {
+      const rawDataOutput = {};
+      const data = getPropertyDataFromBinarySource(
+        iterator,
+        schema,
+        classProperty,
+        numberOfElements,
+        propertyTableProperty,
+        rawDataOutput
+      );
+      propertyTableProperty.data = data;
+      if (rawDataOutput.value !== void 0) {
+        Object.defineProperty(propertyTableProperty, "rawData", {
+          value: rawDataOutput.value,
+          configurable: true,
+          enumerable: false,
+          writable: true
+        });
+      }
+    }
+  }
+}
+function getPropertyDataFromBinarySource(iterator, schema, classProperty, numberOfElements, propertyTableProperty, rawDataOutput) {
+  let data = [];
+  const valuesBufferView = propertyTableProperty.values;
+  const valuesDataBytes = iterator.getTypedArrayForBufferView(valuesBufferView);
+  const arrayOffsets = getArrayOffsetsForProperty(
+    iterator,
+    classProperty,
+    propertyTableProperty,
+    numberOfElements
+  );
+  const stringOffsets = getStringOffsetsForProperty(
+    iterator,
+    classProperty,
+    propertyTableProperty,
+    numberOfElements,
+    arrayOffsets
+  );
+  switch (classProperty.type) {
+    case "SCALAR":
+    case "VEC2":
+    case "VEC3":
+    case "VEC4":
+    case "MAT2":
+    case "MAT3":
+    case "MAT4": {
+      const numericData = getPropertyDataNumeric(
+        classProperty,
+        propertyTableProperty,
+        numberOfElements,
+        valuesDataBytes,
+        arrayOffsets
+      );
+      data = numericData.data;
+      if (rawDataOutput) {
+        rawDataOutput.value = numericData.rawData;
+      }
+      break;
+    }
+    case "BOOLEAN": {
+      data = getPropertyDataBoolean(classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+      break;
+    }
+    case "STRING": {
+      data = (0, import_d_tiles_utils.getPropertyDataString)(
+        numberOfElements,
+        valuesDataBytes,
+        arrayOffsets,
+        stringOffsets,
+        classProperty.array ? classProperty.count : void 0
+      );
+      break;
+    }
+    case "ENUM": {
+      data = getPropertyDataENUM(
+        schema,
+        classProperty,
+        numberOfElements,
+        valuesDataBytes,
+        arrayOffsets
+      );
+      break;
+    }
+    default:
+      throw new Error(`Unknown classProperty type ${classProperty.type}`);
+  }
+  return data;
+}
+function getPropertyDataBoolean(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+  if (!classProperty.array) {
+    return getBooleanValues(valuesDataBytes, 0, numberOfElements);
+  }
+  if (arrayOffsets) {
+    return Array.from({ length: numberOfElements }, (_unused, rowIndex) => {
+      const start = Number(arrayOffsets[rowIndex]);
+      const end = Number(arrayOffsets[rowIndex + 1]);
+      if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) {
+        throw new Error("EXT_structural_metadata: invalid BOOLEAN array offsets");
+      }
+      return getBooleanValues(valuesDataBytes, start, end - start);
+    });
+  }
+  if (classProperty.count === void 0) {
+    return [];
+  }
+  return Array.from(
+    { length: numberOfElements },
+    (_unused, rowIndex) => getBooleanValues(
+      valuesDataBytes,
+      rowIndex * classProperty.count,
+      classProperty.count
+    )
+  );
+}
+function getBooleanValues(valuesDataBytes, start, count) {
+  if (start + count > valuesDataBytes.byteLength * 8) {
+    throw new Error("EXT_structural_metadata: BOOLEAN values exceed their buffer view");
+  }
+  return Array.from({ length: count }, (_unused, index) => {
+    const bitIndex = start + index;
+    return Boolean(valuesDataBytes[Math.floor(bitIndex / 8)] & 1 << bitIndex % 8);
+  });
+}
+function getArrayOffsetsForProperty(iterator, classProperty, propertyTableProperty, numberOfElements) {
+  if (classProperty.array && // `count` is a number of array elements. May only be defined when `array` is true.
+  // If `count` is NOT defined, it's a VARIABLE-length array
+  typeof classProperty.count === "undefined" && // `arrayOffsets` is an index of the buffer view containing offsets for variable-length arrays.
+  typeof propertyTableProperty.arrayOffsets !== "undefined") {
+    return (0, import_d_tiles_utils.getOffsetsForProperty)(
+      iterator,
+      propertyTableProperty.arrayOffsets,
+      propertyTableProperty.arrayOffsetType || "UINT32",
+      numberOfElements
+    );
+  }
+  return null;
+}
+function getStringOffsetsForProperty(iterator, classProperty, propertyTableProperty, numberOfElements, arrayOffsets) {
+  if (typeof propertyTableProperty.stringOffsets !== "undefined") {
+    const numberOfStrings = arrayOffsets ? Number(arrayOffsets[numberOfElements]) : numberOfElements * (classProperty.array ? classProperty.count || 1 : 1);
+    return (0, import_d_tiles_utils.getOffsetsForProperty)(
+      iterator,
+      propertyTableProperty.stringOffsets,
+      propertyTableProperty.stringOffsetType || "UINT32",
+      numberOfStrings
+    );
+  }
+  return null;
+}
+function getPropertyDataNumeric(classProperty, propertyTableProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+  const isArray = classProperty.array;
+  const arrayCount = classProperty.count;
+  const componentCount = { VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 }[classProperty.type] || 1;
+  const elementSize = (0, import_d_tiles_utils.getArrayElementByteSize)(classProperty.type, classProperty.componentType);
+  const elementCount = valuesDataBytes.byteLength / elementSize;
+  let valuesData;
+  if (classProperty.componentType) {
+    valuesData = (0, import_d_tiles_utils.convertRawBufferToMetadataArray)(
+      valuesDataBytes,
+      classProperty.type,
+      // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+      classProperty.componentType,
+      elementCount
+    );
+  } else {
+    valuesData = valuesDataBytes;
+  }
+  const rawValuesData = valuesData;
+  const offset = propertyTableProperty.offset ?? classProperty.offset;
+  const scale = propertyTableProperty.scale ?? classProperty.scale;
+  const transformedValuesData = classProperty.normalized || offset !== void 0 || scale !== void 0 ? applyNumericPropertyTransforms(
+    rawValuesData,
+    classProperty.componentType,
+    classProperty.type,
+    classProperty.normalized,
+    offset,
+    scale
+  ) : rawValuesData;
+  if (isArray) {
+    if (arrayOffsets) {
+      return {
+        data: (0, import_d_tiles_utils.parseVariableLengthArrayNumeric)(
+          transformedValuesData,
+          numberOfElements,
+          arrayOffsets,
+          componentCount
+        ),
+        rawData: (0, import_d_tiles_utils.parseVariableLengthArrayNumeric)(
+          rawValuesData,
+          numberOfElements,
+          arrayOffsets,
+          componentCount
+        )
+      };
+    }
+    if (arrayCount) {
+      return {
+        data: (0, import_d_tiles_utils.parseFixedLengthArrayNumeric)(
+          transformedValuesData,
+          numberOfElements,
+          arrayCount,
+          componentCount
+        ),
+        rawData: (0, import_d_tiles_utils.parseFixedLengthArrayNumeric)(
+          rawValuesData,
+          numberOfElements,
+          arrayCount,
+          componentCount
+        )
+      };
+    }
+    return { data: [], rawData: [] };
+  }
+  return { data: transformedValuesData, rawData: rawValuesData };
+}
+function applyNumericPropertyTransforms(valuesData, componentType, attributeType, normalized, offset, scale) {
+  const normalizationLimit = getNormalizationLimit(componentType);
+  const hasNormalization = Boolean(normalized && normalizationLimit !== void 0);
+  if (!hasNormalization && offset === void 0 && scale === void 0) {
+    return valuesData;
+  }
+  const numberOfComponents = getMetadataComponentCount(attributeType);
+  const result = new Float64Array(valuesData.length);
+  for (let index = 0; index < valuesData.length; index++) {
+    let value = Number(valuesData[index]);
+    if (hasNormalization) {
+      value = componentType?.startsWith("INT") ? Math.max(value / normalizationLimit, -1) : value / normalizationLimit;
+    }
+    const componentIndex = index % numberOfComponents;
+    const offsetValue = Array.isArray(offset) ? offset[componentIndex] ?? 0 : offset ?? 0;
+    const scaleValue = Array.isArray(scale) ? scale[componentIndex] ?? 1 : scale ?? 1;
+    result[index] = value * scaleValue + offsetValue;
+  }
+  return result;
+}
+function getMetadataComponentCount(attributeType) {
+  switch (attributeType) {
+    case "VEC2":
+      return 2;
+    case "VEC3":
+      return 3;
+    case "VEC4":
+      return 4;
+    case "MAT2":
+      return 4;
+    case "MAT3":
+      return 9;
+    case "MAT4":
+      return 16;
+    default:
+      return 1;
+  }
+}
+function getNormalizationLimit(componentType) {
+  switch (componentType) {
+    case "INT8":
+      return 127;
+    case "UINT8":
+      return 255;
+    case "INT16":
+      return 32767;
+    case "UINT16":
+      return 65535;
+    case "INT32":
+      return 2147483647;
+    case "UINT32":
+      return 4294967295;
+    case "INT64":
+      return 2 ** 63 - 1;
+    case "UINT64":
+      return 2 ** 64 - 1;
+    default:
+      return void 0;
+  }
+}
+function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+  const enumType = classProperty.enumType;
+  if (!enumType) {
+    throw new Error(
+      "Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM"
+    );
+  }
+  const enumEntry = schema.enums?.[enumType];
+  if (!enumEntry) {
+    throw new Error(
+      `Incorrect data in the EXT_structural_metadata extension: schema.enums does't contain ${enumType}`
+    );
+  }
+  const enumValueType = enumEntry.valueType || "UINT16";
+  const elementSize = (0, import_d_tiles_utils.getArrayElementByteSize)(classProperty.type, enumValueType);
+  const elementCount = valuesDataBytes.byteLength / elementSize;
+  let valuesData = (0, import_d_tiles_utils.convertRawBufferToMetadataArray)(
+    valuesDataBytes,
+    classProperty.type,
+    enumValueType,
+    elementCount
+  );
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
+  if (classProperty.array) {
+    if (arrayOffsets) {
+      return parseVariableLengthArrayENUM({
+        valuesData,
+        numberOfElements,
+        arrayOffsets,
+        enumEntry
+      });
+    }
+    const arrayCount = classProperty.count;
+    if (arrayCount) {
+      return parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
+    }
+    return [];
+  }
+  return getEnumsArray(valuesData, 0, numberOfElements, enumEntry);
+}
+function parseVariableLengthArrayENUM(params) {
+  const { valuesData, numberOfElements, arrayOffsets, enumEntry } = params;
+  const attributeValueArray = [];
+  for (let index = 0; index < numberOfElements; index++) {
+    const arrayOffset = Number(arrayOffsets[index]);
+    const arrayLength = Number(arrayOffsets[index + 1]) - arrayOffset;
+    if (!Number.isInteger(arrayOffset) || !Number.isInteger(arrayLength) || arrayOffset < 0 || arrayLength < 0 || arrayOffset + arrayLength > valuesData.length) {
+      break;
+    }
+    const array = getEnumsArray(valuesData, arrayOffset, arrayLength, enumEntry);
+    attributeValueArray.push(array);
+  }
+  return attributeValueArray;
+}
+function parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
+  const attributeValueArray = [];
+  for (let index = 0; index < numberOfElements; index++) {
+    const elementOffset = arrayCount * index;
+    const array = getEnumsArray(valuesData, elementOffset, arrayCount, enumEntry);
+    attributeValueArray.push(array);
+  }
+  return attributeValueArray;
+}
+function getEnumsArray(valuesData, offset, count, enumEntry) {
+  const array = [];
+  for (let i = 0; i < count; i++) {
+    const value = valuesData[offset + i];
+    const enumObject = getEnumByValue(enumEntry, value);
+    if (enumObject) {
+      array.push(enumObject.name);
+    } else {
+      array.push("");
+    }
+  }
+  return array;
+}
+function getEnumByValue(enumEntry, value) {
+  for (const enumValue of enumEntry.values) {
+    const matchesValue = typeof value === "bigint" ? Number.isSafeInteger(enumValue.value) && BigInt(enumValue.value) === value : enumValue.value === value;
+    if (matchesValue) {
+      return enumValue;
+    }
+  }
+  return null;
+}
+var SCHEMA_CLASS_ID_DEFAULT = "schemaClassId";
+function encodeExtStructuralMetadata(scenegraph, options) {
+  const extension = scenegraph.getExtension(
+    EXT_STRUCTURAL_METADATA_NAME
+  );
+  if (!extension) {
+    return;
+  }
+  if (extension.propertyTables) {
+    for (const table of extension.propertyTables) {
+      const classId = table.class;
+      const schemaClass = extension.schema?.classes?.[classId];
+      if (table.properties && schemaClass) {
+        encodeProperties(table, schemaClass, scenegraph);
+      }
+    }
+  }
+}
+function encodeProperties(table, schemaClass, scenegraph) {
+  for (const propertyName in table.properties) {
+    const data = table.properties[propertyName].data;
+    if (data) {
+      const classProperty = schemaClass.properties[propertyName];
+      if (classProperty) {
+        const tableProperty = createPropertyTableProperty(
+          data,
+          classProperty,
+          scenegraph
+        );
+        table.properties[propertyName] = tableProperty;
+      }
+    }
+  }
+}
+function createExtStructuralMetadata(scenegraph, propertyAttributes, classId = SCHEMA_CLASS_ID_DEFAULT) {
+  let extension = scenegraph.getExtension(
+    EXT_STRUCTURAL_METADATA_NAME
+  );
+  if (!extension) {
+    extension = scenegraph.addExtension(EXT_STRUCTURAL_METADATA_NAME);
+  }
+  extension.schema = createSchema(propertyAttributes, classId, extension.schema);
+  const table = createPropertyTable(propertyAttributes, classId, extension.schema);
+  if (!extension.propertyTables) {
+    extension.propertyTables = [];
+  }
+  return extension.propertyTables.push(table) - 1;
+}
+function createSchema(propertyAttributes, classId, schemaToUpdate) {
+  const schema = schemaToUpdate ?? {
+    id: "schema_id"
+  };
+  const schemaClass = {
+    properties: {}
+  };
+  for (const attribute of propertyAttributes) {
+    const classProperty = {
+      type: attribute.elementType,
+      componentType: attribute.componentType
+    };
+    schemaClass.properties[attribute.name] = classProperty;
+  }
+  schema.classes = {};
+  schema.classes[classId] = schemaClass;
+  return schema;
+}
+function createPropertyTable(propertyAttributes, classId, schema) {
+  const table = {
+    class: classId,
+    count: 0
+  };
+  let count = 0;
+  const schemaClass = schema.classes?.[classId];
+  for (const attribute of propertyAttributes) {
+    if (count === 0) {
+      count = attribute.values.length;
+    }
+    if (count !== attribute.values.length && attribute.values.length) {
+      throw new Error("Illegal values in attributes");
+    }
+    const classProperty = schemaClass?.properties[attribute.name];
+    if (classProperty) {
+      if (!table.properties) {
+        table.properties = {};
+      }
+      table.properties[attribute.name] = { values: 0, data: attribute.values };
+    }
+  }
+  table.count = count;
+  return table;
+}
+function createPropertyTableProperty(values, classProperty, scenegraph) {
+  const prop = { values: 0 };
+  if (classProperty.type === "STRING") {
+    const { stringData, stringOffsets } = createPropertyDataString(values);
+    prop.stringOffsets = createBufferView(stringOffsets, scenegraph);
+    prop.values = createBufferView(stringData, scenegraph);
+  } else if (classProperty.type === "SCALAR" && classProperty.componentType) {
+    const data = createPropertyDataScalar(values, classProperty.componentType);
+    prop.values = createBufferView(data, scenegraph);
+  }
+  return prop;
+}
+var COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR = {
+  INT8: Int8Array,
+  UINT8: Uint8Array,
+  INT16: Int16Array,
+  UINT16: Uint16Array,
+  INT32: Int32Array,
+  UINT32: Uint32Array,
+  INT64: Int32Array,
+  UINT64: Uint32Array,
+  FLOAT32: Float32Array,
+  FLOAT64: Float64Array
+};
+function createPropertyDataScalar(array, componentType) {
+  const numberArray = [];
+  for (const value of array) {
+    numberArray.push(Number(value));
+  }
+  const Construct = COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR[componentType];
+  if (!Construct) {
+    throw new Error("Illegal component type");
+  }
+  return new Construct(numberArray);
+}
+function createPropertyDataString(strings) {
+  const utf8Encode = new TextEncoder();
+  const arr = [];
+  let len = 0;
+  for (const str of strings) {
+    const uint8Array = utf8Encode.encode(str);
+    len += uint8Array.length;
+    arr.push(uint8Array);
+  }
+  const strArray = new Uint8Array(len);
+  const strOffsets = [];
+  let offset = 0;
+  for (const str of arr) {
+    strArray.set(str, offset);
+    strOffsets.push(offset);
+    offset += str.length;
+  }
+  strOffsets.push(offset);
+  const stringOffsetsTypedArray = new Uint32Array(strOffsets);
+  return { stringData: strArray, stringOffsets: stringOffsetsTypedArray };
+}
+function createBufferView(typedArray, scenegraph) {
+  return scenegraph.addBufferView(typedArray);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExtStructuralMetadata,
+  decode,
+  encode,
+  name
+});
+//# sourceMappingURL=EXT_structural_metadata.cjs.map