diff options
Diffstat (limited to 'extension/lib/vendor/system.src.js')
| -rw-r--r-- | extension/lib/vendor/system.src.js | 4843 |
1 files changed, 4843 insertions, 0 deletions
diff --git a/extension/lib/vendor/system.src.js b/extension/lib/vendor/system.src.js new file mode 100644 index 000000000..55b1b5c3c --- /dev/null +++ b/extension/lib/vendor/system.src.js @@ -0,0 +1,4843 @@ +/* + * SystemJS v0.19.13 + */ +(function() { +function bootstrap() {(function(__global) { + + var isWorker = typeof window == 'undefined' && typeof self != 'undefined' && typeof importScripts != 'undefined'; + var isBrowser = typeof window != 'undefined' && typeof document != 'undefined'; + var isWindows = typeof process != 'undefined' && typeof process.platform != 'undefined' && !!process.platform.match(/^win/); + + if (!__global.console) + __global.console = { assert: function() {} }; + + // IE8 support + var indexOf = Array.prototype.indexOf || function(item) { + for (var i = 0, thisLen = this.length; i < thisLen; i++) { + if (this[i] === item) { + return i; + } + } + return -1; + }; + + var defineProperty; + (function () { + try { + if (!!Object.defineProperty({}, 'a', {})) + defineProperty = Object.defineProperty; + } + catch (e) { + defineProperty = function(obj, prop, opt) { + try { + obj[prop] = opt.value || opt.get.call(obj); + } + catch(e) {} + } + } + })(); + + function addToError(err, msg) { + var newErr; + if (err instanceof Error) { + newErr = new Error(err.message, err.fileName, err.lineNumber); + if (isBrowser) { + newErr.message = err.message + '\n\t' + msg; + newErr.stack = err.stack; + } + else { + // node errors only look correct with the stack modified + newErr.message = err.message; + newErr.stack = err.stack + '\n\t' + msg; + } + } + else { + newErr = err + '\n\t' + msg; + } + + return newErr; + } + + function __eval(source, debugName, context) { + try { + new Function(source).call(context); + } + catch(e) { + throw addToError(e, 'Evaluating ' + debugName); + } + } + + var baseURI; + // environent baseURI detection + if (typeof document != 'undefined' && document.getElementsByTagName) { + baseURI = document.baseURI; + + if (!baseURI) { + var bases = document.getElementsByTagName('base'); + baseURI = bases[0] && bases[0].href || window.location.href; + } + + // sanitize out the hash and querystring + baseURI = baseURI.split('#')[0].split('?')[0]; + baseURI = baseURI.substr(0, baseURI.lastIndexOf('/') + 1); + } + else if (typeof process != 'undefined' && process.cwd) { + baseURI = 'file://' + (isWindows ? '/' : '') + process.cwd() + '/'; + if (isWindows) + baseURI = baseURI.replace(/\\/g, '/'); + } + else if (typeof location != 'undefined') { + baseURI = __global.location.href; + } + else { + throw new TypeError('No environment baseURI'); + } + + var URL = __global.URLPolyfill || __global.URL; +/* +********************************************************************************************* + + Dynamic Module Loader Polyfill + + - Implemented exactly to the former 2014-08-24 ES6 Specification Draft Rev 27, Section 15 + http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts#august_24_2014_draft_rev_27 + + - Functions are commented with their spec numbers, with spec differences commented. + + - Spec bugs are commented in this code with links. + + - Abstract functions have been combined where possible, and their associated functions + commented. + + - Realm implementation is entirely omitted. + +********************************************************************************************* +*/ + +function Module() {} +// http://www.ecma-international.org/ecma-262/6.0/#sec-@@tostringtag +defineProperty(Module.prototype, 'toString', { + value: function() { + return 'Module'; + } +}); +function Loader(options) { + this._loader = { + loaderObj: this, + loads: [], + modules: {}, + importPromises: {}, + moduleRecords: {} + }; + + // 26.3.3.6 + defineProperty(this, 'global', { + get: function() { + return __global; + } + }); + + // 26.3.3.13 realm not implemented +} + +(function() { + +// Some Helpers + +// logs a linkset snapshot for debugging +/* function snapshot(loader) { + console.log('---Snapshot---'); + for (var i = 0; i < loader.loads.length; i++) { + var load = loader.loads[i]; + var linkSetLog = ' ' + load.name + ' (' + load.status + '): '; + + for (var j = 0; j < load.linkSets.length; j++) { + linkSetLog += '{' + logloads(load.linkSets[j].loads) + '} '; + } + console.log(linkSetLog); + } + console.log(''); +} +function logloads(loads) { + var log = ''; + for (var k = 0; k < loads.length; k++) + log += loads[k].name + (k != loads.length - 1 ? ' ' : ''); + return log; +} */ + + +/* function checkInvariants() { + // see https://bugs.ecmascript.org/show_bug.cgi?id=2603#c1 + + var loads = System._loader.loads; + var linkSets = []; + + for (var i = 0; i < loads.length; i++) { + var load = loads[i]; + console.assert(load.status == 'loading' || load.status == 'loaded', 'Each load is loading or loaded'); + + for (var j = 0; j < load.linkSets.length; j++) { + var linkSet = load.linkSets[j]; + + for (var k = 0; k < linkSet.loads.length; k++) + console.assert(loads.indexOf(linkSet.loads[k]) != -1, 'linkSet loads are a subset of loader loads'); + + if (linkSets.indexOf(linkSet) == -1) + linkSets.push(linkSet); + } + } + + for (var i = 0; i < loads.length; i++) { + var load = loads[i]; + for (var j = 0; j < linkSets.length; j++) { + var linkSet = linkSets[j]; + + if (linkSet.loads.indexOf(load) != -1) + console.assert(load.linkSets.indexOf(linkSet) != -1, 'linkSet contains load -> load contains linkSet'); + + if (load.linkSets.indexOf(linkSet) != -1) + console.assert(linkSet.loads.indexOf(load) != -1, 'load contains linkSet -> linkSet contains load'); + } + } + + for (var i = 0; i < linkSets.length; i++) { + var linkSet = linkSets[i]; + for (var j = 0; j < linkSet.loads.length; j++) { + var load = linkSet.loads[j]; + + for (var k = 0; k < load.dependencies.length; k++) { + var depName = load.dependencies[k].value; + var depLoad; + for (var l = 0; l < loads.length; l++) { + if (loads[l].name != depName) + continue; + depLoad = loads[l]; + break; + } + + // loading records are allowed not to have their dependencies yet + // if (load.status != 'loading') + // console.assert(depLoad, 'depLoad found'); + + // console.assert(linkSet.loads.indexOf(depLoad) != -1, 'linkset contains all dependencies'); + } + } + } +} */ + + // 15.2.3 - Runtime Semantics: Loader State + + // 15.2.3.11 + function createLoaderLoad(object) { + return { + // modules is an object for ES5 implementation + modules: {}, + loads: [], + loaderObj: object + }; + } + + // 15.2.3.2 Load Records and LoadRequest Objects + + // 15.2.3.2.1 + function createLoad(name) { + return { + status: 'loading', + name: name, + linkSets: [], + dependencies: [], + metadata: {} + }; + } + + // 15.2.3.2.2 createLoadRequestObject, absorbed into calling functions + + // 15.2.4 + + // 15.2.4.1 + function loadModule(loader, name, options) { + return new Promise(asyncStartLoadPartwayThrough({ + step: options.address ? 'fetch' : 'locate', + loader: loader, + moduleName: name, + // allow metadata for import https://bugs.ecmascript.org/show_bug.cgi?id=3091 + moduleMetadata: options && options.metadata || {}, + moduleSource: options.source, + moduleAddress: options.address + })); + } + + // 15.2.4.2 + function requestLoad(loader, request, refererName, refererAddress) { + // 15.2.4.2.1 CallNormalize + return new Promise(function(resolve, reject) { + resolve(loader.loaderObj.normalize(request, refererName, refererAddress)); + }) + // 15.2.4.2.2 GetOrCreateLoad + .then(function(name) { + var load; + if (loader.modules[name]) { + load = createLoad(name); + load.status = 'linked'; + // https://bugs.ecmascript.org/show_bug.cgi?id=2795 + load.module = loader.modules[name]; + return load; + } + + for (var i = 0, l = loader.loads.length; i < l; i++) { + load = loader.loads[i]; + if (load.name != name) + continue; + console.assert(load.status == 'loading' || load.status == 'loaded', 'loading or loaded'); + return load; + } + + load = createLoad(name); + loader.loads.push(load); + + proceedToLocate(loader, load); + + return load; + }); + } + + // 15.2.4.3 + function proceedToLocate(loader, load) { + proceedToFetch(loader, load, + Promise.resolve() + // 15.2.4.3.1 CallLocate + .then(function() { + return loader.loaderObj.locate({ name: load.name, metadata: load.metadata }); + }) + ); + } + + // 15.2.4.4 + function proceedToFetch(loader, load, p) { + proceedToTranslate(loader, load, + p + // 15.2.4.4.1 CallFetch + .then(function(address) { + // adjusted, see https://bugs.ecmascript.org/show_bug.cgi?id=2602 + if (load.status != 'loading') + return; + load.address = address; + + return loader.loaderObj.fetch({ name: load.name, metadata: load.metadata, address: address }); + }) + ); + } + + var anonCnt = 0; + + // 15.2.4.5 + function proceedToTranslate(loader, load, p) { + p + // 15.2.4.5.1 CallTranslate + .then(function(source) { + if (load.status != 'loading') + return; + + return Promise.resolve(loader.loaderObj.translate({ name: load.name, metadata: load.metadata, address: load.address, source: source })) + + // 15.2.4.5.2 CallInstantiate + .then(function(source) { + load.source = source; + return loader.loaderObj.instantiate({ name: load.name, metadata: load.metadata, address: load.address, source: source }); + }) + + // 15.2.4.5.3 InstantiateSucceeded + .then(function(instantiateResult) { + if (instantiateResult === undefined) { + load.address = load.address || '<Anonymous Module ' + ++anonCnt + '>'; + + // instead of load.kind, use load.isDeclarative + load.isDeclarative = true; + return transpile.call(loader.loaderObj, load) + .then(function(transpiled) { + // Hijack System.register to set declare function + var curSystem = __global.System; + var curRegister = curSystem.register; + curSystem.register = function(name, deps, declare) { + if (typeof name != 'string') { + declare = deps; + deps = name; + } + // store the registered declaration as load.declare + // store the deps as load.deps + load.declare = declare; + load.depsList = deps; + } + // empty {} context is closest to undefined 'this' we can get + __eval(transpiled, load.address, {}); + curSystem.register = curRegister; + }); + } + else if (typeof instantiateResult == 'object') { + load.depsList = instantiateResult.deps || []; + load.execute = instantiateResult.execute; + load.isDeclarative = false; + } + else + throw TypeError('Invalid instantiate return value'); + }) + // 15.2.4.6 ProcessLoadDependencies + .then(function() { + load.dependencies = []; + var depsList = load.depsList; + + var loadPromises = []; + for (var i = 0, l = depsList.length; i < l; i++) (function(request, index) { + loadPromises.push( + requestLoad(loader, request, load.name, load.address) + + // 15.2.4.6.1 AddDependencyLoad (load is parentLoad) + .then(function(depLoad) { + + // adjusted from spec to maintain dependency order + // this is due to the System.register internal implementation needs + load.dependencies[index] = { + key: request, + value: depLoad.name + }; + + if (depLoad.status != 'linked') { + var linkSets = load.linkSets.concat([]); + for (var i = 0, l = linkSets.length; i < l; i++) + addLoadToLinkSet(linkSets[i], depLoad); + } + + // console.log('AddDependencyLoad ' + depLoad.name + ' for ' + load.name); + // snapshot(loader); + }) + ); + })(depsList[i], i); + + return Promise.all(loadPromises); + }) + + // 15.2.4.6.2 LoadSucceeded + .then(function() { + // console.log('LoadSucceeded ' + load.name); + // snapshot(loader); + + console.assert(load.status == 'loading', 'is loading'); + + load.status = 'loaded'; + + var linkSets = load.linkSets.concat([]); + for (var i = 0, l = linkSets.length; i < l; i++) + updateLinkSetOnLoad(linkSets[i], load); + }); + }) + // 15.2.4.5.4 LoadFailed + ['catch'](function(exc) { + load.status = 'failed'; + load.exception = exc; + + var linkSets = load.linkSets.concat([]); + for (var i = 0, l = linkSets.length; i < l; i++) { + linkSetFailed(linkSets[i], load, exc); + } + + console.assert(load.linkSets.length == 0, 'linkSets not removed'); + }); + } + + // 15.2.4.7 PromiseOfStartLoadPartwayThrough absorbed into calling functions + + // 15.2.4.7.1 + function asyncStartLoadPartwayThrough(stepState) { + return function(resolve, reject) { + var loader = stepState.loader; + var name = stepState.moduleName; + var step = stepState.step; + + if (loader.modules[name]) + throw new TypeError('"' + name + '" already exists in the module table'); + + // adjusted to pick up existing loads + var existingLoad; + for (var i = 0, l = loader.loads.length; i < l; i++) { + if (loader.loads[i].name == name) { + existingLoad = loader.loads[i]; + + if (step == 'translate' && !existingLoad.source) { + existingLoad.address = stepState.moduleAddress; + proceedToTranslate(loader, existingLoad, Promise.resolve(stepState.moduleSource)); + } + + // a primary load -> use that existing linkset if it is for the direct load here + // otherwise create a new linkset unit + if (existingLoad.linkSets.length && existingLoad.linkSets[0].loads[0].name == existingLoad.name) + return existingLoad.linkSets[0].done.then(function() { + resolve(existingLoad); + }); + } + } + + var load = existingLoad || createLoad(name); + + load.metadata = stepState.moduleMetadata; + + var linkSet = createLinkSet(loader, load); + + loader.loads.push(load); + + resolve(linkSet.done); + + if (step == 'locate') + proceedToLocate(loader, load); + + else if (step == 'fetch') + proceedToFetch(loader, load, Promise.resolve(stepState.moduleAddress)); + + else { + console.assert(step == 'translate', 'translate step'); + load.address = stepState.moduleAddress; + proceedToTranslate(loader, load, Promise.resolve(stepState.moduleSource)); + } + } + } + + // Declarative linking functions run through alternative implementation: + // 15.2.5.1.1 CreateModuleLinkageRecord not implemented + // 15.2.5.1.2 LookupExport not implemented + // 15.2.5.1.3 LookupModuleDependency not implemented + + // 15.2.5.2.1 + function createLinkSet(loader, startingLoad) { + var linkSet = { + loader: loader, + loads: [], + startingLoad: startingLoad, // added see spec bug https://bugs.ecmascript.org/show_bug.cgi?id=2995 + loadingCount: 0 + }; + linkSet.done = new Promise(function(resolve, reject) { + linkSet.resolve = resolve; + linkSet.reject = reject; + }); + addLoadToLinkSet(linkSet, startingLoad); + return linkSet; + } + // 15.2.5.2.2 + function addLoadToLinkSet(linkSet, load) { + if (load.status == 'failed') + return; + + console.assert(load.status == 'loading' || load.status == 'loaded', 'loading or loaded on link set'); + + for (var i = 0, l = linkSet.loads.length; i < l; i++) + if (linkSet.loads[i] == load) + return; + + linkSet.loads.push(load); + load.linkSets.push(linkSet); + + // adjustment, see https://bugs.ecmascript.org/show_bug.cgi?id=2603 + if (load.status != 'loaded') { + linkSet.loadingCount++; + } + + var loader = linkSet.loader; + + for (var i = 0, l = load.dependencies.length; i < l; i++) { + if (!load.dependencies[i]) + continue; + + var name = load.dependencies[i].value; + + if (loader.modules[name]) + continue; + + for (var j = 0, d = loader.loads.length; j < d; j++) { + if (loader.loads[j].name != name) + continue; + + addLoadToLinkSet(linkSet, loader.loads[j]); + break; + } + } + // console.log('add to linkset ' + load.name); + // snapshot(linkSet.loader); + } + + // linking errors can be generic or load-specific + // this is necessary for debugging info + function doLink(linkSet) { + var error = false; + try { + link(linkSet, function(load, exc) { + linkSetFailed(linkSet, load, exc); + error = true; + }); + } + catch(e) { + linkSetFailed(linkSet, null, e); + error = true; + } + return error; + } + + // 15.2.5.2.3 + function updateLinkSetOnLoad(linkSet, load) { + // console.log('update linkset on load ' + load.name); + // snapshot(linkSet.loader); + + console.assert(load.status == 'loaded' || load.status == 'linked', 'loaded or linked'); + + linkSet.loadingCount--; + + if (linkSet.loadingCount > 0) + return; + + // adjusted for spec bug https://bugs.ecmascript.org/show_bug.cgi?id=2995 + var startingLoad = linkSet.startingLoad; + + // non-executing link variation for loader tracing + // on the server. Not in spec. + /***/ + if (linkSet.loader.loaderObj.execute === false) { + var loads = [].concat(linkSet.loads); + for (var i = 0, l = loads.length; i < l; i++) { + var load = loads[i]; + load.module = !load.isDeclarative ? { + module: _newModule({}) + } : { + name: load.name, + module: _newModule({}), + evaluated: true + }; + load.status = 'linked'; + finishLoad(linkSet.loader, load); + } + return linkSet.resolve(startingLoad); + } + /***/ + + var abrupt = doLink(linkSet); + + if (abrupt) + return; + + console.assert(linkSet.loads.length == 0, 'loads cleared'); + + linkSet.resolve(startingLoad); + } + + // 15.2.5.2.4 + function linkSetFailed(linkSet, load, exc) { + var loader = linkSet.loader; + var requests; + + checkError: + if (load) { + if (linkSet.loads[0].name == load.name) { + exc = addToError(exc, 'Error loading ' + load.name); + } + else { + for (var i = 0; i < linkSet.loads.length; i++) { + var pLoad = linkSet.loads[i]; + for (var j = 0; j < pLoad.dependencies.length; j++) { + var dep = pLoad.dependencies[j]; + if (dep.value == load.name) { + exc = addToError(exc, 'Error loading ' + load.name + ' as "' + dep.key + '" from ' + pLoad.name); + break checkError; + } + } + } + exc = addToError(exc, 'Error loading ' + load.name + ' from ' + linkSet.loads[0].name); + } + } + else { + exc = addToError(exc, 'Error linking ' + linkSet.loads[0].name); + } + + + var loads = linkSet.loads.concat([]); + for (var i = 0, l = loads.length; i < l; i++) { + var load = loads[i]; + + // store all failed load records + loader.loaderObj.failed = loader.loaderObj.failed || []; + if (indexOf.call(loader.loaderObj.failed, load) == -1) + loader.loaderObj.failed.push(load); + + var linkIndex = indexOf.call(load.linkSets, linkSet); + console.assert(linkIndex != -1, 'link not present'); + load.linkSets.splice(linkIndex, 1); + if (load.linkSets.length == 0) { + var globalLoadsIndex = indexOf.call(linkSet.loader.loads, load); + if (globalLoadsIndex != -1) + linkSet.loader.loads.splice(globalLoadsIndex, 1); + } + } + linkSet.reject(exc); + } + + // 15.2.5.2.5 + function finishLoad(loader, load) { + // add to global trace if tracing + if (loader.loaderObj.trace) { + if (!loader.loaderObj.loads) + loader.loaderObj.loads = {}; + var depMap = {}; + load.dependencies.forEach(function(dep) { + depMap[dep.key] = dep.value; + }); + loader.loaderObj.loads[load.name] = { + name: load.name, + deps: load.dependencies.map(function(dep){ return dep.key }), + depMap: depMap, + address: load.address, + metadata: load.metadata, + source: load.source, + kind: load.isDeclarative ? 'declarative' : 'dynamic' + }; + } + // if not anonymous, add to the module table + if (load.name) { + console.assert(!loader.modules[load.name], 'load not in module table'); + loader.modules[load.name] = load.module; + } + var loadIndex = indexOf.call(loader.loads, load); + if (loadIndex != -1) + loader.loads.splice(loadIndex, 1); + for (var i = 0, l = load.linkSets.length; i < l; i++) { + loadIndex = indexOf.call(load.linkSets[i].loads, load); + if (loadIndex != -1) + load.linkSets[i].loads.splice(loadIndex, 1); + } + load.linkSets.splice(0, load.linkSets.length); + } + + function doDynamicExecute(linkSet, load, linkError) { + try { + var module = load.execute(); + } + catch(e) { + linkError(load, e); + return; + } + if (!module || !(module instanceof Module)) + linkError(load, new TypeError('Execution must define a Module instance')); + else + return module; + } + + // 26.3 Loader + + // 26.3.1.1 + // defined at top + + // importPromises adds ability to import a module twice without error - https://bugs.ecmascript.org/show_bug.cgi?id=2601 + function createImportPromise(loader, name, promise) { + var importPromises = loader._loader.importPromises; + return importPromises[name] = promise.then(function(m) { + importPromises[name] = undefined; + return m; + }, function(e) { + importPromises[name] = undefined; + throw e; + }); + } + + Loader.prototype = { + // 26.3.3.1 + constructor: Loader, + // 26.3.3.2 + define: function(name, source, options) { + // check if already defined + if (this._loader.importPromises[name]) + throw new TypeError('Module is already loading.'); + return createImportPromise(this, name, new Promise(asyncStartLoadPartwayThrough({ + step: 'translate', + loader: this._loader, + moduleName: name, + moduleMetadata: options && options.metadata || {}, + moduleSource: source, + moduleAddress: options && options.address + }))); + }, + // 26.3.3.3 + 'delete': function(name) { + var loader = this._loader; + delete loader.importPromises[name]; + delete loader.moduleRecords[name]; + return loader.modules[name] ? delete loader.modules[name] : false; + }, + // 26.3.3.4 entries not implemented + // 26.3.3.5 + get: function(key) { + if (!this._loader.modules[key]) + return; + doEnsureEvaluated(this._loader.modules[key], [], this); + return this._loader.modules[key].module; + }, + // 26.3.3.7 + has: function(name) { + return !!this._loader.modules[name]; + }, + // 26.3.3.8 + 'import': function(name, parentName, parentAddress) { + if (typeof parentName == 'object') + parentName = parentName.name; + + // run normalize first + var loaderObj = this; + + // added, see https://bugs.ecmascript.org/show_bug.cgi?id=2659 + return Promise.resolve(loaderObj.normalize(name, parentName)) + .then(function(name) { + var loader = loaderObj._loader; + + if (loader.modules[name]) { + doEnsureEvaluated(loader.modules[name], [], loader._loader); + return loader.modules[name].module; + } + + return loader.importPromises[name] || createImportPromise(loaderObj, name, + loadModule(loader, name, {}) + .then(function(load) { + delete loader.importPromises[name]; + return evaluateLoadedModule(loader, load); + })); + }); + }, + // 26.3.3.9 keys not implemented + // 26.3.3.10 + load: function(name) { + var loader = this._loader; + if (loader.modules[name]) + return Promise.resolve(); + return loader.importPromises[name] || createImportPromise(this, name, new Promise(asyncStartLoadPartwayThrough({ + step: 'locate', + loader: loader, + moduleName: name, + moduleMetadata: {}, + moduleSource: undefined, + moduleAddress: undefined + })) + .then(function() { + delete loader.importPromises[name]; + })); + }, + // 26.3.3.11 + module: function(source, options) { + var load = createLoad(); + load.address = options && options.address; + var linkSet = createLinkSet(this._loader, load); + var sourcePromise = Promise.resolve(source); + var loader = this._loader; + var p = linkSet.done.then(function() { + return evaluateLoadedModule(loader, load); + }); + proceedToTranslate(loader, load, sourcePromise); + return p; + }, + // 26.3.3.12 + newModule: function (obj) { + if (typeof obj != 'object') + throw new TypeError('Expected object'); + + var m = new Module(); + + var pNames = []; + if (Object.getOwnPropertyNames && obj != null) + pNames = Object.getOwnPropertyNames(obj); + else + for (var key in obj) + pNames.push(key); + + for (var i = 0; i < pNames.length; i++) (function(key) { + defineProperty(m, key, { + configurable: false, + enumerable: true, + get: function () { + return obj[key]; + } + }); + })(pNames[i]); + + return m; + }, + // 26.3.3.14 + set: function(name, module) { + if (!(module instanceof Module)) + throw new TypeError('Loader.set(' + name + ', module) must be a module'); + this._loader.modules[name] = { + module: module + }; + }, + // 26.3.3.15 values not implemented + // 26.3.3.16 @@iterator not implemented + // 26.3.3.17 @@toStringTag not implemented + + // 26.3.3.18.1 + normalize: function(name, referrerName, referrerAddress) { + return name; + }, + // 26.3.3.18.2 + locate: function(load) { + return load.name; + }, + // 26.3.3.18.3 + fetch: function(load) { + }, + // 26.3.3.18.4 + translate: function(load) { + return load.source; + }, + // 26.3.3.18.5 + instantiate: function(load) { + } + }; + + var _newModule = Loader.prototype.newModule; +/* + * ES6 Module Declarative Linking Code - Dev Build Only + */ + function link(linkSet, linkError) { + + var loader = linkSet.loader; + + if (!linkSet.loads.length) + return; + + var loads = linkSet.loads.concat([]); + + for (var i = 0; i < loads.length; i++) { + var load = loads[i]; + + var module = doDynamicExecute(linkSet, load, linkError); + if (!module) + return; + load.module = { + name: load.name, + module: module + }; + load.status = 'linked'; + + finishLoad(loader, load); + } + } + + function evaluateLoadedModule(loader, load) { + console.assert(load.status == 'linked', 'is linked ' + load.name); + return load.module.module; + } + + function doEnsureEvaluated() {} + + function transpile() { + throw new TypeError('ES6 transpilation is only provided in the dev module loader build.'); + } +})();/* +********************************************************************************************* + + System Loader Implementation + + - Implemented to https://github.com/jorendorff/js-loaders/blob/master/browser-loader.js + + - <script type="module"> supported + +********************************************************************************************* +*/ + +var System; + +function SystemLoader() { + Loader.call(this); + this.paths = {}; +} + +// NB no specification provided for System.paths, used ideas discussed in https://github.com/jorendorff/js-loaders/issues/25 +function applyPaths(paths, name) { + // most specific (most number of slashes in path) match wins + var pathMatch = '', wildcard, maxWildcardPrefixLen = 0; + + // check to see if we have a paths entry + for (var p in paths) { + var pathParts = p.split('*'); + if (pathParts.length > 2) + throw new TypeError('Only one wildcard in a path is permitted'); + + // exact path match + if (pathParts.length == 1) { + if (name == p) { + pathMatch = p; + break; + } + } + // wildcard path match + else { + var wildcardPrefixLen = pathParts[0].length; + if (wildcardPrefixLen >= maxWildcardPrefixLen && + name.substr(0, pathParts[0].length) == pathParts[0] && + name.substr(name.length - pathParts[1].length) == pathParts[1]) { + maxWildcardPrefixLen = wildcardPrefixLen; + pathMatch = p; + wildcard = name.substr(pathParts[0].length, name.length - pathParts[1].length - pathParts[0].length); + } + } + } + + var outPath = paths[pathMatch]; + if (typeof wildcard == 'string') + outPath = outPath.replace('*', wildcard); + + return outPath; +} + +// inline Object.create-style class extension +function LoaderProto() {} +LoaderProto.prototype = Loader.prototype; +SystemLoader.prototype = new LoaderProto(); + var fetchTextFromURL; + if (typeof XMLHttpRequest != 'undefined') { + fetchTextFromURL = function(url, authorization, fulfill, reject) { + var xhr = new XMLHttpRequest(); + var sameDomain = true; + var doTimeout = false; + if (!('withCredentials' in xhr)) { + // check if same domain + var domainCheck = /^(\w+:)?\/\/([^\/]+)/.exec(url); + if (domainCheck) { + sameDomain = domainCheck[2] === window.location.host; + if (domainCheck[1]) + sameDomain &= domainCheck[1] === window.location.protocol; + } + } + if (!sameDomain && typeof XDomainRequest != 'undefined') { + xhr = new XDomainRequest(); + xhr.onload = load; + xhr.onerror = error; + xhr.ontimeout = error; + xhr.onprogress = function() {}; + xhr.timeout = 0; + doTimeout = true; + } + function load() { + fulfill(xhr.responseText); + } + function error() { + reject(new Error('XHR error' + (xhr.status ? ' (' + xhr.status + (xhr.statusText ? ' ' + xhr.statusText : '') + ')' : '') + ' loading ' + url)); + } + + xhr.onreadystatechange = function () { + if (xhr.readyState === 4) { + // in Chrome on file:/// URLs, status is 0 + if (xhr.status == 0) { + if (xhr.responseText) { + load(); + } + else { + // when responseText is empty, wait for load or error event + // to inform if it is a 404 or empty file + xhr.addEventListener('error', error); + xhr.addEventListener('load', load); + } + } + else if (xhr.status === 200) { + load(); + } + else { + error(); + } + } + }; + xhr.open("GET", url, true); + + if (xhr.setRequestHeader) { + xhr.setRequestHeader('Accept', 'application/x-es-module, */*'); + // can set "authorization: true" to enable withCredentials only + if (authorization) { + if (typeof authorization == 'string') + xhr.setRequestHeader('Authorization', authorization); + xhr.withCredentials = true; + } + } + + if (doTimeout) { + setTimeout(function() { + xhr.send(); + }, 0); + } else { + xhr.send(null); + } + }; + } + else if (typeof require != 'undefined' && typeof process != 'undefined') { + var fs; + fetchTextFromURL = function(url, authorization, fulfill, reject) { + if (url.substr(0, 8) != 'file:///') + throw new Error('Unable to fetch "' + url + '". Only file URLs of the form file:/// allowed running in Node.'); + fs = fs || require('fs'); + if (isWindows) + url = url.replace(/\//g, '\\').substr(8); + else + url = url.substr(7); + return fs.readFile(url, function(err, data) { + if (err) { + return reject(err); + } + else { + // Strip Byte Order Mark out if it's the leading char + var dataString = data + ''; + if (dataString[0] === '\ufeff') + dataString = dataString.substr(1); + + fulfill(dataString); + } + }); + }; + } + else if (typeof self != 'undefined' && typeof self.fetch != 'undefined') { + fetchTextFromURL = function(url, authorization, fulfill, reject) { + var opts = { + headers: {'Accept': 'application/x-es-module, */*'} + }; + + if (authorization) { + if (typeof authorization == 'string') + opts.headers['Authorization'] = authorization; + opts.credentials = 'include'; + } + + fetch(url, opts) + .then(function (r) { + if (r.ok) { + return r.text(); + } else { + throw new Error('Fetch error: ' + r.status + ' ' + r.statusText); + } + }) + .then(fulfill, reject); + } + } + else { + throw new TypeError('No environment fetch API available.'); + } + + SystemLoader.prototype.fetch = function(load) { + return new Promise(function(resolve, reject) { + fetchTextFromURL(load.address, undefined, resolve, reject); + }); + }; +/* + * Traceur, Babel and TypeScript transpile hook for Loader + */ +var transpile = (function() { + + // use Traceur by default + Loader.prototype.transpiler = 'traceur'; + + function transpile(load) { + var self = this; + + return Promise.resolve(__global[self.transpiler == 'typescript' ? 'ts' : self.transpiler] + || (self.pluginLoader || self)['import'](self.transpiler)) + .then(function(transpiler) { + if (transpiler.__useDefault) + transpiler = transpiler['default']; + + var transpileFunction; + if (transpiler.Compiler) + transpileFunction = traceurTranspile; + else if (transpiler.createLanguageService) + transpileFunction = typescriptTranspile; + else + transpileFunction = babelTranspile; + + // note __moduleName will be part of the transformer meta in future when we have the spec for this + return '(function(__moduleName){' + transpileFunction.call(self, load, transpiler) + '\n})("' + load.name + '");\n//# sourceURL=' + load.address + '!transpiled'; + }); + }; + + function traceurTranspile(load, traceur) { + var options = this.traceurOptions || {}; + options.modules = 'instantiate'; + options.script = false; + if (options.sourceMaps === undefined) + options.sourceMaps = 'inline'; + options.filename = load.address; + options.inputSourceMap = load.metadata.sourceMap; + options.moduleName = false; + + var compiler = new traceur.Compiler(options); + + return doTraceurCompile(load.source, compiler, options.filename); + } + function doTraceurCompile(source, compiler, filename) { + try { + return compiler.compile(source, filename); + } + catch(e) { + // on older versions of traceur (<0.9.3), an array of errors is thrown + // rather than a single error. + if (e.length) { + throw e[0]; + } + throw e; + } + } + + function babelTranspile(load, babel) { + var options = this.babelOptions || {}; + options.modules = 'system'; + if (options.sourceMap === undefined) + options.sourceMap = 'inline'; + options.inputSourceMap = load.metadata.sourceMap; + options.filename = load.address; + options.code = true; + options.ast = false; + + return babel.transform(load.source, options).code; + } + + function typescriptTranspile(load, ts) { + var options = this.typescriptOptions || {}; + options.target = options.target || ts.ScriptTarget.ES5; + if (options.sourceMap === undefined) + options.sourceMap = true; + if (options.sourceMap && options.inlineSourceMap !== false) + options.inlineSourceMap = true; + + options.module = ts.ModuleKind.System; + + return ts.transpile(load.source, options, load.address); + } + + return transpile; +})(); +// SystemJS Loader Class and Extension helpers + +function SystemJSLoader() { + SystemLoader.call(this); + + systemJSConstructor.call(this); +} + +// inline Object.create-style class extension +function SystemProto() {}; +SystemProto.prototype = SystemLoader.prototype; +SystemJSLoader.prototype = new SystemProto(); +SystemJSLoader.prototype.constructor = SystemJSLoader; + +// remove ESML instantiate +SystemJSLoader.prototype.instantiate = function() {}; + +var systemJSConstructor; + +function hook(name, hook) { + SystemJSLoader.prototype[name] = hook(SystemJSLoader.prototype[name] || function() {}); +} +function hookConstructor(hook) { + systemJSConstructor = hook(systemJSConstructor || function() {}); +} + +function dedupe(deps) { + var newDeps = []; + for (var i = 0, l = deps.length; i < l; i++) + if (indexOf.call(newDeps, deps[i]) == -1) + newDeps.push(deps[i]) + return newDeps; +} + +function group(deps) { + var names = []; + var indices = []; + for (var i = 0, l = deps.length; i < l; i++) { + var index = indexOf.call(names, deps[i]); + if (index === -1) { + names.push(deps[i]); + indices.push([i]); + } + else { + indices[index].push(i); + } + } + return { names: names, indices: indices }; +} + +var getOwnPropertyDescriptor = true; +try { + Object.getOwnPropertyDescriptor({ a: 0 }, 'a'); +} +catch(e) { + getOwnPropertyDescriptor = false; +} + +// converts any module.exports object into an object ready for SystemJS.newModule +function getESModule(exports) { + var esModule = {}; + // don't trigger getters/setters in environments that support them + if (typeof exports == 'object' || typeof exports == 'function') { + if (getOwnPropertyDescriptor) { + var d; + for (var p in exports) + if (d = Object.getOwnPropertyDescriptor(exports, p)) + defineProperty(esModule, p, d); + } + else { + var hasOwnProperty = exports && exports.hasOwnProperty; + for (var p in exports) { + if (!hasOwnProperty || exports.hasOwnProperty(p)) + esModule[p] = exports[p]; + } + } + } + esModule['default'] = exports; + defineProperty(esModule, '__useDefault', { + value: true + }); + return esModule; +} + +function extend(a, b, prepend) { + for (var p in b) { + if (!prepend || !(p in a)) + a[p] = b[p]; + } + return a; +} + +// package configuration options +var packageProperties = ['main', 'format', 'defaultExtension', 'meta', 'map', 'basePath', 'depCache']; + +// meta first-level extends where: +// array + array appends +// object + object extends +// other properties replace +function extendMeta(a, b, prepend) { + for (var p in b) { + var val = b[p]; + if (!(p in a)) + a[p] = val; + else if (val instanceof Array && a[p] instanceof Array) + a[p] = [].concat(prepend ? val : a[p]).concat(prepend ? a[p] : val); + else if (typeof val == 'object' && val !== null && typeof a[p] == 'object') + a[p] = extend(extend({}, a[p]), val, prepend); + else if (!prepend) + a[p] = val; + } +} + +function warn(msg) { + if (this.warnings && typeof console != 'undefined' && console.warn) + console.warn(msg); +}// we define a __exec for globally-scoped execution +// used by module format implementations +var __exec; + +(function() { + + // System clobbering protection (mostly for Traceur) + var curSystem; + var callCounter = 0; + var curLoad; + function preExec(loader, load) { + if (callCounter++ == 0) + curSystem = __global.System; + __global.System = loader; + curLoad = load; + } + function postExec() { + if (--callCounter == 0) + __global.System = curSystem; + curLoad = undefined; + } + + // System.register, System.registerDynamic, AMD define pipeline + // if currently evalling code here, immediately reduce the registered entry against the load record + hook('pushRegister_', function() { + return function(register) { + if (!curLoad) + return false; + + this.reduceRegister_(curLoad, register); + return true; + }; + }); + + var hasBtoa = typeof btoa != 'undefined'; + + // used to support leading #!/usr/bin/env in scripts as supported in Node + var hashBangRegEx = /^\#\!.*/; + + function getSource(load) { + var lastLineIndex = load.source.lastIndexOf('\n'); + + // wrap ES formats with a System closure for System global encapsulation + var wrap = load.metadata.format == 'esm' || load.metadata.format == 'register' || load.metadata.bundle; + + return (wrap ? '(function(System) {' : '') + (load.metadata.format == 'cjs' ? load.source.replace(hashBangRegEx, '') : load.source) + (wrap ? '\n})(System);' : '') + // adds the sourceURL comment if not already present + + (load.source.substr(lastLineIndex, 15) != '\n//# sourceURL=' + ? '\n//# sourceURL=' + load.address + (load.metadata.sourceMap ? '!transpiled' : '') : '') + // add sourceMappingURL if load.metadata.sourceMap is set + + (load.metadata.sourceMap && hasBtoa && + '\n//# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(load.metadata.sourceMap))) || '') + } + + function evalExec(load) { + if (load.metadata.integrity) + throw new TypeError('Subresource integrity checking is not supported in Web Workers or Chrome Extensions.'); + try { + preExec(this, load); + new Function(getSource(load)).call(__global); + postExec(); + } + catch(e) { + postExec(); + throw addToError(e, 'Evaluating ' + load.address); + } + } + + // use script injection eval to get identical global script behaviour + if (typeof document != 'undefined' && document.getElementsByTagName) { + var head; + + var scripts = document.getElementsByTagName('script'); + $__curScript = scripts[scripts.length - 1]; + __exec = function(load) { + if (!this.globalEvaluationScope) + return evalExec.call(this, load); + + if (!head) + head = document.head || document.body || document.documentElement; + + var script = document.createElement('script'); + script.text = getSource(load); + var onerror = window.onerror; + var e; + window.onerror = function(_e) { + e = addToError(_e, 'Evaluating ' + load.address); + } + preExec(this, load); + + if (load.metadata.integrity) + script.setAttribute('integrity', load.metadata.integrity); + if (load.metadata.nonce) + script.setAttribute('nonce', load.metadata.nonce); + + head.appendChild(script); + head.removeChild(script); + postExec(); + window.onerror = onerror; + if (e) + throw e; + }; + } + + // global scoped eval for node + else if (typeof require != 'undefined') { + var vmModule = 'vm'; + var vm = require(vmModule); + __exec = function vmExec(load) { + if (!this.globalEvaluationScope) + return evalExec.call(this, load); + + if (load.metadata.integrity) + throw new TypeError('Subresource integrity checking is unavailable in Node.'); + try { + preExec(this, load); + vm.runInThisContext(getSource(load)); + postExec(); + } + catch(e) { + postExec(); + throw addToError(e.toString(), 'Evaluating ' + load.address); + } + }; + } + else { + __exec = evalExec; + } + +})();var absURLRegEx = /^[^\/]+:\/\//; + +function readMemberExpression(p, value) { + var pParts = p.split('.'); + while (pParts.length) + value = value[pParts.shift()]; + return value; +} + +var baseURLCache = {}; +function getBaseURLObj() { + if (baseURLCache[this.baseURL]) + return baseURLCache[this.baseURL]; + + // normalize baseURL if not already + if (this.baseURL[this.baseURL.length - 1] != '/') + this.baseURL += '/'; + + var baseURL = new URL(this.baseURL, baseURI); + + this.baseURL = baseURL.href; + + return (baseURLCache[this.baseURL] = baseURL); +} + +function getMapMatch(map, name) { + var bestMatch, bestMatchLength = 0; + + for (var p in map) { + if (name.substr(0, p.length) == p && (name.length == p.length || name[p.length] == '/')) { + var curMatchLength = p.split('/').length; + if (curMatchLength <= bestMatchLength) + continue; + bestMatch = p; + bestMatchLength = curMatchLength; + } + } + + return bestMatch; +} + +function setConditional(mode) { + this.set('@system-env', this.newModule({ + browser: isBrowser, + node: !!this._nodeRequire, + env: mode, + production: mode == 'production', + development: mode == 'development' + })); +} + +var baseURIObj = new URL(baseURI); + +hookConstructor(function(constructor) { + return function() { + constructor.call(this); + + // support baseURL + this.baseURL = baseURI.substr(0, baseURI.lastIndexOf('/') + 1); + + // support map + this.map = {}; + + // global behaviour flags + this.warnings = false; + this.defaultJSExtensions = false; + this.globalEvaluationScope = true; + this.pluginFirst = false; + + // by default load ".json" files as json + // leading * meta doesn't need normalization + // NB add this in next breaking release + // this.meta['*.json'] = { format: 'json' }; + + // Default settings for globalEvaluationScope: + // Disabled for WebWorker, Chrome Extensions and jsdom + if (isWorker + || isBrowser && window.chrome && window.chrome.extension + || isBrowser && navigator.userAgent.match(/^Node\.js/)) + this.globalEvaluationScope = false; + + // support the empty module, as a concept + this.set('@empty', this.newModule({})); + + setConditional.call(this, 'development'); + }; +}); + +// include the node require since we're overriding it +if (typeof require != 'undefined' && typeof process != 'undefined' && !process.browser) + SystemJSLoader.prototype._nodeRequire = require; + +var nodeCoreModules = ['assert', 'buffer', 'child_process', 'cluster', 'console', 'constants', + 'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http', 'https', 'module', 'net', 'os', 'path', + 'process', 'punycode', 'querystring', 'readline', 'repl', 'stream', 'string_decoder', 'sys', 'timers', + 'tls', 'tty', 'url', 'util', 'vm', 'zlib']; + +/* + Core SystemJS Normalization + + If a name is relative, we apply URL normalization to the page + If a name is an absolute URL, we leave it as-is + + Plain names (neither of the above) run through the map and paths + normalization phases. + + The paths normalization phase applies last (paths extension), which + defines the `decanonicalize` function and normalizes everything into + a URL. + */ +hook('normalize', function(normalize) { + return function(name, parentName) { + // first run map config + if (name[0] != '.' && name[0] != '/' && !name.match(absURLRegEx)) { + var mapMatch = getMapMatch(this.map, name); + if (mapMatch) + name = this.map[mapMatch] + name.substr(mapMatch.length); + } + + // dynamically load node-core modules when requiring `@node/fs` for example + if (name.substr(0, 6) == '@node/' && nodeCoreModules.indexOf(name.substr(6)) != -1) { + if (!this._nodeRequire) + throw new TypeError('Error loading ' + name + '. Can only load node core modules in Node.'); + this.set(name, this.newModule(getESModule(this._nodeRequire(name.substr(6))))); + } + + // relative URL-normalization + if (name[0] == '.' || name[0] == '/') { + if (parentName) + name = new URL(name, parentName.replace(/#/g, '%05')).href.replace(/%05/g, '#'); + else + name = new URL(name, baseURIObj).href; + } + + // if the module is in the registry already, use that + if (this.has(name)) + return name; + + if (name.match(absURLRegEx)) { + // defaultJSExtensions backwards compatibility + if (this.defaultJSExtensions && name.substr(name.length - 3, 3) != '.js') + name += '.js'; + return name; + } + + // applyPaths implementation provided from ModuleLoader system.js source + name = applyPaths(this.paths, name) || name; + + // defaultJSExtensions backwards compatibility + if (this.defaultJSExtensions && name.substr(name.length - 3, 3) != '.js') + name += '.js'; + + // ./x, /x -> page-relative + if (name[0] == '.' || name[0] == '/') + return new URL(name, baseURIObj).href; + // x -> baseURL-relative + else + return new URL(name, getBaseURLObj.call(this)).href; + }; +}); + +// percent encode just '#' in urls if using HTTP requests +var httpRequest = typeof XMLHttpRequest != 'undefined'; +hook('locate', function(locate) { + return function(load) { + return Promise.resolve(locate.call(this, load)) + .then(function(address) { + if (httpRequest) + return address.replace(/#/g, '%23'); + return address; + }); + }; +}); + +/* + * Fetch with authorization + */ +hook('fetch', function() { + return function(load) { + return new Promise(function(resolve, reject) { + fetchTextFromURL(load.address, load.metadata.authorization, resolve, reject); + }); + }; +}); + +/* + __useDefault + + When a module object looks like: + newModule( + __useDefault: true, + default: 'some-module' + }) + + Then importing that module provides the 'some-module' + result directly instead of the full module. + + Useful for eg module.exports = function() {} +*/ +hook('import', function(systemImport) { + return function(name, parentName, parentAddress) { + if (parentName && parentName.name) + warn.call(this, 'SystemJS.import(name, { name: parentName }) is deprecated for SystemJS.import(name, parentName), while importing ' + name + ' from ' + parentName.name); + return systemImport.call(this, name, parentName, parentAddress).then(function(module) { + return module.__useDefault ? module['default'] : module; + }); + }; +}); + +/* + * Allow format: 'detect' meta to enable format detection + */ +hook('translate', function(systemTranslate) { + return function(load) { + if (load.metadata.format == 'detect') + load.metadata.format = undefined; + return systemTranslate.call(this, load); + }; +}); + + +/* + * JSON format support + * + * Supports loading JSON files as a module format itself + * + * Usage: + * + * SystemJS.config({ + * meta: { + * '*.json': { format: 'json' } + * } + * }); + * + * Module is returned as if written: + * + * export default {JSON} + * + * No named exports are provided + * + * Files ending in ".json" are treated as json automatically by SystemJS + */ +hook('instantiate', function(instantiate) { + return function(load) { + if (load.metadata.format == 'json' && !this.builder) { + var entry = load.metadata.entry = createEntry(); + entry.deps = []; + entry.execute = function() { + try { + return JSON.parse(load.source); + } + catch(e) { + throw new Error("Invalid JSON file " + load.name); + } + }; + } + }; +}) + +/* + Extend config merging one deep only + + loader.config({ + some: 'random', + config: 'here', + deep: { + config: { too: 'too' } + } + }); + + <=> + + loader.some = 'random'; + loader.config = 'here' + loader.deep = loader.deep || {}; + loader.deep.config = { too: 'too' }; + + + Normalizes meta and package configs allowing for: + + SystemJS.config({ + meta: { + './index.js': {} + } + }); + + To become + + SystemJS.meta['https://thissite.com/index.js'] = {}; + + For easy normalization canonicalization with latest URL support. + +*/ +SystemJSLoader.prototype.env = 'development'; + +SystemJSLoader.prototype.config = function(cfg) { + var loader = this; + + if ('warnings' in cfg) + loader.warnings = cfg.warnings; + + // always configure baseURL first + if (cfg.baseURL) { + var hasConfig = false; + function checkHasConfig(obj) { + for (var p in obj) + return true; + } + if (checkHasConfig(loader.packages) || checkHasConfig(loader.meta) || checkHasConfig(loader.depCache) || checkHasConfig(loader.bundles) || checkHasConfig(loader.packageConfigPaths)) + throw new TypeError('Incorrect configuration order. The baseURL must be configured with the first SystemJS.config call.'); + + loader.baseURL = cfg.baseURL; + + // sanitize baseURL + getBaseURLObj.call(loader); + } + + if (cfg.defaultJSExtensions) { + loader.defaultJSExtensions = cfg.defaultJSExtensions; + warn.call(loader, 'The defaultJSExtensions configuration option is deprecated, use packages configuration instead.'); + } + + if (cfg.pluginFirst) + loader.pluginFirst = cfg.pluginFirst; + + if (cfg.env) { + if (cfg.env != 'production' && cfg.env != 'development') + throw new TypeError('The config environment must be set to "production" or "development".'); + setConditional.call(loader, cfg.env); + } + + if (cfg.paths) { + for (var p in cfg.paths) + loader.paths[p] = cfg.paths[p]; + } + + function noJSDecanonicalize(name) { + var normalized = loader.decanonicalize(name); + if (loader.defaultJSExtensions && name.substr(name.length - 3, 3) != '.js' && normalized.substr(normalized.length - 3, 3) == '.js') + return normalized.substr(0, normalized.length - 3); + return normalized; + } + + if (cfg.map) { + var objMaps = ''; + for (var p in cfg.map) { + var v = cfg.map[p]; + + // object map backwards-compat into packages configuration + if (typeof v !== 'string') { + objMaps += (objMaps.length ? ', ' : '') + '"' + p + '"'; + + var normalized = noJSDecanonicalize(p); + + // if a package main, revert it + var pkgMatch = ''; + for (var pkg in loader.packages) { + if (normalized.substr(0, pkg.length) == pkg + && (!normalized[pkg.length] || normalized[pkg.length] == '/') + && pkgMatch.split('/').length < pkg.split('/').length) + pkgMatch = pkg; + } + if (pkgMatch && loader.packages[pkgMatch].main) + normalized = normalized.substr(0, normalized.length - loader.packages[pkgMatch].main.length - 1); + + var pkg = loader.packages[normalized] = loader.packages[normalized] || {}; + pkg.map = v; + } + else { + loader.map[p] = v; + } + } + if (objMaps) + warn.call(loader, 'The map configuration for ' + objMaps + ' uses object submaps, which is deprecated in global map.\nUpdate this to use package contextual map with configs like SystemJS.config({ packages: { "' + p + '": { map: {...} } } }).'); + } + + if (cfg.packageConfigPaths) { + var packageConfigPaths = []; + for (var i = 0; i < cfg.packageConfigPaths.length; i++) { + var path = cfg.packageConfigPaths[i]; + var packageLength = Math.max(path.lastIndexOf('*') + 1, path.lastIndexOf('/')); + var normalized = noJSDecanonicalize(path.substr(0, packageLength) + '/'); + normalized = normalized.substr(0, normalized.length - 1) + path.substr(packageLength); + packageConfigPaths[i] = normalized; + } + loader.packageConfigPaths = packageConfigPaths; + } + + if (cfg.bundles) { + for (var p in cfg.bundles) { + var bundle = []; + for (var i = 0; i < cfg.bundles[p].length; i++) + bundle.push(noJSDecanonicalize(cfg.bundles[p][i])); + loader.bundles[p] = bundle; + } + } + + if (cfg.packages) { + for (var p in cfg.packages) { + if (p.match(/^([^\/]+:)?\/\/$/)) + throw new TypeError('"' + p + '" is not a valid package name.'); + + // trailing slash allows paths matches here + var prop = noJSDecanonicalize(p + (p[p.length - 1] != '/' ? '/' : '')); + + // allow trailing '/' in package config + if (prop[prop.length - 1] == '/') + prop = prop.substr(0, prop.length - 1); + + loader.packages[prop] = loader.packages[prop] || {}; + + // meta backwards compatibility + if (cfg.packages[p].modules) { + warn.call(loader, 'Package ' + p + ' is configured with "modules", which is deprecated as it has been renamed to "meta".'); + cfg.packages[p].meta = cfg.packages[p].modules; + delete cfg.packages[p].modules; + } + + for (var q in cfg.packages[p]) + if (indexOf.call(packageProperties, q) == -1) + warn.call(loader, '"' + q + '" is not a valid package configuration option in package ' + p); + + extendMeta(loader.packages[prop], cfg.packages[p]); + } + } + + for (var c in cfg) { + var v = cfg[c]; + var normalizeProp = false; + + if (c == 'baseURL' || c == 'map' || c == 'packages' || c == 'bundles' || c == 'paths' || c == 'warnings' || c == 'packageConfigPaths') + continue; + + if (typeof v != 'object' || v instanceof Array) { + loader[c] = v; + } + else { + loader[c] = loader[c] || {}; + + if (c == 'meta' || c == 'depCache') + normalizeProp = true; + + for (var p in v) { + // base-level wildcard meta does not normalize to retain catch-all quality + if (c == 'meta' && p[0] == '*') + loader[c][p] = v[p]; + else if (normalizeProp) + loader[c][noJSDecanonicalize(p)] = v[p]; + else + loader[c][p] = v[p]; + } + } + } +};/* + * Package Configuration Extension + * + * Example: + * + * SystemJS.packages = { + * jquery: { + * basePath: 'lib', // optionally only use a subdirectory within the package + * main: 'index.js', // when not set, package name is requested directly + * format: 'amd', + * defaultExtension: 'ts', // defaults to 'js', can be set to false + * modules: { + * '*.ts': { + * loader: 'typescript' + * }, + * 'vendor/sizzle.js': { + * format: 'global' + * } + * }, + * map: { + * // map internal require('sizzle') to local require('./vendor/sizzle') + * sizzle: './vendor/sizzle.js', + * // map any internal or external require of 'jquery/vendor/another' to 'another/index.js' + * './vendor/another.js': './another/index.js', + * // test.js / test -> lib/test.js + * './test.js': './lib/test.js', + * + * // environment-specific map configurations + * './index.js': { + * '~browser': './index-node.js' + * } + * }, + * // allows for setting package-prefixed depCache + * // keys are normalized module names relative to the package itself + * depCache: { + * // import 'package/index.js' loads in parallel package/lib/test.js,package/vendor/sizzle.js + * './index.js': ['./test'], + * './test.js': ['external-dep'], + * 'external-dep/path.js': ['./another.js'] + * } + * } + * }; + * + * Then: + * import 'jquery' -> jquery/index.js + * import 'jquery/submodule' -> jquery/submodule.js + * import 'jquery/submodule.ts' -> jquery/submodule.ts loaded as typescript + * import 'jquery/vendor/another' -> another/index.js + * + * Detailed Behaviours + * - main can have a leading "./" can be added optionally + * - map and defaultExtension are applied to the main + * - defaultExtension adds the extension only if the exact extension is not present + * - defaultJSExtensions applies after map when defaultExtension is not set + * - if a meta value is available for a module, map and defaultExtension are skipped + * - like global map, package map also applies to subpaths (sizzle/x, ./vendor/another/sub) + * - condition module map is '@env' module in package or '@system-env' globally + * - map targets support conditional interpolation ('./x': './x.#{|env}.js') + * - internal package map targets cannot use boolean conditionals + * + * In addition, the following modules properties will be allowed to be package + * -relative as well in the package module config: + * + * - loader + * - alias + * + * + * Package Configuration Loading + * + * Not all packages may already have their configuration present in the System config + * For these cases, a list of packageConfigPaths can be provided, which when matched against + * a request, will first request a ".json" file by the package name to derive the package + * configuration from. This allows dynamic loading of non-predetermined code, a key use + * case in SystemJS. + * + * Example: + * + * SystemJS.packageConfigPaths = ['packages/test/package.json', 'packages/*.json']; + * + * // will first request 'packages/new-package/package.json' for the package config + * // before completing the package request to 'packages/new-package/path' + * SystemJS.import('packages/new-package/path'); + * + * // will first request 'packages/test/package.json' before the main + * SystemJS.import('packages/test'); + * + * When a package matches packageConfigPaths, it will always send a config request for + * the package configuration. + * The package name itself is taken to be the match up to and including the last wildcard + * or trailing slash. + * The most specific package config path will be used. + * Any existing package configurations for the package will deeply merge with the + * package config, with the existing package configurations taking preference. + * To opt-out of the package configuration request for a package that matches + * packageConfigPaths, use the { configured: true } package config option. + * + */ +(function() { + + hookConstructor(function(constructor) { + return function() { + constructor.call(this); + this.packages = {}; + this.packageConfigPaths = {}; + }; + }); + + function getPackage(loader, normalized) { + // use most specific package + var curPkg, curPkgLen = 0, pkgLen; + for (var p in loader.packages) { + if (normalized.substr(0, p.length) === p && (normalized.length === p.length || normalized[p.length] === '/')) { + pkgLen = p.split('/').length; + if (pkgLen > curPkgLen) { + curPkg = p; + curPkgLen = pkgLen; + } + } + } + return curPkg; + } + + function getBasePath(pkg) { + // sanitize basePath + var basePath = pkg.basePath && pkg.basePath != '.' ? pkg.basePath : ''; + if (basePath) { + if (basePath.substr(0, 2) == './') + basePath = basePath.substr(2); + if (basePath[basePath.length - 1] != '/') + basePath += '/'; + } + return basePath; + } + + function addDefaultExtension(loader, pkg, pkgName, basePath, subPath, skipExtensions) { + // don't apply extensions to folders or if defaultExtension = false + if (!subPath || subPath[subPath.length - 1] == '/' || skipExtensions || pkg.defaultExtension === false) + return subPath; + + // NB are you sure about this? + // skip if we have interpolation conditional syntax in subPath? + if (subPath.match(interpolationRegEx)) + return subPath; + + var metaMatch = false; + + // exact meta or meta with any content after the last wildcard skips extension + if (pkg.meta) + getMetaMatches(pkg.meta, subPath, function(metaPattern, matchMeta, matchDepth) { + if (matchDepth == 0 || metaPattern.lastIndexOf('*') != metaPattern.length - 1) + return metaMatch = true; + }); + + // exact global meta or meta with any content after the last wildcard skips extension + if (!metaMatch && loader.meta) + getMetaMatches(loader.meta, pkgName + '/' + basePath + subPath, function(metaPattern, matchMeta, matchDepth) { + if (matchDepth == 0 || metaPattern.lastIndexOf('*') != metaPattern.length - 1) + return metaMatch = true; + }); + + if (metaMatch) + return subPath; + + // work out what the defaultExtension is and add if not there already + // NB reconsider if default should really be ".js"? + var defaultExtension = '.' + (pkg.defaultExtension || 'js'); + if (subPath.substr(subPath.length - defaultExtension.length) != defaultExtension) + return subPath + defaultExtension; + else + return subPath; + } + + function applyPackageConfigSync(loader, pkg, pkgName, subPath, skipExtensions) { + // main + if (!subPath) { + if (pkg.main) + subPath = pkg.main.substr(0, 2) == './' ? pkg.main.substr(2) : pkg.main; + // also no submap if name is package itself (import 'pkg' -> 'path/to/pkg.js') + else + // NB can add a default package main convention here when defaultJSExtensions is deprecated + // if it becomes internal to the package then it would no longer be an exit path + return pkgName + (loader.defaultJSExtensions ? '.js' : ''); + } + + var basePath = getBasePath(pkg); + + // map config checking without then with extensions + if (pkg.map) { + var mapPath = './' + subPath; + + var mapMatch = getMapMatch(pkg.map, mapPath); + + // we then check map with the default extension adding + if (!mapMatch) { + mapPath = './' + addDefaultExtension(loader, pkg, pkgName, basePath, subPath, skipExtensions); + if (mapPath != './' + subPath) + mapMatch = getMapMatch(pkg.map, mapPath); + } + if (mapMatch) + return doMapSync(loader, pkg, pkgName, basePath, mapMatch, mapPath, skipExtensions); + } + + // normal package resolution + return pkgName + '/' + basePath + addDefaultExtension(loader, pkg, pkgName, basePath, subPath, skipExtensions); + } + + function doMapSync(loader, pkg, pkgName, basePath, mapMatch, path, skipExtensions) { + var mapped = pkg.map[mapMatch]; + + // ignore conditionals in sync + if (typeof mapped != 'string') + mapped = mapMatch = path; + + // package map to main / base-level + if (mapped == '.') + mapped = pkgName; + + // internal package map + else if (mapped.substr(0, 2) == './') + return pkgName + '/' + basePath + addDefaultExtension(loader, pkg, pkgName, basePath, mapped.substr(2) + path.substr(mapMatch.length), skipExtensions); + + // external map reference + return loader.normalizeSync(mapped + path.substr(mapMatch.length), pkgName + '/'); + } + + function applyPackageConfig(loader, pkg, pkgName, subPath, skipExtensions) { + // main + if (!subPath) { + if (pkg.main) + subPath = pkg.main.substr(0, 2) == './' ? pkg.main.substr(2) : pkg.main; + // also no submap if name is package itself (import 'pkg' -> 'path/to/pkg.js') + else + // NB can add a default package main convention here when defaultJSExtensions is deprecated + // if it becomes internal to the package then it would no longer be an exit path + return Promise.resolve(pkgName + (loader.defaultJSExtensions ? '.js' : '')); + } + + var basePath = getBasePath(pkg); + + // map config checking without then with extensions + var mapPath, mapMatch; + + if (pkg.map) { + mapPath = './' + subPath; + mapMatch = getMapMatch(pkg.map, mapPath); + + // we then check map with the default extension adding + if (!mapMatch) { + mapPath = './' + addDefaultExtension(loader, pkg, pkgName, basePath, subPath, skipExtensions); + if (mapPath != './' + subPath) + mapMatch = getMapMatch(pkg.map, mapPath); + } + } + + return (mapMatch ? doMap(loader, pkg, pkgName, basePath, mapMatch, mapPath, skipExtensions) : Promise.resolve()) + .then(function(mapped) { + if (mapped) + return Promise.resolve(mapped); + + // normal package resolution / fallback resolution for no conditional match + return Promise.resolve(pkgName + '/' + basePath + addDefaultExtension(loader, pkg, pkgName, basePath, subPath, skipExtensions)); + }); + } + + function doStringMap(loader, pkg, pkgName, basePath, mapMatch, mapped, path, skipExtensions) { + // NB the interpolation cases should strictly skip subsequent interpolation + + // package map to main / base-level + if (mapped == '.') + mapped = pkgName; + + // internal package map + else if (mapped.substr(0, 2) == './') + return Promise.resolve(pkgName + '/' + basePath + addDefaultExtension(loader, pkg, pkgName, basePath, mapped.substr(2) + path.substr(mapMatch.length), skipExtensions)) + .then(function(name) { + return interpolateConditional.call(loader, name, pkgName + '/'); + }); + + // external map reference + // NB deprecate the use of the second argument here -> should be fully global reference + return loader.normalize(mapped + path.substr(mapMatch.length), pkgName + '/'); + } + + function doMap(loader, pkg, pkgName, basePath, mapMatch, path, skipExtensions) { + var mapped = pkg.map[mapMatch]; + + if (typeof mapped == 'string') + return doStringMap(loader, pkg, pkgName, basePath, mapMatch, mapped, path, skipExtensions); + + // we use a special conditional syntax to allow the builder to handle conditional branch points further + if (loader.builder) + return Promise.resolve(pkgName + '/#:' + path); + + // map object -> conditional map + return loader['import'](pkg.map['@env'] || '@system-env', pkgName) + .then(function(env) { + // first map condition to match is used + for (var e in mapped) { + var negate = e[0] == '~'; + + var value = readMemberExpression(negate ? e.substr(1) : e, env); + + if (!negate && value || negate && !value) + return mapped[e]; + } + }) + .then(function(mapped) { + if (mapped) + return doStringMap(loader, pkg, pkgName, basePath, mapMatch, mapped, path, skipExtensions); + + // no environment match -> fallback to original subPath by returning undefined + }); + } + + // normalizeSync = decanonicalize + package resolution + SystemJSLoader.prototype.normalizeSync = SystemJSLoader.prototype.decanonicalize = SystemJSLoader.prototype.normalize; + + // decanonicalize must JUST handle package defaultExtension: false case when defaultJSExtensions is set + // to be deprecated! + hook('decanonicalize', function(decanonicalize) { + return function(name, parentName) { + var decanonicalized = decanonicalize.call(this, name, parentName); + + if (!this.defaultJSExtensions) + return decanonicalized; + + var pkgName = getPackage(this, decanonicalized); + + var defaultExtension = pkgName && this.packages[pkgName].defaultExtension; + + if (defaultExtension && (defaultExtension === false || defaultExtension != '.js') && name.substr(name.length - 3, 3) != '.js' && decanonicalized.substr(decanonicalized.length - 3, 3) == '.js') + decanonicalized = decanonicalized.substr(0, decanonicalized.length - 3); + + return decanonicalized; + }; + }); + + hook('normalizeSync', function(normalizeSync) { + return function(name, parentName, isPlugin) { + warn.call(this, 'SystemJS.normalizeSync has been deprecated for SystemJS.decanonicalize.'); + + var loader = this; + isPlugin = isPlugin === true; + + // apply contextual package map first + // (we assume the parent package config has already been loaded) + if (parentName) + var parentPackageName = getPackage(loader, parentName) || + loader.defaultJSExtensions && parentName.substr(parentName.length - 3, 3) == '.js' && + getPackage(loader, parentName.substr(0, parentName.length - 3)); + + var parentPackage = parentPackageName && loader.packages[parentPackageName]; + + // remove any parent basePath from parentName + if (parentPackage) { + var parentBasePath = getBasePath(parentPackage); + if (parentBasePath && parentName.substr(parentPackageName.length + 1, parentBasePath.length) == parentBasePath) + parentName = parentPackageName + parentName.substr(parentPackageName.length + parentBasePath.length); + } + + // ignore . since internal maps handled by standard package resolution + if (parentPackage && name[0] != '.') { + var parentMap = parentPackage.map; + var parentMapMatch = parentMap && getMapMatch(parentMap, name); + + if (parentMapMatch && typeof parentMap[parentMapMatch] == 'string') + return doMapSync(loader, parentPackage, parentPackageName, getBasePath(parentPackage), parentMapMatch, name, isPlugin); + } + + var defaultJSExtension = loader.defaultJSExtensions && name.substr(name.length - 3, 3) != '.js'; + + // apply map, core, paths, contextual package map + var normalized = normalizeSync.call(loader, name, parentName); + + // undo defaultJSExtension + if (defaultJSExtension && normalized.substr(normalized.length - 3, 3) != '.js') + defaultJSExtension = false; + if (defaultJSExtension) + normalized = normalized.substr(0, normalized.length - 3); + + var pkgConfigMatch = getPackageConfigMatch(loader, normalized); + var pkgName = pkgConfigMatch && pkgConfigMatch.packageName || getPackage(loader, normalized); + + if (!pkgName) + return normalized + (defaultJSExtension ? '.js' : ''); + + var subPath = normalized.substr(pkgName.length + 1); + + // allow for direct package name normalization with trailling "/" (no main) + // that is normalize('pkg/') does not apply main, while normalize('./', 'pkg/') does + if (!subPath && normalized.length == pkgName.length + 1 && name[0] != '.') + return pkgName + subPath; + + return applyPackageConfigSync(loader, loader.packages[pkgName] || {}, pkgName, subPath, isPlugin); + }; + }); + + hook('normalize', function(normalize) { + return function(name, parentName, isPlugin) { + var loader = this; + isPlugin = isPlugin === true; + + return Promise.resolve() + .then(function() { + // apply contextual package map first + // (we assume the parent package config has already been loaded) + if (parentName) + var parentPackageName = getPackage(loader, parentName) || + loader.defaultJSExtensions && parentName.substr(parentName.length - 3, 3) == '.js' && + getPackage(loader, parentName.substr(0, parentName.length - 3)); + + var parentPackage = parentPackageName && loader.packages[parentPackageName]; + + // remove any parent basePath from parentName + if (parentPackage) { + var parentBasePath = getBasePath(parentPackage); + if (parentBasePath && parentName.substr(parentPackageName.length + 1, parentBasePath.length) == parentBasePath) + parentName = parentPackageName + parentName.substr(parentPackageName.length + parentBasePath.length); + } + + // ignore . since internal maps handled by standard package resolution + if (parentPackage && name.substr(0, 2) != './') { + var parentMap = parentPackage.map; + var parentMapMatch = parentMap && getMapMatch(parentMap, name); + + if (parentMapMatch) + return doMap(loader, parentPackage, parentPackageName, parentBasePath, parentMapMatch, name, isPlugin); + } + + return Promise.resolve(); + }) + .then(function(mapped) { + if (mapped) + return mapped; + + var defaultJSExtension = loader.defaultJSExtensions && name.substr(name.length - 3, 3) != '.js'; + + // apply map, core, paths, contextual package map + var normalized = normalize.call(loader, name, parentName); + + // undo defaultJSExtension + if (defaultJSExtension && normalized.substr(normalized.length - 3, 3) != '.js') + defaultJSExtension = false; + if (defaultJSExtension) + normalized = normalized.substr(0, normalized.length - 3); + + var pkgConfigMatch = getPackageConfigMatch(loader, normalized); + var pkgName = pkgConfigMatch && pkgConfigMatch.packageName || getPackage(loader, normalized); + + if (!pkgName) + return Promise.resolve(normalized + (defaultJSExtension ? '.js' : '')); + + var pkg = loader.packages[pkgName]; + + // if package is already configured or not a dynamic config package, use existing package config + var isConfigured = pkg && (pkg.configured || !pkgConfigMatch); + return (isConfigured ? Promise.resolve(pkg) : loadPackageConfigPath(loader, pkgName, pkgConfigMatch.configPath)) + .then(function(pkg) { + var subPath = normalized.substr(pkgName.length + 1); + + // allow for direct package name normalization with trailling "/" (no main) + // that is normalize('pkg/') does not apply main, while normalize('./', 'pkg/') does + if (!subPath && normalized.length == pkgName.length + 1 && name[0] != '.') + return Promise.resolve(pkgName + subPath); + + return applyPackageConfig(loader, pkg, pkgName, subPath, isPlugin); + }); + }); + }; + }); + + // check if the given normalized name matches a packageConfigPath + // if so, loads the config + var packageConfigPaths = {}; + + // data object for quick checks against package paths + function createPkgConfigPathObj(path) { + var lastWildcard = path.lastIndexOf('*'); + var length = Math.max(lastWildcard + 1, path.lastIndexOf('/')); + return { + length: length, + // NB handle regex control character escapes or simply create a test function here + regEx: new RegExp('^(' + path.substr(0, length).replace(/\*/g, '[^\\/]+') + ')(\\/|$)'), + wildcard: lastWildcard != -1 + }; + } + + // most specific match wins + function getPackageConfigMatch(loader, normalized) { + var pkgName, exactMatch = false, configPath; + for (var i = 0; i < loader.packageConfigPaths.length; i++) { + var packageConfigPath = loader.packageConfigPaths[i]; + var p = packageConfigPaths[packageConfigPath] || (packageConfigPaths[packageConfigPath] = createPkgConfigPathObj(packageConfigPath)); + if (normalized.length < p.length) + continue; + var match = normalized.match(p.regEx); + if (match && (!pkgName || (!(exactMatch && p.wildcard) && pkgName.length < match[1].length))) { + pkgName = match[1]; + exactMatch = !p.wildcard; + configPath = pkgName + packageConfigPath.substr(p.length); + } + } + + if (!pkgName) + return; + + return { + packageName: pkgName, + configPath: configPath + }; + } + + function loadPackageConfigPath(loader, pkgName, pkgConfigPath) { + var configLoader = loader.pluginLoader || loader; + + // NB remove this when json is default + (configLoader.meta[pkgConfigPath] = configLoader.meta[pkgConfigPath] || {}).format = 'json'; + + return configLoader.load(pkgConfigPath) + .then(function() { + pkgConfig = configLoader.get(pkgConfigPath); + + var cfg = pkgConfig['default']; + + // support "systemjs" prefixing + if (cfg.systemjs) + cfg = cfg.systemjs; + + // modules backwards compatibility + if (cfg.modules) { + cfg.meta = cfg.modules; + warn.call(loader, 'Package config file ' + pkgConfigPath + ' is configured with "modules", which is deprecated as it has been renamed to "meta".'); + } + + // remove any non-system properties if generic config file (eg package.json) + for (var p in cfg) { + if (indexOf.call(packageProperties, p) == -1) + delete cfg[p]; + } + + // deeply-merge (to first level) config with any existing package config + var pkg = loader.packages[pkgName] = loader.packages[pkgName] || {}; + extendMeta(pkg, cfg, true); + + // support external depCache + var basePath = getBasePath(pkg); + if (cfg.depCache) { + for (var d in cfg.depCache) { + var dNormalized; + + if (d.substr(0, 2) == './') + dNormalized = pkgName + '/' + basePath + d.substr(2); + else + dNormalized = coreResolve.call(loader, d); + loader.depCache[dNormalized] = (loader.depCache[dNormalized] || []).concat(cfg.depCache[d]); + } + delete cfg.depCache; + } + + return pkg; + }); + } + + function getMetaMatches(pkgMeta, subPath, matchFn) { + // wildcard meta + var meta = {}; + var wildcardIndex; + for (var module in pkgMeta) { + // allow meta to start with ./ for flexibility + var dotRel = module.substr(0, 2) == './' ? './' : ''; + if (dotRel) + module = module.substr(2); + + wildcardIndex = module.indexOf('*'); + if (wildcardIndex === -1) + continue; + + if (module.substr(0, wildcardIndex) == subPath.substr(0, wildcardIndex) + && module.substr(wildcardIndex + 1) == subPath.substr(subPath.length - module.length + wildcardIndex + 1)) { + // alow match function to return true for an exit path + if (matchFn(module, pkgMeta[dotRel + module], module.split('/').length)) + return; + } + } + // exact meta + var exactMeta = pkgMeta[subPath] || pkgMeta['./' + subPath]; + if (exactMeta) + matchFn(exactMeta, exactMeta, 0); + } + + hook('locate', function(locate) { + return function(load) { + var loader = this; + return Promise.resolve(locate.call(this, load)) + .then(function(address) { + var pkgName = getPackage(loader, load.name); + if (pkgName) { + var pkg = loader.packages[pkgName]; + var basePath = getBasePath(pkg); + var subPath = load.name.substr(pkgName.length + basePath.length + 1); + + // format + if (pkg.format) + load.metadata.format = load.metadata.format || pkg.format; + + var meta = {}; + if (pkg.meta) { + var bestDepth = 0; + + // NB support a main shorthand in meta here? + getMetaMatches(pkg.meta, subPath, function(metaPattern, matchMeta, matchDepth) { + if (matchDepth > bestDepth) + bestDepth = matchDepth; + extendMeta(meta, matchMeta, matchDepth && bestDepth > matchDepth); + }); + + // allow alias and loader to be package-relative + if (meta.alias && meta.alias.substr(0, 2) == './') + meta.alias = pkgName + meta.alias.substr(1); + if (meta.loader && meta.loader.substr(0, 2) == './') + meta.loader = pkgName + meta.loader.substr(1); + extendMeta(load.metadata, meta); + } + } + + return address; + }); + }; + }); + +})(); +/* + * Script tag fetch + * + * When load.metadata.scriptLoad is true, we load via script tag injection. + */ +(function() { + + if (typeof document != 'undefined') + var head = document.getElementsByTagName('head')[0]; + + var curSystem; + + // if doing worker executing, this is set to the load record being executed + var workerLoad = null; + + // interactive mode handling method courtesy RequireJS + var ieEvents = head && (function() { + var s = document.createElement('script'); + var isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]'; + return s.attachEvent && !(s.attachEvent.toString && s.attachEvent.toString().indexOf('[native code') < 0) && !isOpera; + })(); + + // IE interactive-only part + // we store loading scripts array as { script: <script>, load: {...} } + var interactiveLoadingScripts = []; + var interactiveScript; + function getInteractiveScriptLoad() { + if (interactiveScript && interactiveScript.script.readyState === 'interactive') + return interactiveScript.load; + + for (var i = 0; i < interactiveLoadingScripts.length; i++) + if (interactiveLoadingScripts[i].script.readyState == 'interactive') { + interactiveScript = interactiveLoadingScripts[i]; + return interactiveScript.load; + } + } + + // System.register, System.registerDynamic, AMD define pipeline + // this is called by the above methods when they execute + // we then run the reduceRegister_ collection function either immediately + // if we are in IE and know the currently executing script (interactive) + // or later if we need to wait for the synchronous load callback to know the script + var loadingCnt = 0; + var registerQueue = []; + hook('pushRegister_', function(pushRegister) { + return function(register) { + // if using eval-execution then skip + if (pushRegister.call(this, register)) + return false; + + // if using worker execution, then we're done + if (workerLoad) + this.reduceRegister_(workerLoad, register); + + // detect if we know the currently executing load (IE) + // if so, immediately call reduceRegister + else if (ieEvents) + this.reduceRegister_(getInteractiveScriptLoad(), register); + + // otherwise, add to our execution queue + // to call reduceRegister on sync script load event + else if (loadingCnt) + registerQueue.push(register); + + // if we're not currently loading anything though + // then do the reduction against a null load + // (out of band named define or named register) + // note even in non-script environments, this catch is used + else + this.reduceRegister_(null, register); + + return true; + }; + }); + + function webWorkerImport(loader, load) { + return new Promise(function(resolve, reject) { + if (load.metadata.integrity) + reject(new Error('Subresource integrity checking is not supported in web workers.')); + + workerLoad = load; + try { + importScripts(load.address); + } + catch(e) { + workerLoad = null; + reject(e); + } + workerLoad = null; + + // if nothing registered, then something went wrong + if (!load.metadata.entry) + reject(new Error(load.address + ' did not call System.register or AMD define')); + + resolve(''); + }); + } + + // override fetch to use script injection + hook('fetch', function(fetch) { + return function(load) { + var loader = this; + + if (!load.metadata.scriptLoad || (!isBrowser && !isWorker)) + return fetch.call(this, load); + + if (isWorker) + return webWorkerImport(loader, load); + + return new Promise(function(resolve, reject) { + var s = document.createElement('script'); + + s.async = true; + + if (load.metadata.integrity) + s.setAttribute('integrity', load.metadata.integrity); + + if (ieEvents) { + s.attachEvent('onreadystatechange', complete); + interactiveLoadingScripts.push({ + script: s, + load: load + }); + } + else { + s.addEventListener('load', complete, false); + s.addEventListener('error', error, false); + } + + loadingCnt++; + + curSystem = __global.System; + + s.src = load.address; + head.appendChild(s); + + function complete(evt) { + if (s.readyState && s.readyState != 'loaded' && s.readyState != 'complete') + return; + + loadingCnt--; + + // complete call is sync on execution finish + // (in ie already done reductions) + if (!load.metadata.entry && !registerQueue.length) { + loader.reduceRegister_(load); + } + else if (!ieEvents) { + for (var i = 0; i < registerQueue.length; i++) + loader.reduceRegister_(load, registerQueue[i]); + registerQueue = []; + } + + cleanup(); + + // if nothing registered, then something went wrong + if (!load.metadata.entry && !load.metadata.bundle) + reject(new Error(load.name + ' did not call System.register or AMD define. If loading a global module configure the global name via the meta exports property for script injection support.')); + + resolve(''); + } + + function error(evt) { + cleanup(); + reject(new Error('Unable to load script ' + load.address)); + } + + function cleanup() { + __global.System = curSystem; + + if (s.detachEvent) { + s.detachEvent('onreadystatechange', complete); + for (var i = 0; i < interactiveLoadingScripts.length; i++) + if (interactiveLoadingScripts[i].script == s) { + if (interactiveScript && interactiveScript.script == s) + interactiveScript = null; + interactiveLoadingScripts.splice(i, 1); + } + } + else { + s.removeEventListener('load', complete, false); + s.removeEventListener('error', error, false); + } + + head.removeChild(s); + } + }); + }; + }); +})(); +/* + * Instantiate registry extension + * + * Supports Traceur System.register 'instantiate' output for loading ES6 as ES5. + * + * - Creates the loader.register function + * - Also supports metadata.format = 'register' in instantiate for anonymous register modules + * - Also supports metadata.deps, metadata.execute and metadata.executingRequire + * for handling dynamic modules alongside register-transformed ES6 modules + * + * + * The code here replicates the ES6 linking groups algorithm to ensure that + * circular ES6 compiled into System.register can work alongside circular AMD + * and CommonJS, identically to the actual ES6 loader. + * + */ + + +/* + * Registry side table entries in loader.defined + * Registry Entry Contains: + * - name + * - deps + * - declare for declarative modules + * - execute for dynamic modules, different to declarative execute on module + * - executingRequire indicates require drives execution for circularity of dynamic modules + * - declarative optional boolean indicating which of the above + * + * Can preload modules directly on SystemJS.defined['my/module'] = { deps, execute, executingRequire } + * + * Then the entry gets populated with derived information during processing: + * - normalizedDeps derived from deps, created in instantiate + * - groupIndex used by group linking algorithm + * - evaluated indicating whether evaluation has happend + * - module the module record object, containing: + * - exports actual module exports + * + * For dynamic we track the es module with: + * - esModule actual es module value + * - esmExports whether to extend the esModule with named exports + * + * Then for declarative only we track dynamic bindings with the 'module' records: + * - name + * - exports + * - setters declarative setter functions + * - dependencies, module records of dependencies + * - importers, module records of dependents + * + * After linked and evaluated, entries are removed, declarative module records remain in separate + * module binding table + * + */ + +var leadingCommentAndMetaRegEx = /^\s*(\/\*[^\*]*(\*(?!\/)[^\*]*)*\*\/|\s*\/\/[^\n]*|\s*"[^"]+"\s*;?|\s*'[^']+'\s*;?)*\s*/; +function detectRegisterFormat(source) { + var leadingCommentAndMeta = source.match(leadingCommentAndMetaRegEx); + return leadingCommentAndMeta && source.substr(leadingCommentAndMeta[0].length, 15) == 'System.register'; +} + +function createEntry() { + return { + name: null, + deps: null, + originalIndices: null, + declare: null, + execute: null, + executingRequire: false, + declarative: false, + normalizedDeps: null, + groupIndex: null, + evaluated: false, + module: null, + esModule: null, + esmExports: false + }; +} + +(function() { + + /* + * There are two variations of System.register: + * 1. System.register for ES6 conversion (2-3 params) - System.register([name, ]deps, declare) + * see https://github.com/ModuleLoader/es6-module-loader/wiki/System.register-Explained + * + * 2. System.registerDynamic for dynamic modules (3-4 params) - System.registerDynamic([name, ]deps, executingRequire, execute) + * the true or false statement + * + * this extension implements the linking algorithm for the two variations identical to the spec + * allowing compiled ES6 circular references to work alongside AMD and CJS circular references. + * + */ + SystemJSLoader.prototype.register = function(name, deps, declare) { + if (typeof name != 'string') { + declare = deps; + deps = name; + name = null; + } + + // dynamic backwards-compatibility + // can be deprecated eventually + if (typeof declare == 'boolean') + return this.registerDynamic.apply(this, arguments); + + var entry = createEntry(); + // ideally wouldn't apply map config to bundle names but + // dependencies go through map regardless so we can't restrict + // could reconsider in shift to new spec + entry.name = name && (this.decanonicalize || this.normalize).call(this, name); + entry.declarative = true; + entry.deps = deps; + entry.declare = declare; + + this.pushRegister_({ + amd: false, + entry: entry + }); + }; + SystemJSLoader.prototype.registerDynamic = function(name, deps, declare, execute) { + if (typeof name != 'string') { + execute = declare; + declare = deps; + deps = name; + name = null; + } + + // dynamic + var entry = createEntry(); + entry.name = name && (this.decanonicalize || this.normalize).call(this, name); + entry.deps = deps; + entry.execute = execute; + entry.executingRequire = declare; + + this.pushRegister_({ + amd: false, + entry: entry + }); + }; + hook('reduceRegister_', function() { + return function(load, register) { + if (!register) + return; + + var entry = register.entry; + var curMeta = load && load.metadata; + + // named register + if (entry.name) { + if (!(entry.name in this.defined)) + this.defined[entry.name] = entry; + + if (curMeta) + curMeta.bundle = true; + } + // anonymous register + if (!entry.name || load && entry.name == load.name) { + if (!curMeta) + throw new TypeError('Unexpected anonymous System.register call.'); + if (curMeta.entry) { + if (curMeta.format == 'register') + throw new Error('Multiple anonymous System.register calls in module ' + load.name + '. If loading a bundle, ensure all the System.register calls are named.'); + else + throw new Error('Module ' + load.name + ' interpreted as ' + curMeta.format + ' module format, but called System.register.'); + } + if (!curMeta.format) + curMeta.format = 'register'; + curMeta.entry = entry; + } + }; + }); + + hookConstructor(function(constructor) { + return function() { + constructor.call(this); + + this.defined = {}; + this._loader.moduleRecords = {}; + }; + }); + + function buildGroups(entry, loader, groups) { + groups[entry.groupIndex] = groups[entry.groupIndex] || []; + + if (indexOf.call(groups[entry.groupIndex], entry) != -1) + return; + + groups[entry.groupIndex].push(entry); + + for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { + var depName = entry.normalizedDeps[i]; + var depEntry = loader.defined[depName]; + + // not in the registry means already linked / ES6 + if (!depEntry || depEntry.evaluated) + continue; + + // now we know the entry is in our unlinked linkage group + var depGroupIndex = entry.groupIndex + (depEntry.declarative != entry.declarative); + + // the group index of an entry is always the maximum + if (depEntry.groupIndex === null || depEntry.groupIndex < depGroupIndex) { + + // if already in a group, remove from the old group + if (depEntry.groupIndex !== null) { + groups[depEntry.groupIndex].splice(indexOf.call(groups[depEntry.groupIndex], depEntry), 1); + + // if the old group is empty, then we have a mixed depndency cycle + if (groups[depEntry.groupIndex].length == 0) + throw new Error("Mixed dependency cycle detected"); + } + + depEntry.groupIndex = depGroupIndex; + } + + buildGroups(depEntry, loader, groups); + } + } + + function link(name, loader) { + var startEntry = loader.defined[name]; + + // skip if already linked + if (startEntry.module) + return; + + startEntry.groupIndex = 0; + + var groups = []; + + buildGroups(startEntry, loader, groups); + + var curGroupDeclarative = !!startEntry.declarative == groups.length % 2; + for (var i = groups.length - 1; i >= 0; i--) { + var group = groups[i]; + for (var j = 0; j < group.length; j++) { + var entry = group[j]; + + // link each group + if (curGroupDeclarative) + linkDeclarativeModule(entry, loader); + else + linkDynamicModule(entry, loader); + } + curGroupDeclarative = !curGroupDeclarative; + } + } + + // module binding records + function Module() {} + defineProperty(Module, 'toString', { + value: function() { + return 'Module'; + } + }); + + function getOrCreateModuleRecord(name, moduleRecords) { + return moduleRecords[name] || (moduleRecords[name] = { + name: name, + dependencies: [], + exports: new Module(), // start from an empty module and extend + importers: [] + }); + } + + function linkDeclarativeModule(entry, loader) { + // only link if already not already started linking (stops at circular) + if (entry.module) + return; + + var moduleRecords = loader._loader.moduleRecords; + var module = entry.module = getOrCreateModuleRecord(entry.name, moduleRecords); + var exports = entry.module.exports; + + var declaration = entry.declare.call(__global, function(name, value) { + module.locked = true; + + if (typeof name == 'object') { + for (var p in name) + exports[p] = name[p]; + } + else { + exports[name] = value; + } + + for (var i = 0, l = module.importers.length; i < l; i++) { + var importerModule = module.importers[i]; + if (!importerModule.locked) { + var importerIndex = indexOf.call(importerModule.dependencies, module); + importerModule.setters[importerIndex](exports); + } + } + + module.locked = false; + return value; + }, entry.name); + + module.setters = declaration.setters; + module.execute = declaration.execute; + + if (!module.setters || !module.execute) { + throw new TypeError('Invalid System.register form for ' + entry.name); + } + + // now link all the module dependencies + for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { + var depName = entry.normalizedDeps[i]; + var depEntry = loader.defined[depName]; + var depModule = moduleRecords[depName]; + + // work out how to set depExports based on scenarios... + var depExports; + + if (depModule) { + depExports = depModule.exports; + } + // dynamic, already linked in our registry + else if (depEntry && !depEntry.declarative) { + depExports = depEntry.esModule; + } + // in the loader registry + else if (!depEntry) { + depExports = loader.get(depName); + } + // we have an entry -> link + else { + linkDeclarativeModule(depEntry, loader); + depModule = depEntry.module; + depExports = depModule.exports; + } + + // only declarative modules have dynamic bindings + if (depModule && depModule.importers) { + depModule.importers.push(module); + module.dependencies.push(depModule); + } + else { + module.dependencies.push(null); + } + + // run setters for all entries with the matching dependency name + var originalIndices = entry.originalIndices[i]; + for (var j = 0, len = originalIndices.length; j < len; ++j) { + var index = originalIndices[j]; + if (module.setters[index]) { + module.setters[index](depExports); + } + } + } + } + + // An analog to loader.get covering execution of all three layers (real declarative, simulated declarative, simulated dynamic) + function getModule(name, loader) { + var exports; + var entry = loader.defined[name]; + + if (!entry) { + exports = loader.get(name); + if (!exports) + throw new Error('Unable to load dependency ' + name + '.'); + } + + else { + if (entry.declarative) + ensureEvaluated(name, [], loader); + + else if (!entry.evaluated) + linkDynamicModule(entry, loader); + + exports = entry.module.exports; + } + + if ((!entry || entry.declarative) && exports && exports.__useDefault) + return exports['default']; + + return exports; + } + + function linkDynamicModule(entry, loader) { + if (entry.module) + return; + + var exports = {}; + + var module = entry.module = { exports: exports, id: entry.name }; + + // AMD requires execute the tree first + if (!entry.executingRequire) { + for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { + var depName = entry.normalizedDeps[i]; + // we know we only need to link dynamic due to linking algorithm + var depEntry = loader.defined[depName]; + if (depEntry) + linkDynamicModule(depEntry, loader); + } + } + + // now execute + entry.evaluated = true; + var output = entry.execute.call(__global, function(name) { + for (var i = 0, l = entry.deps.length; i < l; i++) { + if (entry.deps[i] != name) + continue; + return getModule(entry.normalizedDeps[i], loader); + } + throw new Error('Module ' + name + ' not declared as a dependency.'); + }, exports, module); + + if (output) + module.exports = output; + + // create the esModule object, which allows ES6 named imports of dynamics + exports = module.exports; + + // __esModule flag treats as already-named + if (exports && exports.__esModule) + entry.esModule = exports; + // set module as 'default' export, then fake named exports by iterating properties + else if (entry.esmExports && exports !== __global) + entry.esModule = getESModule(exports); + // just use the 'default' export + else + entry.esModule = { 'default': exports }; + } + + /* + * Given a module, and the list of modules for this current branch, + * ensure that each of the dependencies of this module is evaluated + * (unless one is a circular dependency already in the list of seen + * modules, in which case we execute it) + * + * Then we evaluate the module itself depth-first left to right + * execution to match ES6 modules + */ + function ensureEvaluated(moduleName, seen, loader) { + var entry = loader.defined[moduleName]; + + // if already seen, that means it's an already-evaluated non circular dependency + if (!entry || entry.evaluated || !entry.declarative) + return; + + // this only applies to declarative modules which late-execute + + seen.push(moduleName); + + for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) { + var depName = entry.normalizedDeps[i]; + if (indexOf.call(seen, depName) == -1) { + if (!loader.defined[depName]) + loader.get(depName); + else + ensureEvaluated(depName, seen, loader); + } + } + + if (entry.evaluated) + return; + + entry.evaluated = true; + entry.module.execute.call(__global); + } + + // override the delete method to also clear the register caches + hook('delete', function(del) { + return function(name) { + delete this._loader.moduleRecords[name]; + delete this.defined[name]; + return del.call(this, name); + }; + }); + + hook('fetch', function(fetch) { + return function(load) { + if (this.defined[load.name]) { + load.metadata.format = 'defined'; + return ''; + } + + if (load.metadata.format == 'register' && !load.metadata.authorization && load.metadata.scriptLoad !== false) + load.metadata.scriptLoad = true; + + load.metadata.deps = load.metadata.deps || []; + + return fetch.call(this, load); + }; + }); + + hook('translate', function(translate) { + // we run the meta detection here (register is after meta) + return function(load) { + load.metadata.deps = load.metadata.deps || []; + return Promise.resolve(translate.call(this, load)).then(function(source) { + // run detection for register format + if (load.metadata.format == 'register' || !load.metadata.format && detectRegisterFormat(load.source)) + load.metadata.format = 'register'; + return source; + }); + }; + }); + + hook('instantiate', function(instantiate) { + return function(load) { + if (load.metadata.format == 'detect') + load.metadata.format = undefined; + + // assumes previous instantiate is sync + // (core json support) + instantiate.call(this, load); + + var loader = this; + + var entry; + + // first we check if this module has already been defined in the registry + if (loader.defined[load.name]) { + entry = loader.defined[load.name]; + // don't support deps for ES modules + if (!entry.declarative) + entry.deps = entry.deps.concat(load.metadata.deps); + } + + // picked up already by an anonymous System.register script injection + // or via the dynamic formats + else if (load.metadata.entry) { + entry = load.metadata.entry; + entry.deps = entry.deps.concat(load.metadata.deps); + } + + // Contains System.register calls + // (dont run bundles in the builder) + else if (!(loader.builder && load.metadata.bundle) + && (load.metadata.format == 'register' || load.metadata.format == 'esm' || load.metadata.format == 'es6')) { + + if (typeof __exec != 'undefined') + __exec.call(loader, load); + + if (!load.metadata.entry && !load.metadata.bundle) + throw new Error(load.name + ' detected as ' + load.metadata.format + ' but didn\'t execute.'); + + entry = load.metadata.entry; + + // support metadata deps for System.register + if (entry && load.metadata.deps) + entry.deps = entry.deps.concat(load.metadata.deps); + } + + // named bundles are just an empty module + if (!entry) { + entry = createEntry(); + entry.deps = load.metadata.deps; + entry.execute = function() {}; + } + + // place this module onto defined for circular references + loader.defined[load.name] = entry; + + var grouped = group(entry.deps); + + entry.deps = grouped.names; + entry.originalIndices = grouped.indices; + entry.name = load.name; + entry.esmExports = load.metadata.esmExports !== false; + + // first, normalize all dependencies + var normalizePromises = []; + for (var i = 0, l = entry.deps.length; i < l; i++) + normalizePromises.push(Promise.resolve(loader.normalize(entry.deps[i], load.name))); + + return Promise.all(normalizePromises).then(function(normalizedDeps) { + + entry.normalizedDeps = normalizedDeps; + + return { + deps: entry.deps, + execute: function() { + // recursively ensure that the module and all its + // dependencies are linked (with dependency group handling) + link(load.name, loader); + + // now handle dependency execution in correct order + ensureEvaluated(load.name, [], loader); + + // remove from the registry + loader.defined[load.name] = undefined; + + // return the defined module object + return loader.newModule(entry.declarative ? entry.module.exports : entry.esModule); + } + }; + }); + }; + }); +})(); +/* + * Extension to detect ES6 and auto-load Traceur or Babel for processing + */ +(function() { + // good enough ES6 module detection regex - format detections not designed to be accurate, but to handle the 99% use case + var esmRegEx = /(^\s*|[}\);\n]\s*)(import\s+(['"]|(\*\s+as\s+)?[^"'\(\)\n;]+\s+from\s+['"]|\{)|export\s+\*\s+from\s+["']|export\s+(\{|default|function|class|var|const|let|async\s+function))/; + + var traceurRuntimeRegEx = /\$traceurRuntime\s*\./; + var babelHelpersRegEx = /babelHelpers\s*\./; + + hook('translate', function(translate) { + return function(load) { + var loader = this; + return translate.call(loader, load) + .then(function(source) { + // detect & transpile ES6 + if (load.metadata.format == 'esm' || load.metadata.format == 'es6' || !load.metadata.format && loader.transpiler !== false && source.match(esmRegEx)) { + if (load.metadata.format == 'es6') + warn.call(loader, 'Module ' + load.name + ' has metadata setting its format to "es6", which is deprecated.\nThis should be updated to "esm".'); + + load.metadata.format = 'esm'; + + if (loader.transpiler === false) { + // we accept translation to esm for builds though to enable eg rollup optimizations + if (loader.builder) + return source; + throw new TypeError('Unable to dynamically transpile ES module as SystemJS.transpiler set to false.'); + } + + // setting _loader.loadedTranspiler = false tells the next block to + // do checks for setting transpiler metadata + loader._loader.loadedTranspiler = loader._loader.loadedTranspiler || false; + if (loader.pluginLoader) + loader.pluginLoader._loader.loadedTranspiler = loader._loader.loadedTranspiler || false; + + // do transpilation + return (loader._loader.transpilerPromise || ( + loader._loader.transpilerPromise = Promise.resolve( + __global[loader.transpiler == 'typescript' ? 'ts' : loader.transpiler] || (loader.pluginLoader || loader)['import'](loader.transpiler) + ))).then(function(transpiler) { + loader._loader.loadedTranspilerRuntime = true; + + // translate hooks means this is a transpiler plugin instead of a raw implementation + if (transpiler.translate) { + // if transpiler is the same as the plugin loader, then don't run twice + if (transpiler == load.metadata.loaderModule) + return load.source; + + return Promise.resolve(transpiler.translate.call(loader, load)) + .then(function(source) { + if (load.metadata.format == 'esm' && !loader.builder && detectRegisterFormat(source)) + load.metadata.format = 'register'; + return source; + }); + } + + // legacy builder support + if (loader.builder) + load.metadata.originalSource = load.source; + + // defined in es6-module-loader/src/transpile.js + return transpile.call(loader, load) + .then(function(source) { + // clear sourceMap as transpiler embeds it + load.metadata.sourceMap = undefined; + return source; + }); + }); + } + + // skip transpiler and transpiler runtime loading when transpiler is disabled + if (loader.transpiler === false) + return source; + + // load the transpiler correctly + if (loader._loader.loadedTranspiler === false && (loader.transpiler == 'traceur' || loader.transpiler == 'typescript' || loader.transpiler == 'babel') + && load.name == loader.normalizeSync(loader.transpiler)) { + + // always load transpiler as a global + if (source.length > 100 && !load.metadata.format) { + load.metadata.format = 'global'; + + if (loader.transpiler === 'traceur') + load.metadata.exports = 'traceur'; + if (loader.transpiler === 'typescript') + load.metadata.exports = 'ts'; + } + + loader._loader.loadedTranspiler = true; + } + + // load the transpiler runtime correctly + if (loader._loader.loadedTranspilerRuntime === false) { + if (load.name == loader.normalizeSync('traceur-runtime') + || load.name == loader.normalizeSync('babel/external-helpers*')) { + if (source.length > 100) + load.metadata.format = load.metadata.format || 'global'; + + loader._loader.loadedTranspilerRuntime = true; + } + } + + // detect transpiler runtime usage to load runtimes + if ((load.metadata.format == 'register' || load.metadata.bundle) && loader._loader.loadedTranspilerRuntime !== true) { + if (!__global.$traceurRuntime && load.source.match(traceurRuntimeRegEx)) { + loader._loader.loadedTranspilerRuntime = loader._loader.loadedTranspilerRuntime || false; + return loader['import']('traceur-runtime').then(function() { + return source; + }); + } + if (!__global.babelHelpers && load.source.match(babelHelpersRegEx)) { + loader._loader.loadedTranspilerRuntime = loader._loader.loadedTranspilerRuntime || false; + return loader['import']('babel/external-helpers').then(function() { + return source; + }); + } + } + + return source; + }); + }; + }); + +})(); +/* + SystemJS Global Format + + Supports + metadata.deps + metadata.globals + metadata.exports + + Without metadata.exports, detects writes to the global object. +*/ +var __globalName = typeof self != 'undefined' ? 'self' : 'global'; + +hook('fetch', function(fetch) { + return function(load) { + if (load.metadata.exports && !load.metadata.format) + load.metadata.format = 'global'; + + // A global with exports, no globals and no deps + // can be loaded via a script tag + if (load.metadata.format == 'global' && !load.metadata.authorization + && load.metadata.exports && !load.metadata.globals + && (!load.metadata.deps || load.metadata.deps.length == 0) + && load.metadata.scriptLoad !== false) + load.metadata.scriptLoad = true; + + return fetch.call(this, load); + }; +}); + +// ideally we could support script loading for globals, but the issue with that is that +// we can't do it with AMD support side-by-side since AMD support means defining the +// global define, and global support means not definining it, yet we don't have any hook +// into the "pre-execution" phase of a script tag being loaded to handle both cases +hook('instantiate', function(instantiate) { + return function(load) { + var loader = this; + + if (!load.metadata.format) + load.metadata.format = 'global'; + + // global is a fallback module format + if (load.metadata.format == 'global' && !load.metadata.registered) { + + var entry = createEntry(); + + load.metadata.entry = entry; + + entry.deps = []; + + for (var g in load.metadata.globals) + entry.deps.push(load.metadata.globals[g]); + + entry.execute = function(require, exports, module) { + + var globals; + if (load.metadata.globals) { + globals = {}; + for (var g in load.metadata.globals) + if (load.metadata.globals[g]) + globals[g] = require(load.metadata.globals[g]); + } + + var exportName = load.metadata.exports; + + if (exportName) + load.source += '\n' + __globalName + '["' + exportName + '"] = ' + exportName + ';'; + + var retrieveGlobal = loader.get('@@global-helpers').prepareGlobal(module.id, exportName, globals); + + __exec.call(loader, load); + + return retrieveGlobal(); + } + } + return instantiate.call(this, load); + }; +}); +hook('reduceRegister_', function(reduceRegister) { + return function(load, register) { + if (register || !load.metadata.exports) + return reduceRegister.call(this, load, register); + + load.metadata.format = 'global'; + var entry = load.metadata.entry = createEntry(); + entry.deps = load.metadata.deps; + var globalValue = readMemberExpression(load.metadata.exports, __global); + entry.execute = function() { + return globalValue; + }; + }; +}); + +hookConstructor(function(constructor) { + return function() { + var loader = this; + constructor.call(loader); + + var hasOwnProperty = Object.prototype.hasOwnProperty; + + // bare minimum ignores for IE8 + var ignoredGlobalProps = ['_g', 'sessionStorage', 'localStorage', 'clipboardData', 'frames', 'frameElement', 'external', 'mozAnimationStartTime', 'webkitStorageInfo', 'webkitIndexedDB']; + + var globalSnapshot; + + function forEachGlobal(callback) { + if (Object.keys) + Object.keys(__global).forEach(callback); + else + for (var g in __global) { + if (!hasOwnProperty.call(__global, g)) + continue; + callback(g); + } + } + + function forEachGlobalValue(callback) { + forEachGlobal(function(globalName) { + if (indexOf.call(ignoredGlobalProps, globalName) != -1) + return; + try { + var value = __global[globalName]; + } + catch (e) { + ignoredGlobalProps.push(globalName); + } + callback(globalName, value); + }); + } + + loader.set('@@global-helpers', loader.newModule({ + prepareGlobal: function(moduleName, exportName, globals) { + // disable module detection + var curDefine = __global.define; + + __global.define = undefined; + __global.exports = undefined; + if (__global.module && __global.module.exports) + __global.module = undefined; + + // set globals + var oldGlobals; + if (globals) { + oldGlobals = {}; + for (var g in globals) { + oldGlobals[g] = __global[g]; + __global[g] = globals[g]; + } + } + + // store a complete copy of the global object in order to detect changes + if (!exportName) { + globalSnapshot = {}; + + forEachGlobalValue(function(name, value) { + globalSnapshot[name] = value; + }); + } + + // return function to retrieve global + return function() { + var globalValue; + + if (exportName) { + globalValue = readMemberExpression(exportName, __global); + } + else { + var singleGlobal; + var multipleExports; + var exports = {}; + + forEachGlobalValue(function(name, value) { + if (globalSnapshot[name] === value) + return; + if (typeof value == 'undefined') + return; + exports[name] = value; + + if (typeof singleGlobal != 'undefined') { + if (!multipleExports && singleGlobal !== value) + multipleExports = true; + } + else { + singleGlobal = value; + } + }); + globalValue = multipleExports ? exports : singleGlobal; + } + + // revert globals + if (oldGlobals) { + for (var g in oldGlobals) + __global[g] = oldGlobals[g]; + } + __global.define = curDefine; + + return globalValue; + }; + } + })); + }; +}); +/* + SystemJS CommonJS Format +*/ +(function() { + // CJS Module Format + // require('...') || exports[''] = ... || exports.asd = ... || module.exports = ... + var cjsExportsRegEx = /(?:^\uFEFF?|[^$_a-zA-Z\xA0-\uFFFF.])(exports\s*(\[['"]|\.)|module(\.exports|\['exports'\]|\["exports"\])\s*(\[['"]|[=,\.]))/; + // RegEx adjusted from https://github.com/jbrantly/yabble/blob/master/lib/yabble.js#L339 + var cjsRequireRegEx = /(?:^\uFEFF?|[^$_a-zA-Z\xA0-\uFFFF."'])require\s*\(\s*("[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*')\s*\)/g; + var commentRegEx = /(^|[^\\])(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg; + + var stringRegEx = /("[^"\\\n\r]*(\\.[^"\\\n\r]*)*"|'[^'\\\n\r]*(\\.[^'\\\n\r]*)*')/g; + + function getCJSDeps(source) { + cjsRequireRegEx.lastIndex = commentRegEx.lastIndex = stringRegEx.lastIndex = 0; + + var deps = []; + + var match; + + // track string and comment locations for unminified source + var stringLocations = [], commentLocations = []; + + function inLocation(locations, match) { + for (var i = 0; i < locations.length; i++) + if (locations[i][0] < match.index && locations[i][1] > match.index) + return true; + return false; + } + + if (source.length / source.split('\n').length < 200) { + while (match = stringRegEx.exec(source)) + stringLocations.push([match.index, match.index + match[0].length]); + + while (match = commentRegEx.exec(source)) { + // only track comments not starting in strings + if (!inLocation(stringLocations, match)) + commentLocations.push([match.index, match.index + match[0].length]); + } + } + + while (match = cjsRequireRegEx.exec(source)) { + // ensure we're not within a string or comment location + if (!inLocation(stringLocations, match) && !inLocation(commentLocations, match)) { + var dep = match[1].substr(1, match[1].length - 2); + // skip cases like require('" + file + "') + if (dep.match(/"|'/)) + continue; + // trailing slash requires are removed as they don't map mains in SystemJS + if (dep[dep.length - 1] == '/') + dep = dep.substr(0, dep.length - 1); + deps.push(dep); + } + } + + return deps; + } + + hook('instantiate', function(instantiate) { + return function(load) { + var loader = this; + if (!load.metadata.format) { + cjsExportsRegEx.lastIndex = 0; + cjsRequireRegEx.lastIndex = 0; + if (cjsRequireRegEx.exec(load.source) || cjsExportsRegEx.exec(load.source)) + load.metadata.format = 'cjs'; + } + + if (load.metadata.format == 'cjs') { + var metaDeps = load.metadata.deps; + var deps = load.metadata.cjsRequireDetection === false ? [] : getCJSDeps(load.source); + + for (var g in load.metadata.globals) + if (load.metadata.globals[g]) + deps.push(load.metadata.globals[g]); + + var entry = createEntry(); + + load.metadata.entry = entry; + + entry.deps = deps; + entry.executingRequire = true; + entry.execute = function(_require, exports, module) { + function require(name) { + if (name[name.length - 1] == '/') + name = name.substr(0, name.length - 1); + return _require.apply(this, arguments); + } + + // ensure meta deps execute first + for (var i = 0; i < metaDeps.length; i++) + require(metaDeps[i]); + + // disable AMD detection + var define = __global.define; + __global.define = undefined; + + var pathVars = loader.get('@@cjs-helpers').getPathVars(module.id); + + __global.__cjsWrapper = { + exports: exports, + args: [require, exports, module, pathVars.filename, pathVars.dirname, __global, __global] + }; + + var globals = ''; + if (load.metadata.globals) { + for (var g in load.metadata.globals) + globals += 'var ' + g + ' = require("' + load.metadata.globals[g] + '");'; + } + + load.source = "(function(require, exports, module, __filename, __dirname, global, GLOBAL) {" + globals + + load.source + "\n}).apply(__cjsWrapper.exports, __cjsWrapper.args);"; + + __exec.call(loader, load); + + __global.__cjsWrapper = undefined; + __global.define = define; + }; + } + + return instantiate.call(loader, load); + }; + }); +})(); +hookConstructor(function(constructor) { + return function() { + var loader = this; + constructor.call(loader); + + if (typeof window != 'undefined' && typeof document != 'undefined' && window.location) + var windowOrigin = location.protocol + '//' + location.hostname + (location.port ? ':' + location.port : ''); + + loader.set('@@cjs-helpers', loader.newModule({ + getPathVars: function(moduleId) { + // remove any plugin syntax + var pluginIndex = moduleId.lastIndexOf('!'); + var filename; + if (pluginIndex != -1) + filename = moduleId.substr(0, pluginIndex); + else + filename = moduleId; + + var dirname = filename.split('/'); + dirname.pop(); + dirname = dirname.join('/'); + + if (filename.substr(0, 8) == 'file:///') { + filename = filename.substr(7); + dirname = dirname.substr(7); + + // on windows remove leading '/' + if (isWindows) { + filename = filename.substr(1); + dirname = dirname.substr(1); + } + } + else if (windowOrigin && filename.substr(0, windowOrigin.length) === windowOrigin) { + filename = filename.substr(windowOrigin.length); + dirname = dirname.substr(windowOrigin.length); + } + + return { + filename: filename, + dirname: dirname + }; + } + })) + }; +});/* + * AMD Helper function module + * Separated into its own file as this is the part needed for full AMD support in SFX builds + * NB since implementations have now diverged this can be merged back with amd.js + */ +hookConstructor(function(constructor) { + return function() { + var loader = this; + constructor.call(this); + + var commentRegEx = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg; + var cjsRequirePre = "(?:^|[^$_a-zA-Z\\xA0-\\uFFFF.])"; + var cjsRequirePost = "\\s*\\(\\s*(\"([^\"]+)\"|'([^']+)')\\s*\\)"; + var fnBracketRegEx = /\(([^\)]*)\)/; + var wsRegEx = /^\s+|\s+$/g; + + var requireRegExs = {}; + + function getCJSDeps(source, requireIndex) { + + // remove comments + source = source.replace(commentRegEx, ''); + + // determine the require alias + var params = source.match(fnBracketRegEx); + var requireAlias = (params[1].split(',')[requireIndex] || 'require').replace(wsRegEx, ''); + + // find or generate the regex for this requireAlias + var requireRegEx = requireRegExs[requireAlias] || (requireRegExs[requireAlias] = new RegExp(cjsRequirePre + requireAlias + cjsRequirePost, 'g')); + + requireRegEx.lastIndex = 0; + + var deps = []; + + var match; + while (match = requireRegEx.exec(source)) + deps.push(match[2] || match[3]); + + return deps; + } + + /* + AMD-compatible require + To copy RequireJS, set window.require = window.requirejs = loader.amdRequire + */ + function require(names, callback, errback, referer) { + // in amd, first arg can be a config object... we just ignore + if (typeof names == 'object' && !(names instanceof Array)) + return require.apply(null, Array.prototype.splice.call(arguments, 1, arguments.length - 1)); + + // amd require + if (typeof names == 'string' && typeof callback == 'function') + names = [names]; + if (names instanceof Array) { + var dynamicRequires = []; + for (var i = 0; i < names.length; i++) + dynamicRequires.push(loader['import'](names[i], referer)); + Promise.all(dynamicRequires).then(function(modules) { + if (callback) + callback.apply(null, modules); + }, errback); + } + + // commonjs require + else if (typeof names == 'string') { + var module = loader.get(loader.decanonicalize(names, referer)); + if (!module) + throw new Error('Module not already loaded loading "' + names + '" from "' + referer + '".'); + return module.__useDefault ? module['default'] : module; + } + + else + throw new TypeError('Invalid require'); + } + + function define(name, deps, factory) { + if (typeof name != 'string') { + factory = deps; + deps = name; + name = null; + } + if (!(deps instanceof Array)) { + factory = deps; + deps = ['require', 'exports', 'module'].splice(0, factory.length); + } + + if (typeof factory != 'function') + factory = (function(factory) { + return function() { return factory; } + })(factory); + + // in IE8, a trailing comma becomes a trailing undefined entry + if (deps[deps.length - 1] === undefined) + deps.pop(); + + // remove system dependencies + var requireIndex, exportsIndex, moduleIndex; + + if ((requireIndex = indexOf.call(deps, 'require')) != -1) { + + deps.splice(requireIndex, 1); + + // only trace cjs requires for non-named + // named defines assume the trace has already been done + if (!name) + deps = deps.concat(getCJSDeps(factory.toString(), requireIndex)); + } + + if ((exportsIndex = indexOf.call(deps, 'exports')) != -1) + deps.splice(exportsIndex, 1); + + if ((moduleIndex = indexOf.call(deps, 'module')) != -1) + deps.splice(moduleIndex, 1); + + function execute(req, exports, module) { + var depValues = []; + for (var i = 0; i < deps.length; i++) + depValues.push(req(deps[i])); + + module.uri = module.id; + + module.config = function() {}; + + // add back in system dependencies + if (moduleIndex != -1) + depValues.splice(moduleIndex, 0, module); + + if (exportsIndex != -1) + depValues.splice(exportsIndex, 0, exports); + + if (requireIndex != -1) { + function contextualRequire(names, callback, errback) { + if (typeof names == 'string' && typeof callback != 'function') + return req(names); + return require.call(loader, names, callback, errback, module.id); + } + contextualRequire.toUrl = function(name) { + // normalize without defaultJSExtensions + var defaultJSExtension = loader.defaultJSExtensions && name.substr(name.length - 3, 3) != '.js'; + var url = loader.decanonicalize(name, module.id); + if (defaultJSExtension && url.substr(url.length - 3, 3) == '.js') + url = url.substr(0, url.length - 3); + return url; + }; + depValues.splice(requireIndex, 0, contextualRequire); + } + + // set global require to AMD require + var curRequire = __global.require; + __global.require = require; + + var output = factory.apply(exportsIndex == -1 ? __global : exports, depValues); + + __global.require = curRequire; + + if (typeof output == 'undefined' && module) + output = module.exports; + + if (typeof output != 'undefined') + return output; + } + + var entry = createEntry(); + entry.name = name && (loader.decanonicalize || loader.normalize).call(loader, name); + entry.deps = deps; + entry.execute = execute; + + loader.pushRegister_({ + amd: true, + entry: entry + }); + } + define.amd = {}; + + // reduction function to attach defines to a load record + hook('reduceRegister_', function(reduceRegister) { + return function(load, register) { + // only handle AMD registers here + if (!register || !register.amd) + return reduceRegister.call(this, load, register); + + var curMeta = load && load.metadata; + var entry = register.entry; + + if (curMeta) + curMeta.format = 'amd'; + + // anonymous define + if (!entry.name) { + if (!curMeta) + throw new TypeError('Unexpected anonymous AMD define.'); + + // already defined anonymously -> throw + if (curMeta.entry) + throw new TypeError('Multiple defines for anonymous module ' + load.name); + + curMeta.entry = entry; + } + // named define + else { + // if we don't have any other defines, + // then let this be an anonymous define + // this is just to support single modules of the form: + // define('jquery') + // still loading anonymously + // because it is done widely enough to be useful + // as soon as there is more than one define, this gets removed though + if (curMeta) { + if (!curMeta.entry && !curMeta.bundle) + curMeta.entry = entry; + else + curMeta.entry = undefined; + + // note this is now a bundle + curMeta.bundle = true; + } + + // define the module through the register registry + if (!(entry.name in this.defined)) + this.defined[entry.name] = entry; + } + }; + }); + + // adds define as a global (potentially just temporarily) + function createDefine() { + // ensure no NodeJS environment detection + var oldModule = __global.module; + var oldExports = __global.exports; + var oldDefine = __global.define; + + __global.module = undefined; + __global.exports = undefined; + __global.define = define; + + return function() { + __global.define = oldDefine; + __global.module = oldModule; + __global.exports = oldExports; + }; + } + + loader.set('@@amd-helpers', loader.newModule({ + createDefine: createDefine, + require: require, + define: define + })); + loader.amdDefine = define; + loader.amdRequire = require; + }; +});/* + SystemJS AMD Format +*/ +(function() { + // AMD Module Format Detection RegEx + // define([.., .., ..], ...) + // define(varName); || define(function(require, exports) {}); || define({}) + var amdRegEx = /(?:^\uFEFF?|[^$_a-zA-Z\xA0-\uFFFF.])define\s*\(\s*("[^"]+"\s*,\s*|'[^']+'\s*,\s*)?\s*(\[(\s*(("[^"]+"|'[^']+')\s*,|\/\/.*\r?\n|\/\*(.|\s)*?\*\/))*(\s*("[^"]+"|'[^']+')\s*,?)?(\s*(\/\/.*\r?\n|\/\*(.|\s)*?\*\/))*\s*\]|function\s*|{|[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*\))/; + + hook('fetch', function(fetch) { + return function(load) { + if (load.metadata.format === 'amd' + && !load.metadata.authorization + && load.metadata.scriptLoad !== false) + load.metadata.scriptLoad = true; + // script load implies define global leak + if (load.metadata.scriptLoad && isBrowser) + this.get('@@amd-helpers').createDefine(); + return fetch.call(this, load); + }; + }); + + hook('instantiate', function(instantiate) { + return function(load) { + var loader = this; + + if (load.metadata.format == 'amd' || !load.metadata.format && load.source.match(amdRegEx)) { + load.metadata.format = 'amd'; + + if (!loader.builder && loader.execute !== false) { + var removeDefine = this.get('@@amd-helpers').createDefine(); + + try { + __exec.call(loader, load); + } + finally { + removeDefine(); + } + + if (!load.metadata.entry && !load.metadata.bundle) + throw new TypeError('AMD module ' + load.name + ' did not define'); + } + else { + load.metadata.execute = function() { + return load.metadata.builderExecute.apply(this, arguments); + }; + } + } + + return instantiate.call(loader, load); + }; + }); + +})(); +/* + SystemJS Loader Plugin Support + + Supports plugin loader syntax with "!", or via metadata.loader + + The plugin name is loaded as a module itself, and can override standard loader hooks + for the plugin resource. See the plugin section of the systemjs readme. +*/ + +(function() { + function getParentName(loader, parentName) { + // if parent is a plugin, normalize against the parent plugin argument only + if (parentName) { + var parentPluginIndex; + if (loader.pluginFirst) { + if ((parentPluginIndex = parentName.lastIndexOf('!')) != -1) + return parentName.substr(parentPluginIndex + 1); + } + else { + if ((parentPluginIndex = parentName.indexOf('!')) != -1) + return parentName.substr(0, parentPluginIndex); + } + + return parentName; + } + } + + function parsePlugin(loader, name) { + var argumentName; + var pluginName; + + var pluginIndex = name.lastIndexOf('!'); + + if (pluginIndex == -1) + return; + + if (loader.pluginFirst) { + argumentName = name.substr(pluginIndex + 1); + pluginName = name.substr(0, pluginIndex); + } + else { + argumentName = name.substr(0, pluginIndex); + pluginName = name.substr(pluginIndex + 1) || argumentName.substr(argumentName.lastIndexOf('.') + 1); + } + + return { + argument: argumentName, + plugin: pluginName + }; + } + + // put name back together after parts have been normalized + function combinePluginParts(loader, argumentName, pluginName, defaultExtension) { + if (defaultExtension && argumentName.substr(argumentName.length - 3, 3) == '.js') + argumentName = argumentName.substr(0, argumentName.length - 3); + + if (loader.pluginFirst) { + return pluginName + '!' + argumentName; + } + else { + return argumentName + '!' + pluginName; + } + } + + // note if normalize will add a default js extension + // if so, remove for backwards compat + // this is strange and sucks, but will be deprecated + function checkDefaultExtension(loader, arg) { + return loader.defaultJSExtensions && arg.substr(arg.length - 3, 3) != '.js'; + } + + function createNormalizeSync(normalizeSync) { + return function(name, parentName, isPlugin) { + var loader = this; + + parentName = getParentName(this, parentName); + var parsed = parsePlugin(loader, name); + + if (!parsed) + return normalizeSync.call(this, name, parentName, isPlugin); + + // if this is a plugin, normalize the plugin name and the argument + var argumentName = loader.normalizeSync(parsed.argument, parentName, true); + var pluginName = loader.normalizeSync(parsed.plugin, parentName, true); + return combinePluginParts(loader, argumentName, pluginName, checkDefaultExtension(loader, parsed.argument)); + }; + } + + hook('decanonicalize', createNormalizeSync); + hook('normalizeSync', createNormalizeSync); + + hook('normalize', function(normalize) { + return function(name, parentName, isPlugin) { + var loader = this; + + parentName = getParentName(this, parentName); + + var parsed = parsePlugin(loader, name); + + if (!parsed) + return normalize.call(loader, name, parentName, isPlugin); + + return Promise.all([ + loader.normalize(parsed.argument, parentName, true), + loader.normalize(parsed.plugin, parentName, true) + ]) + .then(function(normalized) { + return combinePluginParts(loader, normalized[0], normalized[1], checkDefaultExtension(loader, parsed.argument)); + }); + } + }); + + hook('locate', function(locate) { + return function(load) { + var loader = this; + + var name = load.name; + + // plugin syntax + var pluginSyntaxIndex; + if (loader.pluginFirst) { + if ((pluginSyntaxIndex = name.indexOf('!')) != -1) { + load.metadata.loader = name.substr(0, pluginSyntaxIndex); + load.name = name.substr(pluginSyntaxIndex + 1); + } + } + else { + if ((pluginSyntaxIndex = name.lastIndexOf('!')) != -1) { + load.metadata.loader = name.substr(pluginSyntaxIndex + 1); + load.name = name.substr(0, pluginSyntaxIndex); + } + } + + return locate.call(loader, load) + .then(function(address) { + var plugin = load.metadata.loader; + + if (!plugin) + return address; + + // only fetch the plugin itself if this name isn't defined + if (loader.defined && loader.defined[name]) + return address; + + var pluginLoader = loader.pluginLoader || loader; + + // load the plugin module and run standard locate + return pluginLoader['import'](plugin) + .then(function(loaderModule) { + // store the plugin module itself on the metadata + load.metadata.loaderModule = loaderModule; + + load.address = address; + if (loaderModule.locate) + return loaderModule.locate.call(loader, load); + + return address; + }); + }); + }; + }); + + hook('fetch', function(fetch) { + return function(load) { + var loader = this; + if (load.metadata.loaderModule && load.metadata.loaderModule.fetch && load.metadata.format != 'defined') { + load.metadata.scriptLoad = false; + return load.metadata.loaderModule.fetch.call(loader, load, function(load) { + return fetch.call(loader, load); + }); + } + else { + return fetch.call(loader, load); + } + }; + }); + + hook('translate', function(translate) { + return function(load) { + + /* + * Source map sanitization for load.metadata.sourceMap + * Used to set browser and build-level source maps for + * translated sources in a general way. + * + * This isn't plugin-specific, but can't go anywhere else for now + * As it is post-translate + */ + var sourceMap = load.metadata.sourceMap; + + // if an object not a JSON string do sanitizing + if (sourceMap && typeof sourceMap == 'object') { + var originalName = load.name.split('!')[0]; + + // force set the filename of the original file + sourceMap.file = originalName + '!transpiled'; + + // force set the sources list if only one source + if (!sourceMap.sources || sourceMap.sources.length == 1) + sourceMap.sources = [originalName]; + load.metadata.sourceMap = JSON.stringify(sourceMap); + } + + var loader = this; + if (load.metadata.loaderModule && load.metadata.loaderModule.translate && load.metadata.format != 'defined') { + return Promise.resolve(load.metadata.loaderModule.translate.call(loader, load)).then(function(result) { + // NB we should probably enforce a string output + if (typeof result == 'string') + load.source = result; + return translate.call(loader, load); + }); + } + else { + return translate.call(loader, load); + } + }; + }); + + hook('instantiate', function(instantiate) { + return function(load) { + var loader = this; + + if (load.metadata.loaderModule && load.metadata.loaderModule.instantiate && !loader.builder && load.metadata.format != 'defined') + return Promise.resolve(load.metadata.loaderModule.instantiate.call(loader, load)).then(function(result) { + load.metadata.entry = createEntry(); + load.metadata.entry.execute = function() { + return result; + } + load.metadata.entry.deps = load.metadata.deps; + load.metadata.format = 'defined'; + return instantiate.call(loader, load); + }); + else + return instantiate.call(loader, load); + }; + }); + +})();/* + * Conditions Extension + * + * Allows a condition module to alter the resolution of an import via syntax: + * + * import $ from 'jquery/#{browser}'; + * + * Will first load the module 'browser' via `SystemJS.import('browser')` and + * take the default export of that module. + * If the default export is not a string, an error is thrown. + * + * We then substitute the string into the require to get the conditional resolution + * enabling environment-specific variations like: + * + * import $ from 'jquery/ie' + * import $ from 'jquery/firefox' + * import $ from 'jquery/chrome' + * import $ from 'jquery/safari' + * + * It can be useful for a condition module to define multiple conditions. + * This can be done via the `|` modifier to specify an export member expression: + * + * import 'jquery/#{./browser.js|grade.version}' + * + * Where the `grade` export `version` member in the `browser.js` module is substituted. + * + * + * Boolean Conditionals + * + * For polyfill modules, that are used as imports but have no module value, + * a binary conditional allows a module not to be loaded at all if not needed: + * + * import 'es5-shim#?./conditions.js|needs-es5shim' + * + * These conditions can also be negated via: + * + * import 'es5-shim#?~./conditions.js|es6' + * + */ + + function parseCondition(condition) { + var conditionExport, conditionModule, negation; + + var negation = condition[0] == '~'; + var conditionExportIndex = condition.lastIndexOf('|'); + if (conditionExportIndex != -1) { + conditionExport = condition.substr(conditionExportIndex + 1); + conditionModule = condition.substr(negation, conditionExportIndex - negation) || '@system-env'; + } + else { + conditionExport = null; + conditionModule = condition.substr(negation); + } + + return { + module: conditionModule, + prop: conditionExport, + negate: negation + }; + } + + function serializeCondition(conditionObj) { + return (conditionObj.negate ? '~' : '') + conditionObj.module + (conditionObj.prop ? '|' + conditionObj.prop : ''); + } + + function resolveCondition(conditionObj, parentName, bool) { + return this['import'](conditionObj.module, parentName) + .then(function(m) { + if (conditionObj.prop) + m = readMemberExpression(conditionObj.prop, m); + else if (typeof m == 'object' && m + '' == 'Module') + m = m['default']; + + return conditionObj.negate ? !m : m; + }); + } + + var interpolationRegEx = /#\{[^\}]+\}/; + function interpolateConditional(name, parentName) { + // first we normalize the conditional + var conditionalMatch = name.match(interpolationRegEx); + + if (!conditionalMatch) + return Promise.resolve(name); + + var conditionObj = parseCondition(conditionalMatch[0].substr(2, conditionalMatch[0].length - 3)); + + // in builds, return normalized conditional + if (this.builder) + return this['normalize'](conditionObj.module, parentName) + .then(function(conditionModule) { + conditionObj.module = conditionModule; + return name.replace(interpolationRegEx, '#{' + serializeCondition(conditionObj) + '}'); + }); + + return resolveCondition.call(this, conditionObj, parentName, false) + .then(function(conditionValue) { + if (typeof conditionValue !== 'string') + throw new TypeError('The condition value for ' + name + ' doesn\'t resolve to a string.'); + + if (conditionValue.indexOf('/') != -1) + throw new TypeError('Unabled to interpolate conditional ' + name + (parentName ? ' in ' + parentName : '') + '\n\tThe condition value ' + conditionValue + ' cannot contain a "/" separator.'); + + return name.replace(interpolationRegEx, conditionValue); + }); + } + + function booleanConditional(name, parentName) { + // first we normalize the conditional + var booleanIndex = name.lastIndexOf('#?'); + + if (booleanIndex == -1) + return Promise.resolve(name); + + var conditionObj = parseCondition(name.substr(booleanIndex + 2)); + + // in builds, return normalized conditional + if (this.builder) + return this['normalize'](conditionObj.module, parentName) + .then(function(conditionModule) { + conditionObj.module = conditionModule; + return name.substr(0, booleanIndex) + '#?' + serializeCondition(conditionObj); + }); + + return resolveCondition.call(this, conditionObj, parentName, true) + .then(function(conditionValue) { + return conditionValue ? name.substr(0, booleanIndex) : '@empty'; + }); + } + + // normalizeSync does not parse conditionals at all although it could + hook('normalize', function(normalize) { + return function(name, parentName, parentAddress) { + var loader = this; + return booleanConditional.call(loader, name, parentName) + .then(function(name) { + return normalize.call(loader, name, parentName, parentAddress); + }) + .then(function(normalized) { + return interpolateConditional.call(loader, normalized, parentName); + }); + }; + }); +/* + * Alias Extension + * + * Allows a module to be a plain copy of another module by module name + * + * SystemJS.meta['mybootstrapalias'] = { alias: 'bootstrap' }; + * + */ +(function() { + // aliases + hook('fetch', function(fetch) { + return function(load) { + var alias = load.metadata.alias; + var aliasDeps = load.metadata.deps || []; + if (alias) { + load.metadata.format = 'defined'; + var entry = createEntry(); + this.defined[load.name] = entry; + entry.declarative = true; + entry.deps = aliasDeps.concat([alias]); + entry.declare = function(_export) { + return { + setters: [function(module) { + for (var p in module) + _export(p, module[p]); + if (module.__useDefault) + entry.module.exports.__useDefault = true; + }], + execute: function() {} + }; + }; + return ''; + } + + return fetch.call(this, load); + }; + }); +})();/* + * Meta Extension + * + * Sets default metadata on a load record (load.metadata) from + * loader.metadata via SystemJS.meta function. + * + * + * Also provides an inline meta syntax for module meta in source. + * + * Eg: + * + * loader.meta({ + * 'my/module': { deps: ['jquery'] } + * 'my/*': { format: 'amd' } + * }); + * + * Which in turn populates loader.metadata. + * + * load.metadata.deps and load.metadata.format will then be set + * for 'my/module' + * + * The same meta could be set with a my/module.js file containing: + * + * my/module.js + * "format amd"; + * "deps[] jquery"; + * "globals.some value" + * console.log('this is my/module'); + * + * Configuration meta always takes preference to inline meta. + * + * Multiple matches in wildcards are supported and ammend the meta. + * + * + * The benefits of the function form is that paths are URL-normalized + * supporting say + * + * loader.meta({ './app': { format: 'cjs' } }); + * + * Instead of needing to set against the absolute URL (https://site.com/app.js) + * + */ + +(function() { + + hookConstructor(function(constructor) { + return function() { + this.meta = {}; + constructor.call(this); + }; + }); + + hook('locate', function(locate) { + return function(load) { + var meta = this.meta; + var name = load.name; + + // NB for perf, maybe introduce a fast-path wildcard lookup cache here + // which is checked first + + // apply wildcard metas + var bestDepth = 0; + var wildcardIndex; + for (var module in meta) { + wildcardIndex = module.indexOf('*'); + if (wildcardIndex === -1) + continue; + if (module.substr(0, wildcardIndex) === name.substr(0, wildcardIndex) + && module.substr(wildcardIndex + 1) === name.substr(name.length - module.length + wildcardIndex + 1)) { + var depth = module.split('/').length; + if (depth > bestDepth) + bestDepth = depth; + extendMeta(load.metadata, meta[module], bestDepth != depth); + } + } + + // apply exact meta + if (meta[name]) + extendMeta(load.metadata, meta[name]); + + return locate.call(this, load); + }; + }); + + // detect any meta header syntax + // only set if not already set + var metaRegEx = /^(\s*\/\*[^\*]*(\*(?!\/)[^\*]*)*\*\/|\s*\/\/[^\n]*|\s*"[^"]+"\s*;?|\s*'[^']+'\s*;?)+/; + var metaPartRegEx = /\/\*[^\*]*(\*(?!\/)[^\*]*)*\*\/|\/\/[^\n]*|"[^"]+"\s*;?|'[^']+'\s*;?/g; + + function setMetaProperty(target, p, value) { + var pParts = p.split('.'); + var curPart; + while (pParts.length > 1) { + curPart = pParts.shift(); + target = target[curPart] = target[curPart] || {}; + } + curPart = pParts.shift(); + if (!(curPart in target)) + target[curPart] = value; + } + + hook('translate', function(translate) { + return function(load) { + // NB meta will be post-translate pending transpiler conversion to plugins + var meta = load.source.match(metaRegEx); + if (meta) { + var metaParts = meta[0].match(metaPartRegEx); + + for (var i = 0; i < metaParts.length; i++) { + var curPart = metaParts[i]; + var len = curPart.length; + + var firstChar = curPart.substr(0, 1); + if (curPart.substr(len - 1, 1) == ';') + len--; + + if (firstChar != '"' && firstChar != "'") + continue; + + var metaString = curPart.substr(1, curPart.length - 3); + var metaName = metaString.substr(0, metaString.indexOf(' ')); + + if (metaName) { + var metaValue = metaString.substr(metaName.length + 1, metaString.length - metaName.length - 1); + + if (metaName.substr(metaName.length - 2, 2) == '[]') { + metaName = metaName.substr(0, metaName.length - 2); + load.metadata[metaName] = load.metadata[metaName] || []; + load.metadata[metaName].push(metaValue); + } + else if (load.metadata[metaName] instanceof Array) { + // temporary backwards compat for previous "deps" syntax + warn.call(this, 'Module ' + load.name + ' contains deprecated "deps ' + metaValue + '" meta syntax.\nThis should be updated to "deps[] ' + metaValue + '" for pushing to array meta.'); + load.metadata[metaName].push(metaValue); + } + else { + setMetaProperty(load.metadata, metaName, metaValue); + } + } + else { + load.metadata[metaString] = true; + } + } + } + + return translate.call(this, load); + }; + }); +})(); +/* + System bundles + + Allows a bundle module to be specified which will be dynamically + loaded before trying to load a given module. + + For example: + SystemJS.bundles['mybundle'] = ['jquery', 'bootstrap/js/bootstrap'] + + Will result in a load to "mybundle" whenever a load to "jquery" + or "bootstrap/js/bootstrap" is made. + + In this way, the bundle becomes the request that provides the module +*/ + +(function() { + // bundles support (just like RequireJS) + // bundle name is module name of bundle itself + // bundle is array of modules defined by the bundle + // when a module in the bundle is requested, the bundle is loaded instead + // of the form SystemJS.bundles['mybundle'] = ['jquery', 'bootstrap/js/bootstrap'] + hookConstructor(function(constructor) { + return function() { + constructor.call(this); + this.bundles = {}; + this._loader.loadedBundles = {}; + }; + }); + + // assign bundle metadata for bundle loads + hook('locate', function(locate) { + return function(load) { + var loader = this; + + if (!(load.name in loader.defined)) + for (var b in loader.bundles) { + if (loader.bundles[b].indexOf(load.name) != -1) + return loader['import'](b) + .then(function() { + return locate.call(loader, load); + }); + } + + return locate.call(loader, load); + }; + }); +})(); +/* + * Dependency Tree Cache + * + * Allows a build to pre-populate a dependency trace tree on the loader of + * the expected dependency tree, to be loaded upfront when requesting the + * module, avoinding the n round trips latency of module loading, where + * n is the dependency tree depth. + * + * eg: + * SystemJS.depCache = { + * 'app': ['normalized', 'deps'], + * 'normalized': ['another'], + * 'deps': ['tree'] + * }; + * + * SystemJS.import('app') + * // simultaneously starts loading all of: + * // 'normalized', 'deps', 'another', 'tree' + * // before "app" source is even loaded + * + */ + +(function() { + hookConstructor(function(constructor) { + return function() { + constructor.call(this); + this.depCache = {}; + } + }); + + hook('locate', function(locate) { + return function(load) { + var loader = this; + // load direct deps, in turn will pick up their trace trees + var deps = loader.depCache[load.name]; + if (deps) + for (var i = 0; i < deps.length; i++) + loader['import'](deps[i], load.name); + + return locate.call(loader, load); + }; + }); +})(); + +System = new SystemJSLoader(); + +__global.SystemJS = System; +System.version = '0.19.13 Standard'; + // -- exporting -- + + if (typeof exports === 'object') + module.exports = Loader; + + __global.Reflect = __global.Reflect || {}; + __global.Reflect.Loader = __global.Reflect.Loader || Loader; + __global.Reflect.global = __global.Reflect.global || __global; + __global.LoaderPolyfill = Loader; + + if (!System) { + System = new SystemLoader(); + System.constructor = SystemLoader; + } + + if (typeof exports === 'object') + module.exports = System; + + __global.System = System; + +})(typeof self != 'undefined' ? self : global);} + +// auto-load Promise and URL polyfills if needed in the browser +try { + var hasURL = typeof URLPolyfill != 'undefined' || new URL('test:///').protocol == 'test:'; +} +catch(e) {} + +if (typeof Promise === 'undefined' || !hasURL) { + // document.write + if (typeof document !== 'undefined') { + var scripts = document.getElementsByTagName('script'); + $__curScript = scripts[scripts.length - 1]; + var curPath = $__curScript.src; + var basePath = curPath.substr(0, curPath.lastIndexOf('/') + 1); + window.systemJSBootstrap = bootstrap; + document.write( + '<' + 'script type="text/javascript" src="' + basePath + 'system-polyfills.js">' + '<' + '/script>' + ); + } + // importScripts + else if (typeof importScripts !== 'undefined') { + var basePath = ''; + try { + throw new Error('_'); + } catch (e) { + e.stack.replace(/(?:at|@).*(http.+):[\d]+:[\d]+/, function(m, url) { + basePath = url.replace(/\/[^\/]*$/, '/'); + }); + } + importScripts(basePath + 'system-polyfills.js'); + bootstrap(); + } + else { + bootstrap(); + } +} +else { + bootstrap(); +} + + +})();
\ No newline at end of file |