1321 lines
46 KiB
JavaScript
1321 lines
46 KiB
JavaScript
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
|
|
|
|
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
|
|
|
|
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
|
|
|
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
|
|
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
|
|
|
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
|
|
|
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
(function () {
|
|
'use strict';
|
|
|
|
function errMsg(errCode, msg) {
|
|
return (msg || "") + " (SystemJS Error#" + errCode + " " + "https://git.io/JvFET#" + errCode + ")";
|
|
}
|
|
|
|
var hasSymbol = typeof Symbol !== 'undefined';
|
|
var hasSelf = typeof self !== 'undefined';
|
|
var hasDocument = typeof document !== 'undefined';
|
|
var envGlobal = hasSelf ? self : global;
|
|
var baseUrl;
|
|
|
|
if (hasDocument) {
|
|
var baseEl = document.querySelector('base[href]');
|
|
if (baseEl) baseUrl = baseEl.href;
|
|
}
|
|
|
|
if (!baseUrl && typeof location !== 'undefined') {
|
|
baseUrl = location.href.split('#')[0].split('?')[0];
|
|
var lastSepIndex = baseUrl.lastIndexOf('/');
|
|
if (lastSepIndex !== -1) baseUrl = baseUrl.slice(0, lastSepIndex + 1);
|
|
}
|
|
|
|
var backslashRegEx = /\\/g;
|
|
|
|
function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
|
|
if (relUrl.indexOf('\\') !== -1) relUrl = relUrl.replace(backslashRegEx, '/'); // protocol-relative
|
|
|
|
if (relUrl[0] === '/' && relUrl[1] === '/') {
|
|
return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
|
|
} // relative-url
|
|
else if (relUrl[0] === '.' && (relUrl[1] === '/' || relUrl[1] === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) || relUrl.length === 1 && (relUrl += '/')) || relUrl[0] === '/') {
|
|
var parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1); // Disabled, but these cases will give inconsistent results for deep backtracking
|
|
//if (parentUrl[parentProtocol.length] !== '/')
|
|
// throw Error('Cannot resolve');
|
|
// read pathname from parent URL
|
|
// pathname taken to be part after leading "/"
|
|
|
|
var pathname;
|
|
|
|
if (parentUrl[parentProtocol.length + 1] === '/') {
|
|
// resolving to a :// so we need to read out the auth and host
|
|
if (parentProtocol !== 'file:') {
|
|
pathname = parentUrl.slice(parentProtocol.length + 2);
|
|
pathname = pathname.slice(pathname.indexOf('/') + 1);
|
|
} else {
|
|
pathname = parentUrl.slice(8);
|
|
}
|
|
} else {
|
|
// resolving to :/ so pathname is the /... part
|
|
pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/'));
|
|
}
|
|
|
|
if (relUrl[0] === '/') return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl; // join together and split for removal of .. and . segments
|
|
// looping the string instead of anything fancy for perf reasons
|
|
// '../../../../../z' resolved to 'x/y' is just 'z'
|
|
|
|
var segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
|
|
var output = [];
|
|
var segmentIndex = -1;
|
|
|
|
for (var i = 0; i < segmented.length; i++) {
|
|
// busy reading a segment - only terminate on '/'
|
|
if (segmentIndex !== -1) {
|
|
if (segmented[i] === '/') {
|
|
output.push(segmented.slice(segmentIndex, i + 1));
|
|
segmentIndex = -1;
|
|
}
|
|
} // new segment - check if it is relative
|
|
else if (segmented[i] === '.') {
|
|
// ../ segment
|
|
if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
|
|
output.pop();
|
|
i += 2;
|
|
} // ./ segment
|
|
else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
|
|
i += 1;
|
|
} else {
|
|
// the start of a new segment as below
|
|
segmentIndex = i;
|
|
}
|
|
} // it is the start of a new segment
|
|
else {
|
|
segmentIndex = i;
|
|
}
|
|
} // finish reading out the last segment
|
|
|
|
|
|
if (segmentIndex !== -1) output.push(segmented.slice(segmentIndex));
|
|
return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
|
|
}
|
|
}
|
|
/*
|
|
* Import maps implementation
|
|
*
|
|
* To make lookups fast we pre-resolve the entire import map
|
|
* and then match based on backtracked hash lookups
|
|
*
|
|
*/
|
|
|
|
|
|
function resolveUrl(relUrl, parentUrl) {
|
|
return resolveIfNotPlainOrUrl(relUrl, parentUrl) || (relUrl.indexOf(':') !== -1 ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
|
|
}
|
|
|
|
function resolveAndComposePackages(packages, outPackages, baseUrl, parentMap, parentUrl) {
|
|
for (var p in packages) {
|
|
var resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
|
|
var rhs = packages[p]; // package fallbacks not currently supported
|
|
|
|
if (typeof rhs !== 'string') continue;
|
|
var mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(rhs, baseUrl) || rhs, parentUrl);
|
|
|
|
if (!mapped) {
|
|
targetWarning('W1', p, rhs, 'bare specifier did not resolve');
|
|
} else outPackages[resolvedLhs] = mapped;
|
|
}
|
|
}
|
|
|
|
function resolveAndComposeImportMap(json, baseUrl, outMap) {
|
|
if (json.imports) resolveAndComposePackages(json.imports, outMap.imports, baseUrl, outMap, null);
|
|
var u;
|
|
|
|
for (u in json.scopes || {}) {
|
|
var resolvedScope = resolveUrl(u, baseUrl);
|
|
resolveAndComposePackages(json.scopes[u], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, outMap, resolvedScope);
|
|
}
|
|
|
|
for (u in json.depcache || {}) {
|
|
outMap.depcache[resolveUrl(u, baseUrl)] = json.depcache[u];
|
|
}
|
|
|
|
for (u in json.integrity || {}) {
|
|
outMap.integrity[resolveUrl(u, baseUrl)] = json.integrity[u];
|
|
}
|
|
}
|
|
|
|
function getMatch(path, matchObj) {
|
|
if (matchObj[path]) return path;
|
|
var sepIndex = path.length;
|
|
|
|
do {
|
|
var segment = path.slice(0, sepIndex + 1);
|
|
if (segment in matchObj) return segment;
|
|
} while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1);
|
|
}
|
|
|
|
function applyPackages(id, packages) {
|
|
var pkgName = getMatch(id, packages);
|
|
|
|
if (pkgName) {
|
|
var pkg = packages[pkgName];
|
|
if (pkg === null) return;
|
|
|
|
if (id.length > pkgName.length && pkg[pkg.length - 1] !== '/') {
|
|
targetWarning('W2', pkgName, pkg, "should have a trailing '/'");
|
|
} else return pkg + id.slice(pkgName.length);
|
|
}
|
|
}
|
|
|
|
function targetWarning(code, match, target, msg) {
|
|
console.warn(errMsg(code, "Package target " + msg + ", resolving target '" + target + "' for " + match));
|
|
}
|
|
|
|
function resolveImportMap(importMap, resolvedOrPlain, parentUrl) {
|
|
var scopes = importMap.scopes;
|
|
var scopeUrl = parentUrl && getMatch(parentUrl, scopes);
|
|
|
|
while (scopeUrl) {
|
|
var packageResolution = applyPackages(resolvedOrPlain, scopes[scopeUrl]);
|
|
if (packageResolution) return packageResolution;
|
|
scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf('/')), scopes);
|
|
}
|
|
|
|
return applyPackages(resolvedOrPlain, importMap.imports) || resolvedOrPlain.indexOf(':') !== -1 && resolvedOrPlain;
|
|
}
|
|
/*
|
|
* SystemJS Core
|
|
*
|
|
* Provides
|
|
* - System.import
|
|
* - System.register support for
|
|
* live bindings, function hoisting through circular references,
|
|
* reexports, dynamic import, import.meta.url, top-level await
|
|
* - System.getRegister to get the registration
|
|
* - Symbol.toStringTag support in Module objects
|
|
* - Hookable System.createContext to customize import.meta
|
|
* - System.onload(err, id, deps) handler for tracing / hot-reloading
|
|
*
|
|
* Core comes with no System.prototype.resolve or
|
|
* System.prototype.instantiate implementations
|
|
*/
|
|
|
|
|
|
var toStringTag = hasSymbol && Symbol.toStringTag;
|
|
var REGISTRY = hasSymbol ? Symbol() : '@';
|
|
|
|
function SystemJS() {
|
|
this[REGISTRY] = {};
|
|
}
|
|
|
|
var systemJSPrototype = SystemJS.prototype;
|
|
|
|
systemJSPrototype["import"] = function (id, parentUrl) {
|
|
var loader = this;
|
|
return Promise.resolve(loader.prepareImport()).then(function () {
|
|
return loader.resolve(id, parentUrl);
|
|
}).then(function (id) {
|
|
var load = getOrCreateLoad(loader, id);
|
|
return load.C || topLevelLoad(loader, load);
|
|
});
|
|
}; // Hookable createContext function -> allowing eg custom import meta
|
|
|
|
|
|
systemJSPrototype.createContext = function (parentId) {
|
|
var loader = this;
|
|
return {
|
|
url: parentId,
|
|
resolve: function resolve(id, parentUrl) {
|
|
return Promise.resolve(loader.resolve(id, parentUrl || parentId));
|
|
}
|
|
};
|
|
}; // onLoad(err, id, deps) provided for tracing / hot-reloading
|
|
|
|
|
|
systemJSPrototype.onload = function () {};
|
|
|
|
function loadToId(load) {
|
|
return load.id;
|
|
}
|
|
|
|
function triggerOnload(loader, load, err, isErrSource) {
|
|
loader.onload(err, load.id, load.d && load.d.map(loadToId), !!isErrSource);
|
|
if (err) throw err;
|
|
}
|
|
|
|
var lastRegister;
|
|
|
|
systemJSPrototype.register = function (deps, declare) {
|
|
lastRegister = [deps, declare];
|
|
};
|
|
/*
|
|
* getRegister provides the last anonymous System.register call
|
|
*/
|
|
|
|
|
|
systemJSPrototype.getRegister = function () {
|
|
var _lastRegister = lastRegister;
|
|
lastRegister = undefined;
|
|
return _lastRegister;
|
|
};
|
|
|
|
function getOrCreateLoad(loader, id, firstParentUrl) {
|
|
var load = loader[REGISTRY][id];
|
|
if (load) return load;
|
|
var importerSetters = [];
|
|
var ns = Object.create(null);
|
|
if (toStringTag) Object.defineProperty(ns, toStringTag, {
|
|
value: 'Module'
|
|
});
|
|
var instantiatePromise = Promise.resolve().then(function () {
|
|
return loader.instantiate(id, firstParentUrl);
|
|
}).then(function (registration) {
|
|
if (!registration) throw Error(errMsg(2, 'Module ' + id + ' did not instantiate'));
|
|
|
|
function _export(name, value) {
|
|
// note if we have hoisted exports (including reexports)
|
|
load.h = true;
|
|
var changed = false;
|
|
|
|
if (typeof name === 'string') {
|
|
if (!(name in ns) || ns[name] !== value) {
|
|
ns[name] = value;
|
|
changed = true;
|
|
}
|
|
} else {
|
|
for (var p in name) {
|
|
var value = name[p];
|
|
|
|
if (!(p in ns) || ns[p] !== value) {
|
|
ns[p] = value;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (name.__esModule) {
|
|
ns.__esModule = name.__esModule;
|
|
}
|
|
}
|
|
|
|
if (changed) for (var i = 0; i < importerSetters.length; i++) {
|
|
var setter = importerSetters[i];
|
|
if (setter) setter(ns);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
var declared = registration[1](_export, registration[1].length === 2 ? {
|
|
"import": function _import(importId) {
|
|
return loader["import"](importId, id);
|
|
},
|
|
meta: loader.createContext(id)
|
|
} : undefined);
|
|
|
|
load.e = declared.execute || function () {};
|
|
|
|
return [registration[0], declared.setters || []];
|
|
}, function (err) {
|
|
load.e = null;
|
|
load.er = err;
|
|
triggerOnload(loader, load, err, true);
|
|
throw err;
|
|
});
|
|
var linkPromise = instantiatePromise.then(function (instantiation) {
|
|
return Promise.all(instantiation[0].map(function (dep, i) {
|
|
var setter = instantiation[1][i];
|
|
return Promise.resolve(loader.resolve(dep, id)).then(function (depId) {
|
|
var depLoad = getOrCreateLoad(loader, depId, id); // depLoad.I may be undefined for already-evaluated
|
|
|
|
return Promise.resolve(depLoad.I).then(function () {
|
|
if (setter) {
|
|
depLoad.i.push(setter); // only run early setters when there are hoisted exports of that module
|
|
// the timing works here as pending hoisted export calls will trigger through importerSetters
|
|
|
|
if (depLoad.h || !depLoad.I) setter(depLoad.n);
|
|
}
|
|
|
|
return depLoad;
|
|
});
|
|
});
|
|
})).then(function (depLoads) {
|
|
load.d = depLoads;
|
|
});
|
|
}); // Capital letter = a promise function
|
|
|
|
return load = loader[REGISTRY][id] = {
|
|
id: id,
|
|
// importerSetters, the setters functions registered to this dependency
|
|
// we retain this to add more later
|
|
i: importerSetters,
|
|
// module namespace object
|
|
n: ns,
|
|
// instantiate
|
|
I: instantiatePromise,
|
|
// link
|
|
L: linkPromise,
|
|
// whether it has hoisted exports
|
|
h: false,
|
|
// On instantiate completion we have populated:
|
|
// dependency load records
|
|
d: undefined,
|
|
// execution function
|
|
e: undefined,
|
|
// On execution we have populated:
|
|
// the execution error if any
|
|
er: undefined,
|
|
// in the case of TLA, the execution promise
|
|
E: undefined,
|
|
// On execution, L, I, E cleared
|
|
// Promise for top-level completion
|
|
C: undefined,
|
|
// parent instantiator / executor
|
|
p: undefined
|
|
};
|
|
}
|
|
|
|
function instantiateAll(loader, load, parent, loaded) {
|
|
if (!loaded[load.id]) {
|
|
loaded[load.id] = true; // load.L may be undefined for already-instantiated
|
|
|
|
return Promise.resolve(load.L).then(function () {
|
|
if (!load.p || load.p.e === null) load.p = parent;
|
|
return Promise.all(load.d.map(function (dep) {
|
|
return instantiateAll(loader, dep, parent, loaded);
|
|
}));
|
|
})["catch"](function (err) {
|
|
if (load.er) throw err;
|
|
load.e = null;
|
|
triggerOnload(loader, load, err, false);
|
|
throw err;
|
|
});
|
|
}
|
|
}
|
|
|
|
function topLevelLoad(loader, load) {
|
|
return load.C = instantiateAll(loader, load, load, {}).then(function () {
|
|
return postOrderExec(loader, load, {});
|
|
}).then(function () {
|
|
return load.n;
|
|
});
|
|
} // the closest we can get to call(undefined)
|
|
|
|
|
|
var nullContext = Object.freeze(Object.create(null)); // Equivalent to `Promise.prototype.finally`
|
|
// https://gist.github.com/developit/d970bac18430943e4b3392b029a2a96c
|
|
|
|
var promisePrototypeFinally = Promise.prototype["finally"] || function (callback) {
|
|
if (typeof callback !== 'function') {
|
|
return this.then(callback, callback);
|
|
}
|
|
|
|
var P = this.constructor || Promise;
|
|
return this.then(function (value) {
|
|
return P.resolve(callback()).then(function () {
|
|
return value;
|
|
});
|
|
}, function (err) {
|
|
return P.resolve(callback()).then(function () {
|
|
throw err;
|
|
});
|
|
});
|
|
}; // returns a promise if and only if a top-level await subgraph
|
|
// throws on sync errors
|
|
|
|
|
|
function postOrderExec(loader, load, seen) {
|
|
if (seen[load.id]) {
|
|
return load.E;
|
|
}
|
|
|
|
seen[load.id] = true;
|
|
|
|
if (!load.e) {
|
|
if (load.er) throw load.er;
|
|
if (load.E) return load.E;
|
|
return;
|
|
} // From here we're about to execute the load.
|
|
// Because the execution may be async, we pop the `load.e` first.
|
|
// So `load.e === null` always means the load has been executed or is executing.
|
|
// To inspect the state:
|
|
// - If `load.er` is truthy, the execution has threw or has been rejected;
|
|
// - otherwise, either the `load.E` is a promise, means it's under async execution, or
|
|
// - the `load.E` is null, means the load has completed the execution or has been async resolved.
|
|
|
|
|
|
var exec = load.e;
|
|
load.e = null; // deps execute first, unless circular
|
|
|
|
var depLoadPromises;
|
|
load.d.forEach(function (depLoad) {
|
|
try {
|
|
var depLoadPromise = postOrderExec(loader, depLoad, seen);
|
|
if (depLoadPromise) (depLoadPromises = depLoadPromises || []).push(depLoadPromise);
|
|
} catch (err) {
|
|
load.er = err;
|
|
triggerOnload(loader, load, err, false);
|
|
throw err;
|
|
}
|
|
});
|
|
if (depLoadPromises) return load.E = promisePrototypeFinally.call(Promise.all(depLoadPromises).then(doExec), function () {
|
|
load.E = null;
|
|
});
|
|
var execPromise = doExec();
|
|
|
|
if (execPromise) {
|
|
return load.E = promisePrototypeFinally.call(execPromise, function () {
|
|
load.E = null;
|
|
});
|
|
}
|
|
|
|
function doExec() {
|
|
try {
|
|
var execPromise = exec.call(nullContext);
|
|
|
|
if (execPromise) {
|
|
execPromise = execPromise.then(function () {
|
|
load.C = load.n;
|
|
if (!false) triggerOnload(loader, load, null, true);
|
|
}, function (err) {
|
|
load.er = err;
|
|
if (!false) triggerOnload(loader, load, err, true);
|
|
throw err;
|
|
});
|
|
return execPromise;
|
|
} // (should be a promise, but a minify optimization to leave out Promise.resolve)
|
|
|
|
|
|
load.C = load.n;
|
|
load.L = load.I = undefined;
|
|
} catch (err) {
|
|
load.er = err;
|
|
throw err;
|
|
} finally {
|
|
triggerOnload(loader, load, load.er, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
envGlobal.System = new SystemJS();
|
|
/*
|
|
* SystemJS browser attachments for script and import map processing
|
|
*/
|
|
|
|
var importMapPromise = Promise.resolve();
|
|
var importMap = {
|
|
imports: {},
|
|
scopes: {},
|
|
depcache: {},
|
|
integrity: {}
|
|
}; // Scripts are processed immediately, on the first System.import, and on DOMReady.
|
|
// Import map scripts are processed only once (by being marked) and in order for each phase.
|
|
// This is to avoid using DOM mutation observers in core, although that would be an alternative.
|
|
|
|
var processFirst = hasDocument;
|
|
|
|
systemJSPrototype.prepareImport = function (doProcessScripts) {
|
|
if (processFirst || doProcessScripts) {
|
|
processScripts();
|
|
processFirst = false;
|
|
}
|
|
|
|
return importMapPromise;
|
|
};
|
|
|
|
if (hasDocument) {
|
|
processScripts();
|
|
window.addEventListener('DOMContentLoaded', processScripts);
|
|
}
|
|
|
|
function processScripts() {
|
|
[].forEach.call(document.querySelectorAll('script'), function (script) {
|
|
if (script.sp) // sp marker = systemjs processed
|
|
return; // TODO: deprecate systemjs-module in next major now that we have auto import
|
|
|
|
if (script.type === 'systemjs-module') {
|
|
script.sp = true;
|
|
if (!script.src) return;
|
|
System["import"](script.src.slice(0, 7) === 'import:' ? script.src.slice(7) : resolveUrl(script.src, baseUrl))["catch"](function (e) {
|
|
// if there is a script load error, dispatch an "error" event
|
|
// on the script tag.
|
|
if (e.message.indexOf('https://git.io/JvFET#3') > -1) {
|
|
var event = document.createEvent('Event');
|
|
event.initEvent('error', false, false);
|
|
script.dispatchEvent(event);
|
|
}
|
|
|
|
return Promise.reject(e);
|
|
});
|
|
} else if (script.type === 'systemjs-importmap') {
|
|
script.sp = true;
|
|
var fetchPromise = script.src ? fetch(script.src, {
|
|
integrity: script.integrity
|
|
}).then(function (res) {
|
|
if (!res.ok) throw Error('Invalid status code: ' + res.status);
|
|
return res.text();
|
|
})["catch"](function (err) {
|
|
err.message = errMsg('W4', 'Error fetching systemjs-import map ' + script.src) + '\n' + err.message;
|
|
console.warn(err);
|
|
return '{}';
|
|
}) : script.innerHTML;
|
|
importMapPromise = importMapPromise.then(function () {
|
|
return fetchPromise;
|
|
}).then(function (text) {
|
|
extendImportMap(importMap, text, script.src || baseUrl);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
function extendImportMap(importMap, newMapText, newMapUrl) {
|
|
var newMap = {};
|
|
|
|
try {
|
|
newMap = JSON.parse(newMapText);
|
|
} catch (err) {
|
|
console.warn(Error(errMsg('W5', "systemjs-importmap contains invalid JSON") + '\n\n' + newMapText + '\n'));
|
|
}
|
|
|
|
resolveAndComposeImportMap(newMap, newMapUrl, importMap);
|
|
}
|
|
/*
|
|
* Script instantiation loading
|
|
*/
|
|
|
|
|
|
if (hasDocument) {
|
|
window.addEventListener('error', function (evt) {
|
|
lastWindowErrorUrl = evt.filename;
|
|
lastWindowError = evt.error;
|
|
});
|
|
var baseOrigin = location.origin;
|
|
}
|
|
|
|
systemJSPrototype.createScript = function (url) {
|
|
var script = document.createElement('script');
|
|
script.async = true; // Only add cross origin for actual cross origin
|
|
// this is because Safari triggers for all
|
|
// - https://bugs.webkit.org/show_bug.cgi?id=171566
|
|
|
|
if (url.indexOf(baseOrigin + '/')) script.crossOrigin = 'anonymous';
|
|
var integrity = importMap.integrity[url];
|
|
if (integrity) script.integrity = integrity;
|
|
script.src = url;
|
|
return script;
|
|
}; // Auto imports -> script tags can be inlined directly for load phase
|
|
|
|
|
|
var lastAutoImportDeps, lastAutoImportTimeout;
|
|
var autoImportCandidates = {};
|
|
var systemRegister = systemJSPrototype.register;
|
|
|
|
systemJSPrototype.register = function (deps, declare) {
|
|
if (hasDocument && document.readyState === 'loading' && typeof deps !== 'string') {
|
|
var scripts = document.querySelectorAll('script[src]');
|
|
var lastScript = scripts[scripts.length - 1];
|
|
|
|
if (lastScript) {
|
|
lastScript.src;
|
|
lastAutoImportDeps = deps; // if this is already a System load, then the instantiate has already begun
|
|
// so this re-import has no consequence
|
|
|
|
var loader = this;
|
|
lastAutoImportTimeout = setTimeout(function () {
|
|
autoImportCandidates[lastScript.src] = [deps, declare];
|
|
loader["import"](lastScript.src);
|
|
});
|
|
}
|
|
} else {
|
|
lastAutoImportDeps = undefined;
|
|
}
|
|
|
|
return systemRegister.call(this, deps, declare);
|
|
};
|
|
|
|
var lastWindowErrorUrl, lastWindowError;
|
|
|
|
systemJSPrototype.instantiate = function (url, firstParentUrl) {
|
|
var autoImportRegistration = autoImportCandidates[url];
|
|
|
|
if (autoImportRegistration) {
|
|
delete autoImportCandidates[url];
|
|
return autoImportRegistration;
|
|
}
|
|
|
|
var loader = this;
|
|
return new Promise(function (resolve, reject) {
|
|
var script = systemJSPrototype.createScript(url);
|
|
script.addEventListener('error', function () {
|
|
reject(Error(errMsg(3, 'Error loading ' + url + (firstParentUrl ? ' from ' + firstParentUrl : ''))));
|
|
});
|
|
script.addEventListener('load', function () {
|
|
document.head.removeChild(script); // Note that if an error occurs that isn't caught by this if statement,
|
|
// that getRegister will return null and a "did not instantiate" error will be thrown.
|
|
|
|
if (lastWindowErrorUrl === url) {
|
|
reject(lastWindowError);
|
|
} else {
|
|
var register = loader.getRegister(); // Clear any auto import registration for dynamic import scripts during load
|
|
|
|
if (register && register[0] === lastAutoImportDeps) clearTimeout(lastAutoImportTimeout);
|
|
resolve(register);
|
|
}
|
|
});
|
|
document.head.appendChild(script);
|
|
});
|
|
};
|
|
/*
|
|
* Fetch loader, sets up shouldFetch and fetch hooks
|
|
*/
|
|
|
|
|
|
systemJSPrototype.shouldFetch = function () {
|
|
return false;
|
|
};
|
|
|
|
if (typeof fetch !== 'undefined') systemJSPrototype.fetch = fetch;
|
|
var instantiate = systemJSPrototype.instantiate;
|
|
var jsContentTypeRegEx = /^(text|application)\/(x-)?javascript(;|$)/;
|
|
|
|
systemJSPrototype.instantiate = function (url, parent) {
|
|
var loader = this;
|
|
if (!this.shouldFetch(url)) return instantiate.apply(this, arguments);
|
|
return this.fetch(url, {
|
|
credentials: 'same-origin',
|
|
integrity: importMap.integrity[url]
|
|
}).then(function (res) {
|
|
if (!res.ok) throw Error(errMsg(7, res.status + ' ' + res.statusText + ', loading ' + url + (parent ? ' from ' + parent : '')));
|
|
var contentType = res.headers.get('content-type');
|
|
if (!contentType || !jsContentTypeRegEx.test(contentType)) throw Error(errMsg(4, 'Unknown Content-Type "' + contentType + '", loading ' + url + (parent ? ' from ' + parent : '')));
|
|
return res.text().then(function (source) {
|
|
if (source.indexOf('//# sourceURL=') < 0) source += '\n//# sourceURL=' + url;
|
|
(0, eval)(source);
|
|
return loader.getRegister();
|
|
});
|
|
});
|
|
};
|
|
|
|
systemJSPrototype.resolve = function (id, parentUrl) {
|
|
parentUrl = parentUrl || !true || baseUrl;
|
|
return resolveImportMap(importMap, resolveIfNotPlainOrUrl(id, parentUrl) || id, parentUrl) || throwUnresolved(id, parentUrl);
|
|
};
|
|
|
|
function throwUnresolved(id, parentUrl) {
|
|
throw Error(errMsg(8, "Unable to resolve bare specifier '" + id + (parentUrl ? "' from " + parentUrl : "'")));
|
|
}
|
|
|
|
var systemInstantiate = systemJSPrototype.instantiate;
|
|
|
|
systemJSPrototype.instantiate = function (url, firstParentUrl) {
|
|
var preloads = importMap.depcache[url];
|
|
|
|
if (preloads) {
|
|
for (var i = 0; i < preloads.length; i++) {
|
|
getOrCreateLoad(this, this.resolve(preloads[i], url), url);
|
|
}
|
|
}
|
|
|
|
return systemInstantiate.call(this, url, firstParentUrl);
|
|
};
|
|
/*
|
|
* Supports loading System.register in workers
|
|
*/
|
|
|
|
|
|
if (hasSelf && typeof importScripts === 'function') systemJSPrototype.instantiate = function (url) {
|
|
var loader = this;
|
|
return Promise.resolve().then(function () {
|
|
importScripts(url);
|
|
return loader.getRegister();
|
|
});
|
|
};
|
|
/*
|
|
* SystemJS global script loading support
|
|
* Extra for the s.js build only
|
|
* (Included by default in system.js build)
|
|
*/
|
|
|
|
(function (global) {
|
|
var systemJSPrototype = global.System.constructor.prototype; // safari unpredictably lists some new globals first or second in object order
|
|
|
|
var firstGlobalProp, secondGlobalProp, lastGlobalProp;
|
|
|
|
function getGlobalProp(useFirstGlobalProp) {
|
|
var cnt = 0;
|
|
var foundLastProp, result;
|
|
|
|
for (var p in global) {
|
|
// do not check frames cause it could be removed during import
|
|
if (shouldSkipProperty(p)) continue;
|
|
if (cnt === 0 && p !== firstGlobalProp || cnt === 1 && p !== secondGlobalProp) return p;
|
|
|
|
if (foundLastProp) {
|
|
lastGlobalProp = p;
|
|
result = useFirstGlobalProp && result || p;
|
|
} else {
|
|
foundLastProp = p === lastGlobalProp;
|
|
}
|
|
|
|
cnt++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function noteGlobalProps() {
|
|
// alternatively Object.keys(global).pop()
|
|
// but this may be faster (pending benchmarks)
|
|
firstGlobalProp = secondGlobalProp = undefined;
|
|
|
|
for (var p in global) {
|
|
// do not check frames cause it could be removed during import
|
|
if (shouldSkipProperty(p)) continue;
|
|
if (!firstGlobalProp) firstGlobalProp = p;else if (!secondGlobalProp) secondGlobalProp = p;
|
|
lastGlobalProp = p;
|
|
}
|
|
|
|
return lastGlobalProp;
|
|
}
|
|
|
|
var impt = systemJSPrototype["import"];
|
|
|
|
systemJSPrototype["import"] = function (id, parentUrl) {
|
|
noteGlobalProps();
|
|
return impt.call(this, id, parentUrl);
|
|
};
|
|
|
|
var emptyInstantiation = [[], function () {
|
|
return {};
|
|
}];
|
|
var getRegister = systemJSPrototype.getRegister;
|
|
|
|
systemJSPrototype.getRegister = function () {
|
|
var lastRegister = getRegister.call(this);
|
|
if (lastRegister) return lastRegister; // no registration -> attempt a global detection as difference from snapshot
|
|
// when multiple globals, we take the global value to be the last defined new global object property
|
|
// for performance, this will not support multi-version / global collisions as previous SystemJS versions did
|
|
// note in Edge, deleting and re-adding a global does not change its ordering
|
|
|
|
var globalProp = getGlobalProp(this.firstGlobalProp);
|
|
if (!globalProp) return emptyInstantiation;
|
|
var globalExport;
|
|
|
|
try {
|
|
globalExport = global[globalProp];
|
|
} catch (e) {
|
|
return emptyInstantiation;
|
|
}
|
|
|
|
return [[], function (_export) {
|
|
return {
|
|
execute: function execute() {
|
|
_export(globalExport);
|
|
|
|
_export({
|
|
"default": globalExport,
|
|
__useDefault: true
|
|
});
|
|
}
|
|
};
|
|
}];
|
|
};
|
|
|
|
var isIE11 = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('Trident') !== -1;
|
|
|
|
function shouldSkipProperty(p) {
|
|
return !global.hasOwnProperty(p) || !isNaN(p) && p < global.length || isIE11 && global[p] && typeof window !== 'undefined' && global[p].parent === window;
|
|
}
|
|
})(typeof self !== 'undefined' ? self : global);
|
|
/*
|
|
* Loads JSON, CSS, Wasm module types based on file extension
|
|
* filters and content type verifications
|
|
*/
|
|
|
|
|
|
(function (global) {
|
|
var systemJSPrototype = global.System.constructor.prototype;
|
|
var moduleTypesRegEx = /^[^#?]+\.(css|html|json|wasm)([?#].*)?$/;
|
|
|
|
systemJSPrototype.shouldFetch = function (url) {
|
|
return moduleTypesRegEx.test(url);
|
|
};
|
|
|
|
var jsonContentType = /^application\/json(;|$)/;
|
|
var cssContentType = /^text\/css(;|$)/;
|
|
var wasmContentType = /^application\/wasm(;|$)/;
|
|
var fetch = systemJSPrototype.fetch;
|
|
|
|
systemJSPrototype.fetch = function (url, options) {
|
|
return fetch(url, options).then(function (res) {
|
|
if (!res.ok) return res;
|
|
var contentType = res.headers.get('content-type');
|
|
if (jsonContentType.test(contentType)) return res.json().then(function (json) {
|
|
return new Response(new Blob(['System.register([],function(e){return{execute:function(){e("default",' + JSON.stringify(json) + ')}}})'], {
|
|
type: 'application/javascript'
|
|
}));
|
|
});
|
|
if (cssContentType.test(contentType)) return res.text().then(function (source) {
|
|
return new Response(new Blob(['System.register([],function(e){return{execute:function(){var s=new CSSStyleSheet();s.replaceSync(' + JSON.stringify(source) + ');e("default",s)}}})'], {
|
|
type: 'application/javascript'
|
|
}));
|
|
});
|
|
if (wasmContentType.test(contentType)) return (WebAssembly.compileStreaming ? WebAssembly.compileStreaming(res) : res.arrayBuffer().then(WebAssembly.compile)).then(function (module) {
|
|
if (!global.System.wasmModules) global.System.wasmModules = Object.create(null);
|
|
global.System.wasmModules[url] = module; // we can only set imports if supported (eg early Safari doesnt support)
|
|
|
|
var deps = [];
|
|
var setterSources = [];
|
|
if (WebAssembly.Module.imports) WebAssembly.Module.imports(module).forEach(function (impt) {
|
|
var key = JSON.stringify(impt.module);
|
|
|
|
if (deps.indexOf(key) === -1) {
|
|
deps.push(key);
|
|
setterSources.push('function(m){i[' + key + ']=m}');
|
|
}
|
|
});
|
|
return new Response(new Blob(['System.register([' + deps.join(',') + '],function(e){var i={};return{setters:[' + setterSources.join(',') + '],execute:function(){return WebAssembly.instantiate(System.wasmModules[' + JSON.stringify(url) + '],i).then(function(m){e(m.exports)})}}})'], {
|
|
type: 'application/javascript'
|
|
}));
|
|
});
|
|
return res;
|
|
});
|
|
};
|
|
})(typeof self !== 'undefined' ? self : global);
|
|
|
|
var toStringTag$1 = typeof Symbol !== 'undefined' && Symbol.toStringTag;
|
|
|
|
systemJSPrototype.get = function (id) {
|
|
var load = this[REGISTRY][id];
|
|
|
|
if (load && load.e === null && !load.E) {
|
|
if (load.er) return null;
|
|
return load.n;
|
|
}
|
|
};
|
|
|
|
systemJSPrototype.set = function (id, module) {
|
|
{
|
|
try {
|
|
// No page-relative URLs allowed
|
|
new URL(id);
|
|
} catch (err) {
|
|
console.warn(Error(errMsg('W3', '"' + id + '" is not a valid URL to set in the module registry')));
|
|
}
|
|
}
|
|
var ns;
|
|
|
|
if (toStringTag$1 && module[toStringTag$1] === 'Module') {
|
|
ns = module;
|
|
} else {
|
|
ns = Object.assign(Object.create(null), module);
|
|
if (toStringTag$1) Object.defineProperty(ns, toStringTag$1, {
|
|
value: 'Module'
|
|
});
|
|
}
|
|
|
|
var done = Promise.resolve(ns);
|
|
var load = this[REGISTRY][id] || (this[REGISTRY][id] = {
|
|
id: id,
|
|
i: [],
|
|
h: false,
|
|
d: [],
|
|
e: null,
|
|
er: undefined,
|
|
E: undefined
|
|
});
|
|
if (load.e || load.E) return false;
|
|
Object.assign(load, {
|
|
n: ns,
|
|
I: undefined,
|
|
L: undefined,
|
|
C: done
|
|
});
|
|
return ns;
|
|
};
|
|
|
|
systemJSPrototype.has = function (id) {
|
|
var load = this[REGISTRY][id];
|
|
return !!load;
|
|
}; // Delete function provided for hot-reloading use cases
|
|
|
|
|
|
systemJSPrototype["delete"] = function (id) {
|
|
var registry = this[REGISTRY];
|
|
var load = registry[id]; // in future we can support load.E case by failing load first
|
|
// but that will require TLA callbacks to be implemented
|
|
|
|
if (!load || load.p && load.p.e !== null || load.E) return false;
|
|
var importerSetters = load.i; // remove from importerSetters
|
|
// (release for gc)
|
|
|
|
if (load.d) load.d.forEach(function (depLoad) {
|
|
var importerIndex = depLoad.i.indexOf(load);
|
|
if (importerIndex !== -1) depLoad.i.splice(importerIndex, 1);
|
|
});
|
|
delete registry[id];
|
|
return function () {
|
|
var load = registry[id];
|
|
if (!load || !importerSetters || load.e !== null || load.E) return false; // add back the old setters
|
|
|
|
importerSetters.forEach(function (setter) {
|
|
load.i.push(setter);
|
|
setter(load.n);
|
|
});
|
|
importerSetters = null;
|
|
};
|
|
};
|
|
|
|
var iterator = typeof Symbol !== 'undefined' && Symbol.iterator;
|
|
|
|
systemJSPrototype.entries = function () {
|
|
var loader = this,
|
|
keys = Object.keys(loader[REGISTRY]);
|
|
var index = 0,
|
|
ns,
|
|
key;
|
|
var result = {
|
|
next: function next() {
|
|
while ((key = keys[index++]) !== undefined && (ns = loader.get(key)) === undefined) {
|
|
;
|
|
}
|
|
|
|
return {
|
|
done: key === undefined,
|
|
value: key !== undefined && [key, ns]
|
|
};
|
|
}
|
|
};
|
|
|
|
result[iterator] = function () {
|
|
return this;
|
|
};
|
|
|
|
return result;
|
|
};
|
|
/*
|
|
* SystemJS named register extension
|
|
* Supports System.register('name', [..deps..], function (_export, _context) { ... })
|
|
*
|
|
* Names are written to the registry as-is
|
|
* System.register('x', ...) can be imported as System.import('x')
|
|
*/
|
|
|
|
|
|
(function (global) {
|
|
var System = global.System;
|
|
setRegisterRegistry(System);
|
|
var systemJSPrototype = System.constructor.prototype;
|
|
var constructor = System.constructor;
|
|
|
|
var SystemJS = function SystemJS() {
|
|
constructor.call(this);
|
|
setRegisterRegistry(this);
|
|
};
|
|
|
|
SystemJS.prototype = systemJSPrototype;
|
|
System.constructor = SystemJS;
|
|
var firstNamedDefine;
|
|
|
|
function setRegisterRegistry(systemInstance) {
|
|
systemInstance.registerRegistry = Object.create(null);
|
|
}
|
|
|
|
var register = systemJSPrototype.register;
|
|
|
|
systemJSPrototype.register = function (name, deps, declare) {
|
|
if (typeof name !== 'string') return register.apply(this, arguments);
|
|
var define = [deps, declare];
|
|
this.registerRegistry[name] = define;
|
|
|
|
if (!firstNamedDefine) {
|
|
firstNamedDefine = define;
|
|
Promise.resolve().then(function () {
|
|
firstNamedDefine = null;
|
|
});
|
|
}
|
|
|
|
return register.apply(this, arguments);
|
|
};
|
|
|
|
var resolve = systemJSPrototype.resolve;
|
|
|
|
systemJSPrototype.resolve = function (id, parentURL) {
|
|
try {
|
|
// Prefer import map (or other existing) resolution over the registerRegistry
|
|
return resolve.call(this, id, parentURL);
|
|
} catch (err) {
|
|
if (id in this.registerRegistry) {
|
|
return id;
|
|
}
|
|
|
|
throw err;
|
|
}
|
|
};
|
|
|
|
var instantiate = systemJSPrototype.instantiate;
|
|
|
|
systemJSPrototype.instantiate = function (url, firstParentUrl) {
|
|
var result = this.registerRegistry[url];
|
|
|
|
if (result) {
|
|
this.registerRegistry[url] = null;
|
|
return result;
|
|
} else {
|
|
return instantiate.call(this, url, firstParentUrl);
|
|
}
|
|
};
|
|
|
|
var getRegister = systemJSPrototype.getRegister;
|
|
|
|
systemJSPrototype.getRegister = function () {
|
|
// Calling getRegister() because other extras need to know it was called so they can perform side effects
|
|
var register = getRegister.call(this);
|
|
var result = firstNamedDefine || register;
|
|
firstNamedDefine = null;
|
|
return result;
|
|
};
|
|
})(typeof self !== 'undefined' ? self : global);
|
|
|
|
var backslashRegEx$1 = /\\/g;
|
|
|
|
function resolveIfNotPlainOrUrl$1(relUrl, parentUrl) {
|
|
if (relUrl.indexOf('\\') !== -1) relUrl = relUrl.replace(backslashRegEx$1, '/'); // protocol-relative
|
|
|
|
if (relUrl[0] === '/' && relUrl[1] === '/') {
|
|
return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
|
|
} // relative-url
|
|
else if (relUrl[0] === '.' && (relUrl[1] === '/' || relUrl[1] === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) || relUrl.length === 1 && (relUrl += '/')) || relUrl[0] === '/') {
|
|
var parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1); // Disabled, but these cases will give inconsistent results for deep backtracking
|
|
//if (parentUrl[parentProtocol.length] !== '/')
|
|
// throw Error('Cannot resolve');
|
|
// read pathname from parent URL
|
|
// pathname taken to be part after leading "/"
|
|
|
|
var pathname;
|
|
|
|
if (parentUrl[parentProtocol.length + 1] === '/') {
|
|
// resolving to a :// so we need to read out the auth and host
|
|
if (parentProtocol !== 'file:') {
|
|
pathname = parentUrl.slice(parentProtocol.length + 2);
|
|
pathname = pathname.slice(pathname.indexOf('/') + 1);
|
|
} else {
|
|
pathname = parentUrl.slice(8);
|
|
}
|
|
} else {
|
|
// resolving to :/ so pathname is the /... part
|
|
pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/'));
|
|
}
|
|
|
|
if (relUrl[0] === '/') return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl; // join together and split for removal of .. and . segments
|
|
// looping the string instead of anything fancy for perf reasons
|
|
// '../../../../../z' resolved to 'x/y' is just 'z'
|
|
|
|
var segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
|
|
var output = [];
|
|
var segmentIndex = -1;
|
|
|
|
for (var i = 0; i < segmented.length; i++) {
|
|
// busy reading a segment - only terminate on '/'
|
|
if (segmentIndex !== -1) {
|
|
if (segmented[i] === '/') {
|
|
output.push(segmented.slice(segmentIndex, i + 1));
|
|
segmentIndex = -1;
|
|
}
|
|
} // new segment - check if it is relative
|
|
else if (segmented[i] === '.') {
|
|
// ../ segment
|
|
if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
|
|
output.pop();
|
|
i += 2;
|
|
} // ./ segment
|
|
else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
|
|
i += 1;
|
|
} else {
|
|
// the start of a new segment as below
|
|
segmentIndex = i;
|
|
}
|
|
} // it is the start of a new segment
|
|
else {
|
|
segmentIndex = i;
|
|
}
|
|
} // finish reading out the last segment
|
|
|
|
|
|
if (segmentIndex !== -1) output.push(segmented.slice(segmentIndex));
|
|
return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
|
|
}
|
|
}
|
|
/**
|
|
* @type {import('../lib/resolution-detail-map').ResolutionDetailMap}
|
|
*/
|
|
|
|
|
|
var resolutionDetailMap = {};
|
|
|
|
function createDetailResolver(logger, rejector) {
|
|
var _logger, _rejector;
|
|
|
|
(_logger = logger) !== null && _logger !== void 0 ? _logger : logger = function logger(message) {
|
|
var log;
|
|
|
|
switch (message.level) {
|
|
default:
|
|
case 'log':
|
|
log = console.log;
|
|
break;
|
|
|
|
case 'warn':
|
|
log = console.warn;
|
|
break;
|
|
|
|
case 'error':
|
|
log = console.error;
|
|
break;
|
|
}
|
|
|
|
log.call(console, message.text);
|
|
};
|
|
(_rejector = rejector) !== null && _rejector !== void 0 ? _rejector : rejector = function rejector(text) {
|
|
throw new Error(text);
|
|
};
|
|
return function resolve(specifier, importer) {
|
|
var _resolutionDetailMap$;
|
|
|
|
var detail = (_resolutionDetailMap$ = resolutionDetailMap[importer]) === null || _resolutionDetailMap$ === void 0 ? void 0 : _resolutionDetailMap$[specifier];
|
|
|
|
if (!detail) {
|
|
return;
|
|
}
|
|
|
|
var error = detail.error,
|
|
messages = detail.messages;
|
|
|
|
if (messages) {
|
|
var _iterator = _createForOfIteratorHelper(messages),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var message = _step.value;
|
|
logger(message);
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
if (error) {
|
|
rejector(error);
|
|
}
|
|
};
|
|
}
|
|
|
|
function setResolutionDetailMap(map, mapUrl) {
|
|
resolutionDetailMap = {};
|
|
|
|
for (var _i = 0, _Object$entries = Object.entries(map); _i < _Object$entries.length; _i++) {
|
|
var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
|
|
moduleUrl = _Object$entries$_i[0],
|
|
_ = _Object$entries$_i[1];
|
|
|
|
var normalized = resolveIfNotPlainOrUrl$1(moduleUrl, mapUrl);
|
|
resolutionDetailMap[normalized] = _;
|
|
}
|
|
}
|
|
|
|
var resolve = createDetailResolver();
|
|
var vendorResolve = systemJSPrototype.resolve;
|
|
|
|
systemJSPrototype.resolve = function (specifier, importer) {
|
|
void resolve(specifier, importer);
|
|
return vendorResolve.apply(this, arguments);
|
|
};
|
|
|
|
var setResolutionDetailMapCallbackTag = Symbol("[[setResolutionDetailMapCallback]]");
|
|
|
|
systemJSPrototype.setResolutionDetailMapCallback = function (e) {
|
|
this[setResolutionDetailMapCallbackTag] = e;
|
|
};
|
|
|
|
var setupResolutionDetailMapPromise = null;
|
|
var vendorPrepareImport = systemJSPrototype.prepareImport;
|
|
systemJSPrototype.prepareImport = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
|
|
var _this = this;
|
|
|
|
var _args3 = arguments;
|
|
return regeneratorRuntime.wrap(function _callee3$(_context3) {
|
|
while (1) {
|
|
switch (_context3.prev = _context3.next) {
|
|
case 0:
|
|
setupResolutionDetailMapPromise || (setupResolutionDetailMapPromise = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
|
|
return regeneratorRuntime.wrap(function _callee2$(_context2) {
|
|
while (1) {
|
|
switch (_context2.prev = _context2.next) {
|
|
case 0:
|
|
_context2.prev = 0;
|
|
_context2.next = 3;
|
|
return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
|
|
var _yield$_this$setResol, e, t;
|
|
|
|
return regeneratorRuntime.wrap(function _callee$(_context) {
|
|
while (1) {
|
|
switch (_context.prev = _context.next) {
|
|
case 0:
|
|
_context.next = 2;
|
|
return _this[setResolutionDetailMapCallbackTag]();
|
|
|
|
case 2:
|
|
_yield$_this$setResol = _context.sent;
|
|
e = _yield$_this$setResol.json;
|
|
t = _yield$_this$setResol.url;
|
|
setResolutionDetailMap(e, t);
|
|
|
|
case 6:
|
|
case "end":
|
|
return _context.stop();
|
|
}
|
|
}
|
|
}, _callee);
|
|
}))();
|
|
|
|
case 3:
|
|
_context2.next = 8;
|
|
break;
|
|
|
|
case 5:
|
|
_context2.prev = 5;
|
|
_context2.t0 = _context2["catch"](0);
|
|
console.debug("Failed to load resolution detail map: ".concat(_context2.t0));
|
|
|
|
case 8:
|
|
case "end":
|
|
return _context2.stop();
|
|
}
|
|
}
|
|
}, _callee2, null, [[0, 5]]);
|
|
}))());
|
|
_context3.next = 3;
|
|
return setupResolutionDetailMapPromise;
|
|
|
|
case 3:
|
|
vendorPrepareImport.apply(this, _args3);
|
|
|
|
case 4:
|
|
case "end":
|
|
return _context3.stop();
|
|
}
|
|
}
|
|
}, _callee3, this);
|
|
}));
|
|
})(); |