{"version":3,"sources":["vs/vs/loader.js"],"names":["_amdLoaderGlobal","this","AMDLoader","global","isNode","module","exports","isWindows","navigator","userAgent","indexOf","process","platform","isWebWorker","importScripts","isElectronRenderer","versions","electron","type","isElectronMain","hasPerformanceNow","performance","now","getHighPerformanceTimestamp","Date","LoaderEventType","LoaderEvent","detail","timestamp","LoaderEventRecorder","loaderAvailableTimestamp","_events","LoaderAvailable","prototype","record","push","getEvents","NullLoaderEventRecorder","INSTANCE","Utilities","fileUriToFilePath","uri","decodeURI","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","ConfigurationOptionsUtil","validateConfigurationOptions","options","defaultOnError","err","errorCode","console","error","moduleId","stack","neededBy","baseUrl","isBuild","paths","config","catchError","urlArgs","onError","ignoreDuplicateModules","nodeModules","nodeCachedDataWriteDelay","onNodeCachedDataError","warn","path","mergeConfigurationOptions","overwrite","base","concat","key2","value2","Configuration","_createIgnoreDuplicateModulesMap","_createNodeModulesMap","_createSortedPathsRules","nodeRequire","main","filename","nodeMain","dirnameIndex","Math","max","lastIndexOf","substring","ignoreDuplicateModulesMap","i","nodeModulesMap","Object","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","actualScriptLoader","callbackMap","load","moduleManager","scriptSrc","errorback","scriptCallbacks","triggerCallback","triggerErrorback","BrowserScriptLoader","attachListeners","script","unbind","removeEventListener","loadEventListener","errorEventListener","e","addEventListener","document","createElement","setAttribute","getElementsByTagName","appendChild","WorkerScriptLoader","NodeScriptLoader","_initialized","_init","_fs","_vm","_path","_crypto","opts","getConfig","nodeInstrumenter","c","recorder","getRecorder","pieces","split","moduleExports_1","enqueueDefineAnonymousModule","readFile","encoding","data","vmScriptSrc","normalize","driveLetterMatch","match","toUpperCase","replace","contents","prefix","suffix","charCodeAt","_BOM","nodeCachedDataDir","cachedDataPath_1","_getCachedDataPath","scriptOptions","produceCachedData","cachedData","_loadAndEvalScript","cachedDataRejected","_runSoon","unlink","cachedDataProduced","writeFile","NodeBeginEvaluatingScript","Script","r","runInThisContext","call","RequireFunc","DefineFunc","dirname","NodeEndEvaluatingScript","baseDir","hash","createHash","update","digest","basename","join","minTimeout","timeout","ceil","random","setTimeout","scriptLoader","ModuleIdResolver","fromModuleId","lastSlash","fromModulePath","_normalizeModuleId","pattern","resolveModule","ROOT","Module","strId","dependencies","moduleIdResolver","_callback","_errorback","exportsPassedIn","unresolvedDependenciesCount","_isComplete","_safeInvokeFunction","args","returnedValue","apply","producedError","_invokeFactory","strModuleId","dependenciesValues","complete","BeginInvokeFactory","EndInvokeFactory","onDependencyError","isComplete","ModuleIdProvider","_nextId","_strModuleIdToIntModuleId","Map","_intModuleIdToStrModuleId","getModuleId","getMaxModuleId","get","set","getStrModuleId","RegularDependency","EXPORTS","MODULE","REQUIRE","PluginDependency","pluginId","pluginParam","ModuleManager","_recorder","_loaderAvailableTimestamp","_moduleIdProvider","_config","_scriptLoader","_modules2","_knownModules2","_inverseDependencies2","_inversePluginDependencies2","_currentAnnonymousDefineCall","_buildInfoPath","_buildInfoDefineStack","_buildInfoDependencies","_findRelevantLocationInStack","str","normalizedPath","stackPieces","m","stackPath","stackLine","stackColumn","trimPathOffset","line","parseInt","col","Error","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","element","dependencyModule","_findCyclePath","depth","_createRequire","toUrl","getStats","__$__nodeRequire","_loadModule","lastPathIndex","loadNextPath","currentPath_1","recorder_1","BeginLoadingScript","EndLoadingScriptOK","EndLoadingScriptError","_loadPluginDependency","plugin","pluginDependency","cyclePath","reverse","inversePluginDeps","_onModuleComplete","inverseDependencyId","inverseDependency","delete","define","init","_nodeRequire","require","what","NodeBeginNativeRequire","NodeEndNativeRequire","arguments","amd","jQuery","reset"],"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/*---------------------------------------------------------------------------------------------\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 AMDLoader;\n(function (AMDLoader) {\n    AMDLoader.global = _amdLoaderGlobal;\n    AMDLoader.isNode = (typeof module !== 'undefined' && !!module.exports);\n    AMDLoader.isWindows = (function _isWindows() {\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    AMDLoader.isWebWorker = (typeof AMDLoader.global.importScripts === 'function');\n    AMDLoader.isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');\n    AMDLoader.isElectronMain = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'browser');\n    AMDLoader.hasPerformanceNow = (AMDLoader.global.performance && typeof AMDLoader.global.performance.now === 'function');\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 LoaderEventType;\n    (function (LoaderEventType) {\n        LoaderEventType[LoaderEventType[\"LoaderAvailable\"] = 1] = \"LoaderAvailable\";\n        LoaderEventType[LoaderEventType[\"BeginLoadingScript\"] = 10] = \"BeginLoadingScript\";\n        LoaderEventType[LoaderEventType[\"EndLoadingScriptOK\"] = 11] = \"EndLoadingScriptOK\";\n        LoaderEventType[LoaderEventType[\"EndLoadingScriptError\"] = 12] = \"EndLoadingScriptError\";\n        LoaderEventType[LoaderEventType[\"BeginInvokeFactory\"] = 21] = \"BeginInvokeFactory\";\n        LoaderEventType[LoaderEventType[\"EndInvokeFactory\"] = 22] = \"EndInvokeFactory\";\n        LoaderEventType[LoaderEventType[\"NodeBeginEvaluatingScript\"] = 31] = \"NodeBeginEvaluatingScript\";\n        LoaderEventType[LoaderEventType[\"NodeEndEvaluatingScript\"] = 32] = \"NodeEndEvaluatingScript\";\n        LoaderEventType[LoaderEventType[\"NodeBeginNativeRequire\"] = 33] = \"NodeBeginNativeRequire\";\n        LoaderEventType[LoaderEventType[\"NodeEndNativeRequire\"] = 34] = \"NodeEndNativeRequire\";\n    })(LoaderEventType = AMDLoader.LoaderEventType || (AMDLoader.LoaderEventType = {}));\n    function getHighPerformanceTimestamp() {\n        return (AMDLoader.hasPerformanceNow ? AMDLoader.global.performance.now() : Date.now());\n    }\n    AMDLoader.getHighPerformanceTimestamp = getHighPerformanceTimestamp;\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(LoaderEventType.LoaderAvailable, '', loaderAvailableTimestamp)];\n        }\n        LoaderEventRecorder.prototype.record = function (type, detail) {\n            this._events.push(new LoaderEvent(type, detail, 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 (uri) {\n            uri = decodeURI(uri);\n            if (AMDLoader.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 /^===anonymous/.test(id);\n        };\n        return Utilities;\n    }());\n    Utilities.NEXT_ANONYMOUS_ID = 1;\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                // Catch errors by default in web workers, do not catch errors by default in other contexts\n                options.catchError = AMDLoader.isWebWorker;\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 (!Array.isArray(options.nodeModules)) {\n                options.nodeModules = [];\n            }\n            if (typeof options.nodeCachedDataWriteDelay !== 'number' || options.nodeCachedDataWriteDelay < 0) {\n                options.nodeCachedDataWriteDelay = 1000 * 7;\n            }\n            if (typeof options.onNodeCachedDataError !== 'function') {\n                options.onNodeCachedDataError = function (err) {\n                    if (err.errorCode === 'cachedDataRejected') {\n                        console.warn('Rejected cached data from file: ' + err.path);\n                    }\n                    else if (err.errorCode === 'unlink' || err.errorCode === 'writeFile') {\n                        console.error('Problems writing cached data file: ' + err.path);\n                        console.error(err.detail);\n                    }\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(options) {\n            this.options = ConfigurationOptionsUtil.mergeConfigurationOptions(options);\n            this._createIgnoreDuplicateModulesMap();\n            this._createNodeModulesMap();\n            this._createSortedPathsRules();\n            if (this.options.baseUrl === '') {\n                if (AMDLoader.isNode && this.options.nodeRequire && this.options.nodeRequire.main && this.options.nodeRequire.main.filename) {\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 (AMDLoader.isNode && this.options.nodeMain) {\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(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(actualScriptLoader) {\n            this.actualScriptLoader = actualScriptLoader;\n            this.callbackMap = {};\n        }\n        OnlyOnceScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n            var _this = this;\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.actualScriptLoader.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            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() {\n            this._initialized = false;\n        }\n        NodeScriptLoader.prototype._init = function (nodeRequire) {\n            if (this._initialized) {\n                return;\n            }\n            this._initialized = true;\n            this._fs = nodeRequire('fs');\n            this._vm = nodeRequire('vm');\n            this._path = nodeRequire('path');\n            this._crypto = nodeRequire('crypto');\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            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(scriptSrc);\n                this._fs.readFile(scriptSrc, { encoding: 'utf8' }, function (err, data) {\n                    if (err) {\n                        errorback(err);\n                        return;\n                    }\n                    var vmScriptSrc = _this._path.normalize(scriptSrc);\n                    // Make the script src friendly towards electron\n                    if (AMDLoader.isElectronRenderer) {\n                        var driveLetterMatch = vmScriptSrc.match(/^([a-z])\\:(.*)/i);\n                        if (driveLetterMatch) {\n                            vmScriptSrc = driveLetterMatch[1].toUpperCase() + ':' + driveLetterMatch[2];\n                        }\n                        vmScriptSrc = 'file:///' + vmScriptSrc.replace(/\\\\/g, '/');\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, vmScriptSrc);\n                    if (!opts.nodeCachedDataDir) {\n                        _this._loadAndEvalScript(scriptSrc, vmScriptSrc, contents, { filename: vmScriptSrc }, recorder);\n                        callback();\n                    }\n                    else {\n                        var cachedDataPath_1 = _this._getCachedDataPath(opts.nodeCachedDataDir, scriptSrc);\n                        _this._fs.readFile(cachedDataPath_1, function (err, data) {\n                            // create script options\n                            var scriptOptions = {\n                                filename: vmScriptSrc,\n                                produceCachedData: typeof data === 'undefined',\n                                cachedData: data\n                            };\n                            var script = _this._loadAndEvalScript(scriptSrc, vmScriptSrc, contents, scriptOptions, recorder);\n                            callback();\n                            // cached code after math\n                            if (script.cachedDataRejected) {\n                                // data rejected => delete cache file\n                                opts.onNodeCachedDataError({\n                                    errorCode: 'cachedDataRejected',\n                                    path: cachedDataPath_1\n                                });\n                                NodeScriptLoader._runSoon(function () { return _this._fs.unlink(cachedDataPath_1, function (err) {\n                                    if (err) {\n                                        moduleManager.getConfig().getOptionsLiteral().onNodeCachedDataError({\n                                            errorCode: 'unlink',\n                                            path: cachedDataPath_1,\n                                            detail: err\n                                        });\n                                    }\n                                }); }, opts.nodeCachedDataWriteDelay);\n                            }\n                            else if (script.cachedDataProduced) {\n                                // data produced => write cache file\n                                NodeScriptLoader._runSoon(function () { return _this._fs.writeFile(cachedDataPath_1, script.cachedData, function (err) {\n                                    if (err) {\n                                        moduleManager.getConfig().getOptionsLiteral().onNodeCachedDataError({\n                                            errorCode: 'writeFile',\n                                            path: cachedDataPath_1,\n                                            detail: err\n                                        });\n                                    }\n                                }); }, opts.nodeCachedDataWriteDelay);\n                            }\n                        });\n                    }\n                });\n            }\n        };\n        NodeScriptLoader.prototype._loadAndEvalScript = function (scriptSrc, vmScriptSrc, contents, options, recorder) {\n            // create script, run script\n            recorder.record(AMDLoader.LoaderEventType.NodeBeginEvaluatingScript, scriptSrc);\n            var script = new this._vm.Script(contents, options);\n            var r = script.runInThisContext(options);\n            r.call(AMDLoader.global, AMDLoader.RequireFunc, AMDLoader.DefineFunc, vmScriptSrc, this._path.dirname(scriptSrc));\n            // signal done\n            recorder.record(AMDLoader.LoaderEventType.NodeEndEvaluatingScript, scriptSrc);\n            return script;\n        };\n        NodeScriptLoader.prototype._getCachedDataPath = function (baseDir, filename) {\n            var hash = this._crypto.createHash('md5').update(filename, 'utf8').digest('hex');\n            var basename = this._path.basename(filename).replace(/\\.js$/, '');\n            return this._path.join(baseDir, hash + \"-\" + basename + \".code\");\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    AMDLoader.scriptLoader = new OnlyOnceScriptLoader(AMDLoader.isWebWorker ?\n        new WorkerScriptLoader()\n        : AMDLoader.isNode ?\n            new NodeScriptLoader()\n            : new BrowserScriptLoader());\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(AMDLoader.LoaderEventType.BeginInvokeFactory, this.strId);\n                    var r = Module._invokeFactory(config, this.strId, this._callback, dependenciesValues);\n                    producedError = r.producedError;\n                    recorder.record(AMDLoader.LoaderEventType.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(scriptLoader, loaderAvailableTimestamp) {\n            if (loaderAvailableTimestamp === void 0) { loaderAvailableTimestamp = 0; }\n            this._recorder = null;\n            this._loaderAvailableTimestamp = loaderAvailableTimestamp;\n            this._moduleIdProvider = new ModuleIdProvider();\n            this._config = new AMDLoader.Configuration();\n            this._scriptLoader = scriptLoader;\n            this._modules2 = [];\n            this._knownModules2 = [];\n            this._inverseDependencies2 = [];\n            this._inversePluginDependencies2 = new Map();\n            this._currentAnnonymousDefineCall = null;\n            this._buildInfoPath = [];\n            this._buildInfoDefineStack = [];\n            this._buildInfoDependencies = [];\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(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            if (AMDLoader.isNode && strModuleId.indexOf('/') === -1) {\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(AMDLoader.LoaderEventType.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(AMDLoader.LoaderEventType.EndLoadingScriptOK, currentPath_1);\n                        _this._onLoad(moduleId);\n                    }, function (err) {\n                        recorder_1.record(AMDLoader.LoaderEventType.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 = {}));\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'use strict';\n// Limitation: To load jquery through the loader, always require 'jquery' and add a path for it in the loader configuration\nvar define;\nvar AMDLoader;\n(function (AMDLoader) {\n    var moduleManager;\n    var loaderAvailableTimestamp;\n    var DefineFunc = (function () {\n        function DefineFunc(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        return DefineFunc;\n    }());\n    DefineFunc.amd = {\n        jQuery: true\n    };\n    AMDLoader.DefineFunc = DefineFunc;\n    var RequireFunc = (function () {\n        function RequireFunc() {\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 = function (params, shouldOverwrite) {\n            if (shouldOverwrite === void 0) { shouldOverwrite = false; }\n            moduleManager.configure(params, shouldOverwrite);\n        };\n        RequireFunc.getConfig = function () {\n            return moduleManager.getConfig().getOptionsLiteral();\n        };\n        /**\n         * Non standard extension to reset completely the loader state. This is used for running amdjs tests\n         */\n        RequireFunc.reset = function () {\n            moduleManager = new AMDLoader.ModuleManager(AMDLoader.scriptLoader, loaderAvailableTimestamp);\n        };\n        /**\n         * Non standard extension to fetch loader state for building purposes.\n         */\n        RequireFunc.getBuildInfo = function () {\n            return moduleManager.getBuildInfo();\n        };\n        /**\n         * Non standard extension to fetch loader events\n         */\n        RequireFunc.getStats = function () {\n            return moduleManager.getLoaderEvents();\n        };\n        return RequireFunc;\n    }());\n    AMDLoader.RequireFunc = RequireFunc;\n    function init() {\n        moduleManager = new AMDLoader.ModuleManager(AMDLoader.scriptLoader, loaderAvailableTimestamp);\n        if (AMDLoader.isNode) {\n            var _nodeRequire = (AMDLoader.global.require || require);\n            var nodeRequire = function (what) {\n                moduleManager.getRecorder().record(AMDLoader.LoaderEventType.NodeBeginNativeRequire, what);\n                try {\n                    return _nodeRequire(what);\n                }\n                finally {\n                    moduleManager.getRecorder().record(AMDLoader.LoaderEventType.NodeEndNativeRequire, what);\n                }\n            };\n            AMDLoader.global.nodeRequire = nodeRequire;\n            RequireFunc.nodeRequire = nodeRequire;\n        }\n        if (AMDLoader.isNode && !AMDLoader.isElectronRenderer) {\n            module.exports = RequireFunc;\n            // These two defs are fore the local closure defined in node in the case that the loader is concatenated\n            define = function () {\n                DefineFunc.apply(null, arguments);\n            };\n            require = RequireFunc;\n        }\n        else {\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            if (!AMDLoader.isElectronRenderer) {\n                AMDLoader.global.define = define = DefineFunc;\n            }\n            else {\n                define = function () {\n                    DefineFunc.apply(null, arguments);\n                };\n            }\n            AMDLoader.global.require = RequireFunc;\n            AMDLoader.global.require.__$__nodeRequire = nodeRequire;\n        }\n    }\n    if (typeof AMDLoader.global.define !== 'function' || !AMDLoader.global.define.amd) {\n        init();\n        loaderAvailableTimestamp = AMDLoader.getHighPerformanceTimestamp();\n    }\n})(AMDLoader || (AMDLoader = {}));\n"]}