@loaders.gl/scene 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/draco/lib/draco-parser.cjs

@@ -0,0 +1,601 @@
+"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 name in all)
+    __defProp(target, name, { get: all[name], 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/draco/lib/draco-parser.ts
+var draco_parser_exports = {};
+__export(draco_parser_exports, {
+  default: () => DracoParser
+});
+module.exports = __toCommonJS(draco_parser_exports);
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_get_draco_schema = require("./utils/get-draco-schema.cjs");
+var DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {
+  POSITION: "POSITION",
+  NORMAL: "NORMAL",
+  COLOR: "COLOR_0",
+  TEX_COORD: "TEXCOORD_0"
+};
+var DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {
+  1: Int8Array,
+  2: Uint8Array,
+  3: Int16Array,
+  4: Uint16Array,
+  5: Int32Array,
+  6: Uint32Array,
+  // 7: BigInt64Array,
+  // 8: BigUint64Array,
+  9: Float32Array
+  // 10: Float64Array
+  // 11: BOOL - What array type do we use for this?
+};
+var UINT16_INDEX_ITEM_SIZE = 2;
+var UINT32_INDEX_ITEM_SIZE = 4;
+var DracoParser = class {
+  // draco - the draco decoder, either import `draco3d` or load dynamically
+  constructor(draco, logger = (0, import_loader_utils.getLoaderLog)()) {
+    this.logger = logger;
+    this.draco = draco;
+    this.decoder = new this.draco.Decoder();
+    this.metadataQuerier = new this.draco.MetadataQuerier();
+  }
+  logger;
+  draco;
+  decoder;
+  metadataQuerier;
+  /**
+   * Destroy draco resources
+   */
+  destroy() {
+    this.draco.destroy(this.decoder);
+    this.draco.destroy(this.metadataQuerier);
+  }
+  /**
+   * NOTE: caller must call `destroyGeometry` on the return value after using it
+   * @param arrayBuffer
+   * @param options
+   */
+  parseSync(arrayBuffer, options = {}) {
+    validateAttributeSelection(options);
+    const encodedData = ArrayBuffer.isView(arrayBuffer) ? new Int8Array(arrayBuffer.buffer, arrayBuffer.byteOffset, arrayBuffer.byteLength) : new Int8Array(arrayBuffer);
+    this._disableAttributeTransforms(options);
+    const geometry_type = this.decoder.GetEncodedGeometryType(encodedData);
+    const dracoGeometry = geometry_type === this.draco.TRIANGULAR_MESH ? new this.draco.Mesh() : new this.draco.PointCloud();
+    let dracoStatus = null;
+    try {
+      switch (geometry_type) {
+        case this.draco.TRIANGULAR_MESH:
+          dracoStatus = this.decoder.DecodeArrayToMesh(
+            encodedData,
+            encodedData.byteLength,
+            dracoGeometry
+          );
+          break;
+        case this.draco.POINT_CLOUD:
+          dracoStatus = this.decoder.DecodeArrayToPointCloud(
+            encodedData,
+            encodedData.byteLength,
+            dracoGeometry
+          );
+          break;
+        default:
+          throw new Error("DRACO: Unknown geometry type.");
+      }
+      if (!dracoStatus.ok() || !dracoGeometry.ptr) {
+        const message = `DRACO decompression failed: ${dracoStatus.error_msg()}`;
+        throw new Error(message);
+      }
+      const loaderData = this._getDracoLoaderData(dracoGeometry, geometry_type, options);
+      const geometry = this._getMeshData(dracoGeometry, loaderData, options);
+      const boundingBox = getTransformedMeshBoundingBox(geometry.attributes);
+      const schema = (0, import_get_draco_schema.getDracoSchema)(geometry.attributes, loaderData, geometry.indices);
+      const data = {
+        loader: "draco",
+        loaderData,
+        header: {
+          vertexCount: dracoGeometry.num_points(),
+          boundingBox
+        },
+        ...geometry,
+        schema
+      };
+      return data;
+    } finally {
+      if (dracoStatus) {
+        this.draco.destroy(dracoStatus);
+      }
+      if (dracoGeometry) {
+        this.draco.destroy(dracoGeometry);
+      }
+    }
+  }
+  // Draco specific "loader data"
+  /**
+   * Extract
+   * @param dracoGeometry
+   * @param geometry_type
+   * @param options
+   * @returns
+   */
+  _getDracoLoaderData(dracoGeometry, geometry_type, options) {
+    const metadata = this._getTopLevelMetadata(dracoGeometry);
+    const attributes = this._getDracoAttributes(dracoGeometry, options);
+    return {
+      geometry_type,
+      num_attributes: dracoGeometry.num_attributes(),
+      num_points: dracoGeometry.num_points(),
+      num_faces: dracoGeometry instanceof this.draco.Mesh ? dracoGeometry.num_faces() : 0,
+      metadata,
+      attributes
+    };
+  }
+  /**
+   * Extract all draco provided information and metadata for each attribute
+   * @param dracoGeometry
+   * @param options
+   * @returns
+   */
+  _getDracoAttributes(dracoGeometry, options) {
+    const dracoAttributes = {};
+    for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
+      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
+      const metadata = this._getAttributeMetadata(dracoGeometry, attributeId);
+      dracoAttributes[dracoAttribute.unique_id()] = {
+        unique_id: dracoAttribute.unique_id(),
+        attribute_type: dracoAttribute.attribute_type(),
+        data_type: dracoAttribute.data_type(),
+        num_components: dracoAttribute.num_components(),
+        byte_offset: dracoAttribute.byte_offset(),
+        byte_stride: dracoAttribute.byte_stride(),
+        normalized: dracoAttribute.normalized(),
+        attribute_index: attributeId,
+        metadata
+      };
+      const quantization = this._getQuantizationTransform(dracoAttribute, options);
+      if (quantization) {
+        dracoAttributes[dracoAttribute.unique_id()].quantization_transform = quantization;
+      }
+      const octahedron = this._getOctahedronTransform(dracoAttribute, options);
+      if (octahedron) {
+        dracoAttributes[dracoAttribute.unique_id()].octahedron_transform = octahedron;
+      }
+    }
+    return dracoAttributes;
+  }
+  /**
+   * Get standard loaders.gl mesh category data
+   * Extracts the geometry from draco
+   * @param dracoGeometry
+   * @param options
+   */
+  _getMeshData(dracoGeometry, loaderData, options) {
+    const attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);
+    const positionAttribute = attributes.POSITION;
+    if (!positionAttribute) {
+      throw new Error("DRACO: No position attribute found.");
+    }
+    if (dracoGeometry instanceof this.draco.Mesh) {
+      switch (options.topology) {
+        case "triangle-strip":
+          return {
+            topology: "triangle-strip",
+            mode: 5,
+            // GL.TRIANGLE_STRIP
+            attributes,
+            indices: {
+              value: this._getTriangleStripIndices(dracoGeometry),
+              size: 1
+            }
+          };
+        case "triangle-list":
+        default:
+          return {
+            topology: "triangle-list",
+            mode: 4,
+            // GL.TRIANGLES
+            attributes,
+            indices: {
+              value: this._getTriangleListIndices(dracoGeometry),
+              size: 1
+            }
+          };
+      }
+    }
+    return {
+      topology: "point-list",
+      mode: 0,
+      // GL.POINTS
+      attributes
+    };
+  }
+  _getMeshAttributes(loaderData, dracoGeometry, options) {
+    const attributes = {};
+    const usedAttributeNames = {};
+    const loaderAttributes = Object.values(loaderData.attributes).sort(
+      (left, right) => left.attribute_index - right.attribute_index
+    );
+    const namedAttributes = loaderAttributes.map((loaderAttribute) => {
+      const deducedAttributeName = this._deduceAttributeName(loaderAttribute, options);
+      const attributeName = getUniqueAttributeName(deducedAttributeName, usedAttributeNames);
+      usedAttributeNames[attributeName] = true;
+      loaderAttribute.name = attributeName;
+      return { attributeName, loaderAttribute };
+    });
+    validateSelectedAttributeNames(options, Object.keys(usedAttributeNames));
+    for (const { attributeName, loaderAttribute } of namedAttributes) {
+      if (!this._shouldExtractAttribute(attributeName, loaderAttribute, options)) {
+        continue;
+      }
+      const values = this._getAttributeValues(dracoGeometry, loaderAttribute);
+      if (values) {
+        const { value, size } = values;
+        attributes[attributeName] = {
+          value,
+          size,
+          byteOffset: loaderAttribute.byte_offset,
+          byteStride: loaderAttribute.byte_stride,
+          normalized: loaderAttribute.normalized,
+          transform: getMeshAttributeTransform(loaderAttribute)
+        };
+      }
+    }
+    return attributes;
+  }
+  /** Returns true when an attribute should be copied from WASM into the requested output. */
+  _shouldExtractAttribute(attributeName, attribute, options) {
+    if (attribute.attribute_type === this.draco.POSITION) {
+      if (options.excludeAttributes?.includes(attributeName)) {
+        throw new Error(`DracoLoader: position attribute "${attributeName}" cannot be excluded`);
+      }
+      return true;
+    }
+    if (options.includeAttributes && !options.includeAttributes.includes(attributeName)) {
+      return false;
+    }
+    return !options.excludeAttributes?.includes(attributeName);
+  }
+  // MESH INDICES EXTRACTION
+  /**
+   * For meshes, we need indices to define the faces.
+   * @param dracoGeometry
+   */
+  _getTriangleListIndices(dracoGeometry) {
+    const numFaces = dracoGeometry.num_faces();
+    const numIndices = numFaces * 3;
+    const useUint16 = dracoGeometry.num_points() <= 65536;
+    const byteLength = numIndices * (useUint16 ? UINT16_INDEX_ITEM_SIZE : UINT32_INDEX_ITEM_SIZE);
+    const ptr = this.draco._malloc(byteLength);
+    try {
+      if (useUint16) {
+        const decoded2 = this.decoder.GetTrianglesUInt16Array(dracoGeometry, byteLength, ptr);
+        if (!decoded2) {
+          throw new Error("DRACO: Failed to decode triangle indices.");
+        }
+        return new Uint16Array(this.draco.HEAPU8.buffer, ptr, numIndices).slice();
+      }
+      const decoded = this.decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
+      if (!decoded) {
+        throw new Error("DRACO: Failed to decode triangle indices.");
+      }
+      return new Uint32Array(this.draco.HEAPU8.buffer, ptr, numIndices).slice();
+    } finally {
+      this.draco._free(ptr);
+    }
+  }
+  /**
+   * For meshes, we need indices to define the faces.
+   * @param dracoGeometry
+   */
+  _getTriangleStripIndices(dracoGeometry) {
+    const dracoArray = new this.draco.DracoInt32Array();
+    try {
+      this.decoder.GetTriangleStripsFromMesh(dracoGeometry, dracoArray);
+      return getUint32Array(dracoArray);
+    } finally {
+      this.draco.destroy(dracoArray);
+    }
+  }
+  /**
+   *
+   * @param dracoGeometry
+   * @param dracoAttribute
+   * @param attributeName
+   */
+  _getAttributeValues(dracoGeometry, attribute) {
+    const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
+    if (!TypedArrayCtor) {
+      this.logger.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`)();
+      return null;
+    }
+    const numComponents = attribute.num_components;
+    const numPoints = dracoGeometry.num_points();
+    const numValues = numPoints * numComponents;
+    const byteLength = numValues * TypedArrayCtor.BYTES_PER_ELEMENT;
+    const dataType = getDracoDataType(this.draco, TypedArrayCtor);
+    let value;
+    const ptr = this.draco._malloc(byteLength);
+    try {
+      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attribute.attribute_index);
+      const decoded = this.decoder.GetAttributeDataArrayForAllPoints(
+        dracoGeometry,
+        dracoAttribute,
+        dataType,
+        byteLength,
+        ptr
+      );
+      if (!decoded) {
+        throw new Error(`DRACO: Failed to decode attribute ${attribute.unique_id}.`);
+      }
+      value = new TypedArrayCtor(this.draco.HEAPU8.buffer, ptr, numValues).slice();
+    } finally {
+      this.draco._free(ptr);
+    }
+    return { value, size: numComponents };
+  }
+  // Attribute names
+  /** 
+   * DRACO does not store attribute names - We need to deduce an attribute name
+   * for each attribute
+  _getAttributeNames(
+    dracoGeometry: Mesh | PointCloud,
+    options: DracoParseOptions
+  ): {[unique_id: number]: string} {
+    const attributeNames: {[unique_id: number]: string} = {};
+    for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
+      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
+      const attributeName = this._deduceAttributeName(dracoAttribute, options);
+      attributeNames[attributeName] = attributeName;
+    }
+    return attributeNames;
+  }
+   */
+  /**
+   * Deduce an attribute name.
+   * @note DRACO does not save attribute names, just general type (POSITION, COLOR)
+   * to help optimize compression. We generate GLTF compatible names for the Draco-recognized
+   * types
+   * @param attributeData
+   */
+  _deduceAttributeName(attribute, options) {
+    const uniqueId = attribute.unique_id;
+    for (const [attributeName, attributeUniqueId] of Object.entries(
+      options.extraAttributes || {}
+    )) {
+      if (attributeUniqueId === uniqueId) {
+        return attributeName;
+      }
+    }
+    const entryName = options.attributeNameEntry || "name";
+    if (attribute.metadata[entryName]) {
+      const attributeName = attribute.metadata[entryName].string;
+      if (attributeName === "COLOR") {
+        return "COLOR_0";
+      }
+      if (attributeName === "TEX_COORD") {
+        return "TEXCOORD_0";
+      }
+      return attributeName;
+    }
+    const thisAttributeType = attribute.attribute_type;
+    for (const dracoAttributeConstant in DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP) {
+      const attributeType = this.draco[dracoAttributeConstant];
+      if (attributeType === thisAttributeType) {
+        return DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP[dracoAttributeConstant];
+      }
+    }
+    return `CUSTOM_ATTRIBUTE_${uniqueId}`;
+  }
+  // METADATA EXTRACTION
+  /** Get top level metadata */
+  _getTopLevelMetadata(dracoGeometry) {
+    const dracoMetadata = this.decoder.GetMetadata(dracoGeometry);
+    return this._getDracoMetadata(dracoMetadata);
+  }
+  /** Get per attribute metadata */
+  _getAttributeMetadata(dracoGeometry, attributeId) {
+    const dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);
+    return this._getDracoMetadata(dracoMetadata);
+  }
+  /**
+   * Extract metadata field values
+   * @param dracoMetadata
+   * @returns
+   */
+  _getDracoMetadata(dracoMetadata) {
+    if (!dracoMetadata || !dracoMetadata.ptr) {
+      return {};
+    }
+    const result = {};
+    const numEntries = this.metadataQuerier.NumEntries(dracoMetadata);
+    for (let entryIndex = 0; entryIndex < numEntries; entryIndex++) {
+      const entryName = this.metadataQuerier.GetEntryName(dracoMetadata, entryIndex);
+      result[entryName] = this._getDracoMetadataField(dracoMetadata, entryName);
+    }
+    return result;
+  }
+  /**
+   * Extracts possible values for one metadata entry by name
+   * @param dracoMetadata
+   * @param entryName
+   */
+  _getDracoMetadataField(dracoMetadata, entryName) {
+    const dracoArray = new this.draco.DracoInt32Array();
+    try {
+      this.metadataQuerier.GetIntEntryArray(dracoMetadata, entryName, dracoArray);
+      const intArray = getInt32Array(dracoArray);
+      return {
+        int: this.metadataQuerier.GetIntEntry(dracoMetadata, entryName),
+        string: this.metadataQuerier.GetStringEntry(dracoMetadata, entryName),
+        double: this.metadataQuerier.GetDoubleEntry(dracoMetadata, entryName),
+        intArray
+      };
+    } finally {
+      this.draco.destroy(dracoArray);
+    }
+  }
+  // QUANTIZED ATTRIBUTE SUPPORT (NO DECOMPRESSION)
+  /** Skip transforms for specific attribute types */
+  _disableAttributeTransforms(options) {
+    const { quantizedAttributes = [], octahedronAttributes = [] } = options;
+    const skipAttributes = [...quantizedAttributes, ...octahedronAttributes];
+    for (const dracoAttributeName of skipAttributes) {
+      this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);
+    }
+  }
+  /**
+   * Extract (and apply?) Position Transform
+   * @todo not used
+   */
+  _getQuantizationTransform(dracoAttribute, options) {
+    const { quantizedAttributes = [] } = options;
+    const attribute_type = dracoAttribute.attribute_type();
+    const skip = quantizedAttributes.map((type) => this.draco[type]).includes(attribute_type);
+    if (skip) {
+      const transform = new this.draco.AttributeQuantizationTransform();
+      try {
+        if (transform.InitFromAttribute(dracoAttribute)) {
+          return {
+            quantization_bits: transform.quantization_bits(),
+            range: transform.range(),
+            min_values: Float32Array.from(
+              { length: dracoAttribute.num_components() },
+              (_, componentIndex) => transform.min_value(componentIndex)
+            )
+          };
+        }
+      } finally {
+        this.draco.destroy(transform);
+      }
+    }
+    return null;
+  }
+  _getOctahedronTransform(dracoAttribute, options) {
+    const { octahedronAttributes = [] } = options;
+    const attribute_type = dracoAttribute.attribute_type();
+    const octahedron = octahedronAttributes.map((type) => this.draco[type]).includes(attribute_type);
+    if (octahedron) {
+      const transform = new this.draco.AttributeOctahedronTransform();
+      try {
+        if (transform.InitFromAttribute(dracoAttribute)) {
+          return {
+            quantization_bits: transform.quantization_bits()
+          };
+        }
+      } finally {
+        this.draco.destroy(transform);
+      }
+    }
+    return null;
+  }
+  // HELPERS
+};
+function getDracoDataType(draco, attributeType) {
+  switch (attributeType) {
+    case Float32Array:
+      return draco.DT_FLOAT32;
+    case Int8Array:
+      return draco.DT_INT8;
+    case Int16Array:
+      return draco.DT_INT16;
+    case Int32Array:
+      return draco.DT_INT32;
+    case Uint8Array:
+      return draco.DT_UINT8;
+    case Uint16Array:
+      return draco.DT_UINT16;
+    case Uint32Array:
+      return draco.DT_UINT32;
+    default:
+      return draco.DT_INVALID;
+  }
+}
+function getInt32Array(dracoArray) {
+  const numValues = dracoArray.size();
+  const intArray = new Int32Array(numValues);
+  for (let i = 0; i < numValues; i++) {
+    intArray[i] = dracoArray.GetValue(i);
+  }
+  return intArray;
+}
+function getUint32Array(dracoArray) {
+  const numValues = dracoArray.size();
+  const intArray = new Uint32Array(numValues);
+  for (let i = 0; i < numValues; i++) {
+    intArray[i] = dracoArray.GetValue(i);
+  }
+  return intArray;
+}
+function getUniqueAttributeName(attributeName, attributes) {
+  if (!Object.prototype.hasOwnProperty.call(attributes, attributeName)) {
+    return attributeName;
+  }
+  const suffixMatch = /^(.*)_([0-9]+)$/.exec(attributeName);
+  const baseName = suffixMatch ? suffixMatch[1] : attributeName;
+  let suffix = suffixMatch ? BigInt(suffixMatch[2]) + 1n : 1n;
+  while (Object.prototype.hasOwnProperty.call(attributes, `${baseName}_${suffix}`)) {
+    suffix++;
+  }
+  return `${baseName}_${suffix}`;
+}
+function getMeshAttributeTransform(attribute) {
+  if (attribute.quantization_transform) {
+    const { quantization_bits, min_values, range } = attribute.quantization_transform;
+    if (quantization_bits !== void 0 && min_values && range !== void 0) {
+      return {
+        type: "quantization",
+        bits: quantization_bits,
+        origin: Array.from(min_values),
+        range
+      };
+    }
+  }
+  if (attribute.octahedron_transform?.quantization_bits !== void 0) {
+    return {
+      type: "octahedron",
+      bits: attribute.octahedron_transform.quantization_bits
+    };
+  }
+  return void 0;
+}
+function validateAttributeSelection(options) {
+  if (options.includeAttributes && options.excludeAttributes) {
+    throw new Error("DracoLoader: includeAttributes and excludeAttributes cannot be combined");
+  }
+}
+function validateSelectedAttributeNames(options, attributeNames) {
+  for (const attributeName of options.includeAttributes || options.excludeAttributes || []) {
+    if (!attributeNames.includes(attributeName)) {
+      throw new Error(`DracoLoader: selected attribute "${attributeName}" does not exist`);
+    }
+  }
+}
+function getTransformedMeshBoundingBox(attributes) {
+  const boundingBox = (0, import_schema_utils.getMeshBoundingBox)(attributes);
+  if (!boundingBox) throw new Error("Decoded mesh is missing positions");
+  const position = attributes.POSITION;
+  if (position?.transform?.type !== "quantization") {
+    return boundingBox;
+  }
+  const { bits, origin, range } = position.transform;
+  const scale = range / (2 ** bits - 1);
+  return boundingBox.map(
+    (bounds) => bounds.map((value, componentIndex) => origin[componentIndex] + value * scale)
+  );
+}
+//# sourceMappingURL=draco-parser.cjs.map

package/dist/draco/lib/draco-parser.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/draco/lib/draco-parser.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n/* eslint-disable camelcase */\n\nimport {getLoaderLog} from '@loaders.gl/core/loader-utils';\nimport type {\n  TypedArray,\n  TypedArrayConstructor,\n  MeshAttribute,\n  MeshAttributeTransform,\n  MeshGeometry\n} from '@loaders.gl/core/schema';\n\n// Draco types (input)\nimport type {\n  Draco3D,\n  Decoder,\n  Mesh,\n  PointCloud,\n  PointAttribute,\n  Metadata,\n  MetadataQuerier,\n  DracoInt32Array,\n  draco_DataType,\n  Status\n} from '../draco3d/draco3d-types';\n\n// Parsed data types (output)\nimport type {\n  DracoMesh,\n  DracoLoaderData,\n  DracoAttribute,\n  DracoMetadataEntry,\n  DracoQuantizationTransform,\n  DracoOctahedronTransform\n} from './draco-types';\n\nimport {getMeshBoundingBox} from '@loaders.gl/core/schema-utils';\nimport {getDracoSchema} from './utils/get-draco-schema';\n\n/** Options to control draco parsing */\nexport type DracoParseOptions = {\n  /** How triangle indices should be generated (mesh only) */\n  topology?: 'triangle-list' | 'triangle-strip';\n  /** Specify which attribute metadata entry stores the attribute name */\n  attributeNameEntry?: string;\n  /** Names and ids of extra attributes to include in the output */\n  extraAttributes?: {[uniqueId: string]: number};\n  /** Skip transforms specific quantized attributes */\n  quantizedAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];\n  /** Skip transforms specific octahedron encoded  attributes */\n  octahedronAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];\n  /** Application attribute names to extract in addition to the required position attribute. */\n  includeAttributes?: string[];\n  /** Application attribute names to omit. The position attribute cannot be omitted. */\n  excludeAttributes?: string[];\n};\n\n// Native Draco attribute names to GLTF attribute names.\nconst DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {\n  POSITION: 'POSITION',\n  NORMAL: 'NORMAL',\n  COLOR: 'COLOR_0',\n  TEX_COORD: 'TEXCOORD_0'\n};\n\nconst DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {\n  1: Int8Array,\n  2: Uint8Array,\n  3: Int16Array,\n  4: Uint16Array,\n  5: Int32Array,\n  6: Uint32Array,\n  // 7: BigInt64Array,\n  // 8: BigUint64Array,\n  9: Float32Array\n  // 10: Float64Array\n  // 11: BOOL - What array type do we use for this?\n};\n\nconst UINT16_INDEX_ITEM_SIZE = 2;\nconst UINT32_INDEX_ITEM_SIZE = 4;\n\nexport default class DracoParser {\n  draco: Draco3D;\n  decoder: Decoder;\n  metadataQuerier: MetadataQuerier;\n\n  // draco - the draco decoder, either import `draco3d` or load dynamically\n  constructor(\n    draco: Draco3D,\n    private readonly logger = getLoaderLog()\n  ) {\n    this.draco = draco;\n    this.decoder = new this.draco.Decoder();\n    this.metadataQuerier = new this.draco.MetadataQuerier();\n  }\n\n  /**\n   * Destroy draco resources\n   */\n  destroy(): void {\n    this.draco.destroy(this.decoder);\n    this.draco.destroy(this.metadataQuerier);\n  }\n\n  /**\n   * NOTE: caller must call `destroyGeometry` on the return value after using it\n   * @param arrayBuffer\n   * @param options\n   */\n  parseSync(\n    arrayBuffer: ArrayBuffer | ArrayBufferView,\n    options: DracoParseOptions = {}\n  ): DracoMesh {\n    validateAttributeSelection(options);\n    const encodedData = ArrayBuffer.isView(arrayBuffer)\n      ? new Int8Array(arrayBuffer.buffer, arrayBuffer.byteOffset, arrayBuffer.byteLength)\n      : new Int8Array(arrayBuffer);\n\n    this._disableAttributeTransforms(options);\n\n    const geometry_type = this.decoder.GetEncodedGeometryType(encodedData);\n    const dracoGeometry =\n      geometry_type === this.draco.TRIANGULAR_MESH\n        ? new this.draco.Mesh()\n        : new this.draco.PointCloud();\n\n    let dracoStatus: Status | null = null;\n    try {\n      switch (geometry_type) {\n        case this.draco.TRIANGULAR_MESH:\n          dracoStatus = this.decoder.DecodeArrayToMesh(\n            encodedData,\n            encodedData.byteLength,\n            dracoGeometry as Mesh\n          );\n          break;\n\n        case this.draco.POINT_CLOUD:\n          dracoStatus = this.decoder.DecodeArrayToPointCloud(\n            encodedData,\n            encodedData.byteLength,\n            dracoGeometry\n          );\n          break;\n\n        default:\n          throw new Error('DRACO: Unknown geometry type.');\n      }\n\n      if (!dracoStatus.ok() || !dracoGeometry.ptr) {\n        const message = `DRACO decompression failed: ${dracoStatus.error_msg()}`;\n        // console.error(message);\n        throw new Error(message);\n      }\n\n      const loaderData = this._getDracoLoaderData(dracoGeometry, geometry_type, options);\n\n      const geometry = this._getMeshData(dracoGeometry, loaderData, options);\n\n      const boundingBox = getTransformedMeshBoundingBox(geometry.attributes);\n\n      const schema = getDracoSchema(geometry.attributes, loaderData, geometry.indices);\n\n      const data: DracoMesh = {\n        loader: 'draco',\n        loaderData,\n        header: {\n          vertexCount: dracoGeometry.num_points(),\n          boundingBox\n        },\n        ...geometry,\n        schema\n      };\n      return data;\n    } finally {\n      if (dracoStatus) {\n        this.draco.destroy(dracoStatus);\n      }\n      if (dracoGeometry) {\n        this.draco.destroy(dracoGeometry);\n      }\n    }\n  }\n\n  // Draco specific \"loader data\"\n\n  /**\n   * Extract\n   * @param dracoGeometry\n   * @param geometry_type\n   * @param options\n   * @returns\n   */\n  _getDracoLoaderData(\n    dracoGeometry: Mesh | PointCloud,\n    geometry_type,\n    options: DracoParseOptions\n  ): DracoLoaderData {\n    const metadata = this._getTopLevelMetadata(dracoGeometry);\n    const attributes = this._getDracoAttributes(dracoGeometry, options);\n\n    return {\n      geometry_type,\n      num_attributes: dracoGeometry.num_attributes(),\n      num_points: dracoGeometry.num_points(),\n      num_faces: dracoGeometry instanceof this.draco.Mesh ? dracoGeometry.num_faces() : 0,\n      metadata,\n      attributes\n    };\n  }\n\n  /**\n   * Extract all draco provided information and metadata for each attribute\n   * @param dracoGeometry\n   * @param options\n   * @returns\n   */\n  _getDracoAttributes(\n    dracoGeometry: Mesh | PointCloud,\n    options: DracoParseOptions\n  ): {[unique_id: number]: DracoAttribute} {\n    const dracoAttributes: {[unique_id: number]: DracoAttribute} = {};\n\n    for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {\n      // Note: Draco docs do not seem clear on `GetAttribute` ids just being a zero-based index,\n      // but it does seems to work this way\n      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);\n\n      const metadata = this._getAttributeMetadata(dracoGeometry, attributeId);\n\n      dracoAttributes[dracoAttribute.unique_id()] = {\n        unique_id: dracoAttribute.unique_id(),\n        attribute_type: dracoAttribute.attribute_type(),\n        data_type: dracoAttribute.data_type(),\n        num_components: dracoAttribute.num_components(),\n\n        byte_offset: dracoAttribute.byte_offset(),\n        byte_stride: dracoAttribute.byte_stride(),\n        normalized: dracoAttribute.normalized(),\n        attribute_index: attributeId,\n\n        metadata\n      };\n\n      // Add transformation parameters for any attributes app wants untransformed\n      const quantization = this._getQuantizationTransform(dracoAttribute, options);\n      if (quantization) {\n        dracoAttributes[dracoAttribute.unique_id()].quantization_transform = quantization;\n      }\n\n      const octahedron = this._getOctahedronTransform(dracoAttribute, options);\n      if (octahedron) {\n        dracoAttributes[dracoAttribute.unique_id()].octahedron_transform = octahedron;\n      }\n    }\n\n    return dracoAttributes;\n  }\n\n  /**\n   * Get standard loaders.gl mesh category data\n   * Extracts the geometry from draco\n   * @param dracoGeometry\n   * @param options\n   */\n  _getMeshData(\n    dracoGeometry: Mesh | PointCloud,\n    loaderData: DracoLoaderData,\n    options: DracoParseOptions\n  ): MeshGeometry {\n    const attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);\n\n    const positionAttribute = attributes.POSITION;\n    if (!positionAttribute) {\n      throw new Error('DRACO: No position attribute found.');\n    }\n\n    // For meshes, we need indices to define the faces.\n    if (dracoGeometry instanceof this.draco.Mesh) {\n      switch (options.topology) {\n        case 'triangle-strip':\n          return {\n            topology: 'triangle-strip',\n            mode: 5, // GL.TRIANGLE_STRIP\n            attributes,\n            indices: {\n              value: this._getTriangleStripIndices(dracoGeometry),\n              size: 1\n            }\n          };\n        case 'triangle-list':\n        default:\n          return {\n            topology: 'triangle-list',\n            mode: 4, // GL.TRIANGLES\n            attributes,\n            indices: {\n              value: this._getTriangleListIndices(dracoGeometry),\n              size: 1\n            }\n          };\n      }\n    }\n\n    // PointCloud - must come last as Mesh inherits from PointCloud\n    return {\n      topology: 'point-list',\n      mode: 0, // GL.POINTS\n      attributes\n    };\n  }\n\n  _getMeshAttributes(\n    loaderData: DracoLoaderData,\n    dracoGeometry: Mesh | PointCloud,\n    options: DracoParseOptions\n  ): {[attributeName: string]: MeshAttribute} {\n    const attributes: {[key: string]: MeshAttribute} = {};\n    const usedAttributeNames: Record<string, unknown> = {};\n\n    const loaderAttributes = Object.values(loaderData.attributes).sort(\n      (left, right) => left.attribute_index - right.attribute_index\n    );\n    const namedAttributes = loaderAttributes.map(loaderAttribute => {\n      const deducedAttributeName = this._deduceAttributeName(loaderAttribute, options);\n      const attributeName = getUniqueAttributeName(deducedAttributeName, usedAttributeNames);\n      usedAttributeNames[attributeName] = true;\n      loaderAttribute.name = attributeName;\n      return {attributeName, loaderAttribute};\n    });\n    validateSelectedAttributeNames(options, Object.keys(usedAttributeNames));\n\n    for (const {attributeName, loaderAttribute} of namedAttributes) {\n      if (!this._shouldExtractAttribute(attributeName, loaderAttribute, options)) {\n        continue;\n      }\n      const values = this._getAttributeValues(dracoGeometry, loaderAttribute);\n      if (values) {\n        const {value, size} = values;\n        attributes[attributeName] = {\n          value,\n          size,\n          byteOffset: loaderAttribute.byte_offset,\n          byteStride: loaderAttribute.byte_stride,\n          normalized: loaderAttribute.normalized,\n          transform: getMeshAttributeTransform(loaderAttribute)\n        };\n      }\n    }\n\n    return attributes;\n  }\n\n  /** Returns true when an attribute should be copied from WASM into the requested output. */\n  _shouldExtractAttribute(\n    attributeName: string,\n    attribute: DracoAttribute,\n    options: DracoParseOptions\n  ): boolean {\n    if (attribute.attribute_type === this.draco.POSITION) {\n      if (options.excludeAttributes?.includes(attributeName)) {\n        throw new Error(`DracoLoader: position attribute \"${attributeName}\" cannot be excluded`);\n      }\n      return true;\n    }\n    if (options.includeAttributes && !options.includeAttributes.includes(attributeName)) {\n      return false;\n    }\n    return !options.excludeAttributes?.includes(attributeName);\n  }\n\n  // MESH INDICES EXTRACTION\n\n  /**\n   * For meshes, we need indices to define the faces.\n   * @param dracoGeometry\n   */\n  _getTriangleListIndices(dracoGeometry: Mesh): Uint16Array | Uint32Array {\n    // Example on how to retrieve mesh and attributes.\n    const numFaces = dracoGeometry.num_faces();\n    const numIndices = numFaces * 3;\n    const useUint16 = dracoGeometry.num_points() <= 65536;\n    const byteLength = numIndices * (useUint16 ? UINT16_INDEX_ITEM_SIZE : UINT32_INDEX_ITEM_SIZE);\n\n    const ptr = this.draco._malloc(byteLength);\n    try {\n      if (useUint16) {\n        const decoded = this.decoder.GetTrianglesUInt16Array(dracoGeometry, byteLength, ptr);\n        if (!decoded) {\n          throw new Error('DRACO: Failed to decode triangle indices.');\n        }\n        return new Uint16Array(this.draco.HEAPU8.buffer, ptr, numIndices).slice();\n      }\n      const decoded = this.decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);\n      if (!decoded) {\n        throw new Error('DRACO: Failed to decode triangle indices.');\n      }\n      return new Uint32Array(this.draco.HEAPU8.buffer, ptr, numIndices).slice();\n    } finally {\n      this.draco._free(ptr);\n    }\n  }\n\n  /**\n   * For meshes, we need indices to define the faces.\n   * @param dracoGeometry\n   */\n  _getTriangleStripIndices(dracoGeometry: Mesh) {\n    const dracoArray = new this.draco.DracoInt32Array();\n    try {\n      /* const numStrips = */ this.decoder.GetTriangleStripsFromMesh(dracoGeometry, dracoArray);\n      return getUint32Array(dracoArray);\n    } finally {\n      this.draco.destroy(dracoArray);\n    }\n  }\n\n  /**\n   *\n   * @param dracoGeometry\n   * @param dracoAttribute\n   * @param attributeName\n   */\n  _getAttributeValues(\n    dracoGeometry: Mesh | PointCloud,\n    attribute: DracoAttribute\n  ): {value: TypedArray; size: number} | null {\n    const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];\n    if (!TypedArrayCtor) {\n      this.logger.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`)();\n      return null;\n    }\n    const numComponents = attribute.num_components;\n    const numPoints = dracoGeometry.num_points();\n    const numValues = numPoints * numComponents;\n\n    const byteLength = numValues * TypedArrayCtor.BYTES_PER_ELEMENT;\n    const dataType = getDracoDataType(this.draco, TypedArrayCtor);\n\n    let value: TypedArray;\n\n    const ptr = this.draco._malloc(byteLength);\n    try {\n      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attribute.attribute_index);\n      const decoded = this.decoder.GetAttributeDataArrayForAllPoints(\n        dracoGeometry,\n        dracoAttribute,\n        dataType,\n        byteLength,\n        ptr\n      );\n      if (!decoded) {\n        throw new Error(`DRACO: Failed to decode attribute ${attribute.unique_id}.`);\n      }\n      value = new TypedArrayCtor(this.draco.HEAPU8.buffer, ptr, numValues).slice();\n    } finally {\n      this.draco._free(ptr);\n    }\n\n    return {value, size: numComponents};\n  }\n\n  // Attribute names\n\n  /** \n   * DRACO does not store attribute names - We need to deduce an attribute name\n   * for each attribute\n  _getAttributeNames(\n    dracoGeometry: Mesh | PointCloud,\n    options: DracoParseOptions\n  ): {[unique_id: number]: string} {\n    const attributeNames: {[unique_id: number]: string} = {};\n    for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {\n      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);\n      const attributeName = this._deduceAttributeName(dracoAttribute, options);\n      attributeNames[attributeName] = attributeName;\n    }\n    return attributeNames;\n  }\n   */\n\n  /**\n   * Deduce an attribute name.\n   * @note DRACO does not save attribute names, just general type (POSITION, COLOR)\n   * to help optimize compression. We generate GLTF compatible names for the Draco-recognized\n   * types\n   * @param attributeData\n   */\n  _deduceAttributeName(attribute: DracoAttribute, options: DracoParseOptions): string {\n    // Deduce name based on application provided map\n    const uniqueId = attribute.unique_id;\n    for (const [attributeName, attributeUniqueId] of Object.entries(\n      options.extraAttributes || {}\n    )) {\n      if (attributeUniqueId === uniqueId) {\n        return attributeName;\n      }\n    }\n\n    // Prefer the application name preserved by a Draco writer.\n    const entryName = options.attributeNameEntry || 'name';\n    if (attribute.metadata[entryName]) {\n      const attributeName = attribute.metadata[entryName].string;\n      // DracoWriter versions before v5 stored these category names instead of glTF semantics.\n      if (attributeName === 'COLOR') {\n        return 'COLOR_0';\n      }\n      if (attributeName === 'TEX_COORD') {\n        return 'TEXCOORD_0';\n      }\n      return attributeName;\n    }\n\n    // Deduce name based on attribute type\n    const thisAttributeType = attribute.attribute_type;\n    for (const dracoAttributeConstant in DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP) {\n      const attributeType = this.draco[dracoAttributeConstant];\n      if (attributeType === thisAttributeType) {\n        // TODO - Return unique names if there multiple attributes per type\n        // (e.g. multiple TEX_COORDS or COLORS)\n        return DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP[dracoAttributeConstant];\n      }\n    }\n\n    // Attribute of \"GENERIC\" type, we need to assign some name\n    return `CUSTOM_ATTRIBUTE_${uniqueId}`;\n  }\n\n  // METADATA EXTRACTION\n\n  /** Get top level metadata */\n  _getTopLevelMetadata(dracoGeometry: Mesh | PointCloud) {\n    const dracoMetadata = this.decoder.GetMetadata(dracoGeometry);\n    return this._getDracoMetadata(dracoMetadata);\n  }\n\n  /** Get per attribute metadata */\n  _getAttributeMetadata(dracoGeometry: Mesh | PointCloud, attributeId: number) {\n    const dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);\n    return this._getDracoMetadata(dracoMetadata);\n  }\n\n  /**\n   * Extract metadata field values\n   * @param dracoMetadata\n   * @returns\n   */\n  _getDracoMetadata(dracoMetadata: Metadata): {[entry: string]: DracoMetadataEntry} {\n    // The not so wonderful world of undocumented Draco APIs :(\n    if (!dracoMetadata || !dracoMetadata.ptr) {\n      return {};\n    }\n    const result = {};\n    const numEntries = this.metadataQuerier.NumEntries(dracoMetadata);\n    for (let entryIndex = 0; entryIndex < numEntries; entryIndex++) {\n      const entryName = this.metadataQuerier.GetEntryName(dracoMetadata, entryIndex);\n      result[entryName] = this._getDracoMetadataField(dracoMetadata, entryName);\n    }\n    return result;\n  }\n\n  /**\n   * Extracts possible values for one metadata entry by name\n   * @param dracoMetadata\n   * @param entryName\n   */\n  _getDracoMetadataField(dracoMetadata: Metadata, entryName: string): DracoMetadataEntry {\n    const dracoArray = new this.draco.DracoInt32Array();\n    try {\n      // Draco metadata fields can hold int32 arrays\n      this.metadataQuerier.GetIntEntryArray(dracoMetadata, entryName, dracoArray);\n      const intArray = getInt32Array(dracoArray);\n      return {\n        int: this.metadataQuerier.GetIntEntry(dracoMetadata, entryName),\n        string: this.metadataQuerier.GetStringEntry(dracoMetadata, entryName),\n        double: this.metadataQuerier.GetDoubleEntry(dracoMetadata, entryName),\n        intArray\n      };\n    } finally {\n      this.draco.destroy(dracoArray);\n    }\n  }\n\n  // QUANTIZED ATTRIBUTE SUPPORT (NO DECOMPRESSION)\n\n  /** Skip transforms for specific attribute types */\n  _disableAttributeTransforms(options: DracoParseOptions) {\n    const {quantizedAttributes = [], octahedronAttributes = []} = options;\n    const skipAttributes = [...quantizedAttributes, ...octahedronAttributes];\n    for (const dracoAttributeName of skipAttributes) {\n      this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);\n    }\n  }\n\n  /**\n   * Extract (and apply?) Position Transform\n   * @todo not used\n   */\n  _getQuantizationTransform(\n    dracoAttribute: PointAttribute,\n    options: DracoParseOptions\n  ): DracoQuantizationTransform | null {\n    const {quantizedAttributes = []} = options;\n    const attribute_type = dracoAttribute.attribute_type();\n    const skip = quantizedAttributes.map(type => this.draco[type]).includes(attribute_type);\n    if (skip) {\n      const transform = new this.draco.AttributeQuantizationTransform();\n      try {\n        if (transform.InitFromAttribute(dracoAttribute)) {\n          return {\n            quantization_bits: transform.quantization_bits(),\n            range: transform.range(),\n            min_values: Float32Array.from(\n              {length: dracoAttribute.num_components()},\n              (_, componentIndex) => transform.min_value(componentIndex)\n            )\n          };\n        }\n      } finally {\n        this.draco.destroy(transform);\n      }\n    }\n    return null;\n  }\n\n  _getOctahedronTransform(\n    dracoAttribute: PointAttribute,\n    options: DracoParseOptions\n  ): DracoOctahedronTransform | null {\n    const {octahedronAttributes = []} = options;\n    const attribute_type = dracoAttribute.attribute_type();\n    const octahedron = octahedronAttributes.map(type => this.draco[type]).includes(attribute_type);\n    if (octahedron) {\n      const transform = new this.draco.AttributeOctahedronTransform();\n      try {\n        if (transform.InitFromAttribute(dracoAttribute)) {\n          return {\n            quantization_bits: transform.quantization_bits()\n          };\n        }\n      } finally {\n        this.draco.destroy(transform);\n      }\n    }\n    return null;\n  }\n\n  // HELPERS\n}\n\n/**\n * Get draco specific data type by TypedArray constructor type\n * @param attributeType\n * @returns draco specific data type\n */\nfunction getDracoDataType(draco: Draco3D, attributeType: TypedArrayConstructor): draco_DataType {\n  switch (attributeType) {\n    case Float32Array:\n      return draco.DT_FLOAT32;\n    case Int8Array:\n      return draco.DT_INT8;\n    case Int16Array:\n      return draco.DT_INT16;\n    case Int32Array:\n      return draco.DT_INT32;\n    case Uint8Array:\n      return draco.DT_UINT8;\n    case Uint16Array:\n      return draco.DT_UINT16;\n    case Uint32Array:\n      return draco.DT_UINT32;\n    default:\n      return draco.DT_INVALID;\n  }\n}\n\n/**\n * Copy a Draco int32 array into a JS typed array\n */\nfunction getInt32Array(dracoArray: DracoInt32Array): Int32Array {\n  const numValues = dracoArray.size();\n  const intArray = new Int32Array(numValues);\n  for (let i = 0; i < numValues; i++) {\n    intArray[i] = dracoArray.GetValue(i);\n  }\n  return intArray;\n}\n\n/**\n * Copy a Draco int32 array into a JS typed array\n */\nfunction getUint32Array(dracoArray: DracoInt32Array): Uint32Array {\n  const numValues = dracoArray.size();\n  const intArray = new Uint32Array(numValues);\n  for (let i = 0; i < numValues; i++) {\n    intArray[i] = dracoArray.GetValue(i);\n  }\n  return intArray;\n}\n\n/** Returns a collision-free output name without discarding an earlier decoded attribute. */\nfunction getUniqueAttributeName(\n  attributeName: string,\n  attributes: Record<string, unknown>\n): string {\n  if (!Object.prototype.hasOwnProperty.call(attributes, attributeName)) {\n    return attributeName;\n  }\n\n  const suffixMatch = /^(.*)_([0-9]+)$/.exec(attributeName);\n  const baseName = suffixMatch ? suffixMatch[1] : attributeName;\n  let suffix = suffixMatch ? BigInt(suffixMatch[2]) + 1n : 1n;\n  while (Object.prototype.hasOwnProperty.call(attributes, `${baseName}_${suffix}`)) {\n    suffix++;\n  }\n  return `${baseName}_${suffix}`;\n}\n\n/** Converts Draco-specific transform metadata into the shared Mesh attribute representation. */\nfunction getMeshAttributeTransform(attribute: DracoAttribute): MeshAttributeTransform | undefined {\n  if (attribute.quantization_transform) {\n    const {quantization_bits, min_values, range} = attribute.quantization_transform;\n    if (quantization_bits !== undefined && min_values && range !== undefined) {\n      return {\n        type: 'quantization',\n        bits: quantization_bits,\n        origin: Array.from(min_values),\n        range\n      };\n    }\n  }\n  if (attribute.octahedron_transform?.quantization_bits !== undefined) {\n    return {\n      type: 'octahedron',\n      bits: attribute.octahedron_transform.quantization_bits\n    };\n  }\n  return undefined;\n}\n\n/** Validates mutually exclusive attribute selection options. */\nfunction validateAttributeSelection(options: DracoParseOptions): void {\n  if (options.includeAttributes && options.excludeAttributes) {\n    throw new Error('DracoLoader: includeAttributes and excludeAttributes cannot be combined');\n  }\n}\n\n/** Rejects selection entries that do not match decoded application attribute names. */\nfunction validateSelectedAttributeNames(\n  options: DracoParseOptions,\n  attributeNames: string[]\n): void {\n  for (const attributeName of options.includeAttributes || options.excludeAttributes || []) {\n    if (!attributeNames.includes(attributeName)) {\n      throw new Error(`DracoLoader: selected attribute \"${attributeName}\" does not exist`);\n    }\n  }\n}\n\n/** Returns a logical bounding box when quantized positions remain encoded. */\nfunction getTransformedMeshBoundingBox(\n  attributes: Record<string, MeshAttribute>\n): [number[], number[]] {\n  const boundingBox = getMeshBoundingBox(attributes);\n  if (!boundingBox) throw new Error('Decoded mesh is missing positions');\n  const position = attributes.POSITION;\n  if (position?.transform?.type !== 'quantization') {\n    return boundingBox;\n  }\n  const {bits, origin, range} = position.transform;\n  const scale = range / (2 ** bits - 1);\n  return boundingBox.map(bounds =>\n    bounds.map((value, componentIndex) => origin[componentIndex] + value * scale)\n  ) as [number[], number[]];\n}\n"],
+  "mappings": "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",
+  "names": ["decoded"]
+}