@loaders.gl/draco 3.1.0-alpha.4 → 3.1.0-beta.3

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

@@ -7,40 +7,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-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 GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP = {
+const GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP = {
   POSITION: 'POSITION',
   NORMAL: 'NORMAL',
   COLOR_0: 'COLOR',
   TEXCOORD_0: 'TEX_COORD'
 };
 
-var noop = function noop() {};
+const noop = () => {};
 
-var DracoBuilder = function () {
-  function DracoBuilder(draco) {
-    (0, _classCallCheck2.default)(this, DracoBuilder);
+class DracoBuilder {
+  constructor(draco) {
     (0, _defineProperty2.default)(this, "draco", void 0);
     (0, _defineProperty2.default)(this, "dracoEncoder", void 0);
     (0, _defineProperty2.default)(this, "dracoMeshBuilder", void 0);
@@ -52,350 +31,323 @@ var DracoBuilder = function () {
     this.dracoMetadataBuilder = new this.draco.MetadataBuilder();
   }
 
-  (0, _createClass2.default)(DracoBuilder, [{
-    key: "destroy",
-    value: function destroy() {
-      this.destroyEncodedObject(this.dracoMeshBuilder);
-      this.destroyEncodedObject(this.dracoEncoder);
-      this.destroyEncodedObject(this.dracoMetadataBuilder);
-      this.dracoMeshBuilder = null;
-      this.dracoEncoder = null;
-      this.draco = null;
-    }
-  }, {
-    key: "destroyEncodedObject",
-    value: function destroyEncodedObject(object) {
-      if (object) {
-        this.draco.destroy(object);
-      }
+  destroy() {
+    this.destroyEncodedObject(this.dracoMeshBuilder);
+    this.destroyEncodedObject(this.dracoEncoder);
+    this.destroyEncodedObject(this.dracoMetadataBuilder);
+    this.dracoMeshBuilder = null;
+    this.dracoEncoder = null;
+    this.draco = null;
+  }
+
+  destroyEncodedObject(object) {
+    if (object) {
+      this.draco.destroy(object);
     }
-  }, {
-    key: "encodeSync",
-    value: function encodeSync(mesh) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      this.log = noop;
+  }
 
-      this._setOptions(options);
+  encodeSync(mesh, options = {}) {
+    this.log = noop;
 
-      return options.pointcloud ? this._encodePointCloud(mesh, options) : this._encodeMesh(mesh, options);
-    }
-  }, {
-    key: "_getAttributesFromMesh",
-    value: function _getAttributesFromMesh(mesh) {
-      var attributes = _objectSpread(_objectSpread({}, mesh), mesh.attributes);
+    this._setOptions(options);
 
-      if (mesh.indices) {
-        attributes.indices = mesh.indices;
-      }
+    return options.pointcloud ? this._encodePointCloud(mesh, options) : this._encodeMesh(mesh, options);
+  }
+
+  _getAttributesFromMesh(mesh) {
+    const attributes = { ...mesh,
+      ...mesh.attributes
+    };
 
-      return attributes;
+    if (mesh.indices) {
+      attributes.indices = mesh.indices;
     }
-  }, {
-    key: "_encodePointCloud",
-    value: function _encodePointCloud(pointcloud, options) {
-      var dracoPointCloud = new this.draco.PointCloud();
 
-      if (options.metadata) {
-        this._addGeometryMetadata(dracoPointCloud, options.metadata);
-      }
+    return attributes;
+  }
+
+  _encodePointCloud(pointcloud, options) {
+    const dracoPointCloud = new this.draco.PointCloud();
 
-      var attributes = this._getAttributesFromMesh(pointcloud);
+    if (options.metadata) {
+      this._addGeometryMetadata(dracoPointCloud, options.metadata);
+    }
 
-      this._createDracoPointCloud(dracoPointCloud, attributes, options);
+    const attributes = this._getAttributesFromMesh(pointcloud);
 
-      var dracoData = new this.draco.DracoInt8Array();
+    this._createDracoPointCloud(dracoPointCloud, attributes, options);
 
-      try {
-        var encodedLen = this.dracoEncoder.EncodePointCloudToDracoBuffer(dracoPointCloud, false, dracoData);
+    const dracoData = new this.draco.DracoInt8Array();
 
-        if (!(encodedLen > 0)) {
-          throw new Error('Draco encoding failed.');
-        }
+    try {
+      const encodedLen = this.dracoEncoder.EncodePointCloudToDracoBuffer(dracoPointCloud, false, dracoData);
 
-        this.log("DRACO encoded ".concat(dracoPointCloud.num_points(), " points\n        with ").concat(dracoPointCloud.num_attributes(), " attributes into ").concat(encodedLen, " bytes"));
-        return dracoInt8ArrayToArrayBuffer(dracoData);
-      } finally {
-        this.destroyEncodedObject(dracoData);
-        this.destroyEncodedObject(dracoPointCloud);
+      if (!(encodedLen > 0)) {
+        throw new Error('Draco encoding failed.');
       }
+
+      this.log("DRACO encoded ".concat(dracoPointCloud.num_points(), " points\n        with ").concat(dracoPointCloud.num_attributes(), " attributes into ").concat(encodedLen, " bytes"));
+      return dracoInt8ArrayToArrayBuffer(dracoData);
+    } finally {
+      this.destroyEncodedObject(dracoData);
+      this.destroyEncodedObject(dracoPointCloud);
     }
-  }, {
-    key: "_encodeMesh",
-    value: function _encodeMesh(mesh, options) {
-      var dracoMesh = new this.draco.Mesh();
+  }
 
-      if (options.metadata) {
-        this._addGeometryMetadata(dracoMesh, options.metadata);
-      }
+  _encodeMesh(mesh, options) {
+    const dracoMesh = new this.draco.Mesh();
 
-      var attributes = this._getAttributesFromMesh(mesh);
+    if (options.metadata) {
+      this._addGeometryMetadata(dracoMesh, options.metadata);
+    }
 
-      this._createDracoMesh(dracoMesh, attributes, options);
+    const attributes = this._getAttributesFromMesh(mesh);
 
-      var dracoData = new this.draco.DracoInt8Array();
+    this._createDracoMesh(dracoMesh, attributes, options);
 
-      try {
-        var encodedLen = this.dracoEncoder.EncodeMeshToDracoBuffer(dracoMesh, dracoData);
+    const dracoData = new this.draco.DracoInt8Array();
 
-        if (encodedLen <= 0) {
-          throw new Error('Draco encoding failed.');
-        }
+    try {
+      const encodedLen = this.dracoEncoder.EncodeMeshToDracoBuffer(dracoMesh, dracoData);
 
-        this.log("DRACO encoded ".concat(dracoMesh.num_points(), " points\n        with ").concat(dracoMesh.num_attributes(), " attributes into ").concat(encodedLen, " bytes"));
-        return dracoInt8ArrayToArrayBuffer(dracoData);
-      } finally {
-        this.destroyEncodedObject(dracoData);
-        this.destroyEncodedObject(dracoMesh);
+      if (encodedLen <= 0) {
+        throw new Error('Draco encoding failed.');
       }
+
+      this.log("DRACO encoded ".concat(dracoMesh.num_points(), " points\n        with ").concat(dracoMesh.num_attributes(), " attributes into ").concat(encodedLen, " bytes"));
+      return dracoInt8ArrayToArrayBuffer(dracoData);
+    } finally {
+      this.destroyEncodedObject(dracoData);
+      this.destroyEncodedObject(dracoMesh);
     }
-  }, {
-    key: "_setOptions",
-    value: function _setOptions(options) {
-      if ('speed' in options) {
-        var _this$dracoEncoder;
+  }
 
-        (_this$dracoEncoder = this.dracoEncoder).SetSpeedOptions.apply(_this$dracoEncoder, (0, _toConsumableArray2.default)(options.speed));
-      }
+  _setOptions(options) {
+    if ('speed' in options) {
+      this.dracoEncoder.SetSpeedOptions(...options.speed);
+    }
 
-      if ('method' in options) {
-        var dracoMethod = this.draco[options.method || 'MESH_SEQUENTIAL_ENCODING'];
-        this.dracoEncoder.SetEncodingMethod(dracoMethod);
-      }
+    if ('method' in options) {
+      const dracoMethod = this.draco[options.method || 'MESH_SEQUENTIAL_ENCODING'];
+      this.dracoEncoder.SetEncodingMethod(dracoMethod);
+    }
 
-      if ('quantization' in options) {
-        for (var attribute in options.quantization) {
-          var bits = options.quantization[attribute];
-          var dracoPosition = this.draco[attribute];
-          this.dracoEncoder.SetAttributeQuantization(dracoPosition, bits);
-        }
+    if ('quantization' in options) {
+      for (const attribute in options.quantization) {
+        const bits = options.quantization[attribute];
+        const dracoPosition = this.draco[attribute];
+        this.dracoEncoder.SetAttributeQuantization(dracoPosition, bits);
       }
     }
-  }, {
-    key: "_createDracoMesh",
-    value: function _createDracoMesh(dracoMesh, attributes, options) {
-      var optionalMetadata = options.attributesMetadata || {};
+  }
 
-      try {
-        var positions = this._getPositionAttribute(attributes);
+  _createDracoMesh(dracoMesh, attributes, options) {
+    const optionalMetadata = options.attributesMetadata || {};
 
-        if (!positions) {
-          throw new Error('positions');
-        }
+    try {
+      const positions = this._getPositionAttribute(attributes);
 
-        var vertexCount = positions.length / 3;
+      if (!positions) {
+        throw new Error('positions');
+      }
 
-        for (var _attributeName in attributes) {
-          var attribute = attributes[_attributeName];
-          _attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[_attributeName] || _attributeName;
+      const vertexCount = positions.length / 3;
 
-          var uniqueId = this._addAttributeToMesh(dracoMesh, _attributeName, attribute, vertexCount);
+      for (let attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName] || attributeName;
 
-          if (uniqueId !== -1) {
-            this._addAttributeMetadata(dracoMesh, uniqueId, _objectSpread({
-              name: _attributeName
-            }, optionalMetadata[_attributeName] || {}));
-          }
+        const uniqueId = this._addAttributeToMesh(dracoMesh, attributeName, attribute, vertexCount);
+
+        if (uniqueId !== -1) {
+          this._addAttributeMetadata(dracoMesh, uniqueId, {
+            name: attributeName,
+            ...(optionalMetadata[attributeName] || {})
+          });
         }
-      } catch (error) {
-        this.destroyEncodedObject(dracoMesh);
-        throw error;
       }
-
-      return dracoMesh;
+    } catch (error) {
+      this.destroyEncodedObject(dracoMesh);
+      throw error;
     }
-  }, {
-    key: "_createDracoPointCloud",
-    value: function _createDracoPointCloud(dracoPointCloud, attributes, options) {
-      var optionalMetadata = options.attributesMetadata || {};
 
-      try {
-        var positions = this._getPositionAttribute(attributes);
+    return dracoMesh;
+  }
 
-        if (!positions) {
-          throw new Error('positions');
-        }
+  _createDracoPointCloud(dracoPointCloud, attributes, options) {
+    const optionalMetadata = options.attributesMetadata || {};
 
-        var vertexCount = positions.length / 3;
+    try {
+      const positions = this._getPositionAttribute(attributes);
 
-        for (var _attributeName2 in attributes) {
-          var attribute = attributes[_attributeName2];
-          _attributeName2 = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[_attributeName2] || _attributeName2;
+      if (!positions) {
+        throw new Error('positions');
+      }
 
-          var uniqueId = this._addAttributeToMesh(dracoPointCloud, _attributeName2, attribute, vertexCount);
+      const vertexCount = positions.length / 3;
 
-          if (uniqueId !== -1) {
-            this._addAttributeMetadata(dracoPointCloud, uniqueId, _objectSpread({
-              name: _attributeName2
-            }, optionalMetadata[_attributeName2] || {}));
-          }
+      for (let attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName] || attributeName;
+
+        const uniqueId = this._addAttributeToMesh(dracoPointCloud, attributeName, attribute, vertexCount);
+
+        if (uniqueId !== -1) {
+          this._addAttributeMetadata(dracoPointCloud, uniqueId, {
+            name: attributeName,
+            ...(optionalMetadata[attributeName] || {})
+          });
         }
-      } catch (error) {
-        this.destroyEncodedObject(dracoPointCloud);
-        throw error;
       }
+    } catch (error) {
+      this.destroyEncodedObject(dracoPointCloud);
+      throw error;
+    }
 
-      return dracoPointCloud;
+    return dracoPointCloud;
+  }
+
+  _addAttributeToMesh(mesh, attributeName, attribute, vertexCount) {
+    if (!ArrayBuffer.isView(attribute)) {
+      return -1;
     }
-  }, {
-    key: "_addAttributeToMesh",
-    value: function _addAttributeToMesh(mesh, attributeName, attribute, vertexCount) {
-      if (!ArrayBuffer.isView(attribute)) {
-        return -1;
-      }
 
-      var type = this._getDracoAttributeType(attributeName);
+    const type = this._getDracoAttributeType(attributeName);
 
-      var size = attribute.length / vertexCount;
+    const size = attribute.length / vertexCount;
 
-      if (type === 'indices') {
-        var numFaces = attribute.length / 3;
-        this.log("Adding attribute ".concat(attributeName, ", size ").concat(numFaces));
-        this.dracoMeshBuilder.AddFacesToMesh(mesh, numFaces, attribute);
-        return -1;
-      }
+    if (type === 'indices') {
+      const numFaces = attribute.length / 3;
+      this.log("Adding attribute ".concat(attributeName, ", size ").concat(numFaces));
+      this.dracoMeshBuilder.AddFacesToMesh(mesh, numFaces, attribute);
+      return -1;
+    }
 
-      this.log("Adding attribute ".concat(attributeName, ", size ").concat(size));
-      var builder = this.dracoMeshBuilder;
-      var buffer = attribute.buffer;
+    this.log("Adding attribute ".concat(attributeName, ", size ").concat(size));
+    const builder = this.dracoMeshBuilder;
+    const {
+      buffer
+    } = attribute;
 
-      switch (attribute.constructor) {
-        case Int8Array:
-          return builder.AddInt8Attribute(mesh, type, vertexCount, size, new Int8Array(buffer));
+    switch (attribute.constructor) {
+      case Int8Array:
+        return builder.AddInt8Attribute(mesh, type, vertexCount, size, new Int8Array(buffer));
 
-        case Int16Array:
-          return builder.AddInt16Attribute(mesh, type, vertexCount, size, new Int16Array(buffer));
+      case Int16Array:
+        return builder.AddInt16Attribute(mesh, type, vertexCount, size, new Int16Array(buffer));
 
-        case Int32Array:
-          return builder.AddInt32Attribute(mesh, type, vertexCount, size, new Int32Array(buffer));
+      case Int32Array:
+        return builder.AddInt32Attribute(mesh, type, vertexCount, size, new Int32Array(buffer));
 
-        case Uint8Array:
-        case Uint8ClampedArray:
-          return builder.AddUInt8Attribute(mesh, type, vertexCount, size, new Uint8Array(buffer));
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return builder.AddUInt8Attribute(mesh, type, vertexCount, size, new Uint8Array(buffer));
 
-        case Uint16Array:
-          return builder.AddUInt16Attribute(mesh, type, vertexCount, size, new Uint16Array(buffer));
+      case Uint16Array:
+        return builder.AddUInt16Attribute(mesh, type, vertexCount, size, new Uint16Array(buffer));
 
-        case Uint32Array:
-          return builder.AddUInt32Attribute(mesh, type, vertexCount, size, new Uint32Array(buffer));
+      case Uint32Array:
+        return builder.AddUInt32Attribute(mesh, type, vertexCount, size, new Uint32Array(buffer));
 
-        case Float32Array:
-        default:
-          return builder.AddFloatAttribute(mesh, type, vertexCount, size, new Float32Array(buffer));
-      }
+      case Float32Array:
+      default:
+        return builder.AddFloatAttribute(mesh, type, vertexCount, size, new Float32Array(buffer));
     }
-  }, {
-    key: "_getDracoAttributeType",
-    value: function _getDracoAttributeType(attributeName) {
-      switch (attributeName.toLowerCase()) {
-        case 'indices':
-          return 'indices';
-
-        case 'position':
-        case 'positions':
-        case 'vertices':
-          return this.draco.POSITION;
-
-        case 'normal':
-        case 'normals':
-          return this.draco.NORMAL;
-
-        case 'color':
-        case 'colors':
-          return this.draco.COLOR;
-
-        case 'texcoord':
-        case 'texcoords':
-          return this.draco.TEX_COORD;
+  }
 
-        default:
-          return this.draco.GENERIC;
-      }
-    }
-  }, {
-    key: "_getPositionAttribute",
-    value: function _getPositionAttribute(attributes) {
-      for (var _attributeName3 in attributes) {
-        var attribute = attributes[_attributeName3];
+  _getDracoAttributeType(attributeName) {
+    switch (attributeName.toLowerCase()) {
+      case 'indices':
+        return 'indices';
 
-        var dracoType = this._getDracoAttributeType(_attributeName3);
+      case 'position':
+      case 'positions':
+      case 'vertices':
+        return this.draco.POSITION;
 
-        if (dracoType === this.draco.POSITION) {
-          return attribute;
-        }
-      }
+      case 'normal':
+      case 'normals':
+        return this.draco.NORMAL;
 
-      return null;
-    }
-  }, {
-    key: "_addGeometryMetadata",
-    value: function _addGeometryMetadata(dracoGeometry, metadata) {
-      var dracoMetadata = new this.draco.Metadata();
+      case 'color':
+      case 'colors':
+        return this.draco.COLOR;
 
-      this._populateDracoMetadata(dracoMetadata, metadata);
+      case 'texcoord':
+      case 'texcoords':
+        return this.draco.TEX_COORD;
 
-      this.dracoMeshBuilder.AddMetadata(dracoGeometry, dracoMetadata);
+      default:
+        return this.draco.GENERIC;
     }
-  }, {
-    key: "_addAttributeMetadata",
-    value: function _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata) {
-      var dracoAttributeMetadata = new this.draco.Metadata();
+  }
 
-      this._populateDracoMetadata(dracoAttributeMetadata, metadata);
+  _getPositionAttribute(attributes) {
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
 
-      this.dracoMeshBuilder.SetMetadataForAttribute(dracoGeometry, uniqueAttributeId, dracoAttributeMetadata);
+      const dracoType = this._getDracoAttributeType(attributeName);
+
+      if (dracoType === this.draco.POSITION) {
+        return attribute;
+      }
     }
-  }, {
-    key: "_populateDracoMetadata",
-    value: function _populateDracoMetadata(dracoMetadata, metadata) {
-      var _iterator = _createForOfIteratorHelper(getEntries(metadata)),
-          _step;
-
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
-              _key = _step$value[0],
-              value = _step$value[1];
-
-          switch ((0, _typeof2.default)(value)) {
-            case 'number':
-              if (Math.trunc(value) === value) {
-                this.dracoMetadataBuilder.AddIntEntry(dracoMetadata, _key, value);
-              } else {
-                this.dracoMetadataBuilder.AddDoubleEntry(dracoMetadata, _key, value);
-              }
-
-              break;
-
-            case 'object':
-              if (value instanceof Int32Array) {
-                this.dracoMetadataBuilder.AddIntEntryArray(dracoMetadata, _key, value, value.length);
-              }
-
-              break;
-
-            case 'string':
-            default:
-              this.dracoMetadataBuilder.AddStringEntry(dracoMetadata, _key, value);
+
+    return null;
+  }
+
+  _addGeometryMetadata(dracoGeometry, metadata) {
+    const dracoMetadata = new this.draco.Metadata();
+
+    this._populateDracoMetadata(dracoMetadata, metadata);
+
+    this.dracoMeshBuilder.AddMetadata(dracoGeometry, dracoMetadata);
+  }
+
+  _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata) {
+    const dracoAttributeMetadata = new this.draco.Metadata();
+
+    this._populateDracoMetadata(dracoAttributeMetadata, metadata);
+
+    this.dracoMeshBuilder.SetMetadataForAttribute(dracoGeometry, uniqueAttributeId, dracoAttributeMetadata);
+  }
+
+  _populateDracoMetadata(dracoMetadata, metadata) {
+    for (const [key, value] of getEntries(metadata)) {
+      switch (typeof value) {
+        case 'number':
+          if (Math.trunc(value) === value) {
+            this.dracoMetadataBuilder.AddIntEntry(dracoMetadata, key, value);
+          } else {
+            this.dracoMetadataBuilder.AddDoubleEntry(dracoMetadata, key, value);
           }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+
+          break;
+
+        case 'object':
+          if (value instanceof Int32Array) {
+            this.dracoMetadataBuilder.AddIntEntryArray(dracoMetadata, key, value, value.length);
+          }
+
+          break;
+
+        case 'string':
+        default:
+          this.dracoMetadataBuilder.AddStringEntry(dracoMetadata, key, value);
       }
     }
-  }]);
-  return DracoBuilder;
-}();
+  }
+
+}
 
 exports.default = DracoBuilder;
 
 function dracoInt8ArrayToArrayBuffer(dracoData) {
-  var byteLength = dracoData.size();
-  var outputBuffer = new ArrayBuffer(byteLength);
-  var outputData = new Int8Array(outputBuffer);
+  const byteLength = dracoData.size();
+  const outputBuffer = new ArrayBuffer(byteLength);
+  const outputData = new Int8Array(outputBuffer);
 
-  for (var i = 0; i < byteLength; ++i) {
+  for (let i = 0; i < byteLength; ++i) {
     outputData[i] = dracoData.GetValue(i);
   }
 
@@ -403,7 +355,7 @@ function dracoInt8ArrayToArrayBuffer(dracoData) {
 }
 
 function getEntries(container) {
-  var hasEntriesFunc = container.entries && !container.hasOwnProperty('entries');
+  const hasEntriesFunc = container.entries && !container.hasOwnProperty('entries');
   return hasEntriesFunc ? container.entries() : Object.entries(container);
 }
 //# sourceMappingURL=draco-builder.js.map