@babylonjs/serializers 5.20.0 → 5.22.1

package/glTF/2.0/glTFExporter.js

@@ -1,4 +1,3 @@
-import { __spreadArray } from "tslib";
 import { Vector2, Vector3, Vector4, Quaternion } from "@babylonjs/core/Maths/math.vector.js";
 import { Color3, Color4 } from "@babylonjs/core/Maths/math.color.js";
 import { Tools } from "@babylonjs/core/Misc/tools.js";
@@ -20,20 +19,20 @@ import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.js";
  * Converts Babylon Scene into glTF 2.0.
  * @hidden
  */
-var _Exporter = /** @class */ (function () {
+export class _Exporter {
     /**
      * Creates a glTF Exporter instance, which can accept optional exporter options
      * @param babylonScene Babylon scene object
      * @param options Options to modify the behavior of the exporter
      */
-    function _Exporter(babylonScene, options) {
+    constructor(babylonScene, options) {
         /*
          * Specifies if root Babylon empty nodes that act as a coordinate space transform should be included in export
          */
         this._includeCoordinateSystemConversionNodes = false;
         this._extensions = {};
         this._glTF = {
-            asset: { generator: "Babylon.js v".concat(Engine.Version), version: "2.0" },
+            asset: { generator: `Babylon.js v${Engine.Version}`, version: "2.0" },
         };
         babylonScene = babylonScene || EngineStore.LastCreatedScene;
         if (!babylonScene) {
@@ -61,162 +60,151 @@ var _Exporter = /** @class */ (function () {
         this._glTFMaterialExporter = new _GLTFMaterialExporter(this);
         this._loadExtensions();
     }
-    _Exporter.prototype._applyExtension = function (node, extensions, index, actionAsync) {
-        var _this = this;
+    _applyExtension(node, extensions, index, actionAsync) {
         if (index >= extensions.length) {
             return Promise.resolve(node);
         }
-        var currentPromise = actionAsync(extensions[index], node);
+        const currentPromise = actionAsync(extensions[index], node);
         if (!currentPromise) {
             return this._applyExtension(node, extensions, index + 1, actionAsync);
         }
-        return currentPromise.then(function (newNode) { return _this._applyExtension(newNode, extensions, index + 1, actionAsync); });
-    };
-    _Exporter.prototype._applyExtensions = function (node, actionAsync) {
-        var extensions = [];
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_1 = _a[_i];
-            extensions.push(this._extensions[name_1]);
+        return currentPromise.then((newNode) => this._applyExtension(newNode, extensions, index + 1, actionAsync));
+    }
+    _applyExtensions(node, actionAsync) {
+        const extensions = [];
+        for (const name of _Exporter._ExtensionNames) {
+            extensions.push(this._extensions[name]);
         }
         return this._applyExtension(node, extensions, 0, actionAsync);
-    };
-    _Exporter.prototype._extensionsPreExportTextureAsync = function (context, babylonTexture, mimeType) {
-        return this._applyExtensions(babylonTexture, function (extension, node) { return extension.preExportTextureAsync && extension.preExportTextureAsync(context, node, mimeType); });
-    };
-    _Exporter.prototype._extensionsPostExportMeshPrimitiveAsync = function (context, meshPrimitive, babylonSubMesh, binaryWriter) {
-        return this._applyExtensions(meshPrimitive, function (extension, node) { return extension.postExportMeshPrimitiveAsync && extension.postExportMeshPrimitiveAsync(context, node, babylonSubMesh, binaryWriter); });
-    };
-    _Exporter.prototype._extensionsPostExportNodeAsync = function (context, node, babylonNode, nodeMap, binaryWriter) {
-        return this._applyExtensions(node, function (extension, node) { return extension.postExportNodeAsync && extension.postExportNodeAsync(context, node, babylonNode, nodeMap, binaryWriter); });
-    };
-    _Exporter.prototype._extensionsPostExportMaterialAsync = function (context, material, babylonMaterial) {
-        return this._applyExtensions(material, function (extension, node) { return extension.postExportMaterialAsync && extension.postExportMaterialAsync(context, node, babylonMaterial); });
-    };
-    _Exporter.prototype._extensionsPostExportMaterialAdditionalTextures = function (context, material, babylonMaterial) {
-        var output = [];
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_2 = _a[_i];
-            var extension = this._extensions[name_2];
+    }
+    _extensionsPreExportTextureAsync(context, babylonTexture, mimeType) {
+        return this._applyExtensions(babylonTexture, (extension, node) => extension.preExportTextureAsync && extension.preExportTextureAsync(context, node, mimeType));
+    }
+    _extensionsPostExportMeshPrimitiveAsync(context, meshPrimitive, babylonSubMesh, binaryWriter) {
+        return this._applyExtensions(meshPrimitive, (extension, node) => extension.postExportMeshPrimitiveAsync && extension.postExportMeshPrimitiveAsync(context, node, babylonSubMesh, binaryWriter));
+    }
+    _extensionsPostExportNodeAsync(context, node, babylonNode, nodeMap, binaryWriter) {
+        return this._applyExtensions(node, (extension, node) => extension.postExportNodeAsync && extension.postExportNodeAsync(context, node, babylonNode, nodeMap, binaryWriter));
+    }
+    _extensionsPostExportMaterialAsync(context, material, babylonMaterial) {
+        return this._applyExtensions(material, (extension, node) => extension.postExportMaterialAsync && extension.postExportMaterialAsync(context, node, babylonMaterial));
+    }
+    _extensionsPostExportMaterialAdditionalTextures(context, material, babylonMaterial) {
+        const output = [];
+        for (const name of _Exporter._ExtensionNames) {
+            const extension = this._extensions[name];
             if (extension.postExportMaterialAdditionalTextures) {
-                output.push.apply(output, extension.postExportMaterialAdditionalTextures(context, material, babylonMaterial));
+                output.push(...extension.postExportMaterialAdditionalTextures(context, material, babylonMaterial));
             }
         }
         return output;
-    };
-    _Exporter.prototype._extensionsPostExportTextures = function (context, textureInfo, babylonTexture) {
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_3 = _a[_i];
-            var extension = this._extensions[name_3];
+    }
+    _extensionsPostExportTextures(context, textureInfo, babylonTexture) {
+        for (const name of _Exporter._ExtensionNames) {
+            const extension = this._extensions[name];
             if (extension.postExportTexture) {
                 extension.postExportTexture(context, textureInfo, babylonTexture);
             }
         }
-    };
-    _Exporter.prototype._forEachExtensions = function (action) {
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_4 = _a[_i];
-            var extension = this._extensions[name_4];
+    }
+    _forEachExtensions(action) {
+        for (const name of _Exporter._ExtensionNames) {
+            const extension = this._extensions[name];
             if (extension.enabled) {
                 action(extension);
             }
         }
-    };
-    _Exporter.prototype._extensionsOnExporting = function () {
-        var _this = this;
-        this._forEachExtensions(function (extension) {
+    }
+    _extensionsOnExporting() {
+        this._forEachExtensions((extension) => {
             if (extension.wasUsed) {
-                if (_this._glTF.extensionsUsed == null) {
-                    _this._glTF.extensionsUsed = [];
+                if (this._glTF.extensionsUsed == null) {
+                    this._glTF.extensionsUsed = [];
                 }
-                if (_this._glTF.extensionsUsed.indexOf(extension.name) === -1) {
-                    _this._glTF.extensionsUsed.push(extension.name);
+                if (this._glTF.extensionsUsed.indexOf(extension.name) === -1) {
+                    this._glTF.extensionsUsed.push(extension.name);
                 }
                 if (extension.required) {
-                    if (_this._glTF.extensionsRequired == null) {
-                        _this._glTF.extensionsRequired = [];
+                    if (this._glTF.extensionsRequired == null) {
+                        this._glTF.extensionsRequired = [];
                     }
-                    if (_this._glTF.extensionsRequired.indexOf(extension.name) === -1) {
-                        _this._glTF.extensionsRequired.push(extension.name);
+                    if (this._glTF.extensionsRequired.indexOf(extension.name) === -1) {
+                        this._glTF.extensionsRequired.push(extension.name);
                     }
                 }
-                if (_this._glTF.extensions == null) {
-                    _this._glTF.extensions = {};
+                if (this._glTF.extensions == null) {
+                    this._glTF.extensions = {};
                 }
                 if (extension.onExporting) {
                     extension.onExporting();
                 }
             }
         });
-    };
+    }
     /**
      * Load glTF serializer extensions
      */
-    _Exporter.prototype._loadExtensions = function () {
-        for (var _i = 0, _a = _Exporter._ExtensionNames; _i < _a.length; _i++) {
-            var name_5 = _a[_i];
-            var extension = _Exporter._ExtensionFactories[name_5](this);
-            this._extensions[name_5] = extension;
-        }
-    };
-    _Exporter.prototype.dispose = function () {
-        for (var extensionKey in this._extensions) {
-            var extension = this._extensions[extensionKey];
+    _loadExtensions() {
+        for (const name of _Exporter._ExtensionNames) {
+            const extension = _Exporter._ExtensionFactories[name](this);
+            this._extensions[name] = extension;
+        }
+    }
+    dispose() {
+        for (const extensionKey in this._extensions) {
+            const extension = this._extensions[extensionKey];
             extension.dispose();
         }
-    };
-    Object.defineProperty(_Exporter.prototype, "options", {
-        get: function () {
-            return this._options;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    get options() {
+        return this._options;
+    }
     /**
      * Registers a glTF exporter extension
      * @param name Name of the extension to export
      * @param factory The factory function that creates the exporter extension
      */
-    _Exporter.RegisterExtension = function (name, factory) {
+    static RegisterExtension(name, factory) {
         if (_Exporter.UnregisterExtension(name)) {
-            Tools.Warn("Extension with the name ".concat(name, " already exists"));
+            Tools.Warn(`Extension with the name ${name} already exists`);
         }
         _Exporter._ExtensionFactories[name] = factory;
         _Exporter._ExtensionNames.push(name);
-    };
+    }
     /**
      * Un-registers an exporter extension
      * @param name The name fo the exporter extension
      * @returns A boolean indicating whether the extension has been un-registered
      */
-    _Exporter.UnregisterExtension = function (name) {
+    static UnregisterExtension(name) {
         if (!_Exporter._ExtensionFactories[name]) {
             return false;
         }
         delete _Exporter._ExtensionFactories[name];
-        var index = _Exporter._ExtensionNames.indexOf(name);
+        const index = _Exporter._ExtensionNames.indexOf(name);
         if (index !== -1) {
             _Exporter._ExtensionNames.splice(index, 1);
         }
         return true;
-    };
-    _Exporter.prototype._reorderIndicesBasedOnPrimitiveMode = function (submesh, primitiveMode, babylonIndices, byteOffset, binaryWriter) {
+    }
+    _reorderIndicesBasedOnPrimitiveMode(submesh, primitiveMode, babylonIndices, byteOffset, binaryWriter) {
         switch (primitiveMode) {
             case Material.TriangleFillMode: {
                 if (!byteOffset) {
                     byteOffset = 0;
                 }
-                for (var i = submesh.indexStart, length_1 = submesh.indexStart + submesh.indexCount; i < length_1; i = i + 3) {
-                    var index = byteOffset + i * 4;
+                for (let i = submesh.indexStart, length = submesh.indexStart + submesh.indexCount; i < length; i = i + 3) {
+                    const index = byteOffset + i * 4;
                     // swap the second and third indices
-                    var secondIndex = binaryWriter.getUInt32(index + 4);
-                    var thirdIndex = binaryWriter.getUInt32(index + 8);
+                    const secondIndex = binaryWriter.getUInt32(index + 4);
+                    const thirdIndex = binaryWriter.getUInt32(index + 8);
                     binaryWriter.setUInt32(thirdIndex, index + 4);
                     binaryWriter.setUInt32(secondIndex, index + 8);
                 }
                 break;
             }
             case Material.TriangleFanDrawMode: {
-                for (var i = submesh.indexStart + submesh.indexCount - 1, start = submesh.indexStart; i >= start; --i) {
+                for (let i = submesh.indexStart + submesh.indexCount - 1, start = submesh.indexStart; i >= start; --i) {
                     binaryWriter.setUInt32(babylonIndices[i], byteOffset);
                     byteOffset += 4;
                 }
@@ -230,7 +218,7 @@ var _Exporter = /** @class */ (function () {
                 break;
             }
         }
-    };
+    }
     /**
      * Reorders the vertex attribute data based on the primitive mode.  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
@@ -243,7 +231,7 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter The binary data for the glTF file
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderVertexAttributeDataBasedOnPrimitiveMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+    _reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
         if (convertToRightHandedSystem && sideOrientation === Material.ClockWiseSideOrientation) {
             switch (primitiveMode) {
                 case Material.TriangleFillMode: {
@@ -260,7 +248,7 @@ var _Exporter = /** @class */ (function () {
                 }
             }
         }
-    };
+    }
     /**
      * Reorders the vertex attributes in the correct triangle mode order .  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
@@ -273,20 +261,20 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter The binary data for the glTF file
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderTriangleFillMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        var vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
+    _reorderTriangleFillMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+        const vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
-            var stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
+            const stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
             if (submesh.verticesCount % 3 !== 0) {
                 Tools.Error("The submesh vertices for the triangle fill mode is not divisible by 3!");
             }
             else {
-                var vertexData = [];
-                var index = 0;
+                const vertexData = [];
+                let index = 0;
                 switch (vertexBufferKind) {
                     case VertexBuffer.PositionKind:
                     case VertexBuffer.NormalKind: {
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
+                        for (let x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
                             index = x * stride;
                             vertexData.push(Vector3.FromArray(meshAttributeArray, index));
                             vertexData.push(Vector3.FromArray(meshAttributeArray, index + 2 * stride));
@@ -295,7 +283,7 @@ var _Exporter = /** @class */ (function () {
                         break;
                     }
                     case VertexBuffer.TangentKind: {
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
+                        for (let x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
                             index = x * stride;
                             vertexData.push(Vector4.FromArray(meshAttributeArray, index));
                             vertexData.push(Vector4.FromArray(meshAttributeArray, index + 2 * stride));
@@ -304,8 +292,8 @@ var _Exporter = /** @class */ (function () {
                         break;
                     }
                     case VertexBuffer.ColorKind: {
-                        var size = vertexBuffer.getSize();
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + size) {
+                        const size = vertexBuffer.getSize();
+                        for (let x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + size) {
                             index = x * stride;
                             if (size === 4) {
                                 vertexData.push(Vector4.FromArray(meshAttributeArray, index));
@@ -322,7 +310,7 @@ var _Exporter = /** @class */ (function () {
                     }
                     case VertexBuffer.UVKind:
                     case VertexBuffer.UV2Kind: {
-                        for (var x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
+                        for (let x = submesh.verticesStart; x < submesh.verticesStart + submesh.verticesCount; x = x + 3) {
                             index = x * stride;
                             vertexData.push(Vector2.FromArray(meshAttributeArray, index));
                             vertexData.push(Vector2.FromArray(meshAttributeArray, index + 2 * stride));
@@ -331,16 +319,16 @@ var _Exporter = /** @class */ (function () {
                         break;
                     }
                     default: {
-                        Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
+                        Tools.Error(`Unsupported Vertex Buffer type: ${vertexBufferKind}`);
                     }
                 }
                 this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
             }
         }
         else {
-            Tools.Warn("reorderTriangleFillMode: Vertex Buffer Kind ".concat(vertexBufferKind, " not present!"));
+            Tools.Warn(`reorderTriangleFillMode: Vertex Buffer Kind ${vertexBufferKind} not present!`);
         }
-    };
+    }
     /**
      * Reorders the vertex attributes in the correct triangle strip order.  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
@@ -353,12 +341,12 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter The binary data for the glTF file
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderTriangleStripDrawMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        var vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
+    _reorderTriangleStripDrawMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+        const vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
-            var stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
-            var vertexData = [];
-            var index = 0;
+            const stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
+            const vertexData = [];
+            let index = 0;
             switch (vertexBufferKind) {
                 case VertexBuffer.PositionKind:
                 case VertexBuffer.NormalKind: {
@@ -368,14 +356,14 @@ var _Exporter = /** @class */ (function () {
                     break;
                 }
                 case VertexBuffer.TangentKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
+                    for (let x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
                         index = x * stride;
                         vertexData.push(Vector4.FromArray(meshAttributeArray, index));
                     }
                     break;
                 }
                 case VertexBuffer.ColorKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
+                    for (let x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
                         index = x * stride;
                         vertexBuffer.getSize() === 4
                             ? vertexData.push(Vector4.FromArray(meshAttributeArray, index))
@@ -385,22 +373,22 @@ var _Exporter = /** @class */ (function () {
                 }
                 case VertexBuffer.UVKind:
                 case VertexBuffer.UV2Kind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
+                    for (let x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
                         index = x * stride;
                         vertexData.push(Vector2.FromArray(meshAttributeArray, index));
                     }
                     break;
                 }
                 default: {
-                    Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
+                    Tools.Error(`Unsupported Vertex Buffer type: ${vertexBufferKind}`);
                 }
             }
             this._writeVertexAttributeData(vertexData, byteOffset + 12, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
         }
         else {
-            Tools.Warn("reorderTriangleStripDrawMode: Vertex buffer kind ".concat(vertexBufferKind, " not present!"));
+            Tools.Warn(`reorderTriangleStripDrawMode: Vertex buffer kind ${vertexBufferKind} not present!`);
         }
-    };
+    }
     /**
      * Reorders the vertex attributes in the correct triangle fan order.  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
@@ -413,30 +401,30 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter The binary data for the glTF file
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderTriangleFanMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        var vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
+    _reorderTriangleFanMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+        const vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
-            var stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
-            var vertexData = [];
-            var index = 0;
+            const stride = vertexBuffer.byteStride / VertexBuffer.GetTypeByteLength(vertexBuffer.type);
+            const vertexData = [];
+            let index = 0;
             switch (vertexBufferKind) {
                 case VertexBuffer.PositionKind:
                 case VertexBuffer.NormalKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
+                    for (let x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
                         index = x * stride;
                         vertexData.push(Vector3.FromArray(meshAttributeArray, index));
                     }
                     break;
                 }
                 case VertexBuffer.TangentKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
+                    for (let x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
                         index = x * stride;
                         vertexData.push(Vector4.FromArray(meshAttributeArray, index));
                     }
                     break;
                 }
                 case VertexBuffer.ColorKind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
+                    for (let x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
                         index = x * stride;
                         vertexData.push(Vector4.FromArray(meshAttributeArray, index));
                         vertexBuffer.getSize() === 4
@@ -447,22 +435,22 @@ var _Exporter = /** @class */ (function () {
                 }
                 case VertexBuffer.UVKind:
                 case VertexBuffer.UV2Kind: {
-                    for (var x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
+                    for (let x = submesh.verticesStart + submesh.verticesCount - 1; x >= submesh.verticesStart; --x) {
                         index = x * stride;
                         vertexData.push(Vector2.FromArray(meshAttributeArray, index));
                     }
                     break;
                 }
                 default: {
-                    Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
+                    Tools.Error(`Unsupported Vertex Buffer type: ${vertexBufferKind}`);
                 }
             }
             this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
         }
         else {
-            Tools.Warn("reorderTriangleFanMode: Vertex buffer kind ".concat(vertexBufferKind, " not present!"));
+            Tools.Warn(`reorderTriangleFanMode: Vertex buffer kind ${vertexBufferKind} not present!`);
         }
-    };
+    }
     /**
      * Writes the vertex attribute data to binary
      * @param vertices The vertices to write to the binary writer
@@ -472,9 +460,8 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter The writer containing the binary data
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._writeVertexAttributeData = function (vertices, byteOffset, vertexAttributeKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem) {
-        for (var _i = 0, vertices_1 = vertices; _i < vertices_1.length; _i++) {
-            var vertex = vertices_1[_i];
+    _writeVertexAttributeData(vertices, byteOffset, vertexAttributeKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem) {
+        for (const vertex of vertices) {
             if (convertToRightHandedSystem && !(vertexAttributeKind === VertexBuffer.ColorKind) && !(vertex instanceof Vector2)) {
                 if (vertex instanceof Vector3) {
                     if (vertexAttributeKind === VertexBuffer.NormalKind) {
@@ -497,13 +484,12 @@ var _Exporter = /** @class */ (function () {
             else if (vertexAttributeKind === VertexBuffer.TangentKind && vertex instanceof Vector4) {
                 _GLTFUtilities._NormalizeTangentFromRef(vertex);
             }
-            for (var _a = 0, _b = vertex.asArray(); _a < _b.length; _a++) {
-                var component = _b[_a];
+            for (const component of vertex.asArray()) {
                 binaryWriter.setFloat32(component, byteOffset);
                 byteOffset += 4;
             }
         }
-    };
+    }
     /**
      * Writes mesh attribute data to a data buffer
      * Returns the bytelength of the data
@@ -515,14 +501,14 @@ var _Exporter = /** @class */ (function () {
      * @param convertToRightHandedSystem Converts the values to right-handed
      * @param babylonTransformNode
      */
-    _Exporter.prototype._writeAttributeData = function (vertexBufferKind, attributeComponentKind, meshAttributeArray, stride, binaryWriter, convertToRightHandedSystem, babylonTransformNode) {
-        var vertexAttributes = [];
-        var index;
+    _writeAttributeData(vertexBufferKind, attributeComponentKind, meshAttributeArray, stride, binaryWriter, convertToRightHandedSystem, babylonTransformNode) {
+        let vertexAttributes = [];
+        let index;
         switch (vertexBufferKind) {
             case VertexBuffer.PositionKind: {
-                for (var k = 0, length_2 = meshAttributeArray.length / stride; k < length_2; ++k) {
+                for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
+                    const vertexData = Vector3.FromArray(meshAttributeArray, index);
                     if (convertToRightHandedSystem) {
                         _GLTFUtilities._GetRightHandedPositionVector3FromRef(vertexData);
                     }
@@ -531,9 +517,9 @@ var _Exporter = /** @class */ (function () {
                 break;
             }
             case VertexBuffer.NormalKind: {
-                for (var k = 0, length_3 = meshAttributeArray.length / stride; k < length_3; ++k) {
+                for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
+                    const vertexData = Vector3.FromArray(meshAttributeArray, index);
                     if (convertToRightHandedSystem) {
                         _GLTFUtilities._GetRightHandedNormalVector3FromRef(vertexData);
                     }
@@ -543,9 +529,9 @@ var _Exporter = /** @class */ (function () {
                 break;
             }
             case VertexBuffer.TangentKind: {
-                for (var k = 0, length_4 = meshAttributeArray.length / stride; k < length_4; ++k) {
+                for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
+                    const vertexData = Vector4.FromArray(meshAttributeArray, index);
                     if (convertToRightHandedSystem) {
                         _GLTFUtilities._GetRightHandedVector4FromRef(vertexData);
                     }
@@ -555,10 +541,10 @@ var _Exporter = /** @class */ (function () {
                 break;
             }
             case VertexBuffer.ColorKind: {
-                var meshMaterial = babylonTransformNode.material;
-                var convertToLinear = meshMaterial ? meshMaterial.getClassName() === "StandardMaterial" : true;
-                var vertexData = stride === 3 ? new Color3() : new Color4();
-                for (var k = 0, length_5 = meshAttributeArray.length / stride; k < length_5; ++k) {
+                const meshMaterial = babylonTransformNode.material;
+                const convertToLinear = meshMaterial ? meshMaterial.getClassName() === "StandardMaterial" : true;
+                const vertexData = stride === 3 ? new Color3() : new Color4();
+                for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
                     if (stride === 3) {
                         Color3.FromArrayToRef(meshAttributeArray, index, vertexData);
@@ -578,7 +564,7 @@ var _Exporter = /** @class */ (function () {
             }
             case VertexBuffer.UVKind:
             case VertexBuffer.UV2Kind: {
-                for (var k = 0, length_6 = meshAttributeArray.length / stride; k < length_6; ++k) {
+                for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
                     vertexAttributes.push(convertToRightHandedSystem ? [meshAttributeArray[index], meshAttributeArray[index + 1]] : [meshAttributeArray[index], meshAttributeArray[index + 1]]);
                 }
@@ -586,18 +572,18 @@ var _Exporter = /** @class */ (function () {
             }
             case VertexBuffer.MatricesIndicesKind:
             case VertexBuffer.MatricesIndicesExtraKind: {
-                for (var k = 0, length_7 = meshAttributeArray.length / stride; k < length_7; ++k) {
+                for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
+                    const vertexData = Vector4.FromArray(meshAttributeArray, index);
                     vertexAttributes.push(vertexData.asArray());
                 }
                 break;
             }
             case VertexBuffer.MatricesWeightsKind:
             case VertexBuffer.MatricesWeightsExtraKind: {
-                for (var k = 0, length_8 = meshAttributeArray.length / stride; k < length_8; ++k) {
+                for (let k = 0, length = meshAttributeArray.length / stride; k < length; ++k) {
                     index = k * stride;
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
+                    const vertexData = Vector4.FromArray(meshAttributeArray, index);
                     vertexAttributes.push(vertexData.asArray());
                 }
                 break;
@@ -607,7 +593,7 @@ var _Exporter = /** @class */ (function () {
                 vertexAttributes = [];
             }
         }
-        var writeBinaryFunc;
+        let writeBinaryFunc;
         switch (attributeComponentKind) {
             case 5121 /* UNSIGNED_BYTE */: {
                 writeBinaryFunc = binaryWriter.setUInt8.bind(binaryWriter);
@@ -630,14 +616,12 @@ var _Exporter = /** @class */ (function () {
                 return;
             }
         }
-        for (var _i = 0, vertexAttributes_1 = vertexAttributes; _i < vertexAttributes_1.length; _i++) {
-            var vertexAttribute = vertexAttributes_1[_i];
-            for (var _a = 0, vertexAttribute_1 = vertexAttribute; _a < vertexAttribute_1.length; _a++) {
-                var component = vertexAttribute_1[_a];
+        for (const vertexAttribute of vertexAttributes) {
+            for (const component of vertexAttribute) {
                 writeBinaryFunc(component);
             }
         }
-    };
+    }
     /**
      * Writes mesh attribute data to a data buffer
      * Returns the bytelength of the data
@@ -652,17 +636,17 @@ var _Exporter = /** @class */ (function () {
      * @param convertToRightHandedSystem Converts the values to right-handed
      * @param minMax
      */
-    _Exporter.prototype.writeMorphTargetAttributeData = function (vertexBufferKind, attributeComponentKind, meshPrimitive, morphTarget, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, convertToRightHandedSystem, minMax) {
-        var vertexAttributes = [];
-        var index;
-        var difference = new Vector3();
-        var difference4 = new Vector4(0, 0, 0, 0);
+    writeMorphTargetAttributeData(vertexBufferKind, attributeComponentKind, meshPrimitive, morphTarget, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, convertToRightHandedSystem, minMax) {
+        let vertexAttributes = [];
+        let index;
+        let difference = new Vector3();
+        let difference4 = new Vector4(0, 0, 0, 0);
         switch (vertexBufferKind) {
             case VertexBuffer.PositionKind: {
-                for (var k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
+                for (let k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
                     index = meshPrimitive.indexStart + k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    var morphData = Vector3.FromArray(morphTargetAttributeArray, index);
+                    const vertexData = Vector3.FromArray(meshAttributeArray, index);
+                    const morphData = Vector3.FromArray(morphTargetAttributeArray, index);
                     difference = morphData.subtractToRef(vertexData, difference);
                     if (convertToRightHandedSystem) {
                         _GLTFUtilities._GetRightHandedPositionVector3FromRef(difference);
@@ -676,11 +660,11 @@ var _Exporter = /** @class */ (function () {
                 break;
             }
             case VertexBuffer.NormalKind: {
-                for (var k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
+                for (let k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
                     index = meshPrimitive.indexStart + k * stride;
-                    var vertexData = Vector3.FromArray(meshAttributeArray, index);
+                    const vertexData = Vector3.FromArray(meshAttributeArray, index);
                     vertexData.normalize();
-                    var morphData = Vector3.FromArray(morphTargetAttributeArray, index);
+                    const morphData = Vector3.FromArray(morphTargetAttributeArray, index);
                     morphData.normalize();
                     difference = morphData.subtractToRef(vertexData, difference);
                     if (convertToRightHandedSystem) {
@@ -691,11 +675,11 @@ var _Exporter = /** @class */ (function () {
                 break;
             }
             case VertexBuffer.TangentKind: {
-                for (var k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
+                for (let k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
                     index = meshPrimitive.indexStart + k * (stride + 1);
-                    var vertexData = Vector4.FromArray(meshAttributeArray, index);
+                    const vertexData = Vector4.FromArray(meshAttributeArray, index);
                     _GLTFUtilities._NormalizeTangentFromRef(vertexData);
-                    var morphData = Vector4.FromArray(morphTargetAttributeArray, index);
+                    const morphData = Vector4.FromArray(morphTargetAttributeArray, index);
                     _GLTFUtilities._NormalizeTangentFromRef(morphData);
                     difference4 = morphData.subtractToRef(vertexData, difference4);
                     if (convertToRightHandedSystem) {
@@ -710,7 +694,7 @@ var _Exporter = /** @class */ (function () {
                 vertexAttributes = [];
             }
         }
-        var writeBinaryFunc;
+        let writeBinaryFunc;
         switch (attributeComponentKind) {
             case 5121 /* UNSIGNED_BYTE */: {
                 writeBinaryFunc = binaryWriter.setUInt8.bind(binaryWriter);
@@ -733,14 +717,12 @@ var _Exporter = /** @class */ (function () {
                 return;
             }
         }
-        for (var _i = 0, vertexAttributes_2 = vertexAttributes; _i < vertexAttributes_2.length; _i++) {
-            var vertexAttribute = vertexAttributes_2[_i];
-            for (var _a = 0, vertexAttribute_2 = vertexAttribute; _a < vertexAttribute_2.length; _a++) {
-                var component = vertexAttribute_2[_a];
+        for (const vertexAttribute of vertexAttributes) {
+            for (const component of vertexAttribute) {
                 writeBinaryFunc(component);
             }
         }
-    };
+    }
     /**
      * Generates glTF json data
      * @param shouldUseGlb Indicates whether the json should be written for a glb file
@@ -748,13 +730,12 @@ var _Exporter = /** @class */ (function () {
      * @param prettyPrint Indicates whether the json file should be pretty printed (true) or not (false)
      * @returns json data as string
      */
-    _Exporter.prototype._generateJSON = function (shouldUseGlb, glTFPrefix, prettyPrint) {
-        var _this = this;
-        var buffer = { byteLength: this._totalByteLength };
-        var imageName;
-        var imageData;
-        var bufferView;
-        var byteOffset = this._totalByteLength;
+    _generateJSON(shouldUseGlb, glTFPrefix, prettyPrint) {
+        const buffer = { byteLength: this._totalByteLength };
+        let imageName;
+        let imageData;
+        let bufferView;
+        let byteOffset = this._totalByteLength;
         if (buffer.byteLength) {
             this._glTF.buffers = [buffer];
         }
@@ -798,22 +779,22 @@ var _Exporter = /** @class */ (function () {
             }
             else {
                 this._glTF.images = [];
-                this._images.forEach(function (image) {
+                this._images.forEach((image) => {
                     if (image.uri) {
-                        imageData = _this._imageData[image.uri];
-                        _this._orderedImageData.push(imageData);
+                        imageData = this._imageData[image.uri];
+                        this._orderedImageData.push(imageData);
                         imageName = image.uri.split(".")[0] + " image";
                         bufferView = _GLTFUtilities._CreateBufferView(0, byteOffset, imageData.data.length, undefined, imageName);
                         byteOffset += imageData.data.buffer.byteLength;
-                        _this._bufferViews.push(bufferView);
-                        image.bufferView = _this._bufferViews.length - 1;
+                        this._bufferViews.push(bufferView);
+                        image.bufferView = this._bufferViews.length - 1;
                         image.name = imageName;
                         image.mimeType = imageData.mimeType;
                         image.uri = undefined;
-                        if (!_this._glTF.images) {
-                            _this._glTF.images = [];
+                        if (!this._glTF.images) {
+                            this._glTF.images = [];
                         }
-                        _this._glTF.images.push(image);
+                        this._glTF.images.push(image);
                     }
                 });
                 // Replace uri with bufferview and mime type for glb
@@ -823,113 +804,108 @@ var _Exporter = /** @class */ (function () {
         if (!shouldUseGlb) {
             buffer.uri = glTFPrefix + ".bin";
         }
-        var jsonText = prettyPrint ? JSON.stringify(this._glTF, null, 2) : JSON.stringify(this._glTF);
+        const jsonText = prettyPrint ? JSON.stringify(this._glTF, null, 2) : JSON.stringify(this._glTF);
         return jsonText;
-    };
+    }
     /**
      * Generates data for .gltf and .bin files based on the glTF prefix string
      * @param glTFPrefix Text to use when prefixing a glTF file
      * @param dispose Dispose the exporter
      * @returns GLTFData with glTF file data
      */
-    _Exporter.prototype._generateGLTFAsync = function (glTFPrefix, dispose) {
-        var _this = this;
-        if (dispose === void 0) { dispose = true; }
-        return this._generateBinaryAsync().then(function (binaryBuffer) {
-            _this._extensionsOnExporting();
-            var jsonText = _this._generateJSON(false, glTFPrefix, true);
-            var bin = new Blob([binaryBuffer], { type: "application/octet-stream" });
-            var glTFFileName = glTFPrefix + ".gltf";
-            var glTFBinFile = glTFPrefix + ".bin";
-            var container = new GLTFData();
+    _generateGLTFAsync(glTFPrefix, dispose = true) {
+        return this._generateBinaryAsync().then((binaryBuffer) => {
+            this._extensionsOnExporting();
+            const jsonText = this._generateJSON(false, glTFPrefix, true);
+            const bin = new Blob([binaryBuffer], { type: "application/octet-stream" });
+            const glTFFileName = glTFPrefix + ".gltf";
+            const glTFBinFile = glTFPrefix + ".bin";
+            const container = new GLTFData();
             container.glTFFiles[glTFFileName] = jsonText;
             container.glTFFiles[glTFBinFile] = bin;
-            if (_this._imageData) {
-                for (var image in _this._imageData) {
-                    container.glTFFiles[image] = new Blob([_this._imageData[image].data], { type: _this._imageData[image].mimeType });
+            if (this._imageData) {
+                for (const image in this._imageData) {
+                    container.glTFFiles[image] = new Blob([this._imageData[image].data], { type: this._imageData[image].mimeType });
                 }
             }
             if (dispose) {
-                _this.dispose();
+                this.dispose();
             }
             return container;
         });
-    };
+    }
     /**
      * Creates a binary buffer for glTF
      * @returns array buffer for binary data
      */
-    _Exporter.prototype._generateBinaryAsync = function () {
-        var _this = this;
-        var binaryWriter = new _BinaryWriter(4);
-        return this._createSceneAsync(this._babylonScene, binaryWriter).then(function () {
-            if (_this._localEngine) {
-                _this._localEngine.dispose();
+    _generateBinaryAsync() {
+        const binaryWriter = new _BinaryWriter(4);
+        return this._createSceneAsync(this._babylonScene, binaryWriter).then(() => {
+            if (this._localEngine) {
+                this._localEngine.dispose();
             }
             return binaryWriter.getArrayBuffer();
         });
-    };
+    }
     /**
      * Pads the number to a multiple of 4
      * @param num number to pad
      * @returns padded number
      */
-    _Exporter.prototype._getPadding = function (num) {
-        var remainder = num % 4;
-        var padding = remainder === 0 ? remainder : 4 - remainder;
+    _getPadding(num) {
+        const remainder = num % 4;
+        const padding = remainder === 0 ? remainder : 4 - remainder;
         return padding;
-    };
+    }
     /**
      * @param glTFPrefix
      * @param dispose
      * @hidden
      */
-    _Exporter.prototype._generateGLBAsync = function (glTFPrefix, dispose) {
-        var _this = this;
-        if (dispose === void 0) { dispose = true; }
-        return this._generateBinaryAsync().then(function (binaryBuffer) {
-            _this._extensionsOnExporting();
-            var jsonText = _this._generateJSON(true);
-            var glbFileName = glTFPrefix + ".glb";
-            var headerLength = 12;
-            var chunkLengthPrefix = 8;
-            var jsonLength = jsonText.length;
-            var encodedJsonText;
-            var imageByteLength = 0;
+    _generateGLBAsync(glTFPrefix, dispose = true) {
+        return this._generateBinaryAsync().then((binaryBuffer) => {
+            this._extensionsOnExporting();
+            const jsonText = this._generateJSON(true);
+            const glbFileName = glTFPrefix + ".glb";
+            const headerLength = 12;
+            const chunkLengthPrefix = 8;
+            let jsonLength = jsonText.length;
+            let encodedJsonText;
+            let imageByteLength = 0;
             // make use of TextEncoder when available
             if (typeof TextEncoder !== "undefined") {
-                var encoder = new TextEncoder();
+                const encoder = new TextEncoder();
                 encodedJsonText = encoder.encode(jsonText);
                 jsonLength = encodedJsonText.length;
             }
-            for (var i = 0; i < _this._orderedImageData.length; ++i) {
-                imageByteLength += _this._orderedImageData[i].data.byteLength;
+            for (let i = 0; i < this._orderedImageData.length; ++i) {
+                imageByteLength += this._orderedImageData[i].data.byteLength;
             }
-            var jsonPadding = _this._getPadding(jsonLength);
-            var binPadding = _this._getPadding(binaryBuffer.byteLength);
-            var imagePadding = _this._getPadding(imageByteLength);
-            var byteLength = headerLength + 2 * chunkLengthPrefix + jsonLength + jsonPadding + binaryBuffer.byteLength + binPadding + imageByteLength + imagePadding;
+            const jsonPadding = this._getPadding(jsonLength);
+            const binPadding = this._getPadding(binaryBuffer.byteLength);
+            const imagePadding = this._getPadding(imageByteLength);
+            const byteLength = headerLength + 2 * chunkLengthPrefix + jsonLength + jsonPadding + binaryBuffer.byteLength + binPadding + imageByteLength + imagePadding;
             //header
-            var headerBuffer = new ArrayBuffer(headerLength);
-            var headerBufferView = new DataView(headerBuffer);
+            const headerBuffer = new ArrayBuffer(headerLength);
+            const headerBufferView = new DataView(headerBuffer);
             headerBufferView.setUint32(0, 0x46546c67, true); //glTF
             headerBufferView.setUint32(4, 2, true); // version
             headerBufferView.setUint32(8, byteLength, true); // total bytes in file
             //json chunk
-            var jsonChunkBuffer = new ArrayBuffer(chunkLengthPrefix + jsonLength + jsonPadding);
-            var jsonChunkBufferView = new DataView(jsonChunkBuffer);
+            const jsonChunkBuffer = new ArrayBuffer(chunkLengthPrefix + jsonLength + jsonPadding);
+            const jsonChunkBufferView = new DataView(jsonChunkBuffer);
             jsonChunkBufferView.setUint32(0, jsonLength + jsonPadding, true);
             jsonChunkBufferView.setUint32(4, 0x4e4f534a, true);
             //json chunk bytes
-            var jsonData = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix);
+            const jsonData = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix);
             // if TextEncoder was available, we can simply copy the encoded array
             if (encodedJsonText) {
                 jsonData.set(encodedJsonText);
             }
             else {
-                var blankCharCode = "_".charCodeAt(0);
-                for (var i = 0; i < jsonLength; ++i) {
-                    var charCode = jsonText.charCodeAt(i);
+                const blankCharCode = "_".charCodeAt(0);
+                for (let i = 0; i < jsonLength; ++i) {
+                    const charCode = jsonText.charCodeAt(i);
                     // if the character doesn't fit into a single UTF-16 code unit, just put a blank character
                     if (charCode != jsonText.codePointAt(i)) {
                         jsonData[i] = blankCharCode;
@@ -940,52 +916,52 @@ var _Exporter = /** @class */ (function () {
                 }
             }
             //json padding
-            var jsonPaddingView = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix + jsonLength);
-            for (var i = 0; i < jsonPadding; ++i) {
+            const jsonPaddingView = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix + jsonLength);
+            for (let i = 0; i < jsonPadding; ++i) {
                 jsonPaddingView[i] = 0x20;
             }
             //binary chunk
-            var binaryChunkBuffer = new ArrayBuffer(chunkLengthPrefix);
-            var binaryChunkBufferView = new DataView(binaryChunkBuffer);
+            const binaryChunkBuffer = new ArrayBuffer(chunkLengthPrefix);
+            const binaryChunkBufferView = new DataView(binaryChunkBuffer);
             binaryChunkBufferView.setUint32(0, binaryBuffer.byteLength + imageByteLength + imagePadding, true);
             binaryChunkBufferView.setUint32(4, 0x004e4942, true);
             // binary padding
-            var binPaddingBuffer = new ArrayBuffer(binPadding);
-            var binPaddingView = new Uint8Array(binPaddingBuffer);
-            for (var i = 0; i < binPadding; ++i) {
+            const binPaddingBuffer = new ArrayBuffer(binPadding);
+            const binPaddingView = new Uint8Array(binPaddingBuffer);
+            for (let i = 0; i < binPadding; ++i) {
                 binPaddingView[i] = 0;
             }
-            var imagePaddingBuffer = new ArrayBuffer(imagePadding);
-            var imagePaddingView = new Uint8Array(imagePaddingBuffer);
-            for (var i = 0; i < imagePadding; ++i) {
+            const imagePaddingBuffer = new ArrayBuffer(imagePadding);
+            const imagePaddingView = new Uint8Array(imagePaddingBuffer);
+            for (let i = 0; i < imagePadding; ++i) {
                 imagePaddingView[i] = 0;
             }
-            var glbData = [headerBuffer, jsonChunkBuffer, binaryChunkBuffer, binaryBuffer];
+            const glbData = [headerBuffer, jsonChunkBuffer, binaryChunkBuffer, binaryBuffer];
             // binary data
-            for (var i = 0; i < _this._orderedImageData.length; ++i) {
-                glbData.push(_this._orderedImageData[i].data.buffer);
+            for (let i = 0; i < this._orderedImageData.length; ++i) {
+                glbData.push(this._orderedImageData[i].data.buffer);
             }
             glbData.push(binPaddingBuffer);
             glbData.push(imagePaddingBuffer);
-            var glbFile = new Blob(glbData, { type: "application/octet-stream" });
-            var container = new GLTFData();
+            const glbFile = new Blob(glbData, { type: "application/octet-stream" });
+            const container = new GLTFData();
             container.glTFFiles[glbFileName] = glbFile;
-            if (_this._localEngine != null) {
-                _this._localEngine.dispose();
+            if (this._localEngine != null) {
+                this._localEngine.dispose();
             }
             if (dispose) {
-                _this.dispose();
+                this.dispose();
             }
             return container;
         });
-    };
+    }
     /**
      * Sets the TRS for each node
      * @param node glTF Node for storing the transformation data
      * @param babylonTransformNode Babylon mesh used as the source for the transformation data
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._setNodeTransformation = function (node, babylonTransformNode, convertToRightHandedSystem) {
+    _setNodeTransformation(node, babylonTransformNode, convertToRightHandedSystem) {
         if (!babylonTransformNode.getPivotPoint().equalsToFloats(0, 0, 0)) {
             Tools.Warn("Pivot points are not supported in the glTF serializer");
         }
@@ -997,7 +973,7 @@ var _Exporter = /** @class */ (function () {
         if (!babylonTransformNode.scaling.equalsToFloats(1, 1, 1)) {
             node.scale = babylonTransformNode.scaling.asArray();
         }
-        var rotationQuaternion = Quaternion.RotationYawPitchRoll(babylonTransformNode.rotation.y, babylonTransformNode.rotation.x, babylonTransformNode.rotation.z);
+        const rotationQuaternion = Quaternion.RotationYawPitchRoll(babylonTransformNode.rotation.y, babylonTransformNode.rotation.x, babylonTransformNode.rotation.z);
         if (babylonTransformNode.rotationQuaternion) {
             rotationQuaternion.multiplyInPlace(babylonTransformNode.rotationQuaternion);
         }
@@ -1007,28 +983,28 @@ var _Exporter = /** @class */ (function () {
             }
             node.rotation = rotationQuaternion.normalize().asArray();
         }
-    };
-    _Exporter.prototype._setCameraTransformation = function (node, babylonCamera, convertToRightHandedSystem) {
+    }
+    _setCameraTransformation(node, babylonCamera, convertToRightHandedSystem) {
         if (!babylonCamera.position.equalsToFloats(0, 0, 0)) {
             node.translation = convertToRightHandedSystem ? _GLTFUtilities._GetRightHandedPositionVector3(babylonCamera.position).asArray() : babylonCamera.position.asArray();
         }
-        var rotationQuaternion = babylonCamera.rotationQuaternion; // we target the local transformation if one.
+        const rotationQuaternion = babylonCamera.rotationQuaternion; // we target the local transformation if one.
         if (rotationQuaternion && !Quaternion.IsIdentity(rotationQuaternion)) {
             if (convertToRightHandedSystem) {
                 _GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
             }
             node.rotation = rotationQuaternion.normalize().asArray();
         }
-    };
-    _Exporter.prototype._getVertexBufferFromMesh = function (attributeKind, bufferMesh) {
+    }
+    _getVertexBufferFromMesh(attributeKind, bufferMesh) {
         if (bufferMesh.isVerticesDataPresent(attributeKind)) {
-            var vertexBuffer = bufferMesh.getVertexBuffer(attributeKind);
+            const vertexBuffer = bufferMesh.getVertexBuffer(attributeKind);
             if (vertexBuffer) {
                 return vertexBuffer;
             }
         }
         return null;
-    };
+    }
     /**
      * Creates a bufferview based on the vertices type for the Babylon mesh
      * @param kind Indicates the type of vertices data
@@ -1038,24 +1014,24 @@ var _Exporter = /** @class */ (function () {
      * @param byteStride
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._createBufferViewKind = function (kind, attributeComponentKind, babylonTransformNode, binaryWriter, byteStride, convertToRightHandedSystem) {
-        var bufferMesh = babylonTransformNode instanceof Mesh
+    _createBufferViewKind(kind, attributeComponentKind, babylonTransformNode, binaryWriter, byteStride, convertToRightHandedSystem) {
+        const bufferMesh = babylonTransformNode instanceof Mesh
             ? babylonTransformNode
             : babylonTransformNode instanceof InstancedMesh
                 ? babylonTransformNode.sourceMesh
                 : null;
         if (bufferMesh) {
-            var vertexBuffer = bufferMesh.getVertexBuffer(kind);
-            var vertexData = bufferMesh.getVerticesData(kind);
+            const vertexBuffer = bufferMesh.getVertexBuffer(kind);
+            const vertexData = bufferMesh.getVerticesData(kind);
             if (vertexBuffer && vertexData) {
-                var typeByteLength = VertexBuffer.GetTypeByteLength(attributeComponentKind);
-                var byteLength = vertexData.length * typeByteLength;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, kind + " - " + bufferMesh.name);
+                const typeByteLength = VertexBuffer.GetTypeByteLength(attributeComponentKind);
+                const byteLength = vertexData.length * typeByteLength;
+                const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, kind + " - " + bufferMesh.name);
                 this._bufferViews.push(bufferView);
                 this._writeAttributeData(kind, attributeComponentKind, vertexData, byteStride / typeByteLength, binaryWriter, convertToRightHandedSystem, babylonTransformNode);
             }
         }
-    };
+    }
     /**
      * Creates a bufferview based on the vertices type for the Babylon mesh
      * @param babylonSubMesh The Babylon submesh that the morph target is applied to
@@ -1064,37 +1040,37 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter The buffer to write the bufferview data to
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._setMorphTargetAttributes = function (babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter, convertToRightHandedSystem) {
+    _setMorphTargetAttributes(babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter, convertToRightHandedSystem) {
         if (babylonMorphTarget) {
             if (!meshPrimitive.targets) {
                 meshPrimitive.targets = [];
             }
-            var target = {};
+            const target = {};
             if (babylonMorphTarget.hasNormals) {
-                var vertexNormals = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.NormalKind);
-                var morphNormals = babylonMorphTarget.getNormals();
-                var count = babylonSubMesh.verticesCount;
-                var byteStride = 12; // 3 x 4 byte floats
-                var byteLength = count * byteStride;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
+                const vertexNormals = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.NormalKind);
+                const morphNormals = babylonMorphTarget.getNormals();
+                const count = babylonSubMesh.verticesCount;
+                const byteStride = 12; // 3 x 4 byte floats
+                const byteLength = count * byteStride;
+                const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
                 this._bufferViews.push(bufferView);
-                var bufferViewIndex = this._bufferViews.length - 1;
-                var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "NORMAL", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
+                const bufferViewIndex = this._bufferViews.length - 1;
+                const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "NORMAL", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.NORMAL = this._accessors.length - 1;
                 this.writeMorphTargetAttributeData(VertexBuffer.NormalKind, 5126 /* FLOAT */, babylonSubMesh, babylonMorphTarget, vertexNormals, morphNormals, byteStride / 4, binaryWriter, convertToRightHandedSystem);
             }
             if (babylonMorphTarget.hasPositions) {
-                var vertexPositions = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.PositionKind);
-                var morphPositions = babylonMorphTarget.getPositions();
-                var count = babylonSubMesh.verticesCount;
-                var byteStride = 12; // 3 x 4 byte floats
-                var byteLength = count * byteStride;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_POSITION");
+                const vertexPositions = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.PositionKind);
+                const morphPositions = babylonMorphTarget.getPositions();
+                const count = babylonSubMesh.verticesCount;
+                const byteStride = 12; // 3 x 4 byte floats
+                const byteLength = count * byteStride;
+                const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_POSITION");
                 this._bufferViews.push(bufferView);
-                var bufferViewIndex = this._bufferViews.length - 1;
-                var minMax = { min: new Vector3(Infinity, Infinity, Infinity), max: new Vector3(-Infinity, -Infinity, -Infinity) };
-                var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "POSITION", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
+                const bufferViewIndex = this._bufferViews.length - 1;
+                const minMax = { min: new Vector3(Infinity, Infinity, Infinity), max: new Vector3(-Infinity, -Infinity, -Infinity) };
+                const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "POSITION", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.POSITION = this._accessors.length - 1;
                 this.writeMorphTargetAttributeData(VertexBuffer.PositionKind, 5126 /* FLOAT */, babylonSubMesh, babylonMorphTarget, vertexPositions, morphPositions, byteStride / 4, binaryWriter, convertToRightHandedSystem, minMax);
@@ -1102,38 +1078,38 @@ var _Exporter = /** @class */ (function () {
                 accessor.max = minMax.max.asArray();
             }
             if (babylonMorphTarget.hasTangents) {
-                var vertexTangents = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.TangentKind);
-                var morphTangents = babylonMorphTarget.getTangents();
-                var count = babylonSubMesh.verticesCount;
-                var byteStride = 12; // 3 x 4 byte floats
-                var byteLength = count * byteStride;
-                var bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
+                const vertexTangents = babylonSubMesh.getMesh().getVerticesData(VertexBuffer.TangentKind);
+                const morphTangents = babylonMorphTarget.getTangents();
+                const count = babylonSubMesh.verticesCount;
+                const byteStride = 12; // 3 x 4 byte floats
+                const byteLength = count * byteStride;
+                const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
                 this._bufferViews.push(bufferView);
-                var bufferViewIndex = this._bufferViews.length - 1;
-                var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "TANGENT", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
+                const bufferViewIndex = this._bufferViews.length - 1;
+                const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "TANGENT", "VEC3" /* VEC3 */, 5126 /* FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.TANGENT = this._accessors.length - 1;
                 this.writeMorphTargetAttributeData(VertexBuffer.TangentKind, 5126 /* FLOAT */, babylonSubMesh, babylonMorphTarget, vertexTangents, morphTangents, byteStride / 4, binaryWriter, convertToRightHandedSystem);
             }
             meshPrimitive.targets.push(target);
         }
-    };
+    }
     /**
      * The primitive mode of the Babylon mesh
      * @param babylonMesh The BabylonJS mesh
      */
-    _Exporter.prototype._getMeshPrimitiveMode = function (babylonMesh) {
+    _getMeshPrimitiveMode(babylonMesh) {
         if (babylonMesh instanceof LinesMesh) {
             return Material.LineListDrawMode;
         }
         return babylonMesh.material ? babylonMesh.material.fillMode : Material.TriangleFillMode;
-    };
+    }
     /**
      * Sets the primitive mode of the glTF mesh primitive
      * @param meshPrimitive glTF mesh primitive
      * @param primitiveMode The primitive mode
      */
-    _Exporter.prototype._setPrimitiveMode = function (meshPrimitive, primitiveMode) {
+    _setPrimitiveMode(meshPrimitive, primitiveMode) {
         switch (primitiveMode) {
             case Material.TriangleFillMode: {
                 // glTF defaults to using Triangle Mode
@@ -1168,14 +1144,14 @@ var _Exporter = /** @class */ (function () {
                 break;
             }
         }
-    };
+    }
     /**
      * Sets the vertex attribute accessor based of the glTF mesh primitive
      * @param meshPrimitive glTF mesh primitive
      * @param attributeKind vertex attribute
      * @returns boolean specifying if uv coordinates are present
      */
-    _Exporter.prototype._setAttributeKind = function (meshPrimitive, attributeKind) {
+    _setAttributeKind(meshPrimitive, attributeKind) {
         switch (attributeKind) {
             case VertexBuffer.PositionKind: {
                 meshPrimitive.attributes.POSITION = this._accessors.length - 1;
@@ -1221,7 +1197,7 @@ var _Exporter = /** @class */ (function () {
                 Tools.Warn("Unsupported Vertex Buffer Type: " + attributeKind);
             }
         }
-    };
+    }
     /**
      * Sets data for the primitive attributes of each submesh
      * @param mesh glTF Mesh object to store the primitive attribute information
@@ -1229,19 +1205,18 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter Buffer to write the attribute data to
      * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._setPrimitiveAttributesAsync = function (mesh, babylonTransformNode, binaryWriter, convertToRightHandedSystem) {
-        var _a;
-        var promises = [];
-        var bufferMesh = null;
-        var bufferView;
-        var minMax;
+    _setPrimitiveAttributesAsync(mesh, babylonTransformNode, binaryWriter, convertToRightHandedSystem) {
+        const promises = [];
+        let bufferMesh = null;
+        let bufferView;
+        let minMax;
         if (babylonTransformNode instanceof Mesh) {
             bufferMesh = babylonTransformNode;
         }
         else if (babylonTransformNode instanceof InstancedMesh) {
             bufferMesh = babylonTransformNode.sourceMesh;
         }
-        var attributeData = [
+        const attributeData = [
             { kind: VertexBuffer.PositionKind, accessorType: "VEC3" /* VEC3 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 12 },
             { kind: VertexBuffer.NormalKind, accessorType: "VEC3" /* VEC3 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 12 },
             { kind: VertexBuffer.ColorKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 16 },
@@ -1254,17 +1229,16 @@ var _Exporter = /** @class */ (function () {
             { kind: VertexBuffer.MatricesWeightsExtraKind, accessorType: "VEC4" /* VEC4 */, accessorComponentType: 5126 /* FLOAT */, byteStride: 16 },
         ];
         if (bufferMesh) {
-            var indexBufferViewIndex = null;
-            var primitiveMode = this._getMeshPrimitiveMode(bufferMesh);
-            var vertexAttributeBufferViews = {};
-            var morphTargetManager = bufferMesh.morphTargetManager;
+            let indexBufferViewIndex = null;
+            const primitiveMode = this._getMeshPrimitiveMode(bufferMesh);
+            const vertexAttributeBufferViews = {};
+            const morphTargetManager = bufferMesh.morphTargetManager;
             // For each BabylonMesh, create bufferviews for each 'kind'
-            for (var _i = 0, attributeData_1 = attributeData; _i < attributeData_1.length; _i++) {
-                var attribute = attributeData_1[_i];
-                var attributeKind = attribute.kind;
-                var attributeComponentKind = attribute.accessorComponentType;
+            for (const attribute of attributeData) {
+                const attributeKind = attribute.kind;
+                const attributeComponentKind = attribute.accessorComponentType;
                 if (bufferMesh.isVerticesDataPresent(attributeKind)) {
-                    var vertexBuffer = this._getVertexBufferFromMesh(attributeKind, bufferMesh);
+                    const vertexBuffer = this._getVertexBufferFromMesh(attributeKind, bufferMesh);
                     attribute.byteStride = vertexBuffer
                         ? vertexBuffer.getSize() * VertexBuffer.GetTypeByteLength(attribute.accessorComponentType)
                         : VertexBuffer.DeduceStride(attributeKind) * 4;
@@ -1277,27 +1251,26 @@ var _Exporter = /** @class */ (function () {
                 }
             }
             if (bufferMesh.getTotalIndices()) {
-                var indices = bufferMesh.getIndices();
+                const indices = bufferMesh.getIndices();
                 if (indices) {
-                    var byteLength = indices.length * 4;
+                    const byteLength = indices.length * 4;
                     bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, "Indices - " + bufferMesh.name);
                     this._bufferViews.push(bufferView);
                     indexBufferViewIndex = this._bufferViews.length - 1;
-                    for (var k = 0, length_9 = indices.length; k < length_9; ++k) {
+                    for (let k = 0, length = indices.length; k < length; ++k) {
                         binaryWriter.setUInt32(indices[k]);
                     }
                 }
             }
             if (bufferMesh.subMeshes) {
                 // go through all mesh primitives (submeshes)
-                for (var _b = 0, _c = bufferMesh.subMeshes; _b < _c.length; _b++) {
-                    var submesh = _c[_b];
-                    var babylonMaterial = submesh.getMaterial() || bufferMesh.getScene().defaultMaterial;
-                    var materialIndex = null;
+                for (const submesh of bufferMesh.subMeshes) {
+                    let babylonMaterial = submesh.getMaterial() || bufferMesh.getScene().defaultMaterial;
+                    let materialIndex = null;
                     if (babylonMaterial) {
                         if (bufferMesh instanceof LinesMesh) {
                             // get the color from the lines mesh and set it in the material
-                            var material = {
+                            const material = {
                                 name: bufferMesh.name + " material",
                             };
                             if (!bufferMesh.color.equals(Color3.White()) || bufferMesh.alpha < 1) {
@@ -1309,7 +1282,7 @@ var _Exporter = /** @class */ (function () {
                             materialIndex = this._materials.length - 1;
                         }
                         else if (babylonMaterial instanceof MultiMaterial) {
-                            var subMaterial = babylonMaterial.subMaterials[submesh.materialIndex];
+                            const subMaterial = babylonMaterial.subMaterials[submesh.materialIndex];
                             if (subMaterial) {
                                 babylonMaterial = subMaterial;
                                 materialIndex = this._materialMap[babylonMaterial.uniqueId];
@@ -1319,30 +1292,29 @@ var _Exporter = /** @class */ (function () {
                             materialIndex = this._materialMap[babylonMaterial.uniqueId];
                         }
                     }
-                    var glTFMaterial = materialIndex != null ? this._materials[materialIndex] : null;
-                    var meshPrimitive = { attributes: {} };
+                    const glTFMaterial = materialIndex != null ? this._materials[materialIndex] : null;
+                    const meshPrimitive = { attributes: {} };
                     this._setPrimitiveMode(meshPrimitive, primitiveMode);
-                    for (var _d = 0, attributeData_2 = attributeData; _d < attributeData_2.length; _d++) {
-                        var attribute = attributeData_2[_d];
-                        var attributeKind = attribute.kind;
+                    for (const attribute of attributeData) {
+                        const attributeKind = attribute.kind;
                         if ((attributeKind === VertexBuffer.UVKind || attributeKind === VertexBuffer.UV2Kind) && !this._options.exportUnusedUVs) {
                             if (!glTFMaterial || !this._glTFMaterialExporter._hasTexturesPresent(glTFMaterial)) {
                                 continue;
                             }
                         }
-                        var vertexData = bufferMesh.getVerticesData(attributeKind);
+                        const vertexData = bufferMesh.getVerticesData(attributeKind);
                         if (vertexData) {
-                            var vertexBuffer = this._getVertexBufferFromMesh(attributeKind, bufferMesh);
+                            const vertexBuffer = this._getVertexBufferFromMesh(attributeKind, bufferMesh);
                             if (vertexBuffer) {
-                                var stride = vertexBuffer.getSize();
-                                var bufferViewIndex = attribute.bufferViewIndex;
+                                const stride = vertexBuffer.getSize();
+                                const bufferViewIndex = attribute.bufferViewIndex;
                                 if (bufferViewIndex != undefined) {
                                     // check to see if bufferviewindex has a numeric value assigned.
                                     minMax = { min: null, max: null };
                                     if (attributeKind == VertexBuffer.PositionKind) {
                                         minMax = _GLTFUtilities._CalculateMinMaxPositions(vertexData, 0, vertexData.length / stride, convertToRightHandedSystem);
                                     }
-                                    var accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, attributeKind + " - " + babylonTransformNode.name, attribute.accessorType, attribute.accessorComponentType, vertexData.length / stride, 0, minMax.min, minMax.max);
+                                    const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, attributeKind + " - " + babylonTransformNode.name, attribute.accessorType, attribute.accessorComponentType, vertexData.length / stride, 0, minMax.min, minMax.max);
                                     this._accessors.push(accessor);
                                     this._setAttributeKind(meshPrimitive, attributeKind);
                                 }
@@ -1351,21 +1323,21 @@ var _Exporter = /** @class */ (function () {
                     }
                     if (indexBufferViewIndex) {
                         // Create accessor
-                        var accessor = _GLTFUtilities._CreateAccessor(indexBufferViewIndex, "indices - " + babylonTransformNode.name, "SCALAR" /* SCALAR */, 5125 /* UNSIGNED_INT */, submesh.indexCount, submesh.indexStart * 4, null, null);
+                        const accessor = _GLTFUtilities._CreateAccessor(indexBufferViewIndex, "indices - " + babylonTransformNode.name, "SCALAR" /* SCALAR */, 5125 /* UNSIGNED_INT */, submesh.indexCount, submesh.indexStart * 4, null, null);
                         this._accessors.push(accessor);
                         meshPrimitive.indices = this._accessors.length - 1;
                     }
                     if (materialIndex != null && Object.keys(meshPrimitive.attributes).length > 0) {
-                        var sideOrientation = bufferMesh.overrideMaterialSideOrientation !== null ? bufferMesh.overrideMaterialSideOrientation : babylonMaterial.sideOrientation;
+                        const sideOrientation = bufferMesh.overrideMaterialSideOrientation !== null ? bufferMesh.overrideMaterialSideOrientation : babylonMaterial.sideOrientation;
                         if ((sideOrientation == Material.ClockWiseSideOrientation && this._babylonScene.useRightHandedSystem) ||
                             (sideOrientation == Material.ClockWiseSideOrientation &&
                                 convertToRightHandedSystem &&
-                                bufferMesh.overrideMaterialSideOrientation !== ((_a = bufferMesh.material) === null || _a === void 0 ? void 0 : _a.sideOrientation))) {
-                            var byteOffset = indexBufferViewIndex != null ? this._bufferViews[indexBufferViewIndex].byteOffset : null;
+                                bufferMesh.overrideMaterialSideOrientation !== bufferMesh.material?.sideOrientation)) {
+                            let byteOffset = indexBufferViewIndex != null ? this._bufferViews[indexBufferViewIndex].byteOffset : null;
                             if (byteOffset == null) {
                                 byteOffset = 0;
                             }
-                            var babylonIndices = null;
+                            let babylonIndices = null;
                             if (indexBufferViewIndex != null) {
                                 babylonIndices = bufferMesh.getIndices();
                             }
@@ -1373,15 +1345,14 @@ var _Exporter = /** @class */ (function () {
                                 this._reorderIndicesBasedOnPrimitiveMode(submesh, primitiveMode, babylonIndices, byteOffset, binaryWriter);
                             }
                             else {
-                                for (var _e = 0, attributeData_3 = attributeData; _e < attributeData_3.length; _e++) {
-                                    var attribute = attributeData_3[_e];
-                                    var vertexData = bufferMesh.getVerticesData(attribute.kind);
+                                for (const attribute of attributeData) {
+                                    const vertexData = bufferMesh.getVerticesData(attribute.kind);
                                     if (vertexData) {
-                                        var byteOffset_1 = this._bufferViews[vertexAttributeBufferViews[attribute.kind]].byteOffset;
-                                        if (!byteOffset_1) {
-                                            byteOffset_1 = 0;
+                                        let byteOffset = this._bufferViews[vertexAttributeBufferViews[attribute.kind]].byteOffset;
+                                        if (!byteOffset) {
+                                            byteOffset = 0;
                                         }
-                                        this._reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, sideOrientation, attribute.kind, vertexData, byteOffset_1, binaryWriter, convertToRightHandedSystem);
+                                        this._reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, sideOrientation, attribute.kind, vertexData, byteOffset, binaryWriter, convertToRightHandedSystem);
                                     }
                                 }
                             }
@@ -1389,8 +1360,8 @@ var _Exporter = /** @class */ (function () {
                         meshPrimitive.material = materialIndex;
                     }
                     if (morphTargetManager) {
-                        var target = void 0;
-                        for (var i = 0; i < morphTargetManager.numTargets; ++i) {
+                        let target;
+                        for (let i = 0; i < morphTargetManager.numTargets; ++i) {
                             target = morphTargetManager.getTarget(i);
                             this._setMorphTargetAttributes(submesh, meshPrimitive, target, binaryWriter, convertToRightHandedSystem);
                         }
@@ -1401,22 +1372,22 @@ var _Exporter = /** @class */ (function () {
                 }
             }
         }
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             /* do nothing */
         });
-    };
+    }
     /**
      * Check if the node is used to convert its descendants from a right handed coordinate system to the Babylon scene's coordinate system.
      * @param node The node to check
      * @returns True if the node is used to convert its descendants from right-handed to left-handed. False otherwise
      */
-    _Exporter.prototype._isBabylonCoordinateSystemConvertingNode = function (node) {
+    _isBabylonCoordinateSystemConvertingNode(node) {
         if (node instanceof TransformNode) {
             if (node.name !== "__root__") {
                 return false;
             }
             // Transform
-            var matrix = node.getWorldMatrix();
+            const matrix = node.getWorldMatrix();
             if (matrix.determinant() === 1) {
                 return false;
             }
@@ -1430,51 +1401,50 @@ var _Exporter = /** @class */ (function () {
             return true;
         }
         return false;
-    };
+    }
     /**
      * Creates a glTF scene based on the array of meshes
      * Returns the the total byte offset
      * @param babylonScene Babylon scene to get the mesh data from
      * @param binaryWriter Buffer to write binary data to
      */
-    _Exporter.prototype._createSceneAsync = function (babylonScene, binaryWriter) {
-        var _this = this;
-        var scene = { nodes: [] };
-        var glTFNodeIndex;
-        var glTFNode;
-        var directDescendents;
-        var nodes = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], babylonScene.transformNodes, true), babylonScene.meshes, true), babylonScene.lights, true), babylonScene.cameras, true);
-        var rootNodesToLeftHanded = [];
+    _createSceneAsync(babylonScene, binaryWriter) {
+        const scene = { nodes: [] };
+        let glTFNodeIndex;
+        let glTFNode;
+        let directDescendents;
+        const nodes = [...babylonScene.transformNodes, ...babylonScene.meshes, ...babylonScene.lights, ...babylonScene.cameras];
+        const rootNodesToLeftHanded = [];
         this._convertToRightHandedSystem = !babylonScene.useRightHandedSystem;
         this._convertToRightHandedSystemMap = {};
         // Set default values for all nodes
-        babylonScene.rootNodes.forEach(function (rootNode) {
-            _this._convertToRightHandedSystemMap[rootNode.uniqueId] = _this._convertToRightHandedSystem;
-            rootNode.getDescendants(false).forEach(function (descendant) {
-                _this._convertToRightHandedSystemMap[descendant.uniqueId] = _this._convertToRightHandedSystem;
+        babylonScene.rootNodes.forEach((rootNode) => {
+            this._convertToRightHandedSystemMap[rootNode.uniqueId] = this._convertToRightHandedSystem;
+            rootNode.getDescendants(false).forEach((descendant) => {
+                this._convertToRightHandedSystemMap[descendant.uniqueId] = this._convertToRightHandedSystem;
             });
         });
         // Check if root nodes converting to left-handed are present
-        babylonScene.rootNodes.forEach(function (rootNode) {
-            if (_this._isBabylonCoordinateSystemConvertingNode(rootNode)) {
+        babylonScene.rootNodes.forEach((rootNode) => {
+            if (this._isBabylonCoordinateSystemConvertingNode(rootNode)) {
                 rootNodesToLeftHanded.push(rootNode);
                 // Exclude the node from list of nodes to export
-                var indexRootNode = nodes.indexOf(rootNode);
+                const indexRootNode = nodes.indexOf(rootNode);
                 if (indexRootNode !== -1) {
                     // should always be true
                     nodes.splice(indexRootNode, 1);
                 }
                 // Cancel conversion to right handed system
-                rootNode.getDescendants(false).forEach(function (descendant) {
-                    _this._convertToRightHandedSystemMap[descendant.uniqueId] = false;
+                rootNode.getDescendants(false).forEach((descendant) => {
+                    this._convertToRightHandedSystemMap[descendant.uniqueId] = false;
                 });
             }
         });
         // Export babylon cameras to glTFCamera
-        var cameraMap = new Map();
-        babylonScene.cameras.forEach(function (camera) {
-            if (!_this._options.shouldExportNode || _this._options.shouldExportNode(camera)) {
-                var glTFCamera = {
+        const cameraMap = new Map();
+        babylonScene.cameras.forEach((camera) => {
+            if (!this._options.shouldExportNode || this._options.shouldExportNode(camera)) {
+                const glTFCamera = {
                     type: camera.mode === Camera.PERSPECTIVE_CAMERA ? "perspective" /* PERSPECTIVE */ : "orthographic" /* ORTHOGRAPHIC */,
                 };
                 if (camera.name) {
@@ -1489,8 +1459,8 @@ var _Exporter = /** @class */ (function () {
                     };
                 }
                 else if (glTFCamera.type === "orthographic" /* ORTHOGRAPHIC */) {
-                    var halfWidth = camera.orthoLeft && camera.orthoRight ? 0.5 * (camera.orthoRight - camera.orthoLeft) : camera.getEngine().getRenderWidth() * 0.5;
-                    var halfHeight = camera.orthoBottom && camera.orthoTop ? 0.5 * (camera.orthoTop - camera.orthoBottom) : camera.getEngine().getRenderHeight() * 0.5;
+                    const halfWidth = camera.orthoLeft && camera.orthoRight ? 0.5 * (camera.orthoRight - camera.orthoLeft) : camera.getEngine().getRenderWidth() * 0.5;
+                    const halfHeight = camera.orthoBottom && camera.orthoTop ? 0.5 * (camera.orthoTop - camera.orthoBottom) : camera.getEngine().getRenderHeight() * 0.5;
                     glTFCamera.orthographic = {
                         xmag: halfWidth,
                         ymag: halfHeight,
@@ -1498,28 +1468,27 @@ var _Exporter = /** @class */ (function () {
                         zfar: camera.maxZ,
                     };
                 }
-                cameraMap.set(camera, _this._cameras.length);
-                _this._cameras.push(glTFCamera);
+                cameraMap.set(camera, this._cameras.length);
+                this._cameras.push(glTFCamera);
             }
         });
-        var _a = this._getExportNodes(nodes), exportNodes = _a[0], exportMaterials = _a[1];
-        return this._glTFMaterialExporter._convertMaterialsToGLTFAsync(exportMaterials, "image/png" /* PNG */, true).then(function () {
-            return _this._createNodeMapAndAnimationsAsync(babylonScene, exportNodes, binaryWriter).then(function (nodeMap) {
-                return _this._createSkinsAsync(babylonScene, nodeMap, binaryWriter).then(function (skinMap) {
-                    _this._nodeMap = nodeMap;
-                    _this._totalByteLength = binaryWriter.getByteOffset();
-                    if (_this._totalByteLength == undefined) {
+        const [exportNodes, exportMaterials] = this._getExportNodes(nodes);
+        return this._glTFMaterialExporter._convertMaterialsToGLTFAsync(exportMaterials, "image/png" /* PNG */, true).then(() => {
+            return this._createNodeMapAndAnimationsAsync(babylonScene, exportNodes, binaryWriter).then((nodeMap) => {
+                return this._createSkinsAsync(babylonScene, nodeMap, binaryWriter).then((skinMap) => {
+                    this._nodeMap = nodeMap;
+                    this._totalByteLength = binaryWriter.getByteOffset();
+                    if (this._totalByteLength == undefined) {
                         throw new Error("undefined byte length!");
                     }
                     // Build Hierarchy with the node map.
-                    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-                        var babylonNode = nodes_1[_i];
-                        glTFNodeIndex = _this._nodeMap[babylonNode.uniqueId];
+                    for (const babylonNode of nodes) {
+                        glTFNodeIndex = this._nodeMap[babylonNode.uniqueId];
                         if (glTFNodeIndex !== undefined) {
-                            glTFNode = _this._nodes[glTFNodeIndex];
+                            glTFNode = this._nodes[glTFNodeIndex];
                             if (babylonNode.metadata) {
-                                if (_this._options.metadataSelector) {
-                                    glTFNode.extras = _this._options.metadataSelector(babylonNode.metadata);
+                                if (this._options.metadataSelector) {
+                                    glTFNode.extras = this._options.metadataSelector(babylonNode.metadata);
                                 }
                                 else if (babylonNode.metadata.gltf) {
                                     glTFNode.extras = babylonNode.metadata.gltf.extras;
@@ -1529,11 +1498,11 @@ var _Exporter = /** @class */ (function () {
                                 glTFNode.camera = cameraMap.get(babylonNode);
                             }
                             if (!babylonNode.parent || rootNodesToLeftHanded.indexOf(babylonNode.parent) !== -1) {
-                                if (_this._options.shouldExportNode && !_this._options.shouldExportNode(babylonNode)) {
+                                if (this._options.shouldExportNode && !this._options.shouldExportNode(babylonNode)) {
                                     Tools.Log("Omitting " + babylonNode.name + " from scene.");
                                 }
                                 else {
-                                    var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
+                                    const convertToRightHandedSystem = this._convertToRightHandedSystemMap[babylonNode.uniqueId];
                                     if (convertToRightHandedSystem) {
                                         if (glTFNode.translation) {
                                             glTFNode.translation[2] *= -1;
@@ -1547,18 +1516,17 @@ var _Exporter = /** @class */ (function () {
                                 }
                             }
                             if (babylonNode instanceof Mesh) {
-                                var babylonMesh = babylonNode;
+                                const babylonMesh = babylonNode;
                                 if (babylonMesh.skeleton) {
                                     glTFNode.skin = skinMap[babylonMesh.skeleton.uniqueId];
                                 }
                             }
                             directDescendents = babylonNode.getDescendants(true);
                             if (!glTFNode.children && directDescendents && directDescendents.length) {
-                                var children = [];
-                                for (var _a = 0, directDescendents_1 = directDescendents; _a < directDescendents_1.length; _a++) {
-                                    var descendent = directDescendents_1[_a];
-                                    if (_this._nodeMap[descendent.uniqueId] != null) {
-                                        children.push(_this._nodeMap[descendent.uniqueId]);
+                                const children = [];
+                                for (const descendent of directDescendents) {
+                                    if (this._nodeMap[descendent.uniqueId] != null) {
+                                        children.push(this._nodeMap[descendent.uniqueId]);
                                     }
                                 }
                                 if (children.length) {
@@ -1568,31 +1536,29 @@ var _Exporter = /** @class */ (function () {
                         }
                     }
                     if (scene.nodes.length) {
-                        _this._scenes.push(scene);
+                        this._scenes.push(scene);
                     }
                 });
             });
         });
-    };
+    }
     /**
      * Getting the nodes and materials that would be exported.
      * @param nodes Babylon transform nodes
      * @returns Array of nodes which would be exported.
      * @returns Set of materials which would be exported.
      */
-    _Exporter.prototype._getExportNodes = function (nodes) {
-        var exportNodes = [];
-        var exportMaterials = new Set();
-        for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
-            var babylonNode = nodes_2[_i];
+    _getExportNodes(nodes) {
+        const exportNodes = [];
+        const exportMaterials = new Set();
+        for (const babylonNode of nodes) {
             if (!this._options.shouldExportNode || this._options.shouldExportNode(babylonNode)) {
                 exportNodes.push(babylonNode);
-                var babylonMesh = babylonNode;
+                const babylonMesh = babylonNode;
                 if (babylonMesh.subMeshes && babylonMesh.subMeshes.length > 0) {
-                    var material = babylonMesh.material || babylonMesh.getScene().defaultMaterial;
+                    const material = babylonMesh.material || babylonMesh.getScene().defaultMaterial;
                     if (material instanceof MultiMaterial) {
-                        for (var _a = 0, _b = material.subMaterials; _a < _b.length; _a++) {
-                            var subMaterial = _b[_a];
+                        for (const subMaterial of material.subMaterials) {
                             if (subMaterial) {
                                 exportMaterials.add(subMaterial);
                             }
@@ -1604,11 +1570,11 @@ var _Exporter = /** @class */ (function () {
                 }
             }
             else {
-                "Excluding node ".concat(babylonNode.name);
+                `Excluding node ${babylonNode.name}`;
             }
         }
         return [exportNodes, exportMaterials];
-    };
+    }
     /**
      * Creates a mapping of Node unique id to node index and handles animations
      * @param babylonScene Babylon Scene
@@ -1616,64 +1582,59 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter Buffer to write binary data to
      * @returns Node mapping of unique id to index
      */
-    _Exporter.prototype._createNodeMapAndAnimationsAsync = function (babylonScene, nodes, binaryWriter) {
-        var _this = this;
-        var promiseChain = Promise.resolve();
-        var nodeMap = {};
-        var nodeIndex;
-        var runtimeGLTFAnimation = {
+    _createNodeMapAndAnimationsAsync(babylonScene, nodes, binaryWriter) {
+        let promiseChain = Promise.resolve();
+        const nodeMap = {};
+        let nodeIndex;
+        const runtimeGLTFAnimation = {
             name: "runtime animations",
             channels: [],
             samplers: [],
         };
-        var idleGLTFAnimations = [];
-        var _loop_1 = function (babylonNode) {
-            promiseChain = promiseChain.then(function () {
-                var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                return _this._createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem).then(function (node) {
-                    var promise = _this._extensionsPostExportNodeAsync("createNodeAsync", node, babylonNode, nodeMap, binaryWriter);
+        const idleGLTFAnimations = [];
+        for (const babylonNode of nodes) {
+            promiseChain = promiseChain.then(() => {
+                const convertToRightHandedSystem = this._convertToRightHandedSystemMap[babylonNode.uniqueId];
+                return this._createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem).then((node) => {
+                    const promise = this._extensionsPostExportNodeAsync("createNodeAsync", node, babylonNode, nodeMap, binaryWriter);
                     if (promise == null) {
-                        Tools.Warn("Not exporting node ".concat(babylonNode.name));
+                        Tools.Warn(`Not exporting node ${babylonNode.name}`);
                         return Promise.resolve();
                     }
                     else {
-                        return promise.then(function (node) {
+                        return promise.then((node) => {
                             if (!node) {
                                 return;
                             }
-                            _this._nodes.push(node);
-                            nodeIndex = _this._nodes.length - 1;
+                            this._nodes.push(node);
+                            nodeIndex = this._nodes.length - 1;
                             nodeMap[babylonNode.uniqueId] = nodeIndex;
                             if (!babylonScene.animationGroups.length) {
-                                _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
+                                _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, convertToRightHandedSystem, this._animationSampleRate);
                                 if (babylonNode.animations.length) {
-                                    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
+                                    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, convertToRightHandedSystem, this._animationSampleRate);
                                 }
                             }
                         });
                     }
                 });
             });
-        };
-        for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
-            var babylonNode = nodes_3[_i];
-            _loop_1(babylonNode);
         }
-        return promiseChain.then(function () {
+        return promiseChain.then(() => {
             if (runtimeGLTFAnimation.channels.length && runtimeGLTFAnimation.samplers.length) {
-                _this._animations.push(runtimeGLTFAnimation);
+                this._animations.push(runtimeGLTFAnimation);
             }
-            idleGLTFAnimations.forEach(function (idleGLTFAnimation) {
+            idleGLTFAnimations.forEach((idleGLTFAnimation) => {
                 if (idleGLTFAnimation.channels.length && idleGLTFAnimation.samplers.length) {
-                    _this._animations.push(idleGLTFAnimation);
+                    this._animations.push(idleGLTFAnimation);
                 }
             });
             if (babylonScene.animationGroups.length) {
-                _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, _this._animations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, _this._convertToRightHandedSystemMap, _this._animationSampleRate);
+                _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, this._animations, nodeMap, this._nodes, binaryWriter, this._bufferViews, this._accessors, this._convertToRightHandedSystemMap, this._animationSampleRate);
             }
             return nodeMap;
         });
-    };
+    }
     /**
      * Creates a glTF node from a Babylon mesh
      * @param babylonNode Source Babylon mesh
@@ -1681,45 +1642,44 @@ var _Exporter = /** @class */ (function () {
      * @param convertToRightHandedSystem Converts the values to right-handed
      * @returns glTF node
      */
-    _Exporter.prototype._createNodeAsync = function (babylonNode, binaryWriter, convertToRightHandedSystem) {
-        var _this = this;
-        return Promise.resolve().then(function () {
+    _createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem) {
+        return Promise.resolve().then(() => {
             // create node to hold translation/rotation/scale and the mesh
-            var node = {};
+            const node = {};
             // create mesh
-            var mesh = { primitives: [] };
+            const mesh = { primitives: [] };
             if (babylonNode.name) {
                 node.name = babylonNode.name;
             }
             if (babylonNode instanceof TransformNode) {
                 // Set transformation
-                _this._setNodeTransformation(node, babylonNode, convertToRightHandedSystem);
+                this._setNodeTransformation(node, babylonNode, convertToRightHandedSystem);
                 if (babylonNode instanceof Mesh) {
-                    var morphTargetManager = babylonNode.morphTargetManager;
+                    const morphTargetManager = babylonNode.morphTargetManager;
                     if (morphTargetManager && morphTargetManager.numTargets > 0) {
                         mesh.weights = [];
-                        for (var i = 0; i < morphTargetManager.numTargets; ++i) {
+                        for (let i = 0; i < morphTargetManager.numTargets; ++i) {
                             mesh.weights.push(morphTargetManager.getTarget(i).influence);
                         }
                     }
                 }
-                return _this._setPrimitiveAttributesAsync(mesh, babylonNode, binaryWriter, convertToRightHandedSystem).then(function () {
+                return this._setPrimitiveAttributesAsync(mesh, babylonNode, binaryWriter, convertToRightHandedSystem).then(() => {
                     if (mesh.primitives.length) {
-                        _this._meshes.push(mesh);
-                        node.mesh = _this._meshes.length - 1;
+                        this._meshes.push(mesh);
+                        node.mesh = this._meshes.length - 1;
                     }
                     return node;
                 });
             }
             else if (babylonNode instanceof Camera) {
-                _this._setCameraTransformation(node, babylonNode, convertToRightHandedSystem);
+                this._setCameraTransformation(node, babylonNode, convertToRightHandedSystem);
                 return node;
             }
             else {
                 return node;
             }
         });
-    };
+    }
     /**
      * Creates a glTF skin from a Babylon skeleton
      * @param babylonScene Babylon Scene
@@ -1727,23 +1687,21 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter Buffer to write binary data to
      * @returns Node mapping of unique id to index
      */
-    _Exporter.prototype._createSkinsAsync = function (babylonScene, nodeMap, binaryWriter) {
-        var _a;
-        var promiseChain = Promise.resolve();
-        var skinMap = {};
-        for (var _i = 0, _b = babylonScene.skeletons; _i < _b.length; _i++) {
-            var skeleton = _b[_i];
+    _createSkinsAsync(babylonScene, nodeMap, binaryWriter) {
+        const promiseChain = Promise.resolve();
+        const skinMap = {};
+        for (const skeleton of babylonScene.skeletons) {
             if (skeleton.bones.length <= 0) {
                 continue;
             }
             // create skin
-            var skin = { joints: [] };
-            var inverseBindMatrices = [];
-            var boneIndexMap = {};
-            var maxBoneIndex = -1;
-            for (var i = 0; i < skeleton.bones.length; ++i) {
-                var bone = skeleton.bones[i];
-                var boneIndex = (_a = bone.getIndex()) !== null && _a !== void 0 ? _a : i;
+            const skin = { joints: [] };
+            const inverseBindMatrices = [];
+            const boneIndexMap = {};
+            let maxBoneIndex = -1;
+            for (let i = 0; i < skeleton.bones.length; ++i) {
+                const bone = skeleton.bones[i];
+                const boneIndex = bone.getIndex() ?? i;
                 if (boneIndex !== -1) {
                     boneIndexMap[boneIndex] = bone;
                     if (boneIndex > maxBoneIndex) {
@@ -1751,10 +1709,10 @@ var _Exporter = /** @class */ (function () {
                     }
                 }
             }
-            for (var boneIndex = 0; boneIndex <= maxBoneIndex; ++boneIndex) {
-                var bone = boneIndexMap[boneIndex];
+            for (let boneIndex = 0; boneIndex <= maxBoneIndex; ++boneIndex) {
+                const bone = boneIndexMap[boneIndex];
                 inverseBindMatrices.push(bone.getInvertedAbsoluteTransform());
-                var transformNode = bone.getTransformNode();
+                const transformNode = bone.getTransformNode();
                 if (transformNode) {
                     skin.joints.push(nodeMap[transformNode.uniqueId]);
                 }
@@ -1763,43 +1721,41 @@ var _Exporter = /** @class */ (function () {
                 }
             }
             // create buffer view for inverse bind matrices
-            var byteStride = 64; // 4 x 4 matrix of 32 bit float
-            var byteLength = inverseBindMatrices.length * byteStride;
-            var bufferViewOffset = binaryWriter.getByteOffset();
-            var bufferView = _GLTFUtilities._CreateBufferView(0, bufferViewOffset, byteLength, undefined, "InverseBindMatrices" + " - " + skeleton.name);
+            const byteStride = 64; // 4 x 4 matrix of 32 bit float
+            const byteLength = inverseBindMatrices.length * byteStride;
+            const bufferViewOffset = binaryWriter.getByteOffset();
+            const bufferView = _GLTFUtilities._CreateBufferView(0, bufferViewOffset, byteLength, undefined, "InverseBindMatrices" + " - " + skeleton.name);
             this._bufferViews.push(bufferView);
-            var bufferViewIndex = this._bufferViews.length - 1;
-            var bindMatrixAccessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, "InverseBindMatrices" + " - " + skeleton.name, "MAT4" /* MAT4 */, 5126 /* FLOAT */, inverseBindMatrices.length, null, null, null);
-            var inverseBindAccessorIndex = this._accessors.push(bindMatrixAccessor) - 1;
+            const bufferViewIndex = this._bufferViews.length - 1;
+            const bindMatrixAccessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, "InverseBindMatrices" + " - " + skeleton.name, "MAT4" /* MAT4 */, 5126 /* FLOAT */, inverseBindMatrices.length, null, null, null);
+            const inverseBindAccessorIndex = this._accessors.push(bindMatrixAccessor) - 1;
             skin.inverseBindMatrices = inverseBindAccessorIndex;
             this._skins.push(skin);
             skinMap[skeleton.uniqueId] = this._skins.length - 1;
-            inverseBindMatrices.forEach(function (mat) {
-                mat.m.forEach(function (cell) {
+            inverseBindMatrices.forEach((mat) => {
+                mat.m.forEach((cell) => {
                     binaryWriter.setFloat32(cell);
                 });
             });
         }
-        return promiseChain.then(function () {
+        return promiseChain.then(() => {
             return skinMap;
         });
-    };
-    _Exporter._ExtensionNames = new Array();
-    _Exporter._ExtensionFactories = {};
-    return _Exporter;
-}());
-export { _Exporter };
+    }
+}
+_Exporter._ExtensionNames = new Array();
+_Exporter._ExtensionFactories = {};
 /**
  * @hidden
  *
  * Stores glTF binary data.  If the array buffer byte length is exceeded, it doubles in size dynamically
  */
-var _BinaryWriter = /** @class */ (function () {
+export class _BinaryWriter {
     /**
      * Initialize binary writer with an initial byte length
      * @param byteLength Initial byte length of the array buffer
      */
-    function _BinaryWriter(byteLength) {
+    constructor(byteLength) {
         this._arrayBuffer = new ArrayBuffer(byteLength);
         this._dataView = new DataView(this._arrayBuffer);
         this._byteOffset = 0;
@@ -1808,40 +1764,40 @@ var _BinaryWriter = /** @class */ (function () {
      * Resize the array buffer to the specified byte length
      * @param byteLength
      */
-    _BinaryWriter.prototype._resizeBuffer = function (byteLength) {
-        var newBuffer = new ArrayBuffer(byteLength);
-        var oldUint8Array = new Uint8Array(this._arrayBuffer);
-        var newUint8Array = new Uint8Array(newBuffer);
-        for (var i = 0, length_10 = newUint8Array.byteLength; i < length_10; ++i) {
+    _resizeBuffer(byteLength) {
+        const newBuffer = new ArrayBuffer(byteLength);
+        const oldUint8Array = new Uint8Array(this._arrayBuffer);
+        const newUint8Array = new Uint8Array(newBuffer);
+        for (let i = 0, length = newUint8Array.byteLength; i < length; ++i) {
             newUint8Array[i] = oldUint8Array[i];
         }
         this._arrayBuffer = newBuffer;
         this._dataView = new DataView(this._arrayBuffer);
         return newBuffer;
-    };
+    }
     /**
      * Get an array buffer with the length of the byte offset
      * @returns ArrayBuffer resized to the byte offset
      */
-    _BinaryWriter.prototype.getArrayBuffer = function () {
+    getArrayBuffer() {
         return this._resizeBuffer(this.getByteOffset());
-    };
+    }
     /**
      * Get the byte offset of the array buffer
      * @returns byte offset
      */
-    _BinaryWriter.prototype.getByteOffset = function () {
+    getByteOffset() {
         if (this._byteOffset == undefined) {
             throw new Error("Byte offset is undefined!");
         }
         return this._byteOffset;
-    };
+    }
     /**
      * Stores an UInt8 in the array buffer
      * @param entry
      * @param byteOffset If defined, specifies where to set the value as an offset.
      */
-    _BinaryWriter.prototype.setUInt8 = function (entry, byteOffset) {
+    setUInt8(entry, byteOffset) {
         if (byteOffset != null) {
             if (byteOffset < this._byteOffset) {
                 this._dataView.setUint8(byteOffset, entry);
@@ -1857,13 +1813,13 @@ var _BinaryWriter = /** @class */ (function () {
             this._dataView.setUint8(this._byteOffset, entry);
             this._byteOffset += 1;
         }
-    };
+    }
     /**
      * Stores an UInt16 in the array buffer
      * @param entry
      * @param byteOffset If defined, specifies where to set the value as an offset.
      */
-    _BinaryWriter.prototype.setUInt16 = function (entry, byteOffset) {
+    setUInt16(entry, byteOffset) {
         if (byteOffset != null) {
             if (byteOffset < this._byteOffset) {
                 this._dataView.setUint16(byteOffset, entry, true);
@@ -1879,12 +1835,12 @@ var _BinaryWriter = /** @class */ (function () {
             this._dataView.setUint16(this._byteOffset, entry, true);
             this._byteOffset += 2;
         }
-    };
+    }
     /**
      * Gets an UInt32 in the array buffer
      * @param byteOffset If defined, specifies where to set the value as an offset.
      */
-    _BinaryWriter.prototype.getUInt32 = function (byteOffset) {
+    getUInt32(byteOffset) {
         if (byteOffset < this._byteOffset) {
             return this._dataView.getUint32(byteOffset, true);
         }
@@ -1892,30 +1848,30 @@ var _BinaryWriter = /** @class */ (function () {
             Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
             throw new Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
         }
-    };
-    _BinaryWriter.prototype.getVector3Float32FromRef = function (vector3, byteOffset) {
+    }
+    getVector3Float32FromRef(vector3, byteOffset) {
         if (byteOffset + 8 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
+            Tools.Error(`BinaryWriter: byteoffset is greater than the current binary buffer length!`);
         }
         else {
             vector3.x = this._dataView.getFloat32(byteOffset, true);
             vector3.y = this._dataView.getFloat32(byteOffset + 4, true);
             vector3.z = this._dataView.getFloat32(byteOffset + 8, true);
         }
-    };
-    _BinaryWriter.prototype.setVector3Float32FromRef = function (vector3, byteOffset) {
+    }
+    setVector3Float32FromRef(vector3, byteOffset) {
         if (byteOffset + 8 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
+            Tools.Error(`BinaryWriter: byteoffset is greater than the current binary buffer length!`);
         }
         else {
             this._dataView.setFloat32(byteOffset, vector3.x, true);
             this._dataView.setFloat32(byteOffset + 4, vector3.y, true);
             this._dataView.setFloat32(byteOffset + 8, vector3.z, true);
         }
-    };
-    _BinaryWriter.prototype.getVector4Float32FromRef = function (vector4, byteOffset) {
+    }
+    getVector4Float32FromRef(vector4, byteOffset) {
         if (byteOffset + 12 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
+            Tools.Error(`BinaryWriter: byteoffset is greater than the current binary buffer length!`);
         }
         else {
             vector4.x = this._dataView.getFloat32(byteOffset, true);
@@ -1923,10 +1879,10 @@ var _BinaryWriter = /** @class */ (function () {
             vector4.z = this._dataView.getFloat32(byteOffset + 8, true);
             vector4.w = this._dataView.getFloat32(byteOffset + 12, true);
         }
-    };
-    _BinaryWriter.prototype.setVector4Float32FromRef = function (vector4, byteOffset) {
+    }
+    setVector4Float32FromRef(vector4, byteOffset) {
         if (byteOffset + 12 > this._byteOffset) {
-            Tools.Error("BinaryWriter: byteoffset is greater than the current binary buffer length!");
+            Tools.Error(`BinaryWriter: byteoffset is greater than the current binary buffer length!`);
         }
         else {
             this._dataView.setFloat32(byteOffset, vector4.x, true);
@@ -1934,13 +1890,13 @@ var _BinaryWriter = /** @class */ (function () {
             this._dataView.setFloat32(byteOffset + 8, vector4.z, true);
             this._dataView.setFloat32(byteOffset + 12, vector4.w, true);
         }
-    };
+    }
     /**
      * Stores a Float32 in the array buffer
      * @param entry
      * @param byteOffset
      */
-    _BinaryWriter.prototype.setFloat32 = function (entry, byteOffset) {
+    setFloat32(entry, byteOffset) {
         if (isNaN(entry)) {
             Tools.Error("Invalid data being written!");
         }
@@ -1957,13 +1913,13 @@ var _BinaryWriter = /** @class */ (function () {
         }
         this._dataView.setFloat32(this._byteOffset, entry, true);
         this._byteOffset += 4;
-    };
+    }
     /**
      * Stores an UInt32 in the array buffer
      * @param entry
      * @param byteOffset If defined, specifies where to set the value as an offset.
      */
-    _BinaryWriter.prototype.setUInt32 = function (entry, byteOffset) {
+    setUInt32(entry, byteOffset) {
         if (byteOffset != null) {
             if (byteOffset < this._byteOffset) {
                 this._dataView.setUint32(byteOffset, entry, true);
@@ -1979,13 +1935,13 @@ var _BinaryWriter = /** @class */ (function () {
             this._dataView.setUint32(this._byteOffset, entry, true);
             this._byteOffset += 4;
         }
-    };
+    }
     /**
      * Stores an Int16 in the array buffer
      * @param entry
      * @param byteOffset If defined, specifies where to set the value as an offset.
      */
-    _BinaryWriter.prototype.setInt16 = function (entry, byteOffset) {
+    setInt16(entry, byteOffset) {
         if (byteOffset != null) {
             if (byteOffset < this._byteOffset) {
                 this._dataView.setInt16(byteOffset, entry, true);
@@ -2001,13 +1957,13 @@ var _BinaryWriter = /** @class */ (function () {
             this._dataView.setInt16(this._byteOffset, entry, true);
             this._byteOffset += 2;
         }
-    };
+    }
     /**
      * Stores a byte in the array buffer
      * @param entry
      * @param byteOffset If defined, specifies where to set the value as an offset.
      */
-    _BinaryWriter.prototype.setByte = function (entry, byteOffset) {
+    setByte(entry, byteOffset) {
         if (byteOffset != null) {
             if (byteOffset < this._byteOffset) {
                 this._dataView.setInt8(byteOffset, entry);
@@ -2023,8 +1979,6 @@ var _BinaryWriter = /** @class */ (function () {
             this._dataView.setInt8(this._byteOffset, entry);
             this._byteOffset++;
         }
-    };
-    return _BinaryWriter;
-}());
-export { _BinaryWriter };
+    }
+}
 //# sourceMappingURL=glTFExporter.js.map