/* * SJS 2.0.0 * Minimal SystemJS Build */ (function () { const hasSelf = typeof self !== 'undefined'; const envGlobal = hasSelf ? self : global; let baseUrl; if (typeof location !== 'undefined') { baseUrl = location.href.split('#')[0].split('?')[0]; const lastSepIndex = baseUrl.lastIndexOf('/'); if (lastSepIndex !== -1) baseUrl = baseUrl.slice(0, lastSepIndex + 1); } const 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] === '/') { const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1); // Disabled, but these cases will give inconsistent results for deep backtracking //if (parentUrl[parentProtocol.length] !== '/') // throw new Error('Cannot resolve'); // read pathname from parent URL // pathname taken to be part after leading "/" let 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 + 1); } 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' const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl; const output = []; let segmentIndex = -1; for (let 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(''); } } /* * 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(id, err?) handler for tracing / hot-reloading * * Core comes with no System.prototype.resolve or * System.prototype.instantiate implementations */ const hasSymbol = typeof Symbol !== 'undefined'; const toStringTag = hasSymbol && Symbol.toStringTag; const REGISTRY = hasSymbol ? Symbol() : '@'; function SystemJS () { this[REGISTRY] = {}; } const systemJSPrototype = SystemJS.prototype; systemJSPrototype.import = function (id, parentUrl) { const loader = this; return Promise.resolve(loader.resolve(id, parentUrl)) .then(function (id) { const load = getOrCreateLoad(loader, id); return load.C || topLevelLoad(loader, load); }); }; // Hookable createContext function -> allowing eg custom import meta systemJSPrototype.createContext = function (parentId) { return { url: parentId }; }; let lastRegister; systemJSPrototype.register = function (deps, declare) { lastRegister = [deps, declare]; }; /* * getRegister provides the last anonymous System.register call */ systemJSPrototype.getRegister = function () { const _lastRegister = lastRegister; lastRegister = undefined; return _lastRegister; }; function getOrCreateLoad (loader, id, firstParentUrl) { let load = loader[REGISTRY][id]; if (load) return load; const importerSetters = []; const ns = Object.create(null); if (toStringTag) Object.defineProperty(ns, toStringTag, { value: 'Module' }); let instantiatePromise = Promise.resolve() .then(function () { return loader.instantiate(id, firstParentUrl); }) .then(function (registration) { if (!registration) throw new Error('Module ' + id + ' did not instantiate'); function _export (name, value) { // note if we have hoisted exports (including reexports) load.h = true; let changed = false; if (typeof name !== 'object') { if (!(name in ns) || ns[name] !== value) { ns[name] = value; changed = true; } } else { for (let p in name) { let value = name[p]; if (!(p in ns) || ns[p] !== value) { ns[p] = value; changed = true; } } } if (changed) for (let i = 0; i < importerSetters.length; i++) importerSetters[i](ns); return value; } const 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 || []]; }); const linkPromise = instantiatePromise .then(function (instantiation) { return Promise.all(instantiation[0].map(function (dep, i) { const setter = instantiation[1][i]; return Promise.resolve(loader.resolve(dep, id)) .then(function (depId) { const 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; }); }); // disable unhandled rejections linkPromise.catch(function () {}); // Captial 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 // set to NULL immediately after execution (or on any failure) to indicate execution has happened // in such a case, pC should be used, and pLo, pLi will be emptied e: undefined, // On execution we have populated: // the execution error if any eE: undefined, // in the case of TLA, the execution promise E: undefined, // On execution, pLi, pLo, e cleared // Promise for top-level completion C: undefined }; } function instantiateAll (loader, load, loaded) { if (!loaded[load.id]) { loaded[load.id] = true; // load.L may be undefined for already-instantiated return Promise.resolve(load.L) .then(function () { return Promise.all(load.d.map(function (dep) { return instantiateAll(loader, dep, loaded); })); }) } } function topLevelLoad (loader, load) { return load.C = instantiateAll(loader, load, {}) .then(function () { return postOrderExec(loader, load, {}); }) .then(function () { return load.n; }); } // the closest we can get to call(undefined) const 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.eE) throw load.eE; if (load.E) return load.E; return; } // deps execute first, unless circular let depLoadPromises; load.d.forEach(function (depLoad) { { const depLoadPromise = postOrderExec(loader, depLoad, seen); if (depLoadPromise) (depLoadPromises = depLoadPromises || []).push(depLoadPromise); } }); if (depLoadPromises) { return load.E = Promise.all(depLoadPromises).then(doExec); } return doExec(); function doExec () { try { let execPromise = load.e.call(nullContext); if (execPromise) { execPromise.then(function () { load.C = load.n; load.E = null; }); execPromise.catch(function () {}); return load.E = load.E || execPromise; } // (should be a promise, but a minify optimization to leave out Promise.resolve) load.C = load.n; } catch (err) { load.eE = err; throw err; } finally { load.L = load.I = undefined; load.e = null; } } } envGlobal.System = new SystemJS(); /* * Supports loading System.register via script tag injection */ let err$1; if (typeof window !== 'undefined') window.addEventListener('error', function (e) { err$1 = e.error; }); const systemRegister = systemJSPrototype.register; systemJSPrototype.register = function (deps, declare) { err$1 = undefined; systemRegister.call(this, deps, declare); }; systemJSPrototype.instantiate = function (url, firstParentUrl) { const loader = this; return new Promise(function (resolve, reject) { const script = document.createElement('script'); script.charset = 'utf-8'; script.async = true; script.addEventListener('error', function () { reject(new Error('Error loading ' + url + (firstParentUrl ? ' from ' + firstParentUrl : ''))); }); script.addEventListener('load', function () { document.head.removeChild(script); // Note URL normalization issues are going to be a careful concern here if (err$1) return reject(err$1); else resolve(loader.getRegister()); }); script.src = url; document.head.appendChild(script); }); }; systemJSPrototype.resolve = function (id, parentUrl) { const resolved = resolveIfNotPlainOrUrl(id, parentUrl || baseUrl); if (!resolved) { if (id.indexOf(':') !== -1) return id; throw new Error('Cannot resolve "' + id + (parentUrl ? '" from ' + parentUrl : '"')); } return resolved; }; }());