text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("babylonjs"));
  	else if(typeof define === 'function' && define.amd)
  		define("babylonjs-loaders", ["babylonjs"], factory);
  	else if(typeof exports === 'object')
  		exports["babylonjs-loaders"] = factory(require("babylonjs"));
  	else
  		root["LOADERS"] = factory(root["BABYLON"]);
  })((typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this), function(__WEBPACK_EXTERNAL_MODULE_babylonjs_Misc_observable__) {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-glTF1FileLoader.ts");
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "../../node_modules/tslib/tslib.es6.js":
  /*!***********************************************************!*\
    !*** D:/Repos/Babylon.js/node_modules/tslib/tslib.es6.js ***!
    \***********************************************************/
  /*! exports provided: __extends, __assign, __rest, __decorate, __param, __metadata, __awaiter, __generator, __exportStar, __values, __read, __spread, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__extends", function() { return __extends; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__assign", function() { return __assign; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__rest", function() { return __rest; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__decorate", function() { return __decorate; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__param", function() { return __param; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__metadata", function() { return __metadata; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__awaiter", function() { return __awaiter; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__generator", function() { return __generator; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__exportStar", function() { return __exportStar; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__values", function() { return __values; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__read", function() { return __read; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spread", function() { return __spread; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__await", function() { return __await; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncGenerator", function() { return __asyncGenerator; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncDelegator", function() { return __asyncDelegator; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncValues", function() { return __asyncValues; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__makeTemplateObject", function() { return __makeTemplateObject; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importStar", function() { return __importStar; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importDefault", function() { return __importDefault; });
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation. All rights reserved.
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at http://www.apache.org/licenses/LICENSE-2.0
  
  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  MERCHANTABLITY OR NON-INFRINGEMENT.
  
  See the Apache Version 2.0 License for specific language governing permissions
  and limitations under the License.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return extendStatics(d, b);
  };
  
  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return __assign.apply(this, arguments);
  }
  
  function __rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
              t[p[i]] = s[p[i]];
      return t;
  }
  
  function __decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function __param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function __metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function __awaiter(thisArg, _arguments, P, generator) {
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function __generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function __exportStar(m, exports) {
      for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function __values(o) {
      var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
      if (m) return m.call(o);
      return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
  }
  
  function __read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function __spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(__read(arguments[i]));
      return ar;
  }
  
  function __await(v) {
      return this instanceof __await ? (this.v = v, this) : new __await(v);
  }
  
  function __asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function __asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function __asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function __makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function __importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function __importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  
  /***/ }),
  
  /***/ "../../node_modules/webpack/buildin/global.js":
  /*!***********************************!*\
    !*** (webpack)/buildin/global.js ***!
    \***********************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  var g;
  
  // This works in non-strict mode
  g = (function() {
  	return this;
  })();
  
  try {
  	// This works if eval is allowed (see CSP)
  	g = g || new Function("return this")();
  } catch (e) {
  	// This works if the window reference is available
  	if (typeof window === "object") g = window;
  }
  
  // g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  
  module.exports = g;
  
  
  /***/ }),
  
  /***/ "./glTF/1.0/glTFBinaryExtension.ts":
  /*!*****************************************!*\
    !*** ./glTF/1.0/glTFBinaryExtension.ts ***!
    \*****************************************/
  /*! exports provided: GLTFBinaryExtension */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFBinaryExtension", function() { return GLTFBinaryExtension; });
  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../../node_modules/tslib/tslib.es6.js");
  /* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFLoader */ "./glTF/1.0/glTFLoader.ts");
  /* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderUtils */ "./glTF/1.0/glTFLoaderUtils.ts");
  /* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "./glTF/1.0/glTFLoaderInterfaces.ts");
  
  
  
  
  
  var BinaryExtensionBufferName = "binary_glTF";
  /** @hidden */
  var GLTFBinaryExtension = /** @class */ (function (_super) {
      tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](GLTFBinaryExtension, _super);
      function GLTFBinaryExtension() {
          return _super.call(this, "KHR_binary_glTF") || this;
      }
      GLTFBinaryExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
          var extensionsUsed = data.json.extensionsUsed;
          if (!extensionsUsed || extensionsUsed.indexOf(this.name) === -1 || !data.bin) {
              return false;
          }
          this._bin = data.bin;
          onSuccess(_glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoaderBase"].CreateRuntime(data.json, scene, rootUrl));
          return true;
      };
      GLTFBinaryExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
          if (gltfRuntime.extensionsUsed.indexOf(this.name) === -1) {
              return false;
          }
          if (id !== BinaryExtensionBufferName) {
              return false;
          }
          onSuccess(this._bin);
          return true;
      };
      GLTFBinaryExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
          var texture = gltfRuntime.textures[id];
          var source = gltfRuntime.images[texture.source];
          if (!source.extensions || !(this.name in source.extensions)) {
              return false;
          }
          var sourceExt = source.extensions[this.name];
          var bufferView = gltfRuntime.bufferViews[sourceExt.bufferView];
          var buffer = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_3__["EComponentType"].UNSIGNED_BYTE);
          onSuccess(buffer);
          return true;
      };
      GLTFBinaryExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
          var shader = gltfRuntime.shaders[id];
          if (!shader.extensions || !(this.name in shader.extensions)) {
              return false;
          }
          var binaryExtensionShader = shader.extensions[this.name];
          var bufferView = gltfRuntime.bufferViews[binaryExtensionShader.bufferView];
          var shaderBytes = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_3__["EComponentType"].UNSIGNED_BYTE);
          setTimeout(function () {
              var shaderString = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].DecodeBufferToText(shaderBytes);
              onSuccess(shaderString);
          });
          return true;
      };
      return GLTFBinaryExtension;
  }(_glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoaderExtension"]));
  
  _glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoader"].RegisterExtension(new GLTFBinaryExtension());
  
  
  /***/ }),
  
  /***/ "./glTF/1.0/glTFLoader.ts":
  /*!********************************!*\
    !*** ./glTF/1.0/glTFLoader.ts ***!
    \********************************/
  /*! exports provided: GLTFLoaderBase, GLTFLoader, GLTFLoaderExtension */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderBase", function() { return GLTFLoaderBase; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFLoader", function() { return GLTFLoader; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderExtension", function() { return GLTFLoaderExtension; });
  /* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "./glTF/1.0/glTFLoaderInterfaces.ts");
  /* harmony import */ var babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! babylonjs/Maths/math */ "babylonjs/Misc/observable");
  /* harmony import */ var babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__);
  /* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderUtils */ "./glTF/1.0/glTFLoaderUtils.ts");
  /* harmony import */ var _glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../glTFFileLoader */ "./glTF/glTFFileLoader.ts");
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  /**
  * Tokenizer. Used for shaders compatibility
  * Automatically map world, view, projection, worldViewProjection, attributes and so on
  */
  var ETokenType;
  (function (ETokenType) {
      ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
      ETokenType[ETokenType["UNKNOWN"] = 2] = "UNKNOWN";
      ETokenType[ETokenType["END_OF_INPUT"] = 3] = "END_OF_INPUT";
  })(ETokenType || (ETokenType = {}));
  var Tokenizer = /** @class */ (function () {
      function Tokenizer(toParse) {
          this._pos = 0;
          this.currentToken = ETokenType.UNKNOWN;
          this.currentIdentifier = "";
          this.currentString = "";
          this.isLetterOrDigitPattern = /^[a-zA-Z0-9]+$/;
          this._toParse = toParse;
          this._maxPos = toParse.length;
      }
      Tokenizer.prototype.getNextToken = function () {
          if (this.isEnd()) {
              return ETokenType.END_OF_INPUT;
          }
          this.currentString = this.read();
          this.currentToken = ETokenType.UNKNOWN;
          if (this.currentString === "_" || this.isLetterOrDigitPattern.test(this.currentString)) {
              this.currentToken = ETokenType.IDENTIFIER;
              this.currentIdentifier = this.currentString;
              while (!this.isEnd() && (this.isLetterOrDigitPattern.test(this.currentString = this.peek()) || this.currentString === "_")) {
                  this.currentIdentifier += this.currentString;
                  this.forward();
              }
          }
          return this.currentToken;
      };
      Tokenizer.prototype.peek = function () {
          return this._toParse[this._pos];
      };
      Tokenizer.prototype.read = function () {
          return this._toParse[this._pos++];
      };
      Tokenizer.prototype.forward = function () {
          this._pos++;
      };
      Tokenizer.prototype.isEnd = function () {
          return this._pos >= this._maxPos;
      };
      return Tokenizer;
  }());
  /**
  * Values
  */
  var glTFTransforms = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"];
  var babylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
  var glTFAnimationPaths = ["translation", "rotation", "scale"];
  var babylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
  /**
  * Parse
  */
  var parseBuffers = function (parsedBuffers, gltfRuntime) {
      for (var buf in parsedBuffers) {
          var parsedBuffer = parsedBuffers[buf];
          gltfRuntime.buffers[buf] = parsedBuffer;
          gltfRuntime.buffersCount++;
      }
  };
  var parseShaders = function (parsedShaders, gltfRuntime) {
      for (var sha in parsedShaders) {
          var parsedShader = parsedShaders[sha];
          gltfRuntime.shaders[sha] = parsedShader;
          gltfRuntime.shaderscount++;
      }
  };
  var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
      for (var object in parsedObjects) {
          var parsedObject = parsedObjects[object];
          gltfRuntime[runtimeProperty][object] = parsedObject;
      }
  };
  /**
  * Utils
  */
  var normalizeUVs = function (buffer) {
      if (!buffer) {
          return;
      }
      for (var i = 0; i < buffer.length / 2; i++) {
          buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
      }
  };
  var getAttribute = function (attributeParameter) {
      if (attributeParameter.semantic === "NORMAL") {
          return "normal";
      }
      else if (attributeParameter.semantic === "POSITION") {
          return "position";
      }
      else if (attributeParameter.semantic === "JOINT") {
          return "matricesIndices";
      }
      else if (attributeParameter.semantic === "WEIGHT") {
          return "matricesWeights";
      }
      else if (attributeParameter.semantic === "COLOR") {
          return "color";
      }
      else if (attributeParameter.semantic && attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
          var channel = Number(attributeParameter.semantic.split("_")[1]);
          return "uv" + (channel === 0 ? "" : channel + 1);
      }
      return null;
  };
  /**
  * Loads and creates animations
  */
  var loadAnimations = function (gltfRuntime) {
      for (var anim in gltfRuntime.animations) {
          var animation = gltfRuntime.animations[anim];
          if (!animation.channels || !animation.samplers) {
              continue;
          }
          var lastAnimation = null;
          for (var i = 0; i < animation.channels.length; i++) {
              // Get parameters and load buffers
              var channel = animation.channels[i];
              var sampler = animation.samplers[channel.sampler];
              if (!sampler) {
                  continue;
              }
              var inputData = null;
              var outputData = null;
              if (animation.parameters) {
                  inputData = animation.parameters[sampler.input];
                  outputData = animation.parameters[sampler.output];
              }
              else {
                  inputData = sampler.input;
                  outputData = sampler.output;
              }
              var bufferInput = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
              var bufferOutput = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[outputData]);
              var targetID = channel.target.id;
              var targetNode = gltfRuntime.scene.getNodeByID(targetID);
              if (targetNode === null) {
                  targetNode = gltfRuntime.scene.getNodeByName(targetID);
              }
              if (targetNode === null) {
                  babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Warn("Creating animation named " + anim + ". But cannot find node named " + targetID + " to attach to");
                  continue;
              }
              var isBone = targetNode instanceof babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Bone"];
              // Get target path (position, rotation or scaling)
              var targetPath = channel.target.path;
              var targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
              if (targetPathIndex !== -1) {
                  targetPath = babylonAnimationPaths[targetPathIndex];
              }
              // Determine animation type
              var animationType = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Animation"].ANIMATIONTYPE_MATRIX;
              if (!isBone) {
                  if (targetPath === "rotationQuaternion") {
                      animationType = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Animation"].ANIMATIONTYPE_QUATERNION;
                      targetNode.rotationQuaternion = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Quaternion"]();
                  }
                  else {
                      animationType = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Animation"].ANIMATIONTYPE_VECTOR3;
                  }
              }
              // Create animation and key frames
              var babylonAnimation = null;
              var keys = [];
              var arrayOffset = 0;
              var modifyKey = false;
              if (isBone && lastAnimation && lastAnimation.getKeys().length === bufferInput.length) {
                  babylonAnimation = lastAnimation;
                  modifyKey = true;
              }
              if (!modifyKey) {
                  babylonAnimation = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Animation"](anim, isBone ? "_matrix" : targetPath, 1, animationType, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Animation"].ANIMATIONLOOPMODE_CYCLE);
              }
              // For each frame
              for (var j = 0; j < bufferInput.length; j++) {
                  var value = null;
                  if (targetPath === "rotationQuaternion") { // VEC4
                      value = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Quaternion"].FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
                      arrayOffset += 4;
                  }
                  else { // Position and scaling are VEC3
                      value = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
                      arrayOffset += 3;
                  }
                  if (isBone) {
                      var bone = targetNode;
                      var translation = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero();
                      var rotationQuaternion = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Quaternion"]();
                      var scaling = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero();
                      // Warning on decompose
                      var mat = bone.getBaseMatrix();
                      if (modifyKey && lastAnimation) {
                          mat = lastAnimation.getKeys()[j].value;
                      }
                      mat.decompose(scaling, rotationQuaternion, translation);
                      if (targetPath === "position") {
                          translation = value;
                      }
                      else if (targetPath === "rotationQuaternion") {
                          rotationQuaternion = value;
                      }
                      else {
                          scaling = value;
                      }
                      value = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].Compose(scaling, rotationQuaternion, translation);
                  }
                  if (!modifyKey) {
                      keys.push({
                          frame: bufferInput[j],
                          value: value
                      });
                  }
                  else if (lastAnimation) {
                      lastAnimation.getKeys()[j].value = value;
                  }
              }
              // Finish
              if (!modifyKey && babylonAnimation) {
                  babylonAnimation.setKeys(keys);
                  targetNode.animations.push(babylonAnimation);
              }
              lastAnimation = babylonAnimation;
              gltfRuntime.scene.stopAnimation(targetNode);
              gltfRuntime.scene.beginAnimation(targetNode, 0, bufferInput[bufferInput.length - 1], true, 1.0);
          }
      }
  };
  /**
  * Returns the bones transformation matrix
  */
  var configureBoneTransformation = function (node) {
      var mat = null;
      if (node.translation || node.rotation || node.scale) {
          var scale = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray(node.scale || [1, 1, 1]);
          var rotation = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Quaternion"].FromArray(node.rotation || [0, 0, 0, 1]);
          var position = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray(node.translation || [0, 0, 0]);
          mat = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].Compose(scale, rotation, position);
      }
      else {
          mat = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].FromArray(node.matrix);
      }
      return mat;
  };
  /**
  * Returns the parent bone
  */
  var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
      // Try to find
      for (var i = 0; i < newSkeleton.bones.length; i++) {
          if (newSkeleton.bones[i].name === jointName) {
              return newSkeleton.bones[i];
          }
      }
      // Not found, search in gltf nodes
      var nodes = gltfRuntime.nodes;
      for (var nde in nodes) {
          var node = nodes[nde];
          if (!node.jointName) {
              continue;
          }
          var children = node.children;
          for (var i = 0; i < children.length; i++) {
              var child = gltfRuntime.nodes[children[i]];
              if (!child.jointName) {
                  continue;
              }
              if (child.jointName === jointName) {
                  var mat = configureBoneTransformation(node);
                  var bone = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Bone"](node.name || "", newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
                  bone.id = nde;
                  return bone;
              }
          }
      }
      return null;
  };
  /**
  * Returns the appropriate root node
  */
  var getNodeToRoot = function (nodesToRoot, id) {
      for (var i = 0; i < nodesToRoot.length; i++) {
          var nodeToRoot = nodesToRoot[i];
          for (var j = 0; j < nodeToRoot.node.children.length; j++) {
              var child = nodeToRoot.node.children[j];
              if (child === id) {
                  return nodeToRoot.bone;
              }
          }
      }
      return null;
  };
  /**
  * Returns the node with the joint name
  */
  var getJointNode = function (gltfRuntime, jointName) {
      var nodes = gltfRuntime.nodes;
      var node = nodes[jointName];
      if (node) {
          return {
              node: node,
              id: jointName
          };
      }
      for (var nde in nodes) {
          node = nodes[nde];
          if (node.jointName === jointName) {
              return {
                  node: node,
                  id: nde
              };
          }
      }
      return null;
  };
  /**
  * Checks if a nodes is in joints
  */
  var nodeIsInJoints = function (skins, id) {
      for (var i = 0; i < skins.jointNames.length; i++) {
          if (skins.jointNames[i] === id) {
              return true;
          }
      }
      return false;
  };
  /**
  * Fills the nodes to root for bones and builds hierarchy
  */
  var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
      // Creates nodes for root
      for (var nde in gltfRuntime.nodes) {
          var node = gltfRuntime.nodes[nde];
          var id = nde;
          if (!node.jointName || nodeIsInJoints(skins, node.jointName)) {
              continue;
          }
          // Create node to root bone
          var mat = configureBoneTransformation(node);
          var bone = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Bone"](node.name || "", newSkeleton, null, mat);
          bone.id = id;
          nodesToRoot.push({ bone: bone, node: node, id: id });
      }
      // Parenting
      for (var i = 0; i < nodesToRoot.length; i++) {
          var nodeToRoot = nodesToRoot[i];
          var children = nodeToRoot.node.children;
          for (var j = 0; j < children.length; j++) {
              var child = null;
              for (var k = 0; k < nodesToRoot.length; k++) {
                  if (nodesToRoot[k].id === children[j]) {
                      child = nodesToRoot[k];
                      break;
                  }
              }
              if (child) {
                  child.bone._parent = nodeToRoot.bone;
                  nodeToRoot.bone.children.push(child.bone);
              }
          }
      }
  };
  /**
  * Imports a skeleton
  */
  var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton, id) {
      if (!newSkeleton) {
          newSkeleton = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Skeleton"](skins.name || "", "", gltfRuntime.scene);
      }
      if (!skins.babylonSkeleton) {
          return newSkeleton;
      }
      // Find the root bones
      var nodesToRoot = [];
      var nodesToRootToAdd = [];
      getNodesToRoot(gltfRuntime, newSkeleton, skins, nodesToRoot);
      newSkeleton.bones = [];
      // Joints
      for (var i = 0; i < skins.jointNames.length; i++) {
          var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
          if (!jointNode) {
              continue;
          }
          var node = jointNode.node;
          if (!node) {
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Warn("Joint named " + skins.jointNames[i] + " does not exist");
              continue;
          }
          var id = jointNode.id;
          // Optimize, if the bone already exists...
          var existingBone = gltfRuntime.scene.getBoneByID(id);
          if (existingBone) {
              newSkeleton.bones.push(existingBone);
              continue;
          }
          // Search for parent bone
          var foundBone = false;
          var parentBone = null;
          for (var j = 0; j < i; j++) {
              var jointNode_1 = getJointNode(gltfRuntime, skins.jointNames[j]);
              if (!jointNode_1) {
                  continue;
              }
              var joint = jointNode_1.node;
              if (!joint) {
                  babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
                  continue;
              }
              var children = joint.children;
              if (!children) {
                  continue;
              }
              foundBone = false;
              for (var k = 0; k < children.length; k++) {
                  if (children[k] === id) {
                      parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
                      foundBone = true;
                      break;
                  }
              }
              if (foundBone) {
                  break;
              }
          }
          // Create bone
          var mat = configureBoneTransformation(node);
          if (!parentBone && nodesToRoot.length > 0) {
              parentBone = getNodeToRoot(nodesToRoot, id);
              if (parentBone) {
                  if (nodesToRootToAdd.indexOf(parentBone) === -1) {
                      nodesToRootToAdd.push(parentBone);
                  }
              }
          }
          var bone = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Bone"](node.jointName || "", newSkeleton, parentBone, mat);
          bone.id = id;
      }
      // Polish
      var bones = newSkeleton.bones;
      newSkeleton.bones = [];
      for (var i = 0; i < skins.jointNames.length; i++) {
          var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
          if (!jointNode) {
              continue;
          }
          for (var j = 0; j < bones.length; j++) {
              if (bones[j].id === jointNode.id) {
                  newSkeleton.bones.push(bones[j]);
                  break;
              }
          }
      }
      newSkeleton.prepare();
      // Finish
      for (var i = 0; i < nodesToRootToAdd.length; i++) {
          newSkeleton.bones.push(nodesToRootToAdd[i]);
      }
      return newSkeleton;
  };
  /**
  * Imports a mesh and its geometries
  */
  var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
      if (!newMesh) {
          newMesh = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Mesh"](node.name || "", gltfRuntime.scene);
          newMesh.id = id;
      }
      if (!node.babylonNode) {
          return newMesh;
      }
      var subMaterials = [];
      var vertexData = null;
      var verticesStarts = new Array();
      var verticesCounts = new Array();
      var indexStarts = new Array();
      var indexCounts = new Array();
      for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
          var meshID = meshes[meshIndex];
          var mesh = gltfRuntime.meshes[meshID];
          if (!mesh) {
              continue;
          }
          // Positions, normals and UVs
          for (var i = 0; i < mesh.primitives.length; i++) {
              // Temporary vertex data
              var tempVertexData = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["VertexData"]();
              var primitive = mesh.primitives[i];
              if (primitive.mode !== 4) {
                  // continue;
              }
              var attributes = primitive.attributes;
              var accessor = null;
              var buffer = null;
              // Set positions, normal and uvs
              for (var semantic in attributes) {
                  // Link accessor and buffer view
                  accessor = gltfRuntime.accessors[attributes[semantic]];
                  buffer = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetBufferFromAccessor(gltfRuntime, accessor);
                  if (semantic === "NORMAL") {
                      tempVertexData.normals = new Float32Array(buffer.length);
                      tempVertexData.normals.set(buffer);
                  }
                  else if (semantic === "POSITION") {
                      if (_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__["GLTFFileLoader"].HomogeneousCoordinates) {
                          tempVertexData.positions = new Float32Array(buffer.length - buffer.length / 4);
                          for (var j = 0; j < buffer.length; j += 4) {
                              tempVertexData.positions[j] = buffer[j];
                              tempVertexData.positions[j + 1] = buffer[j + 1];
                              tempVertexData.positions[j + 2] = buffer[j + 2];
                          }
                      }
                      else {
                          tempVertexData.positions = new Float32Array(buffer.length);
                          tempVertexData.positions.set(buffer);
                      }
                      verticesCounts.push(tempVertexData.positions.length);
                  }
                  else if (semantic.indexOf("TEXCOORD_") !== -1) {
                      var channel = Number(semantic.split("_")[1]);
                      var uvKind = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["VertexBuffer"].UVKind + (channel === 0 ? "" : (channel + 1));
                      var uvs = new Float32Array(buffer.length);
                      uvs.set(buffer);
                      normalizeUVs(uvs);
                      tempVertexData.set(uvs, uvKind);
                  }
                  else if (semantic === "JOINT") {
                      tempVertexData.matricesIndices = new Float32Array(buffer.length);
                      tempVertexData.matricesIndices.set(buffer);
                  }
                  else if (semantic === "WEIGHT") {
                      tempVertexData.matricesWeights = new Float32Array(buffer.length);
                      tempVertexData.matricesWeights.set(buffer);
                  }
                  else if (semantic === "COLOR") {
                      tempVertexData.colors = new Float32Array(buffer.length);
                      tempVertexData.colors.set(buffer);
                  }
              }
              // Indices
              accessor = gltfRuntime.accessors[primitive.indices];
              if (accessor) {
                  buffer = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetBufferFromAccessor(gltfRuntime, accessor);
                  tempVertexData.indices = new Int32Array(buffer.length);
                  tempVertexData.indices.set(buffer);
                  indexCounts.push(tempVertexData.indices.length);
              }
              else {
                  // Set indices on the fly
                  var indices = [];
                  for (var j = 0; j < tempVertexData.positions.length / 3; j++) {
                      indices.push(j);
                  }
                  tempVertexData.indices = new Int32Array(indices);
                  indexCounts.push(tempVertexData.indices.length);
              }
              if (!vertexData) {
                  vertexData = tempVertexData;
              }
              else {
                  vertexData.merge(tempVertexData);
              }
              // Sub material
              var material_1 = gltfRuntime.scene.getMaterialByID(primitive.material);
              subMaterials.push(material_1 === null ? _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetDefaultMaterial(gltfRuntime.scene) : material_1);
              // Update vertices start and index start
              verticesStarts.push(verticesStarts.length === 0 ? 0 : verticesStarts[verticesStarts.length - 1] + verticesCounts[verticesCounts.length - 2]);
              indexStarts.push(indexStarts.length === 0 ? 0 : indexStarts[indexStarts.length - 1] + indexCounts[indexCounts.length - 2]);
          }
      }
      var material;
      if (subMaterials.length > 1) {
          material = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["MultiMaterial"]("multimat" + id, gltfRuntime.scene);
          material.subMaterials = subMaterials;
      }
      else {
          material = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["StandardMaterial"]("multimat" + id, gltfRuntime.scene);
      }
      if (subMaterials.length === 1) {
          material = subMaterials[0];
      }
      if (!newMesh.material) {
          newMesh.material = material;
      }
      // Apply geometry
      new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Geometry"](id, gltfRuntime.scene, vertexData, false, newMesh);
      newMesh.computeWorldMatrix(true);
      // Apply submeshes
      newMesh.subMeshes = [];
      var index = 0;
      for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
          var meshID = meshes[meshIndex];
          var mesh = gltfRuntime.meshes[meshID];
          if (!mesh) {
              continue;
          }
          for (var i = 0; i < mesh.primitives.length; i++) {
              if (mesh.primitives[i].mode !== 4) {
                  //continue;
              }
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["SubMesh"].AddToMesh(index, verticesStarts[index], verticesCounts[index], indexStarts[index], indexCounts[index], newMesh, newMesh, true);
              index++;
          }
      }
      // Finish
      return newMesh;
  };
  /**
  * Configure node transformation from position, rotation and scaling
  */
  var configureNode = function (newNode, position, rotation, scaling) {
      if (newNode.position) {
          newNode.position = position;
      }
      if (newNode.rotationQuaternion || newNode.rotation) {
          newNode.rotationQuaternion = rotation;
      }
      if (newNode.scaling) {
          newNode.scaling = scaling;
      }
  };
  /**
  * Configures node from transformation matrix
  */
  var configureNodeFromMatrix = function (newNode, node, parent) {
      if (node.matrix) {
          var position = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"](0, 0, 0);
          var rotation = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Quaternion"]();
          var scaling = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"](0, 0, 0);
          var mat = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].FromArray(node.matrix);
          mat.decompose(scaling, rotation, position);
          configureNode(newNode, position, rotation, scaling);
      }
      else if (node.translation && node.rotation && node.scale) {
          configureNode(newNode, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray(node.translation), babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Quaternion"].FromArray(node.rotation), babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray(node.scale));
      }
      newNode.computeWorldMatrix(true);
  };
  /**
  * Imports a node
  */
  var importNode = function (gltfRuntime, node, id, parent) {
      var lastNode = null;
      if (gltfRuntime.importOnlyMeshes && (node.skin || node.meshes)) {
          if (gltfRuntime.importMeshesNames && gltfRuntime.importMeshesNames.length > 0 && gltfRuntime.importMeshesNames.indexOf(node.name || "") === -1) {
              return null;
          }
      }
      // Meshes
      if (node.skin) {
          if (node.meshes) {
              var skin = gltfRuntime.skins[node.skin];
              var newMesh = importMesh(gltfRuntime, node, node.meshes, id, node.babylonNode);
              newMesh.skeleton = gltfRuntime.scene.getLastSkeletonByID(node.skin);
              if (newMesh.skeleton === null) {
                  newMesh.skeleton = importSkeleton(gltfRuntime, skin, newMesh, skin.babylonSkeleton, node.skin);
                  if (!skin.babylonSkeleton) {
                      skin.babylonSkeleton = newMesh.skeleton;
                  }
              }
              lastNode = newMesh;
          }
      }
      else if (node.meshes) {
          /**
          * Improve meshes property
          */
          var newMesh = importMesh(gltfRuntime, node, node.mesh ? [node.mesh] : node.meshes, id, node.babylonNode);
          lastNode = newMesh;
      }
      // Lights
      else if (node.light && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
          var light = gltfRuntime.lights[node.light];
          if (light) {
              if (light.type === "ambient") {
                  var ambienLight = light[light.type];
                  var hemiLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["HemisphericLight"](node.light, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero(), gltfRuntime.scene);
                  hemiLight.name = node.name || "";
                  if (ambienLight.color) {
                      hemiLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Color3"].FromArray(ambienLight.color);
                  }
                  lastNode = hemiLight;
              }
              else if (light.type === "directional") {
                  var directionalLight = light[light.type];
                  var dirLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["DirectionalLight"](node.light, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero(), gltfRuntime.scene);
                  dirLight.name = node.name || "";
                  if (directionalLight.color) {
                      dirLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Color3"].FromArray(directionalLight.color);
                  }
                  lastNode = dirLight;
              }
              else if (light.type === "point") {
                  var pointLight = light[light.type];
                  var ptLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["PointLight"](node.light, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero(), gltfRuntime.scene);
                  ptLight.name = node.name || "";
                  if (pointLight.color) {
                      ptLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Color3"].FromArray(pointLight.color);
                  }
                  lastNode = ptLight;
              }
              else if (light.type === "spot") {
                  var spotLight = light[light.type];
                  var spLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["SpotLight"](node.light, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero(), babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero(), 0, 0, gltfRuntime.scene);
                  spLight.name = node.name || "";
                  if (spotLight.color) {
                      spLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Color3"].FromArray(spotLight.color);
                  }
                  if (spotLight.fallOfAngle) {
                      spLight.angle = spotLight.fallOfAngle;
                  }
                  if (spotLight.fallOffExponent) {
                      spLight.exponent = spotLight.fallOffExponent;
                  }
                  lastNode = spLight;
              }
          }
      }
      // Cameras
      else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
          var camera = gltfRuntime.cameras[node.camera];
          if (camera) {
              if (camera.type === "orthographic") {
                  var orthoCamera = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["FreeCamera"](node.camera, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero(), gltfRuntime.scene, false);
                  orthoCamera.name = node.name || "";
                  orthoCamera.mode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Camera"].ORTHOGRAPHIC_CAMERA;
                  orthoCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas());
                  lastNode = orthoCamera;
              }
              else if (camera.type === "perspective") {
                  var perspectiveCamera = camera[camera.type];
                  var persCamera = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["FreeCamera"](node.camera, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].Zero(), gltfRuntime.scene, false);
                  persCamera.name = node.name || "";
                  persCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas());
                  if (!perspectiveCamera.aspectRatio) {
                      perspectiveCamera.aspectRatio = gltfRuntime.scene.getEngine().getRenderWidth() / gltfRuntime.scene.getEngine().getRenderHeight();
                  }
                  if (perspectiveCamera.znear && perspectiveCamera.zfar) {
                      persCamera.maxZ = perspectiveCamera.zfar;
                      persCamera.minZ = perspectiveCamera.znear;
                  }
                  lastNode = persCamera;
              }
          }
      }
      // Empty node
      if (!node.jointName) {
          if (node.babylonNode) {
              return node.babylonNode;
          }
          else if (lastNode === null) {
              var dummy = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Mesh"](node.name || "", gltfRuntime.scene);
              node.babylonNode = dummy;
              lastNode = dummy;
          }
      }
      if (lastNode !== null) {
          if (node.matrix && lastNode instanceof babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Mesh"]) {
              configureNodeFromMatrix(lastNode, node, parent);
          }
          else {
              var translation = node.translation || [0, 0, 0];
              var rotation = node.rotation || [0, 0, 0, 1];
              var scale = node.scale || [1, 1, 1];
              configureNode(lastNode, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray(translation), babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Quaternion"].FromArray(rotation), babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray(scale));
          }
          lastNode.updateCache(true);
          node.babylonNode = lastNode;
      }
      return lastNode;
  };
  /**
  * Traverses nodes and creates them
  */
  var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
      if (meshIncluded === void 0) { meshIncluded = false; }
      var node = gltfRuntime.nodes[id];
      var newNode = null;
      if (gltfRuntime.importOnlyMeshes && !meshIncluded && gltfRuntime.importMeshesNames) {
          if (gltfRuntime.importMeshesNames.indexOf(node.name || "") !== -1 || gltfRuntime.importMeshesNames.length === 0) {
              meshIncluded = true;
          }
          else {
              meshIncluded = false;
          }
      }
      else {
          meshIncluded = true;
      }
      if (!node.jointName && meshIncluded) {
          newNode = importNode(gltfRuntime, node, id, parent);
          if (newNode !== null) {
              newNode.id = id;
              newNode.parent = parent;
          }
      }
      if (node.children) {
          for (var i = 0; i < node.children.length; i++) {
              traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
          }
      }
  };
  /**
  * do stuff after buffers, shaders are loaded (e.g. hook up materials, load animations, etc.)
  */
  var postLoad = function (gltfRuntime) {
      // Nodes
      var currentScene = gltfRuntime.currentScene;
      if (currentScene) {
          for (var i = 0; i < currentScene.nodes.length; i++) {
              traverseNodes(gltfRuntime, currentScene.nodes[i], null);
          }
      }
      else {
          for (var thing in gltfRuntime.scenes) {
              currentScene = gltfRuntime.scenes[thing];
              for (var i = 0; i < currentScene.nodes.length; i++) {
                  traverseNodes(gltfRuntime, currentScene.nodes[i], null);
              }
          }
      }
      // Set animations
      loadAnimations(gltfRuntime);
      for (var i = 0; i < gltfRuntime.scene.skeletons.length; i++) {
          var skeleton = gltfRuntime.scene.skeletons[i];
          gltfRuntime.scene.beginAnimation(skeleton, 0, Number.MAX_VALUE, true, 1.0);
      }
  };
  /**
  * onBind shaderrs callback to set uniforms and matrices
  */
  var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess) {
      var materialValues = material.values || technique.parameters;
      for (var unif in unTreatedUniforms) {
          var uniform = unTreatedUniforms[unif];
          var type = uniform.type;
          if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_MAT2 || type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_MAT3 || type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_MAT4) {
              if (uniform.semantic && !uniform.source && !uniform.node) {
                  _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].SetMatrix(gltfRuntime.scene, mesh, uniform, unif, shaderMaterial.getEffect());
              }
              else if (uniform.semantic && (uniform.source || uniform.node)) {
                  var source = gltfRuntime.scene.getNodeByName(uniform.source || uniform.node || "");
                  if (source === null) {
                      source = gltfRuntime.scene.getNodeByID(uniform.source || uniform.node || "");
                  }
                  if (source === null) {
                      continue;
                  }
                  _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].SetMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect());
              }
          }
          else {
              var value = materialValues[technique.uniforms[unif]];
              if (!value) {
                  continue;
              }
              if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].SAMPLER_2D) {
                  var texture = gltfRuntime.textures[material.values ? value : uniform.value].babylonTexture;
                  if (texture === null || texture === undefined) {
                      continue;
                  }
                  shaderMaterial.getEffect().setTexture(unif, texture);
              }
              else {
                  _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].SetUniform((shaderMaterial.getEffect()), unif, value, type);
              }
          }
      }
      onSuccess(shaderMaterial);
  };
  /**
  * Prepare uniforms to send the only one time
  * Loads the appropriate textures
  */
  var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
      var materialValues = material.values || technique.parameters;
      var techniqueUniforms = technique.uniforms;
      /**
      * Prepare values here (not matrices)
      */
      for (var unif in unTreatedUniforms) {
          var uniform = unTreatedUniforms[unif];
          var type = uniform.type;
          var value = materialValues[techniqueUniforms[unif]];
          if (value === undefined) {
              // In case the value is the same for all materials
              value = uniform.value;
          }
          if (!value) {
              continue;
          }
          var onLoadTexture = function (uniformName) {
              return function (texture) {
                  if (uniform.value && uniformName) {
                      // Static uniform
                      shaderMaterial.setTexture(uniformName, texture);
                      delete unTreatedUniforms[uniformName];
                  }
              };
          };
          // Texture (sampler2D)
          if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].SAMPLER_2D) {
              GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); });
          }
          // Others
          else {
              if (uniform.value && _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].SetUniform(shaderMaterial, unif, material.values ? value : uniform.value, type)) {
                  // Static uniform
                  delete unTreatedUniforms[unif];
              }
          }
      }
  };
  /**
  * Shader compilation failed
  */
  var onShaderCompileError = function (program, shaderMaterial, onError) {
      return function (effect, error) {
          shaderMaterial.dispose(true);
          onError("Cannot compile program named " + program.name + ". Error: " + error + ". Default material will be applied");
      };
  };
  /**
  * Shader compilation success
  */
  var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) {
      return function (_) {
          prepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
          shaderMaterial.onBind = function (mesh) {
              onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
          };
      };
  };
  /**
  * Returns the appropriate uniform if already handled by babylon
  */
  var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
      for (var unif in technique.uniforms) {
          var uniform = technique.uniforms[unif];
          var uniformParameter = technique.parameters[uniform];
          if (tokenizer.currentIdentifier === unif) {
              if (uniformParameter.semantic && !uniformParameter.source && !uniformParameter.node) {
                  var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
                  if (transformIndex !== -1) {
                      delete unTreatedUniforms[unif];
                      return babylonTransforms[transformIndex];
                  }
              }
          }
      }
      return tokenizer.currentIdentifier;
  };
  /**
  * All shaders loaded. Create materials one by one
  */
  var importMaterials = function (gltfRuntime) {
      // Create materials
      for (var mat in gltfRuntime.materials) {
          GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, function (material) { }, function () { });
      }
  };
  /**
  * Implementation of the base glTF spec
  * @hidden
  */
  var GLTFLoaderBase = /** @class */ (function () {
      function GLTFLoaderBase() {
      }
      GLTFLoaderBase.CreateRuntime = function (parsedData, scene, rootUrl) {
          var gltfRuntime = {
              extensions: {},
              accessors: {},
              buffers: {},
              bufferViews: {},
              meshes: {},
              lights: {},
              cameras: {},
              nodes: {},
              images: {},
              textures: {},
              shaders: {},
              programs: {},
              samplers: {},
              techniques: {},
              materials: {},
              animations: {},
              skins: {},
              extensionsUsed: [],
              scenes: {},
              buffersCount: 0,
              shaderscount: 0,
              scene: scene,
              rootUrl: rootUrl,
              loadedBufferCount: 0,
              loadedBufferViews: {},
              loadedShaderCount: 0,
              importOnlyMeshes: false,
              dummyNodes: []
          };
          // Parse
          if (parsedData.extensions) {
              parseObject(parsedData.extensions, "extensions", gltfRuntime);
          }
          if (parsedData.extensionsUsed) {
              parseObject(parsedData.extensionsUsed, "extensionsUsed", gltfRuntime);
          }
          if (parsedData.buffers) {
              parseBuffers(parsedData.buffers, gltfRuntime);
          }
          if (parsedData.bufferViews) {
              parseObject(parsedData.bufferViews, "bufferViews", gltfRuntime);
          }
          if (parsedData.accessors) {
              parseObject(parsedData.accessors, "accessors", gltfRuntime);
          }
          if (parsedData.meshes) {
              parseObject(parsedData.meshes, "meshes", gltfRuntime);
          }
          if (parsedData.lights) {
              parseObject(parsedData.lights, "lights", gltfRuntime);
          }
          if (parsedData.cameras) {
              parseObject(parsedData.cameras, "cameras", gltfRuntime);
          }
          if (parsedData.nodes) {
              parseObject(parsedData.nodes, "nodes", gltfRuntime);
          }
          if (parsedData.images) {
              parseObject(parsedData.images, "images", gltfRuntime);
          }
          if (parsedData.textures) {
              parseObject(parsedData.textures, "textures", gltfRuntime);
          }
          if (parsedData.shaders) {
              parseShaders(parsedData.shaders, gltfRuntime);
          }
          if (parsedData.programs) {
              parseObject(parsedData.programs, "programs", gltfRuntime);
          }
          if (parsedData.samplers) {
              parseObject(parsedData.samplers, "samplers", gltfRuntime);
          }
          if (parsedData.techniques) {
              parseObject(parsedData.techniques, "techniques", gltfRuntime);
          }
          if (parsedData.materials) {
              parseObject(parsedData.materials, "materials", gltfRuntime);
          }
          if (parsedData.animations) {
              parseObject(parsedData.animations, "animations", gltfRuntime);
          }
          if (parsedData.skins) {
              parseObject(parsedData.skins, "skins", gltfRuntime);
          }
          if (parsedData.scenes) {
              gltfRuntime.scenes = parsedData.scenes;
          }
          if (parsedData.scene && parsedData.scenes) {
              gltfRuntime.currentScene = parsedData.scenes[parsedData.scene];
          }
          return gltfRuntime;
      };
      GLTFLoaderBase.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
          var buffer = gltfRuntime.buffers[id];
          if (babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].IsBase64(buffer.uri)) {
              setTimeout(function () { return onSuccess(new Uint8Array(babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].DecodeBase64(buffer.uri))); });
          }
          else {
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].LoadFile(gltfRuntime.rootUrl + buffer.uri, function (data) { return onSuccess(new Uint8Array(data)); }, onProgress, undefined, true, function (request) {
                  if (request) {
                      onError(request.status + " " + request.statusText);
                  }
              });
          }
      };
      GLTFLoaderBase.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
          var texture = gltfRuntime.textures[id];
          if (!texture || !texture.source) {
              onError("");
              return;
          }
          if (texture.babylonTexture) {
              onSuccess(null);
              return;
          }
          var source = gltfRuntime.images[texture.source];
          if (babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].IsBase64(source.uri)) {
              setTimeout(function () { return onSuccess(new Uint8Array(babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].DecodeBase64(source.uri))); });
          }
          else {
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].LoadFile(gltfRuntime.rootUrl + source.uri, function (data) { return onSuccess(new Uint8Array(data)); }, undefined, undefined, true, function (request) {
                  if (request) {
                      onError(request.status + " " + request.statusText);
                  }
              });
          }
      };
      GLTFLoaderBase.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
          var texture = gltfRuntime.textures[id];
          if (texture.babylonTexture) {
              onSuccess(texture.babylonTexture);
              return;
          }
          var sampler = gltfRuntime.samplers[texture.sampler];
          var createMipMaps = (sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].NEAREST_MIPMAP_NEAREST) ||
              (sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].NEAREST_MIPMAP_LINEAR) ||
              (sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].LINEAR_MIPMAP_NEAREST) ||
              (sampler.minFilter === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].LINEAR_MIPMAP_LINEAR);
          var samplingMode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].BILINEAR_SAMPLINGMODE;
          var blob = buffer == null ? new Blob() : new Blob([buffer]);
          var blobURL = URL.createObjectURL(blob);
          var revokeBlobURL = function () { return URL.revokeObjectURL(blobURL); };
          var newTexture = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"](blobURL, gltfRuntime.scene, !createMipMaps, true, samplingMode, revokeBlobURL, revokeBlobURL);
          if (sampler.wrapS !== undefined) {
              newTexture.wrapU = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetWrapMode(sampler.wrapS);
          }
          if (sampler.wrapT !== undefined) {
              newTexture.wrapV = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__["GLTFUtils"].GetWrapMode(sampler.wrapT);
          }
          newTexture.name = id;
          texture.babylonTexture = newTexture;
          onSuccess(newTexture);
      };
      GLTFLoaderBase.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
          var shader = gltfRuntime.shaders[id];
          if (babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].IsBase64(shader.uri)) {
              var shaderString = atob(shader.uri.split(",")[1]);
              if (onSuccess) {
                  onSuccess(shaderString);
              }
          }
          else {
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].LoadFile(gltfRuntime.rootUrl + shader.uri, onSuccess, undefined, undefined, false, function (request) {
                  if (request && onError) {
                      onError(request.status + " " + request.statusText);
                  }
              });
          }
      };
      GLTFLoaderBase.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
          var material = gltfRuntime.materials[id];
          if (!material.technique) {
              if (onError) {
                  onError("No technique found.");
              }
              return;
          }
          var technique = gltfRuntime.techniques[material.technique];
          if (!technique) {
              var defaultMaterial = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["StandardMaterial"](id, gltfRuntime.scene);
              defaultMaterial.diffuseColor = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Color3"](0.5, 0.5, 0.5);
              defaultMaterial.sideOrientation = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Material"].CounterClockWiseSideOrientation;
              onSuccess(defaultMaterial);
              return;
          }
          var program = gltfRuntime.programs[technique.program];
          var states = technique.states;
          var vertexShader = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore[program.vertexShader + "VertexShader"];
          var pixelShader = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore[program.fragmentShader + "PixelShader"];
          var newVertexShader = "";
          var newPixelShader = "";
          var vertexTokenizer = new Tokenizer(vertexShader);
          var pixelTokenizer = new Tokenizer(pixelShader);
          var unTreatedUniforms = {};
          var uniforms = [];
          var attributes = [];
          var samplers = [];
          // Fill uniform, sampler2D and attributes
          for (var unif in technique.uniforms) {
              var uniform = technique.uniforms[unif];
              var uniformParameter = technique.parameters[uniform];
              unTreatedUniforms[unif] = uniformParameter;
              if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) {
                  var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
                  if (transformIndex !== -1) {
                      uniforms.push(babylonTransforms[transformIndex]);
                      delete unTreatedUniforms[unif];
                  }
                  else {
                      uniforms.push(unif);
                  }
              }
              else if (uniformParameter.type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].SAMPLER_2D) {
                  samplers.push(unif);
              }
              else {
                  uniforms.push(unif);
              }
          }
          for (var attr in technique.attributes) {
              var attribute = technique.attributes[attr];
              var attributeParameter = technique.parameters[attribute];
              if (attributeParameter.semantic) {
                  var name_1 = getAttribute(attributeParameter);
                  if (name_1) {
                      attributes.push(name_1);
                  }
              }
          }
          // Configure vertex shader
          while (!vertexTokenizer.isEnd() && vertexTokenizer.getNextToken()) {
              var tokenType = vertexTokenizer.currentToken;
              if (tokenType !== ETokenType.IDENTIFIER) {
                  newVertexShader += vertexTokenizer.currentString;
                  continue;
              }
              var foundAttribute = false;
              for (var attr in technique.attributes) {
                  var attribute = technique.attributes[attr];
                  var attributeParameter = technique.parameters[attribute];
                  if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) {
                      newVertexShader += getAttribute(attributeParameter);
                      foundAttribute = true;
                      break;
                  }
              }
              if (foundAttribute) {
                  continue;
              }
              newVertexShader += parseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms);
          }
          // Configure pixel shader
          while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) {
              var tokenType = pixelTokenizer.currentToken;
              if (tokenType !== ETokenType.IDENTIFIER) {
                  newPixelShader += pixelTokenizer.currentString;
                  continue;
              }
              newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
          }
          // Create shader material
          var shaderPath = {
              vertex: program.vertexShader + id,
              fragment: program.fragmentShader + id
          };
          var options = {
              attributes: attributes,
              uniforms: uniforms,
              samplers: samplers,
              needAlphaBlending: states && states.enable && states.enable.indexOf(3042) !== -1
          };
          babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
          babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
          var shaderMaterial = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["ShaderMaterial"](id, gltfRuntime.scene, shaderPath, options);
          shaderMaterial.onError = onShaderCompileError(program, shaderMaterial, onError);
          shaderMaterial.onCompiled = onShaderCompileSuccess(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess);
          shaderMaterial.sideOrientation = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Material"].CounterClockWiseSideOrientation;
          if (states && states.functions) {
              var functions = states.functions;
              if (functions.cullFace && functions.cullFace[0] !== _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ECullingType"].BACK) {
                  shaderMaterial.backFaceCulling = false;
              }
              var blendFunc = functions.blendFuncSeparate;
              if (blendFunc) {
                  if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].SRC_ALPHA && blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE_MINUS_SRC_ALPHA && blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE && blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE) {
                      shaderMaterial.alphaMode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Engine"].ALPHA_COMBINE;
                  }
                  else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE && blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE && blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ZERO && blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE) {
                      shaderMaterial.alphaMode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Engine"].ALPHA_ONEONE;
                  }
                  else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].SRC_ALPHA && blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE && blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ZERO && blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE) {
                      shaderMaterial.alphaMode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Engine"].ALPHA_ADD;
                  }
                  else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ZERO && blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE_MINUS_SRC_COLOR && blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE && blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE) {
                      shaderMaterial.alphaMode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Engine"].ALPHA_SUBTRACT;
                  }
                  else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].DST_COLOR && blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ZERO && blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE && blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE) {
                      shaderMaterial.alphaMode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Engine"].ALPHA_MULTIPLY;
                  }
                  else if (blendFunc[0] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].SRC_ALPHA && blendFunc[1] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE_MINUS_SRC_COLOR && blendFunc[2] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE && blendFunc[3] === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EBlendingFunction"].ONE) {
                      shaderMaterial.alphaMode = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Engine"].ALPHA_MAXIMIZED;
                  }
              }
          }
      };
      return GLTFLoaderBase;
  }());
  
  /**
  * glTF V1 Loader
  * @hidden
  */
  var GLTFLoader = /** @class */ (function () {
      function GLTFLoader() {
          this.state = null;
      }
      GLTFLoader.RegisterExtension = function (extension) {
          if (GLTFLoader.Extensions[extension.name]) {
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Error("Tool with the same name \"" + extension.name + "\" already exists");
              return;
          }
          GLTFLoader.Extensions[extension.name] = extension;
      };
      GLTFLoader.prototype.dispose = function () {
          // do nothing
      };
      GLTFLoader.prototype._importMeshAsync = function (meshesNames, scene, data, rootUrl, onSuccess, onProgress, onError) {
          var _this = this;
          scene.useRightHandedSystem = true;
          GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
              gltfRuntime.importOnlyMeshes = true;
              if (meshesNames === "") {
                  gltfRuntime.importMeshesNames = [];
              }
              else if (typeof meshesNames === "string") {
                  gltfRuntime.importMeshesNames = [meshesNames];
              }
              else if (meshesNames && !(meshesNames instanceof Array)) {
                  gltfRuntime.importMeshesNames = [meshesNames];
              }
              else {
                  gltfRuntime.importMeshesNames = [];
                  babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Warn("Argument meshesNames must be of type string or string[]");
              }
              // Create nodes
              _this._createNodes(gltfRuntime);
              var meshes = new Array();
              var skeletons = new Array();
              // Fill arrays of meshes and skeletons
              for (var nde in gltfRuntime.nodes) {
                  var node = gltfRuntime.nodes[nde];
                  if (node.babylonNode instanceof babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["AbstractMesh"]) {
                      meshes.push(node.babylonNode);
                  }
              }
              for (var skl in gltfRuntime.skins) {
                  var skin = gltfRuntime.skins[skl];
                  if (skin.babylonSkeleton instanceof babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Skeleton"]) {
                      skeletons.push(skin.babylonSkeleton);
                  }
              }
              // Load buffers, shaders, materials, etc.
              _this._loadBuffersAsync(gltfRuntime, function () {
                  _this._loadShadersAsync(gltfRuntime, function () {
                      importMaterials(gltfRuntime);
                      postLoad(gltfRuntime);
                      if (!_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__["GLTFFileLoader"].IncrementalLoading && onSuccess) {
                          onSuccess(meshes, skeletons);
                      }
                  });
              }, onProgress);
              if (_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__["GLTFFileLoader"].IncrementalLoading && onSuccess) {
                  onSuccess(meshes, skeletons);
              }
          }, onError);
          return true;
      };
      /**
      * Imports one or more meshes from a loaded gltf file and adds them to the scene
      * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
      * @param scene the scene the meshes should be added to
      * @param data gltf data containing information of the meshes in a loaded file
      * @param rootUrl root url to load from
      * @param onProgress event that fires when loading progress has occured
      * @returns a promise containg the loaded meshes, particles, skeletons and animations
      */
      GLTFLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress) {
          var _this = this;
          return new Promise(function (resolve, reject) {
              _this._importMeshAsync(meshesNames, scene, data, rootUrl, function (meshes, skeletons) {
                  resolve({
                      meshes: meshes,
                      particleSystems: [],
                      skeletons: skeletons,
                      animationGroups: []
                  });
              }, onProgress, function (message) {
                  reject(new Error(message));
              });
          });
      };
      GLTFLoader.prototype._loadAsync = function (scene, data, rootUrl, onSuccess, onProgress, onError) {
          var _this = this;
          scene.useRightHandedSystem = true;
          GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
              // Load runtime extensios
              GLTFLoaderExtension.LoadRuntimeExtensionsAsync(gltfRuntime, function () {
                  // Create nodes
                  _this._createNodes(gltfRuntime);
                  // Load buffers, shaders, materials, etc.
                  _this._loadBuffersAsync(gltfRuntime, function () {
                      _this._loadShadersAsync(gltfRuntime, function () {
                          importMaterials(gltfRuntime);
                          postLoad(gltfRuntime);
                          if (!_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__["GLTFFileLoader"].IncrementalLoading) {
                              onSuccess();
                          }
                      });
                  });
                  if (_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__["GLTFFileLoader"].IncrementalLoading) {
                      onSuccess();
                  }
              }, onError);
          }, onError);
      };
      /**
      * Imports all objects from a loaded gltf file and adds them to the scene
      * @param scene the scene the objects should be added to
      * @param data gltf data containing information of the meshes in a loaded file
      * @param rootUrl root url to load from
      * @param onProgress event that fires when loading progress has occured
      * @returns a promise which completes when objects have been loaded to the scene
      */
      GLTFLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress) {
          var _this = this;
          return new Promise(function (resolve, reject) {
              _this._loadAsync(scene, data, rootUrl, function () {
                  resolve();
              }, onProgress, function (message) {
                  reject(new Error(message));
              });
          });
      };
      GLTFLoader.prototype._loadShadersAsync = function (gltfRuntime, onload) {
          var hasShaders = false;
          var processShader = function (sha, shader) {
              GLTFLoaderExtension.LoadShaderStringAsync(gltfRuntime, sha, function (shaderString) {
                  if (shaderString instanceof ArrayBuffer) {
                      return;
                  }
                  gltfRuntime.loadedShaderCount++;
                  if (shaderString) {
                      babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore[sha + (shader.type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EShaderType"].VERTEX ? "VertexShader" : "PixelShader")] = shaderString;
                  }
                  if (gltfRuntime.loadedShaderCount === gltfRuntime.shaderscount) {
                      onload();
                  }
              }, function () {
                  babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Error("Error when loading shader program named " + sha + " located at " + shader.uri);
              });
          };
          for (var sha in gltfRuntime.shaders) {
              hasShaders = true;
              var shader = gltfRuntime.shaders[sha];
              if (shader) {
                  processShader.bind(this, sha, shader)();
              }
              else {
                  babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Error("No shader named: " + sha);
              }
          }
          if (!hasShaders) {
              onload();
          }
      };
      GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad, onProgress) {
          var hasBuffers = false;
          var processBuffer = function (buf, buffer) {
              GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) {
                  gltfRuntime.loadedBufferCount++;
                  if (bufferView) {
                      if (bufferView.byteLength != gltfRuntime.buffers[buf].byteLength) {
                          babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Error("Buffer named " + buf + " is length " + bufferView.byteLength + ". Expected: " + buffer.byteLength); // Improve error message
                      }
                      gltfRuntime.loadedBufferViews[buf] = bufferView;
                  }
                  if (gltfRuntime.loadedBufferCount === gltfRuntime.buffersCount) {
                      onLoad();
                  }
              }, function () {
                  babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Error("Error when loading buffer named " + buf + " located at " + buffer.uri);
              });
          };
          for (var buf in gltfRuntime.buffers) {
              hasBuffers = true;
              var buffer = gltfRuntime.buffers[buf];
              if (buffer) {
                  processBuffer.bind(this, buf, buffer)();
              }
              else {
                  babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Tools"].Error("No buffer named: " + buf);
              }
          }
          if (!hasBuffers) {
              onLoad();
          }
      };
      GLTFLoader.prototype._createNodes = function (gltfRuntime) {
          var currentScene = gltfRuntime.currentScene;
          if (currentScene) {
              // Only one scene even if multiple scenes are defined
              for (var i = 0; i < currentScene.nodes.length; i++) {
                  traverseNodes(gltfRuntime, currentScene.nodes[i], null);
              }
          }
          else {
              // Load all scenes
              for (var thing in gltfRuntime.scenes) {
                  currentScene = gltfRuntime.scenes[thing];
                  for (var i = 0; i < currentScene.nodes.length; i++) {
                      traverseNodes(gltfRuntime, currentScene.nodes[i], null);
                  }
              }
          }
      };
      GLTFLoader.Extensions = {};
      return GLTFLoader;
  }());
  
  /** @hidden */
  var GLTFLoaderExtension = /** @class */ (function () {
      function GLTFLoaderExtension(name) {
          this._name = name;
      }
      Object.defineProperty(GLTFLoaderExtension.prototype, "name", {
          get: function () {
              return this._name;
          },
          enumerable: true,
          configurable: true
      });
      /**
      * Defines an override for loading the runtime
      * Return true to stop further extensions from loading the runtime
      */
      GLTFLoaderExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
          return false;
      };
      /**
       * Defines an onverride for creating gltf runtime
       * Return true to stop further extensions from creating the runtime
       */
      GLTFLoaderExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
          return false;
      };
      /**
      * Defines an override for loading buffers
      * Return true to stop further extensions from loading this buffer
      */
      GLTFLoaderExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
          return false;
      };
      /**
      * Defines an override for loading texture buffers
      * Return true to stop further extensions from loading this texture data
      */
      GLTFLoaderExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
          return false;
      };
      /**
      * Defines an override for creating textures
      * Return true to stop further extensions from loading this texture
      */
      GLTFLoaderExtension.prototype.createTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
          return false;
      };
      /**
      * Defines an override for loading shader strings
      * Return true to stop further extensions from loading this shader data
      */
      GLTFLoaderExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
          return false;
      };
      /**
      * Defines an override for loading materials
      * Return true to stop further extensions from loading this material
      */
      GLTFLoaderExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
          return false;
      };
      // ---------
      // Utilities
      // ---------
      GLTFLoaderExtension.LoadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
          GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
              return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError);
          }, function () {
              setTimeout(function () {
                  if (!onSuccess) {
                      return;
                  }
                  onSuccess(GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
              });
          });
      };
      GLTFLoaderExtension.LoadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
          GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
              return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError);
          }, function () {
              setTimeout(function () {
                  onSuccess();
              });
          });
      };
      GLTFLoaderExtension.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
          GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
              return loaderExtension.loadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
          }, function () {
              GLTFLoaderBase.LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
          });
      };
      GLTFLoaderExtension.LoadTextureAsync = function (gltfRuntime, id, onSuccess, onError) {
          GLTFLoaderExtension.LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
              if (buffer) {
                  GLTFLoaderExtension.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
              }
          }, onError);
      };
      GLTFLoaderExtension.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
          GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
              return loaderExtension.loadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
          }, function () {
              GLTFLoaderBase.LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
          });
      };
      GLTFLoaderExtension.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
          GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
              return loaderExtension.loadMaterialAsync(gltfRuntime, id, onSuccess, onError);
          }, function () {
              GLTFLoaderBase.LoadMaterialAsync(gltfRuntime, id, onSuccess, onError);
          });
      };
      GLTFLoaderExtension.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
          GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
              return loaderExtension.loadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
          }, function () {
              GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
          });
      };
      GLTFLoaderExtension.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
          GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
              return loaderExtension.createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
          }, function () {
              GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
          });
      };
      GLTFLoaderExtension.ApplyExtensions = function (func, defaultFunc) {
          for (var extensionName in GLTFLoader.Extensions) {
              var loaderExtension = GLTFLoader.Extensions[extensionName];
              if (func(loaderExtension)) {
                  return;
              }
          }
          defaultFunc();
      };
      return GLTFLoaderExtension;
  }());
  
  _glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__["GLTFFileLoader"]._CreateGLTF1Loader = function () { return new GLTFLoader(); };
  
  
  /***/ }),
  
  /***/ "./glTF/1.0/glTFLoaderInterfaces.ts":
  /*!******************************************!*\
    !*** ./glTF/1.0/glTFLoaderInterfaces.ts ***!
    \******************************************/
  /*! exports provided: EComponentType, EShaderType, EParameterType, ETextureWrapMode, ETextureFilterType, ETextureFormat, ECullingType, EBlendingFunction */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EComponentType", function() { return EComponentType; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EShaderType", function() { return EShaderType; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EParameterType", function() { return EParameterType; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ETextureWrapMode", function() { return ETextureWrapMode; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ETextureFilterType", function() { return ETextureFilterType; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ETextureFormat", function() { return ETextureFormat; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ECullingType", function() { return ECullingType; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EBlendingFunction", function() { return EBlendingFunction; });
  /**
  * Enums
  * @hidden
  */
  var EComponentType;
  (function (EComponentType) {
      EComponentType[EComponentType["BYTE"] = 5120] = "BYTE";
      EComponentType[EComponentType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
      EComponentType[EComponentType["SHORT"] = 5122] = "SHORT";
      EComponentType[EComponentType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
      EComponentType[EComponentType["FLOAT"] = 5126] = "FLOAT";
  })(EComponentType || (EComponentType = {}));
  /** @hidden */
  var EShaderType;
  (function (EShaderType) {
      EShaderType[EShaderType["FRAGMENT"] = 35632] = "FRAGMENT";
      EShaderType[EShaderType["VERTEX"] = 35633] = "VERTEX";
  })(EShaderType || (EShaderType = {}));
  /** @hidden */
  var EParameterType;
  (function (EParameterType) {
      EParameterType[EParameterType["BYTE"] = 5120] = "BYTE";
      EParameterType[EParameterType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
      EParameterType[EParameterType["SHORT"] = 5122] = "SHORT";
      EParameterType[EParameterType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
      EParameterType[EParameterType["INT"] = 5124] = "INT";
      EParameterType[EParameterType["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
      EParameterType[EParameterType["FLOAT"] = 5126] = "FLOAT";
      EParameterType[EParameterType["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
      EParameterType[EParameterType["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
      EParameterType[EParameterType["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
      EParameterType[EParameterType["INT_VEC2"] = 35667] = "INT_VEC2";
      EParameterType[EParameterType["INT_VEC3"] = 35668] = "INT_VEC3";
      EParameterType[EParameterType["INT_VEC4"] = 35669] = "INT_VEC4";
      EParameterType[EParameterType["BOOL"] = 35670] = "BOOL";
      EParameterType[EParameterType["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
      EParameterType[EParameterType["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
      EParameterType[EParameterType["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
      EParameterType[EParameterType["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
      EParameterType[EParameterType["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
      EParameterType[EParameterType["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
      EParameterType[EParameterType["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
  })(EParameterType || (EParameterType = {}));
  /** @hidden */
  var ETextureWrapMode;
  (function (ETextureWrapMode) {
      ETextureWrapMode[ETextureWrapMode["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
      ETextureWrapMode[ETextureWrapMode["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
      ETextureWrapMode[ETextureWrapMode["REPEAT"] = 10497] = "REPEAT";
  })(ETextureWrapMode || (ETextureWrapMode = {}));
  /** @hidden */
  var ETextureFilterType;
  (function (ETextureFilterType) {
      ETextureFilterType[ETextureFilterType["NEAREST"] = 9728] = "NEAREST";
      ETextureFilterType[ETextureFilterType["LINEAR"] = 9728] = "LINEAR";
      ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
      ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
      ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
      ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
  })(ETextureFilterType || (ETextureFilterType = {}));
  /** @hidden */
  var ETextureFormat;
  (function (ETextureFormat) {
      ETextureFormat[ETextureFormat["ALPHA"] = 6406] = "ALPHA";
      ETextureFormat[ETextureFormat["RGB"] = 6407] = "RGB";
      ETextureFormat[ETextureFormat["RGBA"] = 6408] = "RGBA";
      ETextureFormat[ETextureFormat["LUMINANCE"] = 6409] = "LUMINANCE";
      ETextureFormat[ETextureFormat["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
  })(ETextureFormat || (ETextureFormat = {}));
  /** @hidden */
  var ECullingType;
  (function (ECullingType) {
      ECullingType[ECullingType["FRONT"] = 1028] = "FRONT";
      ECullingType[ECullingType["BACK"] = 1029] = "BACK";
      ECullingType[ECullingType["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
  })(ECullingType || (ECullingType = {}));
  /** @hidden */
  var EBlendingFunction;
  (function (EBlendingFunction) {
      EBlendingFunction[EBlendingFunction["ZERO"] = 0] = "ZERO";
      EBlendingFunction[EBlendingFunction["ONE"] = 1] = "ONE";
      EBlendingFunction[EBlendingFunction["SRC_COLOR"] = 768] = "SRC_COLOR";
      EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR";
      EBlendingFunction[EBlendingFunction["DST_COLOR"] = 774] = "DST_COLOR";
      EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR";
      EBlendingFunction[EBlendingFunction["SRC_ALPHA"] = 770] = "SRC_ALPHA";
      EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
      EBlendingFunction[EBlendingFunction["DST_ALPHA"] = 772] = "DST_ALPHA";
      EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA";
      EBlendingFunction[EBlendingFunction["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR";
      EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR";
      EBlendingFunction[EBlendingFunction["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA";
      EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA";
      EBlendingFunction[EBlendingFunction["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE";
  })(EBlendingFunction || (EBlendingFunction = {}));
  
  
  /***/ }),
  
  /***/ "./glTF/1.0/glTFLoaderUtils.ts":
  /*!*************************************!*\
    !*** ./glTF/1.0/glTFLoaderUtils.ts ***!
    \*************************************/
  /*! exports provided: GLTFUtils */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFUtils", function() { return GLTFUtils; });
  /* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "./glTF/1.0/glTFLoaderInterfaces.ts");
  /* harmony import */ var babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! babylonjs/Maths/math */ "babylonjs/Misc/observable");
  /* harmony import */ var babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__);
  
  
  
  
  
  /**
  * Utils functions for GLTF
  * @hidden
  */
  var GLTFUtils = /** @class */ (function () {
      function GLTFUtils() {
      }
      /**
       * Sets the given "parameter" matrix
       * @param scene: the Scene object
       * @param source: the source node where to pick the matrix
       * @param parameter: the GLTF technique parameter
       * @param uniformName: the name of the shader's uniform
       * @param shaderMaterial: the shader material
       */
      GLTFUtils.SetMatrix = function (scene, source, parameter, uniformName, shaderMaterial) {
          var mat = null;
          if (parameter.semantic === "MODEL") {
              mat = source.getWorldMatrix();
          }
          else if (parameter.semantic === "PROJECTION") {
              mat = scene.getProjectionMatrix();
          }
          else if (parameter.semantic === "VIEW") {
              mat = scene.getViewMatrix();
          }
          else if (parameter.semantic === "MODELVIEWINVERSETRANSPOSE") {
              mat = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].Transpose(source.getWorldMatrix().multiply(scene.getViewMatrix()).invert());
          }
          else if (parameter.semantic === "MODELVIEW") {
              mat = source.getWorldMatrix().multiply(scene.getViewMatrix());
          }
          else if (parameter.semantic === "MODELVIEWPROJECTION") {
              mat = source.getWorldMatrix().multiply(scene.getTransformMatrix());
          }
          else if (parameter.semantic === "MODELINVERSE") {
              mat = source.getWorldMatrix().invert();
          }
          else if (parameter.semantic === "VIEWINVERSE") {
              mat = scene.getViewMatrix().invert();
          }
          else if (parameter.semantic === "PROJECTIONINVERSE") {
              mat = scene.getProjectionMatrix().invert();
          }
          else if (parameter.semantic === "MODELVIEWINVERSE") {
              mat = source.getWorldMatrix().multiply(scene.getViewMatrix()).invert();
          }
          else if (parameter.semantic === "MODELVIEWPROJECTIONINVERSE") {
              mat = source.getWorldMatrix().multiply(scene.getTransformMatrix()).invert();
          }
          else if (parameter.semantic === "MODELINVERSETRANSPOSE") {
              mat = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].Transpose(source.getWorldMatrix().invert());
          }
          else {
              debugger;
          }
          if (mat) {
              switch (parameter.type) {
                  case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_MAT2:
                      shaderMaterial.setMatrix2x2(uniformName, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].GetAsMatrix2x2(mat));
                      break;
                  case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_MAT3:
                      shaderMaterial.setMatrix3x3(uniformName, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Matrix"].GetAsMatrix3x3(mat));
                      break;
                  case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_MAT4:
                      shaderMaterial.setMatrix(uniformName, mat);
                      break;
                  default: break;
              }
          }
      };
      /**
       * Sets the given "parameter" matrix
       * @param shaderMaterial: the shader material
       * @param uniform: the name of the shader's uniform
       * @param value: the value of the uniform
       * @param type: the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
       */
      GLTFUtils.SetUniform = function (shaderMaterial, uniform, value, type) {
          switch (type) {
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT:
                  shaderMaterial.setFloat(uniform, value);
                  return true;
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_VEC2:
                  shaderMaterial.setVector2(uniform, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector2"].FromArray(value));
                  return true;
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_VEC3:
                  shaderMaterial.setVector3(uniform, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector3"].FromArray(value));
                  return true;
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EParameterType"].FLOAT_VEC4:
                  shaderMaterial.setVector4(uniform, babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Vector4"].FromArray(value));
                  return true;
              default: return false;
          }
      };
      /**
      * Returns the wrap mode of the texture
      * @param mode: the mode value
      */
      GLTFUtils.GetWrapMode = function (mode) {
          switch (mode) {
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureWrapMode"].CLAMP_TO_EDGE: return babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].CLAMP_ADDRESSMODE;
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureWrapMode"].MIRRORED_REPEAT: return babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].MIRROR_ADDRESSMODE;
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureWrapMode"].REPEAT: return babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].WRAP_ADDRESSMODE;
              default: return babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].WRAP_ADDRESSMODE;
          }
      };
      /**
       * Returns the byte stride giving an accessor
       * @param accessor: the GLTF accessor objet
       */
      GLTFUtils.GetByteStrideFromType = function (accessor) {
          // Needs this function since "byteStride" isn't requiered in glTF format
          var type = accessor.type;
          switch (type) {
              case "VEC2": return 2;
              case "VEC3": return 3;
              case "VEC4": return 4;
              case "MAT2": return 4;
              case "MAT3": return 9;
              case "MAT4": return 16;
              default: return 1;
          }
      };
      /**
       * Returns the texture filter mode giving a mode value
       * @param mode: the filter mode value
       */
      GLTFUtils.GetTextureFilterMode = function (mode) {
          switch (mode) {
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].LINEAR:
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].LINEAR_MIPMAP_NEAREST:
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].LINEAR_MIPMAP_LINEAR: return babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].TRILINEAR_SAMPLINGMODE;
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].NEAREST:
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["ETextureFilterType"].NEAREST_MIPMAP_NEAREST: return babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].NEAREST_SAMPLINGMODE;
              default: return babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Texture"].BILINEAR_SAMPLINGMODE;
          }
      };
      GLTFUtils.GetBufferFromBufferView = function (gltfRuntime, bufferView, byteOffset, byteLength, componentType) {
          var byteOffset = bufferView.byteOffset + byteOffset;
          var loadedBufferView = gltfRuntime.loadedBufferViews[bufferView.buffer];
          if (byteOffset + byteLength > loadedBufferView.byteLength) {
              throw new Error("Buffer access is out of range");
          }
          var buffer = loadedBufferView.buffer;
          byteOffset += loadedBufferView.byteOffset;
          switch (componentType) {
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EComponentType"].BYTE: return new Int8Array(buffer, byteOffset, byteLength);
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EComponentType"].UNSIGNED_BYTE: return new Uint8Array(buffer, byteOffset, byteLength);
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EComponentType"].SHORT: return new Int16Array(buffer, byteOffset, byteLength);
              case _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__["EComponentType"].UNSIGNED_SHORT: return new Uint16Array(buffer, byteOffset, byteLength);
              default: return new Float32Array(buffer, byteOffset, byteLength);
          }
      };
      /**
       * Returns a buffer from its accessor
       * @param gltfRuntime: the GLTF runtime
       * @param accessor: the GLTF accessor
       */
      GLTFUtils.GetBufferFromAccessor = function (gltfRuntime, accessor) {
          var bufferView = gltfRuntime.bufferViews[accessor.bufferView];
          var byteLength = accessor.count * GLTFUtils.GetByteStrideFromType(accessor);
          return GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, accessor.byteOffset, byteLength, accessor.componentType);
      };
      /**
       * Decodes a buffer view into a string
       * @param view: the buffer view
       */
      GLTFUtils.DecodeBufferToText = function (view) {
          var result = "";
          var length = view.byteLength;
          for (var i = 0; i < length; ++i) {
              result += String.fromCharCode(view[i]);
          }
          return result;
      };
      /**
       * Returns the default material of gltf. Related to
       * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
       * @param scene: the Babylon.js scene
       */
      GLTFUtils.GetDefaultMaterial = function (scene) {
          if (!GLTFUtils._DefaultMaterial) {
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore["GLTFDefaultMaterialVertexShader"] = [
                  "precision highp float;",
                  "",
                  "uniform mat4 worldView;",
                  "uniform mat4 projection;",
                  "",
                  "attribute vec3 position;",
                  "",
                  "void main(void)",
                  "{",
                  "    gl_Position = projection * worldView * vec4(position, 1.0);",
                  "}"
              ].join("\n");
              babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore["GLTFDefaultMaterialPixelShader"] = [
                  "precision highp float;",
                  "",
                  "uniform vec4 u_emission;",
                  "",
                  "void main(void)",
                  "{",
                  "    gl_FragColor = u_emission;",
                  "}"
              ].join("\n");
              var shaderPath = {
                  vertex: "GLTFDefaultMaterial",
                  fragment: "GLTFDefaultMaterial"
              };
              var options = {
                  attributes: ["position"],
                  uniforms: ["worldView", "projection", "u_emission"],
                  samplers: new Array(),
                  needAlphaBlending: false
              };
              GLTFUtils._DefaultMaterial = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["ShaderMaterial"]("GLTFDefaultMaterial", scene, shaderPath, options);
              GLTFUtils._DefaultMaterial.setColor4("u_emission", new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_1__["Color4"](0.5, 0.5, 0.5, 1.0));
          }
          return GLTFUtils._DefaultMaterial;
      };
      // The GLTF default material
      GLTFUtils._DefaultMaterial = null;
      return GLTFUtils;
  }());
  
  
  
  /***/ }),
  
  /***/ "./glTF/1.0/glTFMaterialsCommonExtension.ts":
  /*!**************************************************!*\
    !*** ./glTF/1.0/glTFMaterialsCommonExtension.ts ***!
    \**************************************************/
  /*! exports provided: GLTFMaterialsCommonExtension */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFMaterialsCommonExtension", function() { return GLTFMaterialsCommonExtension; });
  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../../node_modules/tslib/tslib.es6.js");
  /* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFLoader */ "./glTF/1.0/glTFLoader.ts");
  /* harmony import */ var babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! babylonjs/Maths/math */ "babylonjs/Misc/observable");
  /* harmony import */ var babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__);
  
  
  
  
  
  
  
  
  
  
  
  
  /** @hidden */
  var GLTFMaterialsCommonExtension = /** @class */ (function (_super) {
      tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](GLTFMaterialsCommonExtension, _super);
      function GLTFMaterialsCommonExtension() {
          return _super.call(this, "KHR_materials_common") || this;
      }
      GLTFMaterialsCommonExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
          if (!gltfRuntime.extensions) {
              return false;
          }
          var extension = gltfRuntime.extensions[this.name];
          if (!extension) {
              return false;
          }
          // Create lights
          var lights = extension.lights;
          if (lights) {
              for (var thing in lights) {
                  var light = lights[thing];
                  switch (light.type) {
                      case "ambient":
                          var ambientLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["HemisphericLight"](light.name, new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Vector3"](0, 1, 0), gltfRuntime.scene);
                          var ambient = light.ambient;
                          if (ambient) {
                              ambientLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(ambient.color || [1, 1, 1]);
                          }
                          break;
                      case "point":
                          var pointLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["PointLight"](light.name, new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Vector3"](10, 10, 10), gltfRuntime.scene);
                          var point = light.point;
                          if (point) {
                              pointLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(point.color || [1, 1, 1]);
                          }
                          break;
                      case "directional":
                          var dirLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["DirectionalLight"](light.name, new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Vector3"](0, -1, 0), gltfRuntime.scene);
                          var directional = light.directional;
                          if (directional) {
                              dirLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(directional.color || [1, 1, 1]);
                          }
                          break;
                      case "spot":
                          var spot = light.spot;
                          if (spot) {
                              var spotLight = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["SpotLight"](light.name, new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Vector3"](0, 10, 0), new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Vector3"](0, -1, 0), spot.fallOffAngle || Math.PI, spot.fallOffExponent || 0.0, gltfRuntime.scene);
                              spotLight.diffuse = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(spot.color || [1, 1, 1]);
                          }
                          break;
                      default:
                          babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Tools"].Warn("GLTF Material Common extension: light type \"" + light.type + "\” not supported");
                          break;
                  }
              }
          }
          return false;
      };
      GLTFMaterialsCommonExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
          var material = gltfRuntime.materials[id];
          if (!material || !material.extensions) {
              return false;
          }
          var extension = material.extensions[this.name];
          if (!extension) {
              return false;
          }
          var standardMaterial = new babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["StandardMaterial"](id, gltfRuntime.scene);
          standardMaterial.sideOrientation = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Material"].CounterClockWiseSideOrientation;
          if (extension.technique === "CONSTANT") {
              standardMaterial.disableLighting = true;
          }
          standardMaterial.backFaceCulling = extension.doubleSided === undefined ? false : !extension.doubleSided;
          standardMaterial.alpha = extension.values.transparency === undefined ? 1.0 : extension.values.transparency;
          standardMaterial.specularPower = extension.values.shininess === undefined ? 0.0 : extension.values.shininess;
          // Ambient
          if (typeof extension.values.ambient === "string") {
              this._loadTexture(gltfRuntime, extension.values.ambient, standardMaterial, "ambientTexture", onError);
          }
          else {
              standardMaterial.ambientColor = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(extension.values.ambient || [0, 0, 0]);
          }
          // Diffuse
          if (typeof extension.values.diffuse === "string") {
              this._loadTexture(gltfRuntime, extension.values.diffuse, standardMaterial, "diffuseTexture", onError);
          }
          else {
              standardMaterial.diffuseColor = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(extension.values.diffuse || [0, 0, 0]);
          }
          // Emission
          if (typeof extension.values.emission === "string") {
              this._loadTexture(gltfRuntime, extension.values.emission, standardMaterial, "emissiveTexture", onError);
          }
          else {
              standardMaterial.emissiveColor = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(extension.values.emission || [0, 0, 0]);
          }
          // Specular
          if (typeof extension.values.specular === "string") {
              this._loadTexture(gltfRuntime, extension.values.specular, standardMaterial, "specularTexture", onError);
          }
          else {
              standardMaterial.specularColor = babylonjs_Maths_math__WEBPACK_IMPORTED_MODULE_2__["Color3"].FromArray(extension.values.specular || [0, 0, 0]);
          }
          return true;
      };
      GLTFMaterialsCommonExtension.prototype._loadTexture = function (gltfRuntime, id, material, propertyPath, onError) {
          // Create buffer from texture url
          _glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoaderBase"].LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
              // Create texture from buffer
              _glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoaderBase"].CreateTextureAsync(gltfRuntime, id, buffer, function (texture) { return material[propertyPath] = texture; }, onError);
          }, onError);
      };
      return GLTFMaterialsCommonExtension;
  }(_glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoaderExtension"]));
  
  _glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoader"].RegisterExtension(new GLTFMaterialsCommonExtension());
  
  
  /***/ }),
  
  /***/ "./glTF/1.0/index.ts":
  /*!***************************!*\
    !*** ./glTF/1.0/index.ts ***!
    \***************************/
  /*! exports provided: GLTFBinaryExtension, GLTFLoaderBase, GLTFLoader, GLTFLoaderExtension, EComponentType, EShaderType, EParameterType, ETextureWrapMode, ETextureFilterType, ETextureFormat, ECullingType, EBlendingFunction, GLTFUtils, GLTFMaterialsCommonExtension */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony import */ var _glTFBinaryExtension__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFBinaryExtension */ "./glTF/1.0/glTFBinaryExtension.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFBinaryExtension", function() { return _glTFBinaryExtension__WEBPACK_IMPORTED_MODULE_0__["GLTFBinaryExtension"]; });
  
  /* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFLoader */ "./glTF/1.0/glTFLoader.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderBase", function() { return _glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoaderBase"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoader", function() { return _glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoader"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderExtension", function() { return _glTFLoader__WEBPACK_IMPORTED_MODULE_1__["GLTFLoaderExtension"]; });
  
  /* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "./glTF/1.0/glTFLoaderInterfaces.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "EComponentType", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["EComponentType"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "EShaderType", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["EShaderType"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "EParameterType", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["EParameterType"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ETextureWrapMode", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["ETextureWrapMode"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ETextureFilterType", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["ETextureFilterType"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ETextureFormat", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["ETextureFormat"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ECullingType", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["ECullingType"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "EBlendingFunction", function() { return _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__["EBlendingFunction"]; });
  
  /* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./glTFLoaderUtils */ "./glTF/1.0/glTFLoaderUtils.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFUtils", function() { return _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_3__["GLTFUtils"]; });
  
  /* harmony import */ var _glTFMaterialsCommonExtension__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./glTFMaterialsCommonExtension */ "./glTF/1.0/glTFMaterialsCommonExtension.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFMaterialsCommonExtension", function() { return _glTFMaterialsCommonExtension__WEBPACK_IMPORTED_MODULE_4__["GLTFMaterialsCommonExtension"]; });
  
  
  
  
  
  
  
  
  /***/ }),
  
  /***/ "./glTF/glTFFileLoader.ts":
  /*!********************************!*\
    !*** ./glTF/glTFFileLoader.ts ***!
    \********************************/
  /*! exports provided: GLTFLoaderCoordinateSystemMode, GLTFLoaderAnimationStartMode, GLTFLoaderState, GLTFFileLoader */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderCoordinateSystemMode", function() { return GLTFLoaderCoordinateSystemMode; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderAnimationStartMode", function() { return GLTFLoaderAnimationStartMode; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderState", function() { return GLTFLoaderState; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GLTFFileLoader", function() { return GLTFFileLoader; });
  /* harmony import */ var babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! babylonjs/Misc/observable */ "babylonjs/Misc/observable");
  /* harmony import */ var babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__);
  
  
  
  
  /**
   * Mode that determines the coordinate system to use.
   */
  var GLTFLoaderCoordinateSystemMode;
  (function (GLTFLoaderCoordinateSystemMode) {
      /**
       * Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene.
       */
      GLTFLoaderCoordinateSystemMode[GLTFLoaderCoordinateSystemMode["AUTO"] = 0] = "AUTO";
      /**
       * Sets the useRightHandedSystem flag on the scene.
       */
      GLTFLoaderCoordinateSystemMode[GLTFLoaderCoordinateSystemMode["FORCE_RIGHT_HANDED"] = 1] = "FORCE_RIGHT_HANDED";
  })(GLTFLoaderCoordinateSystemMode || (GLTFLoaderCoordinateSystemMode = {}));
  /**
   * Mode that determines what animations will start.
   */
  var GLTFLoaderAnimationStartMode;
  (function (GLTFLoaderAnimationStartMode) {
      /**
       * No animation will start.
       */
      GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["NONE"] = 0] = "NONE";
      /**
       * The first animation will start.
       */
      GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["FIRST"] = 1] = "FIRST";
      /**
       * All animations will start.
       */
      GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["ALL"] = 2] = "ALL";
  })(GLTFLoaderAnimationStartMode || (GLTFLoaderAnimationStartMode = {}));
  /**
   * Loader state.
   */
  var GLTFLoaderState;
  (function (GLTFLoaderState) {
      /**
       * The asset is loading.
       */
      GLTFLoaderState[GLTFLoaderState["LOADING"] = 0] = "LOADING";
      /**
       * The asset is ready for rendering.
       */
      GLTFLoaderState[GLTFLoaderState["READY"] = 1] = "READY";
      /**
       * The asset is completely loaded.
       */
      GLTFLoaderState[GLTFLoaderState["COMPLETE"] = 2] = "COMPLETE";
  })(GLTFLoaderState || (GLTFLoaderState = {}));
  /**
   * File loader for loading glTF files into a scene.
   */
  var GLTFFileLoader = /** @class */ (function () {
      function GLTFFileLoader() {
          // --------------
          // Common options
          // --------------
          /**
           * Raised when the asset has been parsed
           */
          this.onParsedObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          // ----------
          // V2 options
          // ----------
          /**
           * The coordinate system mode. Defaults to AUTO.
           */
          this.coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO;
          /**
          * The animation start mode. Defaults to FIRST.
          */
          this.animationStartMode = GLTFLoaderAnimationStartMode.FIRST;
          /**
           * Defines if the loader should compile materials before raising the success callback. Defaults to false.
           */
          this.compileMaterials = false;
          /**
           * Defines if the loader should also compile materials with clip planes. Defaults to false.
           */
          this.useClipPlane = false;
          /**
           * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
           */
          this.compileShadowGenerators = false;
          /**
           * Defines if the Alpha blended materials are only applied as coverage.
           * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
           * If true, no extra effects are applied to transparent pixels.
           */
          this.transparencyAsCoverage = false;
          /**
           * Function called before loading a url referenced by the asset.
           */
          this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
          /**
           * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
           */
          this.onMeshLoadedObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
           */
          this.onTextureLoadedObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Observable raised when the loader creates a material after parsing the glTF properties of the material.
           */
          this.onMaterialLoadedObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
           */
          this.onCameraLoadedObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Observable raised when the asset is completely loaded, immediately before the loader is disposed.
           * For assets with LODs, raised when all of the LODs are complete.
           * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
           */
          this.onCompleteObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Observable raised when an error occurs.
           */
          this.onErrorObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Observable raised after the loader is disposed.
           */
          this.onDisposeObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Observable raised after a loader extension is created.
           * Set additional options for a loader extension in this event.
           */
          this.onExtensionLoadedObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          /**
           * Defines if the loader should validate the asset.
           */
          this.validate = false;
          /**
           * Observable raised after validation when validate is set to true. The event data is the result of the validation.
           */
          this.onValidatedObservable = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Observable"]();
          this._loader = null;
          /**
           * Name of the loader ("gltf")
           */
          this.name = "gltf";
          /**
           * Supported file extensions of the loader (.gltf, .glb)
           */
          this.extensions = {
              ".gltf": { isBinary: false },
              ".glb": { isBinary: true }
          };
          this._logIndentLevel = 0;
          this._loggingEnabled = false;
          /** @hidden */
          this._log = this._logDisabled;
          this._capturePerformanceCounters = false;
          /** @hidden */
          this._startPerformanceCounter = this._startPerformanceCounterDisabled;
          /** @hidden */
          this._endPerformanceCounter = this._endPerformanceCounterDisabled;
      }
      Object.defineProperty(GLTFFileLoader.prototype, "onParsed", {
          /**
           * Raised when the asset has been parsed
           */
          set: function (callback) {
              if (this._onParsedObserver) {
                  this.onParsedObservable.remove(this._onParsedObserver);
              }
              this._onParsedObserver = this.onParsedObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onMeshLoaded", {
          /**
           * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
           */
          set: function (callback) {
              if (this._onMeshLoadedObserver) {
                  this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);
              }
              this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onTextureLoaded", {
          /**
           * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
           */
          set: function (callback) {
              if (this._onTextureLoadedObserver) {
                  this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver);
              }
              this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onMaterialLoaded", {
          /**
           * Callback raised when the loader creates a material after parsing the glTF properties of the material.
           */
          set: function (callback) {
              if (this._onMaterialLoadedObserver) {
                  this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver);
              }
              this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onCameraLoaded", {
          /**
           * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
           */
          set: function (callback) {
              if (this._onCameraLoadedObserver) {
                  this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver);
              }
              this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onComplete", {
          /**
           * Callback raised when the asset is completely loaded, immediately before the loader is disposed.
           * For assets with LODs, raised when all of the LODs are complete.
           * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
           */
          set: function (callback) {
              if (this._onCompleteObserver) {
                  this.onCompleteObservable.remove(this._onCompleteObserver);
              }
              this._onCompleteObserver = this.onCompleteObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onError", {
          /**
           * Callback raised when an error occurs.
           */
          set: function (callback) {
              if (this._onErrorObserver) {
                  this.onErrorObservable.remove(this._onErrorObserver);
              }
              this._onErrorObserver = this.onErrorObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onDispose", {
          /**
           * Callback raised after the loader is disposed.
           */
          set: function (callback) {
              if (this._onDisposeObserver) {
                  this.onDisposeObservable.remove(this._onDisposeObserver);
              }
              this._onDisposeObserver = this.onDisposeObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onExtensionLoaded", {
          /**
           * Callback raised after a loader extension is created.
           */
          set: function (callback) {
              if (this._onExtensionLoadedObserver) {
                  this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver);
              }
              this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "loggingEnabled", {
          /**
           * Defines if the loader logging is enabled.
           */
          get: function () {
              return this._loggingEnabled;
          },
          set: function (value) {
              if (this._loggingEnabled === value) {
                  return;
              }
              this._loggingEnabled = value;
              if (this._loggingEnabled) {
                  this._log = this._logEnabled;
              }
              else {
                  this._log = this._logDisabled;
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "capturePerformanceCounters", {
          /**
           * Defines if the loader should capture performance counters.
           */
          get: function () {
              return this._capturePerformanceCounters;
          },
          set: function (value) {
              if (this._capturePerformanceCounters === value) {
                  return;
              }
              this._capturePerformanceCounters = value;
              if (this._capturePerformanceCounters) {
                  this._startPerformanceCounter = this._startPerformanceCounterEnabled;
                  this._endPerformanceCounter = this._endPerformanceCounterEnabled;
              }
              else {
                  this._startPerformanceCounter = this._startPerformanceCounterDisabled;
                  this._endPerformanceCounter = this._endPerformanceCounterDisabled;
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(GLTFFileLoader.prototype, "onValidated", {
          /**
           * Callback raised after a loader extension is created.
           */
          set: function (callback) {
              if (this._onValidatedObserver) {
                  this.onValidatedObservable.remove(this._onValidatedObserver);
              }
              this._onValidatedObserver = this.onValidatedObservable.add(callback);
          },
          enumerable: true,
          configurable: true
      });
      /**
       * Disposes the loader, releases resources during load, and cancels any outstanding requests.
       */
      GLTFFileLoader.prototype.dispose = function () {
          if (this._loader) {
              this._loader.dispose();
              this._loader = null;
          }
          this._clear();
          this.onDisposeObservable.notifyObservers(undefined);
          this.onDisposeObservable.clear();
      };
      /** @hidden */
      GLTFFileLoader.prototype._clear = function () {
          this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
          this.onMeshLoadedObservable.clear();
          this.onTextureLoadedObservable.clear();
          this.onMaterialLoadedObservable.clear();
          this.onCameraLoadedObservable.clear();
          this.onCompleteObservable.clear();
          this.onExtensionLoadedObservable.clear();
      };
      /**
       * Imports one or more meshes from the loaded glTF data and adds them to the scene
       * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
       * @param scene the scene the meshes should be added to
       * @param data the glTF data to load
       * @param rootUrl root url to load from
       * @param onProgress event that fires when loading progress has occured
       * @param fileName Defines the name of the file to load
       * @returns a promise containg the loaded meshes, particles, skeletons and animations
       */
      GLTFFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress, fileName) {
          var _this = this;
          return this._parseAsync(scene, data, rootUrl, fileName).then(function (loaderData) {
              _this._log("Loading " + (fileName || ""));
              _this._loader = _this._getLoader(loaderData);
              return _this._loader.importMeshAsync(meshesNames, scene, loaderData, rootUrl, onProgress, fileName);
          });
      };
      /**
       * Imports all objects from the loaded glTF data and adds them to the scene
       * @param scene the scene the objects should be added to
       * @param data the glTF data to load
       * @param rootUrl root url to load from
       * @param onProgress event that fires when loading progress has occured
       * @param fileName Defines the name of the file to load
       * @returns a promise which completes when objects have been loaded to the scene
       */
      GLTFFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
          var _this = this;
          return this._parseAsync(scene, data, rootUrl, fileName).then(function (loaderData) {
              _this._log("Loading " + (fileName || ""));
              _this._loader = _this._getLoader(loaderData);
              return _this._loader.loadAsync(scene, loaderData, rootUrl, onProgress, fileName);
          });
      };
      /**
       * Load into an asset container.
       * @param scene The scene to load into
       * @param data The data to import
       * @param rootUrl The root url for scene and resources
       * @param onProgress The callback when the load progresses
       * @param fileName Defines the name of the file to load
       * @returns The loaded asset container
       */
      GLTFFileLoader.prototype.loadAssetContainerAsync = function (scene, data, rootUrl, onProgress, fileName) {
          var _this = this;
          return this._parseAsync(scene, data, rootUrl, fileName).then(function (loaderData) {
              _this._log("Loading " + (fileName || ""));
              _this._loader = _this._getLoader(loaderData);
              // Get materials/textures when loading to add to container
              var materials = [];
              _this.onMaterialLoadedObservable.add(function (material) {
                  materials.push(material);
              });
              var textures = [];
              _this.onTextureLoadedObservable.add(function (texture) {
                  textures.push(texture);
              });
              return _this._loader.importMeshAsync(null, scene, loaderData, rootUrl, onProgress, fileName).then(function (result) {
                  var container = new babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["AssetContainer"](scene);
                  Array.prototype.push.apply(container.meshes, result.meshes);
                  Array.prototype.push.apply(container.particleSystems, result.particleSystems);
                  Array.prototype.push.apply(container.skeletons, result.skeletons);
                  Array.prototype.push.apply(container.animationGroups, result.animationGroups);
                  Array.prototype.push.apply(container.materials, materials);
                  Array.prototype.push.apply(container.textures, textures);
                  container.removeAllFromScene();
                  return container;
              });
          });
      };
      /**
       * If the data string can be loaded directly.
       * @param data string contianing the file data
       * @returns if the data can be loaded directly
       */
      GLTFFileLoader.prototype.canDirectLoad = function (data) {
          return ((data.indexOf("scene") !== -1) && (data.indexOf("node") !== -1));
      };
      /**
       * Instantiates a glTF file loader plugin.
       * @returns the created plugin
       */
      GLTFFileLoader.prototype.createPlugin = function () {
          return new GLTFFileLoader();
      };
      Object.defineProperty(GLTFFileLoader.prototype, "loaderState", {
          /**
           * The loader state or null if the loader is not active.
           */
          get: function () {
              return this._loader ? this._loader.state : null;
          },
          enumerable: true,
          configurable: true
      });
      /**
       * Returns a promise that resolves when the asset is completely loaded.
       * @returns a promise that resolves when the asset is completely loaded.
       */
      GLTFFileLoader.prototype.whenCompleteAsync = function () {
          var _this = this;
          return new Promise(function (resolve, reject) {
              _this.onCompleteObservable.addOnce(function () {
                  resolve();
              });
              _this.onErrorObservable.addOnce(function (reason) {
                  reject(reason);
              });
          });
      };
      GLTFFileLoader.prototype._parseAsync = function (scene, data, rootUrl, fileName) {
          var _this = this;
          return Promise.resolve().then(function () {
              return _this._validateAsync(scene, data, rootUrl, fileName).then(function () {
                  var unpacked = (data instanceof ArrayBuffer) ? _this._unpackBinary(data) : { json: data, bin: null };
                  _this._startPerformanceCounter("Parse JSON");
                  _this._log("JSON length: " + unpacked.json.length);
                  var loaderData = {
                      json: JSON.parse(unpacked.json),
                      bin: unpacked.bin
                  };
                  _this._endPerformanceCounter("Parse JSON");
                  _this.onParsedObservable.notifyObservers(loaderData);
                  _this.onParsedObservable.clear();
                  return loaderData;
              });
          });
      };
      GLTFFileLoader.prototype._validateAsync = function (scene, data, rootUrl, fileName) {
          var _this = this;
          if (!this.validate || typeof GLTFValidator === "undefined") {
              return Promise.resolve();
          }
          this._startPerformanceCounter("Validate JSON");
          var options = {
              externalResourceFunction: function (uri) {
                  return _this.preprocessUrlAsync(rootUrl + uri)
                      .then(function (url) { return scene._loadFileAsync(url, true, true); })
                      .then(function (data) { return new Uint8Array(data); });
              }
          };
          if (fileName && fileName.substr(0, 5) !== "data:") {
              options.uri = (rootUrl === "file:" ? fileName : "" + rootUrl + fileName);
          }
          var promise = (data instanceof ArrayBuffer)
              ? GLTFValidator.validateBytes(new Uint8Array(data), options)
              : GLTFValidator.validateString(data, options);
          return promise.then(function (result) {
              _this._endPerformanceCounter("Validate JSON");
              _this.onValidatedObservable.notifyObservers(result);
              _this.onValidatedObservable.clear();
          }, function (reason) {
              _this._endPerformanceCounter("Validate JSON");
              babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Tools"].Warn("Failed to validate: " + reason);
              _this.onValidatedObservable.clear();
          });
      };
      GLTFFileLoader.prototype._getLoader = function (loaderData) {
          var asset = loaderData.json.asset || {};
          this._log("Asset version: " + asset.version);
          asset.minVersion && this._log("Asset minimum version: " + asset.minVersion);
          asset.generator && this._log("Asset generator: " + asset.generator);
          var version = GLTFFileLoader._parseVersion(asset.version);
          if (!version) {
              throw new Error("Invalid version: " + asset.version);
          }
          if (asset.minVersion !== undefined) {
              var minVersion = GLTFFileLoader._parseVersion(asset.minVersion);
              if (!minVersion) {
                  throw new Error("Invalid minimum version: " + asset.minVersion);
              }
              if (GLTFFileLoader._compareVersion(minVersion, { major: 2, minor: 0 }) > 0) {
                  throw new Error("Incompatible minimum version: " + asset.minVersion);
              }
          }
          var createLoaders = {
              1: GLTFFileLoader._CreateGLTF1Loader,
              2: GLTFFileLoader._CreateGLTF2Loader
          };
          var createLoader = createLoaders[version.major];
          if (!createLoader) {
              throw new Error("Unsupported version: " + asset.version);
          }
          return createLoader(this);
      };
      GLTFFileLoader.prototype._unpackBinary = function (data) {
          this._startPerformanceCounter("Unpack binary");
          this._log("Binary length: " + data.byteLength);
          var Binary = {
              Magic: 0x46546C67
          };
          var binaryReader = new BinaryReader(data);
          var magic = binaryReader.readUint32();
          if (magic !== Binary.Magic) {
              throw new Error("Unexpected magic: " + magic);
          }
          var version = binaryReader.readUint32();
          if (this.loggingEnabled) {
              this._log("Binary version: " + version);
          }
          var unpacked;
          switch (version) {
              case 1: {
                  unpacked = this._unpackBinaryV1(binaryReader);
                  break;
              }
              case 2: {
                  unpacked = this._unpackBinaryV2(binaryReader);
                  break;
              }
              default: {
                  throw new Error("Unsupported version: " + version);
              }
          }
          this._endPerformanceCounter("Unpack binary");
          return unpacked;
      };
      GLTFFileLoader.prototype._unpackBinaryV1 = function (binaryReader) {
          var ContentFormat = {
              JSON: 0
          };
          var length = binaryReader.readUint32();
          if (length != binaryReader.getLength()) {
              throw new Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
          }
          var contentLength = binaryReader.readUint32();
          var contentFormat = binaryReader.readUint32();
          var content;
          switch (contentFormat) {
              case ContentFormat.JSON: {
                  content = GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(contentLength));
                  break;
              }
              default: {
                  throw new Error("Unexpected content format: " + contentFormat);
              }
          }
          var bytesRemaining = binaryReader.getLength() - binaryReader.getPosition();
          var body = binaryReader.readUint8Array(bytesRemaining);
          return {
              json: content,
              bin: body
          };
      };
      GLTFFileLoader.prototype._unpackBinaryV2 = function (binaryReader) {
          var ChunkFormat = {
              JSON: 0x4E4F534A,
              BIN: 0x004E4942
          };
          var length = binaryReader.readUint32();
          if (length !== binaryReader.getLength()) {
              throw new Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
          }
          // JSON chunk
          var chunkLength = binaryReader.readUint32();
          var chunkFormat = binaryReader.readUint32();
          if (chunkFormat !== ChunkFormat.JSON) {
              throw new Error("First chunk format is not JSON");
          }
          var json = GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(chunkLength));
          // Look for BIN chunk
          var bin = null;
          while (binaryReader.getPosition() < binaryReader.getLength()) {
              var chunkLength_1 = binaryReader.readUint32();
              var chunkFormat_1 = binaryReader.readUint32();
              switch (chunkFormat_1) {
                  case ChunkFormat.JSON: {
                      throw new Error("Unexpected JSON chunk");
                  }
                  case ChunkFormat.BIN: {
                      bin = binaryReader.readUint8Array(chunkLength_1);
                      break;
                  }
                  default: {
                      // ignore unrecognized chunkFormat
                      binaryReader.skipBytes(chunkLength_1);
                      break;
                  }
              }
          }
          return {
              json: json,
              bin: bin
          };
      };
      GLTFFileLoader._parseVersion = function (version) {
          if (version === "1.0" || version === "1.0.1") {
              return {
                  major: 1,
                  minor: 0
              };
          }
          var match = (version + "").match(/^(\d+)\.(\d+)/);
          if (!match) {
              return null;
          }
          return {
              major: parseInt(match[1]),
              minor: parseInt(match[2])
          };
      };
      GLTFFileLoader._compareVersion = function (a, b) {
          if (a.major > b.major) {
              return 1;
          }
          if (a.major < b.major) {
              return -1;
          }
          if (a.minor > b.minor) {
              return 1;
          }
          if (a.minor < b.minor) {
              return -1;
          }
          return 0;
      };
      GLTFFileLoader._decodeBufferToText = function (buffer) {
          if (typeof TextDecoder !== "undefined") {
              return new TextDecoder().decode(buffer);
          }
          var result = "";
          var length = buffer.byteLength;
          for (var i = 0; i < length; i++) {
              result += String.fromCharCode(buffer[i]);
          }
          return result;
      };
      /** @hidden */
      GLTFFileLoader.prototype._logOpen = function (message) {
          this._log(message);
          this._logIndentLevel++;
      };
      /** @hidden */
      GLTFFileLoader.prototype._logClose = function () {
          --this._logIndentLevel;
      };
      GLTFFileLoader.prototype._logEnabled = function (message) {
          var spaces = GLTFFileLoader._logSpaces.substr(0, this._logIndentLevel * 2);
          babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Tools"].Log("" + spaces + message);
      };
      GLTFFileLoader.prototype._logDisabled = function (message) {
      };
      GLTFFileLoader.prototype._startPerformanceCounterEnabled = function (counterName) {
          babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Tools"].StartPerformanceCounter(counterName);
      };
      GLTFFileLoader.prototype._startPerformanceCounterDisabled = function (counterName) {
      };
      GLTFFileLoader.prototype._endPerformanceCounterEnabled = function (counterName) {
          babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["Tools"].EndPerformanceCounter(counterName);
      };
      GLTFFileLoader.prototype._endPerformanceCounterDisabled = function (counterName) {
      };
      // ----------
      // V1 options
      // ----------
      /**
       * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.
       * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.
       * Defaults to true.
       * @hidden
       */
      GLTFFileLoader.IncrementalLoading = true;
      /**
       * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.
       * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.
       * @hidden
       */
      GLTFFileLoader.HomogeneousCoordinates = false;
      GLTFFileLoader._logSpaces = "                                ";
      return GLTFFileLoader;
  }());
  
  var BinaryReader = /** @class */ (function () {
      function BinaryReader(arrayBuffer) {
          this._arrayBuffer = arrayBuffer;
          this._dataView = new DataView(arrayBuffer);
          this._byteOffset = 0;
      }
      BinaryReader.prototype.getPosition = function () {
          return this._byteOffset;
      };
      BinaryReader.prototype.getLength = function () {
          return this._arrayBuffer.byteLength;
      };
      BinaryReader.prototype.readUint32 = function () {
          var value = this._dataView.getUint32(this._byteOffset, true);
          this._byteOffset += 4;
          return value;
      };
      BinaryReader.prototype.readUint8Array = function (length) {
          var value = new Uint8Array(this._arrayBuffer, this._byteOffset, length);
          this._byteOffset += length;
          return value;
      };
      BinaryReader.prototype.skipBytes = function (length) {
          this._byteOffset += length;
      };
      return BinaryReader;
  }());
  if (babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["SceneLoader"]) {
      babylonjs_Misc_observable__WEBPACK_IMPORTED_MODULE_0__["SceneLoader"].RegisterPlugin(new GLTFFileLoader());
  }
  
  
  /***/ }),
  
  /***/ "./legacy/legacy-glTF.ts":
  /*!*******************************!*\
    !*** ./legacy/legacy-glTF.ts ***!
    \*******************************/
  /*! exports provided: GLTFLoaderCoordinateSystemMode, GLTFLoaderAnimationStartMode, GLTFLoaderState, GLTFFileLoader */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTF/glTFFileLoader */ "./glTF/glTFFileLoader.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderCoordinateSystemMode", function() { return _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__["GLTFLoaderCoordinateSystemMode"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderAnimationStartMode", function() { return _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__["GLTFLoaderAnimationStartMode"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderState", function() { return _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__["GLTFLoaderState"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFFileLoader", function() { return _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__["GLTFFileLoader"]; });
  
  
  /**
   * This is the entry point for the UMD module.
   * The entry point for a future ESM package should be index.ts
   */
  var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : undefined);
  if (typeof globalObject !== "undefined") {
      globalObject.BABYLON = globalObject.BABYLON || {};
      for (var key in _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__) {
          globalObject.BABYLON[key] = _glTF_glTFFileLoader__WEBPACK_IMPORTED_MODULE_0__[key];
      }
  }
  
  
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../node_modules/webpack/buildin/global.js */ "../../node_modules/webpack/buildin/global.js")))
  
  /***/ }),
  
  /***/ "./legacy/legacy-glTF1.ts":
  /*!********************************!*\
    !*** ./legacy/legacy-glTF1.ts ***!
    \********************************/
  /*! exports provided: GLTF1 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var _glTF_1_0__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTF/1.0 */ "./glTF/1.0/index.ts");
  /* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "GLTF1", function() { return _glTF_1_0__WEBPACK_IMPORTED_MODULE_0__; });
  
  /**
   * This is the entry point for the UMD module.
   * The entry point for a future ESM package should be index.ts
   */
  var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : undefined);
  if (typeof globalObject !== "undefined") {
      globalObject.BABYLON = globalObject.BABYLON || {};
      globalObject.BABYLON.GLTF1 = globalObject.BABYLON.GLTF1 || {};
      for (var key in _glTF_1_0__WEBPACK_IMPORTED_MODULE_0__) {
          globalObject.BABYLON.GLTF1[key] = _glTF_1_0__WEBPACK_IMPORTED_MODULE_0__[key];
      }
  }
  
  
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../node_modules/webpack/buildin/global.js */ "../../node_modules/webpack/buildin/global.js")))
  
  /***/ }),
  
  /***/ "./legacy/legacy-glTF1FileLoader.ts":
  /*!******************************************!*\
    !*** ./legacy/legacy-glTF1FileLoader.ts ***!
    \******************************************/
  /*! exports provided: GLTF1, GLTFLoaderCoordinateSystemMode, GLTFLoaderAnimationStartMode, GLTFLoaderState, GLTFFileLoader */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony import */ var _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./legacy-glTF */ "./legacy/legacy-glTF.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderCoordinateSystemMode", function() { return _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__["GLTFLoaderCoordinateSystemMode"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderAnimationStartMode", function() { return _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__["GLTFLoaderAnimationStartMode"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFLoaderState", function() { return _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__["GLTFLoaderState"]; });
  
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTFFileLoader", function() { return _legacy_glTF__WEBPACK_IMPORTED_MODULE_0__["GLTFFileLoader"]; });
  
  /* harmony import */ var _legacy_glTF1__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./legacy-glTF1 */ "./legacy/legacy-glTF1.ts");
  /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "GLTF1", function() { return _legacy_glTF1__WEBPACK_IMPORTED_MODULE_1__["GLTF1"]; });
  
  
  
  
  
  /***/ }),
  
  /***/ "babylonjs/Misc/observable":
  /*!****************************************************************************************************!*\
    !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!
    \****************************************************************************************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  module.exports = __WEBPACK_EXTERNAL_MODULE_babylonjs_Misc_observable__;
  
  /***/ })
  
  /******/ });
  });
  //# sourceMappingURL=babylon.glTF1FileLoader.js.map