archive-gh-me/systemjs
1
0
Fork 0
mirror of https://github.com/systemjs/systemjs.git synced 2026-01-25 14:57:38 +00:00
Code Issues Projects Releases Wiki Activity
systemjs/dist/system.js
guybedford 0e8263cad9 build
2014-07-29 16:32:40 -07:00

2057 lines
63 KiB
JavaScript
Raw Blame History

/*
* SystemJS v0.6.7
*
* Copyright (c) 2014 Guy Bedford
* MIT License
*/
(function(__$global) {
__$global.upgradeSystemLoader = function() {
__$global.upgradeSystemLoader = undefined;
// indexOf polyfill for IE
var indexOf = Array.prototype.indexOf || function(item) {
for (var i = 0, l = this.length; i < l; i++)
if (this[i] === item)
return i;
return -1;
}
// Absolute URL parsing, from https://gist.github.com/Yaffle/1088850
function parseURI(url) {
var m = String(url).replace(/^\s+|\s+$/g, '').match(/^([^:\/?#]+:)?(\/\/(?:[^:@]*(?::[^:@]*)?@)?(([^:\/?#]*)(?::(\d*))?))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?/);
// authority = '//' + user + ':' + pass '@' + hostname + ':' port
return (m ? {
href : m[0] || '',
protocol : m[1] || '',
authority: m[2] || '',
host : m[3] || '',
hostname : m[4] || '',
port : m[5] || '',
pathname : m[6] || '',
search : m[7] || '',
hash : m[8] || ''
} : null);
}
function toAbsoluteURL(base, href) {
function removeDotSegments(input) {
var output = [];
input.replace(/^(\.\.?(\/|$))+/, '')
.replace(/\/(\.(\/|$))+/g, '/')
.replace(/\/\.\.$/, '/../')
.replace(/\/?[^\/]*/g, function (p) {
if (p === '/..')
output.pop();
else
output.push(p);
});
return output.join('').replace(/^\//, input.charAt(0) === '/' ? '/' : '');
}
href = parseURI(href || '');
base = parseURI(base || '');
return !href || !base ? null : (href.protocol || base.protocol) +
(href.protocol || href.authority ? href.authority : base.authority) +
removeDotSegments(href.protocol || href.authority || href.pathname.charAt(0) === '/' ? href.pathname : (href.pathname ? ((base.authority && !base.pathname ? '/' : '') + base.pathname.slice(0, base.pathname.lastIndexOf('/') + 1) + href.pathname) : base.pathname)) +
(href.protocol || href.authority || href.pathname ? href.search : (href.search || base.search)) +
href.hash;
}
// clone the original System loader
var originalSystem = __$global.System;
var System = __$global.System = new LoaderPolyfill(originalSystem);
System.baseURL = originalSystem.baseURL;
System.paths = { '*': '*.js' };
System.originalSystem = originalSystem;
System.noConflict = function() {
__$global.SystemJS = System;
__$global.System = System.originalSystem;
}
/*
* Meta Extension
*
* Sets default metadata on a load record (load.metadata) from
* loader.meta[moduleName].
* Also provides an inline meta syntax for module meta in source.
*
* Eg:
*
* loader.meta['my/module'] = { some: 'meta' };
*
* load.metadata.some = 'meta' will now be set on the load record.
*
* The same meta could be set with a my/module.js file containing:
*
* my/module.js
* "some meta";
* "another meta";
* console.log('this is my/module');
*
* The benefit of inline meta is that coniguration doesn't need
* to be known in advanced, which is useful for modularising
* configuration and avoiding the need for configuration injection.
*
*
* Example
* -------
*
* The simplest meta example is setting the module format:
*
* System.meta['my/module'] = { format: 'amd' };
*
* or inside 'my/module.js':
*
* "format amd";
* define(...);
*
*/
function meta(loader) {
var metaRegEx = /^(\s*\/\*.*\*\/|\s*\/\/[^\n]*|\s*"[^"]+"\s*;?|\s*'[^']+'\s*;?)+/;
var metaPartRegEx = /\/\*.*\*\/|\/\/[^\n]*|"[^"]+"\s*;?|'[^']+'\s*;?/g;
loader.meta = {};
function setConfigMeta(loader, load) {
var meta = loader.meta && loader.meta[load.name];
if (meta) {
for (var p in meta)
load.metadata[p] = load.metadata[p] || meta[p];
}
}
var loaderLocate = loader.locate;
loader.locate = function(load) {
setConfigMeta(this, load);
return loaderLocate.call(this, load);
}
var loaderTranslate = loader.translate;
loader.translate = function(load) {
// detect any meta header syntax
var meta = load.source.match(metaRegEx);
if (meta) {
var metaParts = meta[0].match(metaPartRegEx);
for (var i = 0; i < metaParts.length; i++) {
var len = metaParts[i].length;
var firstChar = metaParts[i].substr(0, 1);
if (metaParts[i].substr(len - 1, 1) == ';')
len--;
if (firstChar != '"' && firstChar != "'")
continue;
var metaString = metaParts[i].substr(1, metaParts[i].length - 3);
var metaName = metaString.substr(0, metaString.indexOf(' '));
if (metaName) {
var metaValue = metaString.substr(metaName.length + 1, metaString.length - metaName.length - 1);
if (load.metadata[metaName] instanceof Array)
load.metadata[metaName].push(metaValue);
else
load.metadata[metaName] = metaValue;
}
}
}
// config meta overrides
setConfigMeta(this, load);
return loaderTranslate.call(this, load);
}
}/*
* 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
*
* Works as a standalone extension, but benefits from having a more
* advanced __eval defined like in SystemJS polyfill-wrapper-end.js
*
* 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.
*
*/
function register(loader) {
if (typeof indexOf == 'undefined')
indexOf = Array.prototype.indexOf;
if (typeof __eval == 'undefined')
__eval = 0 || eval; // uglify breaks without the 0 ||
// define exec for easy evaluation of a load record (load.name, load.source, load.address)
// main feature is source maps support handling
var curSystem;
function exec(load) {
var loader = this;
if (load.name == '@traceur') {
curSystem = System;
}
// support sourceMappingURL (efficiently)
var sourceMappingURL;
var lastLineIndex = load.source.lastIndexOf('\n');
if (lastLineIndex != -1) {
if (load.source.substr(lastLineIndex + 1, 21) == '//# sourceMappingURL=') {
sourceMappingURL = load.source.substr(lastLineIndex + 22, load.source.length - lastLineIndex - 22);
if (typeof toAbsoluteURL != 'undefined')
sourceMappingURL = toAbsoluteURL(load.address, sourceMappingURL);
}
}
__eval(load.source, loader.global, load.address, sourceMappingURL);
// traceur overwrites System and Module - write them back
if (load.name == '@traceur') {
loader.global.traceurSystem = loader.global.System;
loader.global.System = curSystem;
}
}
loader.__exec = exec;
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;
}
/*
* 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.register for dynamic modules (3-4 params) - System.register([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.
*
*/
// loader.register sets loader.defined for declarative modules
var anonRegister;
var calledRegister;
function register(name, deps, declare, execute) {
if (typeof name != 'string') {
execute = declare;
declare = deps;
deps = name;
name = null;
}
calledRegister = true;
var register;
// dynamic
if (typeof declare == 'boolean') {
register = {
declarative: false,
deps: deps,
execute: execute,
executingRequire: declare
};
}
else {
// ES6 declarative
if (deps.length > 0 && declare.length != 1)
throw 'Invalid System.register form for ' + name + '. Declare function must take one argument.';
register = {
declarative: true,
deps: deps,
declare: declare
};
}
// named register
if (name) {
register.name = name;
// we never overwrite an existing define
if (!loader.defined[name])
loader.defined[name] = register;
}
// anonymous register
else if (register.declarative) {
if (anonRegister)
throw 'Multiple anonymous System.register calls in the same module file.';
anonRegister = register;
}
}
/*
* Registry side table - loader.defined
* Registry Entry Contains:
* - 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 System.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
*
* Then for declarative only we track dynamic bindings with the records:
* - name
* - setters declarative setter functions
* - exports actual module values
* - 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
*
*/
function defineRegister(loader) {
if (loader.register)
return;
loader.register = register;
if (!loader.defined)
loader.defined = {};
// script injection mode calls this function synchronously on load
var onScriptLoad = loader.onScriptLoad;
loader.onScriptLoad = function(load) {
onScriptLoad(load);
// anonymous define
if (anonRegister)
load.metadata.entry = anonRegister;
if (anonRegister || calledRegister)
load.metadata.format = load.metadata.format || 'register';
if (calledRegister)
load.metadata.registered = true;
}
}
defineRegister(loader);
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 === undefined || depEntry.groupIndex < depGroupIndex) {
// if already in a group, remove from the old group
if (depEntry.groupIndex) {
groups[depEntry.groupIndex].splice(groups[depEntry.groupIndex].indexOf(depEntry), 1);
// if the old group is empty, then we have a mixed depndency cycle
if (groups[depEntry.groupIndex].length == 0)
throw new TypeError("Mixed dependency cycle detected");
}
depEntry.groupIndex = depGroupIndex;
}
buildGroups(depEntry, loader, groups);
}
}
function link(name, loader) {
var startEntry = loader.defined[name];
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
var moduleRecords = {};
function getOrCreateModuleRecord(name) {
return moduleRecords[name] || (moduleRecords[name] = {
name: name,
dependencies: [],
exports: {}, // 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 module = entry.module = getOrCreateModuleRecord(entry.name);
var exports = entry.module.exports;
var declaration = entry.declare.call(global, function(name, value) {
module.locked = true;
exports[name] = value;
for (var i = 0, l = module.importers.length; i < l; i++) {
var importerModule = module.importers[i];
if (!importerModule.locked) {
var importerIndex = importerModule.dependencies.indexOf(module);
importerModule.setters[importerIndex](exports);
}
}
module.locked = false;
return value;
});
module.setters = declaration.setters;
module.execute = declaration.execute;
if (!module.setters || !module.execute) {
throw "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;
}
// 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);
}
// run the setter for this dependency
if (module.setters[i])
module.setters[i](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 "System Register: The module requested " + name + " but this was not declared as a dependency";
}
else {
if (entry.declarative)
ensureEvaluated(name, [], loader);
else if (!entry.evaluated)
linkDynamicModule(entry, loader);
exports = entry.module.exports;
}
return exports.__useDefault ? exports['default'] : exports;
}
function linkDynamicModule(entry, loader) {
if (entry.module)
return;
var exports = {};
var module = { 'default': exports, __useDefault: true };
entry.module = { exports: module };
// 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];
var depEntry = loader.defined[depName];
if (depEntry)
linkDynamicModule(depEntry, loader);
}
}
// lookup the module name if it is in the registry
var moduleName = entry.name;
// now execute
entry.evaluated = true;
var output = entry.execute.call(loader.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);
}
}, exports, moduleName);
if (output)
module['default'] = output;
}
/*
* 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.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(loader.global);
}
var registerRegEx = /System\.register/;
var loaderFetch = loader.fetch;
loader.fetch = function(load) {
var loader = this;
defineRegister(loader);
if (loader.defined[load.name]) {
load.metadata.format = 'defined';
return '';
}
anonRegister = null;
calledRegister = false;
// the above get picked up by onScriptLoad
return loaderFetch.call(loader, load);
}
var loaderTranslate = loader.translate;
loader.translate = function(load) {
this.register = register;
this.__exec = exec;
load.metadata.deps = load.metadata.deps || [];
// we run the meta detection here (register is after meta)
return Promise.resolve(loaderTranslate.call(this, load)).then(function(source) {
// dont run format detection for globals shimmed
// ideally this should be in the global extension, but there is
// currently no neat way to separate it
if (load.metadata.init || load.metadata.exports)
load.metadata.format = load.metadata.format || 'global';
// run detection for register format
if (load.metadata.format == 'register' || !load.metadata.format && load.source.match(registerRegEx))
load.metadata.format = 'register';
return source;
});
}
var loaderInstantiate = loader.instantiate;
loader.instantiate = function(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];
// picked up already by a script injection
else if (load.metadata.entry)
entry = load.metadata.entry;
// otherwise check if it is dynamic
else if (load.metadata.execute) {
entry = {
declarative: false,
deps: load.metadata.deps || [],
execute: load.metadata.execute,
executingRequire: load.metadata.executingRequire // NodeJS-style requires or not
};
}
// Contains System.register calls
else if (load.metadata.format == 'register') {
anonRegister = null;
calledRegister = false;
var System = loader.global.System = loader.global.System || loader;
var curRegister = System.register;
System.register = register;
loader.__exec(load);
System.register = curRegister;
if (anonRegister)
entry = anonRegister;
if (!calledRegister && !load.metadata.registered)
throw load.name + " detected as System.register but didn't execute.";
}
// named bundles are just an empty module
if (!entry && load.metadata.format != 'es6')
return {
deps: [],
execute: function() {
return loader.newModule({});
}
};
// place this module onto defined for circular references
if (entry)
loader.defined[load.name] = entry;
// no entry -> treat as ES6
else
return loaderInstantiate.call(this, load);
entry.deps = dedupe(entry.deps);
entry.name = load.name;
// 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() {
// this avoids double duplication allowing a bundle to equal its last defined module
if (entry.esmodule) {
loader.defined[load.name] = undefined;
return entry.esmodule;
}
// 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;
var module = loader.newModule(entry.module.exports);
entry.module.module = module;
// if the entry is an alias, set the alias too
for (var name in loader.defined) {
if (!loader.defined[name])
continue;
if (entry.declarative && loader.defined[name].execute != entry.execute)
continue;
if (!entry.declarative && loader.defined[name].declare != entry.declare);
continue;
loader.defined[name].esmodule = module;
}
// return the defined module object
return module;
}
};
});
}
}
/*
* SystemJS Core
* Code should be vaguely readable
*
*/
function core(loader) {
/*
__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() {}
*/
var loaderImport = loader['import'];
loader['import'] = function(name, options) {
return loaderImport.call(this, name, options).then(function(module) {
return module.__useDefault ? module['default'] : module;
});
}
// support the empty module, as a concept
loader.set('@empty', loader.newModule({}));
/*
Config
Extends 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' };
*/
loader.config = function(cfg) {
for (var c in cfg) {
var v = cfg[c];
if (typeof v == 'object') {
this[c] = this[c] || {};
for (var p in v)
this[c][p] = v[p];
}
else
this[c] = v;
}
}
// override locate to allow baseURL to be document-relative
var baseURI;
if (typeof window == 'undefined') {
baseURI = process.cwd() + '/';
}
else {
baseURI = document.baseURI;
if (!baseURI) {
var bases = document.getElementsByTagName('base');
baseURI = bases[0] && bases[0].href || window.location.href;
}
}
var loaderLocate = loader.locate;
var normalizedBaseURL;
loader.locate = function(load) {
if (this.baseURL != normalizedBaseURL) {
normalizedBaseURL = toAbsoluteURL(baseURI, this.baseURL);
if (normalizedBaseURL.substr(normalizedBaseURL.length - 1, 1) != '/')
normalizedBaseURL += '/';
this.baseURL = normalizedBaseURL;
}
return Promise.resolve(loaderLocate.call(this, load));
}
// Traceur conveniences
var aliasRegEx = /^\s*export\s*\*\s*from\s*(?:'([^']+)'|"([^"]+)")/;
var es6RegEx = /(?:^\s*|[}{\(\);,\n]\s*)(import\s+['"]|(import|module)\s+[^"'\(\)\n;]+\s+from\s+['"]|export\s+(\*|\{|default|function|var|const|let|[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*))/;
var loaderTranslate = loader.translate;
loader.translate = function(load) {
var loader = this;
if (load.name == '@traceur')
return loaderTranslate.call(loader, load);
// support ES6 alias modules ("export * from 'module';") without needing Traceur
var match;
if ((load.metadata.format == 'es6' || !load.metadata.format) && (match = load.source.match(aliasRegEx))) {
load.metadata.format = 'cjs';
load.source = 'module.exports = require("' + (match[1] || match[2]) + '");\n';
}
// detect ES6
else if (load.metadata.format == 'es6' || !load.metadata.format && load.source.match(es6RegEx)) {
load.metadata.format = 'es6';
// dynamically load Traceur for ES6 if necessary
if (!loader.global.traceur) {
return loader['import']('@traceur').then(function() {
return loaderTranslate.call(loader, load);
});
}
}
return loaderTranslate.call(loader, load);
}
// always load Traceur as a global
var loaderInstantiate = loader.instantiate;
loader.instantiate = function(load) {
var loader = this;
if (load.name == '@traceur') {
loader.__exec(load);
return {
deps: [],
execute: function() {
return loader.newModule({});
}
};
}
return loaderInstantiate.call(loader, load);
}
}
/*
SystemJS Global Format
Supports
metadata.deps
metadata.init
metadata.exports
Also detects writes to the global object avoiding global collisions.
See the SystemJS readme global support section for further information.
*/
function global(loader) {
function createHelpers(loader) {
if (loader.has('@@global-helpers'))
return;
var hasOwnProperty = loader.global.hasOwnProperty;
var moduleGlobals = {};
var curGlobalObj;
var ignoredGlobalProps;
loader.set('@@global-helpers', loader.newModule({
prepareGlobal: function(moduleName, deps) {
// first, we add all the dependency modules to the global
for (var i = 0; i < deps.length; i++) {
var moduleGlobal = moduleGlobals[deps[i]];
if (moduleGlobal)
for (var m in moduleGlobal)
loader.global[m] = moduleGlobal[m];
}
// now store a complete copy of the global object
// in order to detect changes
curGlobalObj = {};
ignoredGlobalProps = ['indexedDB', 'sessionStorage', 'localStorage', 'clipboardData', 'frames', 'webkitStorageInfo'];
for (var g in loader.global) {
if (~ignoredGlobalProps.indexOf(g)) { continue; }
if (!hasOwnProperty || loader.global.hasOwnProperty(g)) {
try {
curGlobalObj[g] = loader.global[g];
} catch (e) {
ignoredGlobalProps.push(g);
}
}
}
},
retrieveGlobal: function(moduleName, exportName, init) {
var singleGlobal;
var exports = {};
// run init
if (init) {
var depModules = [];
for (var i = 0; i < deps.length; i++)
depModules.push(require(deps[i]));
singleGlobal = init.apply(loader.global, depModules);
}
// check for global changes, creating the globalObject for the module
// if many globals, then a module object for those is created
// if one global, then that is the module directly
if (exportName && !singleGlobal) {
var firstPart = exportName.split('.')[0];
singleGlobal = eval.call(loader.global, exportName);
exports[firstPart] = loader.global[firstPart];
}
else {
for (var g in loader.global) {
if (~ignoredGlobalProps.indexOf(g))
continue;
if ((!hasOwnProperty || loader.global.hasOwnProperty(g)) && g != loader.global && curGlobalObj[g] != loader.global[g]) {
exports[g] = loader.global[g];
if (singleGlobal) {
if (singleGlobal !== loader.global[g])
singleGlobal = undefined;
}
else if (singleGlobal !== false) {
singleGlobal = loader.global[g];
}
}
}
}
moduleGlobals[moduleName] = exports;
return typeof singleGlobal != 'undefined' ? singleGlobal : exports;
}
}));
}
createHelpers(loader);
var loaderInstantiate = loader.instantiate;
loader.instantiate = function(load) {
var loader = this;
createHelpers(loader);
var exportName = load.metadata.exports;
if (!load.metadata.format)
load.metadata.format = 'global';
// global is a fallback module format
if (load.metadata.format == 'global') {
load.metadata.execute = function(require, exports, moduleName) {
loader.get('@@global-helpers').prepareGlobal(moduleName, load.metadata.deps);
if (exportName)
load.source += '\nthis["' + exportName + '"] = ' + exportName + ';';
// disable AMD detection
var define = loader.global.define;
loader.global.define = undefined;
// ensure no NodeJS environment detection
loader.global.module = undefined;
loader.global.exports = undefined;
loader.__exec(load);
loader.global.define = define;
return loader.get('@@global-helpers').retrieveGlobal(moduleName, exportName, load.metadata.init);
}
}
return loaderInstantiate.call(loader, load);
}
}
/*
SystemJS CommonJS Format
*/
function cjs(loader) {
// CJS Module Format
// require('...') || exports[''] = ... || exports.asd = ... || module.exports = ...
var cjsExportsRegEx = /(?:^\s*|[}{\(\);,\n=:\?\&]\s*|module\.)(exports\s*\[\s*('[^']+'|"[^"]+")\s*\]|\exports\s*\.\s*[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*|exports\s*\=)/;
var cjsRequireRegEx = /(?:^\s*|[}{\(\);,\n=:\?\&]\s*)require\s*\(\s*("([^"]+)"|'([^']+)')\s*\)/g;
var commentRegEx = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg;
function getCJSDeps(source) {
cjsExportsRegEx.lastIndex = 0;
cjsRequireRegEx.lastIndex = 0;
var deps = [];
// remove comments from the source first
var source = source.replace(commentRegEx, '');
var match;
while (match = cjsRequireRegEx.exec(source))
deps.push(match[2] || match[3]);
return deps;
}
var noop = function() {}
var nodeProcess = {
nextTick: function(f) {
setTimeout(f, 7);
},
browser: typeof window != 'undefined',
env: {},
argv: [],
on: noop,
once: noop,
off: noop,
emit: noop,
cwd: function() { return '/' }
};
loader._getCJSDeps = getCJSDeps;
if (!loader.has('@@nodeProcess'))
loader.set('@@nodeProcess', loader.newModule({ 'default': nodeProcess, __useDefault: true }));
var loaderTranslate = loader.translate;
loader.translate = function(load) {
var loader = this;
if (!loader.has('@@nodeProcess'))
loader.set('@@nodeProcess', loader.newModule({ 'default': nodeProcess, __useDefault: true }));
if (!loader._getCJSDeps)
loader._getCJSDeps = getCJSDeps;
return loaderTranslate.call(loader, load);
}
var loaderInstantiate = loader.instantiate;
loader.instantiate = function(load) {
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') {
load.metadata.deps = load.metadata.deps ? load.metadata.deps.concat(getCJSDeps(load.source)) : load.metadata.deps;
load.metadata.executingRequire = true;
load.metadata.execute = function(require, exports, moduleName) {
var dirname = (load.address || '').split('/');
dirname.pop();
dirname = dirname.join('/');
var globals = loader.global._g = {
global: loader.global,
exports: exports,
module: { exports: exports },
process: nodeProcess,
require: require,
__filename: load.address,
__dirname: dirname
};
var glString = '';
for (var _g in globals)
glString += 'var ' + _g + ' = _g.' + _g + ';';
load.source = glString + '(function() { ' + load.source + '\n}).call(exports)';
// disable AMD detection
var define = loader.global.define;
loader.global.define = undefined;
loader.__exec(load);
loader.global.define = define;
loader.global._g = undefined;
return globals.module.exports;
}
}
return loaderInstantiate.call(this, load);
};
}/*
SystemJS AMD Format
Provides the AMD module format definition at System.format.amd
as well as a RequireJS-style require on System.require
*/
function amd(loader) {
var isNode = typeof module != 'undefined' && module.exports;
// AMD Module Format Detection RegEx
// define([.., .., ..], ...)
// define(varName); || define(function(require, exports) {}); || define({})
var amdRegEx = /(?:^\s*|[}{\(\);,\n\?\&]\s*)define\s*\(\s*("[^"]+"\s*,\s*|'[^']+'\s*,\s*)?\s*(\[(\s*("[^"]+"|'[^']+')\s*,)*(\s*("[^"]+"|'[^']+')\s*,?\s*)?\]|function\s*|{|[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*\))/;
/*
AMD-compatible require
To copy RequireJS, set window.require = window.requirejs = loader.require
*/
function require(names, callback, errback, referer) {
// 'this' is bound to the loader
var loader = this;
// 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 (names instanceof Array)
Promise.all(names.map(function(name) {
return loader['import'](name, referer);
})).then(function(modules) {
callback.apply(null, modules);
}, errback);
// commonjs require
else if (typeof names == 'string') {
var module = loader.get(names);
return module.__useDefault ? module['default'] : module;
}
else
throw 'Invalid require';
};
loader.require = require;
function makeRequire(parentName, staticRequire, loader) {
return function(names, callback, errback) {
if (typeof names == 'string')
return staticRequire(names);
return require.call(loader, names, callback, errback, { name: parentName });
}
}
var anonDefine;
// set to true of the current module turns out to be a named define bundle
var defineBundle;
function createDefine(loader) {
anonDefine = null;
defineBundle = null;
// ensure no NodeJS environment detection
loader.global.module = undefined;
loader.global.exports = undefined;
if (loader.global.define && loader.global.define.loader == loader)
return;
// script injection mode calls this function synchronously on load
var onScriptLoad = loader.onScriptLoad;
loader.onScriptLoad = function(load) {
onScriptLoad(load);
if (anonDefine || defineBundle)
load.metadata.format = 'defined';
if (anonDefine) {
load.metadata.deps = load.metadata.deps ? load.metadata.deps.concat(anonDefine.deps) : anonDefine.deps;
load.metadata.execute = anonDefine.execute;
}
}
function define(name, deps, factory) {
if (typeof name != 'string') {
factory = deps;
deps = name;
name = null;
}
if (!(deps instanceof Array)) {
factory = deps;
// CommonJS AMD form
if (!loader._getCJSDeps)
throw "AMD extension needs CJS extension for AMD CJS support";
deps = ['require', 'exports', 'module'].concat(loader._getCJSDeps(factory.toString()));
}
if (typeof factory != 'function')
factory = (function(factory) {
return function() { return factory; }
})(factory);
// remove system dependencies
var requireIndex, exportsIndex, moduleIndex
if ((requireIndex = indexOf.call(deps, 'require')) != -1)
deps.splice(requireIndex, 1);
if ((exportsIndex = indexOf.call(deps, 'exports')) != -1)
deps.splice(exportsIndex, 1);
if ((moduleIndex = indexOf.call(deps, 'module')) != -1)
deps.splice(moduleIndex, 1);
var define = {
deps: deps,
execute: function(require, exports, moduleName) {
var depValues = [];
for (var i = 0; i < deps.length; i++)
depValues.push(require(deps[i]));
var module;
// add back in system dependencies
if (moduleIndex != -1)
depValues.splice(moduleIndex, 0, module = { id: moduleName, uri: loader.baseURL + moduleName, config: function() { return {}; }, exports: exports });
if (exportsIndex != -1)
depValues.splice(exportsIndex, 0, exports);
if (requireIndex != -1)
depValues.splice(requireIndex, 0, makeRequire(moduleName, require, loader));
var output = factory.apply(loader.global, depValues);
if (typeof output == 'undefined' && module)
output = module.exports;
if (typeof output != 'undefined')
return output;
}
};
// anonymous define
if (!name) {
// already defined anonymously -> throw
if (anonDefine)
throw "Multiple defines for anonymous module";
anonDefine = define;
}
// named define
else {
// if it has no dependencies and we don't have any other
// defines, then let this be an anonymous define
if (deps.length == 0 && !anonDefine && !defineBundle)
anonDefine = define;
// otherwise its a bundle only
else
anonDefine = null;
// the above is just to support single modules of the form:
// define('jquery')
// still loading anonymously
// because it is done widely enough to be useful
// note this is now a bundle
defineBundle = true;
// define the module through the register registry
loader.register(name, define.deps, false, define.execute);
}
};
loader.amdDefine = define;
loader.global.define = define;
loader.global.define.amd = {};
loader.global.define.loader = loader;
}
if (!isNode && loader.amdDefine !== false)
createDefine(loader);
if (loader.scriptLoader) {
var loaderFetch = loader.fetch;
loader.fetch = function(load) {
if (loader.amdDefine !== false)
createDefine(this);
return loaderFetch.call(this, load);
}
}
var loaderInstantiate = loader.instantiate;
loader.instantiate = function(load) {
var loader = this;
if (load.metadata.format == 'amd' || !load.metadata.format && load.source.match(amdRegEx)) {
load.metadata.format = 'amd';
createDefine(loader);
try {
loader.__exec(load);
}
catch (e) {
if (loader.execute === false && isNode) {
// use a regular expression to pull out deps
var match = load.source.match(amdRegEx);
if (match) {
// named or anonymous
if (match[1] && match[1][0] == '[')
define(match[1].substr(match[1].length - 2), eval(match[2]), function() {});
else if (match[2] && match[2][0] == '[')
define(eval(match[2]), function() {});
else
define(function() {});
}
}
else
throw e;
}
if (isNode)
loader.global.define = undefined;
if (!anonDefine && !defineBundle && !isNode)
throw "AMD module " + load.name + " did not define";
if (anonDefine) {
load.metadata.deps = load.metadata.deps ? load.metadata.deps.concat(anonDefine.deps) : anonDefine.deps;
load.metadata.execute = anonDefine.execute;
}
}
return loaderInstantiate.call(loader, load);
}
}
/*
SystemJS map support
Provides map configuration through
System.map['jquery'] = 'some/module/map'
As well as contextual map config through
System.map['bootstrap'] = {
jquery: 'some/module/map2'
}
Note that this applies for subpaths, just like RequireJS
jquery -> 'some/module/map'
jquery/path -> 'some/module/map/path'
bootstrap -> 'bootstrap'
Inside any module name of the form 'bootstrap' or 'bootstrap/*'
jquery -> 'some/module/map2'
jquery/p -> 'some/module/map2/p'
Maps are carefully applied from most specific contextual map, to least specific global map
*/
function map(loader) {
loader.map = loader.map || {};
// return if prefix parts (separated by '/') match the name
// eg prefixMatch('jquery/some/thing', 'jquery') -> true
// prefixMatch('jqueryhere/', 'jquery') -> false
function prefixMatch(name, prefix) {
if (name.length < prefix.length)
return false;
if (name.substr(0, prefix.length) != prefix)
return false;
if (name[prefix.length] && name[prefix.length] != '/')
return false;
return true;
}
// get the depth of a given path
// eg pathLen('some/name') -> 2
function pathLen(name) {
var len = 1;
for (var i = 0, l = name.length; i < l; i++)
if (name[i] === '/')
len++;
return len;
}
function doMap(name, matchLen, map) {
return map + name.substr(matchLen);
}
// given a relative-resolved module name and normalized parent name,
// apply the map configuration
function applyMap(name, parentName, loader) {
var curMatch, curMatchLength = 0;
var curParent, curParentMatchLength = 0;
var tmpParentLength, tmpPrefixLength;
var subPath;
var nameParts;
// first find most specific contextual match
if (parentName) {
for (var p in loader.map) {
var curMap = loader.map[p];
if (typeof curMap != 'object')
continue;
// most specific parent match wins first
if (!prefixMatch(parentName, p))
continue;
tmpParentLength = pathLen(p);
if (tmpParentLength <= curParentMatchLength)
continue;
for (var q in curMap) {
// most specific name match wins
if (!prefixMatch(name, q))
continue;
tmpPrefixLength = pathLen(q);
if (tmpPrefixLength <= curMatchLength)
continue;
curMatch = q;
curMatchLength = tmpPrefixLength;
curParent = p;
curParentMatchLength = tmpParentLength;
}
}
}
// if we found a contextual match, apply it now
if (curMatch)
return doMap(name, curMatch.length, loader.map[curParent][curMatch]);
// now do the global map
for (var p in loader.map) {
var curMap = loader.map[p];
if (typeof curMap != 'string')
continue;
if (!prefixMatch(name, p))
continue;
var tmpPrefixLength = pathLen(p);
if (tmpPrefixLength <= curMatchLength)
continue;
curMatch = p;
curMatchLength = tmpPrefixLength;
}
if (curMatch)
return doMap(name, curMatch.length, loader.map[curMatch]);
return name;
}
var loaderNormalize = loader.normalize;
loader.normalize = function(name, parentName, parentAddress) {
var loader = this;
if (!loader.map)
loader.map = {};
var isPackage = false;
if (name.substr(name.length - 1, 1) == '/') {
isPackage = true;
name += '#';
}
return Promise.resolve(loaderNormalize.call(loader, name, parentName, parentAddress))
.then(function(name) {
name = applyMap(name, parentName, loader);
// Normalize "module/" into "module/module"
// Convenient for packages
if (isPackage) {
var nameParts = name.split('/');
nameParts.pop();
var pkgName = nameParts.pop();
nameParts.push(pkgName);
nameParts.push(pkgName);
name = nameParts.join('/');
}
return name;
});
}
}
/*
SystemJS Plugin Support
Supports plugin syntax with "!"
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 plugins(loader) {
if (typeof indexOf == 'undefined')
indexOf = Array.prototype.indexOf;
var loaderNormalize = loader.normalize;
loader.normalize = function(name, parentName, parentAddress) {
var loader = this;
// if parent is a plugin, normalize against the parent plugin argument only
var parentPluginIndex;
if (parentName && (parentPluginIndex = parentName.indexOf('!')) != -1)
parentName = parentName.substr(0, parentPluginIndex);
return Promise.resolve(loaderNormalize.call(loader, name, parentName, parentAddress))
.then(function(name) {
// if this is a plugin, normalize the plugin name and the argument
var pluginIndex = name.lastIndexOf('!');
if (pluginIndex != -1) {
var argumentName = name.substr(0, pluginIndex);
// plugin name is part after "!" or the extension itself
var pluginName = name.substr(pluginIndex + 1) || argumentName.substr(argumentName.lastIndexOf('.') + 1);
// normalize the plugin name relative to the same parent
return new Promise(function(resolve) {
resolve(loader.normalize(pluginName, parentName, parentAddress));
})
// normalize the plugin argument
.then(function(_pluginName) {
pluginName = _pluginName;
return loader.normalize(argumentName, parentName, parentAddress);
})
.then(function(argumentName) {
return argumentName + '!' + pluginName;
});
}
// standard normalization
return name;
});
}
var loaderLocate = loader.locate;
loader.locate = function(load) {
var loader = this;
var name = load.name;
// plugin
var pluginIndex = name.lastIndexOf('!');
if (pluginIndex != -1) {
var pluginName = name.substr(pluginIndex + 1);
// the name to locate is the plugin argument only
load.name = name.substr(0, pluginIndex);
var pluginLoader = loader.pluginLoader || loader;
// load the plugin module
// NB ideally should use pluginLoader.load for normalized,
// but not currently working for some reason
return pluginLoader['import'](pluginName)
.then(function() {
var plugin = pluginLoader.get(pluginName);
plugin = plugin['default'] || plugin;
// allow plugins to opt-out of build
if (plugin.build === false && loader.pluginLoader)
load.metadata.build = false;
// store the plugin module itself on the metadata
load.metadata.plugin = plugin;
load.metadata.pluginName = pluginName;
load.metadata.pluginArgument = load.name;
// run plugin locate if given
if (plugin.locate)
return plugin.locate.call(loader, load);
// otherwise use standard locate without '.js' extension adding
else
return Promise.resolve(loader.locate(load))
.then(function(address) {
return address.substr(0, address.length - 3);
});
});
}
return loaderLocate.call(this, load);
}
var loaderFetch = loader.fetch;
loader.fetch = function(load) {
var loader = this;
if (load.metadata.build === false)
return '';
else if (load.metadata.plugin && load.metadata.plugin.fetch && !load.metadata.pluginFetchCalled) {
load.metadata.pluginFetchCalled = true;
return load.metadata.plugin.fetch.call(loader, load, loaderFetch);
}
else
return loaderFetch.call(loader, load);
}
var loaderTranslate = loader.translate;
loader.translate = function(load) {
var loader = this;
if (load.metadata.plugin && load.metadata.plugin.translate)
return Promise.resolve(load.metadata.plugin.translate.call(loader, load)).then(function(result) {
if (result)
return result;
else
return loaderTranslate.call(loader, load);
});
else
return loaderTranslate.call(loader, load);
}
var loaderInstantiate = loader.instantiate;
loader.instantiate = function(load) {
var loader = this;
if (load.metadata.plugin && load.metadata.plugin.instantiate)
return Promise.resolve(load.metadata.plugin.instantiate.call(loader, load)).then(function(result) {
load.metadata.format = 'defined';
load.metadata.execute = function() {
return result;
};
return loaderInstantiate.call(loader, load);
});
else if (load.metadata.plugin && load.metadata.plugin.build === false) {
load.metadata.format = 'defined';
load.metadata.deps.push(load.metadata.pluginName);
load.metadata.execute = function() {
return loader.newModule({});
};
return loaderInstantiate.call(loader, load);
}
else
return loaderInstantiate.call(loader, load);
}
}/*
System bundles
Allows a bundle module to be specified which will be dynamically
loaded before trying to load a given module.
For example:
System.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(loader) {
if (typeof indexOf == 'undefined')
indexOf = Array.prototype.indexOf;
// 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 System.bundles['mybundle'] = ['jquery', 'bootstrap/js/bootstrap']
loader.bundles = loader.bundles || {};
var loaderFetch = loader.fetch;
loader.fetch = function(load) {
var loader = this;
if (loader.trace)
return loaderFetch.call(this, load);
if (!loader.bundles)
loader.bundles = {};
// if this module is in a bundle, load the bundle first then
for (var b in loader.bundles) {
if (indexOf.call(loader.bundles[b], load.name) == -1)
continue;
// we do manual normalization in case the bundle is mapped
// this is so we can still know the normalized name is a bundle
return Promise.resolve(loader.normalize(b))
.then(function(normalized) {
loader.bundles[normalized] = loader.bundles[normalized] || loader.bundles[b];
// note this module is a bundle in the meta
loader.meta = loader.meta || {};
loader.meta[normalized] = loader.meta[normalized] || {};
loader.meta[normalized].bundle = true;
return loader.load(normalized);
})
.then(function() {
return '';
});
}
return loaderFetch.call(this, load);
}
}/*
SystemJS Semver Version Addon
1. Uses Semver convention for major and minor forms
Supports requesting a module from a package that contains a version suffix
with the following semver ranges:
module - any version
module@1 - major version 1, any minor (not prerelease)
module@1.2 - minor version 1.2, any patch (not prerelease)
module@1.2.3 - exact version
It is assumed that these modules are provided by the server / file system.
First checks the already-requested packages to see if there are any packages
that would match the same package and version range.
This provides a greedy algorithm as a simple fix for sharing version-managed
dependencies as much as possible, which can later be optimized through version
hint configuration created out of deeper version tree analysis.
2. Semver-compatibility syntax (caret operator - ^)
Compatible version request support is then also provided for:
module@^1.2.3 - module@1, >=1.2.3
module@^1.2 - module@1, >=1.2.0
module@^1 - module@1
module@^0.5.3 - module@0.5, >= 0.5.3
module@^0.0.1 - module@0.0.1
The ^ symbol is always normalized out to a normal version request.
This provides comprehensive semver compatibility.
3. System.versions version hints and version report
Note this addon should be provided after all other normalize overrides.
The full list of versions can be found at System.versions providing an insight
into any possible version forks.
It is also possible to create version solution hints on the System global:
System.versions = {
jquery: ['1.9.2', '2.0.3'],
bootstrap: '3.0.1'
};
Versions can be an array or string for a single version.
When a matching semver request is made (jquery@1.9, jquery@1, bootstrap@3)
they will be converted to the latest version match contained here, if present.
Prereleases in this versions list are also allowed to satisfy ranges when present.
*/
function versions(loader) {
if (typeof indexOf == 'undefined')
indexOf = Array.prototype.indexOf;
// match x, x.y, x.y.z, x.y.z-prerelease.1
var semverRegEx = /^(\d+)(?:\.(\d+)(?:\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?)?)?$/;
var semverCompare = function(v1, v2) {
var v1Parts = v1.split('.');
var v2Parts = v2.split('.');
var prereleaseIndex;
if (v1Parts[2] && (prereleaseIndex = indexOf.call(v1Parts[2], '-')) != -1)
v1Parts.splice(2, 1, v1Parts[2].substr(0, prereleaseIndex), v1Parts[2].substr(prereleaseIndex + 1));
if (v2Parts[2] && (prereleaseIndex = indexOf.call(v2Parts[2], '-')) != -1)
v2Parts.splice(2, 1, v2Parts[2].substr(0, prereleaseIndex), v2Parts[2].substr(prereleaseIndex + 1));
for (var i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
if (!v1Parts[i])
return 1;
else if (!v2Parts[i])
return -1;
if (v1Parts[i] != v2Parts[i])
return parseInt(v1Parts[i]) > parseInt(v2Parts[i]) ? 1 : -1;
}
return 0;
}
loader.versions = loader.versions || {};
var loaderNormalize = loader.normalize;
loader.normalize = function(name, parentName, parentAddress) {
if (!loader.versions)
loader.versions = {};
var packageVersions = this.versions;
// strip the version before applying map config
var stripVersion, stripSubPathLength;
if (name.indexOf('@') > 0) {
var versionIndex = name.lastIndexOf('@');
var parts = name.substr(versionIndex + 1, name.length - versionIndex - 1).split('/');
stripVersion = parts[0];
stripSubPathLength = parts.length;
name = name.substr(0, versionIndex) + name.substr(versionIndex + stripVersion.length + 1, name.length - versionIndex - stripVersion.length - 1);
}
// run all other normalizers first
return Promise.resolve(loaderNormalize.call(this, name, parentName, parentAddress)).then(function(normalized) {
var version, semverMatch, nextChar, versions;
var index = normalized.indexOf('@');
// if we stripped a version, and it still has no version, add it back
if (stripVersion && (index == -1 || index == 0)) {
var parts = normalized.split('/');
parts[parts.length - stripSubPathLength] += '@' + stripVersion;
normalized = parts.join('/');
index = normalized.indexOf('@');
}
// see if this module corresponds to a package already in our versioned packages list
// no version specified - check against the list (given we don't know the package name)
if (index == -1 || index == 0) {
for (var p in packageVersions) {
versions = packageVersions[p];
if (normalized.substr(0, p.length) != p)
continue;
nextChar = normalized.substr(p.length, 1);
if (nextChar && nextChar != '/')
continue;
// match -> take latest version
return p + '@' + (typeof versions == 'string' ? versions : versions[versions.length - 1]) + normalized.substr(p.length);
}
return normalized;
}
// get the version info
version = normalized.substr(index + 1).split('/')[0];
var versionLength = version.length;
var minVersion;
if (version.substr(0, 1) == '^') {
version = version.substr(1);
minVersion = true;
}
semverMatch = version.match(semverRegEx);
// if not a semver, we cant help
if (!semverMatch)
return normalized;
// translate '^' in range to simpler range form
if (minVersion) {
// ^0 -> 0
// ^1 -> 1
if (!semverMatch[2])
minVersion = false;
if (!semverMatch[3]) {
// ^1.1 -> ^1.1.0
if (semverMatch[2] > 0)
semverMatch[3] = '0';
// ^0.1 -> 0.1
// ^0.0 -> 0.0
else
minVersion = false;
}
}
if (minVersion) {
// >= 1.0.0
if (semverMatch[1] > 0) {
if (!semverMatch[2])
version = semverMatch[1] + '.0.0';
if (!semverMatch[3])
version = semverMatch[1] + '.0';
minVersion = version;
semverMatch = [semverMatch[1]];
}
// >= 0.1.0
else if (semverMatch[2] > 0) {
minVersion = version;
semverMatch = [0, semverMatch[2]];
}
// >= 0.0.0
else {
// NB compatible with prerelease is just prelease itself?
minVersion = false;
semverMatch = [0, 0, semverMatch[3]];
}
version = semverMatch.join('.');
}
var packageName = normalized.substr(0, index);
versions = packageVersions[packageName] || [];
if (typeof versions == 'string')
versions = [versions];
// look for a version match
// if an exact semver, theres nothing to match, just record it
if (!semverMatch[3] || minVersion)
for (var i = versions.length - 1; i >= 0; i--) {
var curVersion = versions[i];
// if I have requested x.y, find an x.y.z-b
// if I have requested x, find any x.y / x.y.z-b
if (curVersion.substr(0, version.length) == version && curVersion.substr(version.length, 1).match(/^[\.\-]?$/)) {
// if a minimum version, then check too
if (!minVersion || minVersion && semverCompare(curVersion, minVersion) != -1)
return packageName + '@' + curVersion + normalized.substr(packageName.length + versionLength + 1);
}
}
// no match
// record the package and semver for reuse since we're now asking the server
// x.y and x versions will now be latest by default, so they are useful in the version list
if (indexOf.call(versions, version) == -1) {
versions.push(version);
versions.sort(semverCompare);
normalized = packageName + '@' + version + normalized.substr(packageName.length + versionLength + 1);
// if this is an x.y.z, remove any x.y, x
// if this is an x.y, remove any x
if (semverMatch[3] && (index = indexOf.call(versions, semverMatch[1] + '.' + semverMatch[2])) != -1)
versions.splice(index, 1);
if (semverMatch[2] && (index = indexOf.call(versions, semverMatch[1])) != -1)
versions.splice(index, 1);
packageVersions[packageName] = versions.length == 1 ? versions[0] : versions;
}
return normalized;
});
}
}
/*
* 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:
* System.depCache = {
* 'app': ['normalized', 'deps'],
* 'normalized': ['another'],
* 'deps': ['tree']
* };
*
* System.import('app')
* // simultaneously starts loading all of:
* // 'normalized', 'deps', 'another', 'tree'
* // before "app" source is even loaded
*/
function depCache(loader) {
loader.depCache = loader.depCache || {};
loaderLocate = loader.locate;
loader.locate = function(load) {
var loader = this;
if (!loader.depCache)
loader.depCache = {};
// 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.load(deps[i]);
return loaderLocate.call(loader, load);
}
}
meta(System);
register(System);
core(System);
global(System);
cjs(System);
amd(System);
map(System);
plugins(System);
bundles(System);
versions(System);
depCache(System);
if (!System.paths['@traceur'])
System.paths['@traceur'] = __$curScript && __$curScript.getAttribute('data-traceur-src')
|| (__$curScript && __$curScript.src
? __$curScript.src.substr(0, __$curScript.src.lastIndexOf('/') + 1)
: System.baseURL + (System.baseURL.lastIndexOf('/') == System.baseURL.length - 1 ? '' : '/')
) + 'traceur.js';
};
function __eval(__source, __global, __address, __sourceMap) {
try {
__source = (__global != __$global ? 'with(__global) { (function() { ' + __source + ' \n }).call(__global); }' : __source)
+ '\n//# sourceURL=' + __address
+ (__sourceMap ? '\n//# sourceMappingURL=' + __sourceMap : '');
eval(__source);
}
catch(e) {
if (e.name == 'SyntaxError')
e.message = 'Evaluating ' + __address + '\n\t' + e.message;
if (System.trace && System.execute == false)
e = 'Execution error for ' + __address + ': ' + e.stack || e;
throw e;
}
}
var __$curScript;
(function(global) {
if (typeof window != 'undefined') {
var scripts = document.getElementsByTagName('script');
__$curScript = scripts[scripts.length - 1];
if (!global.System || !global.LoaderPolyfill) {
// determine the current script path as the base path
var curPath = __$curScript.src;
var basePath = curPath.substr(0, curPath.lastIndexOf('/') + 1);
document.write(
'<' + 'script type="text/javascript" src="' + basePath + 'es6-module-loader.js" data-init="upgradeSystemLoader">' + '<' + '/script>'
);
}
else {
global.upgradeSystemLoader();
}
}
else {
var es6ModuleLoader = require('es6-module-loader');
global.System = es6ModuleLoader.System;
global.Loader = es6ModuleLoader.Loader;
global.upgradeSystemLoader();
module.exports = global.System;
}
})(__$global);
})(typeof window != 'undefined' ? window : global);
Reference in New Issue View Git Blame Copy Permalink