@loaders.gl/draco 3.1.0-beta.7 → 3.1.3

package/dist/es5/lib/draco-parser.js

@@ -7,23 +7,41 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _schema = require("@loaders.gl/schema");
 
 var _getDracoSchema = require("./utils/get-draco-schema");
 
-const GEOMETRY_TYPE = {
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var GEOMETRY_TYPE = {
   TRIANGULAR_MESH: 0,
   POINT_CLOUD: 1
 };
-const DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {
+var DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {
   POSITION: 'POSITION',
   NORMAL: 'NORMAL',
   COLOR: 'COLOR_0',
   TEX_COORD: 'TEXCOORD_0'
 };
-const DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {
+var DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {
   1: Int8Array,
   2: Uint8Array,
   3: Int16Array,
@@ -32,10 +50,11 @@ const DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {
   6: Uint32Array,
   9: Float32Array
 };
-const INDEX_ITEM_SIZE = 4;
+var INDEX_ITEM_SIZE = 4;
 
-class DracoParser {
-  constructor(draco) {
+var DracoParser = function () {
+  function DracoParser(draco) {
+    (0, _classCallCheck2.default)(this, DracoParser);
     (0, _defineProperty2.default)(this, "draco", void 0);
     (0, _defineProperty2.default)(this, "decoder", void 0);
     (0, _defineProperty2.default)(this, "metadataQuerier", void 0);
@@ -44,371 +63,416 @@ class DracoParser {
     this.metadataQuerier = new this.draco.MetadataQuerier();
   }
 
-  destroy() {
-    this.draco.destroy(this.decoder);
-    this.draco.destroy(this.metadataQuerier);
-  }
-
-  parseSync(arrayBuffer, options = {}) {
-    const buffer = new this.draco.DecoderBuffer();
-    buffer.Init(new Int8Array(arrayBuffer), arrayBuffer.byteLength);
+  (0, _createClass2.default)(DracoParser, [{
+    key: "destroy",
+    value: function destroy() {
+      this.draco.destroy(this.decoder);
+      this.draco.destroy(this.metadataQuerier);
+    }
+  }, {
+    key: "parseSync",
+    value: function parseSync(arrayBuffer) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var buffer = new this.draco.DecoderBuffer();
+      buffer.Init(new Int8Array(arrayBuffer), arrayBuffer.byteLength);
 
-    this._disableAttributeTransforms(options);
+      this._disableAttributeTransforms(options);
 
-    const geometry_type = this.decoder.GetEncodedGeometryType(buffer);
-    const dracoGeometry = geometry_type === this.draco.TRIANGULAR_MESH ? new this.draco.Mesh() : new this.draco.PointCloud();
+      var geometry_type = this.decoder.GetEncodedGeometryType(buffer);
+      var dracoGeometry = geometry_type === this.draco.TRIANGULAR_MESH ? new this.draco.Mesh() : new this.draco.PointCloud();
 
-    try {
-      let dracoStatus;
+      try {
+        var dracoStatus;
 
-      switch (geometry_type) {
-        case this.draco.TRIANGULAR_MESH:
-          dracoStatus = this.decoder.DecodeBufferToMesh(buffer, dracoGeometry);
-          break;
+        switch (geometry_type) {
+          case this.draco.TRIANGULAR_MESH:
+            dracoStatus = this.decoder.DecodeBufferToMesh(buffer, dracoGeometry);
+            break;
 
-        case this.draco.POINT_CLOUD:
-          dracoStatus = this.decoder.DecodeBufferToPointCloud(buffer, dracoGeometry);
-          break;
+          case this.draco.POINT_CLOUD:
+            dracoStatus = this.decoder.DecodeBufferToPointCloud(buffer, dracoGeometry);
+            break;
 
-        default:
-          throw new Error('DRACO: Unknown geometry type.');
-      }
+          default:
+            throw new Error('DRACO: Unknown geometry type.');
+        }
 
-      if (!dracoStatus.ok() || !dracoGeometry.ptr) {
-        const message = "DRACO decompression failed: ".concat(dracoStatus.error_msg());
-        throw new Error(message);
-      }
+        if (!dracoStatus.ok() || !dracoGeometry.ptr) {
+          var message = "DRACO decompression failed: ".concat(dracoStatus.error_msg());
+          throw new Error(message);
+        }
 
-      const loaderData = this._getDracoLoaderData(dracoGeometry, geometry_type, options);
-
-      const geometry = this._getMeshData(dracoGeometry, loaderData, options);
-
-      const boundingBox = (0, _schema.getMeshBoundingBox)(geometry.attributes);
-      const schema = (0, _getDracoSchema.getDracoSchema)(geometry.attributes, loaderData, geometry.indices);
-      const data = {
-        loader: 'draco',
-        loaderData,
-        header: {
-          vertexCount: dracoGeometry.num_points(),
-          boundingBox
-        },
-        ...geometry,
-        schema
-      };
-      return data;
-    } finally {
-      this.draco.destroy(buffer);
+        var loaderData = this._getDracoLoaderData(dracoGeometry, geometry_type, options);
 
-      if (dracoGeometry) {
-        this.draco.destroy(dracoGeometry);
-      }
-    }
-  }
+        var geometry = this._getMeshData(dracoGeometry, loaderData, options);
 
-  _getDracoLoaderData(dracoGeometry, geometry_type, options) {
-    const metadata = this._getTopLevelMetadata(dracoGeometry);
+        var boundingBox = (0, _schema.getMeshBoundingBox)(geometry.attributes);
+        var schema = (0, _getDracoSchema.getDracoSchema)(geometry.attributes, loaderData, geometry.indices);
 
-    const attributes = this._getDracoAttributes(dracoGeometry, options);
+        var data = _objectSpread(_objectSpread({
+          loader: 'draco',
+          loaderData: loaderData,
+          header: {
+            vertexCount: dracoGeometry.num_points(),
+            boundingBox: boundingBox
+          }
+        }, geometry), {}, {
+          schema: schema
+        });
 
-    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
-    };
-  }
-
-  _getDracoAttributes(dracoGeometry, options) {
-    const dracoAttributes = {};
+        return data;
+      } finally {
+        this.draco.destroy(buffer);
 
-    for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
-      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
+        if (dracoGeometry) {
+          this.draco.destroy(dracoGeometry);
+        }
+      }
+    }
+  }, {
+    key: "_getDracoLoaderData",
+    value: function _getDracoLoaderData(dracoGeometry, geometry_type, options) {
+      var metadata = this._getTopLevelMetadata(dracoGeometry);
 
-      const metadata = this._getAttributeMetadata(dracoGeometry, attributeId);
+      var attributes = this._getDracoAttributes(dracoGeometry, options);
 
-      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
+      return {
+        geometry_type: geometry_type,
+        num_attributes: dracoGeometry.num_attributes(),
+        num_points: dracoGeometry.num_points(),
+        num_faces: dracoGeometry instanceof this.draco.Mesh ? dracoGeometry.num_faces() : 0,
+        metadata: metadata,
+        attributes: attributes
       };
+    }
+  }, {
+    key: "_getDracoAttributes",
+    value: function _getDracoAttributes(dracoGeometry, options) {
+      var dracoAttributes = {};
+
+      for (var attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
+        var dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
+
+        var 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: metadata
+        };
+
+        var quantization = this._getQuantizationTransform(dracoAttribute, options);
+
+        if (quantization) {
+          dracoAttributes[dracoAttribute.unique_id()].quantization_transform = quantization;
+        }
 
-      const quantization = this._getQuantizationTransform(dracoAttribute, options);
+        var octahedron = this._getOctahedronTransform(dracoAttribute, options);
 
-      if (quantization) {
-        dracoAttributes[dracoAttribute.unique_id()].quantization_transform = quantization;
+        if (octahedron) {
+          dracoAttributes[dracoAttribute.unique_id()].octahedron_transform = octahedron;
+        }
       }
 
-      const octahedron = this._getOctahedronTransform(dracoAttribute, options);
-
-      if (octahedron) {
-        dracoAttributes[dracoAttribute.unique_id()].octahedron_transform = octahedron;
-      }
+      return dracoAttributes;
     }
+  }, {
+    key: "_getMeshData",
+    value: function _getMeshData(dracoGeometry, loaderData, options) {
+      var attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);
 
-    return dracoAttributes;
-  }
-
-  _getMeshData(dracoGeometry, loaderData, options) {
-    const attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);
-
-    const positionAttribute = attributes.POSITION;
+      var 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: 4,
-            attributes,
-            indices: {
-              value: this._getTriangleStripIndices(dracoGeometry),
-              size: 1
-            }
-          };
-
-        case 'triangle-list':
-        default:
-          return {
-            topology: 'triangle-list',
-            mode: 5,
-            attributes,
-            indices: {
-              value: this._getTriangleListIndices(dracoGeometry),
-              size: 1
-            }
-          };
+      if (!positionAttribute) {
+        throw new Error('DRACO: No position attribute found.');
       }
-    }
 
-    return {
-      topology: 'point-list',
-      mode: 0,
-      attributes
-    };
-  }
-
-  _getMeshAttributes(loaderData, dracoGeometry, options) {
-    const attributes = {};
-
-    for (const loaderAttribute of Object.values(loaderData.attributes)) {
-      const attributeName = this._deduceAttributeName(loaderAttribute, options);
-
-      loaderAttribute.name = attributeName;
-
-      const {
-        value,
-        size
-      } = this._getAttributeValues(dracoGeometry, loaderAttribute);
+      if (dracoGeometry instanceof this.draco.Mesh) {
+        switch (options.topology) {
+          case 'triangle-strip':
+            return {
+              topology: 'triangle-strip',
+              mode: 4,
+              attributes: attributes,
+              indices: {
+                value: this._getTriangleStripIndices(dracoGeometry),
+                size: 1
+              }
+            };
+
+          case 'triangle-list':
+          default:
+            return {
+              topology: 'triangle-list',
+              mode: 5,
+              attributes: attributes,
+              indices: {
+                value: this._getTriangleListIndices(dracoGeometry),
+                size: 1
+              }
+            };
+        }
+      }
 
-      attributes[attributeName] = {
-        value,
-        size,
-        byteOffset: loaderAttribute.byte_offset,
-        byteStride: loaderAttribute.byte_stride,
-        normalized: loaderAttribute.normalized
+      return {
+        topology: 'point-list',
+        mode: 0,
+        attributes: attributes
       };
     }
+  }, {
+    key: "_getMeshAttributes",
+    value: function _getMeshAttributes(loaderData, dracoGeometry, options) {
+      var attributes = {};
 
-    return attributes;
-  }
-
-  _getTriangleListIndices(dracoGeometry) {
-    const numFaces = dracoGeometry.num_faces();
-    const numIndices = numFaces * 3;
-    const byteLength = numIndices * INDEX_ITEM_SIZE;
+      for (var _i = 0, _Object$values = Object.values(loaderData.attributes); _i < _Object$values.length; _i++) {
+        var loaderAttribute = _Object$values[_i];
 
-    const ptr = this.draco._malloc(byteLength);
+        var _attributeName = this._deduceAttributeName(loaderAttribute, options);
 
-    try {
-      this.decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
-      return new Uint32Array(this.draco.HEAPF32.buffer, ptr, numIndices).slice();
-    } finally {
-      this.draco._free(ptr);
-    }
-  }
+        loaderAttribute.name = _attributeName;
 
-  _getTriangleStripIndices(dracoGeometry) {
-    const dracoArray = new this.draco.DracoInt32Array();
+        var _this$_getAttributeVa = this._getAttributeValues(dracoGeometry, loaderAttribute),
+            value = _this$_getAttributeVa.value,
+            size = _this$_getAttributeVa.size;
 
-    try {
-      this.decoder.GetTriangleStripsFromMesh(dracoGeometry, dracoArray);
-      return getUint32Array(dracoArray);
-    } finally {
-      this.draco.destroy(dracoArray);
-    }
-  }
+        attributes[_attributeName] = {
+          value: value,
+          size: size,
+          byteOffset: loaderAttribute.byte_offset,
+          byteStride: loaderAttribute.byte_stride,
+          normalized: loaderAttribute.normalized
+        };
+      }
 
-  _getAttributeValues(dracoGeometry, attribute) {
-    const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
-    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);
-      this.decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, dracoAttribute, dataType, byteLength, ptr);
-      value = new TypedArrayCtor(this.draco.HEAPF32.buffer, ptr, numValues).slice();
-    } finally {
-      this.draco._free(ptr);
+      return attributes;
     }
+  }, {
+    key: "_getTriangleListIndices",
+    value: function _getTriangleListIndices(dracoGeometry) {
+      var numFaces = dracoGeometry.num_faces();
+      var numIndices = numFaces * 3;
+      var byteLength = numIndices * INDEX_ITEM_SIZE;
 
-    return {
-      value,
-      size: numComponents
-    };
-  }
-
-  _deduceAttributeName(attribute, options) {
-    const uniqueId = attribute.unique_id;
+      var ptr = this.draco._malloc(byteLength);
 
-    for (const [attributeName, attributeUniqueId] of Object.entries(options.extraAttributes || {})) {
-      if (attributeUniqueId === uniqueId) {
-        return attributeName;
+      try {
+        this.decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
+        return new Uint32Array(this.draco.HEAPF32.buffer, ptr, numIndices).slice();
+      } finally {
+        this.draco._free(ptr);
       }
     }
+  }, {
+    key: "_getTriangleStripIndices",
+    value: function _getTriangleStripIndices(dracoGeometry) {
+      var dracoArray = new this.draco.DracoInt32Array();
 
-    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];
+      try {
+        this.decoder.GetTriangleStripsFromMesh(dracoGeometry, dracoArray);
+        return getUint32Array(dracoArray);
+      } finally {
+        this.draco.destroy(dracoArray);
       }
     }
+  }, {
+    key: "_getAttributeValues",
+    value: function _getAttributeValues(dracoGeometry, attribute) {
+      var TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
+      var numComponents = attribute.num_components;
+      var numPoints = dracoGeometry.num_points();
+      var numValues = numPoints * numComponents;
+      var byteLength = numValues * TypedArrayCtor.BYTES_PER_ELEMENT;
+      var dataType = getDracoDataType(this.draco, TypedArrayCtor);
+      var value;
+
+      var ptr = this.draco._malloc(byteLength);
 
-    const entryName = options.attributeNameEntry || 'name';
+      try {
+        var dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attribute.attribute_index);
+        this.decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, dracoAttribute, dataType, byteLength, ptr);
+        value = new TypedArrayCtor(this.draco.HEAPF32.buffer, ptr, numValues).slice();
+      } finally {
+        this.draco._free(ptr);
+      }
 
-    if (attribute.metadata[entryName]) {
-      return attribute.metadata[entryName].string;
+      return {
+        value: value,
+        size: numComponents
+      };
     }
+  }, {
+    key: "_deduceAttributeName",
+    value: function _deduceAttributeName(attribute, options) {
+      var uniqueId = attribute.unique_id;
+
+      for (var _i2 = 0, _Object$entries = Object.entries(options.extraAttributes || {}); _i2 < _Object$entries.length; _i2++) {
+        var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i2], 2),
+            _attributeName2 = _Object$entries$_i[0],
+            attributeUniqueId = _Object$entries$_i[1];
+
+        if (attributeUniqueId === uniqueId) {
+          return _attributeName2;
+        }
+      }
 
-    return "CUSTOM_ATTRIBUTE_".concat(uniqueId);
-  }
+      var thisAttributeType = attribute.attribute_type;
 
-  _getTopLevelMetadata(dracoGeometry) {
-    const dracoMetadata = this.decoder.GetMetadata(dracoGeometry);
-    return this._getDracoMetadata(dracoMetadata);
-  }
+      for (var dracoAttributeConstant in DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP) {
+        var attributeType = this.draco[dracoAttributeConstant];
 
-  _getAttributeMetadata(dracoGeometry, attributeId) {
-    const dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);
-    return this._getDracoMetadata(dracoMetadata);
-  }
+        if (attributeType === thisAttributeType) {
+          return DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP[dracoAttributeConstant];
+        }
+      }
 
-  _getDracoMetadata(dracoMetadata) {
-    if (!dracoMetadata || !dracoMetadata.ptr) {
-      return {};
-    }
+      var entryName = options.attributeNameEntry || 'name';
 
-    const result = {};
-    const numEntries = this.metadataQuerier.NumEntries(dracoMetadata);
+      if (attribute.metadata[entryName]) {
+        return attribute.metadata[entryName].string;
+      }
 
-    for (let entryIndex = 0; entryIndex < numEntries; entryIndex++) {
-      const entryName = this.metadataQuerier.GetEntryName(dracoMetadata, entryIndex);
-      result[entryName] = this._getDracoMetadataField(dracoMetadata, entryName);
+      return "CUSTOM_ATTRIBUTE_".concat(uniqueId);
     }
-
-    return result;
-  }
-
-  _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);
+  }, {
+    key: "_getTopLevelMetadata",
+    value: function _getTopLevelMetadata(dracoGeometry) {
+      var dracoMetadata = this.decoder.GetMetadata(dracoGeometry);
+      return this._getDracoMetadata(dracoMetadata);
     }
-  }
-
-  _disableAttributeTransforms(options) {
-    const {
-      quantizedAttributes = [],
-      octahedronAttributes = []
-    } = options;
-    const skipAttributes = [...quantizedAttributes, ...octahedronAttributes];
-
-    for (const dracoAttributeName of skipAttributes) {
-      this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);
+  }, {
+    key: "_getAttributeMetadata",
+    value: function _getAttributeMetadata(dracoGeometry, attributeId) {
+      var dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);
+      return this._getDracoMetadata(dracoMetadata);
     }
-  }
+  }, {
+    key: "_getDracoMetadata",
+    value: function _getDracoMetadata(dracoMetadata) {
+      if (!dracoMetadata || !dracoMetadata.ptr) {
+        return {};
+      }
+
+      var result = {};
+      var numEntries = this.metadataQuerier.NumEntries(dracoMetadata);
 
-  _getQuantizationTransform(dracoAttribute, options) {
-    const {
-      quantizedAttributes = []
-    } = options;
-    const attribute_type = dracoAttribute.attribute_type();
-    const skip = quantizedAttributes.map(type => this.decoder[type]).includes(attribute_type);
+      for (var entryIndex = 0; entryIndex < numEntries; entryIndex++) {
+        var entryName = this.metadataQuerier.GetEntryName(dracoMetadata, entryIndex);
+        result[entryName] = this._getDracoMetadataField(dracoMetadata, entryName);
+      }
 
-    if (skip) {
-      const transform = new this.draco.AttributeQuantizationTransform();
+      return result;
+    }
+  }, {
+    key: "_getDracoMetadataField",
+    value: function _getDracoMetadataField(dracoMetadata, entryName) {
+      var dracoArray = new this.draco.DracoInt32Array();
 
       try {
-        if (transform.InitFromAttribute(dracoAttribute)) {
-          return {
-            quantization_bits: transform.quantization_bits(),
-            range: transform.range(),
-            min_values: new Float32Array([1, 2, 3]).map(i => transform.min_value(i))
-          };
-        }
+        this.metadataQuerier.GetIntEntryArray(dracoMetadata, entryName, dracoArray);
+        var intArray = getInt32Array(dracoArray);
+        return {
+          int: this.metadataQuerier.GetIntEntry(dracoMetadata, entryName),
+          string: this.metadataQuerier.GetStringEntry(dracoMetadata, entryName),
+          double: this.metadataQuerier.GetDoubleEntry(dracoMetadata, entryName),
+          intArray: intArray
+        };
       } finally {
-        this.draco.destroy(transform);
+        this.draco.destroy(dracoArray);
       }
     }
-
-    return null;
-  }
-
-  _getOctahedronTransform(dracoAttribute, options) {
-    const {
-      octahedronAttributes = []
-    } = options;
-    const attribute_type = dracoAttribute.attribute_type();
-    const octahedron = octahedronAttributes.map(type => this.decoder[type]).includes(attribute_type);
-
-    if (octahedron) {
-      const transform = new this.draco.AttributeQuantizationTransform();
+  }, {
+    key: "_disableAttributeTransforms",
+    value: function _disableAttributeTransforms(options) {
+      var _options$quantizedAtt = options.quantizedAttributes,
+          quantizedAttributes = _options$quantizedAtt === void 0 ? [] : _options$quantizedAtt,
+          _options$octahedronAt = options.octahedronAttributes,
+          octahedronAttributes = _options$octahedronAt === void 0 ? [] : _options$octahedronAt;
+      var skipAttributes = [].concat((0, _toConsumableArray2.default)(quantizedAttributes), (0, _toConsumableArray2.default)(octahedronAttributes));
+
+      var _iterator = _createForOfIteratorHelper(skipAttributes),
+          _step;
 
       try {
-        if (transform.InitFromAttribute(dracoAttribute)) {
-          return {
-            quantization_bits: transform.quantization_bits()
-          };
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var dracoAttributeName = _step.value;
+          this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);
         }
+      } catch (err) {
+        _iterator.e(err);
       } finally {
-        this.draco.destroy(transform);
+        _iterator.f();
       }
     }
+  }, {
+    key: "_getQuantizationTransform",
+    value: function _getQuantizationTransform(dracoAttribute, options) {
+      var _this = this;
+
+      var _options$quantizedAtt2 = options.quantizedAttributes,
+          quantizedAttributes = _options$quantizedAtt2 === void 0 ? [] : _options$quantizedAtt2;
+      var attribute_type = dracoAttribute.attribute_type();
+      var skip = quantizedAttributes.map(function (type) {
+        return _this.decoder[type];
+      }).includes(attribute_type);
+
+      if (skip) {
+        var transform = new this.draco.AttributeQuantizationTransform();
+
+        try {
+          if (transform.InitFromAttribute(dracoAttribute)) {
+            return {
+              quantization_bits: transform.quantization_bits(),
+              range: transform.range(),
+              min_values: new Float32Array([1, 2, 3]).map(function (i) {
+                return transform.min_value(i);
+              })
+            };
+          }
+        } finally {
+          this.draco.destroy(transform);
+        }
+      }
 
-    return null;
-  }
+      return null;
+    }
+  }, {
+    key: "_getOctahedronTransform",
+    value: function _getOctahedronTransform(dracoAttribute, options) {
+      var _this2 = this;
+
+      var _options$octahedronAt2 = options.octahedronAttributes,
+          octahedronAttributes = _options$octahedronAt2 === void 0 ? [] : _options$octahedronAt2;
+      var attribute_type = dracoAttribute.attribute_type();
+      var octahedron = octahedronAttributes.map(function (type) {
+        return _this2.decoder[type];
+      }).includes(attribute_type);
 
-}
+      if (octahedron) {
+        var transform = new this.draco.AttributeQuantizationTransform();
+
+        try {
+          if (transform.InitFromAttribute(dracoAttribute)) {
+            return {
+              quantization_bits: transform.quantization_bits()
+            };
+          }
+        } finally {
+          this.draco.destroy(transform);
+        }
+      }
+
+      return null;
+    }
+  }]);
+  return DracoParser;
+}();
 
 exports.default = DracoParser;
 
@@ -441,10 +505,10 @@ function getDracoDataType(draco, attributeType) {
 }
 
 function getInt32Array(dracoArray) {
-  const numValues = dracoArray.size();
-  const intArray = new Int32Array(numValues);
+  var numValues = dracoArray.size();
+  var intArray = new Int32Array(numValues);
 
-  for (let i = 0; i < numValues; i++) {
+  for (var i = 0; i < numValues; i++) {
     intArray[i] = dracoArray.GetValue(i);
   }
 
@@ -452,10 +516,10 @@ function getInt32Array(dracoArray) {
 }
 
 function getUint32Array(dracoArray) {
-  const numValues = dracoArray.size();
-  const intArray = new Int32Array(numValues);
+  var numValues = dracoArray.size();
+  var intArray = new Int32Array(numValues);
 
-  for (let i = 0; i < numValues; i++) {
+  for (var i = 0; i < numValues; i++) {
     intArray[i] = dracoArray.GetValue(i);
   }