From 50c317768e49a14033d8c7c12e4b26de25118c93 Mon Sep 17 00:00:00 2001 From: Pierre Ossman Date: Mon, 16 Oct 2017 15:43:09 +0200 Subject: [PATCH] Include .js for anonymous scripts It is required for syntax highlighting in at least Firefox' debugger. --- .../dist/browser-es-module-loader.js | 294 +++++++++--------- .../dist/browser-es-module-loader.js.map | 2 +- .../src/browser-es-module-loader.js | 2 +- 3 files changed, 141 insertions(+), 157 deletions(-) diff --git a/vendor/browser-es-module-loader/dist/browser-es-module-loader.js b/vendor/browser-es-module-loader/dist/browser-es-module-loader.js index 4552c59..3aa2e51 100644 --- a/vendor/browser-es-module-loader/dist/browser-es-module-loader.js +++ b/vendor/browser-es-module-loader/dist/browser-es-module-loader.js @@ -227,7 +227,6 @@ var iteratorSupport = typeof Symbol !== 'undefined' && Symbol.iterator; var REGISTRY = createSymbol('registry'); function Registry() { this[REGISTRY] = {}; - this._registry = REGISTRY; } // 4.4.1 if (iteratorSupport) { @@ -381,8 +380,9 @@ function resolveIfNotPlain (relUrl, parentUrl) { return parentProtocol + relUrl; } // relative-url - else if (firstChar === '.' && (secondChar === '/' || secondChar === '.' && (relUrl[2] === '/' || relUrl.length === 2) || relUrl.length === 1) - || firstChar === '/') { + else if (firstChar === '.' && (secondChar === '/' || secondChar === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) || + relUrl.length === 1 && (relUrl += '/')) || + firstChar === '/') { var parentIsPlain = !parentProtocol || parentUrl[parentProtocol.length] !== '/'; // read pathname from parent if a URL @@ -422,14 +422,14 @@ function resolveIfNotPlain (relUrl, parentUrl) { var segmented = pathname.substr(0, pathname.lastIndexOf('/') + 1) + relUrl; var output = []; - var segmentIndex = undefined; + var segmentIndex = -1; for (var i = 0; i < segmented.length; i++) { // busy reading a segment - only terminate on '/' - if (segmentIndex !== undefined) { + if (segmentIndex !== -1) { if (segmented[i] === '/') { - output.push(segmented.substr(segmentIndex, i - segmentIndex + 1)); - segmentIndex = undefined; + output.push(segmented.substring(segmentIndex, i + 1)); + segmentIndex = -1; } continue; } @@ -437,12 +437,12 @@ function resolveIfNotPlain (relUrl, parentUrl) { // new segment - check if it is relative if (segmented[i] === '.') { // ../ segment - if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i === segmented.length - 2)) { + if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) { output.pop(); i += 2; } // ./ segment - else if (segmented[i + 1] === '/' || i === segmented.length - 1) { + else if (segmented[i + 1] === '/' || i + 1 === segmented.length) { i += 1; } else { @@ -455,9 +455,6 @@ function resolveIfNotPlain (relUrl, parentUrl) { if (parentIsPlain && output.length === 0) throwResolveError(relUrl, parentUrl); - // trailing . or .. segment - if (i === segmented.length) - output.push(''); continue; } @@ -465,8 +462,8 @@ function resolveIfNotPlain (relUrl, parentUrl) { segmentIndex = i; } // finish reading out the last segment - if (segmentIndex !== undefined) - output.push(segmented.substr(segmentIndex, segmented.length - segmentIndex)); + if (segmentIndex !== -1) + output.push(segmented.substr(segmentIndex)); return parentUrl.substr(0, parentUrl.length - pathname.length) + output.join(''); } @@ -491,7 +488,7 @@ function resolveIfNotPlain (relUrl, parentUrl) { * - loader.register support * - hookable higher-level resolve * - instantiate hook returning a ModuleNamespace or undefined for es module loading - * - loader error behaviour as in HTML and loader specs, clearing failed modules from registration cache synchronously + * - loader error behaviour as in HTML and loader specs, caching load and eval errors separately * - build tracing support by providing a .trace=true and .loads object format */ @@ -505,8 +502,10 @@ function RegisterLoader$1 () { var deleted = registryDelete.call(this, key); // also delete from register registry if linked - if (records.hasOwnProperty(key) && !records[key].linkRecord) + if (records.hasOwnProperty(key) && !records[key].linkRecord) { delete records[key]; + deleted = true; + } return deleted; }; @@ -554,6 +553,9 @@ function createLoadRecord (state, key, registration) { // for already-loaded modules by adding themselves to their importerSetters importerSetters: undefined, + loadError: undefined, + evalError: undefined, + // in-flight linking record linkRecord: { // promise for instantiated @@ -573,12 +575,6 @@ function createLoadRecord (state, key, registration) { // will be the array of dependency load record or a module namespace dependencyInstantiations: undefined, - // indicates if the load and all its dependencies are instantiated and linked - // but not yet executed - // mostly just a performance shortpath to avoid rechecking the promises above - linked: false, - - error: undefined // NB optimization and way of ensuring module objects in setters // indicates setters which should run pre-execution of that dependency // setters is then just for completely executed module objects @@ -592,28 +588,26 @@ function createLoadRecord (state, key, registration) { RegisterLoader$1.prototype[Loader.resolveInstantiate] = function (key, parentKey) { var loader = this; var state = this[REGISTER_INTERNAL]; - var registry = loader.registry[loader.registry._registry]; + var registry = this.registry[REGISTRY]; return resolveInstantiate(loader, key, parentKey, registry, state) .then(function (instantiated) { if (instantiated instanceof ModuleNamespace) return instantiated; - // if already beaten to linked, return - if (instantiated.module) - return instantiated.module; - // resolveInstantiate always returns a load record with a link record and no module value - if (instantiated.linkRecord.linked) - return ensureEvaluate(loader, instantiated, instantiated.linkRecord, registry, state, undefined); + var link = instantiated.linkRecord; - return instantiateDeps(loader, instantiated, instantiated.linkRecord, registry, state, [instantiated]) + // if already beaten to done, return + if (!link) { + if (instantiated.module) + return instantiated.module; + throw instantiated.evalError; + } + + return deepInstantiateDeps(loader, instantiated, link, registry, state) .then(function () { - return ensureEvaluate(loader, instantiated, instantiated.linkRecord, registry, state, undefined); - }) - .catch(function (err) { - clearLoadErrors(loader, instantiated); - throw err; + return ensureEvaluate(loader, instantiated, link, registry, state, undefined); }); }); }; @@ -628,8 +622,11 @@ function resolveInstantiate (loader, key, parentKey, registry, state) { var load = state.records[key]; // already linked but not in main registry is ignored - if (load && !load.module) + if (load && !load.module) { + if (load.loadError) + return Promise.reject(load.loadError); return instantiate(loader, load, load.linkRecord, registry, state); + } return loader.resolve(key, parentKey) .then(function (resolvedKey) { @@ -647,6 +644,9 @@ function resolveInstantiate (loader, key, parentKey, registry, state) { if (!load || load.module) load = createLoadRecord(state, resolvedKey, load && load.registration); + if (load.loadError) + return Promise.reject(load.loadError); + var link = load.linkRecord; if (!link) return load; @@ -703,8 +703,7 @@ function instantiate (loader, load, link, registry, state) { // process System.registerDynamic declaration if (registration[2]) { - link.moduleObj.default = {}; - link.moduleObj.__useDefault = true; + link.moduleObj.default = link.moduleObj.__useDefault = {}; link.executingRequire = registration[1]; link.execute = registration[2]; } @@ -714,17 +713,11 @@ function instantiate (loader, load, link, registry, state) { registerDeclarative(loader, load, link, registration[1]); } - // shortpath to instantiateDeps - if (!link.dependencies.length) { - link.linked = true; - if (loader.trace) - traceLoad(loader, load, link); - } - return load; }) .catch(function (err) { - throw link.error = LoaderError__Check_error_message_for_loader_stack(err, 'Instantiating ' + load.key); + load.linkRecord = undefined; + throw load.loadError = load.loadError || LoaderError__Check_error_message_for_loader_stack(err, 'Instantiating ' + load.key); })); } @@ -766,6 +759,9 @@ function resolveInstantiateDep (loader, key, parentKey, registry, state, traceDe if (module && (!load || load.module && module !== load.module)) return module; + if (load && load.loadError) + throw load.loadError; + // already has a module value but not already in the registry (load.module) // means it was removed by registry.delete, so we should // disgard the current load record creating a new one over it @@ -786,6 +782,7 @@ function traceLoad (loader, load, link) { loader.loads[load.key] = { key: load.key, deps: link.dependencies, + dynamicDeps: [], depMap: link.depMap || {} }; } @@ -801,47 +798,52 @@ function registerDeclarative (loader, load, link, declare) { var moduleObj = link.moduleObj; var importerSetters = load.importerSetters; - var locked = false; + var definedExports = false; // closure especially not based on link to allow link record disposal var declared = declare.call(envGlobal, function (name, value) { - // export setter propogation with locking to avoid cycles - if (locked) - return; - if (typeof name === 'object') { - for (var p in name) - if (p !== '__useDefault') - moduleObj[p] = name[p]; + var changed = false; + for (var p in name) { + value = name[p]; + if (p !== '__useDefault' && (!(p in moduleObj) || moduleObj[p] !== value)) { + changed = true; + moduleObj[p] = value; + } + } + if (changed === false) + return value; } else { + if ((definedExports || name in moduleObj) && moduleObj[name] === value) + return value; moduleObj[name] = value; } - locked = true; for (var i = 0; i < importerSetters.length; i++) importerSetters[i](moduleObj); - locked = false; return value; }, new ContextualLoader(loader, load.key)); link.setters = declared.setters; link.execute = declared.execute; - if (declared.exports) + if (declared.exports) { link.moduleObj = moduleObj = declared.exports; + definedExports = true; + } } -function instantiateDeps (loader, load, link, registry, state, seen) { - return (link.depsInstantiatePromise || (link.depsInstantiatePromise = Promise.resolve() - .then(function () { - var depsInstantiatePromises = Array(link.dependencies.length); +function instantiateDeps (loader, load, link, registry, state) { + if (link.depsInstantiatePromise) + return link.depsInstantiatePromise; - for (var i = 0; i < link.dependencies.length; i++) - depsInstantiatePromises[i] = resolveInstantiateDep(loader, link.dependencies[i], load.key, registry, state, loader.trace && link.depMap || (link.depMap = {})); + var depsInstantiatePromises = Array(link.dependencies.length); - return Promise.all(depsInstantiatePromises); - }) + for (var i = 0; i < link.dependencies.length; i++) + depsInstantiatePromises[i] = resolveInstantiateDep(loader, link.dependencies[i], load.key, registry, state, loader.trace && link.depMap || (link.depMap = {})); + + var depsInstantiatePromise = Promise.all(depsInstantiatePromises) .then(function (dependencyInstantiations) { link.dependencyInstantiations = dependencyInstantiations; @@ -856,6 +858,8 @@ function instantiateDeps (loader, load, link, registry, state, seen) { setter(instantiation); } else { + if (instantiation.loadError) + throw instantiation.loadError; setter(instantiation.module || instantiation.linkRecord.moduleObj); // this applies to both es and dynamic registrations if (instantiation.importerSetters) @@ -864,80 +868,59 @@ function instantiateDeps (loader, load, link, registry, state, seen) { } } } - }))) - .then(function () { - // now deeply instantiateDeps on each dependencyInstantiation that is a load record - var deepDepsInstantiatePromises = []; - - for (var i = 0; i < link.dependencies.length; i++) { - var depLoad = link.dependencyInstantiations[i]; - var depLink = depLoad.linkRecord; - if (!depLink || depLink.linked) - continue; - - if (seen.indexOf(depLoad) !== -1) - continue; - seen.push(depLoad); - - deepDepsInstantiatePromises.push(instantiateDeps(loader, depLoad, depLoad.linkRecord, registry, state, seen)); - } + return load; + }); - return Promise.all(deepDepsInstantiatePromises); - }) - .then(function () { - // as soon as all dependencies instantiated, we are ready for evaluation so can add to the registry - // this can run multiple times, but so what - link.linked = true; - if (loader.trace) + if (loader.trace) + depsInstantiatePromise = depsInstantiatePromise.then(function () { traceLoad(loader, load, link); + return load; + }); - return load; - }) - .catch(function (err) { - err = LoaderError__Check_error_message_for_loader_stack(err, 'Loading ' + load.key); - + depsInstantiatePromise = depsInstantiatePromise.catch(function (err) { // throw up the instantiateDeps stack - // loads are then synchonously cleared at the top-level through the clearLoadErrors helper below - // this then ensures avoiding partially unloaded tree states - link.error = link.error || err; - - throw err; + link.depsInstantiatePromise = undefined; + throw LoaderError__Check_error_message_for_loader_stack(err, 'Loading ' + load.key); }); -} - -// clears an errored load and all its errored dependencies from the loads registry -function clearLoadErrors (loader, load) { - var state = loader[REGISTER_INTERNAL]; - - // clear from loads - if (state.records[load.key] === load) - delete state.records[load.key]; - var link = load.linkRecord; + depsInstantiatePromise.catch(function () {}); - if (!link) - return; + return link.depsInstantiatePromise = depsInstantiatePromise; +} - if (link.dependencyInstantiations) - link.dependencyInstantiations.forEach(function (depLoad, index) { - if (!depLoad || depLoad instanceof ModuleNamespace) +function deepInstantiateDeps (loader, load, link, registry, state) { + return new Promise(function (resolve, reject) { + var seen = []; + var loadCnt = 0; + function queueLoad (load) { + var link = load.linkRecord; + if (!link) return; - if (depLoad.linkRecord) { - if (depLoad.linkRecord.error) { - // provides a circular reference check - if (state.records[depLoad.key] === depLoad) - clearLoadErrors(loader, depLoad); - } + if (seen.indexOf(load) !== -1) + return; + seen.push(load); - // unregister setters for es dependency load records that will remain - if (link.setters && depLoad.importerSetters) { - var setterIndex = depLoad.importerSetters.indexOf(link.setters[index]); - depLoad.importerSetters.splice(setterIndex, 1); + loadCnt++; + instantiateDeps(loader, load, link, registry, state) + .then(processLoad, reject); + } + function processLoad (load) { + loadCnt--; + var link = load.linkRecord; + if (link) { + for (var i = 0; i < link.dependencies.length; i++) { + var depLoad = link.dependencyInstantiations[i]; + if (!(depLoad instanceof ModuleNamespace)) + queueLoad(depLoad); } } - }); + if (loadCnt === 0) + resolve(); + } + queueLoad(load); + }); } /* @@ -977,31 +960,34 @@ RegisterLoader$1.prototype.registerDynamic = function (key, deps, executingRequi }; // ContextualLoader class -// backwards-compatible with previous System.register context argument by exposing .id +// backwards-compatible with previous System.register context argument by exposing .id, .key function ContextualLoader (loader, key) { this.loader = loader; this.key = this.id = key; + this.meta = { + url: key + // scriptElement: null + }; } -ContextualLoader.prototype.constructor = function () { +/*ContextualLoader.prototype.constructor = function () { throw new TypeError('Cannot subclass the contextual loader only Reflect.Loader.'); -}; +};*/ ContextualLoader.prototype.import = function (key) { + if (this.loader.trace) + this.loader.loads[this.key].dynamicDeps.push(key); return this.loader.import(key, this.key); }; -ContextualLoader.prototype.resolve = function (key) { +/*ContextualLoader.prototype.resolve = function (key) { return this.loader.resolve(key, this.key); -}; -ContextualLoader.prototype.load = function (key) { - return this.loader.load(key, this.key); -}; +};*/ // this is the execution function bound to the Module namespace record function ensureEvaluate (loader, load, link, registry, state, seen) { if (load.module) return load.module; - if (link.error) - throw link.error; + if (load.evalError) + throw load.evalError; if (seen && seen.indexOf(load) !== -1) return load.linkRecord.moduleObj; @@ -1009,10 +995,8 @@ function ensureEvaluate (loader, load, link, registry, state, seen) { // for ES loads we always run ensureEvaluate on top-level, so empty seen is passed regardless // for dynamic loads, we pass seen if also dynamic var err = doEvaluate(loader, load, link, registry, state, link.setters ? [] : seen || []); - if (err) { - clearLoadErrors(loader, load); + if (err) throw err; - } return load.module; } @@ -1030,7 +1014,7 @@ function makeDynamicRequire (loader, key, dependencies, dependencyInstantiations else module = ensureEvaluate(loader, depLoad, depLoad.linkRecord, registry, state, seen); - return module.__useDefault ? module.default : module; + return '__useDefault' in module ? module.__useDefault : module; } } throw new Error('Module ' + name + ' not declared as a System.registerDynamic dependency of ' + key); @@ -1057,16 +1041,19 @@ function doEvaluate (loader, load, link, registry, state, seen) { // custom Module returned from instantiate depLink = depLoad.linkRecord; if (depLink && seen.indexOf(depLoad) === -1) { - if (depLink.error) - err = depLink.error; + if (depLoad.evalError) + err = depLoad.evalError; else // dynamic / declarative boundaries clear the "seen" list // we just let cross format circular throw as would happen in real implementations err = doEvaluate(loader, depLoad, depLink, registry, state, depLink.setters ? seen : []); } - if (err) - return link.error = LoaderError__Check_error_message_for_loader_stack(err, 'Evaluating ' + load.key); + if (err) { + load.linkRecord = undefined; + load.evalError = LoaderError__Check_error_message_for_loader_stack(err, 'Evaluating ' + load.key); + return load.evalError; + } } } @@ -1085,10 +1072,10 @@ function doEvaluate (loader, load, link, registry, state, seen) { Object.defineProperty(module, 'exports', { configurable: true, set: function (exports) { - moduleObj.default = exports; + moduleObj.default = moduleObj.__useDefault = exports; }, get: function () { - return moduleObj.default; + return moduleObj.__useDefault; } }); @@ -1102,26 +1089,26 @@ function doEvaluate (loader, load, link, registry, state, seen) { err = dynamicExecute(link.execute, require, moduleObj.default, module); // pick up defineProperty calls to module.exports when we can - if (module.exports !== moduleObj.default) - moduleObj.default = module.exports; + if (module.exports !== moduleObj.__useDefault) + moduleObj.default = moduleObj.__useDefault = module.exports; var moduleDefault = moduleObj.default; // __esModule flag extension support via lifting if (moduleDefault && moduleDefault.__esModule) { - if (moduleObj.__useDefault) - delete moduleObj.__useDefault; for (var p in moduleDefault) { if (Object.hasOwnProperty.call(moduleDefault, p)) moduleObj[p] = moduleDefault[p]; } - moduleObj.__esModule = true; } } } + // dispose link record + load.linkRecord = undefined; + if (err) - return link.error = LoaderError__Check_error_message_for_loader_stack(err, 'Evaluating ' + load.key); + return load.evalError = LoaderError__Check_error_message_for_loader_stack(err, 'Evaluating ' + load.key); registry[load.key] = load.module = new ModuleNamespace(link.moduleObj); @@ -1134,9 +1121,6 @@ function doEvaluate (loader, load, link, registry, state, seen) { load.importerSetters[i](load.module); load.importerSetters = undefined; } - - // dispose link record - load.linkRecord = undefined; } // {} is the closest we can get to call(undefined) @@ -1212,7 +1196,7 @@ if (typeof document != 'undefined' && document.getElementsByTagName) { } // anonymous modules supported via a custom naming scheme and registry else { - var uri = './'; + var uri = './.js'; if (script.id !== ""){ uri = "./" + script.id; } diff --git a/vendor/browser-es-module-loader/dist/browser-es-module-loader.js.map b/vendor/browser-es-module-loader/dist/browser-es-module-loader.js.map index 702e2fc..79c4f1f 100644 --- a/vendor/browser-es-module-loader/dist/browser-es-module-loader.js.map +++ b/vendor/browser-es-module-loader/dist/browser-es-module-loader.js.map @@ -1 +1 @@ -{"version":3,"file":"browser-es-module-loader.js","sources":["../../../node_modules/es-module-loader/core/common.js","../../../node_modules/es-module-loader/core/loader-polyfill.js","../../../node_modules/es-module-loader/core/resolve.js","../../../node_modules/es-module-loader/core/register-loader.js","../src/browser-es-module-loader.js"],"sourcesContent":["/*\n * Environment\n */\nexport var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';\nexport var isNode = typeof process !== 'undefined' && process.versions && process.versions.node;\nexport var isWindows = typeof process !== 'undefined' && typeof process.platform === 'string' && process.platform.match(/^win/);\n\nvar envGlobal = typeof self !== 'undefined' ? self : global;\nexport { envGlobal as global }\n\n/*\n * Simple Symbol() shim\n */\nvar hasSymbol = typeof Symbol !== 'undefined';\nexport function createSymbol (name) {\n return hasSymbol ? Symbol() : '@@' + name;\n}\n\nexport function pathToFileUrl (filePath) {\n return 'file://' + (isWindows ? '/' : '') + (isWindows ? filePath.replace(/\\\\/g, '/') : filePath);\n}\n\nexport function fileUrlToPath (fileUrl) {\n if (fileUrl.substr(0, 7) !== 'file://')\n throw new RangeError(fileUrl + ' is not a valid file url');\n if (isWindows)\n return fileUrl.substr(8).replace(/\\\\/g, '/');\n else\n return fileUrl.substr(7);\n}\n\n/*\n * Environment baseURI\n */\nexport var baseURI;\n\n// environent baseURI detection\nif (typeof document != 'undefined' && document.getElementsByTagName) {\n baseURI = document.baseURI;\n\n if (!baseURI) {\n var bases = document.getElementsByTagName('base');\n baseURI = bases[0] && bases[0].href || window.location.href;\n }\n}\nelse if (typeof location != 'undefined') {\n baseURI = location.href;\n}\n\n// sanitize out the hash and querystring\nif (baseURI) {\n baseURI = baseURI.split('#')[0].split('?')[0];\n var slashIndex = baseURI.lastIndexOf('/');\n if (slashIndex !== -1)\n baseURI = baseURI.substr(0, slashIndex + 1);\n}\nelse if (typeof process !== 'undefined' && process.cwd) {\n baseURI = 'file://' + (isWindows ? '/' : '') + process.cwd();\n if (isWindows)\n baseURI = baseURI.replace(/\\\\/g, '/');\n}\nelse {\n throw new TypeError('No environment baseURI');\n}\n\n// ensure baseURI has trailing \"/\"\nif (baseURI[baseURI.length - 1] !== '/')\n baseURI += '/';\n\n/*\n * LoaderError with chaining for loader stacks\n */\nvar errArgs = new Error(0, '_').fileName == '_';\nfunction LoaderError__Check_error_message_for_loader_stack (childErr, newMessage) {\n // Convert file:/// URLs to paths in Node\n if (!isBrowser)\n newMessage = newMessage.replace(isWindows ? /file:\\/\\/\\//g : /file:\\/\\//g, '');\n\n var message = (childErr.message || childErr) + '\\n ' + newMessage;\n\n var err;\n if (errArgs && childErr.fileName)\n err = new Error(message, childErr.fileName, childErr.lineNumber);\n else\n err = new Error(message);\n\n\n var stack = childErr.originalErr ? childErr.originalErr.stack : childErr.stack;\n\n if (isNode)\n // node doesn't show the message otherwise\n err.stack = message + '\\n ' + stack;\n else\n err.stack = stack;\n\n err.originalErr = childErr.originalErr || childErr;\n\n return err;\n}\nexport { LoaderError__Check_error_message_for_loader_stack as addToError }\n","import { addToError, createSymbol } from './common.js';\n\nexport { Loader, ModuleNamespace }\n\nvar resolvedPromise = Promise.resolve();\n\n/*\n * Simple Array values shim\n */\nfunction arrayValues (arr) {\n if (arr.values)\n return arr.values();\n\n if (typeof Symbol === 'undefined' || !Symbol.iterator)\n throw new Error('Symbol.iterator not supported in this browser');\n\n var iterable = {};\n iterable[Symbol.iterator] = function () {\n var keys = Object.keys(arr);\n var keyIndex = 0;\n return {\n next: function () {\n if (keyIndex < keys.length)\n return {\n value: arr[keys[keyIndex++]],\n done: false\n };\n else\n return {\n value: undefined,\n done: true\n };\n }\n };\n };\n return iterable;\n}\n\n/*\n * 3. Reflect.Loader\n *\n * We skip the entire native internal pipeline, just providing the bare API\n */\n// 3.1.1\nfunction Loader () {\n this.registry = new Registry();\n}\n// 3.3.1\nLoader.prototype.constructor = Loader;\n\nfunction ensureInstantiated (module) {\n if (!(module instanceof ModuleNamespace))\n throw new TypeError('Module instantiation did not return a valid namespace object.');\n return module;\n}\n\n// 3.3.2\nLoader.prototype.import = function (key, parent) {\n if (typeof key !== 'string')\n throw new TypeError('Loader import method must be passed a module key string');\n // custom resolveInstantiate combined hook for better perf\n var loader = this;\n return resolvedPromise\n .then(function () {\n return loader[RESOLVE_INSTANTIATE](key, parent);\n })\n .then(ensureInstantiated)\n //.then(Module.evaluate)\n .catch(function (err) {\n throw addToError(err, 'Loading ' + key + (parent ? ' from ' + parent : ''));\n });\n};\n// 3.3.3\nvar RESOLVE = Loader.resolve = createSymbol('resolve');\n\n/*\n * Combined resolve / instantiate hook\n *\n * Not in current reduced spec, but necessary to separate RESOLVE from RESOLVE + INSTANTIATE as described\n * in the spec notes of this repo to ensure that loader.resolve doesn't instantiate when not wanted.\n *\n * We implement RESOLVE_INSTANTIATE as a single hook instead of a separate INSTANTIATE in order to avoid\n * the need for double registry lookups as a performance optimization.\n */\nvar RESOLVE_INSTANTIATE = Loader.resolveInstantiate = createSymbol('resolveInstantiate');\n\n// default resolveInstantiate is just to call resolve and then get from the registry\n// this provides compatibility for the resolveInstantiate optimization\nLoader.prototype[RESOLVE_INSTANTIATE] = function (key, parent) {\n var loader = this;\n return loader.resolve(key, parent)\n .then(function (resolved) {\n return loader.registry.get(resolved);\n });\n};\n\nfunction ensureResolution (resolvedKey) {\n if (resolvedKey === undefined)\n throw new RangeError('No resolution found.');\n return resolvedKey;\n}\n\nLoader.prototype.resolve = function (key, parent) {\n var loader = this;\n return resolvedPromise\n .then(function() {\n return loader[RESOLVE](key, parent);\n })\n .then(ensureResolution)\n .catch(function (err) {\n throw addToError(err, 'Resolving ' + key + (parent ? ' to ' + parent : ''));\n });\n};\n\n// 3.3.4 (import without evaluate)\n// this is not documented because the use of deferred evaluation as in Module.evaluate is not\n// documented, as it is not considered a stable feature to be encouraged\n// Loader.prototype.load may well be deprecated if this stays disabled\n/* Loader.prototype.load = function (key, parent) {\n return Promise.resolve(this[RESOLVE_INSTANTIATE](key, parent || this.key))\n .catch(function (err) {\n throw addToError(err, 'Loading ' + key + (parent ? ' from ' + parent : ''));\n });\n}; */\n\n/*\n * 4. Registry\n *\n * Instead of structuring through a Map, just use a dictionary object\n * We throw for construction attempts so this doesn't affect the public API\n *\n * Registry has been adjusted to use Namespace objects over ModuleStatus objects\n * as part of simplifying loader API implementation\n */\nvar iteratorSupport = typeof Symbol !== 'undefined' && Symbol.iterator;\nvar REGISTRY = createSymbol('registry');\nfunction Registry() {\n this[REGISTRY] = {};\n this._registry = REGISTRY;\n}\n// 4.4.1\nif (iteratorSupport) {\n // 4.4.2\n Registry.prototype[Symbol.iterator] = function () {\n return this.entries()[Symbol.iterator]();\n };\n\n // 4.4.3\n Registry.prototype.entries = function () {\n var registry = this[REGISTRY];\n return arrayValues(Object.keys(registry).map(function (key) {\n return [key, registry[key]];\n }));\n };\n}\n\n// 4.4.4\nRegistry.prototype.keys = function () {\n return arrayValues(Object.keys(this[REGISTRY]));\n};\n// 4.4.5\nRegistry.prototype.values = function () {\n var registry = this[REGISTRY];\n return arrayValues(Object.keys(registry).map(function (key) {\n return registry[key];\n }));\n};\n// 4.4.6\nRegistry.prototype.get = function (key) {\n return this[REGISTRY][key];\n};\n// 4.4.7\nRegistry.prototype.set = function (key, namespace) {\n if (!(namespace instanceof ModuleNamespace))\n throw new Error('Registry must be set with an instance of Module Namespace');\n this[REGISTRY][key] = namespace;\n return this;\n};\n// 4.4.8\nRegistry.prototype.has = function (key) {\n return Object.hasOwnProperty.call(this[REGISTRY], key);\n};\n// 4.4.9\nRegistry.prototype.delete = function (key) {\n if (Object.hasOwnProperty.call(this[REGISTRY], key)) {\n delete this[REGISTRY][key];\n return true;\n }\n return false;\n};\n\n/*\n * Simple ModuleNamespace Exotic object based on a baseObject\n * We export this for allowing a fast-path for module namespace creation over Module descriptors\n */\n// var EVALUATE = createSymbol('evaluate');\nvar BASE_OBJECT = createSymbol('baseObject');\n\n// 8.3.1 Reflect.Module\n/*\n * Best-effort simplified non-spec implementation based on\n * a baseObject referenced via getters.\n *\n * Allows:\n *\n * loader.registry.set('x', new Module({ default: 'x' }));\n *\n * Optional evaluation function provides experimental Module.evaluate\n * support for non-executed modules in registry.\n */\nfunction ModuleNamespace (baseObject/*, evaluate*/) {\n Object.defineProperty(this, BASE_OBJECT, {\n value: baseObject\n });\n\n // evaluate defers namespace population\n /* if (evaluate) {\n Object.defineProperty(this, EVALUATE, {\n value: evaluate,\n configurable: true,\n writable: true\n });\n }\n else { */\n Object.keys(baseObject).forEach(extendNamespace, this);\n //}\n};\n// 8.4.2\nModuleNamespace.prototype = Object.create(null);\n\nif (typeof Symbol !== 'undefined' && Symbol.toStringTag)\n Object.defineProperty(ModuleNamespace.prototype, Symbol.toStringTag, {\n value: 'Module'\n });\n\nfunction extendNamespace (key) {\n Object.defineProperty(this, key, {\n enumerable: true,\n get: function () {\n return this[BASE_OBJECT][key];\n }\n });\n}\n\n/* function doEvaluate (evaluate, context) {\n try {\n evaluate.call(context);\n }\n catch (e) {\n return e;\n }\n}\n\n// 8.4.1 Module.evaluate... not documented or used because this is potentially unstable\nModule.evaluate = function (ns) {\n var evaluate = ns[EVALUATE];\n if (evaluate) {\n ns[EVALUATE] = undefined;\n var err = doEvaluate(evaluate);\n if (err) {\n // cache the error\n ns[EVALUATE] = function () {\n throw err;\n };\n throw err;\n }\n Object.keys(ns[BASE_OBJECT]).forEach(extendNamespace, ns);\n }\n // make chainable\n return ns;\n}; */\n","import { isNode } from './common.js';\n\n/*\n * Optimized URL normalization assuming a syntax-valid URL parent\n */\nfunction throwResolveError (relUrl, parentUrl) {\n throw new RangeError('Unable to resolve \"' + relUrl + '\" to ' + parentUrl);\n}\nexport function resolveIfNotPlain (relUrl, parentUrl) {\n relUrl = relUrl.trim();\n var parentProtocol = parentUrl && parentUrl.substr(0, parentUrl.indexOf(':') + 1);\n\n var firstChar = relUrl[0];\n var secondChar = relUrl[1];\n\n // protocol-relative\n if (firstChar === '/' && secondChar === '/') {\n if (!parentProtocol)\n throwResolveError(relUrl, parentUrl);\n return parentProtocol + relUrl;\n }\n // relative-url\n else if (firstChar === '.' && (secondChar === '/' || secondChar === '.' && (relUrl[2] === '/' || relUrl.length === 2) || relUrl.length === 1)\n || firstChar === '/') {\n var parentIsPlain = !parentProtocol || parentUrl[parentProtocol.length] !== '/';\n\n // read pathname from parent if a URL\n // pathname taken to be part after leading \"/\"\n var pathname;\n if (parentIsPlain) {\n // resolving to a plain parent -> skip standard URL prefix, and treat entire parent as pathname\n if (parentUrl === undefined)\n throwResolveError(relUrl, parentUrl);\n pathname = parentUrl;\n }\n else if (parentUrl[parentProtocol.length + 1] === '/') {\n // resolving to a :// so we need to read out the auth and host\n if (parentProtocol !== 'file:') {\n pathname = parentUrl.substr(parentProtocol.length + 2);\n pathname = pathname.substr(pathname.indexOf('/') + 1);\n }\n else {\n pathname = parentUrl.substr(8);\n }\n }\n else {\n // resolving to :/ so pathname is the /... part\n pathname = parentUrl.substr(parentProtocol.length + 1);\n }\n\n if (firstChar === '/') {\n if (parentIsPlain)\n throwResolveError(relUrl, parentUrl);\n else\n return parentUrl.substr(0, parentUrl.length - pathname.length - 1) + relUrl;\n }\n\n // join together and split for removal of .. and . segments\n // looping the string instead of anything fancy for perf reasons\n // '../../../../../z' resolved to 'x/y' is just 'z' regardless of parentIsPlain\n var segmented = pathname.substr(0, pathname.lastIndexOf('/') + 1) + relUrl;\n\n var output = [];\n var segmentIndex = undefined;\n\n for (var i = 0; i < segmented.length; i++) {\n // busy reading a segment - only terminate on '/'\n if (segmentIndex !== undefined) {\n if (segmented[i] === '/') {\n output.push(segmented.substr(segmentIndex, i - segmentIndex + 1));\n segmentIndex = undefined;\n }\n continue;\n }\n\n // new segment - check if it is relative\n if (segmented[i] === '.') {\n // ../ segment\n if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i === segmented.length - 2)) {\n output.pop();\n i += 2;\n }\n // ./ segment\n else if (segmented[i + 1] === '/' || i === segmented.length - 1) {\n i += 1;\n }\n else {\n // the start of a new segment as below\n segmentIndex = i;\n continue;\n }\n\n // this is the plain URI backtracking error (../, package:x -> error)\n if (parentIsPlain && output.length === 0)\n throwResolveError(relUrl, parentUrl);\n\n // trailing . or .. segment\n if (i === segmented.length)\n output.push('');\n continue;\n }\n\n // it is the start of a new segment\n segmentIndex = i;\n }\n // finish reading out the last segment\n if (segmentIndex !== undefined)\n output.push(segmented.substr(segmentIndex, segmented.length - segmentIndex));\n\n return parentUrl.substr(0, parentUrl.length - pathname.length) + output.join('');\n }\n\n // sanitizes and verifies (by returning undefined if not a valid URL-like form)\n // Windows filepath compatibility is an added convenience here\n var protocolIndex = relUrl.indexOf(':');\n if (protocolIndex !== -1) {\n if (isNode) {\n // C:\\x becomes file:///c:/x (we don't support C|\\x)\n if (relUrl[1] === ':' && relUrl[2] === '\\\\' && relUrl[0].match(/[a-z]/i))\n return 'file:///' + relUrl.replace(/\\\\/g, '/');\n }\n return relUrl;\n }\n}\n","import { Loader, ModuleNamespace } from './loader-polyfill.js';\nimport { resolveIfNotPlain } from './resolve.js';\nimport { addToError, global, createSymbol, baseURI } from './common.js';\n\nexport default RegisterLoader;\n\n/*\n * Register Loader\n *\n * Builds directly on top of loader polyfill to provide:\n * - loader.register support\n * - hookable higher-level resolve\n * - instantiate hook returning a ModuleNamespace or undefined for es module loading\n * - loader error behaviour as in HTML and loader specs, clearing failed modules from registration cache synchronously\n * - build tracing support by providing a .trace=true and .loads object format\n */\n\nvar REGISTER_INTERNAL = createSymbol('register-internal');\n\nfunction RegisterLoader () {\n Loader.call(this);\n\n var registryDelete = this.registry.delete;\n this.registry.delete = function (key) {\n var deleted = registryDelete.call(this, key);\n\n // also delete from register registry if linked\n if (records.hasOwnProperty(key) && !records[key].linkRecord)\n delete records[key];\n\n return deleted;\n };\n\n var records = {};\n\n this[REGISTER_INTERNAL] = {\n // last anonymous System.register call\n lastRegister: undefined,\n // in-flight es module load records\n records: records\n };\n\n // tracing\n this.trace = false;\n}\n\nRegisterLoader.prototype = Object.create(Loader.prototype);\nRegisterLoader.prototype.constructor = RegisterLoader;\n\nvar INSTANTIATE = RegisterLoader.instantiate = createSymbol('instantiate');\n\n// default normalize is the WhatWG style normalizer\nRegisterLoader.prototype[RegisterLoader.resolve = Loader.resolve] = function (key, parentKey) {\n return resolveIfNotPlain(key, parentKey || baseURI);\n};\n\nRegisterLoader.prototype[INSTANTIATE] = function (key, processAnonRegister) {};\n\n// once evaluated, the linkRecord is set to undefined leaving just the other load record properties\n// this allows tracking new binding listeners for es modules through importerSetters\n// for dynamic modules, the load record is removed entirely.\nfunction createLoadRecord (state, key, registration) {\n return state.records[key] = {\n key: key,\n\n // defined System.register cache\n registration: registration,\n\n // module namespace object\n module: undefined,\n\n // es-only\n // this sticks around so new module loads can listen to binding changes\n // for already-loaded modules by adding themselves to their importerSetters\n importerSetters: undefined,\n\n // in-flight linking record\n linkRecord: {\n // promise for instantiated\n instantiatePromise: undefined,\n dependencies: undefined,\n execute: undefined,\n executingRequire: false,\n\n // underlying module object bindings\n moduleObj: undefined,\n\n // es only, also indicates if es or not\n setters: undefined,\n\n // promise for instantiated dependencies (dependencyInstantiations populated)\n depsInstantiatePromise: undefined,\n // will be the array of dependency load record or a module namespace\n dependencyInstantiations: undefined,\n\n // indicates if the load and all its dependencies are instantiated and linked\n // but not yet executed\n // mostly just a performance shortpath to avoid rechecking the promises above\n linked: false,\n\n error: undefined\n // NB optimization and way of ensuring module objects in setters\n // indicates setters which should run pre-execution of that dependency\n // setters is then just for completely executed module objects\n // alternatively we just pass the partially filled module objects as\n // arguments into the execute function\n // hoisted: undefined\n }\n };\n}\n\nRegisterLoader.prototype[Loader.resolveInstantiate] = function (key, parentKey) {\n var loader = this;\n var state = this[REGISTER_INTERNAL];\n var registry = loader.registry[loader.registry._registry];\n\n return resolveInstantiate(loader, key, parentKey, registry, state)\n .then(function (instantiated) {\n if (instantiated instanceof ModuleNamespace)\n return instantiated;\n\n // if already beaten to linked, return\n if (instantiated.module)\n return instantiated.module;\n\n // resolveInstantiate always returns a load record with a link record and no module value\n if (instantiated.linkRecord.linked)\n return ensureEvaluate(loader, instantiated, instantiated.linkRecord, registry, state, undefined);\n\n return instantiateDeps(loader, instantiated, instantiated.linkRecord, registry, state, [instantiated])\n .then(function () {\n return ensureEvaluate(loader, instantiated, instantiated.linkRecord, registry, state, undefined);\n })\n .catch(function (err) {\n clearLoadErrors(loader, instantiated);\n throw err;\n });\n });\n};\n\nfunction resolveInstantiate (loader, key, parentKey, registry, state) {\n // normalization shortpath for already-normalized key\n // could add a plain name filter, but doesn't yet seem necessary for perf\n var module = registry[key];\n if (module)\n return Promise.resolve(module);\n\n var load = state.records[key];\n\n // already linked but not in main registry is ignored\n if (load && !load.module)\n return instantiate(loader, load, load.linkRecord, registry, state);\n\n return loader.resolve(key, parentKey)\n .then(function (resolvedKey) {\n // main loader registry always takes preference\n module = registry[resolvedKey];\n if (module)\n return module;\n\n load = state.records[resolvedKey];\n\n // already has a module value but not already in the registry (load.module)\n // means it was removed by registry.delete, so we should\n // disgard the current load record creating a new one over it\n // but keep any existing registration\n if (!load || load.module)\n load = createLoadRecord(state, resolvedKey, load && load.registration);\n\n var link = load.linkRecord;\n if (!link)\n return load;\n\n return instantiate(loader, load, link, registry, state);\n });\n}\n\nfunction createProcessAnonRegister (loader, load, state) {\n return function () {\n var lastRegister = state.lastRegister;\n\n if (!lastRegister)\n return !!load.registration;\n\n state.lastRegister = undefined;\n load.registration = lastRegister;\n\n return true;\n };\n}\n\nfunction instantiate (loader, load, link, registry, state) {\n return link.instantiatePromise || (link.instantiatePromise =\n // if there is already an existing registration, skip running instantiate\n (load.registration ? Promise.resolve() : Promise.resolve().then(function () {\n state.lastRegister = undefined;\n return loader[INSTANTIATE](load.key, loader[INSTANTIATE].length > 1 && createProcessAnonRegister(loader, load, state));\n }))\n .then(function (instantiation) {\n // direct module return from instantiate -> we're done\n if (instantiation !== undefined) {\n if (!(instantiation instanceof ModuleNamespace))\n throw new TypeError('Instantiate did not return a valid Module object.');\n\n delete state.records[load.key];\n if (loader.trace)\n traceLoad(loader, load, link);\n return registry[load.key] = instantiation;\n }\n\n // run the cached loader.register declaration if there is one\n var registration = load.registration;\n // clear to allow new registrations for future loads (combined with registry delete)\n load.registration = undefined;\n if (!registration)\n throw new TypeError('Module instantiation did not call an anonymous or correctly named System.register.');\n\n link.dependencies = registration[0];\n\n load.importerSetters = [];\n\n link.moduleObj = {};\n\n // process System.registerDynamic declaration\n if (registration[2]) {\n link.moduleObj.default = {};\n link.moduleObj.__useDefault = true;\n link.executingRequire = registration[1];\n link.execute = registration[2];\n }\n\n // process System.register declaration\n else {\n registerDeclarative(loader, load, link, registration[1]);\n }\n\n // shortpath to instantiateDeps\n if (!link.dependencies.length) {\n link.linked = true;\n if (loader.trace)\n traceLoad(loader, load, link);\n }\n\n return load;\n })\n .catch(function (err) {\n throw link.error = addToError(err, 'Instantiating ' + load.key);\n }));\n}\n\n// like resolveInstantiate, but returning load records for linking\nfunction resolveInstantiateDep (loader, key, parentKey, registry, state, traceDepMap) {\n // normalization shortpaths for already-normalized key\n // DISABLED to prioritise consistent resolver calls\n // could add a plain name filter, but doesn't yet seem necessary for perf\n /* var load = state.records[key];\n var module = registry[key];\n\n if (module) {\n if (traceDepMap)\n traceDepMap[key] = key;\n\n // registry authority check in case module was deleted or replaced in main registry\n if (load && load.module && load.module === module)\n return load;\n else\n return module;\n }\n\n // already linked but not in main registry is ignored\n if (load && !load.module) {\n if (traceDepMap)\n traceDepMap[key] = key;\n return instantiate(loader, load, load.linkRecord, registry, state);\n } */\n return loader.resolve(key, parentKey)\n .then(function (resolvedKey) {\n if (traceDepMap)\n traceDepMap[key] = resolvedKey;\n\n // normalization shortpaths for already-normalized key\n var load = state.records[resolvedKey];\n var module = registry[resolvedKey];\n\n // main loader registry always takes preference\n if (module && (!load || load.module && module !== load.module))\n return module;\n\n // already has a module value but not already in the registry (load.module)\n // means it was removed by registry.delete, so we should\n // disgard the current load record creating a new one over it\n // but keep any existing registration\n if (!load || !module && load.module)\n load = createLoadRecord(state, resolvedKey, load && load.registration);\n\n var link = load.linkRecord;\n if (!link)\n return load;\n\n return instantiate(loader, load, link, registry, state);\n });\n}\n\nfunction traceLoad (loader, load, link) {\n loader.loads = loader.loads || {};\n loader.loads[load.key] = {\n key: load.key,\n deps: link.dependencies,\n depMap: link.depMap || {}\n };\n}\n\n/*\n * Convert a CJS module.exports into a valid object for new Module:\n *\n * new Module(getEsModule(module.exports))\n *\n * Sets the default value to the module, while also reading off named exports carefully.\n */\nfunction registerDeclarative (loader, load, link, declare) {\n var moduleObj = link.moduleObj;\n var importerSetters = load.importerSetters;\n\n var locked = false;\n\n // closure especially not based on link to allow link record disposal\n var declared = declare.call(global, function (name, value) {\n // export setter propogation with locking to avoid cycles\n if (locked)\n return;\n\n if (typeof name === 'object') {\n for (var p in name)\n if (p !== '__useDefault')\n moduleObj[p] = name[p];\n }\n else {\n moduleObj[name] = value;\n }\n\n locked = true;\n for (var i = 0; i < importerSetters.length; i++)\n importerSetters[i](moduleObj);\n locked = false;\n\n return value;\n }, new ContextualLoader(loader, load.key));\n\n link.setters = declared.setters;\n link.execute = declared.execute;\n if (declared.exports)\n link.moduleObj = moduleObj = declared.exports;\n}\n\nfunction instantiateDeps (loader, load, link, registry, state, seen) {\n return (link.depsInstantiatePromise || (link.depsInstantiatePromise = Promise.resolve()\n .then(function () {\n var depsInstantiatePromises = Array(link.dependencies.length);\n\n for (var i = 0; i < link.dependencies.length; i++)\n depsInstantiatePromises[i] = resolveInstantiateDep(loader, link.dependencies[i], load.key, registry, state, loader.trace && link.depMap || (link.depMap = {}));\n\n return Promise.all(depsInstantiatePromises);\n })\n .then(function (dependencyInstantiations) {\n link.dependencyInstantiations = dependencyInstantiations;\n\n // run setters to set up bindings to instantiated dependencies\n if (link.setters) {\n for (var i = 0; i < dependencyInstantiations.length; i++) {\n var setter = link.setters[i];\n if (setter) {\n var instantiation = dependencyInstantiations[i];\n\n if (instantiation instanceof ModuleNamespace) {\n setter(instantiation);\n }\n else {\n setter(instantiation.module || instantiation.linkRecord.moduleObj);\n // this applies to both es and dynamic registrations\n if (instantiation.importerSetters)\n instantiation.importerSetters.push(setter);\n }\n }\n }\n }\n })))\n .then(function () {\n // now deeply instantiateDeps on each dependencyInstantiation that is a load record\n var deepDepsInstantiatePromises = [];\n\n for (var i = 0; i < link.dependencies.length; i++) {\n var depLoad = link.dependencyInstantiations[i];\n var depLink = depLoad.linkRecord;\n\n if (!depLink || depLink.linked)\n continue;\n\n if (seen.indexOf(depLoad) !== -1)\n continue;\n seen.push(depLoad);\n\n deepDepsInstantiatePromises.push(instantiateDeps(loader, depLoad, depLoad.linkRecord, registry, state, seen));\n }\n\n return Promise.all(deepDepsInstantiatePromises);\n })\n .then(function () {\n // as soon as all dependencies instantiated, we are ready for evaluation so can add to the registry\n // this can run multiple times, but so what\n link.linked = true;\n if (loader.trace)\n traceLoad(loader, load, link);\n\n return load;\n })\n .catch(function (err) {\n err = addToError(err, 'Loading ' + load.key);\n\n // throw up the instantiateDeps stack\n // loads are then synchonously cleared at the top-level through the clearLoadErrors helper below\n // this then ensures avoiding partially unloaded tree states\n link.error = link.error || err;\n\n throw err;\n });\n}\n\n// clears an errored load and all its errored dependencies from the loads registry\nfunction clearLoadErrors (loader, load) {\n var state = loader[REGISTER_INTERNAL];\n\n // clear from loads\n if (state.records[load.key] === load)\n delete state.records[load.key];\n\n var link = load.linkRecord;\n\n if (!link)\n return;\n\n if (link.dependencyInstantiations)\n link.dependencyInstantiations.forEach(function (depLoad, index) {\n if (!depLoad || depLoad instanceof ModuleNamespace)\n return;\n\n if (depLoad.linkRecord) {\n if (depLoad.linkRecord.error) {\n // provides a circular reference check\n if (state.records[depLoad.key] === depLoad)\n clearLoadErrors(loader, depLoad);\n }\n\n // unregister setters for es dependency load records that will remain\n if (link.setters && depLoad.importerSetters) {\n var setterIndex = depLoad.importerSetters.indexOf(link.setters[index]);\n depLoad.importerSetters.splice(setterIndex, 1);\n }\n }\n });\n}\n\n/*\n * System.register\n */\nRegisterLoader.prototype.register = function (key, deps, declare) {\n var state = this[REGISTER_INTERNAL];\n\n // anonymous modules get stored as lastAnon\n if (declare === undefined) {\n state.lastRegister = [key, deps, undefined];\n }\n\n // everything else registers into the register cache\n else {\n var load = state.records[key] || createLoadRecord(state, key, undefined);\n load.registration = [deps, declare, undefined];\n }\n};\n\n/*\n * System.registerDyanmic\n */\nRegisterLoader.prototype.registerDynamic = function (key, deps, executingRequire, execute) {\n var state = this[REGISTER_INTERNAL];\n\n // anonymous modules get stored as lastAnon\n if (typeof key !== 'string') {\n state.lastRegister = [key, deps, executingRequire];\n }\n\n // everything else registers into the register cache\n else {\n var load = state.records[key] || createLoadRecord(state, key, undefined);\n load.registration = [deps, executingRequire, execute];\n }\n};\n\n// ContextualLoader class\n// backwards-compatible with previous System.register context argument by exposing .id\nfunction ContextualLoader (loader, key) {\n this.loader = loader;\n this.key = this.id = key;\n}\nContextualLoader.prototype.constructor = function () {\n throw new TypeError('Cannot subclass the contextual loader only Reflect.Loader.');\n};\nContextualLoader.prototype.import = function (key) {\n return this.loader.import(key, this.key);\n};\nContextualLoader.prototype.resolve = function (key) {\n return this.loader.resolve(key, this.key);\n};\nContextualLoader.prototype.load = function (key) {\n return this.loader.load(key, this.key);\n};\n\n// this is the execution function bound to the Module namespace record\nfunction ensureEvaluate (loader, load, link, registry, state, seen) {\n if (load.module)\n return load.module;\n\n if (link.error)\n throw link.error;\n\n if (seen && seen.indexOf(load) !== -1)\n return load.linkRecord.moduleObj;\n\n // for ES loads we always run ensureEvaluate on top-level, so empty seen is passed regardless\n // for dynamic loads, we pass seen if also dynamic\n var err = doEvaluate(loader, load, link, registry, state, link.setters ? [] : seen || []);\n if (err) {\n clearLoadErrors(loader, load);\n throw err;\n }\n\n return load.module;\n}\n\nfunction makeDynamicRequire (loader, key, dependencies, dependencyInstantiations, registry, state, seen) {\n // we can only require from already-known dependencies\n return function (name) {\n for (var i = 0; i < dependencies.length; i++) {\n if (dependencies[i] === name) {\n var depLoad = dependencyInstantiations[i];\n var module;\n\n if (depLoad instanceof ModuleNamespace)\n module = depLoad;\n else\n module = ensureEvaluate(loader, depLoad, depLoad.linkRecord, registry, state, seen);\n\n return module.__useDefault ? module.default : module;\n }\n }\n throw new Error('Module ' + name + ' not declared as a System.registerDynamic dependency of ' + key);\n };\n}\n\n// ensures the given es load is evaluated\n// returns the error if any\nfunction doEvaluate (loader, load, link, registry, state, seen) {\n seen.push(load);\n\n var err;\n\n // es modules evaluate dependencies first\n // non es modules explicitly call moduleEvaluate through require\n if (link.setters) {\n var depLoad, depLink;\n for (var i = 0; i < link.dependencies.length; i++) {\n depLoad = link.dependencyInstantiations[i];\n\n if (depLoad instanceof ModuleNamespace)\n continue;\n\n // custom Module returned from instantiate\n depLink = depLoad.linkRecord;\n if (depLink && seen.indexOf(depLoad) === -1) {\n if (depLink.error)\n err = depLink.error;\n else\n // dynamic / declarative boundaries clear the \"seen\" list\n // we just let cross format circular throw as would happen in real implementations\n err = doEvaluate(loader, depLoad, depLink, registry, state, depLink.setters ? seen : []);\n }\n\n if (err)\n return link.error = addToError(err, 'Evaluating ' + load.key);\n }\n }\n\n // link.execute won't exist for Module returns from instantiate on top-level load\n if (link.execute) {\n // ES System.register execute\n // \"this\" is null in ES\n if (link.setters) {\n err = declarativeExecute(link.execute);\n }\n // System.registerDynamic execute\n // \"this\" is \"exports\" in CJS\n else {\n var module = { id: load.key };\n var moduleObj = link.moduleObj;\n Object.defineProperty(module, 'exports', {\n configurable: true,\n set: function (exports) {\n moduleObj.default = exports;\n },\n get: function () {\n return moduleObj.default;\n }\n });\n\n var require = makeDynamicRequire(loader, load.key, link.dependencies, link.dependencyInstantiations, registry, state, seen);\n\n // evaluate deps first\n if (!link.executingRequire)\n for (var i = 0; i < link.dependencies.length; i++)\n require(link.dependencies[i]);\n\n err = dynamicExecute(link.execute, require, moduleObj.default, module);\n\n // pick up defineProperty calls to module.exports when we can\n if (module.exports !== moduleObj.default)\n moduleObj.default = module.exports;\n\n var moduleDefault = moduleObj.default;\n\n // __esModule flag extension support via lifting\n if (moduleDefault && moduleDefault.__esModule) {\n if (moduleObj.__useDefault)\n delete moduleObj.__useDefault;\n for (var p in moduleDefault) {\n if (Object.hasOwnProperty.call(moduleDefault, p))\n moduleObj[p] = moduleDefault[p];\n }\n moduleObj.__esModule = true;\n }\n }\n }\n\n if (err)\n return link.error = addToError(err, 'Evaluating ' + load.key);\n\n registry[load.key] = load.module = new ModuleNamespace(link.moduleObj);\n\n // if not an esm module, run importer setters and clear them\n // this allows dynamic modules to update themselves into es modules\n // as soon as execution has completed\n if (!link.setters) {\n if (load.importerSetters)\n for (var i = 0; i < load.importerSetters.length; i++)\n load.importerSetters[i](load.module);\n load.importerSetters = undefined;\n }\n\n // dispose link record\n load.linkRecord = undefined;\n}\n\n// {} is the closest we can get to call(undefined)\nvar nullContext = {};\nif (Object.freeze)\n Object.freeze(nullContext);\n\nfunction declarativeExecute (execute) {\n try {\n execute.call(nullContext);\n }\n catch (e) {\n return e;\n }\n}\n\nfunction dynamicExecute (execute, require, exports, module) {\n try {\n var output = execute.call(global, require, exports, module);\n if (output !== undefined)\n module.exports = output;\n }\n catch (e) {\n return e;\n }\n}\n","import RegisterLoader from 'es-module-loader/core/register-loader.js';\nimport { InternalModuleNamespace as ModuleNamespace } from 'es-module-loader/core/loader-polyfill.js';\n\nimport { baseURI, global, isBrowser } from 'es-module-loader/core/common.js';\nimport { resolveIfNotPlain } from 'es-module-loader/core/resolve.js';\n\nvar loader;\n\n//