mirror of
https://github.com/koalyptus/TableFilter.git
synced 2024-05-17 22:06:41 +02:00
2411 lines
72 KiB
JavaScript
2411 lines
72 KiB
JavaScript
/*
|
|
* SystemJS v0.16.8
|
|
*/
|
|
|
|
(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;
|
|
}
|
|
|
|
var isWindows = typeof process != 'undefined' && !!process.platform.match(/^win/);
|
|
|
|
// 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) === '/' ? '/' : '');
|
|
}
|
|
|
|
if (isWindows)
|
|
href = href.replace(/\\/g, '/');
|
|
|
|
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 System;
|
|
(function() {
|
|
var originalSystem = $__global.System;
|
|
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;
|
|
}
|
|
|
|
|
|
/*
|
|
* SystemJS Core
|
|
* Code should be vaguely readable
|
|
*
|
|
*/
|
|
var originalSystem = $__global.System.originalSystem;
|
|
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({}));
|
|
|
|
// include the node require since we're overriding it
|
|
if (typeof require != 'undefined')
|
|
loader._nodeRequire = require;
|
|
|
|
/*
|
|
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' && !(v instanceof Array)) {
|
|
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' &&
|
|
typeof WorkerGlobalScope == 'undefined' && typeof process != 'undefined') {
|
|
baseURI = 'file:' + process.cwd() + '/';
|
|
if (isWindows)
|
|
baseURI = baseURI.replace(/\\/g, '/');
|
|
}
|
|
// Inside of a Web Worker
|
|
else if (typeof window == 'undefined') {
|
|
baseURI = location.href;
|
|
}
|
|
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));
|
|
}
|
|
|
|
function applyExtensions(extensions, loader) {
|
|
loader._extensions = [];
|
|
for(var i = 0, len = extensions.length; i < len; i++) {
|
|
extensions[i](loader);
|
|
}
|
|
}
|
|
|
|
loader._extensions = loader._extensions || [];
|
|
loader._extensions.push(core);
|
|
|
|
loader.clone = function() {
|
|
var originalLoader = this;
|
|
var loader = new LoaderPolyfill(originalSystem);
|
|
loader.baseURL = originalLoader.baseURL;
|
|
loader.paths = { '*': '*.js' };
|
|
applyExtensions(originalLoader._extensions, loader);
|
|
return loader;
|
|
};
|
|
}
|
|
/*
|
|
* 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 advance, 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 = {};
|
|
loader._extensions = loader._extensions || [];
|
|
loader._extensions.push(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 if (!load.metadata[metaName])
|
|
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' || typeof document != 'undefined' && !document.addEventListener)
|
|
__eval = 0 || eval; // uglify breaks without the 0 ||
|
|
|
|
loader._extensions = loader._extensions || [];
|
|
loader._extensions.push(register);
|
|
|
|
// 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;
|
|
// 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, load.address, sourceMappingURL);
|
|
}
|
|
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 registerModule(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
|
|
register = {
|
|
declarative: true,
|
|
deps: deps,
|
|
declare: declare
|
|
};
|
|
}
|
|
|
|
// named register
|
|
if (name) {
|
|
register.name = name;
|
|
// we never overwrite an existing define
|
|
if (!(name in loader.defined))
|
|
loader.defined[name] = register;
|
|
}
|
|
// anonymous register
|
|
else if (register.declarative) {
|
|
if (anonRegister)
|
|
throw new TypeError('Multiple anonymous System.register calls in the same module file.');
|
|
anonRegister = register;
|
|
}
|
|
}
|
|
/*
|
|
* Registry side table - 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 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 = registerModule;
|
|
|
|
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 (calledRegister) {
|
|
load.metadata.format = load.metadata.format || 'register';
|
|
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 !== undefined) {
|
|
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 TypeError("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
|
|
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(loader.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 = indexOf.call(importerModule.dependencies, module);
|
|
importerModule.setters[importerIndex](exports);
|
|
}
|
|
}
|
|
|
|
module.locked = false;
|
|
return value;
|
|
});
|
|
|
|
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) {
|
|
if (depEntry.module.exports && depEntry.module.exports.__esModule)
|
|
depExports = depEntry.module.exports;
|
|
else
|
|
depExports = { 'default': depEntry.module.exports, '__useDefault': true };
|
|
}
|
|
// 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 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 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 };
|
|
|
|
function linkDeps() {
|
|
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);
|
|
}
|
|
}
|
|
|
|
// AMD requires execute the tree first
|
|
if (!entry.executingRequire)
|
|
linkDeps();
|
|
|
|
// 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);
|
|
}
|
|
throw new TypeError('Module ' + name + ' not declared as a dependency.');
|
|
}, exports, module);
|
|
|
|
// in case we missed anything, link it now
|
|
// this does mean that deferred execution isn't supported
|
|
if (entry.executingRequire)
|
|
linkDeps();
|
|
|
|
if (output)
|
|
module.exports = 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 || 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);
|
|
}
|
|
|
|
// override the delete method to also clear the register caches
|
|
var loaderDelete = loader['delete'];
|
|
loader['delete'] = function(name) {
|
|
delete moduleRecords[name];
|
|
return loaderDelete.call(this, name);
|
|
};
|
|
|
|
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 = registerModule;
|
|
|
|
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];
|
|
entry.deps = entry.deps.concat(load.metadata.deps);
|
|
}
|
|
|
|
// 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 curSystem = loader.global.System;
|
|
|
|
loader.global.System = loader;
|
|
|
|
loader.__exec(load);
|
|
|
|
loader.global.System = curSystem;
|
|
|
|
if (anonRegister)
|
|
entry = anonRegister;
|
|
else
|
|
load.metadata.bundle = true;
|
|
|
|
if (!entry && System.defined[load.name])
|
|
entry = System.defined[load.name];
|
|
|
|
if (!calledRegister && !load.metadata.registered)
|
|
throw new TypeError(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: load.metadata.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() {
|
|
// 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 = entry.module.exports;
|
|
|
|
if (!module || !entry.declarative && module.__esModule !== true)
|
|
module = { 'default': module, __useDefault: true };
|
|
|
|
// return the defined module object
|
|
return loader.newModule(module);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
}
|
|
/*
|
|
* Extension to detect ES6 and auto-load Traceur or Babel for processing
|
|
*/
|
|
function es6(loader) {
|
|
loader._extensions.push(es6);
|
|
|
|
// good enough ES6 detection regex - format detections not designed to be accurate, but to handle the 99% use case
|
|
var es6RegEx = /(^\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*\./;
|
|
|
|
var transpilerNormalized, transpilerRuntimeNormalized;
|
|
|
|
var firstLoad = true;
|
|
|
|
var nodeResolver = typeof process != 'undefined' && typeof require != 'undefined' && require.resolve;
|
|
|
|
function configNodeGlobal(loader, module, nodeModule, wilcardDummy) {
|
|
loader.meta = loader.meta || {};
|
|
var meta = loader.meta[module] = loader.meta[module] || {};
|
|
meta.format = meta.format || 'global';
|
|
if (!loader.paths[module]) {
|
|
var path = resolvePath(nodeModule, wilcardDummy);
|
|
if (path) {
|
|
loader.paths[module] = path;
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolvePath(nodeModule, wildcard) {
|
|
if (nodeResolver) {
|
|
var ext = wildcard ? '/package.json' : '';
|
|
try {
|
|
var match = nodeResolver(nodeModule + ext);
|
|
return 'file:' + match.substr(0, match.length - ext.length) + (wildcard ? '/*.js' : '');
|
|
}
|
|
catch(e) {}
|
|
}
|
|
}
|
|
|
|
var loaderLocate = loader.locate;
|
|
loader.locate = function(load) {
|
|
var self = this;
|
|
if (firstLoad) {
|
|
if (self.transpiler == 'traceur') {
|
|
configNodeGlobal(self, 'traceur', 'traceur/bin/traceur.js');
|
|
self.meta['traceur'].exports = 'traceur';
|
|
configNodeGlobal(self, 'traceur-runtime', 'traceur/bin/traceur-runtime.js');
|
|
}
|
|
else if (self.transpiler == 'babel') {
|
|
configNodeGlobal(self, 'babel', 'babel-core/browser.js');
|
|
configNodeGlobal(self, 'babel/external-helpers', 'babel-core/external-helpers.js');
|
|
configNodeGlobal(self, 'babel-runtime/*', 'babel-runtime', true);
|
|
}
|
|
firstLoad = false;
|
|
}
|
|
return loaderLocate.call(self, load);
|
|
};
|
|
|
|
var loaderTranslate = loader.translate;
|
|
loader.translate = function(load) {
|
|
var loader = this;
|
|
|
|
return loaderTranslate.call(loader, load)
|
|
.then(function(source) {
|
|
|
|
// detect ES6
|
|
if (load.metadata.format == 'es6' || !load.metadata.format && source.match(es6RegEx)) {
|
|
load.metadata.format = 'es6';
|
|
return source;
|
|
}
|
|
|
|
if (load.metadata.format == 'register') {
|
|
if (!loader.global.$traceurRuntime && load.source.match(traceurRuntimeRegEx)) {
|
|
return loader['import']('traceur-runtime').then(function() {
|
|
return source;
|
|
});
|
|
}
|
|
if (!loader.global.babelHelpers && load.source.match(babelHelpersRegEx)) {
|
|
return loader['import']('babel/external-helpers').then(function() {
|
|
return source;
|
|
});
|
|
}
|
|
}
|
|
|
|
// ensure Traceur doesn't clobber the System global
|
|
if (loader.transpiler == 'traceur')
|
|
return Promise.all([
|
|
transpilerNormalized || (transpilerNormalized = loader.normalize(loader.transpiler)),
|
|
transpilerRuntimeNormalized || (transpilerRuntimeNormalized = loader.normalize(loader.transpiler + '-runtime'))
|
|
])
|
|
.then(function(normalized) {
|
|
if (load.name == normalized[0] || load.name == normalized[1])
|
|
return '(function() { var curSystem = System; ' + source + '\nSystem = curSystem; })();';
|
|
|
|
return source;
|
|
});
|
|
|
|
return source;
|
|
});
|
|
|
|
};
|
|
|
|
}
|
|
/*
|
|
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) {
|
|
|
|
loader._extensions.push(global);
|
|
|
|
function readGlobalProperty(p, value) {
|
|
var pParts = p.split('.');
|
|
while (pParts.length)
|
|
value = value[pParts.shift()];
|
|
return value;
|
|
}
|
|
|
|
var ignoredGlobalProps = ['indexedDB', 'sessionStorage', 'localStorage',
|
|
'clipboardData', 'frames', 'webkitStorageInfo', 'toolbar', 'statusbar',
|
|
'scrollbars', 'personalbar', 'menubar', 'locationbar', 'webkitIndexedDB',
|
|
'screenTop', 'screenLeft', 'external'];
|
|
|
|
var globalName = typeof window != 'undefined' ? 'window' : (typeof global != 'undefined' ? 'global' : 'self');
|
|
|
|
try {
|
|
var hasOwnProperty = loader.global.hasOwnProperty;
|
|
// throws in Safari web-worker
|
|
loader.global.hasOwnProperty('window');
|
|
}
|
|
catch(e) {
|
|
hasOwnProperty = false;
|
|
}
|
|
|
|
function forEachGlobal(callback) {
|
|
for (var g in loader.global) {
|
|
var curGlobal;
|
|
if (indexOf.call(ignoredGlobalProps, g) != -1)
|
|
continue;
|
|
if (hasOwnProperty && !loader.global.hasOwnProperty(g))
|
|
continue;
|
|
try {
|
|
curGlobal = loader.global[g];
|
|
} catch (e) {
|
|
ignoredGlobalProps.push(g);
|
|
}
|
|
if (curGlobal !== loader.global)
|
|
callback(g, curGlobal);
|
|
}
|
|
}
|
|
|
|
function createHelpers(loader) {
|
|
if (loader.has('@@global-helpers'))
|
|
return;
|
|
|
|
var moduleGlobals = {};
|
|
|
|
var curGlobalObj;
|
|
|
|
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 = {};
|
|
|
|
forEachGlobal(function(name, value) {
|
|
curGlobalObj[name] = value;
|
|
});
|
|
},
|
|
retrieveGlobal: function(moduleName, exportName, init) {
|
|
var singleGlobal;
|
|
var multipleExports;
|
|
var exports = {};
|
|
|
|
// run init
|
|
if (init)
|
|
singleGlobal = init.call(loader.global);
|
|
|
|
// 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
|
|
else if (exportName) {
|
|
var firstPart = exportName.split('.')[0];
|
|
singleGlobal = readGlobalProperty(exportName, loader.global);
|
|
exports[firstPart] = loader.global[firstPart];
|
|
}
|
|
|
|
else {
|
|
forEachGlobal(function(name, value) {
|
|
if (curGlobalObj[name] === value)
|
|
return;
|
|
if (typeof value === 'undefined')
|
|
return;
|
|
exports[name] = value;
|
|
if (typeof singleGlobal !== 'undefined') {
|
|
if (!multipleExports && singleGlobal !== value)
|
|
multipleExports = true;
|
|
}
|
|
else {
|
|
singleGlobal = value;
|
|
}
|
|
});
|
|
}
|
|
|
|
moduleGlobals[moduleName] = exports;
|
|
|
|
return multipleExports ? exports : singleGlobal;
|
|
}
|
|
}));
|
|
}
|
|
|
|
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, module) {
|
|
|
|
loader.get('@@global-helpers').prepareGlobal(module.id, load.metadata.deps);
|
|
|
|
if (exportName)
|
|
load.source += globalName + '["' + exportName + '"] = ' + exportName + ';';
|
|
|
|
// disable module detection
|
|
var define = loader.global.define;
|
|
var require = loader.global.require;
|
|
|
|
loader.global.define = undefined;
|
|
loader.global.module = undefined;
|
|
loader.global.exports = undefined;
|
|
|
|
loader.__exec(load);
|
|
|
|
loader.global.require = require;
|
|
loader.global.define = define;
|
|
|
|
return loader.get('@@global-helpers').retrieveGlobal(module.id, exportName, load.metadata.init);
|
|
}
|
|
}
|
|
return loaderInstantiate.call(loader, load);
|
|
}
|
|
}
|
|
/*
|
|
SystemJS CommonJS Format
|
|
*/
|
|
function cjs(loader) {
|
|
loader._extensions.push(cjs);
|
|
|
|
// CJS Module Format
|
|
// require('...') || exports[''] = ... || exports.asd = ... || module.exports = ...
|
|
var cjsExportsRegEx = /(?:^\uFEFF?|[^$_a-zA-Z\xA0-\uFFFF.]|module\.)(exports\s*\[['"]|\exports\s*\.)|(?:^\uFEFF?|[^$_a-zA-Z\xA0-\uFFFF.])module\.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;
|
|
|
|
function getCJSDeps(source) {
|
|
cjsRequireRegEx.lastIndex = 0;
|
|
|
|
var deps = [];
|
|
|
|
// remove comments from the source first, if not minified
|
|
if (source.length / source.split('\n').length < 200)
|
|
source = source.replace(commentRegEx, '');
|
|
|
|
var match;
|
|
|
|
while (match = cjsRequireRegEx.exec(source))
|
|
deps.push(match[1].substr(1, match[1].length - 2));
|
|
|
|
return deps;
|
|
}
|
|
|
|
if (typeof location != 'undefined' && location.origin)
|
|
var curOrigin = location.origin;
|
|
|
|
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)) : getCJSDeps(load.source);
|
|
|
|
load.metadata.executingRequire = true;
|
|
|
|
load.metadata.execute = function(require, exports, module) {
|
|
var dirname = (load.address || '').split('/');
|
|
dirname.pop();
|
|
dirname = dirname.join('/');
|
|
|
|
var address = load.address;
|
|
|
|
if (curOrigin && address.substr(0, curOrigin.length) === curOrigin) {
|
|
address = address.substr(curOrigin.length);
|
|
dirname = dirname.substr(curOrigin.length);
|
|
}
|
|
else if (address.substr(0, 5) == 'file:') {
|
|
address = address.substr(5);
|
|
dirname = dirname.substr(5);
|
|
}
|
|
|
|
// if on the server, remove the "file:" part from the dirname
|
|
if (System._nodeRequire)
|
|
dirname = dirname.substr(5);
|
|
|
|
var globals = loader.global._g = {
|
|
global: loader.global,
|
|
exports: exports,
|
|
module: module,
|
|
require: require,
|
|
__filename: address,
|
|
__dirname: dirname
|
|
};
|
|
|
|
var source = '(function(global, exports, module, require, __filename, __dirname) { ' + load.source
|
|
+ '\n}).call(_g.exports, _g.global, _g.exports, _g.module, _g.require, _g.__filename, _g.__dirname);';
|
|
|
|
// disable AMD detection
|
|
var define = loader.global.define;
|
|
loader.global.define = undefined;
|
|
|
|
loader.__exec({
|
|
name: load.name,
|
|
address: load.address,
|
|
source: source
|
|
});
|
|
|
|
loader.global.define = define;
|
|
|
|
loader.global._g = undefined;
|
|
}
|
|
}
|
|
|
|
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) {
|
|
// by default we only enforce AMD noConflict mode in Node
|
|
var isNode = typeof module != 'undefined' && module.exports;
|
|
|
|
loader._extensions.push(amd);
|
|
|
|
// 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]*\))/;
|
|
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) {
|
|
// '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) {
|
|
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(names);
|
|
return module.__useDefault ? module['default'] : module;
|
|
}
|
|
|
|
else
|
|
throw new TypeError('Invalid require');
|
|
};
|
|
loader.amdRequire = function() {
|
|
return require.apply(this, arguments);
|
|
};
|
|
|
|
function makeRequire(parentName, staticRequire, loader) {
|
|
return function(names, callback, errback) {
|
|
if (typeof names == 'string') {
|
|
if (typeof callback === 'function')
|
|
names = [names];
|
|
else
|
|
return staticRequire(names);
|
|
}
|
|
return require.call(loader, names, callback, errback, { name: parentName });
|
|
}
|
|
}
|
|
|
|
// run once per loader
|
|
function generateDefine(loader) {
|
|
// 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';
|
|
load.metadata.registered = true;
|
|
}
|
|
|
|
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;
|
|
deps = ['require', 'exports', 'module'];
|
|
}
|
|
|
|
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);
|
|
|
|
var factoryText = factory.toString();
|
|
|
|
deps = deps.concat(getCJSDeps(factoryText, requireIndex));
|
|
}
|
|
|
|
|
|
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, module) {
|
|
|
|
var depValues = [];
|
|
for (var i = 0; i < deps.length; i++)
|
|
depValues.push(require(deps[i]));
|
|
|
|
module.uri = loader.baseURL + 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)
|
|
depValues.splice(requireIndex, 0, makeRequire(module.id, require, loader));
|
|
|
|
var output = factory.apply(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 new TypeError('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);
|
|
}
|
|
};
|
|
define.amd = {};
|
|
loader.amdDefine = define;
|
|
}
|
|
|
|
var anonDefine;
|
|
// set to true if the current module turns out to be a named define bundle
|
|
var defineBundle;
|
|
|
|
var oldModule, oldExports, oldDefine;
|
|
|
|
// adds define as a global (potentially just temporarily)
|
|
function createDefine(loader) {
|
|
if (!loader.amdDefine)
|
|
generateDefine(loader);
|
|
|
|
anonDefine = null;
|
|
defineBundle = null;
|
|
|
|
// ensure no NodeJS environment detection
|
|
var global = loader.global;
|
|
|
|
oldModule = global.module;
|
|
oldExports = global.exports;
|
|
oldDefine = global.define;
|
|
|
|
global.module = undefined;
|
|
global.exports = undefined;
|
|
|
|
if (global.define && global.define === loader.amdDefine)
|
|
return;
|
|
|
|
global.define = loader.amdDefine;
|
|
}
|
|
|
|
function removeDefine(loader) {
|
|
var global = loader.global;
|
|
global.define = oldDefine;
|
|
global.module = oldModule;
|
|
global.exports = oldExports;
|
|
}
|
|
|
|
generateDefine(loader);
|
|
|
|
if (loader.scriptLoader) {
|
|
var loaderFetch = loader.fetch;
|
|
loader.fetch = function(load) {
|
|
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';
|
|
|
|
if (loader.execute !== false) {
|
|
createDefine(loader);
|
|
|
|
loader.__exec(load);
|
|
|
|
removeDefine(loader);
|
|
|
|
if (!anonDefine && !defineBundle && !isNode)
|
|
throw new TypeError('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 || {};
|
|
|
|
loader._extensions.push(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;
|
|
|
|
loader._extensions.push(plugins);
|
|
|
|
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;
|
|
|
|
// only fetch the plugin itself if this name isn't defined
|
|
if (this.defined && this.defined[name])
|
|
return loaderLocate.call(this, load);
|
|
|
|
// 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.replace(/\.js$/, '');
|
|
});
|
|
});
|
|
}
|
|
|
|
return loaderLocate.call(this, load);
|
|
};
|
|
|
|
var loaderFetch = loader.fetch;
|
|
loader.fetch = function(load) {
|
|
var loader = this;
|
|
// ignore fetching build = false unless in a plugin loader
|
|
if (load.metadata.build === false && loader.pluginLoader)
|
|
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 (typeof result == 'string')
|
|
load.source = result;
|
|
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;
|
|
|
|
loader._extensions.push(bundles);
|
|
|
|
// 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 loadedBundles = [];
|
|
|
|
function loadFromBundle(loader, bundle) {
|
|
// 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(bundle))
|
|
.then(function(normalized) {
|
|
if (indexOf.call(loadedBundles, normalized) == -1) {
|
|
loadedBundles.push(normalized);
|
|
loader.bundles[normalized] = loader.bundles[normalized] || loader.bundles[bundle];
|
|
|
|
// 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 '';
|
|
});
|
|
}
|
|
|
|
var loaderFetch = loader.fetch;
|
|
loader.fetch = function(load) {
|
|
var loader = this;
|
|
if (loader.trace)
|
|
return loaderFetch.call(this, load);
|
|
if (!loader.bundles)
|
|
loader.bundles = {};
|
|
|
|
// check what bundles we've already loaded
|
|
for (var i = 0; i < loadedBundles.length; i++) {
|
|
if (indexOf.call(loader.bundles[loadedBundles[i]], load.name) == -1)
|
|
continue;
|
|
|
|
return loadFromBundle(loader, loadedBundles[i]);
|
|
}
|
|
|
|
// 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;
|
|
|
|
return loadFromBundle(loader, b);
|
|
}
|
|
|
|
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;
|
|
|
|
loader._extensions.push(versions);
|
|
|
|
var semverRegEx = /^(\d+)(?:\.(\d+)(?:\.(\d+)(?:-([\da-z-]+(?:\.[\da-z-]+)*)(?:\+([\da-z-]+(?:\.[\da-z-]+)*))?)?)?)?$/i;
|
|
var numRegEx = /^\d+$/;
|
|
|
|
function toInt(num) {
|
|
return parseInt(num, 10);
|
|
}
|
|
|
|
function parseSemver(v) {
|
|
var semver = v.match(semverRegEx);
|
|
if (!semver)
|
|
return {
|
|
tag: v
|
|
};
|
|
else
|
|
return {
|
|
major: toInt(semver[1]),
|
|
minor: toInt(semver[2]),
|
|
patch: toInt(semver[3]),
|
|
pre: semver[4] && semver[4].split('.')
|
|
};
|
|
}
|
|
|
|
var parts = ['major', 'minor', 'patch'];
|
|
function semverCompareParsed(v1, v2) {
|
|
// not semvers - tags have equal precedence
|
|
if (v1.tag && v2.tag)
|
|
return 0;
|
|
|
|
// semver beats non-semver
|
|
if (v1.tag)
|
|
return -1;
|
|
if (v2.tag)
|
|
return 1;
|
|
|
|
// compare version numbers
|
|
for (var i = 0; i < parts.length; i++) {
|
|
var part = parts[i];
|
|
var part1 = v1[part];
|
|
var part2 = v2[part];
|
|
if (part1 == part2)
|
|
continue;
|
|
if (isNaN(part1))
|
|
return -1;
|
|
if (isNaN(part2))
|
|
return 1;
|
|
return part1 > part2 ? 1 : -1;
|
|
}
|
|
|
|
if (!v1.pre && !v2.pre)
|
|
return 0;
|
|
|
|
if (!v1.pre)
|
|
return 1;
|
|
if (!v2.pre)
|
|
return -1;
|
|
|
|
// prerelease comparison
|
|
for (var i = 0, l = Math.min(v1.pre.length, v2.pre.length); i < l; i++) {
|
|
if (v1.pre[i] == v2.pre[i])
|
|
continue;
|
|
|
|
var isNum1 = v1.pre[i].match(numRegEx);
|
|
var isNum2 = v2.pre[i].match(numRegEx);
|
|
|
|
// numeric has lower precedence
|
|
if (isNum1 && !isNum2)
|
|
return -1;
|
|
if (isNum2 && !isNum1)
|
|
return 1;
|
|
|
|
// compare parts
|
|
if (isNum1 && isNum2)
|
|
return toInt(v1.pre[i]) > toInt(v2.pre[i]) ? 1 : -1;
|
|
else
|
|
return v1.pre[i] > v2.pre[i] ? 1 : -1;
|
|
}
|
|
|
|
if (v1.pre.length == v2.pre.length)
|
|
return 0;
|
|
|
|
// more pre-release fields win if equal
|
|
return v1.pre.length > v2.pre.length ? 1 : -1;
|
|
}
|
|
|
|
// match against a parsed range object
|
|
// saves operation repetition
|
|
// doesn't support tags
|
|
// if not semver or fuzzy, assume exact
|
|
function matchParsed(range, version) {
|
|
var rangeVersion = range.version;
|
|
|
|
if (rangeVersion.tag)
|
|
return rangeVersion.tag == version.tag;
|
|
|
|
// if the version is less than the range, it's not a match
|
|
if (semverCompareParsed(rangeVersion, version) == 1)
|
|
return false;
|
|
|
|
// now we just have to check that the version isn't too high for the range
|
|
if (isNaN(version.minor) || isNaN(version.patch))
|
|
return false;
|
|
|
|
// if the version has a prerelease, ensure the range version has a prerelease in it
|
|
// and that we match the range version up to the prerelease exactly
|
|
if (version.pre) {
|
|
if (!(rangeVersion.major == version.major && rangeVersion.minor == version.minor && rangeVersion.patch == version.patch))
|
|
return false;
|
|
return range.semver || range.fuzzy || rangeVersion.pre.join('.') == version.pre.join('.');
|
|
}
|
|
|
|
// check semver range
|
|
if (range.semver) {
|
|
// ^0
|
|
if (rangeVersion.major == 0 && isNaN(rangeVersion.minor))
|
|
return version.major < 1;
|
|
// ^1..
|
|
else if (rangeVersion.major >= 1)
|
|
return rangeVersion.major == version.major;
|
|
// ^0.1, ^0.2
|
|
else if (rangeVersion.minor >= 1)
|
|
return rangeVersion.minor == version.minor;
|
|
// ^0.0.0
|
|
else
|
|
return (rangeVersion.patch || 0) == version.patch;
|
|
}
|
|
|
|
// check fuzzy range
|
|
if (range.fuzzy)
|
|
return version.major == rangeVersion.major && version.minor < (rangeVersion.minor || 0) + 1;
|
|
|
|
// exact match
|
|
// eg 001.002.003 matches 1.2.3
|
|
return !rangeVersion.pre && rangeVersion.major == version.major && rangeVersion.minor == version.minor && rangeVersion.patch == version.patch;
|
|
}
|
|
|
|
/*
|
|
* semver - is this a semver range
|
|
* fuzzy - is this a fuzzy range
|
|
* version - the parsed version object
|
|
*/
|
|
function parseRange(range) {
|
|
var rangeObj = {};
|
|
|
|
((rangeObj.semver = range.substr(0, 1) == '^')
|
|
|| (rangeObj.fuzzy = range.substr(0, 1) == '~')
|
|
) && (range = range.substr(1));
|
|
|
|
var rangeVersion = rangeObj.version = parseSemver(range);
|
|
|
|
if (rangeVersion.tag)
|
|
return rangeObj;
|
|
|
|
// 0, 0.1 behave like ~0, ~0.1
|
|
if (!rangeObj.fuzzy && !rangeObj.semver && (isNaN(rangeVersion.minor) || isNaN(rangeVersion.patch)))
|
|
rangeObj.fuzzy = true;
|
|
|
|
// ~1, ~0 behave like ^1, ^0
|
|
if (rangeObj.fuzzy && isNaN(rangeVersion.minor)) {
|
|
rangeObj.semver = true;
|
|
rangeObj.fuzzy = false;
|
|
}
|
|
|
|
// ^0.0 behaves like ~0.0
|
|
if (rangeObj.semver && !isNaN(rangeVersion.minor) && isNaN(rangeVersion.patch)) {
|
|
rangeObj.semver = false;
|
|
rangeObj.fuzzy = true;
|
|
}
|
|
|
|
return rangeObj;
|
|
}
|
|
|
|
function semverCompare(v1, v2) {
|
|
return semverCompareParsed(parseSemver(v1), parseSemver(v2));
|
|
}
|
|
|
|
loader.versions = loader.versions || {};
|
|
|
|
var loaderNormalize = loader.normalize;
|
|
// NOW use modified match algorithm if possible
|
|
loader.normalize = function(name, parentName, parentAddress) {
|
|
if (!this.versions)
|
|
this.versions = {};
|
|
var packageVersions = this.versions;
|
|
|
|
// strip the version before applying map config
|
|
var stripVersion, stripSubPathLength;
|
|
var versionIndex = name.indexOf('!') != -1 ? 0 : name.lastIndexOf('@');
|
|
if (versionIndex > 0) {
|
|
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 index = normalized.indexOf('!') != -1 ? 0 : 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)
|
|
var nextChar, versions;
|
|
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
|
|
var packageName = normalized.substr(0, index);
|
|
var range = normalized.substr(index + 1).split('/')[0];
|
|
var rangeLength = range.length;
|
|
var parsedRange = parseRange(normalized.substr(index + 1).split('/')[0]);
|
|
versions = packageVersions[normalized.substr(0, index)] || [];
|
|
if (typeof versions == 'string')
|
|
versions = [versions];
|
|
|
|
// find a match in our version list
|
|
for (var i = versions.length - 1; i >= 0; i--) {
|
|
if (matchParsed(parsedRange, parseSemver(versions[i])))
|
|
return packageName + '@' + versions[i] + normalized.substr(index + rangeLength + 1);
|
|
}
|
|
|
|
// no match found -> send a request to the server
|
|
var versionRequest;
|
|
if (parsedRange.semver) {
|
|
versionRequest = parsedRange.version.major == 0 && !isNaN(parsedRange.version.minor) ? '0.' + parsedRange.version.minor : parsedRange.version.major;
|
|
}
|
|
else if (parsedRange.fuzzy) {
|
|
versionRequest = parsedRange.version.major + '.' + parsedRange.version.minor;
|
|
}
|
|
else {
|
|
versionRequest = range;
|
|
versions.push(range);
|
|
versions.sort(semverCompare);
|
|
packageVersions[packageName] = versions.length == 1 ? versions[0] : versions;
|
|
}
|
|
|
|
return packageName + '@' + versionRequest + normalized.substr(index + rangeLength + 1);
|
|
});
|
|
}
|
|
}
|
|
/*
|
|
* 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 || {};
|
|
|
|
loader._extensions.push(depCache);
|
|
|
|
var 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);
|
|
}
|
|
}
|
|
|
|
core(System);
|
|
meta(System);
|
|
register(System);
|
|
es6(System);
|
|
global(System);
|
|
cjs(System);
|
|
amd(System);
|
|
map(System);
|
|
plugins(System);
|
|
bundles(System);
|
|
versions(System);
|
|
depCache(System);
|
|
|
|
};
|
|
|
|
var $__curScript, __eval;
|
|
|
|
(function() {
|
|
|
|
var doEval;
|
|
|
|
__eval = function(source, address, sourceMap) {
|
|
source += '\n//# sourceURL=' + address + (sourceMap ? '\n//# sourceMappingURL=' + sourceMap : '');
|
|
|
|
try {
|
|
doEval(source);
|
|
}
|
|
catch(e) {
|
|
var msg = 'Error evaluating ' + address + '\n';
|
|
if (e instanceof Error)
|
|
e.message = msg + e.message;
|
|
else
|
|
e = msg + e;
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
if (typeof document != 'undefined') {
|
|
var head;
|
|
|
|
var scripts = document.getElementsByTagName('script');
|
|
$__curScript = scripts[scripts.length - 1];
|
|
|
|
// globally scoped eval for the browser
|
|
doEval = function(source) {
|
|
if (!head)
|
|
head = document.head || document.body || document.documentElement;
|
|
|
|
var script = document.createElement('script');
|
|
script.text = source;
|
|
var onerror = window.onerror;
|
|
var e;
|
|
window.onerror = function(_e) {
|
|
e = _e;
|
|
}
|
|
head.appendChild(script);
|
|
head.removeChild(script);
|
|
window.onerror = onerror;
|
|
if (e)
|
|
throw e;
|
|
}
|
|
|
|
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 if (typeof importScripts != 'undefined') {
|
|
doEval = function(source) {
|
|
try {
|
|
eval(source);
|
|
} catch(e) {
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
if (!$__global.System || !$__global.LoaderPolyfill) {
|
|
var basePath = '';
|
|
try {
|
|
throw new Error('Get worker base path via error stack');
|
|
} catch (e) {
|
|
e.stack.replace(/(?:at|@).*(http.+):[\d]+:[\d]+/, function (m, url) {
|
|
basePath = url.replace(/\/[^\/]*$/, '/');
|
|
});
|
|
}
|
|
importScripts(basePath + 'es6-module-loader.js');
|
|
$__global.upgradeSystemLoader();
|
|
} 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 scoped eval for node
|
|
var vm = require('vm');
|
|
doEval = function(source, address, sourceMap) {
|
|
vm.runInThisContext(source);
|
|
}
|
|
}
|
|
})();
|
|
|
|
})(typeof window != 'undefined' ? window : (typeof global != 'undefined' ? global : self));
|