{"version":3,"sources":["vs/vs/loader.js"],"names":["_amdLoaderGlobal","this","_commonjsGlobal","global","AMDLoader","Environment","_detected","_isWindows","_isNode","_isElectronRenderer","_isWebWorker","Object","defineProperty","prototype","get","_detect","enumerable","configurable","module","exports","process","versions","electron","type","importScripts","navigator","userAgent","indexOf","platform","LoaderEvent","detail","timestamp","LoaderEventRecorder","loaderAvailableTimestamp","_events","record","push","Utilities","getHighPerformanceTimestamp","getEvents","NullLoaderEventRecorder","INSTANCE","fileUriToFilePath","isWindows","uri","decodeURI","replace","test","substr","startsWith","haystack","needle","length","endsWith","containsQueryString","url","isAbsolutePath","forEachProperty","obj","callback","key","hasOwnProperty","isEmpty","recursiveClone","result","Array","isArray","value","generateAnonymousModule","NEXT_ANONYMOUS_ID","isAnonymousModule","id","PERFORMANCE_NOW_PROBED","HAS_PERFORMANCE_NOW","performance","now","Date","ConfigurationOptionsUtil","validateConfigurationOptions","options","defaultOnError","err","errorCode","console","error","moduleId","stack","neededBy","baseUrl","isBuild","paths","config","catchError","urlArgs","onError","ignoreDuplicateModules","cspNonce","nodeModules","nodeCachedData","seed","writeDelay","onData","warn","path","undefined","mergeConfigurationOptions","overwrite","base","concat","key2","value2","Configuration","env","_env","_createIgnoreDuplicateModulesMap","_createNodeModulesMap","_createSortedPathsRules","nodeRequire","main","filename","isNode","nodeMain","dirnameIndex","Math","max","lastIndexOf","substring","ignoreDuplicateModulesMap","i","nodeModulesMap","create","_i","_a","nodeModule","_this","sortedPathsRules","from","to","sort","a","b","cloneAndMerge","getOptionsLiteral","_applyPaths","pathRule","len","j","lenJ","_addUrlArgsToUrl","_addUrlArgsIfNecessaryToUrl","_addUrlArgsIfNecessaryToUrls","urls","moduleIdToPaths","results","requireToUrl","isDuplicateMessageIgnoredFor","getConfigForModule","shouldCatchError","shouldRecordStats","recordStats","OnlyOnceScriptLoader","_scriptLoader","_callbackMap","load","moduleManager","scriptSrc","errorback","isWebWorker","WorkerScriptLoader","NodeScriptLoader","BrowserScriptLoader","scriptCallbacks","triggerCallback","triggerErrorback","attachListeners","script","unbind","removeEventListener","loadEventListener","errorEventListener","e","addEventListener","document","createElement","setAttribute","getConfig","getElementsByTagName","appendChild","_didInitialize","_didPatchNodeRequire","_hasCreateCachedData","_init","_fs","_vm","_path","_crypto","Script","_initNodeRequire","that","Module","_compile","content","wrapper","wrap","cachedDataPath","_getCachedDataPath","cachedData","readFileSync","produceCachedData","compileWrapper","runInThisContext","dirname","require","mod","constructor","resolve","request","_resolveFilename","mainModule","extensions","_extensions","cache","_cache","makeRequireFunction","args","Buffer","apply","_processCachedData","opts","nodeInstrumenter","c","recorder","getRecorder","pieces","split","moduleExports_1","enqueueDefineAnonymousModule","readFile","encoding","data","normalizedScriptSrc","normalize","vmScriptSrc","isElectronRenderer","driveLetterMatch","match","toUpperCase","contents","prefix","charCodeAt","_BOM","cachedDataPath_1","_err","_loadAndEvalScript","r","globalDefineFunc","getGlobalAMDDefineFunc","receivedDefineCall","localDefineFunc","arguments","amd","call","getGlobalAMDRequireFunc","Error","basedir","hash","createHash","update","digest","basename","join","createCachedData","cachedDataRejected","_runSoon","unlink","cachedDataProduced","writeFile","minTimeout","timeout","ceil","random","setTimeout","createScriptLoader","ModuleIdResolver","fromModuleId","lastSlash","fromModulePath","_normalizeModuleId","pattern","resolveModule","ROOT","strId","dependencies","moduleIdResolver","_callback","_errorback","exportsPassedIn","unresolvedDependenciesCount","_isComplete","_safeInvokeFunction","returnedValue","producedError","_invokeFactory","strModuleId","dependenciesValues","complete","onDependencyError","isComplete","ModuleIdProvider","_nextId","_strModuleIdToIntModuleId","Map","_intModuleIdToStrModuleId","getModuleId","getMaxModuleId","set","getStrModuleId","RegularDependency","EXPORTS","MODULE","REQUIRE","PluginDependency","pluginId","pluginParam","ModuleManager","scriptLoader","defineFunc","requireFunc","_loaderAvailableTimestamp","_defineFunc","_requireFunc","_moduleIdProvider","_config","_modules2","_knownModules2","_inverseDependencies2","_inversePluginDependencies2","_currentAnnonymousDefineCall","_recorder","_buildInfoPath","_buildInfoDefineStack","_buildInfoDependencies","reset","_findRelevantLocationInStack","str","normalizedPath","stackPieces","m","stackPath","stackLine","stackColumn","trimPathOffset","line","parseInt","col","getBuildInfo","resultLen","location_1","defineStack","defineLocation","shim","getLoaderEvents","defineModule","_normalizeDependencies","map","dep","_resolve","_normalizeDependency","dependency","bangIndex","strPluginId","dependencyId","_relativeRequire","synchronousRequire","_strModuleId","configure","params","shouldOverwrite","oldShouldRecordStats","_onLoad","defineCall","_createLoadError","intModuleId","_onLoadError","seenModuleId","someoneNotified","queue","queueElement","shift","inverseDeps","inverseDep","_hasDependencyPath","fromId","toId","inQueue","dependencyModule","_findCyclePath","depth","_createRequire","toUrl","getStats","__$__nodeRequire","_loadModule","lastPathIndex","loadNextPath","currentPath_1","recorder_1","_loadPluginDependency","plugin","pluginDependency","cyclePath","reverse","inversePluginDeps","_onModuleComplete","inverseDependencyId","inverseDependency","delete","define","init","_nodeRequire_1","what","RequireFunc","DefineFunc","jQuery","_requireFunc_config","doNotInitLoader"],"mappings":"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","file":"loader.js","sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/*---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n * Please make sure to make edits in the .ts file at https://github.com/Microsoft/vscode-loader/\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *--------------------------------------------------------------------------------------------*/\nvar _amdLoaderGlobal = this;\nvar _commonjsGlobal = typeof global === 'object' ? global : {};\nvar AMDLoader;\n(function (AMDLoader) {\n    AMDLoader.global = _amdLoaderGlobal;\n    var Environment = (function () {\n        function Environment() {\n            this._detected = false;\n            this._isWindows = false;\n            this._isNode = false;\n            this._isElectronRenderer = false;\n            this._isWebWorker = false;\n        }\n        Object.defineProperty(Environment.prototype, \"isWindows\", {\n            get: function () {\n                this._detect();\n                return this._isWindows;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(Environment.prototype, \"isNode\", {\n            get: function () {\n                this._detect();\n                return this._isNode;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(Environment.prototype, \"isElectronRenderer\", {\n            get: function () {\n                this._detect();\n                return this._isElectronRenderer;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(Environment.prototype, \"isWebWorker\", {\n            get: function () {\n                this._detect();\n                return this._isWebWorker;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Environment.prototype._detect = function () {\n            if (this._detected) {\n                return;\n            }\n            this._detected = true;\n            this._isWindows = Environment._isWindows();\n            this._isNode = (typeof module !== 'undefined' && !!module.exports);\n            this._isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');\n            this._isWebWorker = (typeof AMDLoader.global.importScripts === 'function');\n        };\n        Environment._isWindows = function () {\n            if (typeof navigator !== 'undefined') {\n                if (navigator.userAgent && navigator.userAgent.indexOf('Windows') >= 0) {\n                    return true;\n                }\n            }\n            if (typeof process !== 'undefined') {\n                return (process.platform === 'win32');\n            }\n            return false;\n        };\n        return Environment;\n    }());\n    AMDLoader.Environment = Environment;\n})(AMDLoader || (AMDLoader = {}));\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar AMDLoader;\n(function (AMDLoader) {\n    var LoaderEvent = (function () {\n        function LoaderEvent(type, detail, timestamp) {\n            this.type = type;\n            this.detail = detail;\n            this.timestamp = timestamp;\n        }\n        return LoaderEvent;\n    }());\n    AMDLoader.LoaderEvent = LoaderEvent;\n    var LoaderEventRecorder = (function () {\n        function LoaderEventRecorder(loaderAvailableTimestamp) {\n            this._events = [new LoaderEvent(1 /* LoaderAvailable */, '', loaderAvailableTimestamp)];\n        }\n        LoaderEventRecorder.prototype.record = function (type, detail) {\n            this._events.push(new LoaderEvent(type, detail, AMDLoader.Utilities.getHighPerformanceTimestamp()));\n        };\n        LoaderEventRecorder.prototype.getEvents = function () {\n            return this._events;\n        };\n        return LoaderEventRecorder;\n    }());\n    AMDLoader.LoaderEventRecorder = LoaderEventRecorder;\n    var NullLoaderEventRecorder = (function () {\n        function NullLoaderEventRecorder() {\n        }\n        NullLoaderEventRecorder.prototype.record = function (type, detail) {\n            // Nothing to do\n        };\n        NullLoaderEventRecorder.prototype.getEvents = function () {\n            return [];\n        };\n        return NullLoaderEventRecorder;\n    }());\n    NullLoaderEventRecorder.INSTANCE = new NullLoaderEventRecorder();\n    AMDLoader.NullLoaderEventRecorder = NullLoaderEventRecorder;\n})(AMDLoader || (AMDLoader = {}));\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar AMDLoader;\n(function (AMDLoader) {\n    var Utilities = (function () {\n        function Utilities() {\n        }\n        /**\n         * This method does not take care of / vs \\\n         */\n        Utilities.fileUriToFilePath = function (isWindows, uri) {\n            uri = decodeURI(uri).replace(/%23/g, '#');\n            if (isWindows) {\n                if (/^file:\\/\\/\\//.test(uri)) {\n                    // This is a URI without a hostname => return only the path segment\n                    return uri.substr(8);\n                }\n                if (/^file:\\/\\//.test(uri)) {\n                    return uri.substr(5);\n                }\n            }\n            else {\n                if (/^file:\\/\\//.test(uri)) {\n                    return uri.substr(7);\n                }\n            }\n            // Not sure...\n            return uri;\n        };\n        Utilities.startsWith = function (haystack, needle) {\n            return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;\n        };\n        Utilities.endsWith = function (haystack, needle) {\n            return haystack.length >= needle.length && haystack.substr(haystack.length - needle.length) === needle;\n        };\n        // only check for \"?\" before \"#\" to ensure that there is a real Query-String\n        Utilities.containsQueryString = function (url) {\n            return /^[^\\#]*\\?/gi.test(url);\n        };\n        /**\n         * Does `url` start with http:// or https:// or file:// or / ?\n         */\n        Utilities.isAbsolutePath = function (url) {\n            return /^((http:\\/\\/)|(https:\\/\\/)|(file:\\/\\/)|(\\/))/.test(url);\n        };\n        Utilities.forEachProperty = function (obj, callback) {\n            if (obj) {\n                var key = void 0;\n                for (key in obj) {\n                    if (obj.hasOwnProperty(key)) {\n                        callback(key, obj[key]);\n                    }\n                }\n            }\n        };\n        Utilities.isEmpty = function (obj) {\n            var isEmpty = true;\n            Utilities.forEachProperty(obj, function () {\n                isEmpty = false;\n            });\n            return isEmpty;\n        };\n        Utilities.recursiveClone = function (obj) {\n            if (!obj || typeof obj !== 'object') {\n                return obj;\n            }\n            var result = Array.isArray(obj) ? [] : {};\n            Utilities.forEachProperty(obj, function (key, value) {\n                if (value && typeof value === 'object') {\n                    result[key] = Utilities.recursiveClone(value);\n                }\n                else {\n                    result[key] = value;\n                }\n            });\n            return result;\n        };\n        Utilities.generateAnonymousModule = function () {\n            return '===anonymous' + (Utilities.NEXT_ANONYMOUS_ID++) + '===';\n        };\n        Utilities.isAnonymousModule = function (id) {\n            return Utilities.startsWith(id, '===anonymous');\n        };\n        Utilities.getHighPerformanceTimestamp = function () {\n            if (!this.PERFORMANCE_NOW_PROBED) {\n                this.PERFORMANCE_NOW_PROBED = true;\n                this.HAS_PERFORMANCE_NOW = (AMDLoader.global.performance && typeof AMDLoader.global.performance.now === 'function');\n            }\n            return (this.HAS_PERFORMANCE_NOW ? AMDLoader.global.performance.now() : Date.now());\n        };\n        return Utilities;\n    }());\n    Utilities.NEXT_ANONYMOUS_ID = 1;\n    Utilities.PERFORMANCE_NOW_PROBED = false;\n    Utilities.HAS_PERFORMANCE_NOW = false;\n    AMDLoader.Utilities = Utilities;\n})(AMDLoader || (AMDLoader = {}));\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar AMDLoader;\n(function (AMDLoader) {\n    var ConfigurationOptionsUtil = (function () {\n        function ConfigurationOptionsUtil() {\n        }\n        /**\n         * Ensure configuration options make sense\n         */\n        ConfigurationOptionsUtil.validateConfigurationOptions = function (options) {\n            function defaultOnError(err) {\n                if (err.errorCode === 'load') {\n                    console.error('Loading \"' + err.moduleId + '\" failed');\n                    console.error('Detail: ', err.detail);\n                    if (err.detail && err.detail.stack) {\n                        console.error(err.detail.stack);\n                    }\n                    console.error('Here are the modules that depend on it:');\n                    console.error(err.neededBy);\n                    return;\n                }\n                if (err.errorCode === 'factory') {\n                    console.error('The factory method of \"' + err.moduleId + '\" has thrown an exception');\n                    console.error(err.detail);\n                    if (err.detail && err.detail.stack) {\n                        console.error(err.detail.stack);\n                    }\n                    return;\n                }\n            }\n            options = options || {};\n            if (typeof options.baseUrl !== 'string') {\n                options.baseUrl = '';\n            }\n            if (typeof options.isBuild !== 'boolean') {\n                options.isBuild = false;\n            }\n            if (typeof options.paths !== 'object') {\n                options.paths = {};\n            }\n            if (typeof options.config !== 'object') {\n                options.config = {};\n            }\n            if (typeof options.catchError === 'undefined') {\n                options.catchError = false;\n            }\n            if (typeof options.urlArgs !== 'string') {\n                options.urlArgs = '';\n            }\n            if (typeof options.onError !== 'function') {\n                options.onError = defaultOnError;\n            }\n            if (typeof options.ignoreDuplicateModules !== 'object' || !Array.isArray(options.ignoreDuplicateModules)) {\n                options.ignoreDuplicateModules = [];\n            }\n            if (options.baseUrl.length > 0) {\n                if (!AMDLoader.Utilities.endsWith(options.baseUrl, '/')) {\n                    options.baseUrl += '/';\n                }\n            }\n            if (typeof options.cspNonce !== 'string') {\n                options.cspNonce = '';\n            }\n            if (!Array.isArray(options.nodeModules)) {\n                options.nodeModules = [];\n            }\n            if (typeof options.nodeCachedData === 'object') {\n                if (typeof options.nodeCachedData.seed !== 'string') {\n                    options.nodeCachedData.seed = 'seed';\n                }\n                if (typeof options.nodeCachedData.writeDelay !== 'number' || options.nodeCachedData.writeDelay < 0) {\n                    options.nodeCachedData.writeDelay = 1000 * 7;\n                }\n                if (typeof options.nodeCachedData.onData !== 'function') {\n                    options.nodeCachedData.onData = function (err) {\n                        if (err && err.errorCode === 'cachedDataRejected') {\n                            console.warn('Rejected cached data from file: ' + err.path);\n                        }\n                        else if (err && err.errorCode) {\n                            console.error('Problems handling cached data file: ' + err.path);\n                            console.error(err.detail);\n                        }\n                        else if (err) {\n                            console.error(err);\n                        }\n                    };\n                }\n                if (!options.nodeCachedData.path || typeof options.nodeCachedData.path !== 'string') {\n                    options.nodeCachedData.onData('INVALID cached data configuration, \\'path\\' MUST be set');\n                    options.nodeCachedData = undefined;\n                }\n            }\n            return options;\n        };\n        ConfigurationOptionsUtil.mergeConfigurationOptions = function (overwrite, base) {\n            if (overwrite === void 0) { overwrite = null; }\n            if (base === void 0) { base = null; }\n            var result = AMDLoader.Utilities.recursiveClone(base || {});\n            // Merge known properties and overwrite the unknown ones\n            AMDLoader.Utilities.forEachProperty(overwrite, function (key, value) {\n                if (key === 'ignoreDuplicateModules' && typeof result.ignoreDuplicateModules !== 'undefined') {\n                    result.ignoreDuplicateModules = result.ignoreDuplicateModules.concat(value);\n                }\n                else if (key === 'paths' && typeof result.paths !== 'undefined') {\n                    AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.paths[key2] = value2; });\n                }\n                else if (key === 'config' && typeof result.config !== 'undefined') {\n                    AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.config[key2] = value2; });\n                }\n                else {\n                    result[key] = AMDLoader.Utilities.recursiveClone(value);\n                }\n            });\n            return ConfigurationOptionsUtil.validateConfigurationOptions(result);\n        };\n        return ConfigurationOptionsUtil;\n    }());\n    AMDLoader.ConfigurationOptionsUtil = ConfigurationOptionsUtil;\n    var Configuration = (function () {\n        function Configuration(env, options) {\n            this._env = env;\n            this.options = ConfigurationOptionsUtil.mergeConfigurationOptions(options);\n            this._createIgnoreDuplicateModulesMap();\n            this._createNodeModulesMap();\n            this._createSortedPathsRules();\n            if (this.options.baseUrl === '') {\n                if (this.options.nodeRequire && this.options.nodeRequire.main && this.options.nodeRequire.main.filename && this._env.isNode) {\n                    var nodeMain = this.options.nodeRequire.main.filename;\n                    var dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\\\'));\n                    this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);\n                }\n                if (this.options.nodeMain && this._env.isNode) {\n                    var nodeMain = this.options.nodeMain;\n                    var dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\\\'));\n                    this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);\n                }\n            }\n        }\n        Configuration.prototype._createIgnoreDuplicateModulesMap = function () {\n            // Build a map out of the ignoreDuplicateModules array\n            this.ignoreDuplicateModulesMap = {};\n            for (var i = 0; i < this.options.ignoreDuplicateModules.length; i++) {\n                this.ignoreDuplicateModulesMap[this.options.ignoreDuplicateModules[i]] = true;\n            }\n        };\n        Configuration.prototype._createNodeModulesMap = function () {\n            // Build a map out of nodeModules array\n            this.nodeModulesMap = Object.create(null);\n            for (var _i = 0, _a = this.options.nodeModules; _i < _a.length; _i++) {\n                var nodeModule = _a[_i];\n                this.nodeModulesMap[nodeModule] = true;\n            }\n        };\n        Configuration.prototype._createSortedPathsRules = function () {\n            var _this = this;\n            // Create an array our of the paths rules, sorted descending by length to\n            // result in a more specific -> less specific order\n            this.sortedPathsRules = [];\n            AMDLoader.Utilities.forEachProperty(this.options.paths, function (from, to) {\n                if (!Array.isArray(to)) {\n                    _this.sortedPathsRules.push({\n                        from: from,\n                        to: [to]\n                    });\n                }\n                else {\n                    _this.sortedPathsRules.push({\n                        from: from,\n                        to: to\n                    });\n                }\n            });\n            this.sortedPathsRules.sort(function (a, b) {\n                return b.from.length - a.from.length;\n            });\n        };\n        /**\n         * Clone current configuration and overwrite options selectively.\n         * @param options The selective options to overwrite with.\n         * @result A new configuration\n         */\n        Configuration.prototype.cloneAndMerge = function (options) {\n            return new Configuration(this._env, ConfigurationOptionsUtil.mergeConfigurationOptions(options, this.options));\n        };\n        /**\n         * Get current options bag. Useful for passing it forward to plugins.\n         */\n        Configuration.prototype.getOptionsLiteral = function () {\n            return this.options;\n        };\n        Configuration.prototype._applyPaths = function (moduleId) {\n            var pathRule;\n            for (var i = 0, len = this.sortedPathsRules.length; i < len; i++) {\n                pathRule = this.sortedPathsRules[i];\n                if (AMDLoader.Utilities.startsWith(moduleId, pathRule.from)) {\n                    var result = [];\n                    for (var j = 0, lenJ = pathRule.to.length; j < lenJ; j++) {\n                        result.push(pathRule.to[j] + moduleId.substr(pathRule.from.length));\n                    }\n                    return result;\n                }\n            }\n            return [moduleId];\n        };\n        Configuration.prototype._addUrlArgsToUrl = function (url) {\n            if (AMDLoader.Utilities.containsQueryString(url)) {\n                return url + '&' + this.options.urlArgs;\n            }\n            else {\n                return url + '?' + this.options.urlArgs;\n            }\n        };\n        Configuration.prototype._addUrlArgsIfNecessaryToUrl = function (url) {\n            if (this.options.urlArgs) {\n                return this._addUrlArgsToUrl(url);\n            }\n            return url;\n        };\n        Configuration.prototype._addUrlArgsIfNecessaryToUrls = function (urls) {\n            if (this.options.urlArgs) {\n                for (var i = 0, len = urls.length; i < len; i++) {\n                    urls[i] = this._addUrlArgsToUrl(urls[i]);\n                }\n            }\n            return urls;\n        };\n        /**\n         * Transform a module id to a location. Appends .js to module ids\n         */\n        Configuration.prototype.moduleIdToPaths = function (moduleId) {\n            if (this.nodeModulesMap[moduleId] === true) {\n                // This is a node module...\n                if (this.isBuild()) {\n                    // ...and we are at build time, drop it\n                    return ['empty:'];\n                }\n                else {\n                    // ...and at runtime we create a `shortcut`-path\n                    return ['node|' + moduleId];\n                }\n            }\n            var result = moduleId;\n            var results;\n            if (!AMDLoader.Utilities.endsWith(result, '.js') && !AMDLoader.Utilities.isAbsolutePath(result)) {\n                results = this._applyPaths(result);\n                for (var i = 0, len = results.length; i < len; i++) {\n                    if (this.isBuild() && results[i] === 'empty:') {\n                        continue;\n                    }\n                    if (!AMDLoader.Utilities.isAbsolutePath(results[i])) {\n                        results[i] = this.options.baseUrl + results[i];\n                    }\n                    if (!AMDLoader.Utilities.endsWith(results[i], '.js') && !AMDLoader.Utilities.containsQueryString(results[i])) {\n                        results[i] = results[i] + '.js';\n                    }\n                }\n            }\n            else {\n                if (!AMDLoader.Utilities.endsWith(result, '.js') && !AMDLoader.Utilities.containsQueryString(result)) {\n                    result = result + '.js';\n                }\n                results = [result];\n            }\n            return this._addUrlArgsIfNecessaryToUrls(results);\n        };\n        /**\n         * Transform a module id or url to a location.\n         */\n        Configuration.prototype.requireToUrl = function (url) {\n            var result = url;\n            if (!AMDLoader.Utilities.isAbsolutePath(result)) {\n                result = this._applyPaths(result)[0];\n                if (!AMDLoader.Utilities.isAbsolutePath(result)) {\n                    result = this.options.baseUrl + result;\n                }\n            }\n            return this._addUrlArgsIfNecessaryToUrl(result);\n        };\n        /**\n         * Flag to indicate if current execution is as part of a build.\n         */\n        Configuration.prototype.isBuild = function () {\n            return this.options.isBuild;\n        };\n        /**\n         * Test if module `moduleId` is expected to be defined multiple times\n         */\n        Configuration.prototype.isDuplicateMessageIgnoredFor = function (moduleId) {\n            return this.ignoreDuplicateModulesMap.hasOwnProperty(moduleId);\n        };\n        /**\n         * Get the configuration settings for the provided module id\n         */\n        Configuration.prototype.getConfigForModule = function (moduleId) {\n            if (this.options.config) {\n                return this.options.config[moduleId];\n            }\n        };\n        /**\n         * Should errors be caught when executing module factories?\n         */\n        Configuration.prototype.shouldCatchError = function () {\n            return this.options.catchError;\n        };\n        /**\n         * Should statistics be recorded?\n         */\n        Configuration.prototype.shouldRecordStats = function () {\n            return this.options.recordStats;\n        };\n        /**\n         * Forward an error to the error handler.\n         */\n        Configuration.prototype.onError = function (err) {\n            this.options.onError(err);\n        };\n        return Configuration;\n    }());\n    AMDLoader.Configuration = Configuration;\n})(AMDLoader || (AMDLoader = {}));\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar AMDLoader;\n(function (AMDLoader) {\n    /**\n     * Load `scriptSrc` only once (avoid multiple <script> tags)\n     */\n    var OnlyOnceScriptLoader = (function () {\n        function OnlyOnceScriptLoader(env) {\n            this._env = env;\n            this._scriptLoader = null;\n            this._callbackMap = {};\n        }\n        OnlyOnceScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n            var _this = this;\n            if (!this._scriptLoader) {\n                this._scriptLoader = (this._env.isWebWorker\n                    ? new WorkerScriptLoader()\n                    : this._env.isNode\n                        ? new NodeScriptLoader(this._env)\n                        : new BrowserScriptLoader());\n            }\n            var scriptCallbacks = {\n                callback: callback,\n                errorback: errorback\n            };\n            if (this._callbackMap.hasOwnProperty(scriptSrc)) {\n                this._callbackMap[scriptSrc].push(scriptCallbacks);\n                return;\n            }\n            this._callbackMap[scriptSrc] = [scriptCallbacks];\n            this._scriptLoader.load(moduleManager, scriptSrc, function () { return _this.triggerCallback(scriptSrc); }, function (err) { return _this.triggerErrorback(scriptSrc, err); });\n        };\n        OnlyOnceScriptLoader.prototype.triggerCallback = function (scriptSrc) {\n            var scriptCallbacks = this._callbackMap[scriptSrc];\n            delete this._callbackMap[scriptSrc];\n            for (var i = 0; i < scriptCallbacks.length; i++) {\n                scriptCallbacks[i].callback();\n            }\n        };\n        OnlyOnceScriptLoader.prototype.triggerErrorback = function (scriptSrc, err) {\n            var scriptCallbacks = this._callbackMap[scriptSrc];\n            delete this._callbackMap[scriptSrc];\n            for (var i = 0; i < scriptCallbacks.length; i++) {\n                scriptCallbacks[i].errorback(err);\n            }\n        };\n        return OnlyOnceScriptLoader;\n    }());\n    var BrowserScriptLoader = (function () {\n        function BrowserScriptLoader() {\n        }\n        /**\n         * Attach load / error listeners to a script element and remove them when either one has fired.\n         * Implemented for browssers supporting HTML5 standard 'load' and 'error' events.\n         */\n        BrowserScriptLoader.prototype.attachListeners = function (script, callback, errorback) {\n            var unbind = function () {\n                script.removeEventListener('load', loadEventListener);\n                script.removeEventListener('error', errorEventListener);\n            };\n            var loadEventListener = function (e) {\n                unbind();\n                callback();\n            };\n            var errorEventListener = function (e) {\n                unbind();\n                errorback(e);\n            };\n            script.addEventListener('load', loadEventListener);\n            script.addEventListener('error', errorEventListener);\n        };\n        BrowserScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n            var script = document.createElement('script');\n            script.setAttribute('async', 'async');\n            script.setAttribute('type', 'text/javascript');\n            this.attachListeners(script, callback, errorback);\n            script.setAttribute('src', scriptSrc);\n            // Propagate CSP nonce to dynamically created script tag.\n            var cspNonce = moduleManager.getConfig().getOptionsLiteral().cspNonce;\n            if (cspNonce) {\n                script.setAttribute('nonce', cspNonce);\n            }\n            document.getElementsByTagName('head')[0].appendChild(script);\n        };\n        return BrowserScriptLoader;\n    }());\n    var WorkerScriptLoader = (function () {\n        function WorkerScriptLoader() {\n        }\n        WorkerScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n            try {\n                importScripts(scriptSrc);\n                callback();\n            }\n            catch (e) {\n                errorback(e);\n            }\n        };\n        return WorkerScriptLoader;\n    }());\n    var NodeScriptLoader = (function () {\n        function NodeScriptLoader(env) {\n            this._env = env;\n            this._didInitialize = false;\n            this._didPatchNodeRequire = false;\n            this._hasCreateCachedData = false;\n        }\n        NodeScriptLoader.prototype._init = function (nodeRequire) {\n            if (this._didInitialize) {\n                return;\n            }\n            this._didInitialize = true;\n            // capture node modules\n            this._fs = nodeRequire('fs');\n            this._vm = nodeRequire('vm');\n            this._path = nodeRequire('path');\n            this._crypto = nodeRequire('crypto');\n            // check for `createCachedData`-api\n            this._hasCreateCachedData = typeof (new this._vm.Script('').createCachedData) === 'function';\n        };\n        // patch require-function of nodejs such that we can manually create a script\n        // from cached data. this is done by overriding the `Module._compile` function\n        NodeScriptLoader.prototype._initNodeRequire = function (nodeRequire, moduleManager) {\n            var nodeCachedData = moduleManager.getConfig().getOptionsLiteral().nodeCachedData;\n            if (!nodeCachedData || this._didPatchNodeRequire) {\n                return;\n            }\n            this._didPatchNodeRequire = true;\n            var that = this;\n            var Module = nodeRequire('module');\n            function makeRequireFunction(mod) {\n                var Module = mod.constructor;\n                var require = function require(path) {\n                    try {\n                        return mod.require(path);\n                    }\n                    finally {\n                        // nothing\n                    }\n                };\n                require.resolve = function resolve(request) {\n                    return Module._resolveFilename(request, mod);\n                };\n                require.main = process.mainModule;\n                require.extensions = Module._extensions;\n                require.cache = Module._cache;\n                return require;\n            }\n            Module.prototype._compile = function (content, filename) {\n                // remove shebang\n                content = content.replace(/^#!.*/, '');\n                // create wrapper function\n                var wrapper = Module.wrap(content);\n                var cachedDataPath = that._getCachedDataPath(nodeCachedData.seed, nodeCachedData.path, filename);\n                var options = { filename: filename };\n                try {\n                    options.cachedData = that._fs.readFileSync(cachedDataPath);\n                }\n                catch (e) {\n                    options.produceCachedData = !that._hasCreateCachedData;\n                }\n                var script = new that._vm.Script(wrapper, options);\n                var compileWrapper = script.runInThisContext(options);\n                var dirname = that._path.dirname(filename);\n                var require = makeRequireFunction(this);\n                var args = [this.exports, require, this, filename, dirname, process, _commonjsGlobal, Buffer];\n                var result = compileWrapper.apply(this.exports, args);\n                that._processCachedData(moduleManager, script, wrapper, cachedDataPath, !options.cachedData);\n                return result;\n            };\n        };\n        NodeScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n            var _this = this;\n            var opts = moduleManager.getConfig().getOptionsLiteral();\n            var nodeRequire = (opts.nodeRequire || AMDLoader.global.nodeRequire);\n            var nodeInstrumenter = (opts.nodeInstrumenter || function (c) { return c; });\n            this._init(nodeRequire);\n            this._initNodeRequire(nodeRequire, moduleManager);\n            var recorder = moduleManager.getRecorder();\n            if (/^node\\|/.test(scriptSrc)) {\n                var pieces = scriptSrc.split('|');\n                var moduleExports_1 = null;\n                try {\n                    moduleExports_1 = nodeRequire(pieces[1]);\n                }\n                catch (err) {\n                    errorback(err);\n                    return;\n                }\n                moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports_1; });\n                callback();\n            }\n            else {\n                scriptSrc = AMDLoader.Utilities.fileUriToFilePath(this._env.isWindows, scriptSrc);\n                this._fs.readFile(scriptSrc, { encoding: 'utf8' }, function (err, data) {\n                    if (err) {\n                        errorback(err);\n                        return;\n                    }\n                    var normalizedScriptSrc = _this._path.normalize(scriptSrc);\n                    var vmScriptSrc = normalizedScriptSrc;\n                    // Make the script src friendly towards electron\n                    if (_this._env.isElectronRenderer) {\n                        var driveLetterMatch = vmScriptSrc.match(/^([a-z])\\:(.*)/i);\n                        if (driveLetterMatch) {\n                            // windows\n                            vmScriptSrc = \"file:///\" + (driveLetterMatch[1].toUpperCase() + ':' + driveLetterMatch[2]).replace(/\\\\/g, '/');\n                        }\n                        else {\n                            // nix\n                            vmScriptSrc = \"file://\" + vmScriptSrc;\n                        }\n                    }\n                    var contents, prefix = '(function (require, define, __filename, __dirname) { ', suffix = '\\n});';\n                    if (data.charCodeAt(0) === NodeScriptLoader._BOM) {\n                        contents = prefix + data.substring(1) + suffix;\n                    }\n                    else {\n                        contents = prefix + data + suffix;\n                    }\n                    contents = nodeInstrumenter(contents, normalizedScriptSrc);\n                    if (!opts.nodeCachedData) {\n                        _this._loadAndEvalScript(moduleManager, scriptSrc, vmScriptSrc, contents, { filename: vmScriptSrc }, recorder, callback, errorback);\n                    }\n                    else {\n                        var cachedDataPath_1 = _this._getCachedDataPath(opts.nodeCachedData.seed, opts.nodeCachedData.path, scriptSrc);\n                        _this._fs.readFile(cachedDataPath_1, function (_err, cachedData) {\n                            // create script options\n                            var options = {\n                                filename: vmScriptSrc,\n                                produceCachedData: !_this._hasCreateCachedData && typeof cachedData === 'undefined',\n                                cachedData: cachedData\n                            };\n                            var script = _this._loadAndEvalScript(moduleManager, scriptSrc, vmScriptSrc, contents, options, recorder, callback, errorback);\n                            _this._processCachedData(moduleManager, script, contents, cachedDataPath_1, !options.cachedData);\n                        });\n                    }\n                });\n            }\n        };\n        NodeScriptLoader.prototype._loadAndEvalScript = function (moduleManager, scriptSrc, vmScriptSrc, contents, options, recorder, callback, errorback) {\n            // create script, run script\n            recorder.record(31 /* NodeBeginEvaluatingScript */, scriptSrc);\n            var script = new this._vm.Script(contents, options);\n            var r = script.runInThisContext(options);\n            var globalDefineFunc = moduleManager.getGlobalAMDDefineFunc();\n            var receivedDefineCall = false;\n            var localDefineFunc = function () {\n                receivedDefineCall = true;\n                return globalDefineFunc.apply(null, arguments);\n            };\n            localDefineFunc.amd = globalDefineFunc.amd;\n            r.call(AMDLoader.global, moduleManager.getGlobalAMDRequireFunc(), localDefineFunc, vmScriptSrc, this._path.dirname(scriptSrc));\n            // signal done\n            recorder.record(32 /* NodeEndEvaluatingScript */, scriptSrc);\n            if (receivedDefineCall) {\n                callback();\n            }\n            else {\n                errorback(new Error(\"Didn't receive define call in \" + scriptSrc + \"!\"));\n            }\n            return script;\n        };\n        NodeScriptLoader.prototype._getCachedDataPath = function (seed, basedir, filename) {\n            var hash = this._crypto.createHash('md5').update(filename, 'utf8').update(seed, 'utf8').digest('hex');\n            var basename = this._path.basename(filename).replace(/\\.js$/, '');\n            return this._path.join(basedir, basename + \"-\" + hash + \".code\");\n        };\n        NodeScriptLoader.prototype._processCachedData = function (moduleManager, script, contents, cachedDataPath, createCachedData) {\n            var _this = this;\n            if (script.cachedDataRejected) {\n                // data rejected => delete cache file\n                moduleManager.getConfig().getOptionsLiteral().nodeCachedData.onData({\n                    errorCode: 'cachedDataRejected',\n                    path: cachedDataPath\n                });\n                NodeScriptLoader._runSoon(function () {\n                    return _this._fs.unlink(cachedDataPath, function (err) {\n                        if (err) {\n                            moduleManager.getConfig().getOptionsLiteral().nodeCachedData.onData({\n                                errorCode: 'unlink',\n                                path: cachedDataPath,\n                                detail: err\n                            });\n                        }\n                    });\n                }, moduleManager.getConfig().getOptionsLiteral().nodeCachedData.writeDelay / 2);\n            }\n            else if (script.cachedDataProduced) {\n                // data produced => tell outside world\n                moduleManager.getConfig().getOptionsLiteral().nodeCachedData.onData(undefined, {\n                    path: cachedDataPath\n                });\n                // data produced => write cache file\n                NodeScriptLoader._runSoon(function () {\n                    return _this._fs.writeFile(cachedDataPath, script.cachedData, function (err) {\n                        if (err) {\n                            moduleManager.getConfig().getOptionsLiteral().nodeCachedData.onData({\n                                errorCode: 'writeFile',\n                                path: cachedDataPath,\n                                detail: err\n                            });\n                        }\n                    });\n                }, moduleManager.getConfig().getOptionsLiteral().nodeCachedData.writeDelay);\n            }\n            else if (this._hasCreateCachedData && createCachedData) {\n                // NEW world\n                // data produced => tell outside world\n                moduleManager.getConfig().getOptionsLiteral().nodeCachedData.onData(undefined, {\n                    path: cachedDataPath\n                });\n                // soon'ish create and save cached data\n                NodeScriptLoader._runSoon(function () {\n                    var data = script.createCachedData(contents);\n                    _this._fs.writeFile(cachedDataPath, data, function (err) {\n                        if (!err) {\n                            return;\n                        }\n                        moduleManager.getConfig().getOptionsLiteral().nodeCachedData.onData({\n                            errorCode: 'writeFile',\n                            path: cachedDataPath,\n                            detail: err\n                        });\n                    });\n                }, moduleManager.getConfig().getOptionsLiteral().nodeCachedData.writeDelay);\n            }\n        };\n        NodeScriptLoader._runSoon = function (callback, minTimeout) {\n            var timeout = minTimeout + Math.ceil(Math.random() * minTimeout);\n            setTimeout(callback, timeout);\n        };\n        return NodeScriptLoader;\n    }());\n    NodeScriptLoader._BOM = 0xFEFF;\n    function createScriptLoader(env) {\n        return new OnlyOnceScriptLoader(env);\n    }\n    AMDLoader.createScriptLoader = createScriptLoader;\n})(AMDLoader || (AMDLoader = {}));\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar AMDLoader;\n(function (AMDLoader) {\n    // ------------------------------------------------------------------------\n    // ModuleIdResolver\n    var ModuleIdResolver = (function () {\n        function ModuleIdResolver(fromModuleId) {\n            var lastSlash = fromModuleId.lastIndexOf('/');\n            if (lastSlash !== -1) {\n                this.fromModulePath = fromModuleId.substr(0, lastSlash + 1);\n            }\n            else {\n                this.fromModulePath = '';\n            }\n        }\n        /**\n         * Normalize 'a/../name' to 'name', etc.\n         */\n        ModuleIdResolver._normalizeModuleId = function (moduleId) {\n            var r = moduleId, pattern;\n            // replace /./ => /\n            pattern = /\\/\\.\\//;\n            while (pattern.test(r)) {\n                r = r.replace(pattern, '/');\n            }\n            // replace ^./ => nothing\n            r = r.replace(/^\\.\\//g, '');\n            // replace /aa/../ => / (BUT IGNORE /../../)\n            pattern = /\\/(([^\\/])|([^\\/][^\\/\\.])|([^\\/\\.][^\\/])|([^\\/][^\\/][^\\/]+))\\/\\.\\.\\//;\n            while (pattern.test(r)) {\n                r = r.replace(pattern, '/');\n            }\n            // replace ^aa/../ => nothing (BUT IGNORE ../../)\n            r = r.replace(/^(([^\\/])|([^\\/][^\\/\\.])|([^\\/\\.][^\\/])|([^\\/][^\\/][^\\/]+))\\/\\.\\.\\//, '');\n            return r;\n        };\n        /**\n         * Resolve relative module ids\n         */\n        ModuleIdResolver.prototype.resolveModule = function (moduleId) {\n            var result = moduleId;\n            if (!AMDLoader.Utilities.isAbsolutePath(result)) {\n                if (AMDLoader.Utilities.startsWith(result, './') || AMDLoader.Utilities.startsWith(result, '../')) {\n                    result = ModuleIdResolver._normalizeModuleId(this.fromModulePath + result);\n                }\n            }\n            return result;\n        };\n        return ModuleIdResolver;\n    }());\n    ModuleIdResolver.ROOT = new ModuleIdResolver('');\n    AMDLoader.ModuleIdResolver = ModuleIdResolver;\n    // ------------------------------------------------------------------------\n    // Module\n    var Module = (function () {\n        function Module(id, strId, dependencies, callback, errorback, moduleIdResolver) {\n            this.id = id;\n            this.strId = strId;\n            this.dependencies = dependencies;\n            this._callback = callback;\n            this._errorback = errorback;\n            this.moduleIdResolver = moduleIdResolver;\n            this.exports = {};\n            this.exportsPassedIn = false;\n            this.unresolvedDependenciesCount = this.dependencies.length;\n            this._isComplete = false;\n        }\n        Module._safeInvokeFunction = function (callback, args) {\n            try {\n                return {\n                    returnedValue: callback.apply(AMDLoader.global, args),\n                    producedError: null\n                };\n            }\n            catch (e) {\n                return {\n                    returnedValue: null,\n                    producedError: e\n                };\n            }\n        };\n        Module._invokeFactory = function (config, strModuleId, callback, dependenciesValues) {\n            if (config.isBuild() && !AMDLoader.Utilities.isAnonymousModule(strModuleId)) {\n                return {\n                    returnedValue: null,\n                    producedError: null\n                };\n            }\n            if (config.shouldCatchError()) {\n                return this._safeInvokeFunction(callback, dependenciesValues);\n            }\n            return {\n                returnedValue: callback.apply(AMDLoader.global, dependenciesValues),\n                producedError: null\n            };\n        };\n        Module.prototype.complete = function (recorder, config, dependenciesValues) {\n            this._isComplete = true;\n            var producedError = null;\n            if (this._callback) {\n                if (typeof this._callback === 'function') {\n                    recorder.record(21 /* BeginInvokeFactory */, this.strId);\n                    var r = Module._invokeFactory(config, this.strId, this._callback, dependenciesValues);\n                    producedError = r.producedError;\n                    recorder.record(22 /* EndInvokeFactory */, this.strId);\n                    if (!producedError && typeof r.returnedValue !== 'undefined' && (!this.exportsPassedIn || AMDLoader.Utilities.isEmpty(this.exports))) {\n                        this.exports = r.returnedValue;\n                    }\n                }\n                else {\n                    this.exports = this._callback;\n                }\n            }\n            if (producedError) {\n                config.onError({\n                    errorCode: 'factory',\n                    moduleId: this.strId,\n                    detail: producedError\n                });\n            }\n            this.dependencies = null;\n            this._callback = null;\n            this._errorback = null;\n            this.moduleIdResolver = null;\n        };\n        /**\n         * One of the direct dependencies or a transitive dependency has failed to load.\n         */\n        Module.prototype.onDependencyError = function (err) {\n            if (this._errorback) {\n                this._errorback(err);\n                return true;\n            }\n            return false;\n        };\n        /**\n         * Is the current module complete?\n         */\n        Module.prototype.isComplete = function () {\n            return this._isComplete;\n        };\n        return Module;\n    }());\n    AMDLoader.Module = Module;\n    var ModuleIdProvider = (function () {\n        function ModuleIdProvider() {\n            this._nextId = 0;\n            this._strModuleIdToIntModuleId = new Map();\n            this._intModuleIdToStrModuleId = [];\n            // Ensure values 0, 1, 2 are assigned accordingly with ModuleId\n            this.getModuleId('exports');\n            this.getModuleId('module');\n            this.getModuleId('require');\n        }\n        ModuleIdProvider.prototype.getMaxModuleId = function () {\n            return this._nextId;\n        };\n        ModuleIdProvider.prototype.getModuleId = function (strModuleId) {\n            var id = this._strModuleIdToIntModuleId.get(strModuleId);\n            if (typeof id === 'undefined') {\n                id = this._nextId++;\n                this._strModuleIdToIntModuleId.set(strModuleId, id);\n                this._intModuleIdToStrModuleId[id] = strModuleId;\n            }\n            return id;\n        };\n        ModuleIdProvider.prototype.getStrModuleId = function (moduleId) {\n            return this._intModuleIdToStrModuleId[moduleId];\n        };\n        return ModuleIdProvider;\n    }());\n    var RegularDependency = (function () {\n        function RegularDependency(id) {\n            this.id = id;\n        }\n        return RegularDependency;\n    }());\n    RegularDependency.EXPORTS = new RegularDependency(0 /* EXPORTS */);\n    RegularDependency.MODULE = new RegularDependency(1 /* MODULE */);\n    RegularDependency.REQUIRE = new RegularDependency(2 /* REQUIRE */);\n    AMDLoader.RegularDependency = RegularDependency;\n    var PluginDependency = (function () {\n        function PluginDependency(id, pluginId, pluginParam) {\n            this.id = id;\n            this.pluginId = pluginId;\n            this.pluginParam = pluginParam;\n        }\n        return PluginDependency;\n    }());\n    AMDLoader.PluginDependency = PluginDependency;\n    var ModuleManager = (function () {\n        function ModuleManager(env, scriptLoader, defineFunc, requireFunc, loaderAvailableTimestamp) {\n            if (loaderAvailableTimestamp === void 0) { loaderAvailableTimestamp = 0; }\n            this._env = env;\n            this._scriptLoader = scriptLoader;\n            this._loaderAvailableTimestamp = loaderAvailableTimestamp;\n            this._defineFunc = defineFunc;\n            this._requireFunc = requireFunc;\n            this._moduleIdProvider = new ModuleIdProvider();\n            this._config = new AMDLoader.Configuration(this._env);\n            this._modules2 = [];\n            this._knownModules2 = [];\n            this._inverseDependencies2 = [];\n            this._inversePluginDependencies2 = new Map();\n            this._currentAnnonymousDefineCall = null;\n            this._recorder = null;\n            this._buildInfoPath = [];\n            this._buildInfoDefineStack = [];\n            this._buildInfoDependencies = [];\n        }\n        ModuleManager.prototype.reset = function () {\n            return new ModuleManager(this._env, this._scriptLoader, this._defineFunc, this._requireFunc, this._loaderAvailableTimestamp);\n        };\n        ModuleManager.prototype.getGlobalAMDDefineFunc = function () {\n            return this._defineFunc;\n        };\n        ModuleManager.prototype.getGlobalAMDRequireFunc = function () {\n            return this._requireFunc;\n        };\n        ModuleManager._findRelevantLocationInStack = function (needle, stack) {\n            var normalize = function (str) { return str.replace(/\\\\/g, '/'); };\n            var normalizedPath = normalize(needle);\n            var stackPieces = stack.split(/\\n/);\n            for (var i = 0; i < stackPieces.length; i++) {\n                var m = stackPieces[i].match(/(.*):(\\d+):(\\d+)\\)?$/);\n                if (m) {\n                    var stackPath = m[1];\n                    var stackLine = m[2];\n                    var stackColumn = m[3];\n                    var trimPathOffset = Math.max(stackPath.lastIndexOf(' ') + 1, stackPath.lastIndexOf('(') + 1);\n                    stackPath = stackPath.substr(trimPathOffset);\n                    stackPath = normalize(stackPath);\n                    if (stackPath === normalizedPath) {\n                        var r = {\n                            line: parseInt(stackLine, 10),\n                            col: parseInt(stackColumn, 10)\n                        };\n                        if (r.line === 1) {\n                            r.col -= '(function (require, define, __filename, __dirname) { '.length;\n                        }\n                        return r;\n                    }\n                }\n            }\n            throw new Error('Could not correlate define call site for needle ' + needle);\n        };\n        ModuleManager.prototype.getBuildInfo = function () {\n            if (!this._config.isBuild()) {\n                return null;\n            }\n            var result = [], resultLen = 0;\n            for (var i = 0, len = this._modules2.length; i < len; i++) {\n                var m = this._modules2[i];\n                if (!m) {\n                    continue;\n                }\n                var location_1 = this._buildInfoPath[m.id] || null;\n                var defineStack = this._buildInfoDefineStack[m.id] || null;\n                var dependencies = this._buildInfoDependencies[m.id];\n                result[resultLen++] = {\n                    id: m.strId,\n                    path: location_1,\n                    defineLocation: (location_1 && defineStack ? ModuleManager._findRelevantLocationInStack(location_1, defineStack) : null),\n                    dependencies: dependencies,\n                    shim: null,\n                    exports: m.exports\n                };\n            }\n            return result;\n        };\n        ModuleManager.prototype.getRecorder = function () {\n            if (!this._recorder) {\n                if (this._config.shouldRecordStats()) {\n                    this._recorder = new AMDLoader.LoaderEventRecorder(this._loaderAvailableTimestamp);\n                }\n                else {\n                    this._recorder = AMDLoader.NullLoaderEventRecorder.INSTANCE;\n                }\n            }\n            return this._recorder;\n        };\n        ModuleManager.prototype.getLoaderEvents = function () {\n            return this.getRecorder().getEvents();\n        };\n        /**\n         * Defines an anonymous module (without an id). Its name will be resolved as we receive a callback from the scriptLoader.\n         * @param dependecies @see defineModule\n         * @param callback @see defineModule\n         */\n        ModuleManager.prototype.enqueueDefineAnonymousModule = function (dependencies, callback) {\n            if (this._currentAnnonymousDefineCall !== null) {\n                throw new Error('Can only have one anonymous define call per script file');\n            }\n            var stack = null;\n            if (this._config.isBuild()) {\n                stack = new Error('StackLocation').stack;\n            }\n            this._currentAnnonymousDefineCall = {\n                stack: stack,\n                dependencies: dependencies,\n                callback: callback\n            };\n        };\n        /**\n         * Creates a module and stores it in _modules. The manager will immediately begin resolving its dependencies.\n         * @param strModuleId An unique and absolute id of the module. This must not collide with another module's id\n         * @param dependencies An array with the dependencies of the module. Special keys are: \"require\", \"exports\" and \"module\"\n         * @param callback if callback is a function, it will be called with the resolved dependencies. if callback is an object, it will be considered as the exports of the module.\n         */\n        ModuleManager.prototype.defineModule = function (strModuleId, dependencies, callback, errorback, stack, moduleIdResolver) {\n            var _this = this;\n            if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(strModuleId); }\n            var moduleId = this._moduleIdProvider.getModuleId(strModuleId);\n            if (this._modules2[moduleId]) {\n                if (!this._config.isDuplicateMessageIgnoredFor(strModuleId)) {\n                    console.warn('Duplicate definition of module \\'' + strModuleId + '\\'');\n                }\n                // Super important! Completely ignore duplicate module definition\n                return;\n            }\n            var m = new Module(moduleId, strModuleId, this._normalizeDependencies(dependencies, moduleIdResolver), callback, errorback, moduleIdResolver);\n            this._modules2[moduleId] = m;\n            if (this._config.isBuild()) {\n                this._buildInfoDefineStack[moduleId] = stack;\n                this._buildInfoDependencies[moduleId] = m.dependencies.map(function (dep) { return _this._moduleIdProvider.getStrModuleId(dep.id); });\n            }\n            // Resolving of dependencies is immediate (not in a timeout). If there's a need to support a packer that concatenates in an\n            // unordered manner, in order to finish processing the file, execute the following method in a timeout\n            this._resolve(m);\n        };\n        ModuleManager.prototype._normalizeDependency = function (dependency, moduleIdResolver) {\n            if (dependency === 'exports') {\n                return RegularDependency.EXPORTS;\n            }\n            if (dependency === 'module') {\n                return RegularDependency.MODULE;\n            }\n            if (dependency === 'require') {\n                return RegularDependency.REQUIRE;\n            }\n            // Normalize dependency and then request it from the manager\n            var bangIndex = dependency.indexOf('!');\n            if (bangIndex >= 0) {\n                var strPluginId = moduleIdResolver.resolveModule(dependency.substr(0, bangIndex));\n                var pluginParam = moduleIdResolver.resolveModule(dependency.substr(bangIndex + 1));\n                var dependencyId = this._moduleIdProvider.getModuleId(strPluginId + '!' + pluginParam);\n                var pluginId = this._moduleIdProvider.getModuleId(strPluginId);\n                return new PluginDependency(dependencyId, pluginId, pluginParam);\n            }\n            return new RegularDependency(this._moduleIdProvider.getModuleId(moduleIdResolver.resolveModule(dependency)));\n        };\n        ModuleManager.prototype._normalizeDependencies = function (dependencies, moduleIdResolver) {\n            var result = [], resultLen = 0;\n            for (var i = 0, len = dependencies.length; i < len; i++) {\n                result[resultLen++] = this._normalizeDependency(dependencies[i], moduleIdResolver);\n            }\n            return result;\n        };\n        ModuleManager.prototype._relativeRequire = function (moduleIdResolver, dependencies, callback, errorback) {\n            if (typeof dependencies === 'string') {\n                return this.synchronousRequire(dependencies, moduleIdResolver);\n            }\n            this.defineModule(AMDLoader.Utilities.generateAnonymousModule(), dependencies, callback, errorback, null, moduleIdResolver);\n        };\n        /**\n         * Require synchronously a module by its absolute id. If the module is not loaded, an exception will be thrown.\n         * @param id The unique and absolute id of the required module\n         * @return The exports of module 'id'\n         */\n        ModuleManager.prototype.synchronousRequire = function (_strModuleId, moduleIdResolver) {\n            if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(_strModuleId); }\n            var dependency = this._normalizeDependency(_strModuleId, moduleIdResolver);\n            var m = this._modules2[dependency.id];\n            if (!m) {\n                throw new Error('Check dependency list! Synchronous require cannot resolve module \\'' + _strModuleId + '\\'. This is the first mention of this module!');\n            }\n            if (!m.isComplete()) {\n                throw new Error('Check dependency list! Synchronous require cannot resolve module \\'' + _strModuleId + '\\'. This module has not been resolved completely yet.');\n            }\n            return m.exports;\n        };\n        ModuleManager.prototype.configure = function (params, shouldOverwrite) {\n            var oldShouldRecordStats = this._config.shouldRecordStats();\n            if (shouldOverwrite) {\n                this._config = new AMDLoader.Configuration(this._env, params);\n            }\n            else {\n                this._config = this._config.cloneAndMerge(params);\n            }\n            if (this._config.shouldRecordStats() && !oldShouldRecordStats) {\n                this._recorder = null;\n            }\n        };\n        ModuleManager.prototype.getConfig = function () {\n            return this._config;\n        };\n        /**\n         * Callback from the scriptLoader when a module has been loaded.\n         * This means its code is available and has been executed.\n         */\n        ModuleManager.prototype._onLoad = function (moduleId) {\n            if (this._currentAnnonymousDefineCall !== null) {\n                var defineCall = this._currentAnnonymousDefineCall;\n                this._currentAnnonymousDefineCall = null;\n                // Hit an anonymous define call\n                this.defineModule(this._moduleIdProvider.getStrModuleId(moduleId), defineCall.dependencies, defineCall.callback, null, defineCall.stack);\n            }\n        };\n        ModuleManager.prototype._createLoadError = function (moduleId, err) {\n            var _this = this;\n            var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);\n            var neededBy = (this._inverseDependencies2[moduleId] || []).map(function (intModuleId) { return _this._moduleIdProvider.getStrModuleId(intModuleId); });\n            return {\n                errorCode: 'load',\n                moduleId: strModuleId,\n                neededBy: neededBy,\n                detail: err\n            };\n        };\n        /**\n         * Callback from the scriptLoader when a module hasn't been loaded.\n         * This means that the script was not found (e.g. 404) or there was an error in the script.\n         */\n        ModuleManager.prototype._onLoadError = function (moduleId, err) {\n            var error = this._createLoadError(moduleId, err);\n            // Find any 'local' error handlers, walk the entire chain of inverse dependencies if necessary.\n            var seenModuleId = [];\n            for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {\n                seenModuleId[i] = false;\n            }\n            var someoneNotified = false;\n            var queue = [];\n            queue.push(moduleId);\n            seenModuleId[moduleId] = true;\n            while (queue.length > 0) {\n                var queueElement = queue.shift();\n                var m = this._modules2[queueElement];\n                if (m) {\n                    someoneNotified = m.onDependencyError(error) || someoneNotified;\n                }\n                var inverseDeps = this._inverseDependencies2[queueElement];\n                if (inverseDeps) {\n                    for (var i = 0, len = inverseDeps.length; i < len; i++) {\n                        var inverseDep = inverseDeps[i];\n                        if (!seenModuleId[inverseDep]) {\n                            queue.push(inverseDep);\n                            seenModuleId[inverseDep] = true;\n                        }\n                    }\n                }\n            }\n            if (!someoneNotified) {\n                this._config.onError(error);\n            }\n        };\n        /**\n         * Walks (recursively) the dependencies of 'from' in search of 'to'.\n         * Returns true if there is such a path or false otherwise.\n         * @param from Module id to start at\n         * @param to Module id to look for\n         */\n        ModuleManager.prototype._hasDependencyPath = function (fromId, toId) {\n            var from = this._modules2[fromId];\n            if (!from) {\n                return false;\n            }\n            var inQueue = [];\n            for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {\n                inQueue[i] = false;\n            }\n            var queue = [];\n            // Insert 'from' in queue\n            queue.push(from);\n            inQueue[fromId] = true;\n            while (queue.length > 0) {\n                // Pop first inserted element of queue\n                var element = queue.shift();\n                var dependencies = element.dependencies;\n                if (dependencies) {\n                    // Walk the element's dependencies\n                    for (var i = 0, len = dependencies.length; i < len; i++) {\n                        var dependency = dependencies[i];\n                        if (dependency.id === toId) {\n                            // There is a path to 'to'\n                            return true;\n                        }\n                        var dependencyModule = this._modules2[dependency.id];\n                        if (dependencyModule && !inQueue[dependency.id]) {\n                            // Insert 'dependency' in queue\n                            inQueue[dependency.id] = true;\n                            queue.push(dependencyModule);\n                        }\n                    }\n                }\n            }\n            // There is no path to 'to'\n            return false;\n        };\n        /**\n         * Walks (recursively) the dependencies of 'from' in search of 'to'.\n         * Returns cycle as array.\n         * @param from Module id to start at\n         * @param to Module id to look for\n         */\n        ModuleManager.prototype._findCyclePath = function (fromId, toId, depth) {\n            if (fromId === toId || depth === 50) {\n                return [fromId];\n            }\n            var from = this._modules2[fromId];\n            if (!from) {\n                return null;\n            }\n            // Walk the element's dependencies\n            var dependencies = from.dependencies;\n            for (var i = 0, len = dependencies.length; i < len; i++) {\n                var path = this._findCyclePath(dependencies[i].id, toId, depth + 1);\n                if (path !== null) {\n                    path.push(fromId);\n                    return path;\n                }\n            }\n            return null;\n        };\n        /**\n         * Create the local 'require' that is passed into modules\n         */\n        ModuleManager.prototype._createRequire = function (moduleIdResolver) {\n            var _this = this;\n            var result = (function (dependencies, callback, errorback) {\n                return _this._relativeRequire(moduleIdResolver, dependencies, callback, errorback);\n            });\n            result.toUrl = function (id) {\n                return _this._config.requireToUrl(moduleIdResolver.resolveModule(id));\n            };\n            result.getStats = function () {\n                return _this.getLoaderEvents();\n            };\n            result.__$__nodeRequire = AMDLoader.global.nodeRequire;\n            return result;\n        };\n        ModuleManager.prototype._loadModule = function (moduleId) {\n            var _this = this;\n            if (this._modules2[moduleId] || this._knownModules2[moduleId]) {\n                // known module\n                return;\n            }\n            this._knownModules2[moduleId] = true;\n            var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);\n            var paths = this._config.moduleIdToPaths(strModuleId);\n            var scopedPackageRegex = /^@[^\\/]+\\/[^\\/]+$/; // matches @scope/package-name\n            if (this._env.isNode && (strModuleId.indexOf('/') === -1 || scopedPackageRegex.test(strModuleId))) {\n                paths.push('node|' + strModuleId);\n            }\n            var lastPathIndex = -1;\n            var loadNextPath = function (err) {\n                lastPathIndex++;\n                if (lastPathIndex >= paths.length) {\n                    // No more paths to try\n                    _this._onLoadError(moduleId, err);\n                }\n                else {\n                    var currentPath_1 = paths[lastPathIndex];\n                    var recorder_1 = _this.getRecorder();\n                    if (_this._config.isBuild() && currentPath_1 === 'empty:') {\n                        _this._buildInfoPath[moduleId] = currentPath_1;\n                        _this.defineModule(_this._moduleIdProvider.getStrModuleId(moduleId), [], null, null, null);\n                        _this._onLoad(moduleId);\n                        return;\n                    }\n                    recorder_1.record(10 /* BeginLoadingScript */, currentPath_1);\n                    _this._scriptLoader.load(_this, currentPath_1, function () {\n                        if (_this._config.isBuild()) {\n                            _this._buildInfoPath[moduleId] = currentPath_1;\n                        }\n                        recorder_1.record(11 /* EndLoadingScriptOK */, currentPath_1);\n                        _this._onLoad(moduleId);\n                    }, function (err) {\n                        recorder_1.record(12 /* EndLoadingScriptError */, currentPath_1);\n                        loadNextPath(err);\n                    });\n                }\n            };\n            loadNextPath(null);\n        };\n        /**\n         * Resolve a plugin dependency with the plugin loaded & complete\n         * @param module The module that has this dependency\n         * @param pluginDependency The semi-normalized dependency that appears in the module. e.g. 'vs/css!./mycssfile'. Only the plugin part (before !) is normalized\n         * @param plugin The plugin (what the plugin exports)\n         */\n        ModuleManager.prototype._loadPluginDependency = function (plugin, pluginDependency) {\n            var _this = this;\n            if (this._modules2[pluginDependency.id] || this._knownModules2[pluginDependency.id]) {\n                // known module\n                return;\n            }\n            this._knownModules2[pluginDependency.id] = true;\n            // Delegate the loading of the resource to the plugin\n            var load = (function (value) {\n                _this.defineModule(_this._moduleIdProvider.getStrModuleId(pluginDependency.id), [], value, null, null);\n            });\n            load.error = function (err) {\n                _this._config.onError(_this._createLoadError(pluginDependency.id, err));\n            };\n            plugin.load(pluginDependency.pluginParam, this._createRequire(ModuleIdResolver.ROOT), load, this._config.getOptionsLiteral());\n        };\n        /**\n         * Examine the dependencies of module 'module' and resolve them as needed.\n         */\n        ModuleManager.prototype._resolve = function (module) {\n            var _this = this;\n            var dependencies = module.dependencies;\n            for (var i = 0, len = dependencies.length; i < len; i++) {\n                var dependency = dependencies[i];\n                if (dependency === RegularDependency.EXPORTS) {\n                    module.exportsPassedIn = true;\n                    module.unresolvedDependenciesCount--;\n                    continue;\n                }\n                if (dependency === RegularDependency.MODULE) {\n                    module.unresolvedDependenciesCount--;\n                    continue;\n                }\n                if (dependency === RegularDependency.REQUIRE) {\n                    module.unresolvedDependenciesCount--;\n                    continue;\n                }\n                var dependencyModule = this._modules2[dependency.id];\n                if (dependencyModule && dependencyModule.isComplete()) {\n                    module.unresolvedDependenciesCount--;\n                    continue;\n                }\n                if (this._hasDependencyPath(dependency.id, module.id)) {\n                    console.warn('There is a dependency cycle between \\'' + this._moduleIdProvider.getStrModuleId(dependency.id) + '\\' and \\'' + this._moduleIdProvider.getStrModuleId(module.id) + '\\'. The cyclic path follows:');\n                    var cyclePath = this._findCyclePath(dependency.id, module.id, 0);\n                    cyclePath.reverse();\n                    cyclePath.push(dependency.id);\n                    console.warn(cyclePath.map(function (id) { return _this._moduleIdProvider.getStrModuleId(id); }).join(' => \\n'));\n                    // Break the cycle\n                    module.unresolvedDependenciesCount--;\n                    continue;\n                }\n                // record inverse dependency\n                this._inverseDependencies2[dependency.id] = this._inverseDependencies2[dependency.id] || [];\n                this._inverseDependencies2[dependency.id].push(module.id);\n                if (dependency instanceof PluginDependency) {\n                    var plugin = this._modules2[dependency.pluginId];\n                    if (plugin && plugin.isComplete()) {\n                        this._loadPluginDependency(plugin.exports, dependency);\n                        continue;\n                    }\n                    // Record dependency for when the plugin gets loaded\n                    var inversePluginDeps = this._inversePluginDependencies2.get(dependency.pluginId);\n                    if (!inversePluginDeps) {\n                        inversePluginDeps = [];\n                        this._inversePluginDependencies2.set(dependency.pluginId, inversePluginDeps);\n                    }\n                    inversePluginDeps.push(dependency);\n                    this._loadModule(dependency.pluginId);\n                    continue;\n                }\n                this._loadModule(dependency.id);\n            }\n            if (module.unresolvedDependenciesCount === 0) {\n                this._onModuleComplete(module);\n            }\n        };\n        ModuleManager.prototype._onModuleComplete = function (module) {\n            var _this = this;\n            var recorder = this.getRecorder();\n            if (module.isComplete()) {\n                // already done\n                return;\n            }\n            var dependencies = module.dependencies;\n            var dependenciesValues = [];\n            for (var i = 0, len = dependencies.length; i < len; i++) {\n                var dependency = dependencies[i];\n                if (dependency === RegularDependency.EXPORTS) {\n                    dependenciesValues[i] = module.exports;\n                    continue;\n                }\n                if (dependency === RegularDependency.MODULE) {\n                    dependenciesValues[i] = {\n                        id: module.strId,\n                        config: function () {\n                            return _this._config.getConfigForModule(module.strId);\n                        }\n                    };\n                    continue;\n                }\n                if (dependency === RegularDependency.REQUIRE) {\n                    dependenciesValues[i] = this._createRequire(module.moduleIdResolver);\n                    continue;\n                }\n                var dependencyModule = this._modules2[dependency.id];\n                if (dependencyModule) {\n                    dependenciesValues[i] = dependencyModule.exports;\n                    continue;\n                }\n                dependenciesValues[i] = null;\n            }\n            module.complete(recorder, this._config, dependenciesValues);\n            // Fetch and clear inverse dependencies\n            var inverseDeps = this._inverseDependencies2[module.id];\n            this._inverseDependencies2[module.id] = null;\n            if (inverseDeps) {\n                // Resolve one inverse dependency at a time, always\n                // on the lookout for a completed module.\n                for (var i = 0, len = inverseDeps.length; i < len; i++) {\n                    var inverseDependencyId = inverseDeps[i];\n                    var inverseDependency = this._modules2[inverseDependencyId];\n                    inverseDependency.unresolvedDependenciesCount--;\n                    if (inverseDependency.unresolvedDependenciesCount === 0) {\n                        this._onModuleComplete(inverseDependency);\n                    }\n                }\n            }\n            var inversePluginDeps = this._inversePluginDependencies2.get(module.id);\n            if (inversePluginDeps) {\n                // This module is used as a plugin at least once\n                // Fetch and clear these inverse plugin dependencies\n                this._inversePluginDependencies2.delete(module.id);\n                // Resolve plugin dependencies one at a time\n                for (var i = 0, len = inversePluginDeps.length; i < len; i++) {\n                    this._loadPluginDependency(module.exports, inversePluginDeps[i]);\n                }\n            }\n        };\n        return ModuleManager;\n    }());\n    AMDLoader.ModuleManager = ModuleManager;\n})(AMDLoader || (AMDLoader = {}));\nvar define;\nvar AMDLoader;\n(function (AMDLoader) {\n    var env = new AMDLoader.Environment();\n    var moduleManager = null;\n    var DefineFunc = function (id, dependencies, callback) {\n        if (typeof id !== 'string') {\n            callback = dependencies;\n            dependencies = id;\n            id = null;\n        }\n        if (typeof dependencies !== 'object' || !Array.isArray(dependencies)) {\n            callback = dependencies;\n            dependencies = null;\n        }\n        if (!dependencies) {\n            dependencies = ['require', 'exports', 'module'];\n        }\n        if (id) {\n            moduleManager.defineModule(id, dependencies, callback, null, null);\n        }\n        else {\n            moduleManager.enqueueDefineAnonymousModule(dependencies, callback);\n        }\n    };\n    DefineFunc.amd = {\n        jQuery: true\n    };\n    var _requireFunc_config = function (params, shouldOverwrite) {\n        if (shouldOverwrite === void 0) { shouldOverwrite = false; }\n        moduleManager.configure(params, shouldOverwrite);\n    };\n    var RequireFunc = function () {\n        if (arguments.length === 1) {\n            if ((arguments[0] instanceof Object) && !Array.isArray(arguments[0])) {\n                _requireFunc_config(arguments[0]);\n                return;\n            }\n            if (typeof arguments[0] === 'string') {\n                return moduleManager.synchronousRequire(arguments[0]);\n            }\n        }\n        if (arguments.length === 2 || arguments.length === 3) {\n            if (Array.isArray(arguments[0])) {\n                moduleManager.defineModule(AMDLoader.Utilities.generateAnonymousModule(), arguments[0], arguments[1], arguments[2], null);\n                return;\n            }\n        }\n        throw new Error('Unrecognized require call');\n    };\n    RequireFunc.config = _requireFunc_config;\n    RequireFunc.getConfig = function () {\n        return moduleManager.getConfig().getOptionsLiteral();\n    };\n    RequireFunc.reset = function () {\n        moduleManager = moduleManager.reset();\n    };\n    RequireFunc.getBuildInfo = function () {\n        return moduleManager.getBuildInfo();\n    };\n    RequireFunc.getStats = function () {\n        return moduleManager.getLoaderEvents();\n    };\n    RequireFunc.define = function () {\n        return DefineFunc.apply(null, arguments);\n    };\n    function init() {\n        if (typeof AMDLoader.global.require !== 'undefined' || typeof require !== 'undefined') {\n            var _nodeRequire_1 = (AMDLoader.global.require || require);\n            if (typeof _nodeRequire_1 === 'function' && typeof _nodeRequire_1.resolve === 'function') {\n                // re-expose node's require function\n                var nodeRequire = function (what) {\n                    moduleManager.getRecorder().record(33 /* NodeBeginNativeRequire */, what);\n                    try {\n                        return _nodeRequire_1(what);\n                    }\n                    finally {\n                        moduleManager.getRecorder().record(34 /* NodeEndNativeRequire */, what);\n                    }\n                };\n                AMDLoader.global.nodeRequire = nodeRequire;\n                RequireFunc.nodeRequire = nodeRequire;\n                RequireFunc.__$__nodeRequire = nodeRequire;\n            }\n        }\n        if (env.isNode && !env.isElectronRenderer) {\n            module.exports = RequireFunc;\n            require = RequireFunc;\n        }\n        else {\n            if (!env.isElectronRenderer) {\n                AMDLoader.global.define = DefineFunc;\n            }\n            AMDLoader.global.require = RequireFunc;\n        }\n    }\n    AMDLoader.init = init;\n    if (typeof AMDLoader.global.define !== 'function' || !AMDLoader.global.define.amd) {\n        moduleManager = new AMDLoader.ModuleManager(env, AMDLoader.createScriptLoader(env), DefineFunc, RequireFunc, AMDLoader.Utilities.getHighPerformanceTimestamp());\n        // The global variable require can configure the loader\n        if (typeof AMDLoader.global.require !== 'undefined' && typeof AMDLoader.global.require !== 'function') {\n            RequireFunc.config(AMDLoader.global.require);\n        }\n        // This define is for the local closure defined in node in the case that the loader is concatenated\n        define = function () {\n            return DefineFunc.apply(null, arguments);\n        };\n        define.amd = DefineFunc.amd;\n        if (typeof doNotInitLoader === 'undefined') {\n            init();\n        }\n    }\n})(AMDLoader || (AMDLoader = {}));\n"]}