(global.BrowserESModuleLoader = factory());
}(this, (function () { 'use strict';
-/*
- * Environment
- */
-var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
-var isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
-var isWindows = typeof process !== 'undefined' && typeof process.platform === 'string' && process.platform.match(/^win/);
-
-var envGlobal = typeof self !== 'undefined' ? self : global;
-/*
- * Simple Symbol() shim
- */
-var hasSymbol = typeof Symbol !== 'undefined';
-function createSymbol (name) {
- return hasSymbol ? Symbol() : '@@' + name;
-}
-
-
-
-
-
-/*
- * Environment baseURI
- */
-var baseURI;
-
-// environent baseURI detection
-if (typeof document != 'undefined' && document.getElementsByTagName) {
- baseURI = document.baseURI;
-
- if (!baseURI) {
- var bases = document.getElementsByTagName('base');
- baseURI = bases[0] && bases[0].href || window.location.href;
- }
-}
-else if (typeof location != 'undefined') {
- baseURI = location.href;
-}
-
-// sanitize out the hash and querystring
-if (baseURI) {
- baseURI = baseURI.split('#')[0].split('?')[0];
- var slashIndex = baseURI.lastIndexOf('/');
- if (slashIndex !== -1)
- baseURI = baseURI.substr(0, slashIndex + 1);
-}
-else if (typeof process !== 'undefined' && process.cwd) {
- baseURI = 'file://' + (isWindows ? '/' : '') + process.cwd();
- if (isWindows)
- baseURI = baseURI.replace(/\\/g, '/');
-}
-else {
- throw new TypeError('No environment baseURI');
-}
-
-// ensure baseURI has trailing "/"
-if (baseURI[baseURI.length - 1] !== '/')
- baseURI += '/';
-
-/*
- * LoaderError with chaining for loader stacks
- */
-var errArgs = new Error(0, '_').fileName == '_';
-function LoaderError__Check_error_message_for_loader_stack (childErr, newMessage) {
- // Convert file:/// URLs to paths in Node
- if (!isBrowser)
- newMessage = newMessage.replace(isWindows ? /file:\/\/\//g : /file:\/\//g, '');
-
- var message = (childErr.message || childErr) + '\n ' + newMessage;
-
- var err;
- if (errArgs && childErr.fileName)
- err = new Error(message, childErr.fileName, childErr.lineNumber);
- else
- err = new Error(message);
-
-
- var stack = childErr.originalErr ? childErr.originalErr.stack : childErr.stack;
-
- if (isNode)
- // node doesn't show the message otherwise
- err.stack = message + '\n ' + stack;
- else
- err.stack = stack;
-
- err.originalErr = childErr.originalErr || childErr;
-
- return err;
+/*\r
+ * Environment\r
+ */\r
+var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';\r
+var isNode = typeof process !== 'undefined' && process.versions && process.versions.node;\r
+var isWindows = typeof process !== 'undefined' && typeof process.platform === 'string' && process.platform.match(/^win/);\r
+\r
+var envGlobal = typeof self !== 'undefined' ? self : global;\r
+/*\r
+ * Simple Symbol() shim\r
+ */\r
+var hasSymbol = typeof Symbol !== 'undefined';\r
+function createSymbol (name) {\r
+ return hasSymbol ? Symbol() : '@@' + name;\r
+}\r
+\r
+var toStringTag = hasSymbol && Symbol.toStringTag;\r
+\r
+\r
+\r
+\r
+\r
+/*\r
+ * Environment baseURI\r
+ */\r
+var baseURI;\r
+\r
+// environent baseURI detection\r
+if (typeof document != 'undefined' && document.getElementsByTagName) {\r
+ baseURI = document.baseURI;\r
+\r
+ if (!baseURI) {\r
+ var bases = document.getElementsByTagName('base');\r
+ baseURI = bases[0] && bases[0].href || window.location.href;\r
+ }\r
+}\r
+else if (typeof location != 'undefined') {\r
+ baseURI = location.href;\r
+}\r
+\r
+// sanitize out the hash and querystring\r
+if (baseURI) {\r
+ baseURI = baseURI.split('#')[0].split('?')[0];\r
+ var slashIndex = baseURI.lastIndexOf('/');\r
+ if (slashIndex !== -1)\r
+ baseURI = baseURI.substr(0, slashIndex + 1);\r
+}\r
+else if (typeof process !== 'undefined' && process.cwd) {\r
+ baseURI = 'file://' + (isWindows ? '/' : '') + process.cwd();\r
+ if (isWindows)\r
+ baseURI = baseURI.replace(/\\/g, '/');\r
+}\r
+else {\r
+ throw new TypeError('No environment baseURI');\r
+}\r
+\r
+// ensure baseURI has trailing "/"\r
+if (baseURI[baseURI.length - 1] !== '/')\r
+ baseURI += '/';\r
+\r
+/*\r
+ * LoaderError with chaining for loader stacks\r
+ */\r
+var errArgs = new Error(0, '_').fileName == '_';\r
+function LoaderError__Check_error_message_for_loader_stack (childErr, newMessage) {\r
+ // Convert file:/// URLs to paths in Node\r
+ if (!isBrowser)\r
+ newMessage = newMessage.replace(isWindows ? /file:\/\/\//g : /file:\/\//g, '');\r
+\r
+ var message = (childErr.message || childErr) + '\n ' + newMessage;\r
+\r
+ var err;\r
+ if (errArgs && childErr.fileName)\r
+ err = new Error(message, childErr.fileName, childErr.lineNumber);\r
+ else\r
+ err = new Error(message);\r
+\r
+\r
+ var stack = childErr.originalErr ? childErr.originalErr.stack : childErr.stack;\r
+\r
+ if (isNode)\r
+ // node doesn't show the message otherwise\r
+ err.stack = message + '\n ' + stack;\r
+ else\r
+ err.stack = stack;\r
+\r
+ err.originalErr = childErr.originalErr || childErr;\r
+\r
+ return err;\r
}
-var resolvedPromise = Promise.resolve();
-
-/*
- * Simple Array values shim
- */
-function arrayValues (arr) {
- if (arr.values)
- return arr.values();
-
- if (typeof Symbol === 'undefined' || !Symbol.iterator)
- throw new Error('Symbol.iterator not supported in this browser');
-
- var iterable = {};
- iterable[Symbol.iterator] = function () {
- var keys = Object.keys(arr);
- var keyIndex = 0;
- return {
- next: function () {
- if (keyIndex < keys.length)
- return {
- value: arr[keys[keyIndex++]],
- done: false
- };
- else
- return {
- value: undefined,
- done: true
- };
- }
- };
- };
- return iterable;
-}
-
-/*
- * 3. Reflect.Loader
- *
- * We skip the entire native internal pipeline, just providing the bare API
- */
-// 3.1.1
-function Loader () {
- this.registry = new Registry();
-}
-// 3.3.1
-Loader.prototype.constructor = Loader;
-
-function ensureInstantiated (module) {
- if (!(module instanceof ModuleNamespace))
- throw new TypeError('Module instantiation did not return a valid namespace object.');
- return module;
-}
-
-// 3.3.2
-Loader.prototype.import = function (key, parent) {
- if (typeof key !== 'string')
- throw new TypeError('Loader import method must be passed a module key string');
- // custom resolveInstantiate combined hook for better perf
- var loader = this;
- return resolvedPromise
- .then(function () {
- return loader[RESOLVE_INSTANTIATE](key, parent);
- })
- .then(ensureInstantiated)
- //.then(Module.evaluate)
- .catch(function (err) {
- throw LoaderError__Check_error_message_for_loader_stack(err, 'Loading ' + key + (parent ? ' from ' + parent : ''));
- });
-};
-// 3.3.3
-var RESOLVE = Loader.resolve = createSymbol('resolve');
-
-/*
- * Combined resolve / instantiate hook
- *
- * Not in current reduced spec, but necessary to separate RESOLVE from RESOLVE + INSTANTIATE as described
- * in the spec notes of this repo to ensure that loader.resolve doesn't instantiate when not wanted.
- *
- * We implement RESOLVE_INSTANTIATE as a single hook instead of a separate INSTANTIATE in order to avoid
- * the need for double registry lookups as a performance optimization.
- */
-var RESOLVE_INSTANTIATE = Loader.resolveInstantiate = createSymbol('resolveInstantiate');
-
-// default resolveInstantiate is just to call resolve and then get from the registry
-// this provides compatibility for the resolveInstantiate optimization
-Loader.prototype[RESOLVE_INSTANTIATE] = function (key, parent) {
- var loader = this;
- return loader.resolve(key, parent)
- .then(function (resolved) {
- return loader.registry.get(resolved);
- });
-};
-
-function ensureResolution (resolvedKey) {
- if (resolvedKey === undefined)
- throw new RangeError('No resolution found.');
- return resolvedKey;
-}
-
-Loader.prototype.resolve = function (key, parent) {
- var loader = this;
- return resolvedPromise
- .then(function() {
- return loader[RESOLVE](key, parent);
- })
- .then(ensureResolution)
- .catch(function (err) {
- throw LoaderError__Check_error_message_for_loader_stack(err, 'Resolving ' + key + (parent ? ' to ' + parent : ''));
- });
-};
-
-// 3.3.4 (import without evaluate)
-// this is not documented because the use of deferred evaluation as in Module.evaluate is not
-// documented, as it is not considered a stable feature to be encouraged
-// Loader.prototype.load may well be deprecated if this stays disabled
-/* Loader.prototype.load = function (key, parent) {
- return Promise.resolve(this[RESOLVE_INSTANTIATE](key, parent || this.key))
- .catch(function (err) {
- throw addToError(err, 'Loading ' + key + (parent ? ' from ' + parent : ''));
- });
+var resolvedPromise$1 = Promise.resolve();\r
+\r
+/*\r
+ * Simple Array values shim\r
+ */\r
+function arrayValues (arr) {\r
+ if (arr.values)\r
+ return arr.values();\r
+\r
+ if (typeof Symbol === 'undefined' || !Symbol.iterator)\r
+ throw new Error('Symbol.iterator not supported in this browser');\r
+\r
+ var iterable = {};\r
+ iterable[Symbol.iterator] = function () {\r
+ var keys = Object.keys(arr);\r
+ var keyIndex = 0;\r
+ return {\r
+ next: function () {\r
+ if (keyIndex < keys.length)\r
+ return {\r
+ value: arr[keys[keyIndex++]],\r
+ done: false\r
+ };\r
+ else\r
+ return {\r
+ value: undefined,\r
+ done: true\r
+ };\r
+ }\r
+ };\r
+ };\r
+ return iterable;\r
+}\r
+\r
+/*\r
+ * 3. Reflect.Loader\r
+ *\r
+ * We skip the entire native internal pipeline, just providing the bare API\r
+ */\r
+// 3.1.1\r
+function Loader () {\r
+ this.registry = new Registry();\r
+}\r
+// 3.3.1\r
+Loader.prototype.constructor = Loader;\r
+\r
+function ensureInstantiated (module) {\r
+ if (module === undefined)\r
+ return;\r
+ if (module instanceof ModuleNamespace === false && module[toStringTag] !== 'module')\r
+ throw new TypeError('Module instantiation did not return a valid namespace object.');\r
+ return module;\r
+}\r
+\r
+// 3.3.2\r
+Loader.prototype.import = function (key, parent) {\r
+ if (typeof key !== 'string')\r
+ throw new TypeError('Loader import method must be passed a module key string');\r
+ // custom resolveInstantiate combined hook for better perf\r
+ var loader = this;\r
+ return resolvedPromise$1\r
+ .then(function () {\r
+ return loader[RESOLVE_INSTANTIATE](key, parent);\r
+ })\r
+ .then(ensureInstantiated)\r
+ //.then(Module.evaluate)\r
+ .catch(function (err) {\r
+ throw LoaderError__Check_error_message_for_loader_stack(err, 'Loading ' + key + (parent ? ' from ' + parent : ''));\r
+ });\r
+};\r
+// 3.3.3\r
+var RESOLVE = Loader.resolve = createSymbol('resolve');\r
+\r
+/*\r
+ * Combined resolve / instantiate hook\r
+ *\r
+ * Not in current reduced spec, but necessary to separate RESOLVE from RESOLVE + INSTANTIATE as described\r
+ * in the spec notes of this repo to ensure that loader.resolve doesn't instantiate when not wanted.\r
+ *\r
+ * We implement RESOLVE_INSTANTIATE as a single hook instead of a separate INSTANTIATE in order to avoid\r
+ * the need for double registry lookups as a performance optimization.\r
+ */\r
+var RESOLVE_INSTANTIATE = Loader.resolveInstantiate = createSymbol('resolveInstantiate');\r
+\r
+// default resolveInstantiate is just to call resolve and then get from the registry\r
+// this provides compatibility for the resolveInstantiate optimization\r
+Loader.prototype[RESOLVE_INSTANTIATE] = function (key, parent) {\r
+ var loader = this;\r
+ return loader.resolve(key, parent)\r
+ .then(function (resolved) {\r
+ return loader.registry.get(resolved);\r
+ });\r
+};\r
+\r
+function ensureResolution (resolvedKey) {\r
+ if (resolvedKey === undefined)\r
+ throw new RangeError('No resolution found.');\r
+ return resolvedKey;\r
+}\r
+\r
+Loader.prototype.resolve = function (key, parent) {\r
+ var loader = this;\r
+ return resolvedPromise$1\r
+ .then(function() {\r
+ return loader[RESOLVE](key, parent);\r
+ })\r
+ .then(ensureResolution)\r
+ .catch(function (err) {\r
+ throw LoaderError__Check_error_message_for_loader_stack(err, 'Resolving ' + key + (parent ? ' to ' + parent : ''));\r
+ });\r
+};\r
+\r
+// 3.3.4 (import without evaluate)\r
+// this is not documented because the use of deferred evaluation as in Module.evaluate is not\r
+// documented, as it is not considered a stable feature to be encouraged\r
+// Loader.prototype.load may well be deprecated if this stays disabled\r
+/* Loader.prototype.load = function (key, parent) {\r
+ return Promise.resolve(this[RESOLVE_INSTANTIATE](key, parent || this.key))\r
+ .catch(function (err) {\r
+ throw addToError(err, 'Loading ' + key + (parent ? ' from ' + parent : ''));\r
+ });\r
+}; */\r
+\r
+/*\r
+ * 4. Registry\r
+ *\r
+ * Instead of structuring through a Map, just use a dictionary object\r
+ * We throw for construction attempts so this doesn't affect the public API\r
+ *\r
+ * Registry has been adjusted to use Namespace objects over ModuleStatus objects\r
+ * as part of simplifying loader API implementation\r
+ */\r
+var iteratorSupport = typeof Symbol !== 'undefined' && Symbol.iterator;\r
+var REGISTRY = createSymbol('registry');\r
+function Registry() {\r
+ this[REGISTRY] = {};\r
+}\r
+// 4.4.1\r
+if (iteratorSupport) {\r
+ // 4.4.2\r
+ Registry.prototype[Symbol.iterator] = function () {\r
+ return this.entries()[Symbol.iterator]();\r
+ };\r
+\r
+ // 4.4.3\r
+ Registry.prototype.entries = function () {\r
+ var registry = this[REGISTRY];\r
+ return arrayValues(Object.keys(registry).map(function (key) {\r
+ return [key, registry[key]];\r
+ }));\r
+ };\r
+}\r
+\r
+// 4.4.4\r
+Registry.prototype.keys = function () {\r
+ return arrayValues(Object.keys(this[REGISTRY]));\r
+};\r
+// 4.4.5\r
+Registry.prototype.values = function () {\r
+ var registry = this[REGISTRY];\r
+ return arrayValues(Object.keys(registry).map(function (key) {\r
+ return registry[key];\r
+ }));\r
+};\r
+// 4.4.6\r
+Registry.prototype.get = function (key) {\r
+ return this[REGISTRY][key];\r
+};\r
+// 4.4.7\r
+Registry.prototype.set = function (key, namespace) {\r
+ if (!(namespace instanceof ModuleNamespace || namespace[toStringTag] === 'module'))\r
+ throw new Error('Registry must be set with an instance of Module Namespace');\r
+ this[REGISTRY][key] = namespace;\r
+ return this;\r
+};\r
+// 4.4.8\r
+Registry.prototype.has = function (key) {\r
+ return Object.hasOwnProperty.call(this[REGISTRY], key);\r
+};\r
+// 4.4.9\r
+Registry.prototype.delete = function (key) {\r
+ if (Object.hasOwnProperty.call(this[REGISTRY], key)) {\r
+ delete this[REGISTRY][key];\r
+ return true;\r
+ }\r
+ return false;\r
+};\r
+\r
+/*\r
+ * Simple ModuleNamespace Exotic object based on a baseObject\r
+ * We export this for allowing a fast-path for module namespace creation over Module descriptors\r
+ */\r
+// var EVALUATE = createSymbol('evaluate');\r
+var BASE_OBJECT = createSymbol('baseObject');\r
+\r
+// 8.3.1 Reflect.Module\r
+/*\r
+ * Best-effort simplified non-spec implementation based on\r
+ * a baseObject referenced via getters.\r
+ *\r
+ * Allows:\r
+ *\r
+ * loader.registry.set('x', new Module({ default: 'x' }));\r
+ *\r
+ * Optional evaluation function provides experimental Module.evaluate\r
+ * support for non-executed modules in registry.\r
+ */\r
+function ModuleNamespace (baseObject/*, evaluate*/) {\r
+ Object.defineProperty(this, BASE_OBJECT, {\r
+ value: baseObject\r
+ });\r
+\r
+ // evaluate defers namespace population\r
+ /* if (evaluate) {\r
+ Object.defineProperty(this, EVALUATE, {\r
+ value: evaluate,\r
+ configurable: true,\r
+ writable: true\r
+ });\r
+ }\r
+ else { */\r
+ Object.keys(baseObject).forEach(extendNamespace, this);\r
+ //}\r
+}\r
+// 8.4.2\r
+ModuleNamespace.prototype = Object.create(null);\r
+\r
+if (toStringTag)\r
+ Object.defineProperty(ModuleNamespace.prototype, toStringTag, {\r
+ value: 'Module'\r
+ });\r
+\r
+function extendNamespace (key) {\r
+ Object.defineProperty(this, key, {\r
+ enumerable: true,\r
+ get: function () {\r
+ return this[BASE_OBJECT][key];\r
+ }\r
+ });\r
+}\r
+\r
+/* function doEvaluate (evaluate, context) {\r
+ try {\r
+ evaluate.call(context);\r
+ }\r
+ catch (e) {\r
+ return e;\r
+ }\r
+}\r
+\r
+// 8.4.1 Module.evaluate... not documented or used because this is potentially unstable\r
+Module.evaluate = function (ns) {\r
+ var evaluate = ns[EVALUATE];\r
+ if (evaluate) {\r
+ ns[EVALUATE] = undefined;\r
+ var err = doEvaluate(evaluate);\r
+ if (err) {\r
+ // cache the error\r
+ ns[EVALUATE] = function () {\r
+ throw err;\r
+ };\r
+ throw err;\r
+ }\r
+ Object.keys(ns[BASE_OBJECT]).forEach(extendNamespace, ns);\r
+ }\r
+ // make chainable\r
+ return ns;\r
}; */
-/*
- * 4. Registry
- *
- * Instead of structuring through a Map, just use a dictionary object
- * We throw for construction attempts so this doesn't affect the public API
- *
- * Registry has been adjusted to use Namespace objects over ModuleStatus objects
- * as part of simplifying loader API implementation
- */
-var iteratorSupport = typeof Symbol !== 'undefined' && Symbol.iterator;
-var REGISTRY = createSymbol('registry');
-function Registry() {
- this[REGISTRY] = {};
-}
-// 4.4.1
-if (iteratorSupport) {
- // 4.4.2
- Registry.prototype[Symbol.iterator] = function () {
- return this.entries()[Symbol.iterator]();
- };
-
- // 4.4.3
- Registry.prototype.entries = function () {
- var registry = this[REGISTRY];
- return arrayValues(Object.keys(registry).map(function (key) {
- return [key, registry[key]];
- }));
- };
+/*\r
+ * Optimized URL normalization assuming a syntax-valid URL parent\r
+ */\r
+function throwResolveError (relUrl, parentUrl) {\r
+ throw new RangeError('Unable to resolve "' + relUrl + '" to ' + parentUrl);\r
+}\r
+var backslashRegEx = /\\/g;\r
+function resolveIfNotPlain (relUrl, parentUrl) {\r
+ if (relUrl[0] === ' ' || relUrl[relUrl.length - 1] === ' ')\r
+ relUrl = relUrl.trim();\r
+ var parentProtocol = parentUrl && parentUrl.substr(0, parentUrl.indexOf(':') + 1);\r
+\r
+ var firstChar = relUrl[0];\r
+ var secondChar = relUrl[1];\r
+\r
+ // protocol-relative\r
+ if (firstChar === '/' && secondChar === '/') {\r
+ if (!parentProtocol)\r
+ throwResolveError(relUrl, parentUrl);\r
+ if (relUrl.indexOf('\\') !== -1)\r
+ relUrl = relUrl.replace(backslashRegEx, '/');\r
+ return parentProtocol + relUrl;\r
+ }\r
+ // relative-url\r
+ else if (firstChar === '.' && (secondChar === '/' || secondChar === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) ||\r
+ relUrl.length === 1 && (relUrl += '/')) ||\r
+ firstChar === '/') {\r
+ if (relUrl.indexOf('\\') !== -1)\r
+ relUrl = relUrl.replace(backslashRegEx, '/');\r
+ var parentIsPlain = !parentProtocol || parentUrl[parentProtocol.length] !== '/';\r
+\r
+ // read pathname from parent if a URL\r
+ // pathname taken to be part after leading "/"\r
+ var pathname;\r
+ if (parentIsPlain) {\r
+ // resolving to a plain parent -> skip standard URL prefix, and treat entire parent as pathname\r
+ if (parentUrl === undefined)\r
+ throwResolveError(relUrl, parentUrl);\r
+ pathname = parentUrl;\r
+ }\r
+ else if (parentUrl[parentProtocol.length + 1] === '/') {\r
+ // resolving to a :// so we need to read out the auth and host\r
+ if (parentProtocol !== 'file:') {\r
+ pathname = parentUrl.substr(parentProtocol.length + 2);\r
+ pathname = pathname.substr(pathname.indexOf('/') + 1);\r
+ }\r
+ else {\r
+ pathname = parentUrl.substr(8);\r
+ }\r
+ }\r
+ else {\r
+ // resolving to :/ so pathname is the /... part\r
+ pathname = parentUrl.substr(parentProtocol.length + 1);\r
+ }\r
+\r
+ if (firstChar === '/') {\r
+ if (parentIsPlain)\r
+ throwResolveError(relUrl, parentUrl);\r
+ else\r
+ return parentUrl.substr(0, parentUrl.length - pathname.length - 1) + relUrl;\r
+ }\r
+\r
+ // join together and split for removal of .. and . segments\r
+ // looping the string instead of anything fancy for perf reasons\r
+ // '../../../../../z' resolved to 'x/y' is just 'z' regardless of parentIsPlain\r
+ var segmented = pathname.substr(0, pathname.lastIndexOf('/') + 1) + relUrl;\r
+\r
+ var output = [];\r
+ var segmentIndex = -1;\r
+\r
+ for (var i = 0; i < segmented.length; i++) {\r
+ // busy reading a segment - only terminate on '/'\r
+ if (segmentIndex !== -1) {\r
+ if (segmented[i] === '/') {\r
+ output.push(segmented.substring(segmentIndex, i + 1));\r
+ segmentIndex = -1;\r
+ }\r
+ continue;\r
+ }\r
+\r
+ // new segment - check if it is relative\r
+ if (segmented[i] === '.') {\r
+ // ../ segment\r
+ if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {\r
+ output.pop();\r
+ i += 2;\r
+ }\r
+ // ./ segment\r
+ else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {\r
+ i += 1;\r
+ }\r
+ else {\r
+ // the start of a new segment as below\r
+ segmentIndex = i;\r
+ continue;\r
+ }\r
+\r
+ // this is the plain URI backtracking error (../, package:x -> error)\r
+ if (parentIsPlain && output.length === 0)\r
+ throwResolveError(relUrl, parentUrl);\r
+\r
+ continue;\r
+ }\r
+\r
+ // it is the start of a new segment\r
+ segmentIndex = i;\r
+ }\r
+ // finish reading out the last segment\r
+ if (segmentIndex !== -1)\r
+ output.push(segmented.substr(segmentIndex));\r
+\r
+ return parentUrl.substr(0, parentUrl.length - pathname.length) + output.join('');\r
+ }\r
+\r
+ // sanitizes and verifies (by returning undefined if not a valid URL-like form)\r
+ // Windows filepath compatibility is an added convenience here\r
+ var protocolIndex = relUrl.indexOf(':');\r
+ if (protocolIndex !== -1) {\r
+ if (isNode) {\r
+ // C:\x becomes file:///c:/x (we don't support C|\x)\r
+ if (relUrl[1] === ':' && relUrl[2] === '\\' && relUrl[0].match(/[a-z]/i))\r
+ return 'file:///' + relUrl.replace(backslashRegEx, '/');\r
+ }\r
+ return relUrl;\r
+ }\r
}
-// 4.4.4
-Registry.prototype.keys = function () {
- return arrayValues(Object.keys(this[REGISTRY]));
-};
-// 4.4.5
-Registry.prototype.values = function () {
- var registry = this[REGISTRY];
- return arrayValues(Object.keys(registry).map(function (key) {
- return registry[key];
- }));
-};
-// 4.4.6
-Registry.prototype.get = function (key) {
- return this[REGISTRY][key];
-};
-// 4.4.7
-Registry.prototype.set = function (key, namespace) {
- if (!(namespace instanceof ModuleNamespace))
- throw new Error('Registry must be set with an instance of Module Namespace');
- this[REGISTRY][key] = namespace;
- return this;
-};
-// 4.4.8
-Registry.prototype.has = function (key) {
- return Object.hasOwnProperty.call(this[REGISTRY], key);
-};
-// 4.4.9
-Registry.prototype.delete = function (key) {
- if (Object.hasOwnProperty.call(this[REGISTRY], key)) {
- delete this[REGISTRY][key];
- return true;
- }
- return false;
-};
-
-/*
- * Simple ModuleNamespace Exotic object based on a baseObject
- * We export this for allowing a fast-path for module namespace creation over Module descriptors
- */
-// var EVALUATE = createSymbol('evaluate');
-var BASE_OBJECT = createSymbol('baseObject');
-
-// 8.3.1 Reflect.Module
-/*
- * Best-effort simplified non-spec implementation based on
- * a baseObject referenced via getters.
- *
- * Allows:
- *
- * loader.registry.set('x', new Module({ default: 'x' }));
- *
- * Optional evaluation function provides experimental Module.evaluate
- * support for non-executed modules in registry.
- */
-function ModuleNamespace (baseObject/*, evaluate*/) {
- Object.defineProperty(this, BASE_OBJECT, {
- value: baseObject
- });
-
- // evaluate defers namespace population
- /* if (evaluate) {
- Object.defineProperty(this, EVALUATE, {
- value: evaluate,
- configurable: true,
- writable: true
- });
- }
- else { */
- Object.keys(baseObject).forEach(extendNamespace, this);
- //}
-}
-// 8.4.2
-ModuleNamespace.prototype = Object.create(null);
-
-if (typeof Symbol !== 'undefined' && Symbol.toStringTag)
- Object.defineProperty(ModuleNamespace.prototype, Symbol.toStringTag, {
- value: 'Module'
- });
-
-function extendNamespace (key) {
- Object.defineProperty(this, key, {
- enumerable: true,
- get: function () {
- return this[BASE_OBJECT][key];
- }
- });
-}
-
-/* function doEvaluate (evaluate, context) {
- try {
- evaluate.call(context);
- }
- catch (e) {
- return e;
- }
-}
-
-// 8.4.1 Module.evaluate... not documented or used because this is potentially unstable
-Module.evaluate = function (ns) {
- var evaluate = ns[EVALUATE];
- if (evaluate) {
- ns[EVALUATE] = undefined;
- var err = doEvaluate(evaluate);
- if (err) {
- // cache the error
- ns[EVALUATE] = function () {
- throw err;
- };
- throw err;
- }
- Object.keys(ns[BASE_OBJECT]).forEach(extendNamespace, ns);
- }
- // make chainable
- return ns;
-}; */
-
-/*
- * Optimized URL normalization assuming a syntax-valid URL parent
- */
-function throwResolveError (relUrl, parentUrl) {
- throw new RangeError('Unable to resolve "' + relUrl + '" to ' + parentUrl);
-}
-function resolveIfNotPlain (relUrl, parentUrl) {
- relUrl = relUrl.trim();
- var parentProtocol = parentUrl && parentUrl.substr(0, parentUrl.indexOf(':') + 1);
-
- var firstChar = relUrl[0];
- var secondChar = relUrl[1];
-
- // protocol-relative
- if (firstChar === '/' && secondChar === '/') {
- if (!parentProtocol)
- throwResolveError(relUrl, parentUrl);
- return parentProtocol + relUrl;
- }
- // relative-url
- else if (firstChar === '.' && (secondChar === '/' || secondChar === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) ||
- relUrl.length === 1 && (relUrl += '/')) ||
- firstChar === '/') {
- var parentIsPlain = !parentProtocol || parentUrl[parentProtocol.length] !== '/';
-
- // read pathname from parent if a URL
- // pathname taken to be part after leading "/"
- var pathname;
- if (parentIsPlain) {
- // resolving to a plain parent -> skip standard URL prefix, and treat entire parent as pathname
- if (parentUrl === undefined)
- throwResolveError(relUrl, parentUrl);
- pathname = parentUrl;
- }
- else if (parentUrl[parentProtocol.length + 1] === '/') {
- // resolving to a :// so we need to read out the auth and host
- if (parentProtocol !== 'file:') {
- pathname = parentUrl.substr(parentProtocol.length + 2);
- pathname = pathname.substr(pathname.indexOf('/') + 1);
- }
- else {
- pathname = parentUrl.substr(8);
- }
- }
- else {
- // resolving to :/ so pathname is the /... part
- pathname = parentUrl.substr(parentProtocol.length + 1);
- }
-
- if (firstChar === '/') {
- if (parentIsPlain)
- throwResolveError(relUrl, parentUrl);
- else
- return parentUrl.substr(0, parentUrl.length - pathname.length - 1) + relUrl;
- }
-
- // join together and split for removal of .. and . segments
- // looping the string instead of anything fancy for perf reasons
- // '../../../../../z' resolved to 'x/y' is just 'z' regardless of parentIsPlain
- var segmented = pathname.substr(0, pathname.lastIndexOf('/') + 1) + relUrl;
-
- var output = [];
- var segmentIndex = -1;
-
- for (var i = 0; i < segmented.length; i++) {
- // busy reading a segment - only terminate on '/'
- if (segmentIndex !== -1) {
- if (segmented[i] === '/') {
- output.push(segmented.substring(segmentIndex, i + 1));
- segmentIndex = -1;
- }
- continue;
- }
-
- // new segment - check if it is relative
- if (segmented[i] === '.') {
- // ../ segment
- if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
- output.pop();
- i += 2;
- }
- // ./ segment
- else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
- i += 1;
- }
- else {
- // the start of a new segment as below
- segmentIndex = i;
- continue;
- }
-
- // this is the plain URI backtracking error (../, package:x -> error)
- if (parentIsPlain && output.length === 0)
- throwResolveError(relUrl, parentUrl);
-
- continue;
- }
-
- // it is the start of a new segment
- segmentIndex = i;
- }
- // finish reading out the last segment
- if (segmentIndex !== -1)
- output.push(segmented.substr(segmentIndex));
-
- return parentUrl.substr(0, parentUrl.length - pathname.length) + output.join('');
- }
-
- // sanitizes and verifies (by returning undefined if not a valid URL-like form)
- // Windows filepath compatibility is an added convenience here
- var protocolIndex = relUrl.indexOf(':');
- if (protocolIndex !== -1) {
- if (isNode) {
- // C:\x becomes file:///c:/x (we don't support C|\x)
- if (relUrl[1] === ':' && relUrl[2] === '\\' && relUrl[0].match(/[a-z]/i))
- return 'file:///' + relUrl.replace(/\\/g, '/');
- }
- return relUrl;
- }
-}
-
-/*
- * Register Loader
- *
- * Builds directly on top of loader polyfill to provide:
- * - loader.register support
- * - hookable higher-level resolve
- * - instantiate hook returning a ModuleNamespace or undefined for es module loading
- * - loader error behaviour as in HTML and loader specs, caching load and eval errors separately
- * - build tracing support by providing a .trace=true and .loads object format
- */
-
-var REGISTER_INTERNAL = createSymbol('register-internal');
-
-function RegisterLoader$1 () {
- Loader.call(this);
-
- var registryDelete = this.registry.delete;
- this.registry.delete = function (key) {
- var deleted = registryDelete.call(this, key);
-
- // also delete from register registry if linked
- if (records.hasOwnProperty(key) && !records[key].linkRecord) {
- delete records[key];
- deleted = true;
- }
-
- return deleted;
- };
-
- var records = {};
-
- this[REGISTER_INTERNAL] = {
- // last anonymous System.register call
- lastRegister: undefined,
- // in-flight es module load records
- records: records
- };
-
- // tracing
- this.trace = false;
-}
-
-RegisterLoader$1.prototype = Object.create(Loader.prototype);
-RegisterLoader$1.prototype.constructor = RegisterLoader$1;
-
-var INSTANTIATE = RegisterLoader$1.instantiate = createSymbol('instantiate');
-
-// default normalize is the WhatWG style normalizer
-RegisterLoader$1.prototype[RegisterLoader$1.resolve = Loader.resolve] = function (key, parentKey) {
- return resolveIfNotPlain(key, parentKey || baseURI);
-};
-
-RegisterLoader$1.prototype[INSTANTIATE] = function (key, processAnonRegister) {};
-
-// once evaluated, the linkRecord is set to undefined leaving just the other load record properties
-// this allows tracking new binding listeners for es modules through importerSetters
-// for dynamic modules, the load record is removed entirely.
-function createLoadRecord (state, key, registration) {
- return state.records[key] = {
- key: key,
-
- // defined System.register cache
- registration: registration,
-
- // module namespace object
- module: undefined,
-
- // es-only
- // this sticks around so new module loads can listen to binding changes
- // for already-loaded modules by adding themselves to their importerSetters
- importerSetters: undefined,
-
- loadError: undefined,
- evalError: undefined,
-
- // in-flight linking record
- linkRecord: {
- // promise for instantiated
- instantiatePromise: undefined,
- dependencies: undefined,
- execute: undefined,
- executingRequire: false,
-
- // underlying module object bindings
- moduleObj: undefined,
-
- // es only, also indicates if es or not
- setters: undefined,
-
- // promise for instantiated dependencies (dependencyInstantiations populated)
- depsInstantiatePromise: undefined,
- // will be the array of dependency load record or a module namespace
- dependencyInstantiations: undefined,
-
- // NB optimization and way of ensuring module objects in setters
- // indicates setters which should run pre-execution of that dependency
- // setters is then just for completely executed module objects
- // alternatively we just pass the partially filled module objects as
- // arguments into the execute function
- // hoisted: undefined
- }
- };
-}
-
-RegisterLoader$1.prototype[Loader.resolveInstantiate] = function (key, parentKey) {
- var loader = this;
- var state = this[REGISTER_INTERNAL];
- var registry = this.registry[REGISTRY];
-
- return resolveInstantiate(loader, key, parentKey, registry, state)
- .then(function (instantiated) {
- if (instantiated instanceof ModuleNamespace)
- return instantiated;
-
- // resolveInstantiate always returns a load record with a link record and no module value
- var link = instantiated.linkRecord;
-
- // if already beaten to done, return
- if (!link) {
- if (instantiated.module)
- return instantiated.module;
- throw instantiated.evalError;
- }
-
- return deepInstantiateDeps(loader, instantiated, link, registry, state)
- .then(function () {
- return ensureEvaluate(loader, instantiated, link, registry, state, undefined);
- });
- });
-};
-
-function resolveInstantiate (loader, key, parentKey, registry, state) {
- // normalization shortpath for already-normalized key
- // could add a plain name filter, but doesn't yet seem necessary for perf
- var module = registry[key];
- if (module)
- return Promise.resolve(module);
-
- var load = state.records[key];
-
- // already linked but not in main registry is ignored
- if (load && !load.module) {
- if (load.loadError)
- return Promise.reject(load.loadError);
- return instantiate(loader, load, load.linkRecord, registry, state);
- }
-
- return loader.resolve(key, parentKey)
- .then(function (resolvedKey) {
- // main loader registry always takes preference
- module = registry[resolvedKey];
- if (module)
- return module;
-
- load = state.records[resolvedKey];
-
- // already has a module value but not already in the registry (load.module)
- // means it was removed by registry.delete, so we should
- // disgard the current load record creating a new one over it
- // but keep any existing registration
- if (!load || load.module)
- load = createLoadRecord(state, resolvedKey, load && load.registration);
-
- if (load.loadError)
- return Promise.reject(load.loadError);
-
- var link = load.linkRecord;
- if (!link)
- return load;
-
- return instantiate(loader, load, link, registry, state);
- });
-}
-
-function createProcessAnonRegister (loader, load, state) {
- return function () {
- var lastRegister = state.lastRegister;
-
- if (!lastRegister)
- return !!load.registration;
-
- state.lastRegister = undefined;
- load.registration = lastRegister;
-
- return true;
- };
-}
-
-function instantiate (loader, load, link, registry, state) {
- return link.instantiatePromise || (link.instantiatePromise =
- // if there is already an existing registration, skip running instantiate
- (load.registration ? Promise.resolve() : Promise.resolve().then(function () {
- state.lastRegister = undefined;
- return loader[INSTANTIATE](load.key, loader[INSTANTIATE].length > 1 && createProcessAnonRegister(loader, load, state));
- }))
- .then(function (instantiation) {
- // direct module return from instantiate -> we're done
- if (instantiation !== undefined) {
- if (!(instantiation instanceof ModuleNamespace))
- throw new TypeError('Instantiate did not return a valid Module object.');
-
- delete state.records[load.key];
- if (loader.trace)
- traceLoad(loader, load, link);
- return registry[load.key] = instantiation;
- }
-
- // run the cached loader.register declaration if there is one
- var registration = load.registration;
- // clear to allow new registrations for future loads (combined with registry delete)
- load.registration = undefined;
- if (!registration)
- throw new TypeError('Module instantiation did not call an anonymous or correctly named System.register.');
-
- link.dependencies = registration[0];
-
- load.importerSetters = [];
-
- link.moduleObj = {};
-
- // process System.registerDynamic declaration
- if (registration[2]) {
- link.moduleObj.default = link.moduleObj.__useDefault = {};
- link.executingRequire = registration[1];
- link.execute = registration[2];
- }
-
- // process System.register declaration
- else {
- registerDeclarative(loader, load, link, registration[1]);
- }
-
- return load;
- })
- .catch(function (err) {
- load.linkRecord = undefined;
- throw load.loadError = load.loadError || LoaderError__Check_error_message_for_loader_stack(err, 'Instantiating ' + load.key);
- }));
-}
-
-// like resolveInstantiate, but returning load records for linking
-function resolveInstantiateDep (loader, key, parentKey, registry, state, traceDepMap) {
- // normalization shortpaths for already-normalized key
- // DISABLED to prioritise consistent resolver calls
- // could add a plain name filter, but doesn't yet seem necessary for perf
- /* var load = state.records[key];
- var module = registry[key];
-
- if (module) {
- if (traceDepMap)
- traceDepMap[key] = key;
-
- // registry authority check in case module was deleted or replaced in main registry
- if (load && load.module && load.module === module)
- return load;
- else
- return module;
- }
-
- // already linked but not in main registry is ignored
- if (load && !load.module) {
- if (traceDepMap)
- traceDepMap[key] = key;
- return instantiate(loader, load, load.linkRecord, registry, state);
- } */
- return loader.resolve(key, parentKey)
- .then(function (resolvedKey) {
- if (traceDepMap)
- traceDepMap[key] = resolvedKey;
-
- // normalization shortpaths for already-normalized key
- var load = state.records[resolvedKey];
- var module = registry[resolvedKey];
-
- // main loader registry always takes preference
- if (module && (!load || load.module && module !== load.module))
- return module;
-
- if (load && load.loadError)
- throw load.loadError;
-
- // already has a module value but not already in the registry (load.module)
- // means it was removed by registry.delete, so we should
- // disgard the current load record creating a new one over it
- // but keep any existing registration
- if (!load || !module && load.module)
- load = createLoadRecord(state, resolvedKey, load && load.registration);
-
- var link = load.linkRecord;
- if (!link)
- return load;
-
- return instantiate(loader, load, link, registry, state);
- });
-}
-
-function traceLoad (loader, load, link) {
- loader.loads = loader.loads || {};
- loader.loads[load.key] = {
- key: load.key,
- deps: link.dependencies,
- dynamicDeps: [],
- depMap: link.depMap || {}
- };
-}
-
-/*
- * Convert a CJS module.exports into a valid object for new Module:
- *
- * new Module(getEsModule(module.exports))
- *
- * Sets the default value to the module, while also reading off named exports carefully.
- */
-function registerDeclarative (loader, load, link, declare) {
- var moduleObj = link.moduleObj;
- var importerSetters = load.importerSetters;
-
- var definedExports = false;
-
- // closure especially not based on link to allow link record disposal
- var declared = declare.call(envGlobal, function (name, value) {
- if (typeof name === 'object') {
- var changed = false;
- for (var p in name) {
- value = name[p];
- if (p !== '__useDefault' && (!(p in moduleObj) || moduleObj[p] !== value)) {
- changed = true;
- moduleObj[p] = value;
- }
- }
- if (changed === false)
- return value;
- }
- else {
- if ((definedExports || name in moduleObj) && moduleObj[name] === value)
- return value;
- moduleObj[name] = value;
- }
-
- for (var i = 0; i < importerSetters.length; i++)
- importerSetters[i](moduleObj);
-
- return value;
- }, new ContextualLoader(loader, load.key));
-
- link.setters = declared.setters;
- link.execute = declared.execute;
- if (declared.exports) {
- link.moduleObj = moduleObj = declared.exports;
- definedExports = true;
- }
-}
-
-function instantiateDeps (loader, load, link, registry, state) {
- if (link.depsInstantiatePromise)
- return link.depsInstantiatePromise;
-
- var depsInstantiatePromises = Array(link.dependencies.length);
-
- for (var i = 0; i < link.dependencies.length; i++)
- depsInstantiatePromises[i] = resolveInstantiateDep(loader, link.dependencies[i], load.key, registry, state, loader.trace && link.depMap || (link.depMap = {}));
-
- var depsInstantiatePromise = Promise.all(depsInstantiatePromises)
- .then(function (dependencyInstantiations) {
- link.dependencyInstantiations = dependencyInstantiations;
-
- // run setters to set up bindings to instantiated dependencies
- if (link.setters) {
- for (var i = 0; i < dependencyInstantiations.length; i++) {
- var setter = link.setters[i];
- if (setter) {
- var instantiation = dependencyInstantiations[i];
-
- if (instantiation instanceof ModuleNamespace) {
- setter(instantiation);
- }
- else {
- if (instantiation.loadError)
- throw instantiation.loadError;
- setter(instantiation.module || instantiation.linkRecord.moduleObj);
- // this applies to both es and dynamic registrations
- if (instantiation.importerSetters)
- instantiation.importerSetters.push(setter);
- }
- }
- }
- }
-
- return load;
- });
-
- if (loader.trace)
- depsInstantiatePromise = depsInstantiatePromise.then(function () {
- traceLoad(loader, load, link);
- return load;
- });
-
- depsInstantiatePromise = depsInstantiatePromise.catch(function (err) {
- // throw up the instantiateDeps stack
- link.depsInstantiatePromise = undefined;
- throw LoaderError__Check_error_message_for_loader_stack(err, 'Loading ' + load.key);
- });
-
- depsInstantiatePromise.catch(function () {});
-
- return link.depsInstantiatePromise = depsInstantiatePromise;
-}
-
-function deepInstantiateDeps (loader, load, link, registry, state) {
- return new Promise(function (resolve, reject) {
- var seen = [];
- var loadCnt = 0;
- function queueLoad (load) {
- var link = load.linkRecord;
- if (!link)
- return;
-
- if (seen.indexOf(load) !== -1)
- return;
- seen.push(load);
-
- loadCnt++;
- instantiateDeps(loader, load, link, registry, state)
- .then(processLoad, reject);
- }
- function processLoad (load) {
- loadCnt--;
- var link = load.linkRecord;
- if (link) {
- for (var i = 0; i < link.dependencies.length; i++) {
- var depLoad = link.dependencyInstantiations[i];
- if (!(depLoad instanceof ModuleNamespace))
- queueLoad(depLoad);
- }
- }
- if (loadCnt === 0)
- resolve();
- }
- queueLoad(load);
- });
-}
-
-/*
- * System.register
- */
-RegisterLoader$1.prototype.register = function (key, deps, declare) {
- var state = this[REGISTER_INTERNAL];
-
- // anonymous modules get stored as lastAnon
- if (declare === undefined) {
- state.lastRegister = [key, deps, undefined];
- }
-
- // everything else registers into the register cache
- else {
- var load = state.records[key] || createLoadRecord(state, key, undefined);
- load.registration = [deps, declare, undefined];
- }
-};
-
-/*
- * System.registerDyanmic
- */
-RegisterLoader$1.prototype.registerDynamic = function (key, deps, executingRequire, execute) {
- var state = this[REGISTER_INTERNAL];
-
- // anonymous modules get stored as lastAnon
- if (typeof key !== 'string') {
- state.lastRegister = [key, deps, executingRequire];
- }
-
- // everything else registers into the register cache
- else {
- var load = state.records[key] || createLoadRecord(state, key, undefined);
- load.registration = [deps, executingRequire, execute];
- }
-};
-
-// ContextualLoader class
-// backwards-compatible with previous System.register context argument by exposing .id, .key
-function ContextualLoader (loader, key) {
- this.loader = loader;
- this.key = this.id = key;
- this.meta = {
- url: key
- // scriptElement: null
- };
-}
-/*ContextualLoader.prototype.constructor = function () {
- throw new TypeError('Cannot subclass the contextual loader only Reflect.Loader.');
-};*/
-ContextualLoader.prototype.import = function (key) {
- if (this.loader.trace)
- this.loader.loads[this.key].dynamicDeps.push(key);
- return this.loader.import(key, this.key);
-};
-/*ContextualLoader.prototype.resolve = function (key) {
- return this.loader.resolve(key, this.key);
-};*/
-
-// this is the execution function bound to the Module namespace record
-function ensureEvaluate (loader, load, link, registry, state, seen) {
- if (load.module)
- return load.module;
-
- if (load.evalError)
- throw load.evalError;
-
- if (seen && seen.indexOf(load) !== -1)
- return load.linkRecord.moduleObj;
-
- // for ES loads we always run ensureEvaluate on top-level, so empty seen is passed regardless
- // for dynamic loads, we pass seen if also dynamic
- var err = doEvaluate(loader, load, link, registry, state, link.setters ? [] : seen || []);
- if (err)
- throw err;
-
- return load.module;
-}
-
-function makeDynamicRequire (loader, key, dependencies, dependencyInstantiations, registry, state, seen) {
- // we can only require from already-known dependencies
- return function (name) {
- for (var i = 0; i < dependencies.length; i++) {
- if (dependencies[i] === name) {
- var depLoad = dependencyInstantiations[i];
- var module;
-
- if (depLoad instanceof ModuleNamespace)
- module = depLoad;
- else
- module = ensureEvaluate(loader, depLoad, depLoad.linkRecord, registry, state, seen);
-
- return '__useDefault' in module ? module.__useDefault : module;
- }
- }
- throw new Error('Module ' + name + ' not declared as a System.registerDynamic dependency of ' + key);
- };
-}
-
-// ensures the given es load is evaluated
-// returns the error if any
-function doEvaluate (loader, load, link, registry, state, seen) {
- seen.push(load);
-
- var err;
-
- // es modules evaluate dependencies first
- // non es modules explicitly call moduleEvaluate through require
- if (link.setters) {
- var depLoad, depLink;
- for (var i = 0; i < link.dependencies.length; i++) {
- depLoad = link.dependencyInstantiations[i];
-
- if (depLoad instanceof ModuleNamespace)
- continue;
-
- // custom Module returned from instantiate
- depLink = depLoad.linkRecord;
- if (depLink && seen.indexOf(depLoad) === -1) {
- if (depLoad.evalError)
- err = depLoad.evalError;
- else
- // dynamic / declarative boundaries clear the "seen" list
- // we just let cross format circular throw as would happen in real implementations
- err = doEvaluate(loader, depLoad, depLink, registry, state, depLink.setters ? seen : []);
- }
-
- if (err) {
- load.linkRecord = undefined;
- load.evalError = LoaderError__Check_error_message_for_loader_stack(err, 'Evaluating ' + load.key);
- return load.evalError;
- }
- }
- }
-
- // link.execute won't exist for Module returns from instantiate on top-level load
- if (link.execute) {
- // ES System.register execute
- // "this" is null in ES
- if (link.setters) {
- err = declarativeExecute(link.execute);
- }
- // System.registerDynamic execute
- // "this" is "exports" in CJS
- else {
- var module = { id: load.key };
- var moduleObj = link.moduleObj;
- Object.defineProperty(module, 'exports', {
- configurable: true,
- set: function (exports) {
- moduleObj.default = moduleObj.__useDefault = exports;
- },
- get: function () {
- return moduleObj.__useDefault;
- }
- });
-
- var require = makeDynamicRequire(loader, load.key, link.dependencies, link.dependencyInstantiations, registry, state, seen);
-
- // evaluate deps first
- if (!link.executingRequire)
- for (var i = 0; i < link.dependencies.length; i++)
- require(link.dependencies[i]);
-
- err = dynamicExecute(link.execute, require, moduleObj.default, module);
-
- // pick up defineProperty calls to module.exports when we can
- if (module.exports !== moduleObj.__useDefault)
- moduleObj.default = moduleObj.__useDefault = module.exports;
-
- var moduleDefault = moduleObj.default;
-
- // __esModule flag extension support via lifting
- if (moduleDefault && moduleDefault.__esModule) {
- for (var p in moduleDefault) {
- if (Object.hasOwnProperty.call(moduleDefault, p))
- moduleObj[p] = moduleDefault[p];
- }
- }
- }
- }
-
- // dispose link record
- load.linkRecord = undefined;
-
- if (err)
- return load.evalError = LoaderError__Check_error_message_for_loader_stack(err, 'Evaluating ' + load.key);
-
- registry[load.key] = load.module = new ModuleNamespace(link.moduleObj);
-
- // if not an esm module, run importer setters and clear them
- // this allows dynamic modules to update themselves into es modules
- // as soon as execution has completed
- if (!link.setters) {
- if (load.importerSetters)
- for (var i = 0; i < load.importerSetters.length; i++)
- load.importerSetters[i](load.module);
- load.importerSetters = undefined;
- }
-}
-
-// {} is the closest we can get to call(undefined)
-var nullContext = {};
-if (Object.freeze)
+var resolvedPromise = Promise.resolve();\r
+/*\r
+ * Register Loader\r
+ *\r
+ * Builds directly on top of loader polyfill to provide:\r
+ * - loader.register support\r
+ * - hookable higher-level resolve\r
+ * - instantiate hook returning a ModuleNamespace or undefined for es module loading\r
+ * - loader error behaviour as in HTML and loader specs, caching load and eval errors separately\r
+ * - build tracing support by providing a .trace=true and .loads object format\r
+ */\r
+\r
+var REGISTER_INTERNAL = createSymbol('register-internal');\r
+\r
+function RegisterLoader$1 () {\r
+ Loader.call(this);\r
+\r
+ var registryDelete = this.registry.delete;\r
+ this.registry.delete = function (key) {\r
+ var deleted = registryDelete.call(this, key);\r
+\r
+ // also delete from register registry if linked\r
+ if (records.hasOwnProperty(key) && !records[key].linkRecord) {\r
+ delete records[key];\r
+ deleted = true;\r
+ }\r
+\r
+ return deleted;\r
+ };\r
+\r
+ var records = {};\r
+\r
+ this[REGISTER_INTERNAL] = {\r
+ // last anonymous System.register call\r
+ lastRegister: undefined,\r
+ // in-flight es module load records\r
+ records: records\r
+ };\r
+\r
+ // tracing\r
+ this.trace = false;\r
+}\r
+\r
+RegisterLoader$1.prototype = Object.create(Loader.prototype);\r
+RegisterLoader$1.prototype.constructor = RegisterLoader$1;\r
+\r
+var INSTANTIATE = RegisterLoader$1.instantiate = createSymbol('instantiate');\r
+\r
+// default normalize is the WhatWG style normalizer\r
+RegisterLoader$1.prototype[RegisterLoader$1.resolve = Loader.resolve] = function (key, parentKey) {\r
+ return resolveIfNotPlain(key, parentKey || baseURI);\r
+};\r
+\r
+RegisterLoader$1.prototype[INSTANTIATE] = function (key, processAnonRegister) {};\r
+\r
+// once evaluated, the linkRecord is set to undefined leaving just the other load record properties\r
+// this allows tracking new binding listeners for es modules through importerSetters\r
+// for dynamic modules, the load record is removed entirely.\r
+function createLoadRecord (state, key, registration) {\r
+ return state.records[key] = {\r
+ key: key,\r
+\r
+ // defined System.register cache\r
+ registration: registration,\r
+\r
+ // module namespace object\r
+ module: undefined,\r
+\r
+ // es-only\r
+ // this sticks around so new module loads can listen to binding changes\r
+ // for already-loaded modules by adding themselves to their importerSetters\r
+ importerSetters: undefined,\r
+\r
+ loadError: undefined,\r
+ evalError: undefined,\r
+\r
+ // in-flight linking record\r
+ linkRecord: {\r
+ // promise for instantiated\r
+ instantiatePromise: undefined,\r
+ dependencies: undefined,\r
+ execute: undefined,\r
+ executingRequire: false,\r
+\r
+ // underlying module object bindings\r
+ moduleObj: undefined,\r
+\r
+ // es only, also indicates if es or not\r
+ setters: undefined,\r
+\r
+ // promise for instantiated dependencies (dependencyInstantiations populated)\r
+ depsInstantiatePromise: undefined,\r
+ // will be the array of dependency load record or a module namespace\r
+ dependencyInstantiations: undefined,\r
+\r
+ // top-level await!\r
+ evaluatePromise: undefined,\r
+\r
+ // NB optimization and way of ensuring module objects in setters\r
+ // indicates setters which should run pre-execution of that dependency\r
+ // setters is then just for completely executed module objects\r
+ // alternatively we just pass the partially filled module objects as\r
+ // arguments into the execute function\r
+ // hoisted: undefined\r
+ }\r
+ };\r
+}\r
+\r
+RegisterLoader$1.prototype[Loader.resolveInstantiate] = function (key, parentKey) {\r
+ var loader = this;\r
+ var state = this[REGISTER_INTERNAL];\r
+ var registry = this.registry[REGISTRY];\r
+\r
+ return resolveInstantiate(loader, key, parentKey, registry, state)\r
+ .then(function (instantiated) {\r
+ if (instantiated instanceof ModuleNamespace || instantiated[toStringTag] === 'module')\r
+ return instantiated;\r
+\r
+ // resolveInstantiate always returns a load record with a link record and no module value\r
+ var link = instantiated.linkRecord;\r
+\r
+ // if already beaten to done, return\r
+ if (!link) {\r
+ if (instantiated.module)\r
+ return instantiated.module;\r
+ throw instantiated.evalError;\r
+ }\r
+\r
+ return deepInstantiateDeps(loader, instantiated, link, registry, state)\r
+ .then(function () {\r
+ return ensureEvaluate(loader, instantiated, link, registry, state);\r
+ });\r
+ });\r
+};\r
+\r
+function resolveInstantiate (loader, key, parentKey, registry, state) {\r
+ // normalization shortpath for already-normalized key\r
+ // could add a plain name filter, but doesn't yet seem necessary for perf\r
+ var module = registry[key];\r
+ if (module)\r
+ return Promise.resolve(module);\r
+\r
+ var load = state.records[key];\r
+\r
+ // already linked but not in main registry is ignored\r
+ if (load && !load.module) {\r
+ if (load.loadError)\r
+ return Promise.reject(load.loadError);\r
+ return instantiate(loader, load, load.linkRecord, registry, state);\r
+ }\r
+\r
+ return loader.resolve(key, parentKey)\r
+ .then(function (resolvedKey) {\r
+ // main loader registry always takes preference\r
+ module = registry[resolvedKey];\r
+ if (module)\r
+ return module;\r
+\r
+ load = state.records[resolvedKey];\r
+\r
+ // already has a module value but not already in the registry (load.module)\r
+ // means it was removed by registry.delete, so we should\r
+ // disgard the current load record creating a new one over it\r
+ // but keep any existing registration\r
+ if (!load || load.module)\r
+ load = createLoadRecord(state, resolvedKey, load && load.registration);\r
+\r
+ if (load.loadError)\r
+ return Promise.reject(load.loadError);\r
+\r
+ var link = load.linkRecord;\r
+ if (!link)\r
+ return load;\r
+\r
+ return instantiate(loader, load, link, registry, state);\r
+ });\r
+}\r
+\r
+function createProcessAnonRegister (loader, load, state) {\r
+ return function () {\r
+ var lastRegister = state.lastRegister;\r
+\r
+ if (!lastRegister)\r
+ return !!load.registration;\r
+\r
+ state.lastRegister = undefined;\r
+ load.registration = lastRegister;\r
+\r
+ return true;\r
+ };\r
+}\r
+\r
+function instantiate (loader, load, link, registry, state) {\r
+ return link.instantiatePromise || (link.instantiatePromise =\r
+ // if there is already an existing registration, skip running instantiate\r
+ (load.registration ? resolvedPromise : resolvedPromise.then(function () {\r
+ state.lastRegister = undefined;\r
+ return loader[INSTANTIATE](load.key, loader[INSTANTIATE].length > 1 && createProcessAnonRegister(loader, load, state));\r
+ }))\r
+ .then(function (instantiation) {\r
+ // direct module return from instantiate -> we're done\r
+ if (instantiation !== undefined) {\r
+ if (!(instantiation instanceof ModuleNamespace || instantiation[toStringTag] === 'module'))\r
+ throw new TypeError('Instantiate did not return a valid Module object.');\r
+\r
+ delete state.records[load.key];\r
+ if (loader.trace)\r
+ traceLoad(loader, load, link);\r
+ return registry[load.key] = instantiation;\r
+ }\r
+\r
+ // run the cached loader.register declaration if there is one\r
+ var registration = load.registration;\r
+ // clear to allow new registrations for future loads (combined with registry delete)\r
+ load.registration = undefined;\r
+ if (!registration)\r
+ throw new TypeError('Module instantiation did not call an anonymous or correctly named System.register.');\r
+\r
+ link.dependencies = registration[0];\r
+\r
+ load.importerSetters = [];\r
+\r
+ link.moduleObj = {};\r
+\r
+ // process System.registerDynamic declaration\r
+ if (registration[2]) {\r
+ link.moduleObj.default = link.moduleObj.__useDefault = {};\r
+ link.executingRequire = registration[1];\r
+ link.execute = registration[2];\r
+ }\r
+\r
+ // process System.register declaration\r
+ else {\r
+ registerDeclarative(loader, load, link, registration[1]);\r
+ }\r
+\r
+ return load;\r
+ })\r
+ .catch(function (err) {\r
+ load.linkRecord = undefined;\r
+ throw load.loadError = load.loadError || LoaderError__Check_error_message_for_loader_stack(err, 'Instantiating ' + load.key);\r
+ }));\r
+}\r
+\r
+// like resolveInstantiate, but returning load records for linking\r
+function resolveInstantiateDep (loader, key, parentKey, registry, state, traceDepMap) {\r
+ // normalization shortpaths for already-normalized key\r
+ // DISABLED to prioritise consistent resolver calls\r
+ // could add a plain name filter, but doesn't yet seem necessary for perf\r
+ /* var load = state.records[key];\r
+ var module = registry[key];\r
+\r
+ if (module) {\r
+ if (traceDepMap)\r
+ traceDepMap[key] = key;\r
+\r
+ // registry authority check in case module was deleted or replaced in main registry\r
+ if (load && load.module && load.module === module)\r
+ return load;\r
+ else\r
+ return module;\r
+ }\r
+\r
+ // already linked but not in main registry is ignored\r
+ if (load && !load.module) {\r
+ if (traceDepMap)\r
+ traceDepMap[key] = key;\r
+ return instantiate(loader, load, load.linkRecord, registry, state);\r
+ } */\r
+ return loader.resolve(key, parentKey)\r
+ .then(function (resolvedKey) {\r
+ if (traceDepMap)\r
+ traceDepMap[key] = resolvedKey;\r
+\r
+ // normalization shortpaths for already-normalized key\r
+ var load = state.records[resolvedKey];\r
+ var module = registry[resolvedKey];\r
+\r
+ // main loader registry always takes preference\r
+ if (module && (!load || load.module && module !== load.module))\r
+ return module;\r
+\r
+ if (load && load.loadError)\r
+ throw load.loadError;\r
+\r
+ // already has a module value but not already in the registry (load.module)\r
+ // means it was removed by registry.delete, so we should\r
+ // disgard the current load record creating a new one over it\r
+ // but keep any existing registration\r
+ if (!load || !module && load.module)\r
+ load = createLoadRecord(state, resolvedKey, load && load.registration);\r
+\r
+ var link = load.linkRecord;\r
+ if (!link)\r
+ return load;\r
+\r
+ return instantiate(loader, load, link, registry, state);\r
+ });\r
+}\r
+\r
+function traceLoad (loader, load, link) {\r
+ loader.loads = loader.loads || {};\r
+ loader.loads[load.key] = {\r
+ key: load.key,\r
+ deps: link.dependencies,\r
+ dynamicDeps: [],\r
+ depMap: link.depMap || {}\r
+ };\r
+}\r
+\r
+/*\r
+ * Convert a CJS module.exports into a valid object for new Module:\r
+ *\r
+ * new Module(getEsModule(module.exports))\r
+ *\r
+ * Sets the default value to the module, while also reading off named exports carefully.\r
+ */\r
+function registerDeclarative (loader, load, link, declare) {\r
+ var moduleObj = link.moduleObj;\r
+ var importerSetters = load.importerSetters;\r
+\r
+ var definedExports = false;\r
+\r
+ // closure especially not based on link to allow link record disposal\r
+ var declared = declare.call(envGlobal, function (name, value) {\r
+ if (typeof name === 'object') {\r
+ var changed = false;\r
+ for (var p in name) {\r
+ value = name[p];\r
+ if (p !== '__useDefault' && (!(p in moduleObj) || moduleObj[p] !== value)) {\r
+ changed = true;\r
+ moduleObj[p] = value;\r
+ }\r
+ }\r
+ if (changed === false)\r
+ return value;\r
+ }\r
+ else {\r
+ if ((definedExports || name in moduleObj) && moduleObj[name] === value)\r
+ return value;\r
+ moduleObj[name] = value;\r
+ }\r
+\r
+ for (var i = 0; i < importerSetters.length; i++)\r
+ importerSetters[i](moduleObj);\r
+\r
+ return value;\r
+ }, new ContextualLoader(loader, load.key));\r
+\r
+ link.setters = declared.setters || [];\r
+ link.execute = declared.execute;\r
+ if (declared.exports) {\r
+ link.moduleObj = moduleObj = declared.exports;\r
+ definedExports = true;\r
+ }\r
+}\r
+\r
+function instantiateDeps (loader, load, link, registry, state) {\r
+ if (link.depsInstantiatePromise)\r
+ return link.depsInstantiatePromise;\r
+\r
+ var depsInstantiatePromises = Array(link.dependencies.length);\r
+\r
+ for (var i = 0; i < link.dependencies.length; i++)\r
+ depsInstantiatePromises[i] = resolveInstantiateDep(loader, link.dependencies[i], load.key, registry, state, loader.trace && link.depMap || (link.depMap = {}));\r
+\r
+ var depsInstantiatePromise = Promise.all(depsInstantiatePromises)\r
+ .then(function (dependencyInstantiations) {\r
+ link.dependencyInstantiations = dependencyInstantiations;\r
+\r
+ // run setters to set up bindings to instantiated dependencies\r
+ if (link.setters) {\r
+ for (var i = 0; i < dependencyInstantiations.length; i++) {\r
+ var setter = link.setters[i];\r
+ if (setter) {\r
+ var instantiation = dependencyInstantiations[i];\r
+\r
+ if (instantiation instanceof ModuleNamespace || instantiation[toStringTag] === 'module') {\r
+ setter(instantiation);\r
+ }\r
+ else {\r
+ if (instantiation.loadError)\r
+ throw instantiation.loadError;\r
+ setter(instantiation.module || instantiation.linkRecord.moduleObj);\r
+ // this applies to both es and dynamic registrations\r
+ if (instantiation.importerSetters)\r
+ instantiation.importerSetters.push(setter);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ return load;\r
+ });\r
+\r
+ if (loader.trace)\r
+ depsInstantiatePromise = depsInstantiatePromise.then(function () {\r
+ traceLoad(loader, load, link);\r
+ return load;\r
+ });\r
+\r
+ depsInstantiatePromise = depsInstantiatePromise.catch(function (err) {\r
+ // throw up the instantiateDeps stack\r
+ link.depsInstantiatePromise = undefined;\r
+ throw LoaderError__Check_error_message_for_loader_stack(err, 'Loading ' + load.key);\r
+ });\r
+\r
+ depsInstantiatePromise.catch(function () {});\r
+\r
+ return link.depsInstantiatePromise = depsInstantiatePromise;\r
+}\r
+\r
+function deepInstantiateDeps (loader, load, link, registry, state) {\r
+ var seen = [];\r
+ function addDeps (load, link) {\r
+ if (!link)\r
+ return resolvedPromise;\r
+ if (seen.indexOf(load) !== -1)\r
+ return resolvedPromise;\r
+ seen.push(load);\r
+ \r
+ return instantiateDeps(loader, load, link, registry, state)\r
+ .then(function () {\r
+ var depPromises;\r
+ for (var i = 0; i < link.dependencies.length; i++) {\r
+ var depLoad = link.dependencyInstantiations[i];\r
+ if (!(depLoad instanceof ModuleNamespace || depLoad[toStringTag] === 'module')) {\r
+ depPromises = depPromises || [];\r
+ depPromises.push(addDeps(depLoad, depLoad.linkRecord));\r
+ }\r
+ }\r
+ if (depPromises)\r
+ return Promise.all(depPromises);\r
+ });\r
+ }\r
+\r
+ return addDeps(load, link);\r
+}\r
+\r
+/*\r
+ * System.register\r
+ */\r
+RegisterLoader$1.prototype.register = function (key, deps, declare) {\r
+ var state = this[REGISTER_INTERNAL];\r
+\r
+ // anonymous modules get stored as lastAnon\r
+ if (declare === undefined) {\r
+ state.lastRegister = [key, deps, undefined];\r
+ }\r
+\r
+ // everything else registers into the register cache\r
+ else {\r
+ var load = state.records[key] || createLoadRecord(state, key, undefined);\r
+ load.registration = [deps, declare, undefined];\r
+ }\r
+};\r
+\r
+/*\r
+ * System.registerDyanmic\r
+ */\r
+RegisterLoader$1.prototype.registerDynamic = function (key, deps, executingRequire, execute) {\r
+ var state = this[REGISTER_INTERNAL];\r
+\r
+ // anonymous modules get stored as lastAnon\r
+ if (typeof key !== 'string') {\r
+ state.lastRegister = [key, deps, executingRequire];\r
+ }\r
+\r
+ // everything else registers into the register cache\r
+ else {\r
+ var load = state.records[key] || createLoadRecord(state, key, undefined);\r
+ load.registration = [deps, executingRequire, execute];\r
+ }\r
+};\r
+\r
+// ContextualLoader class\r
+// backwards-compatible with previous System.register context argument by exposing .id, .key\r
+function ContextualLoader (loader, key) {\r
+ this.loader = loader;\r
+ this.key = this.id = key;\r
+ this.meta = {\r
+ url: key\r
+ // scriptElement: null\r
+ };\r
+}\r
+/*ContextualLoader.prototype.constructor = function () {\r
+ throw new TypeError('Cannot subclass the contextual loader only Reflect.Loader.');\r
+};*/\r
+ContextualLoader.prototype.import = function (key) {\r
+ if (this.loader.trace)\r
+ this.loader.loads[this.key].dynamicDeps.push(key);\r
+ return this.loader.import(key, this.key);\r
+};\r
+/*ContextualLoader.prototype.resolve = function (key) {\r
+ return this.loader.resolve(key, this.key);\r
+};*/\r
+\r
+function ensureEvaluate (loader, load, link, registry, state) {\r
+ if (load.module)\r
+ return load.module;\r
+ if (load.evalError)\r
+ throw load.evalError;\r
+ if (link.evaluatePromise)\r
+ return link.evaluatePromise;\r
+\r
+ if (link.setters) {\r
+ var evaluatePromise = doEvaluateDeclarative(loader, load, link, registry, state, [load]);\r
+ if (evaluatePromise)\r
+ return evaluatePromise;\r
+ }\r
+ else {\r
+ doEvaluateDynamic(loader, load, link, registry, state, [load]);\r
+ }\r
+ return load.module;\r
+}\r
+\r
+function makeDynamicRequire (loader, key, dependencies, dependencyInstantiations, registry, state, seen) {\r
+ // we can only require from already-known dependencies\r
+ return function (name) {\r
+ for (var i = 0; i < dependencies.length; i++) {\r
+ if (dependencies[i] === name) {\r
+ var depLoad = dependencyInstantiations[i];\r
+ var module;\r
+\r
+ if (depLoad instanceof ModuleNamespace || depLoad[toStringTag] === 'module') {\r
+ module = depLoad;\r
+ }\r
+ else {\r
+ if (depLoad.evalError)\r
+ throw depLoad.evalError;\r
+ if (depLoad.module === undefined && seen.indexOf(depLoad) === -1 && !depLoad.linkRecord.evaluatePromise) {\r
+ if (depLoad.linkRecord.setters) {\r
+ doEvaluateDeclarative(loader, depLoad, depLoad.linkRecord, registry, state, [depLoad]);\r
+ }\r
+ else {\r
+ seen.push(depLoad);\r
+ doEvaluateDynamic(loader, depLoad, depLoad.linkRecord, registry, state, seen);\r
+ }\r
+ }\r
+ module = depLoad.module || depLoad.linkRecord.moduleObj;\r
+ }\r
+\r
+ return '__useDefault' in module ? module.__useDefault : module;\r
+ }\r
+ }\r
+ throw new Error('Module ' + name + ' not declared as a System.registerDynamic dependency of ' + key);\r
+ };\r
+}\r
+\r
+function evalError (load, err) {\r
+ load.linkRecord = undefined;\r
+ var evalError = LoaderError__Check_error_message_for_loader_stack(err, 'Evaluating ' + load.key);\r
+ if (load.evalError === undefined)\r
+ load.evalError = evalError;\r
+ throw evalError;\r
+}\r
+\r
+// es modules evaluate dependencies first\r
+// returns the error if any\r
+function doEvaluateDeclarative (loader, load, link, registry, state, seen) {\r
+ var depLoad, depLink;\r
+ var depLoadPromises;\r
+ for (var i = 0; i < link.dependencies.length; i++) {\r
+ var depLoad = link.dependencyInstantiations[i];\r
+ if (depLoad instanceof ModuleNamespace || depLoad[toStringTag] === 'module')\r
+ continue;\r
+\r
+ // custom Module returned from instantiate\r
+ depLink = depLoad.linkRecord;\r
+ if (depLink) {\r
+ if (depLoad.evalError) {\r
+ evalError(load, depLoad.evalError);\r
+ }\r
+ else if (depLink.setters) {\r
+ if (seen.indexOf(depLoad) === -1) {\r
+ seen.push(depLoad);\r
+ try {\r
+ var depLoadPromise = doEvaluateDeclarative(loader, depLoad, depLink, registry, state, seen);\r
+ }\r
+ catch (e) {\r
+ evalError(load, e);\r
+ }\r
+ if (depLoadPromise) {\r
+ depLoadPromises = depLoadPromises || [];\r
+ depLoadPromises.push(depLoadPromise.catch(function (err) {\r
+ evalError(load, err);\r
+ }));\r
+ }\r
+ }\r
+ }\r
+ else {\r
+ try {\r
+ doEvaluateDynamic(loader, depLoad, depLink, registry, state, [depLoad]);\r
+ }\r
+ catch (e) {\r
+ evalError(load, e);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ if (depLoadPromises)\r
+ return link.evaluatePromise = Promise.all(depLoadPromises)\r
+ .then(function () {\r
+ if (link.execute) {\r
+ // ES System.register execute\r
+ // "this" is null in ES\r
+ try {\r
+ var execPromise = link.execute.call(nullContext);\r
+ }\r
+ catch (e) {\r
+ evalError(load, e);\r
+ }\r
+ if (execPromise)\r
+ return execPromise.catch(function (e) {\r
+ evalError(load, e);\r
+ })\r
+ .then(function () {\r
+ load.linkRecord = undefined;\r
+ return registry[load.key] = load.module = new ModuleNamespace(link.moduleObj);\r
+ });\r
+ }\r
+ \r
+ // dispose link record\r
+ load.linkRecord = undefined;\r
+ registry[load.key] = load.module = new ModuleNamespace(link.moduleObj);\r
+ });\r
+\r
+ if (link.execute) {\r
+ // ES System.register execute\r
+ // "this" is null in ES\r
+ try {\r
+ var execPromise = link.execute.call(nullContext);\r
+ }\r
+ catch (e) {\r
+ evalError(load, e);\r
+ }\r
+ if (execPromise)\r
+ return link.evaluatePromise = execPromise.catch(function (e) {\r
+ evalError(load, e);\r
+ })\r
+ .then(function () {\r
+ load.linkRecord = undefined;\r
+ return registry[load.key] = load.module = new ModuleNamespace(link.moduleObj);\r
+ });\r
+ }\r
+\r
+ // dispose link record\r
+ load.linkRecord = undefined;\r
+ registry[load.key] = load.module = new ModuleNamespace(link.moduleObj);\r
+}\r
+\r
+// non es modules explicitly call moduleEvaluate through require\r
+function doEvaluateDynamic (loader, load, link, registry, state, seen) {\r
+ // System.registerDynamic execute\r
+ // "this" is "exports" in CJS\r
+ var module = { id: load.key };\r
+ var moduleObj = link.moduleObj;\r
+ Object.defineProperty(module, 'exports', {\r
+ configurable: true,\r
+ set: function (exports) {\r
+ moduleObj.default = moduleObj.__useDefault = exports;\r
+ },\r
+ get: function () {\r
+ return moduleObj.__useDefault;\r
+ }\r
+ });\r
+\r
+ var require = makeDynamicRequire(loader, load.key, link.dependencies, link.dependencyInstantiations, registry, state, seen);\r
+\r
+ // evaluate deps first\r
+ if (!link.executingRequire)\r
+ for (var i = 0; i < link.dependencies.length; i++)\r
+ require(link.dependencies[i]);\r
+\r
+ try {\r
+ var output = link.execute.call(envGlobal, require, moduleObj.default, module);\r
+ if (output !== undefined)\r
+ module.exports = output;\r
+ }\r
+ catch (e) {\r
+ evalError(load, e);\r
+ }\r
+\r
+ load.linkRecord = undefined;\r
+\r
+ // pick up defineProperty calls to module.exports when we can\r
+ if (module.exports !== moduleObj.__useDefault)\r
+ moduleObj.default = moduleObj.__useDefault = module.exports;\r
+\r
+ var moduleDefault = moduleObj.default;\r
+\r
+ // __esModule flag extension support via lifting\r
+ if (moduleDefault && moduleDefault.__esModule) {\r
+ for (var p in moduleDefault) {\r
+ if (Object.hasOwnProperty.call(moduleDefault, p))\r
+ moduleObj[p] = moduleDefault[p];\r
+ }\r
+ }\r
+\r
+ registry[load.key] = load.module = new ModuleNamespace(link.moduleObj);\r
+\r
+ // run importer setters and clear them\r
+ // this allows dynamic modules to update themselves into es modules\r
+ // as soon as execution has completed\r
+ if (load.importerSetters)\r
+ for (var i = 0; i < load.importerSetters.length; i++)\r
+ load.importerSetters[i](load.module);\r
+ load.importerSetters = undefined;\r
+}\r
+\r
+// the closest we can get to call(undefined)\r
+var nullContext = Object.create(null);\r
+if (Object.freeze)\r
Object.freeze(nullContext);
-function declarativeExecute (execute) {
- try {
- execute.call(nullContext);
- }
- catch (e) {
- return e;
- }
-}
-
-function dynamicExecute (execute, require, exports, module) {
- try {
- var output = execute.call(envGlobal, require, exports, module);
- if (output !== undefined)
- module.exports = output;
- }
- catch (e) {
- return e;
- }
-}
-
var loader;
// <script type="module"> support
var current = document.currentScript;
// IE doesn't support currentScript
if (!current) {
- // We should be the last loaded script
+ // Find an entry with out basename
var scripts = document.getElementsByTagName('script');
- current = scripts[scripts.length - 1];
+ for (var i = 0; i < scripts.length; i++) {
+ if (scripts[i].src.indexOf("browser-es-module-loader.js") !== -1) {
+ current = scripts[i];
+ break;
+ }
+ }
+ if (!current)
+ throw Error("Could not find own <script> element");
}
script = current.src.substr(0, current.src.lastIndexOf("/")) + "/" + script;
this._workers = new Array(size);
projects / mirror_novnc.git / blobdiff