From f0195104abd5ba9e95bb54e0789c30bb09cb748d Mon Sep 17 00:00:00 2001
From: Alexandru Dima <alexdima@microsoft.com>
Date: Fri, 24 Feb 2023 22:02:49 +0100
Subject: [PATCH] Adopt latest loader (#175379)

* Adopt latest loader

* Update to latest loader
---
 src/vs/loader.js | 1154 ++++++++++++++++++++++------------------------
 1 file changed, 544 insertions(+), 610 deletions(-)

diff --git a/src/vs/loader.js b/src/vs/loader.js
index 67ef8665099..5c71e7aacf5 100644
--- a/src/vs/loader.js
+++ b/src/vs/loader.js
@@ -18,13 +18,33 @@
  *---------------------------------------------------------------------------------------------
  *---------------------------------------------------------------------------------------------
  *--------------------------------------------------------------------------------------------*/
-var _amdLoaderGlobal = this;
-var _commonjsGlobal = typeof global === 'object' ? global : {};
+const _amdLoaderGlobal = this;
+const _commonjsGlobal = typeof global === 'object' ? global : {};
 var AMDLoader;
 (function (AMDLoader) {
     AMDLoader.global = _amdLoaderGlobal;
-    var Environment = /** @class */ (function () {
-        function Environment() {
+    class Environment {
+        get isWindows() {
+            this._detect();
+            return this._isWindows;
+        }
+        get isNode() {
+            this._detect();
+            return this._isNode;
+        }
+        get isElectronRenderer() {
+            this._detect();
+            return this._isElectronRenderer;
+        }
+        get isWebWorker() {
+            this._detect();
+            return this._isWebWorker;
+        }
+        get isElectronNodeIntegrationWebWorker() {
+            this._detect();
+            return this._isElectronNodeIntegrationWebWorker;
+        }
+        constructor() {
             this._detected = false;
             this._isWindows = false;
             this._isNode = false;
@@ -32,47 +52,7 @@ var AMDLoader;
             this._isWebWorker = false;
             this._isElectronNodeIntegrationWebWorker = false;
         }
-        Object.defineProperty(Environment.prototype, "isWindows", {
-            get: function () {
-                this._detect();
-                return this._isWindows;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(Environment.prototype, "isNode", {
-            get: function () {
-                this._detect();
-                return this._isNode;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(Environment.prototype, "isElectronRenderer", {
-            get: function () {
-                this._detect();
-                return this._isElectronRenderer;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(Environment.prototype, "isWebWorker", {
-            get: function () {
-                this._detect();
-                return this._isWebWorker;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(Environment.prototype, "isElectronNodeIntegrationWebWorker", {
-            get: function () {
-                this._detect();
-                return this._isElectronNodeIntegrationWebWorker;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Environment.prototype._detect = function () {
+        _detect() {
             if (this._detected) {
                 return;
             }
@@ -82,8 +62,8 @@ var AMDLoader;
             this._isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');
             this._isWebWorker = (typeof AMDLoader.global.importScripts === 'function');
             this._isElectronNodeIntegrationWebWorker = this._isWebWorker && (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'worker');
-        };
-        Environment._isWindows = function () {
+        }
+        static _isWindows() {
             if (typeof navigator !== 'undefined') {
                 if (navigator.userAgent && navigator.userAgent.indexOf('Windows') >= 0) {
                     return true;
@@ -93,9 +73,8 @@ var AMDLoader;
                 return (process.platform === 'win32');
             }
             return false;
-        };
-        return Environment;
-    }());
+        }
+    }
     AMDLoader.Environment = Environment;
 })(AMDLoader || (AMDLoader = {}));
 /*---------------------------------------------------------------------------------------------
@@ -104,40 +83,35 @@ var AMDLoader;
  *--------------------------------------------------------------------------------------------*/
 var AMDLoader;
 (function (AMDLoader) {
-    var LoaderEvent = /** @class */ (function () {
-        function LoaderEvent(type, detail, timestamp) {
+    class LoaderEvent {
+        constructor(type, detail, timestamp) {
             this.type = type;
             this.detail = detail;
             this.timestamp = timestamp;
         }
-        return LoaderEvent;
-    }());
+    }
     AMDLoader.LoaderEvent = LoaderEvent;
-    var LoaderEventRecorder = /** @class */ (function () {
-        function LoaderEventRecorder(loaderAvailableTimestamp) {
-            this._events = [new LoaderEvent(1 /* LoaderAvailable */, '', loaderAvailableTimestamp)];
+    class LoaderEventRecorder {
+        constructor(loaderAvailableTimestamp) {
+            this._events = [new LoaderEvent(1 /* LoaderEventType.LoaderAvailable */, '', loaderAvailableTimestamp)];
         }
-        LoaderEventRecorder.prototype.record = function (type, detail) {
+        record(type, detail) {
             this._events.push(new LoaderEvent(type, detail, AMDLoader.Utilities.getHighPerformanceTimestamp()));
-        };
-        LoaderEventRecorder.prototype.getEvents = function () {
-            return this._events;
-        };
-        return LoaderEventRecorder;
-    }());
-    AMDLoader.LoaderEventRecorder = LoaderEventRecorder;
-    var NullLoaderEventRecorder = /** @class */ (function () {
-        function NullLoaderEventRecorder() {
         }
-        NullLoaderEventRecorder.prototype.record = function (type, detail) {
+        getEvents() {
+            return this._events;
+        }
+    }
+    AMDLoader.LoaderEventRecorder = LoaderEventRecorder;
+    class NullLoaderEventRecorder {
+        record(type, detail) {
             // Nothing to do
-        };
-        NullLoaderEventRecorder.prototype.getEvents = function () {
+        }
+        getEvents() {
             return [];
-        };
-        NullLoaderEventRecorder.INSTANCE = new NullLoaderEventRecorder();
-        return NullLoaderEventRecorder;
-    }());
+        }
+    }
+    NullLoaderEventRecorder.INSTANCE = new NullLoaderEventRecorder();
     AMDLoader.NullLoaderEventRecorder = NullLoaderEventRecorder;
 })(AMDLoader || (AMDLoader = {}));
 /*---------------------------------------------------------------------------------------------
@@ -146,13 +120,11 @@ var AMDLoader;
  *--------------------------------------------------------------------------------------------*/
 var AMDLoader;
 (function (AMDLoader) {
-    var Utilities = /** @class */ (function () {
-        function Utilities() {
-        }
+    class Utilities {
         /**
          * This method does not take care of / vs \
          */
-        Utilities.fileUriToFilePath = function (isWindows, uri) {
+        static fileUriToFilePath(isWindows, uri) {
             uri = decodeURI(uri).replace(/%23/g, '#');
             if (isWindows) {
                 if (/^file:\/\/\//.test(uri)) {
@@ -170,41 +142,41 @@ var AMDLoader;
             }
             // Not sure...
             return uri;
-        };
-        Utilities.startsWith = function (haystack, needle) {
+        }
+        static startsWith(haystack, needle) {
             return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;
-        };
-        Utilities.endsWith = function (haystack, needle) {
+        }
+        static endsWith(haystack, needle) {
             return haystack.length >= needle.length && haystack.substr(haystack.length - needle.length) === needle;
-        };
+        }
         // only check for "?" before "#" to ensure that there is a real Query-String
-        Utilities.containsQueryString = function (url) {
+        static containsQueryString(url) {
             return /^[^\#]*\?/gi.test(url);
-        };
+        }
         /**
          * Does `url` start with http:// or https:// or file:// or / ?
          */
-        Utilities.isAbsolutePath = function (url) {
+        static isAbsolutePath(url) {
             return /^((http:\/\/)|(https:\/\/)|(file:\/\/)|(\/))/.test(url);
-        };
-        Utilities.forEachProperty = function (obj, callback) {
+        }
+        static forEachProperty(obj, callback) {
             if (obj) {
-                var key = void 0;
+                let key;
                 for (key in obj) {
                     if (obj.hasOwnProperty(key)) {
                         callback(key, obj[key]);
                     }
                 }
             }
-        };
-        Utilities.isEmpty = function (obj) {
-            var isEmpty = true;
-            Utilities.forEachProperty(obj, function () {
+        }
+        static isEmpty(obj) {
+            let isEmpty = true;
+            Utilities.forEachProperty(obj, () => {
                 isEmpty = false;
             });
             return isEmpty;
-        };
-        Utilities.recursiveClone = function (obj) {
+        }
+        static recursiveClone(obj) {
             if (!obj || typeof obj !== 'object' || obj instanceof RegExp) {
                 return obj;
             }
@@ -212,8 +184,8 @@ var AMDLoader;
                 // only clone "simple" objects
                 return obj;
             }
-            var result = Array.isArray(obj) ? [] : {};
-            Utilities.forEachProperty(obj, function (key, value) {
+            let result = Array.isArray(obj) ? [] : {};
+            Utilities.forEachProperty(obj, (key, value) => {
                 if (value && typeof value === 'object') {
                     result[key] = Utilities.recursiveClone(value);
                 }
@@ -222,25 +194,24 @@ var AMDLoader;
                 }
             });
             return result;
-        };
-        Utilities.generateAnonymousModule = function () {
+        }
+        static generateAnonymousModule() {
             return '===anonymous' + (Utilities.NEXT_ANONYMOUS_ID++) + '===';
-        };
-        Utilities.isAnonymousModule = function (id) {
+        }
+        static isAnonymousModule(id) {
             return Utilities.startsWith(id, '===anonymous');
-        };
-        Utilities.getHighPerformanceTimestamp = function () {
+        }
+        static getHighPerformanceTimestamp() {
             if (!this.PERFORMANCE_NOW_PROBED) {
                 this.PERFORMANCE_NOW_PROBED = true;
                 this.HAS_PERFORMANCE_NOW = (AMDLoader.global.performance && typeof AMDLoader.global.performance.now === 'function');
             }
             return (this.HAS_PERFORMANCE_NOW ? AMDLoader.global.performance.now() : Date.now());
-        };
-        Utilities.NEXT_ANONYMOUS_ID = 1;
-        Utilities.PERFORMANCE_NOW_PROBED = false;
-        Utilities.HAS_PERFORMANCE_NOW = false;
-        return Utilities;
-    }());
+        }
+    }
+    Utilities.NEXT_ANONYMOUS_ID = 1;
+    Utilities.PERFORMANCE_NOW_PROBED = false;
+    Utilities.HAS_PERFORMANCE_NOW = false;
     AMDLoader.Utilities = Utilities;
 })(AMDLoader || (AMDLoader = {}));
 /*---------------------------------------------------------------------------------------------
@@ -253,7 +224,7 @@ var AMDLoader;
         if (err instanceof Error) {
             return err;
         }
-        var result = new Error(err.message || String(err) || 'Unknown Error');
+        const result = new Error(err.message || String(err) || 'Unknown Error');
         if (err.stack) {
             result.stack = err.stack;
         }
@@ -261,13 +232,11 @@ var AMDLoader;
     }
     AMDLoader.ensureError = ensureError;
     ;
-    var ConfigurationOptionsUtil = /** @class */ (function () {
-        function ConfigurationOptionsUtil() {
-        }
+    class ConfigurationOptionsUtil {
         /**
          * Ensure configuration options make sense
          */
-        ConfigurationOptionsUtil.validateConfigurationOptions = function (options) {
+        static validateConfigurationOptions(options) {
             function defaultOnError(err) {
                 if (err.phase === 'loading') {
                     console.error('Loading "' + err.moduleId + '" failed');
@@ -331,138 +300,134 @@ var AMDLoader;
                     options.nodeCachedData.writeDelay = 1000 * 7;
                 }
                 if (!options.nodeCachedData.path || typeof options.nodeCachedData.path !== 'string') {
-                    var err = ensureError(new Error('INVALID cached data configuration, \'path\' MUST be set'));
+                    const err = ensureError(new Error('INVALID cached data configuration, \'path\' MUST be set'));
                     err.phase = 'configuration';
                     options.onError(err);
                     options.nodeCachedData = undefined;
                 }
             }
             return options;
-        };
-        ConfigurationOptionsUtil.mergeConfigurationOptions = function (overwrite, base) {
-            if (overwrite === void 0) { overwrite = null; }
-            if (base === void 0) { base = null; }
-            var result = AMDLoader.Utilities.recursiveClone(base || {});
+        }
+        static mergeConfigurationOptions(overwrite = null, base = null) {
+            let result = AMDLoader.Utilities.recursiveClone(base || {});
             // Merge known properties and overwrite the unknown ones
-            AMDLoader.Utilities.forEachProperty(overwrite, function (key, value) {
+            AMDLoader.Utilities.forEachProperty(overwrite, (key, value) => {
                 if (key === 'ignoreDuplicateModules' && typeof result.ignoreDuplicateModules !== 'undefined') {
                     result.ignoreDuplicateModules = result.ignoreDuplicateModules.concat(value);
                 }
                 else if (key === 'paths' && typeof result.paths !== 'undefined') {
-                    AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.paths[key2] = value2; });
+                    AMDLoader.Utilities.forEachProperty(value, (key2, value2) => result.paths[key2] = value2);
                 }
                 else if (key === 'config' && typeof result.config !== 'undefined') {
-                    AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.config[key2] = value2; });
+                    AMDLoader.Utilities.forEachProperty(value, (key2, value2) => result.config[key2] = value2);
                 }
                 else {
                     result[key] = AMDLoader.Utilities.recursiveClone(value);
                 }
             });
             return ConfigurationOptionsUtil.validateConfigurationOptions(result);
-        };
-        return ConfigurationOptionsUtil;
-    }());
+        }
+    }
     AMDLoader.ConfigurationOptionsUtil = ConfigurationOptionsUtil;
-    var Configuration = /** @class */ (function () {
-        function Configuration(env, options) {
+    class Configuration {
+        constructor(env, options) {
             this._env = env;
             this.options = ConfigurationOptionsUtil.mergeConfigurationOptions(options);
             this._createIgnoreDuplicateModulesMap();
             this._createSortedPathsRules();
             if (this.options.baseUrl === '') {
                 if (this.options.nodeRequire && this.options.nodeRequire.main && this.options.nodeRequire.main.filename && this._env.isNode) {
-                    var nodeMain = this.options.nodeRequire.main.filename;
-                    var dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\'));
+                    let nodeMain = this.options.nodeRequire.main.filename;
+                    let dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\'));
                     this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);
                 }
             }
         }
-        Configuration.prototype._createIgnoreDuplicateModulesMap = function () {
+        _createIgnoreDuplicateModulesMap() {
             // Build a map out of the ignoreDuplicateModules array
             this.ignoreDuplicateModulesMap = {};
-            for (var i = 0; i < this.options.ignoreDuplicateModules.length; i++) {
+            for (let i = 0; i < this.options.ignoreDuplicateModules.length; i++) {
                 this.ignoreDuplicateModulesMap[this.options.ignoreDuplicateModules[i]] = true;
             }
-        };
-        Configuration.prototype._createSortedPathsRules = function () {
-            var _this = this;
+        }
+        _createSortedPathsRules() {
             // Create an array our of the paths rules, sorted descending by length to
             // result in a more specific -> less specific order
             this.sortedPathsRules = [];
-            AMDLoader.Utilities.forEachProperty(this.options.paths, function (from, to) {
+            AMDLoader.Utilities.forEachProperty(this.options.paths, (from, to) => {
                 if (!Array.isArray(to)) {
-                    _this.sortedPathsRules.push({
+                    this.sortedPathsRules.push({
                         from: from,
                         to: [to]
                     });
                 }
                 else {
-                    _this.sortedPathsRules.push({
+                    this.sortedPathsRules.push({
                         from: from,
                         to: to
                     });
                 }
             });
-            this.sortedPathsRules.sort(function (a, b) {
+            this.sortedPathsRules.sort((a, b) => {
                 return b.from.length - a.from.length;
             });
-        };
+        }
         /**
          * Clone current configuration and overwrite options selectively.
          * @param options The selective options to overwrite with.
          * @result A new configuration
          */
-        Configuration.prototype.cloneAndMerge = function (options) {
+        cloneAndMerge(options) {
             return new Configuration(this._env, ConfigurationOptionsUtil.mergeConfigurationOptions(options, this.options));
-        };
+        }
         /**
          * Get current options bag. Useful for passing it forward to plugins.
          */
-        Configuration.prototype.getOptionsLiteral = function () {
+        getOptionsLiteral() {
             return this.options;
-        };
-        Configuration.prototype._applyPaths = function (moduleId) {
-            var pathRule;
-            for (var i = 0, len = this.sortedPathsRules.length; i < len; i++) {
+        }
+        _applyPaths(moduleId) {
+            let pathRule;
+            for (let i = 0, len = this.sortedPathsRules.length; i < len; i++) {
                 pathRule = this.sortedPathsRules[i];
                 if (AMDLoader.Utilities.startsWith(moduleId, pathRule.from)) {
-                    var result = [];
-                    for (var j = 0, lenJ = pathRule.to.length; j < lenJ; j++) {
+                    let result = [];
+                    for (let j = 0, lenJ = pathRule.to.length; j < lenJ; j++) {
                         result.push(pathRule.to[j] + moduleId.substr(pathRule.from.length));
                     }
                     return result;
                 }
             }
             return [moduleId];
-        };
-        Configuration.prototype._addUrlArgsToUrl = function (url) {
+        }
+        _addUrlArgsToUrl(url) {
             if (AMDLoader.Utilities.containsQueryString(url)) {
                 return url + '&' + this.options.urlArgs;
             }
             else {
                 return url + '?' + this.options.urlArgs;
             }
-        };
-        Configuration.prototype._addUrlArgsIfNecessaryToUrl = function (url) {
+        }
+        _addUrlArgsIfNecessaryToUrl(url) {
             if (this.options.urlArgs) {
                 return this._addUrlArgsToUrl(url);
             }
             return url;
-        };
-        Configuration.prototype._addUrlArgsIfNecessaryToUrls = function (urls) {
+        }
+        _addUrlArgsIfNecessaryToUrls(urls) {
             if (this.options.urlArgs) {
-                for (var i = 0, len = urls.length; i < len; i++) {
+                for (let i = 0, len = urls.length; i < len; i++) {
                     urls[i] = this._addUrlArgsToUrl(urls[i]);
                 }
             }
             return urls;
-        };
+        }
         /**
          * Transform a module id to a location. Appends .js to module ids
          */
-        Configuration.prototype.moduleIdToPaths = function (moduleId) {
+        moduleIdToPaths(moduleId) {
             if (this._env.isNode) {
-                var isNodeModule = (this.options.amdModulesPattern instanceof RegExp
+                const isNodeModule = (this.options.amdModulesPattern instanceof RegExp
                     && !this.options.amdModulesPattern.test(moduleId));
                 if (isNodeModule) {
                     // This is a node module...
@@ -476,11 +441,11 @@ var AMDLoader;
                     }
                 }
             }
-            var result = moduleId;
-            var results;
+            let result = moduleId;
+            let results;
             if (!AMDLoader.Utilities.endsWith(result, '.js') && !AMDLoader.Utilities.isAbsolutePath(result)) {
                 results = this._applyPaths(result);
-                for (var i = 0, len = results.length; i < len; i++) {
+                for (let i = 0, len = results.length; i < len; i++) {
                     if (this.isBuild() && results[i] === 'empty:') {
                         continue;
                     }
@@ -499,12 +464,12 @@ var AMDLoader;
                 results = [result];
             }
             return this._addUrlArgsIfNecessaryToUrls(results);
-        };
+        }
         /**
          * Transform a module id or url to a location.
          */
-        Configuration.prototype.requireToUrl = function (url) {
-            var result = url;
+        requireToUrl(url) {
+            let result = url;
             if (!AMDLoader.Utilities.isAbsolutePath(result)) {
                 result = this._applyPaths(result)[0];
                 if (!AMDLoader.Utilities.isAbsolutePath(result)) {
@@ -512,14 +477,14 @@ var AMDLoader;
                 }
             }
             return this._addUrlArgsIfNecessaryToUrl(result);
-        };
+        }
         /**
          * Flag to indicate if current execution is as part of a build.
          */
-        Configuration.prototype.isBuild = function () {
+        isBuild() {
             return this.options.isBuild;
-        };
-        Configuration.prototype.shouldInvokeFactory = function (strModuleId) {
+        }
+        shouldInvokeFactory(strModuleId) {
             if (!this.options.isBuild) {
                 // outside of a build, all factories should be invoked
                 return true;
@@ -532,41 +497,40 @@ var AMDLoader;
                 return true;
             }
             return false;
-        };
+        }
         /**
          * Test if module `moduleId` is expected to be defined multiple times
          */
-        Configuration.prototype.isDuplicateMessageIgnoredFor = function (moduleId) {
+        isDuplicateMessageIgnoredFor(moduleId) {
             return this.ignoreDuplicateModulesMap.hasOwnProperty(moduleId);
-        };
+        }
         /**
          * Get the configuration settings for the provided module id
          */
-        Configuration.prototype.getConfigForModule = function (moduleId) {
+        getConfigForModule(moduleId) {
             if (this.options.config) {
                 return this.options.config[moduleId];
             }
-        };
+        }
         /**
          * Should errors be caught when executing module factories?
          */
-        Configuration.prototype.shouldCatchError = function () {
+        shouldCatchError() {
             return this.options.catchError;
-        };
+        }
         /**
          * Should statistics be recorded?
          */
-        Configuration.prototype.shouldRecordStats = function () {
+        shouldRecordStats() {
             return this.options.recordStats;
-        };
+        }
         /**
          * Forward an error to the error handler.
          */
-        Configuration.prototype.onError = function (err) {
+        onError(err) {
             this.options.onError(err);
-        };
-        return Configuration;
-    }());
+        }
+    }
     AMDLoader.Configuration = Configuration;
 })(AMDLoader || (AMDLoader = {}));
 /*---------------------------------------------------------------------------------------------
@@ -578,20 +542,19 @@ var AMDLoader;
     /**
      * Load `scriptSrc` only once (avoid multiple <script> tags)
      */
-    var OnlyOnceScriptLoader = /** @class */ (function () {
-        function OnlyOnceScriptLoader(env) {
+    class OnlyOnceScriptLoader {
+        constructor(env) {
             this._env = env;
             this._scriptLoader = null;
             this._callbackMap = {};
         }
-        OnlyOnceScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
-            var _this = this;
+        load(moduleManager, scriptSrc, callback, errorback) {
             if (!this._scriptLoader) {
                 if (this._env.isWebWorker) {
                     this._scriptLoader = new WorkerScriptLoader();
                 }
                 else if (this._env.isElectronRenderer) {
-                    var preferScriptTags = moduleManager.getConfig().getOptionsLiteral().preferScriptTags;
+                    const { preferScriptTags } = moduleManager.getConfig().getOptionsLiteral();
                     if (preferScriptTags) {
                         this._scriptLoader = new BrowserScriptLoader();
                     }
@@ -606,7 +569,7 @@ var AMDLoader;
                     this._scriptLoader = new BrowserScriptLoader();
                 }
             }
-            var scriptCallbacks = {
+            let scriptCallbacks = {
                 callback: callback,
                 errorback: errorback
             };
@@ -615,87 +578,83 @@ var AMDLoader;
                 return;
             }
             this._callbackMap[scriptSrc] = [scriptCallbacks];
-            this._scriptLoader.load(moduleManager, scriptSrc, function () { return _this.triggerCallback(scriptSrc); }, function (err) { return _this.triggerErrorback(scriptSrc, err); });
-        };
-        OnlyOnceScriptLoader.prototype.triggerCallback = function (scriptSrc) {
-            var scriptCallbacks = this._callbackMap[scriptSrc];
+            this._scriptLoader.load(moduleManager, scriptSrc, () => this.triggerCallback(scriptSrc), (err) => this.triggerErrorback(scriptSrc, err));
+        }
+        triggerCallback(scriptSrc) {
+            let scriptCallbacks = this._callbackMap[scriptSrc];
             delete this._callbackMap[scriptSrc];
-            for (var i = 0; i < scriptCallbacks.length; i++) {
+            for (let i = 0; i < scriptCallbacks.length; i++) {
                 scriptCallbacks[i].callback();
             }
-        };
-        OnlyOnceScriptLoader.prototype.triggerErrorback = function (scriptSrc, err) {
-            var scriptCallbacks = this._callbackMap[scriptSrc];
+        }
+        triggerErrorback(scriptSrc, err) {
+            let scriptCallbacks = this._callbackMap[scriptSrc];
             delete this._callbackMap[scriptSrc];
-            for (var i = 0; i < scriptCallbacks.length; i++) {
+            for (let i = 0; i < scriptCallbacks.length; i++) {
                 scriptCallbacks[i].errorback(err);
             }
-        };
-        return OnlyOnceScriptLoader;
-    }());
-    var BrowserScriptLoader = /** @class */ (function () {
-        function BrowserScriptLoader() {
         }
+    }
+    class BrowserScriptLoader {
         /**
          * Attach load / error listeners to a script element and remove them when either one has fired.
          * Implemented for browsers supporting HTML5 standard 'load' and 'error' events.
          */
-        BrowserScriptLoader.prototype.attachListeners = function (script, callback, errorback) {
-            var unbind = function () {
+        attachListeners(script, callback, errorback) {
+            let unbind = () => {
                 script.removeEventListener('load', loadEventListener);
                 script.removeEventListener('error', errorEventListener);
             };
-            var loadEventListener = function (e) {
+            let loadEventListener = (e) => {
                 unbind();
                 callback();
             };
-            var errorEventListener = function (e) {
+            let errorEventListener = (e) => {
                 unbind();
                 errorback(e);
             };
             script.addEventListener('load', loadEventListener);
             script.addEventListener('error', errorEventListener);
-        };
-        BrowserScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
+        }
+        load(moduleManager, scriptSrc, callback, errorback) {
             if (/^node\|/.test(scriptSrc)) {
-                var opts = moduleManager.getConfig().getOptionsLiteral();
-                var nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
-                var pieces = scriptSrc.split('|');
-                var moduleExports_1 = null;
+                let opts = moduleManager.getConfig().getOptionsLiteral();
+                let nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
+                let pieces = scriptSrc.split('|');
+                let moduleExports = null;
                 try {
-                    moduleExports_1 = nodeRequire(pieces[1]);
+                    moduleExports = nodeRequire(pieces[1]);
                 }
                 catch (err) {
                     errorback(err);
                     return;
                 }
-                moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports_1; });
+                moduleManager.enqueueDefineAnonymousModule([], () => moduleExports);
                 callback();
             }
             else {
-                var script = document.createElement('script');
+                let script = document.createElement('script');
                 script.setAttribute('async', 'async');
                 script.setAttribute('type', 'text/javascript');
                 this.attachListeners(script, callback, errorback);
-                var trustedTypesPolicy = moduleManager.getConfig().getOptionsLiteral().trustedTypesPolicy;
+                const { trustedTypesPolicy } = moduleManager.getConfig().getOptionsLiteral();
                 if (trustedTypesPolicy) {
                     scriptSrc = trustedTypesPolicy.createScriptURL(scriptSrc);
                 }
                 script.setAttribute('src', scriptSrc);
                 // Propagate CSP nonce to dynamically created script tag.
-                var cspNonce = moduleManager.getConfig().getOptionsLiteral().cspNonce;
+                const { cspNonce } = moduleManager.getConfig().getOptionsLiteral();
                 if (cspNonce) {
                     script.setAttribute('nonce', cspNonce);
                 }
                 document.getElementsByTagName('head')[0].appendChild(script);
             }
-        };
-        return BrowserScriptLoader;
-    }());
+        }
+    }
     function canUseEval(moduleManager) {
-        var trustedTypesPolicy = moduleManager.getConfig().getOptionsLiteral().trustedTypesPolicy;
+        const { trustedTypesPolicy } = moduleManager.getConfig().getOptionsLiteral();
         try {
-            var func = (trustedTypesPolicy
+            const func = (trustedTypesPolicy
                 ? self.eval(trustedTypesPolicy.createScript('', 'true'))
                 : new Function('true'));
             func.call(self);
@@ -705,47 +664,47 @@ var AMDLoader;
             return false;
         }
     }
-    var WorkerScriptLoader = /** @class */ (function () {
-        function WorkerScriptLoader() {
+    class WorkerScriptLoader {
+        constructor() {
             this._cachedCanUseEval = null;
         }
-        WorkerScriptLoader.prototype._canUseEval = function (moduleManager) {
+        _canUseEval(moduleManager) {
             if (this._cachedCanUseEval === null) {
                 this._cachedCanUseEval = canUseEval(moduleManager);
             }
             return this._cachedCanUseEval;
-        };
-        WorkerScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
+        }
+        load(moduleManager, scriptSrc, callback, errorback) {
             if (/^node\|/.test(scriptSrc)) {
-                var opts = moduleManager.getConfig().getOptionsLiteral();
-                var nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
-                var pieces = scriptSrc.split('|');
-                var moduleExports_2 = null;
+                const opts = moduleManager.getConfig().getOptionsLiteral();
+                const nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
+                const pieces = scriptSrc.split('|');
+                let moduleExports = null;
                 try {
-                    moduleExports_2 = nodeRequire(pieces[1]);
+                    moduleExports = nodeRequire(pieces[1]);
                 }
                 catch (err) {
                     errorback(err);
                     return;
                 }
-                moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports_2; });
+                moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports; });
                 callback();
             }
             else {
-                var trustedTypesPolicy_1 = moduleManager.getConfig().getOptionsLiteral().trustedTypesPolicy;
-                var isCrossOrigin = (/^((http:)|(https:)|(file:))/.test(scriptSrc) && scriptSrc.substring(0, self.origin.length) !== self.origin);
+                const { trustedTypesPolicy } = moduleManager.getConfig().getOptionsLiteral();
+                const isCrossOrigin = (/^((http:)|(https:)|(file:))/.test(scriptSrc) && scriptSrc.substring(0, self.origin.length) !== self.origin);
                 if (!isCrossOrigin && this._canUseEval(moduleManager)) {
                     // use `fetch` if possible because `importScripts`
                     // is synchronous and can lead to deadlocks on Safari
-                    fetch(scriptSrc).then(function (response) {
+                    fetch(scriptSrc).then((response) => {
                         if (response.status !== 200) {
                             throw new Error(response.statusText);
                         }
                         return response.text();
-                    }).then(function (text) {
-                        text = text + "\n//# sourceURL=" + scriptSrc;
-                        var func = (trustedTypesPolicy_1
-                            ? self.eval(trustedTypesPolicy_1.createScript('', text))
+                    }).then((text) => {
+                        text = `${text}\n//# sourceURL=${scriptSrc}`;
+                        const func = (trustedTypesPolicy
+                            ? self.eval(trustedTypesPolicy.createScript('', text))
                             : new Function(text));
                         func.call(self);
                         callback();
@@ -753,8 +712,8 @@ var AMDLoader;
                     return;
                 }
                 try {
-                    if (trustedTypesPolicy_1) {
-                        scriptSrc = trustedTypesPolicy_1.createScriptURL(scriptSrc);
+                    if (trustedTypesPolicy) {
+                        scriptSrc = trustedTypesPolicy.createScriptURL(scriptSrc);
                     }
                     importScripts(scriptSrc);
                     callback();
@@ -763,16 +722,15 @@ var AMDLoader;
                     errorback(e);
                 }
             }
-        };
-        return WorkerScriptLoader;
-    }());
-    var NodeScriptLoader = /** @class */ (function () {
-        function NodeScriptLoader(env) {
+        }
+    }
+    class NodeScriptLoader {
+        constructor(env) {
             this._env = env;
             this._didInitialize = false;
             this._didPatchNodeRequire = false;
         }
-        NodeScriptLoader.prototype._init = function (nodeRequire) {
+        _init(nodeRequire) {
             if (this._didInitialize) {
                 return;
             }
@@ -782,13 +740,13 @@ var AMDLoader;
             this._vm = nodeRequire('vm');
             this._path = nodeRequire('path');
             this._crypto = nodeRequire('crypto');
-        };
+        }
         // patch require-function of nodejs such that we can manually create a script
         // from cached data. this is done by overriding the `Module._compile` function
-        NodeScriptLoader.prototype._initNodeRequire = function (nodeRequire, moduleManager) {
+        _initNodeRequire(nodeRequire, moduleManager) {
             // It is important to check for `nodeCachedData` first and then set `_didPatchNodeRequire`.
             // That's because `nodeCachedData` is set _after_ calling this for the first time...
-            var nodeCachedData = moduleManager.getConfig().getOptionsLiteral().nodeCachedData;
+            const { nodeCachedData } = moduleManager.getConfig().getOptionsLiteral();
             if (!nodeCachedData) {
                 return;
             }
@@ -796,11 +754,11 @@ var AMDLoader;
                 return;
             }
             this._didPatchNodeRequire = true;
-            var that = this;
-            var Module = nodeRequire('module');
+            const that = this;
+            const Module = nodeRequire('module');
             function makeRequireFunction(mod) {
-                var Module = mod.constructor;
-                var require = function require(path) {
+                const Module = mod.constructor;
+                let require = function require(path) {
                     try {
                         return mod.require(path);
                     }
@@ -821,129 +779,127 @@ var AMDLoader;
             }
             Module.prototype._compile = function (content, filename) {
                 // remove shebang and create wrapper function
-                var scriptSource = Module.wrap(content.replace(/^#!.*/, ''));
+                const scriptSource = Module.wrap(content.replace(/^#!.*/, ''));
                 // create script
-                var recorder = moduleManager.getRecorder();
-                var cachedDataPath = that._getCachedDataPath(nodeCachedData, filename);
-                var options = { filename: filename };
-                var hashData;
+                const recorder = moduleManager.getRecorder();
+                const cachedDataPath = that._getCachedDataPath(nodeCachedData, filename);
+                const options = { filename };
+                let hashData;
                 try {
-                    var data = that._fs.readFileSync(cachedDataPath);
+                    const data = that._fs.readFileSync(cachedDataPath);
                     hashData = data.slice(0, 16);
                     options.cachedData = data.slice(16);
-                    recorder.record(60 /* CachedDataFound */, cachedDataPath);
+                    recorder.record(60 /* LoaderEventType.CachedDataFound */, cachedDataPath);
                 }
                 catch (_e) {
-                    recorder.record(61 /* CachedDataMissed */, cachedDataPath);
+                    recorder.record(61 /* LoaderEventType.CachedDataMissed */, cachedDataPath);
                 }
-                var script = new that._vm.Script(scriptSource, options);
-                var compileWrapper = script.runInThisContext(options);
+                const script = new that._vm.Script(scriptSource, options);
+                const compileWrapper = script.runInThisContext(options);
                 // run script
-                var dirname = that._path.dirname(filename);
-                var require = makeRequireFunction(this);
-                var args = [this.exports, require, this, filename, dirname, process, _commonjsGlobal, Buffer];
-                var result = compileWrapper.apply(this.exports, args);
+                const dirname = that._path.dirname(filename);
+                const require = makeRequireFunction(this);
+                const args = [this.exports, require, this, filename, dirname, process, _commonjsGlobal, Buffer];
+                const result = compileWrapper.apply(this.exports, args);
                 // cached data aftermath
                 that._handleCachedData(script, scriptSource, cachedDataPath, !options.cachedData, moduleManager);
                 that._verifyCachedData(script, scriptSource, cachedDataPath, hashData, moduleManager);
                 return result;
             };
-        };
-        NodeScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
-            var _this = this;
-            var opts = moduleManager.getConfig().getOptionsLiteral();
-            var nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
-            var nodeInstrumenter = (opts.nodeInstrumenter || function (c) { return c; });
+        }
+        load(moduleManager, scriptSrc, callback, errorback) {
+            const opts = moduleManager.getConfig().getOptionsLiteral();
+            const nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
+            const nodeInstrumenter = (opts.nodeInstrumenter || function (c) { return c; });
             this._init(nodeRequire);
             this._initNodeRequire(nodeRequire, moduleManager);
-            var recorder = moduleManager.getRecorder();
+            let recorder = moduleManager.getRecorder();
             if (/^node\|/.test(scriptSrc)) {
-                var pieces = scriptSrc.split('|');
-                var moduleExports_3 = null;
+                let pieces = scriptSrc.split('|');
+                let moduleExports = null;
                 try {
-                    moduleExports_3 = nodeRequire(pieces[1]);
+                    moduleExports = nodeRequire(pieces[1]);
                 }
                 catch (err) {
                     errorback(err);
                     return;
                 }
-                moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports_3; });
+                moduleManager.enqueueDefineAnonymousModule([], () => moduleExports);
                 callback();
             }
             else {
                 scriptSrc = AMDLoader.Utilities.fileUriToFilePath(this._env.isWindows, scriptSrc);
-                var normalizedScriptSrc_1 = this._path.normalize(scriptSrc);
-                var vmScriptPathOrUri_1 = this._getElectronRendererScriptPathOrUri(normalizedScriptSrc_1);
-                var wantsCachedData_1 = Boolean(opts.nodeCachedData);
-                var cachedDataPath_1 = wantsCachedData_1 ? this._getCachedDataPath(opts.nodeCachedData, scriptSrc) : undefined;
-                this._readSourceAndCachedData(normalizedScriptSrc_1, cachedDataPath_1, recorder, function (err, data, cachedData, hashData) {
+                const normalizedScriptSrc = this._path.normalize(scriptSrc);
+                const vmScriptPathOrUri = this._getElectronRendererScriptPathOrUri(normalizedScriptSrc);
+                const wantsCachedData = Boolean(opts.nodeCachedData);
+                const cachedDataPath = wantsCachedData ? this._getCachedDataPath(opts.nodeCachedData, scriptSrc) : undefined;
+                this._readSourceAndCachedData(normalizedScriptSrc, cachedDataPath, recorder, (err, data, cachedData, hashData) => {
                     if (err) {
                         errorback(err);
                         return;
                     }
-                    var scriptSource;
+                    let scriptSource;
                     if (data.charCodeAt(0) === NodeScriptLoader._BOM) {
                         scriptSource = NodeScriptLoader._PREFIX + data.substring(1) + NodeScriptLoader._SUFFIX;
                     }
                     else {
                         scriptSource = NodeScriptLoader._PREFIX + data + NodeScriptLoader._SUFFIX;
                     }
-                    scriptSource = nodeInstrumenter(scriptSource, normalizedScriptSrc_1);
-                    var scriptOpts = { filename: vmScriptPathOrUri_1, cachedData: cachedData };
-                    var script = _this._createAndEvalScript(moduleManager, scriptSource, scriptOpts, callback, errorback);
-                    _this._handleCachedData(script, scriptSource, cachedDataPath_1, wantsCachedData_1 && !cachedData, moduleManager);
-                    _this._verifyCachedData(script, scriptSource, cachedDataPath_1, hashData, moduleManager);
+                    scriptSource = nodeInstrumenter(scriptSource, normalizedScriptSrc);
+                    const scriptOpts = { filename: vmScriptPathOrUri, cachedData };
+                    const script = this._createAndEvalScript(moduleManager, scriptSource, scriptOpts, callback, errorback);
+                    this._handleCachedData(script, scriptSource, cachedDataPath, wantsCachedData && !cachedData, moduleManager);
+                    this._verifyCachedData(script, scriptSource, cachedDataPath, hashData, moduleManager);
                 });
             }
-        };
-        NodeScriptLoader.prototype._createAndEvalScript = function (moduleManager, contents, options, callback, errorback) {
-            var recorder = moduleManager.getRecorder();
-            recorder.record(31 /* NodeBeginEvaluatingScript */, options.filename);
-            var script = new this._vm.Script(contents, options);
-            var ret = script.runInThisContext(options);
-            var globalDefineFunc = moduleManager.getGlobalAMDDefineFunc();
-            var receivedDefineCall = false;
-            var localDefineFunc = function () {
+        }
+        _createAndEvalScript(moduleManager, contents, options, callback, errorback) {
+            const recorder = moduleManager.getRecorder();
+            recorder.record(31 /* LoaderEventType.NodeBeginEvaluatingScript */, options.filename);
+            const script = new this._vm.Script(contents, options);
+            const ret = script.runInThisContext(options);
+            const globalDefineFunc = moduleManager.getGlobalAMDDefineFunc();
+            let receivedDefineCall = false;
+            const localDefineFunc = function () {
                 receivedDefineCall = true;
                 return globalDefineFunc.apply(null, arguments);
             };
             localDefineFunc.amd = globalDefineFunc.amd;
             ret.call(AMDLoader.global, moduleManager.getGlobalAMDRequireFunc(), localDefineFunc, options.filename, this._path.dirname(options.filename));
-            recorder.record(32 /* NodeEndEvaluatingScript */, options.filename);
+            recorder.record(32 /* LoaderEventType.NodeEndEvaluatingScript */, options.filename);
             if (receivedDefineCall) {
                 callback();
             }
             else {
-                errorback(new Error("Didn't receive define call in " + options.filename + "!"));
+                errorback(new Error(`Didn't receive define call in ${options.filename}!`));
             }
             return script;
-        };
-        NodeScriptLoader.prototype._getElectronRendererScriptPathOrUri = function (path) {
+        }
+        _getElectronRendererScriptPathOrUri(path) {
             if (!this._env.isElectronRenderer) {
                 return path;
             }
-            var driveLetterMatch = path.match(/^([a-z])\:(.*)/i);
+            let driveLetterMatch = path.match(/^([a-z])\:(.*)/i);
             if (driveLetterMatch) {
                 // windows
-                return "file:///" + (driveLetterMatch[1].toUpperCase() + ':' + driveLetterMatch[2]).replace(/\\/g, '/');
+                return `file:///${(driveLetterMatch[1].toUpperCase() + ':' + driveLetterMatch[2]).replace(/\\/g, '/')}`;
             }
             else {
                 // nix
-                return "file://" + path;
+                return `file://${path}`;
             }
-        };
-        NodeScriptLoader.prototype._getCachedDataPath = function (config, filename) {
-            var hash = this._crypto.createHash('md5').update(filename, 'utf8').update(config.seed, 'utf8').update(process.arch, '').digest('hex');
-            var basename = this._path.basename(filename).replace(/\.js$/, '');
-            return this._path.join(config.path, basename + "-" + hash + ".code");
-        };
-        NodeScriptLoader.prototype._handleCachedData = function (script, scriptSource, cachedDataPath, createCachedData, moduleManager) {
-            var _this = this;
+        }
+        _getCachedDataPath(config, filename) {
+            const hash = this._crypto.createHash('md5').update(filename, 'utf8').update(config.seed, 'utf8').update(process.arch, '').digest('hex');
+            const basename = this._path.basename(filename).replace(/\.js$/, '');
+            return this._path.join(config.path, `${basename}-${hash}.code`);
+        }
+        _handleCachedData(script, scriptSource, cachedDataPath, createCachedData, moduleManager) {
             if (script.cachedDataRejected) {
                 // cached data got rejected -> delete and re-create
-                this._fs.unlink(cachedDataPath, function (err) {
-                    moduleManager.getRecorder().record(62 /* CachedDataRejected */, cachedDataPath);
-                    _this._createAndWriteCachedData(script, scriptSource, cachedDataPath, moduleManager);
+                this._fs.unlink(cachedDataPath, err => {
+                    moduleManager.getRecorder().record(62 /* LoaderEventType.CachedDataRejected */, cachedDataPath);
+                    this._createAndWriteCachedData(script, scriptSource, cachedDataPath, moduleManager);
                     if (err) {
                         moduleManager.getConfig().onError(err);
                     }
@@ -953,22 +909,21 @@ var AMDLoader;
                 // no cached data, but wanted
                 this._createAndWriteCachedData(script, scriptSource, cachedDataPath, moduleManager);
             }
-        };
+        }
         // Cached data format: | SOURCE_HASH | V8_CACHED_DATA |
         // -SOURCE_HASH is the md5 hash of the JS source (always 16 bytes)
         // -V8_CACHED_DATA is what v8 produces
-        NodeScriptLoader.prototype._createAndWriteCachedData = function (script, scriptSource, cachedDataPath, moduleManager) {
-            var _this = this;
-            var timeout = Math.ceil(moduleManager.getConfig().getOptionsLiteral().nodeCachedData.writeDelay * (1 + Math.random()));
-            var lastSize = -1;
-            var iteration = 0;
-            var hashData = undefined;
-            var createLoop = function () {
-                setTimeout(function () {
+        _createAndWriteCachedData(script, scriptSource, cachedDataPath, moduleManager) {
+            let timeout = Math.ceil(moduleManager.getConfig().getOptionsLiteral().nodeCachedData.writeDelay * (1 + Math.random()));
+            let lastSize = -1;
+            let iteration = 0;
+            let hashData = undefined;
+            const createLoop = () => {
+                setTimeout(() => {
                     if (!hashData) {
-                        hashData = _this._crypto.createHash('md5').update(scriptSource, 'utf8').digest();
+                        hashData = this._crypto.createHash('md5').update(scriptSource, 'utf8').digest();
                     }
-                    var cachedData = script.createCachedData();
+                    const cachedData = script.createCachedData();
                     if (cachedData.length === 0 || cachedData.length === lastSize || iteration >= 5) {
                         // done
                         return;
@@ -979,11 +934,11 @@ var AMDLoader;
                         return;
                     }
                     lastSize = cachedData.length;
-                    _this._fs.writeFile(cachedDataPath, Buffer.concat([hashData, cachedData]), function (err) {
+                    this._fs.writeFile(cachedDataPath, Buffer.concat([hashData, cachedData]), err => {
                         if (err) {
                             moduleManager.getConfig().onError(err);
                         }
-                        moduleManager.getRecorder().record(63 /* CachedDataCreated */, cachedDataPath);
+                        moduleManager.getRecorder().record(63 /* LoaderEventType.CachedDataCreated */, cachedDataPath);
                         createLoop();
                     });
                 }, timeout * (Math.pow(4, iteration++)));
@@ -992,45 +947,44 @@ var AMDLoader;
             // and repeat that (with backoff delay) until the
             // data seems to be not changing anymore
             createLoop();
-        };
-        NodeScriptLoader.prototype._readSourceAndCachedData = function (sourcePath, cachedDataPath, recorder, callback) {
+        }
+        _readSourceAndCachedData(sourcePath, cachedDataPath, recorder, callback) {
             if (!cachedDataPath) {
                 // no cached data case
                 this._fs.readFile(sourcePath, { encoding: 'utf8' }, callback);
             }
             else {
                 // cached data case: read both files in parallel
-                var source_1 = undefined;
-                var cachedData_1 = undefined;
-                var hashData_1 = undefined;
-                var steps_1 = 2;
-                var step_1 = function (err) {
+                let source = undefined;
+                let cachedData = undefined;
+                let hashData = undefined;
+                let steps = 2;
+                const step = (err) => {
                     if (err) {
                         callback(err);
                     }
-                    else if (--steps_1 === 0) {
-                        callback(undefined, source_1, cachedData_1, hashData_1);
+                    else if (--steps === 0) {
+                        callback(undefined, source, cachedData, hashData);
                     }
                 };
-                this._fs.readFile(sourcePath, { encoding: 'utf8' }, function (err, data) {
-                    source_1 = data;
-                    step_1(err);
+                this._fs.readFile(sourcePath, { encoding: 'utf8' }, (err, data) => {
+                    source = data;
+                    step(err);
                 });
-                this._fs.readFile(cachedDataPath, function (err, data) {
+                this._fs.readFile(cachedDataPath, (err, data) => {
                     if (!err && data && data.length > 0) {
-                        hashData_1 = data.slice(0, 16);
-                        cachedData_1 = data.slice(16);
-                        recorder.record(60 /* CachedDataFound */, cachedDataPath);
+                        hashData = data.slice(0, 16);
+                        cachedData = data.slice(16);
+                        recorder.record(60 /* LoaderEventType.CachedDataFound */, cachedDataPath);
                     }
                     else {
-                        recorder.record(61 /* CachedDataMissed */, cachedDataPath);
+                        recorder.record(61 /* LoaderEventType.CachedDataMissed */, cachedDataPath);
                     }
-                    step_1(); // ignored: cached data is optional
+                    step(); // ignored: cached data is optional
                 });
             }
-        };
-        NodeScriptLoader.prototype._verifyCachedData = function (script, scriptSource, cachedDataPath, hashData, moduleManager) {
-            var _this = this;
+        }
+        _verifyCachedData(script, scriptSource, cachedDataPath, hashData, moduleManager) {
             if (!hashData) {
                 // nothing to do
                 return;
@@ -1039,38 +993,37 @@ var AMDLoader;
                 // invalid anyways
                 return;
             }
-            setTimeout(function () {
+            setTimeout(() => {
                 // check source hash - the contract is that file paths change when file content
                 // change (e.g use the commit or version id as cache path). this check is
                 // for violations of this contract.
-                var hashDataNow = _this._crypto.createHash('md5').update(scriptSource, 'utf8').digest();
+                const hashDataNow = this._crypto.createHash('md5').update(scriptSource, 'utf8').digest();
                 if (!hashData.equals(hashDataNow)) {
-                    moduleManager.getConfig().onError(new Error("FAILED TO VERIFY CACHED DATA, deleting stale '" + cachedDataPath + "' now, but a RESTART IS REQUIRED"));
-                    _this._fs.unlink(cachedDataPath, function (err) {
+                    moduleManager.getConfig().onError(new Error(`FAILED TO VERIFY CACHED DATA, deleting stale '${cachedDataPath}' now, but a RESTART IS REQUIRED`));
+                    this._fs.unlink(cachedDataPath, err => {
                         if (err) {
                             moduleManager.getConfig().onError(err);
                         }
                     });
                 }
             }, Math.ceil(5000 * (1 + Math.random())));
-        };
-        NodeScriptLoader._BOM = 0xFEFF;
-        NodeScriptLoader._PREFIX = '(function (require, define, __filename, __dirname) { ';
-        NodeScriptLoader._SUFFIX = '\n});';
-        return NodeScriptLoader;
-    }());
+        }
+    }
+    NodeScriptLoader._BOM = 0xFEFF;
+    NodeScriptLoader._PREFIX = '(function (require, define, __filename, __dirname) { ';
+    NodeScriptLoader._SUFFIX = '\n});';
     function ensureRecordedNodeRequire(recorder, _nodeRequire) {
         if (_nodeRequire.__$__isRecorded) {
             // it is already recorded
             return _nodeRequire;
         }
-        var nodeRequire = function nodeRequire(what) {
-            recorder.record(33 /* NodeBeginNativeRequire */, what);
+        const nodeRequire = function nodeRequire(what) {
+            recorder.record(33 /* LoaderEventType.NodeBeginNativeRequire */, what);
             try {
                 return _nodeRequire(what);
             }
             finally {
-                recorder.record(34 /* NodeEndNativeRequire */, what);
+                recorder.record(34 /* LoaderEventType.NodeEndNativeRequire */, what);
             }
         };
         nodeRequire.__$__isRecorded = true;
@@ -1090,9 +1043,9 @@ var AMDLoader;
 (function (AMDLoader) {
     // ------------------------------------------------------------------------
     // ModuleIdResolver
-    var ModuleIdResolver = /** @class */ (function () {
-        function ModuleIdResolver(fromModuleId) {
-            var lastSlash = fromModuleId.lastIndexOf('/');
+    class ModuleIdResolver {
+        constructor(fromModuleId) {
+            let lastSlash = fromModuleId.lastIndexOf('/');
             if (lastSlash !== -1) {
                 this.fromModulePath = fromModuleId.substr(0, lastSlash + 1);
             }
@@ -1103,8 +1056,8 @@ var AMDLoader;
         /**
          * Normalize 'a/../name' to 'name', etc.
          */
-        ModuleIdResolver._normalizeModuleId = function (moduleId) {
-            var r = moduleId, pattern;
+        static _normalizeModuleId(moduleId) {
+            let r = moduleId, pattern;
             // replace /./ => /
             pattern = /\/\.\//;
             while (pattern.test(r)) {
@@ -1120,27 +1073,26 @@ var AMDLoader;
             // replace ^aa/../ => nothing (BUT IGNORE ../../)
             r = r.replace(/^(([^\/])|([^\/][^\/\.])|([^\/\.][^\/])|([^\/][^\/][^\/]+))\/\.\.\//, '');
             return r;
-        };
+        }
         /**
          * Resolve relative module ids
          */
-        ModuleIdResolver.prototype.resolveModule = function (moduleId) {
-            var result = moduleId;
+        resolveModule(moduleId) {
+            let result = moduleId;
             if (!AMDLoader.Utilities.isAbsolutePath(result)) {
                 if (AMDLoader.Utilities.startsWith(result, './') || AMDLoader.Utilities.startsWith(result, '../')) {
                     result = ModuleIdResolver._normalizeModuleId(this.fromModulePath + result);
                 }
             }
             return result;
-        };
-        ModuleIdResolver.ROOT = new ModuleIdResolver('');
-        return ModuleIdResolver;
-    }());
+        }
+    }
+    ModuleIdResolver.ROOT = new ModuleIdResolver('');
     AMDLoader.ModuleIdResolver = ModuleIdResolver;
     // ------------------------------------------------------------------------
     // Module
-    var Module = /** @class */ (function () {
-        function Module(id, strId, dependencies, callback, errorback, moduleIdResolver) {
+    class Module {
+        constructor(id, strId, dependencies, callback, errorback, moduleIdResolver) {
             this.id = id;
             this.strId = strId;
             this.dependencies = dependencies;
@@ -1153,7 +1105,7 @@ var AMDLoader;
             this.unresolvedDependenciesCount = this.dependencies.length;
             this._isComplete = false;
         }
-        Module._safeInvokeFunction = function (callback, args) {
+        static _safeInvokeFunction(callback, args) {
             try {
                 return {
                     returnedValue: callback.apply(AMDLoader.global, args),
@@ -1166,8 +1118,8 @@ var AMDLoader;
                     producedError: e
                 };
             }
-        };
-        Module._invokeFactory = function (config, strModuleId, callback, dependenciesValues) {
+        }
+        static _invokeFactory(config, strModuleId, callback, dependenciesValues) {
             if (!config.shouldInvokeFactory(strModuleId)) {
                 return {
                     returnedValue: null,
@@ -1181,16 +1133,16 @@ var AMDLoader;
                 returnedValue: callback.apply(AMDLoader.global, dependenciesValues),
                 producedError: null
             };
-        };
-        Module.prototype.complete = function (recorder, config, dependenciesValues, inversedependenciesProvider) {
+        }
+        complete(recorder, config, dependenciesValues, inversedependenciesProvider) {
             this._isComplete = true;
-            var producedError = null;
+            let producedError = null;
             if (this._callback) {
                 if (typeof this._callback === 'function') {
-                    recorder.record(21 /* BeginInvokeFactory */, this.strId);
-                    var r = Module._invokeFactory(config, this.strId, this._callback, dependenciesValues);
+                    recorder.record(21 /* LoaderEventType.BeginInvokeFactory */, this.strId);
+                    let r = Module._invokeFactory(config, this.strId, this._callback, dependenciesValues);
                     producedError = r.producedError;
-                    recorder.record(22 /* EndInvokeFactory */, this.strId);
+                    recorder.record(22 /* LoaderEventType.EndInvokeFactory */, this.strId);
                     if (!producedError && typeof r.returnedValue !== 'undefined' && (!this.exportsPassedIn || AMDLoader.Utilities.isEmpty(this.exports))) {
                         this.exports = r.returnedValue;
                     }
@@ -1200,7 +1152,7 @@ var AMDLoader;
                 }
             }
             if (producedError) {
-                var err = AMDLoader.ensureError(producedError);
+                let err = AMDLoader.ensureError(producedError);
                 err.phase = 'factory';
                 err.moduleId = this.strId;
                 err.neededBy = inversedependenciesProvider(this.id);
@@ -1211,11 +1163,11 @@ var AMDLoader;
             this._callback = null;
             this._errorback = null;
             this.moduleIdResolver = null;
-        };
+        }
         /**
          * One of the direct dependencies or a transitive dependency has failed to load.
          */
-        Module.prototype.onDependencyError = function (err) {
+        onDependencyError(err) {
             this._isComplete = true;
             this.error = err;
             if (this._errorback) {
@@ -1223,18 +1175,17 @@ var AMDLoader;
                 return true;
             }
             return false;
-        };
+        }
         /**
          * Is the current module complete?
          */
-        Module.prototype.isComplete = function () {
+        isComplete() {
             return this._isComplete;
-        };
-        return Module;
-    }());
+        }
+    }
     AMDLoader.Module = Module;
-    var ModuleIdProvider = /** @class */ (function () {
-        function ModuleIdProvider() {
+    class ModuleIdProvider {
+        constructor() {
             this._nextId = 0;
             this._strModuleIdToIntModuleId = new Map();
             this._intModuleIdToStrModuleId = [];
@@ -1243,45 +1194,41 @@ var AMDLoader;
             this.getModuleId('module');
             this.getModuleId('require');
         }
-        ModuleIdProvider.prototype.getMaxModuleId = function () {
+        getMaxModuleId() {
             return this._nextId;
-        };
-        ModuleIdProvider.prototype.getModuleId = function (strModuleId) {
-            var id = this._strModuleIdToIntModuleId.get(strModuleId);
+        }
+        getModuleId(strModuleId) {
+            let id = this._strModuleIdToIntModuleId.get(strModuleId);
             if (typeof id === 'undefined') {
                 id = this._nextId++;
                 this._strModuleIdToIntModuleId.set(strModuleId, id);
                 this._intModuleIdToStrModuleId[id] = strModuleId;
             }
             return id;
-        };
-        ModuleIdProvider.prototype.getStrModuleId = function (moduleId) {
+        }
+        getStrModuleId(moduleId) {
             return this._intModuleIdToStrModuleId[moduleId];
-        };
-        return ModuleIdProvider;
-    }());
-    var RegularDependency = /** @class */ (function () {
-        function RegularDependency(id) {
+        }
+    }
+    class RegularDependency {
+        constructor(id) {
             this.id = id;
         }
-        RegularDependency.EXPORTS = new RegularDependency(0 /* EXPORTS */);
-        RegularDependency.MODULE = new RegularDependency(1 /* MODULE */);
-        RegularDependency.REQUIRE = new RegularDependency(2 /* REQUIRE */);
-        return RegularDependency;
-    }());
+    }
+    RegularDependency.EXPORTS = new RegularDependency(0 /* ModuleId.EXPORTS */);
+    RegularDependency.MODULE = new RegularDependency(1 /* ModuleId.MODULE */);
+    RegularDependency.REQUIRE = new RegularDependency(2 /* ModuleId.REQUIRE */);
     AMDLoader.RegularDependency = RegularDependency;
-    var PluginDependency = /** @class */ (function () {
-        function PluginDependency(id, pluginId, pluginParam) {
+    class PluginDependency {
+        constructor(id, pluginId, pluginParam) {
             this.id = id;
             this.pluginId = pluginId;
             this.pluginParam = pluginParam;
         }
-        return PluginDependency;
-    }());
+    }
     AMDLoader.PluginDependency = PluginDependency;
-    var ModuleManager = /** @class */ (function () {
-        function ModuleManager(env, scriptLoader, defineFunc, requireFunc, loaderAvailableTimestamp) {
-            if (loaderAvailableTimestamp === void 0) { loaderAvailableTimestamp = 0; }
+    class ModuleManager {
+        constructor(env, scriptLoader, defineFunc, requireFunc, loaderAvailableTimestamp = 0) {
             this._env = env;
             this._scriptLoader = scriptLoader;
             this._loaderAvailableTimestamp = loaderAvailableTimestamp;
@@ -1300,30 +1247,30 @@ var AMDLoader;
             this._buildInfoDefineStack = [];
             this._buildInfoDependencies = [];
         }
-        ModuleManager.prototype.reset = function () {
+        reset() {
             return new ModuleManager(this._env, this._scriptLoader, this._defineFunc, this._requireFunc, this._loaderAvailableTimestamp);
-        };
-        ModuleManager.prototype.getGlobalAMDDefineFunc = function () {
+        }
+        getGlobalAMDDefineFunc() {
             return this._defineFunc;
-        };
-        ModuleManager.prototype.getGlobalAMDRequireFunc = function () {
+        }
+        getGlobalAMDRequireFunc() {
             return this._requireFunc;
-        };
-        ModuleManager._findRelevantLocationInStack = function (needle, stack) {
-            var normalize = function (str) { return str.replace(/\\/g, '/'); };
-            var normalizedPath = normalize(needle);
-            var stackPieces = stack.split(/\n/);
-            for (var i = 0; i < stackPieces.length; i++) {
-                var m = stackPieces[i].match(/(.*):(\d+):(\d+)\)?$/);
+        }
+        static _findRelevantLocationInStack(needle, stack) {
+            let normalize = (str) => str.replace(/\\/g, '/');
+            let normalizedPath = normalize(needle);
+            let stackPieces = stack.split(/\n/);
+            for (let i = 0; i < stackPieces.length; i++) {
+                let m = stackPieces[i].match(/(.*):(\d+):(\d+)\)?$/);
                 if (m) {
-                    var stackPath = m[1];
-                    var stackLine = m[2];
-                    var stackColumn = m[3];
-                    var trimPathOffset = Math.max(stackPath.lastIndexOf(' ') + 1, stackPath.lastIndexOf('(') + 1);
+                    let stackPath = m[1];
+                    let stackLine = m[2];
+                    let stackColumn = m[3];
+                    let trimPathOffset = Math.max(stackPath.lastIndexOf(' ') + 1, stackPath.lastIndexOf('(') + 1);
                     stackPath = stackPath.substr(trimPathOffset);
                     stackPath = normalize(stackPath);
                     if (stackPath === normalizedPath) {
-                        var r = {
+                        let r = {
                             line: parseInt(stackLine, 10),
                             col: parseInt(stackColumn, 10)
                         };
@@ -1335,32 +1282,32 @@ var AMDLoader;
                 }
             }
             throw new Error('Could not correlate define call site for needle ' + needle);
-        };
-        ModuleManager.prototype.getBuildInfo = function () {
+        }
+        getBuildInfo() {
             if (!this._config.isBuild()) {
                 return null;
             }
-            var result = [], resultLen = 0;
-            for (var i = 0, len = this._modules2.length; i < len; i++) {
-                var m = this._modules2[i];
+            let result = [], resultLen = 0;
+            for (let i = 0, len = this._modules2.length; i < len; i++) {
+                let m = this._modules2[i];
                 if (!m) {
                     continue;
                 }
-                var location_1 = this._buildInfoPath[m.id] || null;
-                var defineStack = this._buildInfoDefineStack[m.id] || null;
-                var dependencies = this._buildInfoDependencies[m.id];
+                let location = this._buildInfoPath[m.id] || null;
+                let defineStack = this._buildInfoDefineStack[m.id] || null;
+                let dependencies = this._buildInfoDependencies[m.id];
                 result[resultLen++] = {
                     id: m.strId,
-                    path: location_1,
-                    defineLocation: (location_1 && defineStack ? ModuleManager._findRelevantLocationInStack(location_1, defineStack) : null),
+                    path: location,
+                    defineLocation: (location && defineStack ? ModuleManager._findRelevantLocationInStack(location, defineStack) : null),
                     dependencies: dependencies,
                     shim: null,
                     exports: m.exports
                 };
             }
             return result;
-        };
-        ModuleManager.prototype.getRecorder = function () {
+        }
+        getRecorder() {
             if (!this._recorder) {
                 if (this._config.shouldRecordStats()) {
                     this._recorder = new AMDLoader.LoaderEventRecorder(this._loaderAvailableTimestamp);
@@ -1370,20 +1317,20 @@ var AMDLoader;
                 }
             }
             return this._recorder;
-        };
-        ModuleManager.prototype.getLoaderEvents = function () {
+        }
+        getLoaderEvents() {
             return this.getRecorder().getEvents();
-        };
+        }
         /**
          * Defines an anonymous module (without an id). Its name will be resolved as we receive a callback from the scriptLoader.
          * @param dependencies @see defineModule
          * @param callback @see defineModule
          */
-        ModuleManager.prototype.enqueueDefineAnonymousModule = function (dependencies, callback) {
+        enqueueDefineAnonymousModule(dependencies, callback) {
             if (this._currentAnonymousDefineCall !== null) {
                 throw new Error('Can only have one anonymous define call per script file');
             }
-            var stack = null;
+            let stack = null;
             if (this._config.isBuild()) {
                 stack = new Error('StackLocation').stack || null;
             }
@@ -1392,17 +1339,15 @@ var AMDLoader;
                 dependencies: dependencies,
                 callback: callback
             };
-        };
+        }
         /**
          * Creates a module and stores it in _modules. The manager will immediately begin resolving its dependencies.
          * @param strModuleId An unique and absolute id of the module. This must not collide with another module's id
          * @param dependencies An array with the dependencies of the module. Special keys are: "require", "exports" and "module"
          * @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.
          */
-        ModuleManager.prototype.defineModule = function (strModuleId, dependencies, callback, errorback, stack, moduleIdResolver) {
-            var _this = this;
-            if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(strModuleId); }
-            var moduleId = this._moduleIdProvider.getModuleId(strModuleId);
+        defineModule(strModuleId, dependencies, callback, errorback, stack, moduleIdResolver = new ModuleIdResolver(strModuleId)) {
+            let moduleId = this._moduleIdProvider.getModuleId(strModuleId);
             if (this._modules2[moduleId]) {
                 if (!this._config.isDuplicateMessageIgnoredFor(strModuleId)) {
                     console.warn('Duplicate definition of module \'' + strModuleId + '\'');
@@ -1410,17 +1355,17 @@ var AMDLoader;
                 // Super important! Completely ignore duplicate module definition
                 return;
             }
-            var m = new Module(moduleId, strModuleId, this._normalizeDependencies(dependencies, moduleIdResolver), callback, errorback, moduleIdResolver);
+            let m = new Module(moduleId, strModuleId, this._normalizeDependencies(dependencies, moduleIdResolver), callback, errorback, moduleIdResolver);
             this._modules2[moduleId] = m;
             if (this._config.isBuild()) {
                 this._buildInfoDefineStack[moduleId] = stack;
-                this._buildInfoDependencies[moduleId] = (m.dependencies || []).map(function (dep) { return _this._moduleIdProvider.getStrModuleId(dep.id); });
+                this._buildInfoDependencies[moduleId] = (m.dependencies || []).map(dep => this._moduleIdProvider.getStrModuleId(dep.id));
             }
             // Resolving of dependencies is immediate (not in a timeout). If there's a need to support a packer that concatenates in an
             // unordered manner, in order to finish processing the file, execute the following method in a timeout
             this._resolve(m);
-        };
-        ModuleManager.prototype._normalizeDependency = function (dependency, moduleIdResolver) {
+        }
+        _normalizeDependency(dependency, moduleIdResolver) {
             if (dependency === 'exports') {
                 return RegularDependency.EXPORTS;
             }
@@ -1431,38 +1376,37 @@ var AMDLoader;
                 return RegularDependency.REQUIRE;
             }
             // Normalize dependency and then request it from the manager
-            var bangIndex = dependency.indexOf('!');
+            let bangIndex = dependency.indexOf('!');
             if (bangIndex >= 0) {
-                var strPluginId = moduleIdResolver.resolveModule(dependency.substr(0, bangIndex));
-                var pluginParam = moduleIdResolver.resolveModule(dependency.substr(bangIndex + 1));
-                var dependencyId = this._moduleIdProvider.getModuleId(strPluginId + '!' + pluginParam);
-                var pluginId = this._moduleIdProvider.getModuleId(strPluginId);
+                let strPluginId = moduleIdResolver.resolveModule(dependency.substr(0, bangIndex));
+                let pluginParam = moduleIdResolver.resolveModule(dependency.substr(bangIndex + 1));
+                let dependencyId = this._moduleIdProvider.getModuleId(strPluginId + '!' + pluginParam);
+                let pluginId = this._moduleIdProvider.getModuleId(strPluginId);
                 return new PluginDependency(dependencyId, pluginId, pluginParam);
             }
             return new RegularDependency(this._moduleIdProvider.getModuleId(moduleIdResolver.resolveModule(dependency)));
-        };
-        ModuleManager.prototype._normalizeDependencies = function (dependencies, moduleIdResolver) {
-            var result = [], resultLen = 0;
-            for (var i = 0, len = dependencies.length; i < len; i++) {
+        }
+        _normalizeDependencies(dependencies, moduleIdResolver) {
+            let result = [], resultLen = 0;
+            for (let i = 0, len = dependencies.length; i < len; i++) {
                 result[resultLen++] = this._normalizeDependency(dependencies[i], moduleIdResolver);
             }
             return result;
-        };
-        ModuleManager.prototype._relativeRequire = function (moduleIdResolver, dependencies, callback, errorback) {
+        }
+        _relativeRequire(moduleIdResolver, dependencies, callback, errorback) {
             if (typeof dependencies === 'string') {
                 return this.synchronousRequire(dependencies, moduleIdResolver);
             }
             this.defineModule(AMDLoader.Utilities.generateAnonymousModule(), dependencies, callback, errorback, null, moduleIdResolver);
-        };
+        }
         /**
          * Require synchronously a module by its absolute id. If the module is not loaded, an exception will be thrown.
          * @param id The unique and absolute id of the required module
          * @return The exports of module 'id'
          */
-        ModuleManager.prototype.synchronousRequire = function (_strModuleId, moduleIdResolver) {
-            if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(_strModuleId); }
-            var dependency = this._normalizeDependency(_strModuleId, moduleIdResolver);
-            var m = this._modules2[dependency.id];
+        synchronousRequire(_strModuleId, moduleIdResolver = new ModuleIdResolver(_strModuleId)) {
+            let dependency = this._normalizeDependency(_strModuleId, moduleIdResolver);
+            let m = this._modules2[dependency.id];
             if (!m) {
                 throw new Error('Check dependency list! Synchronous require cannot resolve module \'' + _strModuleId + '\'. This is the first mention of this module!');
             }
@@ -1473,9 +1417,9 @@ var AMDLoader;
                 throw m.error;
             }
             return m.exports;
-        };
-        ModuleManager.prototype.configure = function (params, shouldOverwrite) {
-            var oldShouldRecordStats = this._config.shouldRecordStats();
+        }
+        configure(params, shouldOverwrite) {
+            let oldShouldRecordStats = this._config.shouldRecordStats();
             if (shouldOverwrite) {
                 this._config = new AMDLoader.Configuration(this._env, params);
             }
@@ -1485,60 +1429,59 @@ var AMDLoader;
             if (this._config.shouldRecordStats() && !oldShouldRecordStats) {
                 this._recorder = null;
             }
-        };
-        ModuleManager.prototype.getConfig = function () {
+        }
+        getConfig() {
             return this._config;
-        };
+        }
         /**
          * Callback from the scriptLoader when a module has been loaded.
          * This means its code is available and has been executed.
          */
-        ModuleManager.prototype._onLoad = function (moduleId) {
+        _onLoad(moduleId) {
             if (this._currentAnonymousDefineCall !== null) {
-                var defineCall = this._currentAnonymousDefineCall;
+                let defineCall = this._currentAnonymousDefineCall;
                 this._currentAnonymousDefineCall = null;
                 // Hit an anonymous define call
                 this.defineModule(this._moduleIdProvider.getStrModuleId(moduleId), defineCall.dependencies, defineCall.callback, null, defineCall.stack);
             }
-        };
-        ModuleManager.prototype._createLoadError = function (moduleId, _err) {
-            var _this = this;
-            var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);
-            var neededBy = (this._inverseDependencies2[moduleId] || []).map(function (intModuleId) { return _this._moduleIdProvider.getStrModuleId(intModuleId); });
-            var err = AMDLoader.ensureError(_err);
+        }
+        _createLoadError(moduleId, _err) {
+            let strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);
+            let neededBy = (this._inverseDependencies2[moduleId] || []).map((intModuleId) => this._moduleIdProvider.getStrModuleId(intModuleId));
+            const err = AMDLoader.ensureError(_err);
             err.phase = 'loading';
             err.moduleId = strModuleId;
             err.neededBy = neededBy;
             return err;
-        };
+        }
         /**
          * Callback from the scriptLoader when a module hasn't been loaded.
          * This means that the script was not found (e.g. 404) or there was an error in the script.
          */
-        ModuleManager.prototype._onLoadError = function (moduleId, err) {
-            var error = this._createLoadError(moduleId, err);
+        _onLoadError(moduleId, err) {
+            const error = this._createLoadError(moduleId, err);
             if (!this._modules2[moduleId]) {
-                this._modules2[moduleId] = new Module(moduleId, this._moduleIdProvider.getStrModuleId(moduleId), [], function () { }, null, null);
+                this._modules2[moduleId] = new Module(moduleId, this._moduleIdProvider.getStrModuleId(moduleId), [], () => { }, null, null);
             }
             // Find any 'local' error handlers, walk the entire chain of inverse dependencies if necessary.
-            var seenModuleId = [];
-            for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {
+            let seenModuleId = [];
+            for (let i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {
                 seenModuleId[i] = false;
             }
-            var someoneNotified = false;
-            var queue = [];
+            let someoneNotified = false;
+            let queue = [];
             queue.push(moduleId);
             seenModuleId[moduleId] = true;
             while (queue.length > 0) {
-                var queueElement = queue.shift();
-                var m = this._modules2[queueElement];
+                let queueElement = queue.shift();
+                let m = this._modules2[queueElement];
                 if (m) {
                     someoneNotified = m.onDependencyError(error) || someoneNotified;
                 }
-                var inverseDeps = this._inverseDependencies2[queueElement];
+                let inverseDeps = this._inverseDependencies2[queueElement];
                 if (inverseDeps) {
-                    for (var i = 0, len = inverseDeps.length; i < len; i++) {
-                        var inverseDep = inverseDeps[i];
+                    for (let i = 0, len = inverseDeps.length; i < len; i++) {
+                        let inverseDep = inverseDeps[i];
                         if (!seenModuleId[inverseDep]) {
                             queue.push(inverseDep);
                             seenModuleId[inverseDep] = true;
@@ -1549,39 +1492,39 @@ var AMDLoader;
             if (!someoneNotified) {
                 this._config.onError(error);
             }
-        };
+        }
         /**
          * Walks (recursively) the dependencies of 'from' in search of 'to'.
          * Returns true if there is such a path or false otherwise.
          * @param from Module id to start at
          * @param to Module id to look for
          */
-        ModuleManager.prototype._hasDependencyPath = function (fromId, toId) {
-            var from = this._modules2[fromId];
+        _hasDependencyPath(fromId, toId) {
+            let from = this._modules2[fromId];
             if (!from) {
                 return false;
             }
-            var inQueue = [];
-            for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {
+            let inQueue = [];
+            for (let i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {
                 inQueue[i] = false;
             }
-            var queue = [];
+            let queue = [];
             // Insert 'from' in queue
             queue.push(from);
             inQueue[fromId] = true;
             while (queue.length > 0) {
                 // Pop first inserted element of queue
-                var element = queue.shift();
-                var dependencies = element.dependencies;
+                let element = queue.shift();
+                let dependencies = element.dependencies;
                 if (dependencies) {
                     // Walk the element's dependencies
-                    for (var i = 0, len = dependencies.length; i < len; i++) {
-                        var dependency = dependencies[i];
+                    for (let i = 0, len = dependencies.length; i < len; i++) {
+                        let dependency = dependencies[i];
                         if (dependency.id === toId) {
                             // There is a path to 'to'
                             return true;
                         }
-                        var dependencyModule = this._modules2[dependency.id];
+                        let dependencyModule = this._modules2[dependency.id];
                         if (dependencyModule && !inQueue[dependency.id]) {
                             // Insert 'dependency' in queue
                             inQueue[dependency.id] = true;
@@ -1592,26 +1535,26 @@ var AMDLoader;
             }
             // There is no path to 'to'
             return false;
-        };
+        }
         /**
          * Walks (recursively) the dependencies of 'from' in search of 'to'.
          * Returns cycle as array.
          * @param from Module id to start at
          * @param to Module id to look for
          */
-        ModuleManager.prototype._findCyclePath = function (fromId, toId, depth) {
+        _findCyclePath(fromId, toId, depth) {
             if (fromId === toId || depth === 50) {
                 return [fromId];
             }
-            var from = this._modules2[fromId];
+            let from = this._modules2[fromId];
             if (!from) {
                 return null;
             }
             // Walk the element's dependencies
-            var dependencies = from.dependencies;
+            let dependencies = from.dependencies;
             if (dependencies) {
-                for (var i = 0, len = dependencies.length; i < len; i++) {
-                    var path = this._findCyclePath(dependencies[i].id, toId, depth + 1);
+                for (let i = 0, len = dependencies.length; i < len; i++) {
+                    let path = this._findCyclePath(dependencies[i].id, toId, depth + 1);
                     if (path !== null) {
                         path.push(fromId);
                         return path;
@@ -1619,106 +1562,101 @@ var AMDLoader;
                 }
             }
             return null;
-        };
+        }
         /**
          * Create the local 'require' that is passed into modules
          */
-        ModuleManager.prototype._createRequire = function (moduleIdResolver) {
-            var _this = this;
-            var result = (function (dependencies, callback, errorback) {
-                return _this._relativeRequire(moduleIdResolver, dependencies, callback, errorback);
+        _createRequire(moduleIdResolver) {
+            let result = ((dependencies, callback, errorback) => {
+                return this._relativeRequire(moduleIdResolver, dependencies, callback, errorback);
             });
-            result.toUrl = function (id) {
-                return _this._config.requireToUrl(moduleIdResolver.resolveModule(id));
+            result.toUrl = (id) => {
+                return this._config.requireToUrl(moduleIdResolver.resolveModule(id));
             };
-            result.getStats = function () {
-                return _this.getLoaderEvents();
+            result.getStats = () => {
+                return this.getLoaderEvents();
             };
-            result.hasDependencyCycle = function () {
-                return _this._hasDependencyCycle;
+            result.hasDependencyCycle = () => {
+                return this._hasDependencyCycle;
             };
-            result.config = function (params, shouldOverwrite) {
-                if (shouldOverwrite === void 0) { shouldOverwrite = false; }
-                _this.configure(params, shouldOverwrite);
+            result.config = (params, shouldOverwrite = false) => {
+                this.configure(params, shouldOverwrite);
             };
             result.__$__nodeRequire = AMDLoader.global.nodeRequire;
             return result;
-        };
-        ModuleManager.prototype._loadModule = function (moduleId) {
-            var _this = this;
+        }
+        _loadModule(moduleId) {
             if (this._modules2[moduleId] || this._knownModules2[moduleId]) {
                 // known module
                 return;
             }
             this._knownModules2[moduleId] = true;
-            var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);
-            var paths = this._config.moduleIdToPaths(strModuleId);
-            var scopedPackageRegex = /^@[^\/]+\/[^\/]+$/; // matches @scope/package-name
+            let strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);
+            let paths = this._config.moduleIdToPaths(strModuleId);
+            let scopedPackageRegex = /^@[^\/]+\/[^\/]+$/; // matches @scope/package-name
             if (this._env.isNode && (strModuleId.indexOf('/') === -1 || scopedPackageRegex.test(strModuleId))) {
                 paths.push('node|' + strModuleId);
             }
-            var lastPathIndex = -1;
-            var loadNextPath = function (err) {
+            let lastPathIndex = -1;
+            let loadNextPath = (err) => {
                 lastPathIndex++;
                 if (lastPathIndex >= paths.length) {
                     // No more paths to try
-                    _this._onLoadError(moduleId, err);
+                    this._onLoadError(moduleId, err);
                 }
                 else {
-                    var currentPath_1 = paths[lastPathIndex];
-                    var recorder_1 = _this.getRecorder();
-                    if (_this._config.isBuild() && currentPath_1 === 'empty:') {
-                        _this._buildInfoPath[moduleId] = currentPath_1;
-                        _this.defineModule(_this._moduleIdProvider.getStrModuleId(moduleId), [], null, null, null);
-                        _this._onLoad(moduleId);
+                    let currentPath = paths[lastPathIndex];
+                    let recorder = this.getRecorder();
+                    if (this._config.isBuild() && currentPath === 'empty:') {
+                        this._buildInfoPath[moduleId] = currentPath;
+                        this.defineModule(this._moduleIdProvider.getStrModuleId(moduleId), [], null, null, null);
+                        this._onLoad(moduleId);
                         return;
                     }
-                    recorder_1.record(10 /* BeginLoadingScript */, currentPath_1);
-                    _this._scriptLoader.load(_this, currentPath_1, function () {
-                        if (_this._config.isBuild()) {
-                            _this._buildInfoPath[moduleId] = currentPath_1;
+                    recorder.record(10 /* LoaderEventType.BeginLoadingScript */, currentPath);
+                    this._scriptLoader.load(this, currentPath, () => {
+                        if (this._config.isBuild()) {
+                            this._buildInfoPath[moduleId] = currentPath;
                         }
-                        recorder_1.record(11 /* EndLoadingScriptOK */, currentPath_1);
-                        _this._onLoad(moduleId);
-                    }, function (err) {
-                        recorder_1.record(12 /* EndLoadingScriptError */, currentPath_1);
+                        recorder.record(11 /* LoaderEventType.EndLoadingScriptOK */, currentPath);
+                        this._onLoad(moduleId);
+                    }, (err) => {
+                        recorder.record(12 /* LoaderEventType.EndLoadingScriptError */, currentPath);
                         loadNextPath(err);
                     });
                 }
             };
             loadNextPath(null);
-        };
+        }
         /**
          * Resolve a plugin dependency with the plugin loaded & complete
          * @param module The module that has this dependency
          * @param pluginDependency The semi-normalized dependency that appears in the module. e.g. 'vs/css!./mycssfile'. Only the plugin part (before !) is normalized
          * @param plugin The plugin (what the plugin exports)
          */
-        ModuleManager.prototype._loadPluginDependency = function (plugin, pluginDependency) {
-            var _this = this;
+        _loadPluginDependency(plugin, pluginDependency) {
             if (this._modules2[pluginDependency.id] || this._knownModules2[pluginDependency.id]) {
                 // known module
                 return;
             }
             this._knownModules2[pluginDependency.id] = true;
             // Delegate the loading of the resource to the plugin
-            var load = (function (value) {
-                _this.defineModule(_this._moduleIdProvider.getStrModuleId(pluginDependency.id), [], value, null, null);
+            let load = ((value) => {
+                this.defineModule(this._moduleIdProvider.getStrModuleId(pluginDependency.id), [], value, null, null);
             });
-            load.error = function (err) {
-                _this._config.onError(_this._createLoadError(pluginDependency.id, err));
+            load.error = (err) => {
+                this._config.onError(this._createLoadError(pluginDependency.id, err));
             };
             plugin.load(pluginDependency.pluginParam, this._createRequire(ModuleIdResolver.ROOT), load, this._config.getOptionsLiteral());
-        };
+        }
         /**
          * Examine the dependencies of module 'module' and resolve them as needed.
          */
-        ModuleManager.prototype._resolve = function (module) {
-            var _this = this;
-            var dependencies = module.dependencies;
+        _resolve(module) {
+            let dependencies = module.dependencies;
             if (dependencies) {
-                for (var i = 0, len = dependencies.length; i < len; i++) {
-                    var dependency = dependencies[i];
+                for (let i = 0, len = dependencies.length; i < len; i++) {
+                    let dependency = dependencies[i];
                     if (dependency === RegularDependency.EXPORTS) {
                         module.exportsPassedIn = true;
                         module.unresolvedDependenciesCount--;
@@ -1732,7 +1670,7 @@ var AMDLoader;
                         module.unresolvedDependenciesCount--;
                         continue;
                     }
-                    var dependencyModule = this._modules2[dependency.id];
+                    let dependencyModule = this._modules2[dependency.id];
                     if (dependencyModule && dependencyModule.isComplete()) {
                         if (dependencyModule.error) {
                             module.onDependencyError(dependencyModule.error);
@@ -1744,10 +1682,10 @@ var AMDLoader;
                     if (this._hasDependencyPath(dependency.id, module.id)) {
                         this._hasDependencyCycle = true;
                         console.warn('There is a dependency cycle between \'' + this._moduleIdProvider.getStrModuleId(dependency.id) + '\' and \'' + this._moduleIdProvider.getStrModuleId(module.id) + '\'. The cyclic path follows:');
-                        var cyclePath = this._findCyclePath(dependency.id, module.id, 0) || [];
+                        let cyclePath = this._findCyclePath(dependency.id, module.id, 0) || [];
                         cyclePath.reverse();
                         cyclePath.push(dependency.id);
-                        console.warn(cyclePath.map(function (id) { return _this._moduleIdProvider.getStrModuleId(id); }).join(' => \n'));
+                        console.warn(cyclePath.map(id => this._moduleIdProvider.getStrModuleId(id)).join(' => \n'));
                         // Break the cycle
                         module.unresolvedDependenciesCount--;
                         continue;
@@ -1756,13 +1694,13 @@ var AMDLoader;
                     this._inverseDependencies2[dependency.id] = this._inverseDependencies2[dependency.id] || [];
                     this._inverseDependencies2[dependency.id].push(module.id);
                     if (dependency instanceof PluginDependency) {
-                        var plugin = this._modules2[dependency.pluginId];
+                        let plugin = this._modules2[dependency.pluginId];
                         if (plugin && plugin.isComplete()) {
                             this._loadPluginDependency(plugin.exports, dependency);
                             continue;
                         }
                         // Record dependency for when the plugin gets loaded
-                        var inversePluginDeps = this._inversePluginDependencies2.get(dependency.pluginId);
+                        let inversePluginDeps = this._inversePluginDependencies2.get(dependency.pluginId);
                         if (!inversePluginDeps) {
                             inversePluginDeps = [];
                             this._inversePluginDependencies2.set(dependency.pluginId, inversePluginDeps);
@@ -1777,19 +1715,18 @@ var AMDLoader;
             if (module.unresolvedDependenciesCount === 0) {
                 this._onModuleComplete(module);
             }
-        };
-        ModuleManager.prototype._onModuleComplete = function (module) {
-            var _this = this;
-            var recorder = this.getRecorder();
+        }
+        _onModuleComplete(module) {
+            let recorder = this.getRecorder();
             if (module.isComplete()) {
                 // already done
                 return;
             }
-            var dependencies = module.dependencies;
-            var dependenciesValues = [];
+            let dependencies = module.dependencies;
+            let dependenciesValues = [];
             if (dependencies) {
-                for (var i = 0, len = dependencies.length; i < len; i++) {
-                    var dependency = dependencies[i];
+                for (let i = 0, len = dependencies.length; i < len; i++) {
+                    let dependency = dependencies[i];
                     if (dependency === RegularDependency.EXPORTS) {
                         dependenciesValues[i] = module.exports;
                         continue;
@@ -1797,8 +1734,8 @@ var AMDLoader;
                     if (dependency === RegularDependency.MODULE) {
                         dependenciesValues[i] = {
                             id: module.strId,
-                            config: function () {
-                                return _this._config.getConfigForModule(module.strId);
+                            config: () => {
+                                return this._config.getConfigForModule(module.strId);
                             }
                         };
                         continue;
@@ -1807,7 +1744,7 @@ var AMDLoader;
                         dependenciesValues[i] = this._createRequire(module.moduleIdResolver);
                         continue;
                     }
-                    var dependencyModule = this._modules2[dependency.id];
+                    let dependencyModule = this._modules2[dependency.id];
                     if (dependencyModule) {
                         dependenciesValues[i] = dependencyModule.exports;
                         continue;
@@ -1815,46 +1752,45 @@ var AMDLoader;
                     dependenciesValues[i] = null;
                 }
             }
-            var inversedependenciesProvider = function (moduleId) {
-                return (_this._inverseDependencies2[moduleId] || []).map(function (intModuleId) { return _this._moduleIdProvider.getStrModuleId(intModuleId); });
+            const inversedependenciesProvider = (moduleId) => {
+                return (this._inverseDependencies2[moduleId] || []).map((intModuleId) => this._moduleIdProvider.getStrModuleId(intModuleId));
             };
             module.complete(recorder, this._config, dependenciesValues, inversedependenciesProvider);
             // Fetch and clear inverse dependencies
-            var inverseDeps = this._inverseDependencies2[module.id];
+            let inverseDeps = this._inverseDependencies2[module.id];
             this._inverseDependencies2[module.id] = null;
             if (inverseDeps) {
                 // Resolve one inverse dependency at a time, always
                 // on the lookout for a completed module.
-                for (var i = 0, len = inverseDeps.length; i < len; i++) {
-                    var inverseDependencyId = inverseDeps[i];
-                    var inverseDependency = this._modules2[inverseDependencyId];
+                for (let i = 0, len = inverseDeps.length; i < len; i++) {
+                    let inverseDependencyId = inverseDeps[i];
+                    let inverseDependency = this._modules2[inverseDependencyId];
                     inverseDependency.unresolvedDependenciesCount--;
                     if (inverseDependency.unresolvedDependenciesCount === 0) {
                         this._onModuleComplete(inverseDependency);
                     }
                 }
             }
-            var inversePluginDeps = this._inversePluginDependencies2.get(module.id);
+            let inversePluginDeps = this._inversePluginDependencies2.get(module.id);
             if (inversePluginDeps) {
                 // This module is used as a plugin at least once
                 // Fetch and clear these inverse plugin dependencies
                 this._inversePluginDependencies2.delete(module.id);
                 // Resolve plugin dependencies one at a time
-                for (var i = 0, len = inversePluginDeps.length; i < len; i++) {
+                for (let i = 0, len = inversePluginDeps.length; i < len; i++) {
                     this._loadPluginDependency(module.exports, inversePluginDeps[i]);
                 }
             }
-        };
-        return ModuleManager;
-    }());
+        }
+    }
     AMDLoader.ModuleManager = ModuleManager;
 })(AMDLoader || (AMDLoader = {}));
 var define;
 var AMDLoader;
 (function (AMDLoader) {
-    var env = new AMDLoader.Environment();
-    var moduleManager = null;
-    var DefineFunc = function (id, dependencies, callback) {
+    const env = new AMDLoader.Environment();
+    let moduleManager = null;
+    const DefineFunc = function (id, dependencies, callback) {
         if (typeof id !== 'string') {
             callback = dependencies;
             dependencies = id;
@@ -1877,11 +1813,10 @@ var AMDLoader;
     DefineFunc.amd = {
         jQuery: true
     };
-    var _requireFunc_config = function (params, shouldOverwrite) {
-        if (shouldOverwrite === void 0) { shouldOverwrite = false; }
+    const _requireFunc_config = function (params, shouldOverwrite = false) {
         moduleManager.configure(params, shouldOverwrite);
     };
-    var RequireFunc = function () {
+    const RequireFunc = function () {
         if (arguments.length === 1) {
             if ((arguments[0] instanceof Object) && !Array.isArray(arguments[0])) {
                 _requireFunc_config(arguments[0]);
@@ -1915,10 +1850,10 @@ var AMDLoader;
     RequireFunc.define = DefineFunc;
     function init() {
         if (typeof AMDLoader.global.require !== 'undefined' || typeof require !== 'undefined') {
-            var _nodeRequire = (AMDLoader.global.require || require);
+            const _nodeRequire = (AMDLoader.global.require || require);
             if (typeof _nodeRequire === 'function' && typeof _nodeRequire.resolve === 'function') {
                 // re-expose node's require function
-                var nodeRequire = AMDLoader.ensureRecordedNodeRequire(moduleManager.getRecorder(), _nodeRequire);
+                const nodeRequire = AMDLoader.ensureRecordedNodeRequire(moduleManager.getRecorder(), _nodeRequire);
                 AMDLoader.global.nodeRequire = nodeRequire;
                 RequireFunc.nodeRequire = nodeRequire;
                 RequireFunc.__$__nodeRequire = nodeRequire;
@@ -1926,7 +1861,6 @@ var AMDLoader;
         }
         if (env.isNode && !env.isElectronRenderer && !env.isElectronNodeIntegrationWebWorker) {
             module.exports = RequireFunc;
-            // require = RequireFunc;
         }
         else {
             if (!env.isElectronRenderer) {