You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1016 lines
33 KiB
1016 lines
33 KiB
/* |
|
* SystemJS 6.12.1 |
|
*/ |
|
(function () { |
|
|
|
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$1 = 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 (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$1) |
|
Object.defineProperty(ns, toStringTag$1, { 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 && 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 (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)); |
|
|
|
// 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; |
|
seen[load.id] = true; |
|
|
|
if (!load.e) { |
|
if (load.er) |
|
throw load.er; |
|
if (load.E) |
|
return load.E; |
|
return; |
|
} |
|
|
|
// 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.e = null; |
|
load.er = err; |
|
triggerOnload(loader, load, err, false); |
|
throw err; |
|
} |
|
}); |
|
if (depLoadPromises) |
|
return Promise.all(depLoadPromises).then(doExec); |
|
|
|
return doExec(); |
|
|
|
function doExec () { |
|
try { |
|
var execPromise = load.e.call(nullContext); |
|
if (execPromise) { |
|
execPromise = execPromise.then(function () { |
|
load.C = load.n; |
|
load.E = null; // indicates completion |
|
if (!false) triggerOnload(loader, load, null, true); |
|
}, function (err) { |
|
load.er = err; |
|
load.E = null; |
|
if (!false) triggerOnload(loader, load, err, true); |
|
throw err; |
|
}); |
|
return load.E = 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 { |
|
load.e = null; |
|
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; |
|
// The passThrough property is for letting the module types fetch implementation know that this is not a SystemJS module. |
|
var fetchPromise = script.src ? (System.fetch || fetch)(script.src, { integrity: script.integrity, passThrough: true }).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); |
|
if (typeof script.onerror === 'function') { |
|
script.onerror(); |
|
} |
|
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) { |
|
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 Promise.resolve(systemJSPrototype.createScript(url)).then(function (script) { |
|
return new Promise(function (resolve, reject) { |
|
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(url); |
|
// 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(url); |
|
}); |
|
}); |
|
}; |
|
|
|
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(url); |
|
}); |
|
}; |
|
|
|
/* |
|
* 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 () { |
|
_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 (options.passThrough) |
|
return 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) { |
|
source = source.replace(/url\(\s*(?:(["'])((?:\\.|[^\n\\"'])+)\1|((?:\\.|[^\s,"'()\\])+))\s*\)/g, function (match, quotes, relUrl1, relUrl2) { |
|
return 'url(' + quotes + resolveUrl(relUrl1 || relUrl2, url) + quotes + ')'; |
|
}); |
|
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 = 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 && module[toStringTag] === 'Module') { |
|
ns = module; |
|
} |
|
else { |
|
ns = Object.assign(Object.create(null), module); |
|
if (toStringTag) |
|
Object.defineProperty(ns, toStringTag, { 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 () { |
|
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; |
|
}; |
|
|
|
})();
|
|
|