1 (function (global
, factory
) {
2 typeof exports
=== 'object' && typeof module
!== 'undefined' ? module
.exports
= factory() :
3 typeof define
=== 'function' && define
.amd
? define(factory
) :
4 (global
.BrowserESModuleLoader
= factory());
5 }(this, (function () { 'use strict';
10 var isBrowser
= typeof window
!== 'undefined' && typeof document
!== 'undefined';
11 var isNode
= typeof process
!== 'undefined' && process
.versions
&& process
.versions
.node
;
12 var isWindows
= typeof process
!== 'undefined' && typeof process
.platform
=== 'string' && process
.platform
.match(/^win/);
14 var envGlobal
= typeof self
!== 'undefined' ? self
: global
;
16 * Simple Symbol() shim
18 var hasSymbol
= typeof Symbol
!== 'undefined';
19 function createSymbol (name
) {
20 return hasSymbol
? Symbol() : '@@' + name
;
23 var toStringTag
= hasSymbol
&& Symbol
.toStringTag
;
34 // environent baseURI detection
35 if (typeof document
!= 'undefined' && document
.getElementsByTagName
) {
36 baseURI
= document
.baseURI
;
39 var bases
= document
.getElementsByTagName('base');
40 baseURI
= bases
[0] && bases
[0].href
|| window
.location
.href
;
43 else if (typeof location
!= 'undefined') {
44 baseURI
= location
.href
;
47 // sanitize out the hash and querystring
49 baseURI
= baseURI
.split('#')[0].split('?')[0];
50 var slashIndex
= baseURI
.lastIndexOf('/');
51 if (slashIndex
!== -1)
52 baseURI
= baseURI
.substr(0, slashIndex
+ 1);
54 else if (typeof process
!== 'undefined' && process
.cwd
) {
55 baseURI
= 'file://' + (isWindows
? '/' : '') + process
.cwd();
57 baseURI
= baseURI
.replace(/\\/g, '/');
60 throw new TypeError('No environment baseURI
');
63 // ensure baseURI has trailing "/"
64 if (baseURI[baseURI.length - 1] !== '/')
68 * LoaderError with chaining for loader stacks
70 var errArgs = new Error(0, '_
').fileName == '_
';
71 function LoaderError__Check_error_message_for_loader_stack (childErr, newMessage) {
72 // Convert file:/// URLs to paths in Node
74 newMessage = newMessage.replace(isWindows ? /file:\/\/\//g : /file:\/\//g, '');
76 var message = (childErr.message || childErr) + '\n ' + newMessage;
79 if (errArgs && childErr.fileName)
80 err = new Error(message, childErr.fileName, childErr.lineNumber);
82 err = new Error(message);
85 var stack = childErr.originalErr ? childErr.originalErr.stack : childErr.stack;
88 // node doesn't show the message otherwise
89 err
.stack
= message
+ '\n ' + stack
;
93 err
.originalErr
= childErr
.originalErr
|| childErr
;
98 var resolvedPromise
$1 = Promise
.resolve();
101 * Simple Array values shim
103 function arrayValues (arr
) {
107 if (typeof Symbol
=== 'undefined' || !Symbol
.iterator
)
108 throw new Error('Symbol.iterator not supported in this browser');
111 iterable
[Symbol
.iterator
] = function () {
112 var keys
= Object
.keys(arr
);
116 if (keyIndex
< keys
.length
)
118 value
: arr
[keys
[keyIndex
++]],
135 * We skip the entire native internal pipeline, just providing the bare API
139 this.registry
= new Registry();
142 Loader
.prototype.constructor = Loader
;
144 function ensureInstantiated (module
) {
145 if (module
=== undefined)
147 if (module
instanceof ModuleNamespace
=== false && module
[toStringTag
] !== 'module')
148 throw new TypeError('Module instantiation did not return a valid namespace object.');
153 Loader
.prototype.import = function (key
, parent
) {
154 if (typeof key
!== 'string')
155 throw new TypeError('Loader import method must be passed a module key string');
156 // custom resolveInstantiate combined hook for better perf
158 return resolvedPromise
$1
160 return loader
[RESOLVE_INSTANTIATE
](key
, parent
);
162 .then(ensureInstantiated
)
163 //.then(Module.evaluate)
164 .catch(function (err
) {
165 throw LoaderError__Check_error_message_for_loader_stack(err
, 'Loading ' + key
+ (parent
? ' from ' + parent
: ''));
169 var RESOLVE
= Loader
.resolve
= createSymbol('resolve');
172 * Combined resolve / instantiate hook
174 * Not in current reduced spec, but necessary to separate RESOLVE from RESOLVE + INSTANTIATE as described
175 * in the spec notes of this repo to ensure that loader.resolve doesn't instantiate when not wanted.
177 * We implement RESOLVE_INSTANTIATE as a single hook instead of a separate INSTANTIATE in order to avoid
178 * the need for double registry lookups as a performance optimization.
180 var RESOLVE_INSTANTIATE
= Loader
.resolveInstantiate
= createSymbol('resolveInstantiate');
182 // default resolveInstantiate is just to call resolve and then get from the registry
183 // this provides compatibility for the resolveInstantiate optimization
184 Loader
.prototype[RESOLVE_INSTANTIATE
] = function (key
, parent
) {
186 return loader
.resolve(key
, parent
)
187 .then(function (resolved
) {
188 return loader
.registry
.get(resolved
);
192 function ensureResolution (resolvedKey
) {
193 if (resolvedKey
=== undefined)
194 throw new RangeError('No resolution found.');
198 Loader
.prototype.resolve = function (key
, parent
) {
200 return resolvedPromise
$1
202 return loader
[RESOLVE
](key
, parent
);
204 .then(ensureResolution
)
205 .catch(function (err
) {
206 throw LoaderError__Check_error_message_for_loader_stack(err
, 'Resolving ' + key
+ (parent
? ' to ' + parent
: ''));
210 // 3.3.4 (import without evaluate)
211 // this is not documented because the use of deferred evaluation as in Module.evaluate is not
212 // documented, as it is not considered a stable feature to be encouraged
213 // Loader.prototype.load may well be deprecated if this stays disabled
214 /* Loader.prototype.load = function (key, parent) {
215 return Promise.resolve(this[RESOLVE_INSTANTIATE](key, parent || this.key))
216 .catch(function (err) {
217 throw addToError(err, 'Loading ' + key + (parent ? ' from ' + parent : ''));
224 * Instead of structuring through a Map, just use a dictionary object
225 * We throw for construction attempts so this doesn't affect the public API
227 * Registry has been adjusted to use Namespace objects over ModuleStatus objects
228 * as part of simplifying loader API implementation
230 var iteratorSupport
= typeof Symbol
!== 'undefined' && Symbol
.iterator
;
231 var REGISTRY
= createSymbol('registry');
232 function Registry() {
236 if (iteratorSupport
) {
238 Registry
.prototype[Symbol
.iterator
] = function () {
239 return this.entries()[Symbol
.iterator
]();
243 Registry
.prototype.entries = function () {
244 var registry
= this[REGISTRY
];
245 return arrayValues(Object
.keys(registry
).map(function (key
) {
246 return [key
, registry
[key
]];
252 Registry
.prototype.keys = function () {
253 return arrayValues(Object
.keys(this[REGISTRY
]));
256 Registry
.prototype.values = function () {
257 var registry
= this[REGISTRY
];
258 return arrayValues(Object
.keys(registry
).map(function (key
) {
259 return registry
[key
];
263 Registry
.prototype.get = function (key
) {
264 return this[REGISTRY
][key
];
267 Registry
.prototype.set = function (key
, namespace) {
268 if (!(namespace instanceof ModuleNamespace
|| namespace[toStringTag
] === 'module'))
269 throw new Error('Registry must be set with an instance of Module Namespace');
270 this[REGISTRY
][key
] = namespace;
274 Registry
.prototype.has = function (key
) {
275 return Object
.hasOwnProperty
.call(this[REGISTRY
], key
);
278 Registry
.prototype.delete = function (key
) {
279 if (Object
.hasOwnProperty
.call(this[REGISTRY
], key
)) {
280 delete this[REGISTRY
][key
];
287 * Simple ModuleNamespace Exotic object based on a baseObject
288 * We export this for allowing a fast-path for module namespace creation over Module descriptors
290 // var EVALUATE = createSymbol('evaluate');
291 var BASE_OBJECT
= createSymbol('baseObject');
293 // 8.3.1 Reflect.Module
295 * Best-effort simplified non-spec implementation based on
296 * a baseObject referenced via getters.
300 * loader.registry.set('x', new Module({ default: 'x' }));
302 * Optional evaluation function provides experimental Module.evaluate
303 * support for non-executed modules in registry.
305 function ModuleNamespace (baseObject
/*, evaluate*/) {
306 Object
.defineProperty(this, BASE_OBJECT
, {
310 // evaluate defers namespace population
312 Object.defineProperty(this, EVALUATE, {
319 Object
.keys(baseObject
).forEach(extendNamespace
, this);
323 ModuleNamespace
.prototype = Object
.create(null);
326 Object
.defineProperty(ModuleNamespace
.prototype, toStringTag
, {
330 function extendNamespace (key
) {
331 Object
.defineProperty(this, key
, {
334 return this[BASE_OBJECT
][key
];
339 /* function doEvaluate (evaluate, context) {
341 evaluate.call(context);
348 // 8.4.1 Module.evaluate... not documented or used because this is potentially unstable
349 Module.evaluate = function (ns) {
350 var evaluate = ns[EVALUATE];
352 ns[EVALUATE] = undefined;
353 var err = doEvaluate(evaluate);
356 ns[EVALUATE] = function () {
361 Object.keys(ns[BASE_OBJECT]).forEach(extendNamespace, ns);
368 * Optimized URL normalization assuming a syntax-valid URL parent
370 function throwResolveError (relUrl
, parentUrl
) {
371 throw new RangeError('Unable to resolve "' + relUrl
+ '" to ' + parentUrl
);
373 var backslashRegEx
= /\\/g
;
374 function resolveIfNotPlain (relUrl
, parentUrl
) {
375 if (relUrl
[0] === ' ' || relUrl
[relUrl
.length
- 1] === ' ')
376 relUrl
= relUrl
.trim();
377 var parentProtocol
= parentUrl
&& parentUrl
.substr(0, parentUrl
.indexOf(':') + 1);
379 var firstChar
= relUrl
[0];
380 var secondChar
= relUrl
[1];
383 if (firstChar
=== '/' && secondChar
=== '/') {
385 throwResolveError(relUrl
, parentUrl
);
386 if (relUrl
.indexOf('\\') !== -1)
387 relUrl
= relUrl
.replace(backslashRegEx
, '/');
388 return parentProtocol
+ relUrl
;
391 else if (firstChar
=== '.' && (secondChar
=== '/' || secondChar
=== '.' && (relUrl
[2] === '/' || relUrl
.length
=== 2 && (relUrl
+= '/')) ||
392 relUrl
.length
=== 1 && (relUrl
+= '/')) ||
394 if (relUrl
.indexOf('\\') !== -1)
395 relUrl
= relUrl
.replace(backslashRegEx
, '/');
396 var parentIsPlain
= !parentProtocol
|| parentUrl
[parentProtocol
.length
] !== '/';
398 // read pathname from parent if a URL
399 // pathname taken to be part after leading "/"
402 // resolving to a plain parent -> skip standard URL prefix, and treat entire parent as pathname
403 if (parentUrl
=== undefined)
404 throwResolveError(relUrl
, parentUrl
);
405 pathname
= parentUrl
;
407 else if (parentUrl
[parentProtocol
.length
+ 1] === '/') {
408 // resolving to a :// so we need to read out the auth and host
409 if (parentProtocol
!== 'file:') {
410 pathname
= parentUrl
.substr(parentProtocol
.length
+ 2);
411 pathname
= pathname
.substr(pathname
.indexOf('/') + 1);
414 pathname
= parentUrl
.substr(8);
418 // resolving to :/ so pathname is the /... part
419 pathname
= parentUrl
.substr(parentProtocol
.length
+ 1);
422 if (firstChar
=== '/') {
424 throwResolveError(relUrl
, parentUrl
);
426 return parentUrl
.substr(0, parentUrl
.length
- pathname
.length
- 1) + relUrl
;
429 // join together and split for removal of .. and . segments
430 // looping the string instead of anything fancy for perf reasons
431 // '../../../../../z' resolved to 'x/y' is just 'z' regardless of parentIsPlain
432 var segmented
= pathname
.substr(0, pathname
.lastIndexOf('/') + 1) + relUrl
;
435 var segmentIndex
= -1;
437 for (var i
= 0; i
< segmented
.length
; i
++) {
438 // busy reading a segment - only terminate on '/'
439 if (segmentIndex
!== -1) {
440 if (segmented
[i
] === '/') {
441 output
.push(segmented
.substring(segmentIndex
, i
+ 1));
447 // new segment - check if it is relative
448 if (segmented
[i
] === '.') {
450 if (segmented
[i
+ 1] === '.' && (segmented
[i
+ 2] === '/' || i
+ 2 === segmented
.length
)) {
455 else if (segmented
[i
+ 1] === '/' || i
+ 1 === segmented
.length
) {
459 // the start of a new segment as below
464 // this is the plain URI backtracking error (../, package:x -> error)
465 if (parentIsPlain
&& output
.length
=== 0)
466 throwResolveError(relUrl
, parentUrl
);
471 // it is the start of a new segment
474 // finish reading out the last segment
475 if (segmentIndex
!== -1)
476 output
.push(segmented
.substr(segmentIndex
));
478 return parentUrl
.substr(0, parentUrl
.length
- pathname
.length
) + output
.join('');
481 // sanitizes and verifies (by returning undefined if not a valid URL-like form)
482 // Windows filepath compatibility is an added convenience here
483 var protocolIndex
= relUrl
.indexOf(':');
484 if (protocolIndex
!== -1) {
486 // C:\x becomes file:///c:/x (we don't support C|\x)
487 if (relUrl
[1] === ':' && relUrl
[2] === '\\' && relUrl
[0].match(/[a-z]/i))
488 return 'file:///' + relUrl
.replace(backslashRegEx
, '/');
494 var resolvedPromise
= Promise
.resolve();
498 * Builds directly on top of loader polyfill to provide:
499 * - loader.register support
500 * - hookable higher-level resolve
501 * - instantiate hook returning a ModuleNamespace or undefined for es module loading
502 * - loader error behaviour as in HTML and loader specs, caching load and eval errors separately
503 * - build tracing support by providing a .trace=true and .loads object format
506 var REGISTER_INTERNAL
= createSymbol('register-internal');
508 function RegisterLoader
$1 () {
511 var registryDelete
= this.registry
.delete;
512 this.registry
.delete = function (key
) {
513 var deleted
= registryDelete
.call(this, key
);
515 // also delete from register registry if linked
516 if (records
.hasOwnProperty(key
) && !records
[key
].linkRecord
) {
526 this[REGISTER_INTERNAL
] = {
527 // last anonymous System.register call
528 lastRegister
: undefined,
529 // in-flight es module load records
537 RegisterLoader
$1.prototype = Object
.create(Loader
.prototype);
538 RegisterLoader
$1.prototype.constructor = RegisterLoader
$1;
540 var INSTANTIATE
= RegisterLoader
$1.instantiate
= createSymbol('instantiate');
542 // default normalize is the WhatWG style normalizer
543 RegisterLoader
$1.prototype[RegisterLoader
$1.resolve
= Loader
.resolve
] = function (key
, parentKey
) {
544 return resolveIfNotPlain(key
, parentKey
|| baseURI
);
547 RegisterLoader
$1.prototype[INSTANTIATE
] = function (key
, processAnonRegister
) {};
549 // once evaluated, the linkRecord is set to undefined leaving just the other load record properties
550 // this allows tracking new binding listeners for es modules through importerSetters
551 // for dynamic modules, the load record is removed entirely.
552 function createLoadRecord (state
, key
, registration
) {
553 return state
.records
[key
] = {
556 // defined System.register cache
557 registration
: registration
,
559 // module namespace object
563 // this sticks around so new module loads can listen to binding changes
564 // for already-loaded modules by adding themselves to their importerSetters
565 importerSetters
: undefined,
567 loadError
: undefined,
568 evalError
: undefined,
570 // in-flight linking record
572 // promise for instantiated
573 instantiatePromise
: undefined,
574 dependencies
: undefined,
576 executingRequire
: false,
578 // underlying module object bindings
579 moduleObj
: undefined,
581 // es only, also indicates if es or not
584 // promise for instantiated dependencies (dependencyInstantiations populated)
585 depsInstantiatePromise
: undefined,
586 // will be the array of dependency load record or a module namespace
587 dependencyInstantiations
: undefined,
590 evaluatePromise
: undefined,
592 // NB optimization and way of ensuring module objects in setters
593 // indicates setters which should run pre-execution of that dependency
594 // setters is then just for completely executed module objects
595 // alternatively we just pass the partially filled module objects as
596 // arguments into the execute function
597 // hoisted: undefined
602 RegisterLoader
$1.prototype[Loader
.resolveInstantiate
] = function (key
, parentKey
) {
604 var state
= this[REGISTER_INTERNAL
];
605 var registry
= this.registry
[REGISTRY
];
607 return resolveInstantiate(loader
, key
, parentKey
, registry
, state
)
608 .then(function (instantiated
) {
609 if (instantiated
instanceof ModuleNamespace
|| instantiated
[toStringTag
] === 'module')
612 // resolveInstantiate always returns a load record with a link record and no module value
613 var link
= instantiated
.linkRecord
;
615 // if already beaten to done, return
617 if (instantiated
.module
)
618 return instantiated
.module
;
619 throw instantiated
.evalError
;
622 return deepInstantiateDeps(loader
, instantiated
, link
, registry
, state
)
624 return ensureEvaluate(loader
, instantiated
, link
, registry
, state
);
629 function resolveInstantiate (loader
, key
, parentKey
, registry
, state
) {
630 // normalization shortpath for already-normalized key
631 // could add a plain name filter, but doesn't yet seem necessary for perf
632 var module
= registry
[key
];
634 return Promise
.resolve(module
);
636 var load
= state
.records
[key
];
638 // already linked but not in main registry is ignored
639 if (load
&& !load
.module
) {
641 return Promise
.reject(load
.loadError
);
642 return instantiate(loader
, load
, load
.linkRecord
, registry
, state
);
645 return loader
.resolve(key
, parentKey
)
646 .then(function (resolvedKey
) {
647 // main loader registry always takes preference
648 module
= registry
[resolvedKey
];
652 load
= state
.records
[resolvedKey
];
654 // already has a module value but not already in the registry (load.module)
655 // means it was removed by registry.delete, so we should
656 // disgard the current load record creating a new one over it
657 // but keep any existing registration
658 if (!load
|| load
.module
)
659 load
= createLoadRecord(state
, resolvedKey
, load
&& load
.registration
);
662 return Promise
.reject(load
.loadError
);
664 var link
= load
.linkRecord
;
668 return instantiate(loader
, load
, link
, registry
, state
);
672 function createProcessAnonRegister (loader
, load
, state
) {
674 var lastRegister
= state
.lastRegister
;
677 return !!load
.registration
;
679 state
.lastRegister
= undefined;
680 load
.registration
= lastRegister
;
686 function instantiate (loader
, load
, link
, registry
, state
) {
687 return link
.instantiatePromise
|| (link
.instantiatePromise
=
688 // if there is already an existing registration, skip running instantiate
689 (load
.registration
? resolvedPromise
: resolvedPromise
.then(function () {
690 state
.lastRegister
= undefined;
691 return loader
[INSTANTIATE
](load
.key
, loader
[INSTANTIATE
].length
> 1 && createProcessAnonRegister(loader
, load
, state
));
693 .then(function (instantiation
) {
694 // direct module return from instantiate -> we're done
695 if (instantiation
!== undefined) {
696 if (!(instantiation
instanceof ModuleNamespace
|| instantiation
[toStringTag
] === 'module'))
697 throw new TypeError('Instantiate did not return a valid Module object.');
699 delete state
.records
[load
.key
];
701 traceLoad(loader
, load
, link
);
702 return registry
[load
.key
] = instantiation
;
705 // run the cached loader.register declaration if there is one
706 var registration
= load
.registration
;
707 // clear to allow new registrations for future loads (combined with registry delete)
708 load
.registration
= undefined;
710 throw new TypeError('Module instantiation did not call an anonymous or correctly named System.register.');
712 link
.dependencies
= registration
[0];
714 load
.importerSetters
= [];
718 // process System.registerDynamic declaration
719 if (registration
[2]) {
720 link
.moduleObj
.default = link
.moduleObj
.__useDefault
= {};
721 link
.executingRequire
= registration
[1];
722 link
.execute
= registration
[2];
725 // process System.register declaration
727 registerDeclarative(loader
, load
, link
, registration
[1]);
732 .catch(function (err
) {
733 load
.linkRecord
= undefined;
734 throw load
.loadError
= load
.loadError
|| LoaderError__Check_error_message_for_loader_stack(err
, 'Instantiating ' + load
.key
);
738 // like resolveInstantiate, but returning load records for linking
739 function resolveInstantiateDep (loader
, key
, parentKey
, registry
, state
, traceDepMap
) {
740 // normalization shortpaths for already-normalized key
741 // DISABLED to prioritise consistent resolver calls
742 // could add a plain name filter, but doesn't yet seem necessary for perf
743 /* var load = state.records[key];
744 var module = registry[key];
748 traceDepMap[key] = key;
750 // registry authority check in case module was deleted or replaced in main registry
751 if (load && load.module && load.module === module)
757 // already linked but not in main registry is ignored
758 if (load && !load.module) {
760 traceDepMap[key] = key;
761 return instantiate(loader, load, load.linkRecord, registry, state);
763 return loader
.resolve(key
, parentKey
)
764 .then(function (resolvedKey
) {
766 traceDepMap
[key
] = resolvedKey
;
768 // normalization shortpaths for already-normalized key
769 var load
= state
.records
[resolvedKey
];
770 var module
= registry
[resolvedKey
];
772 // main loader registry always takes preference
773 if (module
&& (!load
|| load
.module
&& module
!== load
.module
))
776 if (load
&& load
.loadError
)
777 throw load
.loadError
;
779 // already has a module value but not already in the registry (load.module)
780 // means it was removed by registry.delete, so we should
781 // disgard the current load record creating a new one over it
782 // but keep any existing registration
783 if (!load
|| !module
&& load
.module
)
784 load
= createLoadRecord(state
, resolvedKey
, load
&& load
.registration
);
786 var link
= load
.linkRecord
;
790 return instantiate(loader
, load
, link
, registry
, state
);
794 function traceLoad (loader
, load
, link
) {
795 loader
.loads
= loader
.loads
|| {};
796 loader
.loads
[load
.key
] = {
798 deps
: link
.dependencies
,
800 depMap
: link
.depMap
|| {}
805 * Convert a CJS module.exports into a valid object for new Module:
807 * new Module(getEsModule(module.exports))
809 * Sets the default value to the module, while also reading off named exports carefully.
811 function registerDeclarative (loader
, load
, link
, declare
) {
812 var moduleObj
= link
.moduleObj
;
813 var importerSetters
= load
.importerSetters
;
815 var definedExports
= false;
817 // closure especially not based on link to allow link record disposal
818 var declared
= declare
.call(envGlobal
, function (name
, value
) {
819 if (typeof name
=== 'object') {
821 for (var p
in name
) {
823 if (p
!== '__useDefault' && (!(p
in moduleObj
) || moduleObj
[p
] !== value
)) {
825 moduleObj
[p
] = value
;
828 if (changed
=== false)
832 if ((definedExports
|| name
in moduleObj
) && moduleObj
[name
] === value
)
834 moduleObj
[name
] = value
;
837 for (var i
= 0; i
< importerSetters
.length
; i
++)
838 importerSetters
[i
](moduleObj
);
841 }, new ContextualLoader(loader
, load
.key
));
843 link
.setters
= declared
.setters
|| [];
844 link
.execute
= declared
.execute
;
845 if (declared
.exports
) {
846 link
.moduleObj
= moduleObj
= declared
.exports
;
847 definedExports
= true;
851 function instantiateDeps (loader
, load
, link
, registry
, state
) {
852 if (link
.depsInstantiatePromise
)
853 return link
.depsInstantiatePromise
;
855 var depsInstantiatePromises
= Array(link
.dependencies
.length
);
857 for (var i
= 0; i
< link
.dependencies
.length
; i
++)
858 depsInstantiatePromises
[i
] = resolveInstantiateDep(loader
, link
.dependencies
[i
], load
.key
, registry
, state
, loader
.trace
&& link
.depMap
|| (link
.depMap
= {}));
860 var depsInstantiatePromise
= Promise
.all(depsInstantiatePromises
)
861 .then(function (dependencyInstantiations
) {
862 link
.dependencyInstantiations
= dependencyInstantiations
;
864 // run setters to set up bindings to instantiated dependencies
866 for (var i
= 0; i
< dependencyInstantiations
.length
; i
++) {
867 var setter
= link
.setters
[i
];
869 var instantiation
= dependencyInstantiations
[i
];
871 if (instantiation
instanceof ModuleNamespace
|| instantiation
[toStringTag
] === 'module') {
872 setter(instantiation
);
875 if (instantiation
.loadError
)
876 throw instantiation
.loadError
;
877 setter(instantiation
.module
|| instantiation
.linkRecord
.moduleObj
);
878 // this applies to both es and dynamic registrations
879 if (instantiation
.importerSetters
)
880 instantiation
.importerSetters
.push(setter
);
890 depsInstantiatePromise
= depsInstantiatePromise
.then(function () {
891 traceLoad(loader
, load
, link
);
895 depsInstantiatePromise
= depsInstantiatePromise
.catch(function (err
) {
896 // throw up the instantiateDeps stack
897 link
.depsInstantiatePromise
= undefined;
898 throw LoaderError__Check_error_message_for_loader_stack(err
, 'Loading ' + load
.key
);
901 depsInstantiatePromise
.catch(function () {});
903 return link
.depsInstantiatePromise
= depsInstantiatePromise
;
906 function deepInstantiateDeps (loader
, load
, link
, registry
, state
) {
908 function addDeps (load
, link
) {
910 return resolvedPromise
;
911 if (seen
.indexOf(load
) !== -1)
912 return resolvedPromise
;
915 return instantiateDeps(loader
, load
, link
, registry
, state
)
918 for (var i
= 0; i
< link
.dependencies
.length
; i
++) {
919 var depLoad
= link
.dependencyInstantiations
[i
];
920 if (!(depLoad
instanceof ModuleNamespace
|| depLoad
[toStringTag
] === 'module')) {
921 depPromises
= depPromises
|| [];
922 depPromises
.push(addDeps(depLoad
, depLoad
.linkRecord
));
926 return Promise
.all(depPromises
);
930 return addDeps(load
, link
);
936 RegisterLoader
$1.prototype.register = function (key
, deps
, declare
) {
937 var state
= this[REGISTER_INTERNAL
];
939 // anonymous modules get stored as lastAnon
940 if (declare
=== undefined) {
941 state
.lastRegister
= [key
, deps
, undefined];
944 // everything else registers into the register cache
946 var load
= state
.records
[key
] || createLoadRecord(state
, key
, undefined);
947 load
.registration
= [deps
, declare
, undefined];
952 * System.registerDyanmic
954 RegisterLoader
$1.prototype.registerDynamic = function (key
, deps
, executingRequire
, execute
) {
955 var state
= this[REGISTER_INTERNAL
];
957 // anonymous modules get stored as lastAnon
958 if (typeof key
!== 'string') {
959 state
.lastRegister
= [key
, deps
, executingRequire
];
962 // everything else registers into the register cache
964 var load
= state
.records
[key
] || createLoadRecord(state
, key
, undefined);
965 load
.registration
= [deps
, executingRequire
, execute
];
969 // ContextualLoader class
970 // backwards-compatible with previous System.register context argument by exposing .id, .key
971 function ContextualLoader (loader
, key
) {
972 this.loader
= loader
;
973 this.key
= this.id
= key
;
976 // scriptElement: null
979 /*ContextualLoader.prototype.constructor = function () {
980 throw new TypeError('Cannot subclass the contextual loader only Reflect.Loader.');
982 ContextualLoader
.prototype.import = function (key
) {
983 if (this.loader
.trace
)
984 this.loader
.loads
[this.key
].dynamicDeps
.push(key
);
985 return this.loader
.import(key
, this.key
);
987 /*ContextualLoader.prototype.resolve = function (key) {
988 return this.loader.resolve(key, this.key);
991 function ensureEvaluate (loader
, load
, link
, registry
, state
) {
995 throw load
.evalError
;
996 if (link
.evaluatePromise
)
997 return link
.evaluatePromise
;
1000 var evaluatePromise
= doEvaluateDeclarative(loader
, load
, link
, registry
, state
, [load
]);
1001 if (evaluatePromise
)
1002 return evaluatePromise
;
1005 doEvaluateDynamic(loader
, load
, link
, registry
, state
, [load
]);
1010 function makeDynamicRequire (loader
, key
, dependencies
, dependencyInstantiations
, registry
, state
, seen
) {
1011 // we can only require from already-known dependencies
1012 return function (name
) {
1013 for (var i
= 0; i
< dependencies
.length
; i
++) {
1014 if (dependencies
[i
] === name
) {
1015 var depLoad
= dependencyInstantiations
[i
];
1018 if (depLoad
instanceof ModuleNamespace
|| depLoad
[toStringTag
] === 'module') {
1022 if (depLoad
.evalError
)
1023 throw depLoad
.evalError
;
1024 if (depLoad
.module
=== undefined && seen
.indexOf(depLoad
) === -1 && !depLoad
.linkRecord
.evaluatePromise
) {
1025 if (depLoad
.linkRecord
.setters
) {
1026 doEvaluateDeclarative(loader
, depLoad
, depLoad
.linkRecord
, registry
, state
, [depLoad
]);
1030 doEvaluateDynamic(loader
, depLoad
, depLoad
.linkRecord
, registry
, state
, seen
);
1033 module
= depLoad
.module
|| depLoad
.linkRecord
.moduleObj
;
1036 return '__useDefault' in module
? module
.__useDefault
: module
;
1039 throw new Error('Module ' + name
+ ' not declared as a System.registerDynamic dependency of ' + key
);
1043 function evalError (load
, err
) {
1044 load
.linkRecord
= undefined;
1045 var evalError
= LoaderError__Check_error_message_for_loader_stack(err
, 'Evaluating ' + load
.key
);
1046 if (load
.evalError
=== undefined)
1047 load
.evalError
= evalError
;
1051 // es modules evaluate dependencies first
1052 // returns the error if any
1053 function doEvaluateDeclarative (loader
, load
, link
, registry
, state
, seen
) {
1054 var depLoad
, depLink
;
1055 var depLoadPromises
;
1056 for (var i
= 0; i
< link
.dependencies
.length
; i
++) {
1057 var depLoad
= link
.dependencyInstantiations
[i
];
1058 if (depLoad
instanceof ModuleNamespace
|| depLoad
[toStringTag
] === 'module')
1061 // custom Module returned from instantiate
1062 depLink
= depLoad
.linkRecord
;
1064 if (depLoad
.evalError
) {
1065 evalError(load
, depLoad
.evalError
);
1067 else if (depLink
.setters
) {
1068 if (seen
.indexOf(depLoad
) === -1) {
1071 var depLoadPromise
= doEvaluateDeclarative(loader
, depLoad
, depLink
, registry
, state
, seen
);
1076 if (depLoadPromise
) {
1077 depLoadPromises
= depLoadPromises
|| [];
1078 depLoadPromises
.push(depLoadPromise
.catch(function (err
) {
1079 evalError(load
, err
);
1086 doEvaluateDynamic(loader
, depLoad
, depLink
, registry
, state
, [depLoad
]);
1095 if (depLoadPromises
)
1096 return link
.evaluatePromise
= Promise
.all(depLoadPromises
)
1099 // ES System.register execute
1100 // "this" is null in ES
1102 var execPromise
= link
.execute
.call(nullContext
);
1108 return execPromise
.catch(function (e
) {
1112 load
.linkRecord
= undefined;
1113 return registry
[load
.key
] = load
.module
= new ModuleNamespace(link
.moduleObj
);
1117 // dispose link record
1118 load
.linkRecord
= undefined;
1119 registry
[load
.key
] = load
.module
= new ModuleNamespace(link
.moduleObj
);
1123 // ES System.register execute
1124 // "this" is null in ES
1126 var execPromise
= link
.execute
.call(nullContext
);
1132 return link
.evaluatePromise
= execPromise
.catch(function (e
) {
1136 load
.linkRecord
= undefined;
1137 return registry
[load
.key
] = load
.module
= new ModuleNamespace(link
.moduleObj
);
1141 // dispose link record
1142 load
.linkRecord
= undefined;
1143 registry
[load
.key
] = load
.module
= new ModuleNamespace(link
.moduleObj
);
1146 // non es modules explicitly call moduleEvaluate through require
1147 function doEvaluateDynamic (loader
, load
, link
, registry
, state
, seen
) {
1148 // System.registerDynamic execute
1149 // "this" is "exports" in CJS
1150 var module
= { id
: load
.key
};
1151 var moduleObj
= link
.moduleObj
;
1152 Object
.defineProperty(module
, 'exports', {
1154 set: function (exports
) {
1155 moduleObj
.default = moduleObj
.__useDefault
= exports
;
1158 return moduleObj
.__useDefault
;
1162 var require
= makeDynamicRequire(loader
, load
.key
, link
.dependencies
, link
.dependencyInstantiations
, registry
, state
, seen
);
1164 // evaluate deps first
1165 if (!link
.executingRequire
)
1166 for (var i
= 0; i
< link
.dependencies
.length
; i
++)
1167 require(link
.dependencies
[i
]);
1170 var output
= link
.execute
.call(envGlobal
, require
, moduleObj
.default, module
);
1171 if (output
!== undefined)
1172 module
.exports
= output
;
1178 load
.linkRecord
= undefined;
1180 // pick up defineProperty calls to module.exports when we can
1181 if (module
.exports
!== moduleObj
.__useDefault
)
1182 moduleObj
.default = moduleObj
.__useDefault
= module
.exports
;
1184 var moduleDefault
= moduleObj
.default;
1186 // __esModule flag extension support via lifting
1187 if (moduleDefault
&& moduleDefault
.__esModule
) {
1188 for (var p
in moduleDefault
) {
1189 if (Object
.hasOwnProperty
.call(moduleDefault
, p
))
1190 moduleObj
[p
] = moduleDefault
[p
];
1194 registry
[load
.key
] = load
.module
= new ModuleNamespace(link
.moduleObj
);
1196 // run importer setters and clear them
1197 // this allows dynamic modules to update themselves into es modules
1198 // as soon as execution has completed
1199 if (load
.importerSetters
)
1200 for (var i
= 0; i
< load
.importerSetters
.length
; i
++)
1201 load
.importerSetters
[i
](load
.module
);
1202 load
.importerSetters
= undefined;
1205 // the closest we can get to call(undefined)
1206 var nullContext
= Object
.create(null);
1208 Object
.freeze(nullContext
);
1212 // <script type="module"> support
1213 var anonSources
= {};
1214 if (typeof document
!= 'undefined' && document
.getElementsByTagName
) {
1215 var handleError = function(err
) {
1216 // dispatch an error event so that we can display in errors in browsers
1217 // that don't yet support unhandledrejection
1218 if (window
.onunhandledrejection
=== undefined) {
1220 var evt
= new Event('error');
1221 } catch (_eventError
) {
1222 var evt
= document
.createEvent('Event');
1223 evt
.initEvent('error', true, true);
1225 evt
.message
= err
.message
;
1227 evt
.filename
= err
.fileName
;
1228 evt
.lineno
= err
.lineNumber
;
1229 evt
.colno
= err
.columnNumber
;
1230 } else if (err
.sourceURL
) {
1231 evt
.filename
= err
.sourceURL
;
1232 evt
.lineno
= err
.line
;
1233 evt
.colno
= err
.column
;
1236 window
.dispatchEvent(evt
);
1239 // throw so it still shows up in the console
1243 var ready = function() {
1244 document
.removeEventListener('DOMContentLoaded', ready
, false );
1248 var scripts
= document
.getElementsByTagName('script');
1249 for (var i
= 0; i
< scripts
.length
; i
++) {
1250 var script
= scripts
[i
];
1251 if (script
.type
== 'module' && !script
.loaded
) {
1252 script
.loaded
= true;
1254 loader
.import(script
.src
).catch(handleError
);
1256 // anonymous modules supported via a custom naming scheme and registry
1258 var uri
= './<anon' + ++anonCnt
+ '>.js';
1259 if (script
.id
!== ""){
1260 uri
= "./" + script
.id
;
1263 var anonName
= resolveIfNotPlain(uri
, baseURI
);
1264 anonSources
[anonName
] = script
.innerHTML
;
1265 loader
.import(anonName
).catch(handleError
);
1272 if (document
.readyState
=== 'complete')
1275 document
.addEventListener('DOMContentLoaded', ready
, false);
1278 function BrowserESModuleLoader(baseKey
) {
1280 this.baseKey
= resolveIfNotPlain(baseKey
, baseURI
) || resolveIfNotPlain('./' + baseKey
, baseURI
);
1282 RegisterLoader
$1.call(this);
1286 // ensure System.register is available
1287 envGlobal
.System
= envGlobal
.System
|| {};
1288 if (typeof envGlobal
.System
.register
== 'function')
1289 var prevRegister
= envGlobal
.System
.register
;
1290 envGlobal
.System
.register = function() {
1291 loader
.register
.apply(loader
, arguments
);
1293 prevRegister
.apply(this, arguments
);
1296 BrowserESModuleLoader
.prototype = Object
.create(RegisterLoader
$1.prototype);
1298 // normalize is never given a relative name like "./x", that part is already handled
1299 BrowserESModuleLoader
.prototype[RegisterLoader
$1.resolve
] = function(key
, parent
) {
1300 var resolved
= RegisterLoader
$1.prototype[RegisterLoader
$1.resolve
].call(this, key
, parent
|| this.baseKey
) || key
;
1302 throw new RangeError('ES module loader does not resolve plain module names, resolving "' + key
+ '" to ' + parent
);
1307 function xhrFetch(url
, resolve
, reject
) {
1308 var xhr
= new XMLHttpRequest();
1309 var load = function(source
) {
1310 resolve(xhr
.responseText
);
1312 var error = function() {
1313 reject(new Error('XHR error' + (xhr
.status
? ' (' + xhr
.status
+ (xhr
.statusText
? ' ' + xhr
.statusText
: '') + ')' : '') + ' loading ' + url
));
1316 xhr
.onreadystatechange = function () {
1317 if (xhr
.readyState
=== 4) {
1318 // in Chrome on file:/// URLs, status is 0
1319 if (xhr
.status
== 0) {
1320 if (xhr
.responseText
) {
1324 // when responseText is empty, wait for load or error event
1325 // to inform if it is a 404 or empty file
1326 xhr
.addEventListener('error', error
);
1327 xhr
.addEventListener('load', load
);
1330 else if (xhr
.status
=== 200) {
1338 xhr
.open("GET", url
, true);
1342 var WorkerPool = function (script
, size
) {
1343 var current
= document
.currentScript
;
1344 // IE doesn't support currentScript
1346 // Find an entry with out basename
1347 var scripts
= document
.getElementsByTagName('script');
1348 for (var i
= 0; i
< scripts
.length
; i
++) {
1349 if (scripts
[i
].src
.indexOf("browser-es-module-loader.js") !== -1) {
1350 current
= scripts
[i
];
1355 throw Error("Could not find own <script> element");
1357 script
= current
.src
.substr(0, current
.src
.lastIndexOf("/")) + "/" + script
;
1358 this._workers
= new Array(size
);
1362 this.onmessage
= undefined;
1363 this._stopTimeout
= undefined;
1364 for (var i
= 0; i
< size
; i
++) {
1365 var wrkr
= new Worker(script
);
1368 wrkr
.onmessage
= this._onmessage
.bind(this, wrkr
);
1369 wrkr
.onerror
= this._onerror
.bind(this);
1370 this._workers
[i
] = wrkr
;
1375 WorkerPool
.prototype = {
1376 postMessage: function (msg
) {
1377 if (this._stopTimeout
!== undefined) {
1378 clearTimeout(this._stopTimeout
);
1379 this._stopTimeout
= undefined;
1381 var wrkr
= this._workers
[this._ind
% this._size
];
1384 wrkr
.postMessage(msg
);
1388 _onmessage: function (wrkr
, evt
) {
1391 this.onmessage(evt
, wrkr
);
1395 _onerror: function(err
) {
1397 var evt
= new Event('error');
1398 } catch (_eventError
) {
1399 var evt
= document
.createEvent('Event');
1400 evt
.initEvent('error', true, true);
1402 evt
.message
= err
.message
;
1403 evt
.filename
= err
.filename
;
1404 evt
.lineno
= err
.lineno
;
1405 evt
.colno
= err
.colno
;
1406 evt
.error
= err
.error
;
1407 window
.dispatchEvent(evt
);
1410 _checkJobs: function () {
1411 if (this._jobs
=== 0 && this._stopTimeout
=== undefined) {
1412 // wait for 2s of inactivity before stopping (that should be enough for local loading)
1413 this._stopTimeout
= setTimeout(this._stop
.bind(this), 2000);
1417 _stop: function () {
1418 this._workers
.forEach(function(wrkr
) {
1424 var promiseMap
= new Map();
1425 var babelWorker
= new WorkerPool('babel-worker.js', 3);
1426 babelWorker
.onmessage = function (evt
) {
1427 var promFuncs
= promiseMap
.get(evt
.data
.key
);
1428 promFuncs
.resolve(evt
.data
);
1429 promiseMap
.delete(evt
.data
.key
);
1432 // instantiate just needs to run System.register
1433 // so we fetch the source, convert into the Babel System module format, then evaluate it
1434 BrowserESModuleLoader
.prototype[RegisterLoader
$1.instantiate
] = function(key
, processAnonRegister
) {
1437 // load as ES with Babel converting into System.register
1438 return new Promise(function(resolve
, reject
) {
1440 if (anonSources
[key
]) {
1441 resolve(anonSources
[key
]);
1442 anonSources
[key
] = undefined;
1444 // otherwise we fetch
1446 xhrFetch(key
, resolve
, reject
);
1449 .then(function(source
) {
1450 // check our cache first
1451 var cacheEntry
= localStorage
.getItem(key
);
1453 cacheEntry
= JSON
.parse(cacheEntry
);
1454 // TODO: store a hash instead
1455 if (cacheEntry
.source
=== source
) {
1456 return Promise
.resolve({key
: key
, code
: cacheEntry
.code
, source
: cacheEntry
.source
});
1459 return new Promise(function (resolve
, reject
) {
1460 promiseMap
.set(key
, {resolve
: resolve
, reject
: reject
});
1461 babelWorker
.postMessage({key
: key
, source
: source
});
1463 }).then(function (data
) {
1464 // evaluate without require, exports and module variables
1465 // we leave module in for now to allow module.require access
1467 var cacheEntry
= JSON
.stringify({source
: data
.source
, code
: data
.code
});
1468 localStorage
.setItem(key
, cacheEntry
);
1470 if (window
.console
) {
1471 window
.console
.warn('Unable to cache transpiled version of ' + key
+ ': ' + e
);
1474 (0, eval
)(data
.code
+ '\n//# sourceURL=' + data
.key
+ '!transpiled');
1475 processAnonRegister();
1479 // create a default loader instance in the browser
1481 loader
= new BrowserESModuleLoader();
1483 return BrowserESModuleLoader
;
1486 //# sourceMappingURL=browser-es-module-loader.js.map