@babylonjs/loaders 5.20.0 → 5.22.1

package/glTF/2.0/glTFLoader.js

@@ -23,9 +23,7 @@ import { BoundingInfo } from "@babylonjs/core/Culling/boundingInfo.js";
 /**
  * Helper class for working with arrays when loading the glTF asset
  */
-var ArrayItem = /** @class */ (function () {
-    function ArrayItem() {
-    }
+export class ArrayItem {
     /**
      * Gets an item from the given array.
      * @param context The context when loading the asset
@@ -33,39 +31,33 @@ var ArrayItem = /** @class */ (function () {
      * @param index The index to the array
      * @returns The array item
      */
-    ArrayItem.Get = function (context, array, index) {
+    static Get(context, array, index) {
         if (!array || index == undefined || !array[index]) {
-            throw new Error("".concat(context, ": Failed to find index (").concat(index, ")"));
+            throw new Error(`${context}: Failed to find index (${index})`);
         }
         return array[index];
-    };
+    }
     /**
      * Assign an `index` field to each item of the given array.
      * @param array The array of items
      */
-    ArrayItem.Assign = function (array) {
+    static Assign(array) {
         if (array) {
-            for (var index = 0; index < array.length; index++) {
+            for (let index = 0; index < array.length; index++) {
                 array[index].index = index;
             }
         }
-    };
-    return ArrayItem;
-}());
-export { ArrayItem };
+    }
+}
 // https://stackoverflow.com/a/48218209
-function mergeDeep() {
-    var objects = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        objects[_i] = arguments[_i];
-    }
-    var isObject = function (obj) { return obj && typeof obj === "object"; };
-    return objects.reduce(function (prev, obj) {
-        Object.keys(obj).forEach(function (key) {
-            var pVal = prev[key];
-            var oVal = obj[key];
+function mergeDeep(...objects) {
+    const isObject = (obj) => obj && typeof obj === "object";
+    return objects.reduce((prev, obj) => {
+        Object.keys(obj).forEach((key) => {
+            const pVal = prev[key];
+            const oVal = obj[key];
             if (Array.isArray(pVal) && Array.isArray(oVal)) {
-                prev[key] = pVal.concat.apply(pVal, oVal);
+                prev[key] = pVal.concat(...oVal);
             }
             else if (isObject(pVal) && isObject(oVal)) {
                 prev[key] = mergeDeep(pVal, oVal);
@@ -80,12 +72,12 @@ function mergeDeep() {
 /**
  * The glTF 2.0 loader
  */
-var GLTFLoader = /** @class */ (function () {
+export class GLTFLoader {
     /**
      * @param parent
      * @hidden
      */
-    function GLTFLoader(parent) {
+    constructor(parent) {
         /** @hidden */
         this._completePromises = new Array();
         /** @hidden */
@@ -110,90 +102,70 @@ var GLTFLoader = /** @class */ (function () {
      * @param name The name of the loader extension.
      * @param factory The factory function that creates the loader extension.
      */
-    GLTFLoader.RegisterExtension = function (name, factory) {
+    static RegisterExtension(name, factory) {
         if (GLTFLoader.UnregisterExtension(name)) {
-            Logger.Warn("Extension with the name '".concat(name, "' already exists"));
+            Logger.Warn(`Extension with the name '${name}' already exists`);
         }
         GLTFLoader._RegisteredExtensions[name] = {
             factory: factory,
         };
-    };
+    }
     /**
      * Unregisters a loader extension.
      * @param name The name of the loader extension.
      * @returns A boolean indicating whether the extension has been unregistered
      */
-    GLTFLoader.UnregisterExtension = function (name) {
+    static UnregisterExtension(name) {
         if (!GLTFLoader._RegisteredExtensions[name]) {
             return false;
         }
         delete GLTFLoader._RegisteredExtensions[name];
         return true;
-    };
-    Object.defineProperty(GLTFLoader.prototype, "gltf", {
-        /**
-         * The object that represents the glTF JSON.
-         */
-        get: function () {
-            if (!this._gltf) {
-                throw new Error("glTF JSON is not available");
-            }
-            return this._gltf;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "bin", {
-        /**
-         * The BIN chunk of a binary glTF.
-         */
-        get: function () {
-            return this._bin;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "parent", {
-        /**
-         * The parent file loader.
-         */
-        get: function () {
-            return this._parent;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "babylonScene", {
-        /**
-         * The Babylon scene when loading the asset.
-         */
-        get: function () {
-            if (!this._babylonScene) {
-                throw new Error("Scene is not available");
-            }
-            return this._babylonScene;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "rootBabylonMesh", {
-        /**
-         * The root Babylon mesh when loading the asset.
-         */
-        get: function () {
-            return this._rootBabylonMesh;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /**
+     * The object that represents the glTF JSON.
+     */
+    get gltf() {
+        if (!this._gltf) {
+            throw new Error("glTF JSON is not available");
+        }
+        return this._gltf;
+    }
+    /**
+     * The BIN chunk of a binary glTF.
+     */
+    get bin() {
+        return this._bin;
+    }
+    /**
+     * The parent file loader.
+     */
+    get parent() {
+        return this._parent;
+    }
+    /**
+     * The Babylon scene when loading the asset.
+     */
+    get babylonScene() {
+        if (!this._babylonScene) {
+            throw new Error("Scene is not available");
+        }
+        return this._babylonScene;
+    }
+    /**
+     * The root Babylon mesh when loading the asset.
+     */
+    get rootBabylonMesh() {
+        return this._rootBabylonMesh;
+    }
     /** @hidden */
-    GLTFLoader.prototype.dispose = function () {
+    dispose() {
         if (this._disposed) {
             return;
         }
         this._disposed = true;
         this._completePromises.length = 0;
-        this._extensions.forEach(function (extension) { return extension.dispose && extension.dispose(); });
+        this._extensions.forEach((extension) => extension.dispose && extension.dispose());
         this._extensions.length = 0;
         this._gltf = null; // TODO
         this._bin = null;
@@ -202,7 +174,7 @@ var GLTFLoader = /** @class */ (function () {
         this._defaultBabylonMaterialData = {};
         this._postSceneLoadActions.length = 0;
         this._parent.dispose();
-    };
+    }
     /**
      * @param meshesNames
      * @param scene
@@ -213,46 +185,43 @@ var GLTFLoader = /** @class */ (function () {
      * @param fileName
      * @hidden
      */
-    GLTFLoader.prototype.importMeshAsync = function (meshesNames, scene, container, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        if (fileName === void 0) { fileName = ""; }
-        return Promise.resolve().then(function () {
-            _this._babylonScene = scene;
-            _this._assetContainer = container;
-            _this._loadData(data);
-            var nodes = null;
+    importMeshAsync(meshesNames, scene, container, data, rootUrl, onProgress, fileName = "") {
+        return Promise.resolve().then(() => {
+            this._babylonScene = scene;
+            this._assetContainer = container;
+            this._loadData(data);
+            let nodes = null;
             if (meshesNames) {
-                var nodeMap_1 = {};
-                if (_this._gltf.nodes) {
-                    for (var _i = 0, _a = _this._gltf.nodes; _i < _a.length; _i++) {
-                        var node = _a[_i];
+                const nodeMap = {};
+                if (this._gltf.nodes) {
+                    for (const node of this._gltf.nodes) {
                         if (node.name) {
-                            nodeMap_1[node.name] = node.index;
+                            nodeMap[node.name] = node.index;
                         }
                     }
                 }
-                var names = meshesNames instanceof Array ? meshesNames : [meshesNames];
-                nodes = names.map(function (name) {
-                    var node = nodeMap_1[name];
+                const names = meshesNames instanceof Array ? meshesNames : [meshesNames];
+                nodes = names.map((name) => {
+                    const node = nodeMap[name];
                     if (node === undefined) {
-                        throw new Error("Failed to find node '".concat(name, "'"));
+                        throw new Error(`Failed to find node '${name}'`);
                     }
                     return node;
                 });
             }
-            return _this._loadAsync(rootUrl, fileName, nodes, function () {
+            return this._loadAsync(rootUrl, fileName, nodes, () => {
                 return {
-                    meshes: _this._getMeshes(),
+                    meshes: this._getMeshes(),
                     particleSystems: [],
-                    skeletons: _this._getSkeletons(),
-                    animationGroups: _this._getAnimationGroups(),
-                    lights: _this._babylonLights,
-                    transformNodes: _this._getTransformNodes(),
-                    geometries: _this._getGeometries(),
+                    skeletons: this._getSkeletons(),
+                    animationGroups: this._getAnimationGroups(),
+                    lights: this._babylonLights,
+                    transformNodes: this._getTransformNodes(),
+                    geometries: this._getGeometries(),
                 };
             });
         });
-    };
+    }
     /**
      * @param scene
      * @param data
@@ -261,106 +230,103 @@ var GLTFLoader = /** @class */ (function () {
      * @param fileName
      * @hidden
      */
-    GLTFLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        if (fileName === void 0) { fileName = ""; }
-        return Promise.resolve().then(function () {
-            _this._babylonScene = scene;
-            _this._loadData(data);
-            return _this._loadAsync(rootUrl, fileName, null, function () { return undefined; });
+    loadAsync(scene, data, rootUrl, onProgress, fileName = "") {
+        return Promise.resolve().then(() => {
+            this._babylonScene = scene;
+            this._loadData(data);
+            return this._loadAsync(rootUrl, fileName, null, () => undefined);
         });
-    };
-    GLTFLoader.prototype._loadAsync = function (rootUrl, fileName, nodes, resultFunc) {
-        var _this = this;
+    }
+    _loadAsync(rootUrl, fileName, nodes, resultFunc) {
         return Promise.resolve()
-            .then(function () {
-            _this._rootUrl = rootUrl;
-            _this._uniqueRootUrl = !rootUrl.startsWith("file:") && fileName ? rootUrl : "".concat(rootUrl).concat(Date.now(), "/");
-            _this._fileName = fileName;
-            _this._loadExtensions();
-            _this._checkExtensions();
-            var loadingToReadyCounterName = "".concat(GLTFLoaderState[GLTFLoaderState.LOADING], " => ").concat(GLTFLoaderState[GLTFLoaderState.READY]);
-            var loadingToCompleteCounterName = "".concat(GLTFLoaderState[GLTFLoaderState.LOADING], " => ").concat(GLTFLoaderState[GLTFLoaderState.COMPLETE]);
-            _this._parent._startPerformanceCounter(loadingToReadyCounterName);
-            _this._parent._startPerformanceCounter(loadingToCompleteCounterName);
-            _this._parent._setState(GLTFLoaderState.LOADING);
-            _this._extensionsOnLoading();
-            var promises = new Array();
+            .then(() => {
+            this._rootUrl = rootUrl;
+            this._uniqueRootUrl = !rootUrl.startsWith("file:") && fileName ? rootUrl : `${rootUrl}${Date.now()}/`;
+            this._fileName = fileName;
+            this._loadExtensions();
+            this._checkExtensions();
+            const loadingToReadyCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.READY]}`;
+            const loadingToCompleteCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.COMPLETE]}`;
+            this._parent._startPerformanceCounter(loadingToReadyCounterName);
+            this._parent._startPerformanceCounter(loadingToCompleteCounterName);
+            this._parent._setState(GLTFLoaderState.LOADING);
+            this._extensionsOnLoading();
+            const promises = new Array();
             // Block the marking of materials dirty until the scene is loaded.
-            var oldBlockMaterialDirtyMechanism = _this._babylonScene.blockMaterialDirtyMechanism;
-            _this._babylonScene.blockMaterialDirtyMechanism = true;
-            if (!_this.parent.loadOnlyMaterials) {
+            const oldBlockMaterialDirtyMechanism = this._babylonScene.blockMaterialDirtyMechanism;
+            this._babylonScene.blockMaterialDirtyMechanism = true;
+            if (!this.parent.loadOnlyMaterials) {
                 if (nodes) {
-                    promises.push(_this.loadSceneAsync("/nodes", { nodes: nodes, index: -1 }));
+                    promises.push(this.loadSceneAsync("/nodes", { nodes: nodes, index: -1 }));
                 }
-                else if (_this._gltf.scene != undefined || (_this._gltf.scenes && _this._gltf.scenes[0])) {
-                    var scene = ArrayItem.Get("/scene", _this._gltf.scenes, _this._gltf.scene || 0);
-                    promises.push(_this.loadSceneAsync("/scenes/".concat(scene.index), scene));
+                else if (this._gltf.scene != undefined || (this._gltf.scenes && this._gltf.scenes[0])) {
+                    const scene = ArrayItem.Get(`/scene`, this._gltf.scenes, this._gltf.scene || 0);
+                    promises.push(this.loadSceneAsync(`/scenes/${scene.index}`, scene));
                 }
             }
-            if (!_this.parent.skipMaterials && _this.parent.loadAllMaterials && _this._gltf.materials) {
-                for (var m = 0; m < _this._gltf.materials.length; ++m) {
-                    var material = _this._gltf.materials[m];
-                    var context_1 = "/materials/" + m;
-                    var babylonDrawMode = Material.TriangleFillMode;
-                    promises.push(_this._loadMaterialAsync(context_1, material, null, babylonDrawMode, function () { }));
+            if (!this.parent.skipMaterials && this.parent.loadAllMaterials && this._gltf.materials) {
+                for (let m = 0; m < this._gltf.materials.length; ++m) {
+                    const material = this._gltf.materials[m];
+                    const context = "/materials/" + m;
+                    const babylonDrawMode = Material.TriangleFillMode;
+                    promises.push(this._loadMaterialAsync(context, material, null, babylonDrawMode, () => { }));
                 }
             }
             // Restore the blocking of material dirty.
-            _this._babylonScene.blockMaterialDirtyMechanism = oldBlockMaterialDirtyMechanism;
-            if (_this._parent.compileMaterials) {
-                promises.push(_this._compileMaterialsAsync());
+            this._babylonScene.blockMaterialDirtyMechanism = oldBlockMaterialDirtyMechanism;
+            if (this._parent.compileMaterials) {
+                promises.push(this._compileMaterialsAsync());
             }
-            if (_this._parent.compileShadowGenerators) {
-                promises.push(_this._compileShadowGeneratorsAsync());
+            if (this._parent.compileShadowGenerators) {
+                promises.push(this._compileShadowGeneratorsAsync());
             }
-            var resultPromise = Promise.all(promises).then(function () {
-                if (_this._rootBabylonMesh) {
-                    _this._rootBabylonMesh.setEnabled(true);
+            const resultPromise = Promise.all(promises).then(() => {
+                if (this._rootBabylonMesh) {
+                    this._rootBabylonMesh.setEnabled(true);
                 }
-                _this._extensionsOnReady();
-                _this._parent._setState(GLTFLoaderState.READY);
-                _this._startAnimations();
+                this._extensionsOnReady();
+                this._parent._setState(GLTFLoaderState.READY);
+                this._startAnimations();
                 return resultFunc();
             });
-            return resultPromise.then(function (result) {
-                _this._parent._endPerformanceCounter(loadingToReadyCounterName);
-                Tools.SetImmediate(function () {
-                    if (!_this._disposed) {
-                        Promise.all(_this._completePromises).then(function () {
-                            _this._parent._endPerformanceCounter(loadingToCompleteCounterName);
-                            _this._parent._setState(GLTFLoaderState.COMPLETE);
-                            _this._parent.onCompleteObservable.notifyObservers(undefined);
-                            _this._parent.onCompleteObservable.clear();
-                            _this.dispose();
-                        }, function (error) {
-                            _this._parent.onErrorObservable.notifyObservers(error);
-                            _this._parent.onErrorObservable.clear();
-                            _this.dispose();
+            return resultPromise.then((result) => {
+                this._parent._endPerformanceCounter(loadingToReadyCounterName);
+                Tools.SetImmediate(() => {
+                    if (!this._disposed) {
+                        Promise.all(this._completePromises).then(() => {
+                            this._parent._endPerformanceCounter(loadingToCompleteCounterName);
+                            this._parent._setState(GLTFLoaderState.COMPLETE);
+                            this._parent.onCompleteObservable.notifyObservers(undefined);
+                            this._parent.onCompleteObservable.clear();
+                            this.dispose();
+                        }, (error) => {
+                            this._parent.onErrorObservable.notifyObservers(error);
+                            this._parent.onErrorObservable.clear();
+                            this.dispose();
                         });
                     }
                 });
                 return result;
             });
         })
-            .catch(function (error) {
-            if (!_this._disposed) {
-                _this._parent.onErrorObservable.notifyObservers(error);
-                _this._parent.onErrorObservable.clear();
-                _this.dispose();
+            .catch((error) => {
+            if (!this._disposed) {
+                this._parent.onErrorObservable.notifyObservers(error);
+                this._parent.onErrorObservable.clear();
+                this.dispose();
             }
             throw error;
         });
-    };
-    GLTFLoader.prototype._loadData = function (data) {
+    }
+    _loadData(data) {
         this._gltf = data.json;
         this._setupData();
         if (data.bin) {
-            var buffers = this._gltf.buffers;
+            const buffers = this._gltf.buffers;
             if (buffers && buffers[0] && !buffers[0].uri) {
-                var binaryBuffer = buffers[0];
+                const binaryBuffer = buffers[0];
                 if (binaryBuffer.byteLength < data.bin.byteLength - 3 || binaryBuffer.byteLength > data.bin.byteLength) {
-                    Logger.Warn("Binary buffer length (".concat(binaryBuffer.byteLength, ") from JSON does not match chunk length (").concat(data.bin.byteLength, ")"));
+                    Logger.Warn(`Binary buffer length (${binaryBuffer.byteLength}) from JSON does not match chunk length (${data.bin.byteLength})`);
                 }
                 this._bin = data.bin;
             }
@@ -368,8 +334,8 @@ var GLTFLoader = /** @class */ (function () {
                 Logger.Warn("Unexpected BIN chunk");
             }
         }
-    };
-    GLTFLoader.prototype._setupData = function () {
+    }
+    _setupData() {
         ArrayItem.Assign(this._gltf.accessors);
         ArrayItem.Assign(this._gltf.animations);
         ArrayItem.Assign(this._gltf.buffers);
@@ -384,58 +350,50 @@ var GLTFLoader = /** @class */ (function () {
         ArrayItem.Assign(this._gltf.skins);
         ArrayItem.Assign(this._gltf.textures);
         if (this._gltf.nodes) {
-            var nodeParents = {};
-            for (var _i = 0, _a = this._gltf.nodes; _i < _a.length; _i++) {
-                var node = _a[_i];
+            const nodeParents = {};
+            for (const node of this._gltf.nodes) {
                 if (node.children) {
-                    for (var _b = 0, _c = node.children; _b < _c.length; _b++) {
-                        var index = _c[_b];
+                    for (const index of node.children) {
                         nodeParents[index] = node.index;
                     }
                 }
             }
-            var rootNode = this._createRootNode();
-            for (var _d = 0, _e = this._gltf.nodes; _d < _e.length; _d++) {
-                var node = _e[_d];
-                var parentIndex = nodeParents[node.index];
+            const rootNode = this._createRootNode();
+            for (const node of this._gltf.nodes) {
+                const parentIndex = nodeParents[node.index];
                 node.parent = parentIndex === undefined ? rootNode : this._gltf.nodes[parentIndex];
             }
         }
-    };
-    GLTFLoader.prototype._loadExtensions = function () {
-        for (var name_1 in GLTFLoader._RegisteredExtensions) {
-            var extension = GLTFLoader._RegisteredExtensions[name_1].factory(this);
-            if (extension.name !== name_1) {
-                Logger.Warn("The name of the glTF loader extension instance does not match the registered name: ".concat(extension.name, " !== ").concat(name_1));
+    }
+    _loadExtensions() {
+        for (const name in GLTFLoader._RegisteredExtensions) {
+            const extension = GLTFLoader._RegisteredExtensions[name].factory(this);
+            if (extension.name !== name) {
+                Logger.Warn(`The name of the glTF loader extension instance does not match the registered name: ${extension.name} !== ${name}`);
             }
             this._extensions.push(extension);
             this._parent.onExtensionLoadedObservable.notifyObservers(extension);
         }
-        this._extensions.sort(function (a, b) { return (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE); });
+        this._extensions.sort((a, b) => (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE));
         this._parent.onExtensionLoadedObservable.clear();
-    };
-    GLTFLoader.prototype._checkExtensions = function () {
+    }
+    _checkExtensions() {
         if (this._gltf.extensionsRequired) {
-            var _loop_1 = function (name_2) {
-                var available = this_1._extensions.some(function (extension) { return extension.name === name_2 && extension.enabled; });
+            for (const name of this._gltf.extensionsRequired) {
+                const available = this._extensions.some((extension) => extension.name === name && extension.enabled);
                 if (!available) {
-                    throw new Error("Require extension ".concat(name_2, " is not available"));
+                    throw new Error(`Require extension ${name} is not available`);
                 }
-            };
-            var this_1 = this;
-            for (var _i = 0, _a = this._gltf.extensionsRequired; _i < _a.length; _i++) {
-                var name_2 = _a[_i];
-                _loop_1(name_2);
             }
         }
-    };
-    GLTFLoader.prototype._createRootNode = function () {
+    }
+    _createRootNode() {
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
         this._rootBabylonMesh = new Mesh("__root__", this._babylonScene);
         this._rootBabylonMesh._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         this._rootBabylonMesh.setEnabled(false);
-        var rootNode = {
+        const rootNode = {
             _babylonTransformNode: this._rootBabylonMesh,
             index: -1,
         };
@@ -453,59 +411,54 @@ var GLTFLoader = /** @class */ (function () {
                 break;
             }
             default: {
-                throw new Error("Invalid coordinate system mode (".concat(this._parent.coordinateSystemMode, ")"));
+                throw new Error(`Invalid coordinate system mode (${this._parent.coordinateSystemMode})`);
             }
         }
         this._parent.onMeshLoadedObservable.notifyObservers(this._rootBabylonMesh);
         return rootNode;
-    };
+    }
     /**
      * Loads a glTF scene.
      * @param context The context when loading the asset
      * @param scene The glTF scene property
      * @returns A promise that resolves when the load is complete
      */
-    GLTFLoader.prototype.loadSceneAsync = function (context, scene) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadSceneAsync(context, scene);
+    loadSceneAsync(context, scene) {
+        const extensionPromise = this._extensionsLoadSceneAsync(context, scene);
         if (extensionPromise) {
             return extensionPromise;
         }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(scene.name || ""));
+        const promises = new Array();
+        this.logOpen(`${context} ${scene.name || ""}`);
         if (scene.nodes) {
-            for (var _i = 0, _a = scene.nodes; _i < _a.length; _i++) {
-                var index = _a[_i];
-                var node = ArrayItem.Get("".concat(context, "/nodes/").concat(index), this._gltf.nodes, index);
-                promises.push(this.loadNodeAsync("/nodes/".concat(node.index), node, function (babylonMesh) {
-                    babylonMesh.parent = _this._rootBabylonMesh;
+            for (const index of scene.nodes) {
+                const node = ArrayItem.Get(`${context}/nodes/${index}`, this._gltf.nodes, index);
+                promises.push(this.loadNodeAsync(`/nodes/${node.index}`, node, (babylonMesh) => {
+                    babylonMesh.parent = this._rootBabylonMesh;
                 }));
             }
         }
-        for (var _b = 0, _c = this._postSceneLoadActions; _b < _c.length; _b++) {
-            var action = _c[_b];
+        for (const action of this._postSceneLoadActions) {
             action();
         }
         promises.push(this._loadAnimationsAsync());
         this.logClose();
-        return Promise.all(promises).then(function () { });
-    };
-    GLTFLoader.prototype._forEachPrimitive = function (node, callback) {
+        return Promise.all(promises).then(() => { });
+    }
+    _forEachPrimitive(node, callback) {
         if (node._primitiveBabylonMeshes) {
-            for (var _i = 0, _a = node._primitiveBabylonMeshes; _i < _a.length; _i++) {
-                var babylonMesh = _a[_i];
+            for (const babylonMesh of node._primitiveBabylonMeshes) {
                 callback(babylonMesh);
             }
         }
-    };
-    GLTFLoader.prototype._getGeometries = function () {
-        var geometries = new Array();
-        var nodes = this._gltf.nodes;
+    }
+    _getGeometries() {
+        const geometries = new Array();
+        const nodes = this._gltf.nodes;
         if (nodes) {
-            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-                var node = nodes_1[_i];
-                this._forEachPrimitive(node, function (babylonMesh) {
-                    var geometry = babylonMesh.geometry;
+            for (const node of nodes) {
+                this._forEachPrimitive(node, (babylonMesh) => {
+                    const geometry = babylonMesh.geometry;
                     if (geometry && geometries.indexOf(geometry) === -1) {
                         geometries.push(geometry);
                     }
@@ -513,30 +466,28 @@ var GLTFLoader = /** @class */ (function () {
             }
         }
         return geometries;
-    };
-    GLTFLoader.prototype._getMeshes = function () {
-        var meshes = new Array();
+    }
+    _getMeshes() {
+        const meshes = new Array();
         // Root mesh is always first, if available.
         if (this._rootBabylonMesh) {
             meshes.push(this._rootBabylonMesh);
         }
-        var nodes = this._gltf.nodes;
+        const nodes = this._gltf.nodes;
         if (nodes) {
-            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
-                var node = nodes_2[_i];
-                this._forEachPrimitive(node, function (babylonMesh) {
+            for (const node of nodes) {
+                this._forEachPrimitive(node, (babylonMesh) => {
                     meshes.push(babylonMesh);
                 });
             }
         }
         return meshes;
-    };
-    GLTFLoader.prototype._getTransformNodes = function () {
-        var transformNodes = new Array();
-        var nodes = this._gltf.nodes;
+    }
+    _getTransformNodes() {
+        const transformNodes = new Array();
+        const nodes = this._gltf.nodes;
         if (nodes) {
-            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
-                var node = nodes_3[_i];
+            for (const node of nodes) {
                 if (node._babylonTransformNode && node._babylonTransformNode.getClassName() === "TransformNode") {
                     transformNodes.push(node._babylonTransformNode);
                 }
@@ -546,60 +497,57 @@ var GLTFLoader = /** @class */ (function () {
             }
         }
         return transformNodes;
-    };
-    GLTFLoader.prototype._getSkeletons = function () {
-        var skeletons = new Array();
-        var skins = this._gltf.skins;
+    }
+    _getSkeletons() {
+        const skeletons = new Array();
+        const skins = this._gltf.skins;
         if (skins) {
-            for (var _i = 0, skins_1 = skins; _i < skins_1.length; _i++) {
-                var skin = skins_1[_i];
+            for (const skin of skins) {
                 if (skin._data) {
                     skeletons.push(skin._data.babylonSkeleton);
                 }
             }
         }
         return skeletons;
-    };
-    GLTFLoader.prototype._getAnimationGroups = function () {
-        var animationGroups = new Array();
-        var animations = this._gltf.animations;
+    }
+    _getAnimationGroups() {
+        const animationGroups = new Array();
+        const animations = this._gltf.animations;
         if (animations) {
-            for (var _i = 0, animations_1 = animations; _i < animations_1.length; _i++) {
-                var animation = animations_1[_i];
+            for (const animation of animations) {
                 if (animation._babylonAnimationGroup) {
                     animationGroups.push(animation._babylonAnimationGroup);
                 }
             }
         }
         return animationGroups;
-    };
-    GLTFLoader.prototype._startAnimations = function () {
+    }
+    _startAnimations() {
         switch (this._parent.animationStartMode) {
             case GLTFLoaderAnimationStartMode.NONE: {
                 // do nothing
                 break;
             }
             case GLTFLoaderAnimationStartMode.FIRST: {
-                var babylonAnimationGroups = this._getAnimationGroups();
+                const babylonAnimationGroups = this._getAnimationGroups();
                 if (babylonAnimationGroups.length !== 0) {
                     babylonAnimationGroups[0].start(true);
                 }
                 break;
             }
             case GLTFLoaderAnimationStartMode.ALL: {
-                var babylonAnimationGroups = this._getAnimationGroups();
-                for (var _i = 0, babylonAnimationGroups_1 = babylonAnimationGroups; _i < babylonAnimationGroups_1.length; _i++) {
-                    var babylonAnimationGroup = babylonAnimationGroups_1[_i];
+                const babylonAnimationGroups = this._getAnimationGroups();
+                for (const babylonAnimationGroup of babylonAnimationGroups) {
                     babylonAnimationGroup.start(true);
                 }
                 break;
             }
             default: {
-                Logger.Error("Invalid animation start mode (".concat(this._parent.animationStartMode, ")"));
+                Logger.Error(`Invalid animation start mode (${this._parent.animationStartMode})`);
                 return;
             }
         }
-    };
+    }
     /**
      * Loads a glTF node.
      * @param context The context when loading the asset
@@ -607,32 +555,29 @@ var GLTFLoader = /** @class */ (function () {
      * @param assign A function called synchronously after parsing the glTF properties
      * @returns A promise that resolves with the loaded Babylon mesh when the load is complete
      */
-    GLTFLoader.prototype.loadNodeAsync = function (context, node, assign) {
-        var _this = this;
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);
+    loadNodeAsync(context, node, assign = () => { }) {
+        const extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);
         if (extensionPromise) {
             return extensionPromise;
         }
         if (node._babylonTransformNode) {
-            throw new Error("".concat(context, ": Invalid recursive node hierarchy"));
+            throw new Error(`${context}: Invalid recursive node hierarchy`);
         }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(node.name || ""));
-        var loadNode = function (babylonTransformNode) {
+        const promises = new Array();
+        this.logOpen(`${context} ${node.name || ""}`);
+        const loadNode = (babylonTransformNode) => {
             GLTFLoader.AddPointerMetadata(babylonTransformNode, context);
             GLTFLoader._LoadTransform(node, babylonTransformNode);
             if (node.camera != undefined) {
-                var camera = ArrayItem.Get("".concat(context, "/camera"), _this._gltf.cameras, node.camera);
-                promises.push(_this.loadCameraAsync("/cameras/".concat(camera.index), camera, function (babylonCamera) {
+                const camera = ArrayItem.Get(`${context}/camera`, this._gltf.cameras, node.camera);
+                promises.push(this.loadCameraAsync(`/cameras/${camera.index}`, camera, (babylonCamera) => {
                     babylonCamera.parent = babylonTransformNode;
                 }));
             }
             if (node.children) {
-                for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
-                    var index = _a[_i];
-                    var childNode = ArrayItem.Get("".concat(context, "/children/").concat(index), _this._gltf.nodes, index);
-                    promises.push(_this.loadNodeAsync("/nodes/".concat(childNode.index), childNode, function (childBabylonMesh) {
+                for (const index of node.children) {
+                    const childNode = ArrayItem.Get(`${context}/children/${index}`, this._gltf.nodes, index);
+                    promises.push(this.loadNodeAsync(`/nodes/${childNode.index}`, childNode, (childBabylonMesh) => {
                         childBabylonMesh.parent = babylonTransformNode;
                     }));
                 }
@@ -640,9 +585,9 @@ var GLTFLoader = /** @class */ (function () {
             assign(babylonTransformNode);
         };
         if (node.mesh == undefined || node.skin != undefined) {
-            var nodeName = node.name || "node".concat(node.index);
+            const nodeName = node.name || `node${node.index}`;
             this._babylonScene._blockEntityCollection = !!this._assetContainer;
-            var transformNode = new TransformNode(nodeName, this._babylonScene);
+            const transformNode = new TransformNode(nodeName, this._babylonScene);
             transformNode._parentContainer = this._assetContainer;
             this._babylonScene._blockEntityCollection = false;
             if (node.mesh == undefined) {
@@ -655,29 +600,29 @@ var GLTFLoader = /** @class */ (function () {
         }
         if (node.mesh != undefined) {
             if (node.skin == undefined) {
-                var mesh = ArrayItem.Get("".concat(context, "/mesh"), this._gltf.meshes, node.mesh);
-                promises.push(this._loadMeshAsync("/meshes/".concat(mesh.index), node, mesh, loadNode));
+                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);
+                promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, loadNode));
             }
             else {
                 // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
                 // This code path will place the skinned mesh as a sibling of the skeleton root node without loading the
                 // transform, which effectively ignores the transform of the skinned mesh, as per spec.
-                var mesh = ArrayItem.Get("".concat(context, "/mesh"), this._gltf.meshes, node.mesh);
-                promises.push(this._loadMeshAsync("/meshes/".concat(mesh.index), node, mesh, function (babylonTransformNode) {
-                    var babylonTransformNodeForSkin = node._babylonTransformNodeForSkin;
+                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);
+                promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, (babylonTransformNode) => {
+                    const babylonTransformNodeForSkin = node._babylonTransformNodeForSkin;
                     // Merge the metadata from the skin node to the skinned mesh in case a loader extension added metadata.
                     babylonTransformNode.metadata = mergeDeep(babylonTransformNodeForSkin.metadata, babylonTransformNode.metadata || {});
-                    var skin = ArrayItem.Get("".concat(context, "/skin"), _this._gltf.skins, node.skin);
-                    promises.push(_this._loadSkinAsync("/skins/".concat(skin.index), node, skin, function (babylonSkeleton) {
-                        _this._forEachPrimitive(node, function (babylonMesh) {
+                    const skin = ArrayItem.Get(`${context}/skin`, this._gltf.skins, node.skin);
+                    promises.push(this._loadSkinAsync(`/skins/${skin.index}`, node, skin, (babylonSkeleton) => {
+                        this._forEachPrimitive(node, (babylonMesh) => {
                             babylonMesh.skeleton = babylonSkeleton;
                         });
                         // Wait until all the nodes are parented before parenting the skinned mesh.
-                        _this._postSceneLoadActions.push(function () {
+                        this._postSceneLoadActions.push(() => {
                             if (skin.skeleton != undefined) {
                                 // Place the skinned mesh node as a sibling of the skeleton root node.
                                 // Handle special case when the parent of the skeleton root is the skinned mesh.
-                                var parentNode = ArrayItem.Get("/skins/".concat(skin.index, "/skeleton"), _this._gltf.nodes, skin.skeleton).parent;
+                                const parentNode = ArrayItem.Get(`/skins/${skin.index}/skeleton`, this._gltf.nodes, skin.skeleton).parent;
                                 if (node.index === parentNode.index) {
                                     babylonTransformNode.parent = babylonTransformNodeForSkin.parent;
                                 }
@@ -686,17 +631,17 @@ var GLTFLoader = /** @class */ (function () {
                                 }
                             }
                             else {
-                                babylonTransformNode.parent = _this._rootBabylonMesh;
+                                babylonTransformNode.parent = this._rootBabylonMesh;
                             }
-                            _this._parent.onSkinLoadedObservable.notifyObservers({ node: babylonTransformNodeForSkin, skinnedNode: babylonTransformNode });
+                            this._parent.onSkinLoadedObservable.notifyObservers({ node: babylonTransformNodeForSkin, skinnedNode: babylonTransformNode });
                         });
                     }));
                 }));
             }
         }
         this.logClose();
-        return Promise.all(promises).then(function () {
-            _this._forEachPrimitive(node, function (babylonMesh) {
+        return Promise.all(promises).then(() => {
+            this._forEachPrimitive(node, (babylonMesh) => {
                 if (babylonMesh.geometry && babylonMesh.geometry.useBoundingInfoFromGeometry) {
                     // simply apply the world matrices to the bounding info - the extends are already ok
                     babylonMesh._updateBoundingInfo();
@@ -707,21 +652,21 @@ var GLTFLoader = /** @class */ (function () {
             });
             return node._babylonTransformNode;
         });
-    };
-    GLTFLoader.prototype._loadMeshAsync = function (context, node, mesh, assign) {
-        var primitives = mesh.primitives;
+    }
+    _loadMeshAsync(context, node, mesh, assign) {
+        const primitives = mesh.primitives;
         if (!primitives || !primitives.length) {
-            throw new Error("".concat(context, ": Primitives are missing"));
+            throw new Error(`${context}: Primitives are missing`);
         }
         if (primitives[0].index == undefined) {
             ArrayItem.Assign(primitives);
         }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(mesh.name || ""));
-        var name = node.name || "node".concat(node.index);
+        const promises = new Array();
+        this.logOpen(`${context} ${mesh.name || ""}`);
+        const name = node.name || `node${node.index}`;
         if (primitives.length === 1) {
-            var primitive = mesh.primitives[0];
-            promises.push(this._loadMeshPrimitiveAsync("".concat(context, "/primitives/").concat(primitive.index), name, node, mesh, primitive, function (babylonMesh) {
+            const primitive = mesh.primitives[0];
+            promises.push(this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, name, node, mesh, primitive, (babylonMesh) => {
                 node._babylonTransformNode = babylonMesh;
                 node._primitiveBabylonMeshes = [babylonMesh];
             }));
@@ -732,9 +677,8 @@ var GLTFLoader = /** @class */ (function () {
             node._babylonTransformNode._parentContainer = this._assetContainer;
             this._babylonScene._blockEntityCollection = false;
             node._primitiveBabylonMeshes = [];
-            for (var _i = 0, primitives_1 = primitives; _i < primitives_1.length; _i++) {
-                var primitive = primitives_1[_i];
-                promises.push(this._loadMeshPrimitiveAsync("".concat(context, "/primitives/").concat(primitive.index), "".concat(name, "_primitive").concat(primitive.index), node, mesh, primitive, function (babylonMesh) {
+            for (const primitive of primitives) {
+                promises.push(this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, `${name}_primitive${primitive.index}`, node, mesh, primitive, (babylonMesh) => {
                     babylonMesh.parent = node._babylonTransformNode;
                     node._primitiveBabylonMeshes.push(babylonMesh);
                 }));
@@ -742,10 +686,10 @@ var GLTFLoader = /** @class */ (function () {
         }
         assign(node._babylonTransformNode);
         this.logClose();
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             return node._babylonTransformNode;
         });
-    };
+    }
     /**
      * @hidden Define this method to modify the default behavior when loading data for mesh primitives.
      * @param context The context when loading the asset
@@ -756,16 +700,15 @@ var GLTFLoader = /** @class */ (function () {
      * @param assign A function called synchronously after parsing the glTF properties
      * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
      */
-    GLTFLoader.prototype._loadMeshPrimitiveAsync = function (context, name, node, mesh, primitive, assign) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);
+    _loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign) {
+        const extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);
         if (extensionPromise) {
             return extensionPromise;
         }
-        this.logOpen("".concat(context));
-        var shouldInstance = this._disableInstancedMesh === 0 && this._parent.createInstances && node.skin == undefined && !mesh.primitives[0].targets;
-        var babylonAbstractMesh;
-        var promise;
+        this.logOpen(`${context}`);
+        const shouldInstance = this._disableInstancedMesh === 0 && this._parent.createInstances && node.skin == undefined && !mesh.primitives[0].targets;
+        let babylonAbstractMesh;
+        let promise;
         if (shouldInstance && primitive._instanceData) {
             this._babylonScene._blockEntityCollection = !!this._assetContainer;
             babylonAbstractMesh = primitive._instanceData.babylonSourceMesh.createInstance(name);
@@ -774,79 +717,78 @@ var GLTFLoader = /** @class */ (function () {
             promise = primitive._instanceData.promise;
         }
         else {
-            var promises = new Array();
+            const promises = new Array();
             this._babylonScene._blockEntityCollection = !!this._assetContainer;
-            var babylonMesh_1 = new Mesh(name, this._babylonScene);
-            babylonMesh_1._parentContainer = this._assetContainer;
+            const babylonMesh = new Mesh(name, this._babylonScene);
+            babylonMesh._parentContainer = this._assetContainer;
             this._babylonScene._blockEntityCollection = false;
-            babylonMesh_1.overrideMaterialSideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
-            this._createMorphTargets(context, node, mesh, primitive, babylonMesh_1);
-            promises.push(this._loadVertexDataAsync(context, primitive, babylonMesh_1).then(function (babylonGeometry) {
-                return _this._loadMorphTargetsAsync(context, primitive, babylonMesh_1, babylonGeometry).then(function () {
-                    if (_this._disposed) {
+            babylonMesh.overrideMaterialSideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
+            this._createMorphTargets(context, node, mesh, primitive, babylonMesh);
+            promises.push(this._loadVertexDataAsync(context, primitive, babylonMesh).then((babylonGeometry) => {
+                return this._loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry).then(() => {
+                    if (this._disposed) {
                         return;
                     }
-                    _this._babylonScene._blockEntityCollection = !!_this._assetContainer;
-                    babylonGeometry.applyToMesh(babylonMesh_1);
-                    babylonGeometry._parentContainer = _this._assetContainer;
-                    _this._babylonScene._blockEntityCollection = false;
+                    this._babylonScene._blockEntityCollection = !!this._assetContainer;
+                    babylonGeometry.applyToMesh(babylonMesh);
+                    babylonGeometry._parentContainer = this._assetContainer;
+                    this._babylonScene._blockEntityCollection = false;
                 });
             }));
-            var babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
+            const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
             if (primitive.material == undefined) {
-                var babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
+                let babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
                 if (!babylonMaterial) {
                     babylonMaterial = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode);
                     this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                     this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;
                 }
-                babylonMesh_1.material = babylonMaterial;
+                babylonMesh.material = babylonMaterial;
             }
             else if (!this.parent.skipMaterials) {
-                var material = ArrayItem.Get("".concat(context, "/material"), this._gltf.materials, primitive.material);
-                promises.push(this._loadMaterialAsync("/materials/".concat(material.index), material, babylonMesh_1, babylonDrawMode, function (babylonMaterial) {
-                    babylonMesh_1.material = babylonMaterial;
+                const material = ArrayItem.Get(`${context}/material`, this._gltf.materials, primitive.material);
+                promises.push(this._loadMaterialAsync(`/materials/${material.index}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {
+                    babylonMesh.material = babylonMaterial;
                 }));
             }
             promise = Promise.all(promises);
             if (shouldInstance) {
                 primitive._instanceData = {
-                    babylonSourceMesh: babylonMesh_1,
+                    babylonSourceMesh: babylonMesh,
                     promise: promise,
                 };
             }
-            babylonAbstractMesh = babylonMesh_1;
+            babylonAbstractMesh = babylonMesh;
         }
         GLTFLoader.AddPointerMetadata(babylonAbstractMesh, context);
         this._parent.onMeshLoadedObservable.notifyObservers(babylonAbstractMesh);
         assign(babylonAbstractMesh);
         this.logClose();
-        return promise.then(function () {
+        return promise.then(() => {
             return babylonAbstractMesh;
         });
-    };
-    GLTFLoader.prototype._loadVertexDataAsync = function (context, primitive, babylonMesh) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);
+    }
+    _loadVertexDataAsync(context, primitive, babylonMesh) {
+        const extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);
         if (extensionPromise) {
             return extensionPromise;
         }
-        var attributes = primitive.attributes;
+        const attributes = primitive.attributes;
         if (!attributes) {
-            throw new Error("".concat(context, ": Attributes are missing"));
+            throw new Error(`${context}: Attributes are missing`);
         }
-        var promises = new Array();
-        var babylonGeometry = new Geometry(babylonMesh.name, this._babylonScene);
+        const promises = new Array();
+        const babylonGeometry = new Geometry(babylonMesh.name, this._babylonScene);
         if (primitive.indices == undefined) {
             babylonMesh.isUnIndexed = true;
         }
         else {
-            var accessor = ArrayItem.Get("".concat(context, "/indices"), this._gltf.accessors, primitive.indices);
-            promises.push(this._loadIndicesAccessorAsync("/accessors/".concat(accessor.index), accessor).then(function (data) {
+            const accessor = ArrayItem.Get(`${context}/indices`, this._gltf.accessors, primitive.indices);
+            promises.push(this._loadIndicesAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {
                 babylonGeometry.setIndices(data);
             }));
         }
-        var loadAttribute = function (attribute, kind, callback) {
+        const loadAttribute = (attribute, kind, callback) => {
             if (attributes[attribute] == undefined) {
                 return;
             }
@@ -854,13 +796,13 @@ var GLTFLoader = /** @class */ (function () {
             if (babylonMesh._delayInfo.indexOf(kind) === -1) {
                 babylonMesh._delayInfo.push(kind);
             }
-            var accessor = ArrayItem.Get("".concat(context, "/attributes/").concat(attribute), _this._gltf.accessors, attributes[attribute]);
-            promises.push(_this._loadVertexAccessorAsync("/accessors/".concat(accessor.index), accessor, kind).then(function (babylonVertexBuffer) {
-                if (babylonVertexBuffer.getKind() === VertexBuffer.PositionKind && !_this.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton) {
-                    var mmin = accessor.min, mmax = accessor.max;
+            const accessor = ArrayItem.Get(`${context}/attributes/${attribute}`, this._gltf.accessors, attributes[attribute]);
+            promises.push(this._loadVertexAccessorAsync(`/accessors/${accessor.index}`, accessor, kind).then((babylonVertexBuffer) => {
+                if (babylonVertexBuffer.getKind() === VertexBuffer.PositionKind && !this.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton) {
+                    const mmin = accessor.min, mmax = accessor.max;
                     if (mmin !== undefined && mmax !== undefined) {
                         if (accessor.normalized && accessor.componentType !== 5126 /* FLOAT */) {
-                            var divider = 1;
+                            let divider = 1;
                             switch (accessor.componentType) {
                                 case 5120 /* BYTE */:
                                     divider = 127.0;
@@ -875,14 +817,14 @@ var GLTFLoader = /** @class */ (function () {
                                     divider = 65535.0;
                                     break;
                             }
-                            for (var i = 0; i < 3; ++i) {
+                            for (let i = 0; i < 3; ++i) {
                                 mmin[i] = Math.max(mmin[i] / divider, -1.0);
                                 mmax[i] = Math.max(mmax[i] / divider, -1.0);
                             }
                         }
-                        var min = TmpVectors.Vector3[0], max = TmpVectors.Vector3[1];
-                        min.copyFromFloats.apply(min, mmin);
-                        max.copyFromFloats.apply(max, mmax);
+                        const min = TmpVectors.Vector3[0], max = TmpVectors.Vector3[1];
+                        min.copyFromFloats(...mmin);
+                        max.copyFromFloats(...mmax);
                         babylonGeometry._boundingInfo = new BoundingInfo(min, max);
                         babylonGeometry.useBoundingInfoFromGeometry = true;
                     }
@@ -909,16 +851,16 @@ var GLTFLoader = /** @class */ (function () {
         loadAttribute("WEIGHTS_0", VertexBuffer.MatricesWeightsKind);
         loadAttribute("JOINTS_1", VertexBuffer.MatricesIndicesExtraKind);
         loadAttribute("WEIGHTS_1", VertexBuffer.MatricesWeightsExtraKind);
-        loadAttribute("COLOR_0", VertexBuffer.ColorKind, function (accessor) {
+        loadAttribute("COLOR_0", VertexBuffer.ColorKind, (accessor) => {
             if (accessor.type === "VEC4" /* VEC4 */) {
                 babylonMesh.hasVertexAlpha = true;
             }
         });
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             return babylonGeometry;
         });
-    };
-    GLTFLoader.prototype._createMorphTargets = function (context, node, mesh, primitive, babylonMesh) {
+    }
+    _createMorphTargets(context, node, mesh, primitive, babylonMesh) {
         if (!primitive.targets) {
             return;
         }
@@ -926,66 +868,65 @@ var GLTFLoader = /** @class */ (function () {
             node._numMorphTargets = primitive.targets.length;
         }
         else if (primitive.targets.length !== node._numMorphTargets) {
-            throw new Error("".concat(context, ": Primitives do not have the same number of targets"));
+            throw new Error(`${context}: Primitives do not have the same number of targets`);
         }
-        var targetNames = mesh.extras ? mesh.extras.targetNames : null;
+        const targetNames = mesh.extras ? mesh.extras.targetNames : null;
         babylonMesh.morphTargetManager = new MorphTargetManager(babylonMesh.getScene());
         babylonMesh.morphTargetManager.areUpdatesFrozen = true;
-        for (var index = 0; index < primitive.targets.length; index++) {
-            var weight = node.weights ? node.weights[index] : mesh.weights ? mesh.weights[index] : 0;
-            var name_3 = targetNames ? targetNames[index] : "morphTarget".concat(index);
-            babylonMesh.morphTargetManager.addTarget(new MorphTarget(name_3, weight, babylonMesh.getScene()));
+        for (let index = 0; index < primitive.targets.length; index++) {
+            const weight = node.weights ? node.weights[index] : mesh.weights ? mesh.weights[index] : 0;
+            const name = targetNames ? targetNames[index] : `morphTarget${index}`;
+            babylonMesh.morphTargetManager.addTarget(new MorphTarget(name, weight, babylonMesh.getScene()));
             // TODO: tell the target whether it has positions, normals, tangents
         }
-    };
-    GLTFLoader.prototype._loadMorphTargetsAsync = function (context, primitive, babylonMesh, babylonGeometry) {
+    }
+    _loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry) {
         if (!primitive.targets) {
             return Promise.resolve();
         }
-        var promises = new Array();
-        var morphTargetManager = babylonMesh.morphTargetManager;
-        for (var index = 0; index < morphTargetManager.numTargets; index++) {
-            var babylonMorphTarget = morphTargetManager.getTarget(index);
-            promises.push(this._loadMorphTargetVertexDataAsync("".concat(context, "/targets/").concat(index), babylonGeometry, primitive.targets[index], babylonMorphTarget));
+        const promises = new Array();
+        const morphTargetManager = babylonMesh.morphTargetManager;
+        for (let index = 0; index < morphTargetManager.numTargets; index++) {
+            const babylonMorphTarget = morphTargetManager.getTarget(index);
+            promises.push(this._loadMorphTargetVertexDataAsync(`${context}/targets/${index}`, babylonGeometry, primitive.targets[index], babylonMorphTarget));
         }
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             morphTargetManager.areUpdatesFrozen = false;
         });
-    };
-    GLTFLoader.prototype._loadMorphTargetVertexDataAsync = function (context, babylonGeometry, attributes, babylonMorphTarget) {
-        var _this = this;
-        var promises = new Array();
-        var loadAttribute = function (attribute, kind, setData) {
+    }
+    _loadMorphTargetVertexDataAsync(context, babylonGeometry, attributes, babylonMorphTarget) {
+        const promises = new Array();
+        const loadAttribute = (attribute, kind, setData) => {
             if (attributes[attribute] == undefined) {
                 return;
             }
-            var babylonVertexBuffer = babylonGeometry.getVertexBuffer(kind);
+            const babylonVertexBuffer = babylonGeometry.getVertexBuffer(kind);
             if (!babylonVertexBuffer) {
                 return;
             }
-            var accessor = ArrayItem.Get("".concat(context, "/").concat(attribute), _this._gltf.accessors, attributes[attribute]);
-            promises.push(_this._loadFloatAccessorAsync("/accessors/".concat(accessor.index), accessor).then(function (data) {
+            const accessor = ArrayItem.Get(`${context}/${attribute}`, this._gltf.accessors, attributes[attribute]);
+            promises.push(this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {
                 setData(babylonVertexBuffer, data);
             }));
         };
-        loadAttribute("POSITION", VertexBuffer.PositionKind, function (babylonVertexBuffer, data) {
-            var positions = new Float32Array(data.length);
-            babylonVertexBuffer.forEach(data.length, function (value, index) {
+        loadAttribute("POSITION", VertexBuffer.PositionKind, (babylonVertexBuffer, data) => {
+            const positions = new Float32Array(data.length);
+            babylonVertexBuffer.forEach(data.length, (value, index) => {
                 positions[index] = data[index] + value;
             });
             babylonMorphTarget.setPositions(positions);
         });
-        loadAttribute("NORMAL", VertexBuffer.NormalKind, function (babylonVertexBuffer, data) {
-            var normals = new Float32Array(data.length);
-            babylonVertexBuffer.forEach(normals.length, function (value, index) {
+        loadAttribute("NORMAL", VertexBuffer.NormalKind, (babylonVertexBuffer, data) => {
+            const normals = new Float32Array(data.length);
+            babylonVertexBuffer.forEach(normals.length, (value, index) => {
                 normals[index] = data[index] + value;
             });
             babylonMorphTarget.setNormals(normals);
         });
-        loadAttribute("TANGENT", VertexBuffer.TangentKind, function (babylonVertexBuffer, data) {
-            var tangents = new Float32Array((data.length / 3) * 4);
-            var dataIndex = 0;
-            babylonVertexBuffer.forEach((data.length / 3) * 4, function (value, index) {
+        loadAttribute("TANGENT", VertexBuffer.TangentKind, (babylonVertexBuffer, data) => {
+            const tangents = new Float32Array((data.length / 3) * 4);
+            let dataIndex = 0;
+            babylonVertexBuffer.forEach((data.length / 3) * 4, (value, index) => {
                 // Tangent data for morph targets is stored as xyz delta.
                 // The vertexData.tangent is stored as xyzw.
                 // So we need to skip every fourth vertexData.tangent.
@@ -996,19 +937,19 @@ var GLTFLoader = /** @class */ (function () {
             });
             babylonMorphTarget.setTangents(tangents);
         });
-        return Promise.all(promises).then(function () { });
-    };
-    GLTFLoader._LoadTransform = function (node, babylonNode) {
+        return Promise.all(promises).then(() => { });
+    }
+    static _LoadTransform(node, babylonNode) {
         // Ignore the TRS of skinned nodes.
         // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
         if (node.skin != undefined) {
             return;
         }
-        var position = Vector3.Zero();
-        var rotation = Quaternion.Identity();
-        var scaling = Vector3.One();
+        let position = Vector3.Zero();
+        let rotation = Quaternion.Identity();
+        let scaling = Vector3.One();
         if (node.matrix) {
-            var matrix = Matrix.FromArray(node.matrix);
+            const matrix = Matrix.FromArray(node.matrix);
             matrix.decompose(scaling, rotation, position);
         }
         else {
@@ -1025,10 +966,9 @@ var GLTFLoader = /** @class */ (function () {
         babylonNode.position = position;
         babylonNode.rotationQuaternion = rotation;
         babylonNode.scaling = scaling;
-    };
-    GLTFLoader.prototype._loadSkinAsync = function (context, node, skin, assign) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);
+    }
+    _loadSkinAsync(context, node, skin, assign) {
+        const extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);
         if (extensionPromise) {
             return extensionPromise;
         }
@@ -1036,14 +976,14 @@ var GLTFLoader = /** @class */ (function () {
             assign(skin._data.babylonSkeleton);
             return skin._data.promise;
         }
-        var skeletonId = "skeleton".concat(skin.index);
+        const skeletonId = `skeleton${skin.index}`;
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonSkeleton = new Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
+        const babylonSkeleton = new Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
         babylonSkeleton._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         this._loadBones(context, skin, babylonSkeleton);
-        var promise = this._loadSkinInverseBindMatricesDataAsync(context, skin).then(function (inverseBindMatricesData) {
-            _this._updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);
+        const promise = this._loadSkinInverseBindMatricesDataAsync(context, skin).then((inverseBindMatricesData) => {
+            this._updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);
         });
         skin._data = {
             babylonSkeleton: babylonSkeleton,
@@ -1051,16 +991,16 @@ var GLTFLoader = /** @class */ (function () {
         };
         assign(babylonSkeleton);
         return promise;
-    };
-    GLTFLoader.prototype._loadBones = function (context, skin, babylonSkeleton) {
+    }
+    _loadBones(context, skin, babylonSkeleton) {
         if (skin.skeleton == undefined || this._parent.alwaysComputeSkeletonRootNode) {
-            var rootNode = this._findSkeletonRootNode("".concat(context, "/joints"), skin.joints);
+            const rootNode = this._findSkeletonRootNode(`${context}/joints`, skin.joints);
             if (rootNode) {
                 if (skin.skeleton === undefined) {
                     skin.skeleton = rootNode.index;
                 }
                 else {
-                    var isParent = function (a, b) {
+                    const isParent = (a, b) => {
                         for (; b.parent; b = b.parent) {
                             if (b.parent === a) {
                                 return true;
@@ -1068,47 +1008,45 @@ var GLTFLoader = /** @class */ (function () {
                         }
                         return false;
                     };
-                    var skeletonNode = ArrayItem.Get("".concat(context, "/skeleton"), this._gltf.nodes, skin.skeleton);
+                    const skeletonNode = ArrayItem.Get(`${context}/skeleton`, this._gltf.nodes, skin.skeleton);
                     if (skeletonNode !== rootNode && !isParent(skeletonNode, rootNode)) {
-                        Logger.Warn("".concat(context, "/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root"));
+                        Logger.Warn(`${context}/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root`);
                         skin.skeleton = rootNode.index;
                     }
                 }
             }
             else {
-                Logger.Warn("".concat(context, ": Failed to find common root"));
+                Logger.Warn(`${context}: Failed to find common root`);
             }
         }
-        var babylonBones = {};
-        for (var _i = 0, _a = skin.joints; _i < _a.length; _i++) {
-            var index = _a[_i];
-            var node = ArrayItem.Get("".concat(context, "/joints/").concat(index), this._gltf.nodes, index);
+        const babylonBones = {};
+        for (const index of skin.joints) {
+            const node = ArrayItem.Get(`${context}/joints/${index}`, this._gltf.nodes, index);
             this._loadBone(node, skin, babylonSkeleton, babylonBones);
         }
-    };
-    GLTFLoader.prototype._findSkeletonRootNode = function (context, joints) {
+    }
+    _findSkeletonRootNode(context, joints) {
         if (joints.length === 0) {
             return null;
         }
-        var paths = {};
-        for (var _i = 0, joints_1 = joints; _i < joints_1.length; _i++) {
-            var index = joints_1[_i];
-            var path = new Array();
-            var node = ArrayItem.Get("".concat(context, "/").concat(index), this._gltf.nodes, index);
+        const paths = {};
+        for (const index of joints) {
+            const path = new Array();
+            let node = ArrayItem.Get(`${context}/${index}`, this._gltf.nodes, index);
             while (node.index !== -1) {
                 path.unshift(node);
                 node = node.parent;
             }
             paths[index] = path;
         }
-        var rootNode = null;
-        for (var i = 0;; ++i) {
-            var path = paths[joints[0]];
+        let rootNode = null;
+        for (let i = 0;; ++i) {
+            let path = paths[joints[0]];
             if (i >= path.length) {
                 return rootNode;
             }
-            var node = path[i];
-            for (var j = 1; j < joints.length; ++j) {
+            const node = path[i];
+            for (let j = 1; j < joints.length; ++j) {
                 path = paths[joints[j]];
                 if (i >= path.length || node !== path[i]) {
                     return rootNode;
@@ -1116,61 +1054,60 @@ var GLTFLoader = /** @class */ (function () {
             }
             rootNode = node;
         }
-    };
-    GLTFLoader.prototype._loadBone = function (node, skin, babylonSkeleton, babylonBones) {
-        var babylonBone = babylonBones[node.index];
+    }
+    _loadBone(node, skin, babylonSkeleton, babylonBones) {
+        let babylonBone = babylonBones[node.index];
         if (babylonBone) {
             return babylonBone;
         }
-        var parentBabylonBone = null;
+        let parentBabylonBone = null;
         if (node.index !== skin.skeleton) {
             if (node.parent && node.parent.index !== -1) {
                 parentBabylonBone = this._loadBone(node.parent, skin, babylonSkeleton, babylonBones);
             }
             else if (skin.skeleton !== undefined) {
-                Logger.Warn("/skins/".concat(skin.index, "/skeleton: Skeleton node is not a common root"));
+                Logger.Warn(`/skins/${skin.index}/skeleton: Skeleton node is not a common root`);
             }
         }
-        var boneIndex = skin.joints.indexOf(node.index);
-        babylonBone = new Bone(node.name || "joint".concat(node.index), babylonSkeleton, parentBabylonBone, this._getNodeMatrix(node), null, null, boneIndex);
+        const boneIndex = skin.joints.indexOf(node.index);
+        babylonBone = new Bone(node.name || `joint${node.index}`, babylonSkeleton, parentBabylonBone, this._getNodeMatrix(node), null, null, boneIndex);
         babylonBones[node.index] = babylonBone;
         // Wait until the scene is loaded to ensure the transform nodes are loaded.
-        this._postSceneLoadActions.push(function () {
+        this._postSceneLoadActions.push(() => {
             // Link the Babylon bone with the corresponding Babylon transform node.
             // A glTF joint is a pointer to a glTF node in the glTF node hierarchy similar to Unity3D.
             babylonBone.linkTransformNode(node._babylonTransformNode);
         });
         return babylonBone;
-    };
-    GLTFLoader.prototype._loadSkinInverseBindMatricesDataAsync = function (context, skin) {
+    }
+    _loadSkinInverseBindMatricesDataAsync(context, skin) {
         if (skin.inverseBindMatrices == undefined) {
             return Promise.resolve(null);
         }
-        var accessor = ArrayItem.Get("".concat(context, "/inverseBindMatrices"), this._gltf.accessors, skin.inverseBindMatrices);
-        return this._loadFloatAccessorAsync("/accessors/".concat(accessor.index), accessor);
-    };
-    GLTFLoader.prototype._updateBoneMatrices = function (babylonSkeleton, inverseBindMatricesData) {
-        for (var _i = 0, _a = babylonSkeleton.bones; _i < _a.length; _i++) {
-            var babylonBone = _a[_i];
-            var baseMatrix = Matrix.Identity();
-            var boneIndex = babylonBone._index;
+        const accessor = ArrayItem.Get(`${context}/inverseBindMatrices`, this._gltf.accessors, skin.inverseBindMatrices);
+        return this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor);
+    }
+    _updateBoneMatrices(babylonSkeleton, inverseBindMatricesData) {
+        for (const babylonBone of babylonSkeleton.bones) {
+            const baseMatrix = Matrix.Identity();
+            const boneIndex = babylonBone._index;
             if (inverseBindMatricesData && boneIndex !== -1) {
                 Matrix.FromArrayToRef(inverseBindMatricesData, boneIndex * 16, baseMatrix);
                 baseMatrix.invertToRef(baseMatrix);
             }
-            var babylonParentBone = babylonBone.getParent();
+            const babylonParentBone = babylonBone.getParent();
             if (babylonParentBone) {
                 baseMatrix.multiplyToRef(babylonParentBone.getInvertedAbsoluteTransform(), baseMatrix);
             }
             babylonBone.updateMatrix(baseMatrix, false, false);
             babylonBone._updateDifferenceMatrix(undefined, false);
         }
-    };
-    GLTFLoader.prototype._getNodeMatrix = function (node) {
+    }
+    _getNodeMatrix(node) {
         return node.matrix
             ? Matrix.FromArray(node.matrix)
             : Matrix.Compose(node.scale ? Vector3.FromArray(node.scale) : Vector3.One(), node.rotation ? Quaternion.FromArray(node.rotation) : Quaternion.Identity(), node.translation ? Vector3.FromArray(node.translation) : Vector3.Zero());
-    };
+    }
     /**
      * Loads a glTF camera.
      * @param context The context when loading the asset
@@ -1178,25 +1115,24 @@ var GLTFLoader = /** @class */ (function () {
      * @param assign A function called synchronously after parsing the glTF properties
      * @returns A promise that resolves with the loaded Babylon camera when the load is complete
      */
-    GLTFLoader.prototype.loadCameraAsync = function (context, camera, assign) {
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadCameraAsync(context, camera, assign);
+    loadCameraAsync(context, camera, assign = () => { }) {
+        const extensionPromise = this._extensionsLoadCameraAsync(context, camera, assign);
         if (extensionPromise) {
             return extensionPromise;
         }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(camera.name || ""));
+        const promises = new Array();
+        this.logOpen(`${context} ${camera.name || ""}`);
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonCamera = new FreeCamera(camera.name || "camera".concat(camera.index), Vector3.Zero(), this._babylonScene, false);
+        const babylonCamera = new FreeCamera(camera.name || `camera${camera.index}`, Vector3.Zero(), this._babylonScene, false);
         babylonCamera._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         babylonCamera.ignoreParentScaling = true;
         babylonCamera.rotation = new Vector3(0, Math.PI, 0);
         switch (camera.type) {
             case "perspective" /* PERSPECTIVE */: {
-                var perspective = camera.perspective;
+                const perspective = camera.perspective;
                 if (!perspective) {
-                    throw new Error("".concat(context, ": Camera perspective properties are missing"));
+                    throw new Error(`${context}: Camera perspective properties are missing`);
                 }
                 babylonCamera.fov = perspective.yfov;
                 babylonCamera.minZ = perspective.znear;
@@ -1205,7 +1141,7 @@ var GLTFLoader = /** @class */ (function () {
             }
             case "orthographic" /* ORTHOGRAPHIC */: {
                 if (!camera.orthographic) {
-                    throw new Error("".concat(context, ": Camera orthographic properties are missing"));
+                    throw new Error(`${context}: Camera orthographic properties are missing`);
                 }
                 babylonCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
                 babylonCamera.orthoLeft = -camera.orthographic.xmag;
@@ -1217,7 +1153,7 @@ var GLTFLoader = /** @class */ (function () {
                 break;
             }
             default: {
-                throw new Error("".concat(context, ": Invalid camera type (").concat(camera.type, ")"));
+                throw new Error(`${context}: Invalid camera type (${camera.type})`);
             }
         }
         GLTFLoader.AddPointerMetadata(babylonCamera, context);
@@ -1226,44 +1162,43 @@ var GLTFLoader = /** @class */ (function () {
         // register the camera to be used later.
         camera._babylonCamera = babylonCamera;
         this.logClose();
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             return babylonCamera;
         });
-    };
-    GLTFLoader.prototype._loadAnimationsAsync = function () {
-        var animations = this._gltf.animations;
+    }
+    _loadAnimationsAsync() {
+        const animations = this._gltf.animations;
         if (!animations) {
             return Promise.resolve();
         }
-        var promises = new Array();
-        for (var index = 0; index < animations.length; index++) {
-            var animation = animations[index];
-            promises.push(this.loadAnimationAsync("/animations/".concat(animation.index), animation).then(function (animationGroup) {
+        const promises = new Array();
+        for (let index = 0; index < animations.length; index++) {
+            const animation = animations[index];
+            promises.push(this.loadAnimationAsync(`/animations/${animation.index}`, animation).then((animationGroup) => {
                 // Delete the animation group if it ended up not having any animations in it.
                 if (animationGroup.targetedAnimations.length === 0) {
                     animationGroup.dispose();
                 }
             }));
         }
-        return Promise.all(promises).then(function () { });
-    };
+        return Promise.all(promises).then(() => { });
+    }
     /**
      * Loads a glTF animation.
      * @param context The context when loading the asset
      * @param animation The glTF animation property
      * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
      */
-    GLTFLoader.prototype.loadAnimationAsync = function (context, animation) {
+    loadAnimationAsync(context, animation) {
         // turn everything into pointer
-        for (var _i = 0, _a = animation.channels; _i < _a.length; _i++) {
-            var channel = _a[_i];
+        for (const channel of animation.channels) {
             if (channel.target.path == "pointer" /* POINTER */) {
                 continue;
             }
             // decorate the channel with a KHR_animation_pointer extension.
             channel.target.extensions = channel.target.extensions || {};
             channel.target.extensions.KHR_animation_pointer = {
-                pointer: "/nodes/".concat(channel.target.node, "/").concat(channel.target.path),
+                pointer: `/nodes/${channel.target.node}/${channel.target.path}`,
             };
             channel.target.path = "pointer" /* POINTER */;
             delete channel.target.node;
@@ -1275,13 +1210,13 @@ var GLTFLoader = /** @class */ (function () {
         }
         // create the animation group to be passed to extension.
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonAnimationGroup = new AnimationGroup(animation.name || "animation".concat(animation.index), this._babylonScene);
+        const babylonAnimationGroup = new AnimationGroup(animation.name || `animation${animation.index}`, this._babylonScene);
         babylonAnimationGroup._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         animation._babylonAnimationGroup = babylonAnimationGroup;
-        var promise = this._extensionsLoadAnimationAsync(context, animation);
-        return promise !== null && promise !== void 0 ? promise : Promise.resolve(animation._babylonAnimationGroup);
-    };
+        const promise = this._extensionsLoadAnimationAsync(context, animation);
+        return promise ?? Promise.resolve(animation._babylonAnimationGroup);
+    }
     /**
      * Loads a glTF buffer.
      * @param context The context when loading the asset
@@ -1290,103 +1225,101 @@ var GLTFLoader = /** @class */ (function () {
      * @param byteLength The byte length to use
      * @returns A promise that resolves with the loaded data when the load is complete
      */
-    GLTFLoader.prototype.loadBufferAsync = function (context, buffer, byteOffset, byteLength) {
-        var extensionPromise = this._extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength);
+    loadBufferAsync(context, buffer, byteOffset, byteLength) {
+        const extensionPromise = this._extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength);
         if (extensionPromise) {
             return extensionPromise;
         }
         if (!buffer._data) {
             if (buffer.uri) {
-                buffer._data = this.loadUriAsync("".concat(context, "/uri"), buffer, buffer.uri);
+                buffer._data = this.loadUriAsync(`${context}/uri`, buffer, buffer.uri);
             }
             else {
                 if (!this._bin) {
-                    throw new Error("".concat(context, ": Uri is missing or the binary glTF is missing its binary chunk"));
+                    throw new Error(`${context}: Uri is missing or the binary glTF is missing its binary chunk`);
                 }
                 buffer._data = this._bin.readAsync(0, buffer.byteLength);
             }
         }
-        return buffer._data.then(function (data) {
+        return buffer._data.then((data) => {
             try {
                 return new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);
             }
             catch (e) {
-                throw new Error("".concat(context, ": ").concat(e.message));
+                throw new Error(`${context}: ${e.message}`);
             }
         });
-    };
+    }
     /**
      * Loads a glTF buffer view.
      * @param context The context when loading the asset
      * @param bufferView The glTF buffer view property
      * @returns A promise that resolves with the loaded data when the load is complete
      */
-    GLTFLoader.prototype.loadBufferViewAsync = function (context, bufferView) {
-        var extensionPromise = this._extensionsLoadBufferViewAsync(context, bufferView);
+    loadBufferViewAsync(context, bufferView) {
+        const extensionPromise = this._extensionsLoadBufferViewAsync(context, bufferView);
         if (extensionPromise) {
             return extensionPromise;
         }
         if (bufferView._data) {
             return bufferView._data;
         }
-        var buffer = ArrayItem.Get("".concat(context, "/buffer"), this._gltf.buffers, bufferView.buffer);
-        bufferView._data = this.loadBufferAsync("/buffers/".concat(buffer.index), buffer, bufferView.byteOffset || 0, bufferView.byteLength);
+        const buffer = ArrayItem.Get(`${context}/buffer`, this._gltf.buffers, bufferView.buffer);
+        bufferView._data = this.loadBufferAsync(`/buffers/${buffer.index}`, buffer, bufferView.byteOffset || 0, bufferView.byteLength);
         return bufferView._data;
-    };
-    GLTFLoader.prototype._loadAccessorAsync = function (context, accessor, constructor) {
-        var _this = this;
+    }
+    _loadAccessorAsync(context, accessor, constructor) {
         if (accessor._data) {
             return accessor._data;
         }
-        var numComponents = GLTFLoader._GetNumComponents(context, accessor.type);
-        var byteStride = numComponents * VertexBuffer.GetTypeByteLength(accessor.componentType);
-        var length = numComponents * accessor.count;
+        const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);
+        const byteStride = numComponents * VertexBuffer.GetTypeByteLength(accessor.componentType);
+        const length = numComponents * accessor.count;
         if (accessor.bufferView == undefined) {
             accessor._data = Promise.resolve(new constructor(length));
         }
         else {
-            var bufferView_1 = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
-            accessor._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView_1.index), bufferView_1).then(function (data) {
-                if (accessor.componentType === 5126 /* FLOAT */ && !accessor.normalized && (!bufferView_1.byteStride || bufferView_1.byteStride === byteStride)) {
+            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);
+            accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {
+                if (accessor.componentType === 5126 /* FLOAT */ && !accessor.normalized && (!bufferView.byteStride || bufferView.byteStride === byteStride)) {
                     return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, length);
                 }
                 else {
-                    var typedArray_1 = new constructor(length);
-                    VertexBuffer.ForEach(data, accessor.byteOffset || 0, bufferView_1.byteStride || byteStride, numComponents, accessor.componentType, typedArray_1.length, accessor.normalized || false, function (value, index) {
-                        typedArray_1[index] = value;
+                    const typedArray = new constructor(length);
+                    VertexBuffer.ForEach(data, accessor.byteOffset || 0, bufferView.byteStride || byteStride, numComponents, accessor.componentType, typedArray.length, accessor.normalized || false, (value, index) => {
+                        typedArray[index] = value;
                     });
-                    return typedArray_1;
+                    return typedArray;
                 }
             });
         }
         if (accessor.sparse) {
-            var sparse_1 = accessor.sparse;
-            accessor._data = accessor._data.then(function (data) {
-                var typedArray = data;
-                var indicesBufferView = ArrayItem.Get("".concat(context, "/sparse/indices/bufferView"), _this._gltf.bufferViews, sparse_1.indices.bufferView);
-                var valuesBufferView = ArrayItem.Get("".concat(context, "/sparse/values/bufferView"), _this._gltf.bufferViews, sparse_1.values.bufferView);
+            const sparse = accessor.sparse;
+            accessor._data = accessor._data.then((data) => {
+                const typedArray = data;
+                const indicesBufferView = ArrayItem.Get(`${context}/sparse/indices/bufferView`, this._gltf.bufferViews, sparse.indices.bufferView);
+                const valuesBufferView = ArrayItem.Get(`${context}/sparse/values/bufferView`, this._gltf.bufferViews, sparse.values.bufferView);
                 return Promise.all([
-                    _this.loadBufferViewAsync("/bufferViews/".concat(indicesBufferView.index), indicesBufferView),
-                    _this.loadBufferViewAsync("/bufferViews/".concat(valuesBufferView.index), valuesBufferView),
-                ]).then(function (_a) {
-                    var indicesData = _a[0], valuesData = _a[1];
-                    var indices = GLTFLoader._GetTypedArray("".concat(context, "/sparse/indices"), sparse_1.indices.componentType, indicesData, sparse_1.indices.byteOffset, sparse_1.count);
-                    var sparseLength = numComponents * sparse_1.count;
-                    var values;
+                    this.loadBufferViewAsync(`/bufferViews/${indicesBufferView.index}`, indicesBufferView),
+                    this.loadBufferViewAsync(`/bufferViews/${valuesBufferView.index}`, valuesBufferView),
+                ]).then(([indicesData, valuesData]) => {
+                    const indices = GLTFLoader._GetTypedArray(`${context}/sparse/indices`, sparse.indices.componentType, indicesData, sparse.indices.byteOffset, sparse.count);
+                    const sparseLength = numComponents * sparse.count;
+                    let values;
                     if (accessor.componentType === 5126 /* FLOAT */ && !accessor.normalized) {
-                        values = GLTFLoader._GetTypedArray("".concat(context, "/sparse/values"), accessor.componentType, valuesData, sparse_1.values.byteOffset, sparseLength);
+                        values = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);
                     }
                     else {
-                        var sparseData = GLTFLoader._GetTypedArray("".concat(context, "/sparse/values"), accessor.componentType, valuesData, sparse_1.values.byteOffset, sparseLength);
+                        const sparseData = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);
                         values = new constructor(sparseLength);
-                        VertexBuffer.ForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, function (value, index) {
+                        VertexBuffer.ForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, (value, index) => {
                             values[index] = value;
                         });
                     }
-                    var valuesIndex = 0;
-                    for (var indicesIndex = 0; indicesIndex < indices.length; indicesIndex++) {
-                        var dataIndex = indices[indicesIndex] * numComponents;
-                        for (var componentIndex = 0; componentIndex < numComponents; componentIndex++) {
+                    let valuesIndex = 0;
+                    for (let indicesIndex = 0; indicesIndex < indices.length; indicesIndex++) {
+                        let dataIndex = indices[indicesIndex] * numComponents;
+                        for (let componentIndex = 0; componentIndex < numComponents; componentIndex++) {
                             typedArray[dataIndex++] = values[valuesIndex++];
                         }
                     }
@@ -1395,84 +1328,83 @@ var GLTFLoader = /** @class */ (function () {
             });
         }
         return accessor._data;
-    };
+    }
     /**
      * @param context
      * @param accessor
      * @hidden
      */
-    GLTFLoader.prototype._loadFloatAccessorAsync = function (context, accessor) {
+    _loadFloatAccessorAsync(context, accessor) {
         return this._loadAccessorAsync(context, accessor, Float32Array);
-    };
-    GLTFLoader.prototype._loadIndicesAccessorAsync = function (context, accessor) {
+    }
+    _loadIndicesAccessorAsync(context, accessor) {
         if (accessor.type !== "SCALAR" /* SCALAR */) {
-            throw new Error("".concat(context, "/type: Invalid value ").concat(accessor.type));
+            throw new Error(`${context}/type: Invalid value ${accessor.type}`);
         }
         if (accessor.componentType !== 5121 /* UNSIGNED_BYTE */ &&
             accessor.componentType !== 5123 /* UNSIGNED_SHORT */ &&
             accessor.componentType !== 5125 /* UNSIGNED_INT */) {
-            throw new Error("".concat(context, "/componentType: Invalid value ").concat(accessor.componentType));
+            throw new Error(`${context}/componentType: Invalid value ${accessor.componentType}`);
         }
         if (accessor._data) {
             return accessor._data;
         }
         if (accessor.sparse) {
-            var constructor = GLTFLoader._GetTypedArrayConstructor("".concat(context, "/componentType"), accessor.componentType);
+            const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, accessor.componentType);
             accessor._data = this._loadAccessorAsync(context, accessor, constructor);
         }
         else {
-            var bufferView = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
-            accessor._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView).then(function (data) {
+            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);
+            accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {
                 return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, accessor.count);
             });
         }
         return accessor._data;
-    };
-    GLTFLoader.prototype._loadVertexBufferViewAsync = function (bufferView) {
+    }
+    _loadVertexBufferViewAsync(bufferView) {
         if (bufferView._babylonBuffer) {
             return bufferView._babylonBuffer;
         }
-        var engine = this._babylonScene.getEngine();
-        bufferView._babylonBuffer = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView).then(function (data) {
+        const engine = this._babylonScene.getEngine();
+        bufferView._babylonBuffer = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {
             return new Buffer(engine, data, false);
         });
         return bufferView._babylonBuffer;
-    };
-    GLTFLoader.prototype._loadVertexAccessorAsync = function (context, accessor, kind) {
-        var _a;
-        if ((_a = accessor._babylonVertexBuffer) === null || _a === void 0 ? void 0 : _a[kind]) {
+    }
+    _loadVertexAccessorAsync(context, accessor, kind) {
+        if (accessor._babylonVertexBuffer?.[kind]) {
             return accessor._babylonVertexBuffer[kind];
         }
         if (!accessor._babylonVertexBuffer) {
             accessor._babylonVertexBuffer = {};
         }
-        var engine = this._babylonScene.getEngine();
+        const engine = this._babylonScene.getEngine();
         if (accessor.sparse) {
-            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then(function (data) {
+            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then((data) => {
                 return new VertexBuffer(engine, data, kind, false);
             });
         }
         // Load joint indices as a float array since the shaders expect float data but glTF uses unsigned byte/short.
         // This prevents certain platforms (e.g. D3D) from having to convert the data to float on the fly.
         else if (kind === VertexBuffer.MatricesIndicesKind || kind === VertexBuffer.MatricesIndicesExtraKind) {
-            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then(function (data) {
+            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then((data) => {
                 return new VertexBuffer(engine, data, kind, false);
             });
         }
         else {
-            var bufferView_2 = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
-            accessor._babylonVertexBuffer[kind] = this._loadVertexBufferViewAsync(bufferView_2).then(function (babylonBuffer) {
-                var size = GLTFLoader._GetNumComponents(context, accessor.type);
-                return new VertexBuffer(engine, babylonBuffer, kind, false, false, bufferView_2.byteStride, false, accessor.byteOffset, size, accessor.componentType, accessor.normalized, true, 1, true);
+            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);
+            accessor._babylonVertexBuffer[kind] = this._loadVertexBufferViewAsync(bufferView).then((babylonBuffer) => {
+                const size = GLTFLoader._GetNumComponents(context, accessor.type);
+                return new VertexBuffer(engine, babylonBuffer, kind, false, false, bufferView.byteStride, false, accessor.byteOffset, size, accessor.componentType, accessor.normalized, true, 1, true);
             });
         }
         return accessor._babylonVertexBuffer[kind];
-    };
-    GLTFLoader.prototype._loadMaterialMetallicRoughnessPropertiesAsync = function (context, properties, babylonMaterial) {
+    }
+    _loadMaterialMetallicRoughnessPropertiesAsync(context, properties, babylonMaterial) {
         if (!(babylonMaterial instanceof PBRMaterial)) {
-            throw new Error("".concat(context, ": Material type not supported"));
+            throw new Error(`${context}: Material type not supported`);
         }
-        var promises = new Array();
+        const promises = new Array();
         if (properties) {
             if (properties.baseColorFactor) {
                 babylonMaterial.albedoColor = Color3.FromArray(properties.baseColorFactor);
@@ -1484,15 +1416,15 @@ var GLTFLoader = /** @class */ (function () {
             babylonMaterial.metallic = properties.metallicFactor == undefined ? 1 : properties.metallicFactor;
             babylonMaterial.roughness = properties.roughnessFactor == undefined ? 1 : properties.roughnessFactor;
             if (properties.baseColorTexture) {
-                promises.push(this.loadTextureInfoAsync("".concat(context, "/baseColorTexture"), properties.baseColorTexture, function (texture) {
-                    texture.name = "".concat(babylonMaterial.name, " (Base Color)");
+                promises.push(this.loadTextureInfoAsync(`${context}/baseColorTexture`, properties.baseColorTexture, (texture) => {
+                    texture.name = `${babylonMaterial.name} (Base Color)`;
                     babylonMaterial.albedoTexture = texture;
                 }));
             }
             if (properties.metallicRoughnessTexture) {
                 properties.metallicRoughnessTexture.nonColorData = true;
-                promises.push(this.loadTextureInfoAsync("".concat(context, "/metallicRoughnessTexture"), properties.metallicRoughnessTexture, function (texture) {
-                    texture.name = "".concat(babylonMaterial.name, " (Metallic Roughness)");
+                promises.push(this.loadTextureInfoAsync(`${context}/metallicRoughnessTexture`, properties.metallicRoughnessTexture, (texture) => {
+                    texture.name = `${babylonMaterial.name} (Metallic Roughness)`;
                     babylonMaterial.metallicTexture = texture;
                 }));
                 babylonMaterial.useMetallnessFromMetallicTextureBlue = true;
@@ -1500,8 +1432,8 @@ var GLTFLoader = /** @class */ (function () {
                 babylonMaterial.useRoughnessFromMetallicTextureAlpha = false;
             }
         }
-        return Promise.all(promises).then(function () { });
-    };
+        return Promise.all(promises).then(() => { });
+    }
     /**
      * @param context
      * @param material
@@ -1510,17 +1442,16 @@ var GLTFLoader = /** @class */ (function () {
      * @param assign
      * @hidden
      */
-    GLTFLoader.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);
+    _loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign = () => { }) {
+        const extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);
         if (extensionPromise) {
             return extensionPromise;
         }
         material._data = material._data || {};
-        var babylonData = material._data[babylonDrawMode];
+        let babylonData = material._data[babylonDrawMode];
         if (!babylonData) {
-            this.logOpen("".concat(context, " ").concat(material.name || ""));
-            var babylonMaterial = this.createMaterial(context, material, babylonDrawMode);
+            this.logOpen(`${context} ${material.name || ""}`);
+            const babylonMaterial = this.createMaterial(context, material, babylonDrawMode);
             babylonData = {
                 babylonMaterial: babylonMaterial,
                 babylonMeshes: [],
@@ -1533,21 +1464,21 @@ var GLTFLoader = /** @class */ (function () {
         }
         if (babylonMesh) {
             babylonData.babylonMeshes.push(babylonMesh);
-            babylonMesh.onDisposeObservable.addOnce(function () {
-                var index = babylonData.babylonMeshes.indexOf(babylonMesh);
+            babylonMesh.onDisposeObservable.addOnce(() => {
+                const index = babylonData.babylonMeshes.indexOf(babylonMesh);
                 if (index !== -1) {
                     babylonData.babylonMeshes.splice(index, 1);
                 }
             });
         }
         assign(babylonData.babylonMaterial);
-        return babylonData.promise.then(function () {
+        return babylonData.promise.then(() => {
             return babylonData.babylonMaterial;
         });
-    };
-    GLTFLoader.prototype._createDefaultMaterial = function (name, babylonDrawMode) {
+    }
+    _createDefaultMaterial(name, babylonDrawMode) {
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonMaterial = new PBRMaterial(name, this._babylonScene);
+        const babylonMaterial = new PBRMaterial(name, this._babylonScene);
         babylonMaterial._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         // Moved to mesh so user can change materials on gltf meshes: babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
@@ -1559,7 +1490,7 @@ var GLTFLoader = /** @class */ (function () {
         babylonMaterial.metallic = 1;
         babylonMaterial.roughness = 1;
         return babylonMaterial;
-    };
+    }
     /**
      * Creates a Babylon material from a glTF material.
      * @param context The context when loading the asset
@@ -1567,15 +1498,15 @@ var GLTFLoader = /** @class */ (function () {
      * @param babylonDrawMode The draw mode for the Babylon material
      * @returns The Babylon material
      */
-    GLTFLoader.prototype.createMaterial = function (context, material, babylonDrawMode) {
-        var extensionPromise = this._extensionsCreateMaterial(context, material, babylonDrawMode);
+    createMaterial(context, material, babylonDrawMode) {
+        const extensionPromise = this._extensionsCreateMaterial(context, material, babylonDrawMode);
         if (extensionPromise) {
             return extensionPromise;
         }
-        var name = material.name || "material".concat(material.index);
-        var babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);
+        const name = material.name || `material${material.index}`;
+        const babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);
         return babylonMaterial;
-    };
+    }
     /**
      * Loads properties from a glTF material into a Babylon material.
      * @param context The context when loading the asset
@@ -1583,19 +1514,19 @@ var GLTFLoader = /** @class */ (function () {
      * @param babylonMaterial The Babylon material
      * @returns A promise that resolves when the load is complete
      */
-    GLTFLoader.prototype.loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
-        var extensionPromise = this._extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial);
+    loadMaterialPropertiesAsync(context, material, babylonMaterial) {
+        const extensionPromise = this._extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial);
         if (extensionPromise) {
             return extensionPromise;
         }
-        var promises = new Array();
+        const promises = new Array();
         promises.push(this.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
         if (material.pbrMetallicRoughness) {
-            promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync("".concat(context, "/pbrMetallicRoughness"), material.pbrMetallicRoughness, babylonMaterial));
+            promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(`${context}/pbrMetallicRoughness`, material.pbrMetallicRoughness, babylonMaterial));
         }
         this.loadMaterialAlphaProperties(context, material, babylonMaterial);
-        return Promise.all(promises).then(function () { });
-    };
+        return Promise.all(promises).then(() => { });
+    }
     /**
      * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.
      * @param context The context when loading the asset
@@ -1603,11 +1534,11 @@ var GLTFLoader = /** @class */ (function () {
      * @param babylonMaterial The Babylon material
      * @returns A promise that resolves when the load is complete
      */
-    GLTFLoader.prototype.loadMaterialBasePropertiesAsync = function (context, material, babylonMaterial) {
+    loadMaterialBasePropertiesAsync(context, material, babylonMaterial) {
         if (!(babylonMaterial instanceof PBRMaterial)) {
-            throw new Error("".concat(context, ": Material type not supported"));
+            throw new Error(`${context}: Material type not supported`);
         }
-        var promises = new Array();
+        const promises = new Array();
         babylonMaterial.emissiveColor = material.emissiveFactor ? Color3.FromArray(material.emissiveFactor) : new Color3(0, 0, 0);
         if (material.doubleSided) {
             babylonMaterial.backFaceCulling = false;
@@ -1615,8 +1546,8 @@ var GLTFLoader = /** @class */ (function () {
         }
         if (material.normalTexture) {
             material.normalTexture.nonColorData = true;
-            promises.push(this.loadTextureInfoAsync("".concat(context, "/normalTexture"), material.normalTexture, function (texture) {
-                texture.name = "".concat(babylonMaterial.name, " (Normal)");
+            promises.push(this.loadTextureInfoAsync(`${context}/normalTexture`, material.normalTexture, (texture) => {
+                texture.name = `${babylonMaterial.name} (Normal)`;
                 babylonMaterial.bumpTexture = texture;
             }));
             babylonMaterial.invertNormalMapX = !this._babylonScene.useRightHandedSystem;
@@ -1628,8 +1559,8 @@ var GLTFLoader = /** @class */ (function () {
         }
         if (material.occlusionTexture) {
             material.occlusionTexture.nonColorData = true;
-            promises.push(this.loadTextureInfoAsync("".concat(context, "/occlusionTexture"), material.occlusionTexture, function (texture) {
-                texture.name = "".concat(babylonMaterial.name, " (Occlusion)");
+            promises.push(this.loadTextureInfoAsync(`${context}/occlusionTexture`, material.occlusionTexture, (texture) => {
+                texture.name = `${babylonMaterial.name} (Occlusion)`;
                 babylonMaterial.ambientTexture = texture;
             }));
             babylonMaterial.useAmbientInGrayScale = true;
@@ -1638,13 +1569,13 @@ var GLTFLoader = /** @class */ (function () {
             }
         }
         if (material.emissiveTexture) {
-            promises.push(this.loadTextureInfoAsync("".concat(context, "/emissiveTexture"), material.emissiveTexture, function (texture) {
-                texture.name = "".concat(babylonMaterial.name, " (Emissive)");
+            promises.push(this.loadTextureInfoAsync(`${context}/emissiveTexture`, material.emissiveTexture, (texture) => {
+                texture.name = `${babylonMaterial.name} (Emissive)`;
                 babylonMaterial.emissiveTexture = texture;
             }));
         }
-        return Promise.all(promises).then(function () { });
-    };
+        return Promise.all(promises).then(() => { });
+    }
     /**
      * Loads the alpha properties from a glTF material into a Babylon material.
      * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.
@@ -1652,11 +1583,11 @@ var GLTFLoader = /** @class */ (function () {
      * @param material The glTF material property
      * @param babylonMaterial The Babylon material
      */
-    GLTFLoader.prototype.loadMaterialAlphaProperties = function (context, material, babylonMaterial) {
+    loadMaterialAlphaProperties(context, material, babylonMaterial) {
         if (!(babylonMaterial instanceof PBRMaterial)) {
-            throw new Error("".concat(context, ": Material type not supported"));
+            throw new Error(`${context}: Material type not supported`);
         }
-        var alphaMode = material.alphaMode || "OPAQUE" /* OPAQUE */;
+        const alphaMode = material.alphaMode || "OPAQUE" /* OPAQUE */;
         switch (alphaMode) {
             case "OPAQUE" /* OPAQUE */: {
                 babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;
@@ -1679,10 +1610,10 @@ var GLTFLoader = /** @class */ (function () {
                 break;
             }
             default: {
-                throw new Error("".concat(context, "/alphaMode: Invalid value (").concat(material.alphaMode, ")"));
+                throw new Error(`${context}/alphaMode: Invalid value (${material.alphaMode})`);
             }
         }
-    };
+    }
     /**
      * Loads a glTF texture info.
      * @param context The context when loading the asset
@@ -1690,47 +1621,44 @@ var GLTFLoader = /** @class */ (function () {
      * @param assign A function called synchronously after parsing the glTF properties
      * @returns A promise that resolves with the loaded Babylon texture when the load is complete
      */
-    GLTFLoader.prototype.loadTextureInfoAsync = function (context, textureInfo, assign) {
-        var _this = this;
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);
+    loadTextureInfoAsync(context, textureInfo, assign = () => { }) {
+        const extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);
         if (extensionPromise) {
             return extensionPromise;
         }
-        this.logOpen("".concat(context));
+        this.logOpen(`${context}`);
         if (textureInfo.texCoord >= 6) {
-            throw new Error("".concat(context, "/texCoord: Invalid value (").concat(textureInfo.texCoord, ")"));
+            throw new Error(`${context}/texCoord: Invalid value (${textureInfo.texCoord})`);
         }
-        var texture = ArrayItem.Get("".concat(context, "/index"), this._gltf.textures, textureInfo.index);
+        const texture = ArrayItem.Get(`${context}/index`, this._gltf.textures, textureInfo.index);
         texture._textureInfo = textureInfo;
-        var promise = this._loadTextureAsync("/textures/".concat(textureInfo.index), texture, function (babylonTexture) {
+        const promise = this._loadTextureAsync(`/textures/${textureInfo.index}`, texture, (babylonTexture) => {
             babylonTexture.coordinatesIndex = textureInfo.texCoord || 0;
             GLTFLoader.AddPointerMetadata(babylonTexture, context);
-            _this._parent.onTextureLoadedObservable.notifyObservers(babylonTexture);
+            this._parent.onTextureLoadedObservable.notifyObservers(babylonTexture);
             assign(babylonTexture);
         });
         this.logClose();
         return promise;
-    };
+    }
     /**
      * @param context
      * @param texture
      * @param assign
      * @hidden
      */
-    GLTFLoader.prototype._loadTextureAsync = function (context, texture, assign) {
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);
+    _loadTextureAsync(context, texture, assign = () => { }) {
+        const extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);
         if (extensionPromise) {
             return extensionPromise;
         }
-        this.logOpen("".concat(context, " ").concat(texture.name || ""));
-        var sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get("".concat(context, "/sampler"), this._gltf.samplers, texture.sampler);
-        var image = ArrayItem.Get("".concat(context, "/source"), this._gltf.images, texture.source);
-        var promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);
+        this.logOpen(`${context} ${texture.name || ""}`);
+        const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._gltf.samplers, texture.sampler);
+        const image = ArrayItem.Get(`${context}/source`, this._gltf.images, texture.source);
+        const promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);
         this.logClose();
         return promise;
-    };
+    }
     /**
      * @param context
      * @param sampler
@@ -1740,78 +1668,76 @@ var GLTFLoader = /** @class */ (function () {
      * @param useSRGBBuffer
      * @hidden
      */
-    GLTFLoader.prototype._createTextureAsync = function (context, sampler, image, assign, textureLoaderOptions, useSRGBBuffer) {
-        var _this = this;
-        if (assign === void 0) { assign = function () { }; }
-        var samplerData = this._loadSampler("/samplers/".concat(sampler.index), sampler);
-        var promises = new Array();
-        var deferred = new Deferred();
+    _createTextureAsync(context, sampler, image, assign = () => { }, textureLoaderOptions, useSRGBBuffer) {
+        const samplerData = this._loadSampler(`/samplers/${sampler.index}`, sampler);
+        const promises = new Array();
+        const deferred = new Deferred();
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var textureCreationOptions = {
+        const textureCreationOptions = {
             noMipmap: samplerData.noMipMaps,
             invertY: false,
             samplingMode: samplerData.samplingMode,
-            onLoad: function () {
-                if (!_this._disposed) {
+            onLoad: () => {
+                if (!this._disposed) {
                     deferred.resolve();
                 }
             },
-            onError: function (message, exception) {
-                if (!_this._disposed) {
-                    deferred.reject(new Error("".concat(context, ": ").concat(exception && exception.message ? exception.message : message || "Failed to load texture")));
+            onError: (message, exception) => {
+                if (!this._disposed) {
+                    deferred.reject(new Error(`${context}: ${exception && exception.message ? exception.message : message || "Failed to load texture"}`));
                 }
             },
             mimeType: image.mimeType,
             loaderOptions: textureLoaderOptions,
             useSRGBBuffer: !!useSRGBBuffer && this._parent.useSRGBBuffers,
         };
-        var babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);
+        const babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);
         babylonTexture._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         promises.push(deferred.promise);
-        promises.push(this.loadImageAsync("/images/".concat(image.index), image).then(function (data) {
-            var name = image.uri || "".concat(_this._fileName, "#image").concat(image.index);
-            var dataUrl = "data:".concat(_this._uniqueRootUrl).concat(name);
+        promises.push(this.loadImageAsync(`/images/${image.index}`, image).then((data) => {
+            const name = image.uri || `${this._fileName}#image${image.index}`;
+            const dataUrl = `data:${this._uniqueRootUrl}${name}`;
             babylonTexture.updateURL(dataUrl, data);
         }));
         babylonTexture.wrapU = samplerData.wrapU;
         babylonTexture.wrapV = samplerData.wrapV;
         assign(babylonTexture);
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             return babylonTexture;
         });
-    };
-    GLTFLoader.prototype._loadSampler = function (context, sampler) {
+    }
+    _loadSampler(context, sampler) {
         if (!sampler._data) {
             sampler._data = {
                 noMipMaps: sampler.minFilter === 9728 /* NEAREST */ || sampler.minFilter === 9729 /* LINEAR */,
                 samplingMode: GLTFLoader._GetTextureSamplingMode(context, sampler),
-                wrapU: GLTFLoader._GetTextureWrapMode("".concat(context, "/wrapS"), sampler.wrapS),
-                wrapV: GLTFLoader._GetTextureWrapMode("".concat(context, "/wrapT"), sampler.wrapT),
+                wrapU: GLTFLoader._GetTextureWrapMode(`${context}/wrapS`, sampler.wrapS),
+                wrapV: GLTFLoader._GetTextureWrapMode(`${context}/wrapT`, sampler.wrapT),
             };
         }
         return sampler._data;
-    };
+    }
     /**
      * Loads a glTF image.
      * @param context The context when loading the asset
      * @param image The glTF image property
      * @returns A promise that resolves with the loaded data when the load is complete
      */
-    GLTFLoader.prototype.loadImageAsync = function (context, image) {
+    loadImageAsync(context, image) {
         if (!image._data) {
-            this.logOpen("".concat(context, " ").concat(image.name || ""));
+            this.logOpen(`${context} ${image.name || ""}`);
             if (image.uri) {
-                image._data = this.loadUriAsync("".concat(context, "/uri"), image, image.uri);
+                image._data = this.loadUriAsync(`${context}/uri`, image, image.uri);
             }
             else {
-                var bufferView = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, image.bufferView);
-                image._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView);
+                const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, image.bufferView);
+                image._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);
             }
             this.logClose();
         }
         return image._data;
-    };
+    }
     /**
      * Loads a glTF uri.
      * @param context The context when loading the asset
@@ -1819,47 +1745,46 @@ var GLTFLoader = /** @class */ (function () {
      * @param uri The base64 or relative uri
      * @returns A promise that resolves with the loaded data when the load is complete
      */
-    GLTFLoader.prototype.loadUriAsync = function (context, property, uri) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadUriAsync(context, property, uri);
+    loadUriAsync(context, property, uri) {
+        const extensionPromise = this._extensionsLoadUriAsync(context, property, uri);
         if (extensionPromise) {
             return extensionPromise;
         }
         if (!GLTFLoader._ValidateUri(uri)) {
-            throw new Error("".concat(context, ": '").concat(uri, "' is invalid"));
+            throw new Error(`${context}: '${uri}' is invalid`);
         }
         if (IsBase64DataUrl(uri)) {
-            var data = new Uint8Array(DecodeBase64UrlToBinary(uri));
-            this.log("".concat(context, ": Decoded ").concat(uri.substr(0, 64), "... (").concat(data.length, " bytes)"));
+            const data = new Uint8Array(DecodeBase64UrlToBinary(uri));
+            this.log(`${context}: Decoded ${uri.substr(0, 64)}... (${data.length} bytes)`);
             return Promise.resolve(data);
         }
-        this.log("".concat(context, ": Loading ").concat(uri));
-        return this._parent.preprocessUrlAsync(this._rootUrl + uri).then(function (url) {
-            return new Promise(function (resolve, reject) {
-                _this._parent._loadFile(_this._babylonScene, url, function (data) {
-                    if (!_this._disposed) {
-                        _this.log("".concat(context, ": Loaded ").concat(uri, " (").concat(data.byteLength, " bytes)"));
+        this.log(`${context}: Loading ${uri}`);
+        return this._parent.preprocessUrlAsync(this._rootUrl + uri).then((url) => {
+            return new Promise((resolve, reject) => {
+                this._parent._loadFile(this._babylonScene, url, (data) => {
+                    if (!this._disposed) {
+                        this.log(`${context}: Loaded ${uri} (${data.byteLength} bytes)`);
                         resolve(new Uint8Array(data));
                     }
-                }, true, function (request) {
-                    reject(new LoadFileError("".concat(context, ": Failed to load '").concat(uri, "'").concat(request ? ": " + request.status + " " + request.statusText : ""), request));
+                }, true, (request) => {
+                    reject(new LoadFileError(`${context}: Failed to load '${uri}'${request ? ": " + request.status + " " + request.statusText : ""}`, request));
                 });
             });
         });
-    };
+    }
     /**
      * Adds a JSON pointer to the metadata of the Babylon object at `<object>.metadata.gltf.pointers`.
      * @param babylonObject the Babylon object with metadata
      * @param babylonObject.metadata
      * @param pointer the JSON pointer
      */
-    GLTFLoader.AddPointerMetadata = function (babylonObject, pointer) {
-        var metadata = (babylonObject.metadata = babylonObject.metadata || {});
-        var gltf = (metadata.gltf = metadata.gltf || {});
-        var pointers = (gltf.pointers = gltf.pointers || []);
+    static AddPointerMetadata(babylonObject, pointer) {
+        const metadata = (babylonObject.metadata = babylonObject.metadata || {});
+        const gltf = (metadata.gltf = metadata.gltf || {});
+        const pointers = (gltf.pointers = gltf.pointers || []);
         pointers.push(pointer);
-    };
-    GLTFLoader._GetTextureWrapMode = function (context, mode) {
+    }
+    static _GetTextureWrapMode(context, mode) {
         // Set defaults if undefined
         mode = mode == undefined ? 10497 /* REPEAT */ : mode;
         switch (mode) {
@@ -1870,14 +1795,14 @@ var GLTFLoader = /** @class */ (function () {
             case 10497 /* REPEAT */:
                 return Texture.WRAP_ADDRESSMODE;
             default:
-                Logger.Warn("".concat(context, ": Invalid value (").concat(mode, ")"));
+                Logger.Warn(`${context}: Invalid value (${mode})`);
                 return Texture.WRAP_ADDRESSMODE;
         }
-    };
-    GLTFLoader._GetTextureSamplingMode = function (context, sampler) {
+    }
+    static _GetTextureSamplingMode(context, sampler) {
         // Set defaults if undefined
-        var magFilter = sampler.magFilter == undefined ? 9729 /* LINEAR */ : sampler.magFilter;
-        var minFilter = sampler.minFilter == undefined ? 9987 /* LINEAR_MIPMAP_LINEAR */ : sampler.minFilter;
+        const magFilter = sampler.magFilter == undefined ? 9729 /* LINEAR */ : sampler.magFilter;
+        const minFilter = sampler.minFilter == undefined ? 9987 /* LINEAR_MIPMAP_LINEAR */ : sampler.minFilter;
         if (magFilter === 9729 /* LINEAR */) {
             switch (minFilter) {
                 case 9728 /* NEAREST */:
@@ -1893,13 +1818,13 @@ var GLTFLoader = /** @class */ (function () {
                 case 9987 /* LINEAR_MIPMAP_LINEAR */:
                     return Texture.LINEAR_LINEAR_MIPLINEAR;
                 default:
-                    Logger.Warn("".concat(context, "/minFilter: Invalid value (").concat(minFilter, ")"));
+                    Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);
                     return Texture.LINEAR_LINEAR_MIPLINEAR;
             }
         }
         else {
             if (magFilter !== 9728 /* NEAREST */) {
-                Logger.Warn("".concat(context, "/magFilter: Invalid value (").concat(magFilter, ")"));
+                Logger.Warn(`${context}/magFilter: Invalid value (${magFilter})`);
             }
             switch (minFilter) {
                 case 9728 /* NEAREST */:
@@ -1915,12 +1840,12 @@ var GLTFLoader = /** @class */ (function () {
                 case 9987 /* LINEAR_MIPMAP_LINEAR */:
                     return Texture.NEAREST_LINEAR_MIPLINEAR;
                 default:
-                    Logger.Warn("".concat(context, "/minFilter: Invalid value (").concat(minFilter, ")"));
+                    Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);
                     return Texture.NEAREST_NEAREST_MIPNEAREST;
             }
         }
-    };
-    GLTFLoader._GetTypedArrayConstructor = function (context, componentType) {
+    }
+    static _GetTypedArrayConstructor(context, componentType) {
         switch (componentType) {
             case 5120 /* BYTE */:
                 return Int8Array;
@@ -1935,22 +1860,22 @@ var GLTFLoader = /** @class */ (function () {
             case 5126 /* FLOAT */:
                 return Float32Array;
             default:
-                throw new Error("".concat(context, ": Invalid component type ").concat(componentType));
+                throw new Error(`${context}: Invalid component type ${componentType}`);
         }
-    };
-    GLTFLoader._GetTypedArray = function (context, componentType, bufferView, byteOffset, length) {
-        var buffer = bufferView.buffer;
+    }
+    static _GetTypedArray(context, componentType, bufferView, byteOffset, length) {
+        const buffer = bufferView.buffer;
         byteOffset = bufferView.byteOffset + (byteOffset || 0);
-        var constructor = GLTFLoader._GetTypedArrayConstructor("".concat(context, "/componentType"), componentType);
-        var componentTypeLength = VertexBuffer.GetTypeByteLength(componentType);
+        const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, componentType);
+        const componentTypeLength = VertexBuffer.GetTypeByteLength(componentType);
         if (byteOffset % componentTypeLength !== 0) {
             // HACK: Copy the buffer if byte offset is not a multiple of component type byte length.
-            Logger.Warn("".concat(context, ": Copying buffer as byte offset (").concat(byteOffset, ") is not a multiple of component type byte length (").concat(componentTypeLength, ")"));
+            Logger.Warn(`${context}: Copying buffer as byte offset (${byteOffset}) is not a multiple of component type byte length (${componentTypeLength})`);
             return new constructor(buffer.slice(byteOffset, byteOffset + length * componentTypeLength), 0);
         }
         return new constructor(buffer, byteOffset, length);
-    };
-    GLTFLoader._GetNumComponents = function (context, type) {
+    }
+    static _GetNumComponents(context, type) {
         switch (type) {
             case "SCALAR":
                 return 1;
@@ -1967,17 +1892,17 @@ var GLTFLoader = /** @class */ (function () {
             case "MAT4":
                 return 16;
         }
-        throw new Error("".concat(context, ": Invalid type (").concat(type, ")"));
-    };
-    GLTFLoader._ValidateUri = function (uri) {
+        throw new Error(`${context}: Invalid type (${type})`);
+    }
+    static _ValidateUri(uri) {
         return Tools.IsBase64(uri) || uri.indexOf("..") === -1;
-    };
+    }
     /**
      * @param context
      * @param mode
      * @hidden
      */
-    GLTFLoader._GetDrawMode = function (context, mode) {
+    static _GetDrawMode(context, mode) {
         if (mode == undefined) {
             mode = 4 /* TRIANGLES */;
         }
@@ -1997,23 +1922,20 @@ var GLTFLoader = /** @class */ (function () {
             case 6 /* TRIANGLE_FAN */:
                 return Material.TriangleFanDrawMode;
         }
-        throw new Error("".concat(context, ": Invalid mesh primitive mode (").concat(mode, ")"));
-    };
-    GLTFLoader.prototype._compileMaterialsAsync = function () {
-        var _this = this;
+        throw new Error(`${context}: Invalid mesh primitive mode (${mode})`);
+    }
+    _compileMaterialsAsync() {
         this._parent._startPerformanceCounter("Compile materials");
-        var promises = new Array();
+        const promises = new Array();
         if (this._gltf.materials) {
-            for (var _i = 0, _a = this._gltf.materials; _i < _a.length; _i++) {
-                var material = _a[_i];
+            for (const material of this._gltf.materials) {
                 if (material._data) {
-                    for (var babylonDrawMode in material._data) {
-                        var babylonData = material._data[babylonDrawMode];
-                        for (var _b = 0, _c = babylonData.babylonMeshes; _b < _c.length; _b++) {
-                            var babylonMesh = _c[_b];
+                    for (const babylonDrawMode in material._data) {
+                        const babylonData = material._data[babylonDrawMode];
+                        for (const babylonMesh of babylonData.babylonMeshes) {
                             // Ensure nonUniformScaling is set if necessary.
                             babylonMesh.computeWorldMatrix(true);
-                            var babylonMaterial = babylonData.babylonMaterial;
+                            const babylonMaterial = babylonData.babylonMaterial;
                             promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));
                             promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { useInstances: true }));
                             if (this._parent.useClipPlane) {
@@ -2025,46 +1947,42 @@ var GLTFLoader = /** @class */ (function () {
                 }
             }
         }
-        return Promise.all(promises).then(function () {
-            _this._parent._endPerformanceCounter("Compile materials");
+        return Promise.all(promises).then(() => {
+            this._parent._endPerformanceCounter("Compile materials");
         });
-    };
-    GLTFLoader.prototype._compileShadowGeneratorsAsync = function () {
-        var _this = this;
+    }
+    _compileShadowGeneratorsAsync() {
         this._parent._startPerformanceCounter("Compile shadow generators");
-        var promises = new Array();
-        var lights = this._babylonScene.lights;
-        for (var _i = 0, lights_1 = lights; _i < lights_1.length; _i++) {
-            var light = lights_1[_i];
-            var generator = light.getShadowGenerator();
+        const promises = new Array();
+        const lights = this._babylonScene.lights;
+        for (const light of lights) {
+            const generator = light.getShadowGenerator();
             if (generator) {
                 promises.push(generator.forceCompilationAsync());
             }
         }
-        return Promise.all(promises).then(function () {
-            _this._parent._endPerformanceCounter("Compile shadow generators");
+        return Promise.all(promises).then(() => {
+            this._parent._endPerformanceCounter("Compile shadow generators");
         });
-    };
-    GLTFLoader.prototype._forEachExtensions = function (action) {
-        for (var _i = 0, _a = this._extensions; _i < _a.length; _i++) {
-            var extension = _a[_i];
+    }
+    _forEachExtensions(action) {
+        for (const extension of this._extensions) {
             if (extension.enabled) {
                 action(extension);
             }
         }
-    };
-    GLTFLoader.prototype._applyExtensions = function (property, functionName, actionAsync) {
-        for (var _i = 0, _a = this._extensions; _i < _a.length; _i++) {
-            var extension = _a[_i];
+    }
+    _applyExtensions(property, functionName, actionAsync) {
+        for (const extension of this._extensions) {
             if (extension.enabled) {
-                var id = "".concat(extension.name, ".").concat(functionName);
-                var loaderProperty = property;
+                const id = `${extension.name}.${functionName}`;
+                const loaderProperty = property;
                 loaderProperty._activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions || {};
-                var activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions;
+                const activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions;
                 if (!activeLoaderExtensionFunctions[id]) {
                     activeLoaderExtensionFunctions[id] = true;
                     try {
-                        var result = actionAsync(extension);
+                        const result = actionAsync(extension);
                         if (result) {
                             return result;
                         }
@@ -2076,58 +1994,58 @@ var GLTFLoader = /** @class */ (function () {
             }
         }
         return null;
-    };
-    GLTFLoader.prototype._extensionsOnLoading = function () {
-        this._forEachExtensions(function (extension) { return extension.onLoading && extension.onLoading(); });
-    };
-    GLTFLoader.prototype._extensionsOnReady = function () {
-        this._forEachExtensions(function (extension) { return extension.onReady && extension.onReady(); });
-    };
-    GLTFLoader.prototype._extensionsLoadSceneAsync = function (context, scene) {
-        return this._applyExtensions(scene, "loadScene", function (extension) { return extension.loadSceneAsync && extension.loadSceneAsync(context, scene); });
-    };
-    GLTFLoader.prototype._extensionsLoadNodeAsync = function (context, node, assign) {
-        return this._applyExtensions(node, "loadNode", function (extension) { return extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadCameraAsync = function (context, camera, assign) {
-        return this._applyExtensions(camera, "loadCamera", function (extension) { return extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadVertexDataAsync = function (context, primitive, babylonMesh) {
-        return this._applyExtensions(primitive, "loadVertexData", function (extension) { return extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh); });
-    };
-    GLTFLoader.prototype._extensionsLoadMeshPrimitiveAsync = function (context, name, node, mesh, primitive, assign) {
-        return this._applyExtensions(primitive, "loadMeshPrimitive", function (extension) { return extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
-        return this._applyExtensions(material, "loadMaterial", function (extension) { return extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign); });
-    };
-    GLTFLoader.prototype._extensionsCreateMaterial = function (context, material, babylonDrawMode) {
-        return this._applyExtensions(material, "createMaterial", function (extension) { return extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode); });
-    };
-    GLTFLoader.prototype._extensionsLoadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
-        return this._applyExtensions(material, "loadMaterialProperties", function (extension) { return extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial); });
-    };
-    GLTFLoader.prototype._extensionsLoadTextureInfoAsync = function (context, textureInfo, assign) {
-        return this._applyExtensions(textureInfo, "loadTextureInfo", function (extension) { return extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadTextureAsync = function (context, texture, assign) {
-        return this._applyExtensions(texture, "loadTexture", function (extension) { return extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadAnimationAsync = function (context, animation) {
-        return this._applyExtensions(animation, "loadAnimation", function (extension) { return extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation); });
-    };
-    GLTFLoader.prototype._extensionsLoadSkinAsync = function (context, node, skin) {
-        return this._applyExtensions(skin, "loadSkin", function (extension) { return extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin); });
-    };
-    GLTFLoader.prototype._extensionsLoadUriAsync = function (context, property, uri) {
-        return this._applyExtensions(property, "loadUri", function (extension) { return extension._loadUriAsync && extension._loadUriAsync(context, property, uri); });
-    };
-    GLTFLoader.prototype._extensionsLoadBufferViewAsync = function (context, bufferView) {
-        return this._applyExtensions(bufferView, "loadBufferView", function (extension) { return extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView); });
-    };
-    GLTFLoader.prototype._extensionsLoadBufferAsync = function (context, buffer, byteOffset, byteLength) {
-        return this._applyExtensions(buffer, "loadBuffer", function (extension) { return extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength); });
-    };
+    }
+    _extensionsOnLoading() {
+        this._forEachExtensions((extension) => extension.onLoading && extension.onLoading());
+    }
+    _extensionsOnReady() {
+        this._forEachExtensions((extension) => extension.onReady && extension.onReady());
+    }
+    _extensionsLoadSceneAsync(context, scene) {
+        return this._applyExtensions(scene, "loadScene", (extension) => extension.loadSceneAsync && extension.loadSceneAsync(context, scene));
+    }
+    _extensionsLoadNodeAsync(context, node, assign) {
+        return this._applyExtensions(node, "loadNode", (extension) => extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign));
+    }
+    _extensionsLoadCameraAsync(context, camera, assign) {
+        return this._applyExtensions(camera, "loadCamera", (extension) => extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign));
+    }
+    _extensionsLoadVertexDataAsync(context, primitive, babylonMesh) {
+        return this._applyExtensions(primitive, "loadVertexData", (extension) => extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh));
+    }
+    _extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign) {
+        return this._applyExtensions(primitive, "loadMeshPrimitive", (extension) => extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign));
+    }
+    _extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign) {
+        return this._applyExtensions(material, "loadMaterial", (extension) => extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign));
+    }
+    _extensionsCreateMaterial(context, material, babylonDrawMode) {
+        return this._applyExtensions(material, "createMaterial", (extension) => extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode));
+    }
+    _extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial) {
+        return this._applyExtensions(material, "loadMaterialProperties", (extension) => extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial));
+    }
+    _extensionsLoadTextureInfoAsync(context, textureInfo, assign) {
+        return this._applyExtensions(textureInfo, "loadTextureInfo", (extension) => extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign));
+    }
+    _extensionsLoadTextureAsync(context, texture, assign) {
+        return this._applyExtensions(texture, "loadTexture", (extension) => extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign));
+    }
+    _extensionsLoadAnimationAsync(context, animation) {
+        return this._applyExtensions(animation, "loadAnimation", (extension) => extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation));
+    }
+    _extensionsLoadSkinAsync(context, node, skin) {
+        return this._applyExtensions(skin, "loadSkin", (extension) => extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin));
+    }
+    _extensionsLoadUriAsync(context, property, uri) {
+        return this._applyExtensions(property, "loadUri", (extension) => extension._loadUriAsync && extension._loadUriAsync(context, property, uri));
+    }
+    _extensionsLoadBufferViewAsync(context, bufferView) {
+        return this._applyExtensions(bufferView, "loadBufferView", (extension) => extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView));
+    }
+    _extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength) {
+        return this._applyExtensions(buffer, "loadBuffer", (extension) => extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength));
+    }
     /**
      * Helper method called by a loader extension to load an glTF extension.
      * @param context The context when loading the asset
@@ -2136,17 +2054,17 @@ var GLTFLoader = /** @class */ (function () {
      * @param actionAsync The action to run
      * @returns The promise returned by actionAsync or null if the extension does not exist
      */
-    GLTFLoader.LoadExtensionAsync = function (context, property, extensionName, actionAsync) {
+    static LoadExtensionAsync(context, property, extensionName, actionAsync) {
         if (!property.extensions) {
             return null;
         }
-        var extensions = property.extensions;
-        var extension = extensions[extensionName];
+        const extensions = property.extensions;
+        const extension = extensions[extensionName];
         if (!extension) {
             return null;
         }
-        return actionAsync("".concat(context, "/extensions/").concat(extensionName), extension);
-    };
+        return actionAsync(`${context}/extensions/${extensionName}`, extension);
+    }
     /**
      * Helper method called by a loader extension to load a glTF extra.
      * @param context The context when loading the asset
@@ -2155,70 +2073,68 @@ var GLTFLoader = /** @class */ (function () {
      * @param actionAsync The action to run
      * @returns The promise returned by actionAsync or null if the extra does not exist
      */
-    GLTFLoader.LoadExtraAsync = function (context, property, extensionName, actionAsync) {
+    static LoadExtraAsync(context, property, extensionName, actionAsync) {
         if (!property.extras) {
             return null;
         }
-        var extras = property.extras;
-        var extra = extras[extensionName];
+        const extras = property.extras;
+        const extra = extras[extensionName];
         if (!extra) {
             return null;
         }
-        return actionAsync("".concat(context, "/extras/").concat(extensionName), extra);
-    };
+        return actionAsync(`${context}/extras/${extensionName}`, extra);
+    }
     /**
      * Checks for presence of an extension.
      * @param name The name of the extension to check
      * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`
      */
-    GLTFLoader.prototype.isExtensionUsed = function (name) {
+    isExtensionUsed(name) {
         return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(name) !== -1;
-    };
+    }
     /**
      * Increments the indentation level and logs a message.
      * @param message The message to log
      */
-    GLTFLoader.prototype.logOpen = function (message) {
+    logOpen(message) {
         this._parent._logOpen(message);
-    };
+    }
     /**
      * Decrements the indentation level.
      */
-    GLTFLoader.prototype.logClose = function () {
+    logClose() {
         this._parent._logClose();
-    };
+    }
     /**
      * Logs a message
      * @param message The message to log
      */
-    GLTFLoader.prototype.log = function (message) {
+    log(message) {
         this._parent._log(message);
-    };
+    }
     /**
      * Starts a performance counter.
      * @param counterName The name of the performance counter
      */
-    GLTFLoader.prototype.startPerformanceCounter = function (counterName) {
+    startPerformanceCounter(counterName) {
         this._parent._startPerformanceCounter(counterName);
-    };
+    }
     /**
      * Ends a performance counter.
      * @param counterName The name of the performance counter
      */
-    GLTFLoader.prototype.endPerformanceCounter = function (counterName) {
+    endPerformanceCounter(counterName) {
         this._parent._endPerformanceCounter(counterName);
-    };
-    /** @hidden */
-    // note : KHR_animation_pointer is used to load animation in ALL case, turning everything
-    // into pointer. This is the reason why this value is located here.
-    GLTFLoader._KHRAnimationPointerName = "KHR_animation_pointer";
-    GLTFLoader._RegisteredExtensions = {};
-    /**
-     * The default glTF sampler.
-     */
-    GLTFLoader.DefaultSampler = { index: -1 };
-    return GLTFLoader;
-}());
-export { GLTFLoader };
-GLTFFileLoader._CreateGLTF2Loader = function (parent) { return new GLTFLoader(parent); };
+    }
+}
+/** @hidden */
+// note : KHR_animation_pointer is used to load animation in ALL case, turning everything
+// into pointer. This is the reason why this value is located here.
+GLTFLoader._KHRAnimationPointerName = "KHR_animation_pointer";
+GLTFLoader._RegisteredExtensions = {};
+/**
+ * The default glTF sampler.
+ */
+GLTFLoader.DefaultSampler = { index: -1 };
+GLTFFileLoader._CreateGLTF2Loader = (parent) => new GLTFLoader(parent);
 //# sourceMappingURL=glTFLoader.js.map