Better currentScript fallback

[mirror_novnc.git] / vendor / browser-es-module-loader / dist / browser-es-module-loader.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global.BrowserESModuleLoader = factory());
}(this, (function () { 'use strict';

/*\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$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
}; */

/*\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
}

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);

var loader;

// <script type="module"> support
var anonSources = {};
if (typeof document != 'undefined' && document.getElementsByTagName) {
  var handleError = function(err) {
    // dispatch an error event so that we can display in errors in browsers
    // that don't yet support unhandledrejection
    if (window.onunhandledrejection === undefined) {
      try {
        var evt = new Event('error');
      } catch (_eventError) {
        var evt = document.createEvent('Event');
        evt.initEvent('error', true, true);
      }
      evt.message = err.message;
      if (err.fileName) {
        evt.filename = err.fileName;
        evt.lineno = err.lineNumber;
        evt.colno = err.columnNumber;
      } else if (err.sourceURL) {
        evt.filename = err.sourceURL;
        evt.lineno = err.line;
        evt.colno = err.column;
      }
      evt.error = err;
      window.dispatchEvent(evt);
    }

    // throw so it still shows up in the console
    throw err;
  };

  var ready = function() {
    document.removeEventListener('DOMContentLoaded', ready, false );

    var anonCnt = 0;

    var scripts = document.getElementsByTagName('script');
    for (var i = 0; i < scripts.length; i++) {
      var script = scripts[i];
      if (script.type == 'module' && !script.loaded) {
        script.loaded = true;
        if (script.src) {
          loader.import(script.src).catch(handleError);
        }
        // anonymous modules supported via a custom naming scheme and registry
        else {
          var uri = './<anon' + ++anonCnt + '>.js';
          if (script.id !== ""){
            uri = "./" + script.id;
          }

          var anonName = resolveIfNotPlain(uri, baseURI);
          anonSources[anonName] = script.innerHTML;
          loader.import(anonName).catch(handleError);
        }
      }
    }
  };

  // simple DOM ready
  if (document.readyState === 'complete')
    setTimeout(ready);
  else
    document.addEventListener('DOMContentLoaded', ready, false);
}

function BrowserESModuleLoader(baseKey) {
  if (baseKey)
    this.baseKey = resolveIfNotPlain(baseKey, baseURI) || resolveIfNotPlain('./' + baseKey, baseURI);

  RegisterLoader$1.call(this);

  var loader = this;

  // ensure System.register is available
  envGlobal.System = envGlobal.System || {};
  if (typeof envGlobal.System.register == 'function')
    var prevRegister = envGlobal.System.register;
  envGlobal.System.register = function() {
    loader.register.apply(loader, arguments);
    if (prevRegister)
      prevRegister.apply(this, arguments);
  };
}
BrowserESModuleLoader.prototype = Object.create(RegisterLoader$1.prototype);

// normalize is never given a relative name like "./x", that part is already handled
BrowserESModuleLoader.prototype[RegisterLoader$1.resolve] = function(key, parent) {
  var resolved = RegisterLoader$1.prototype[RegisterLoader$1.resolve].call(this, key, parent || this.baseKey) || key;
  if (!resolved)
    throw new RangeError('ES module loader does not resolve plain module names, resolving "' + key + '" to ' + parent);

  return resolved;
};

function xhrFetch(url, resolve, reject) {
  var xhr = new XMLHttpRequest();
  var load = function(source) {
    resolve(xhr.responseText);
  };
  var error = function() {
    reject(new Error('XHR error' + (xhr.status ? ' (' + xhr.status + (xhr.statusText ? ' ' + xhr.statusText  : '') + ')' : '') + ' loading ' + url));
  };

  xhr.onreadystatechange = function () {
    if (xhr.readyState === 4) {
      // in Chrome on file:/// URLs, status is 0
      if (xhr.status == 0) {
        if (xhr.responseText) {
          load();
        }
        else {
          // when responseText is empty, wait for load or error event
          // to inform if it is a 404 or empty file
          xhr.addEventListener('error', error);
          xhr.addEventListener('load', load);
        }
      }
      else if (xhr.status === 200) {
        load();
      }
      else {
        error();
      }
    }
  };
  xhr.open("GET", url, true);
  xhr.send(null);
}

var WorkerPool = function (script, size) {
  var current = document.currentScript;
  // IE doesn't support currentScript
  if (!current) {
    // Find an entry with out basename
    var scripts = document.getElementsByTagName('script');
    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);
  this._ind = 0;
  this._size = size;
  this._jobs = 0;
  this.onmessage = undefined;
  this._stopTimeout = undefined;
  for (var i = 0; i < size; i++) {
    var wrkr = new Worker(script);
    wrkr._count = 0;
    wrkr._ind = i;
    wrkr.onmessage = this._onmessage.bind(this, wrkr);
    wrkr.onerror = this._onerror.bind(this);
    this._workers[i] = wrkr;
  }

  this._checkJobs();
};
WorkerPool.prototype = {
  postMessage: function (msg) {
    if (this._stopTimeout !== undefined) {
      clearTimeout(this._stopTimeout);
      this._stopTimeout = undefined;
    }
    var wrkr = this._workers[this._ind % this._size];
    wrkr._count++;
    this._jobs++;
    wrkr.postMessage(msg);
    this._ind++;
  },

  _onmessage: function (wrkr, evt) {
    wrkr._count--;
    this._jobs--;
    this.onmessage(evt, wrkr);
    this._checkJobs();
  },

  _onerror: function(err) {
    try {
        var evt = new Event('error');
    } catch (_eventError) {
        var evt = document.createEvent('Event');
        evt.initEvent('error', true, true);
    }
    evt.message = err.message;
    evt.filename = err.filename;
    evt.lineno = err.lineno;
    evt.colno = err.colno;
    evt.error = err.error;
    window.dispatchEvent(evt);
  },

  _checkJobs: function () {
    if (this._jobs === 0 && this._stopTimeout === undefined) {
      // wait for 2s of inactivity before stopping (that should be enough for local loading)
      this._stopTimeout = setTimeout(this._stop.bind(this), 2000);
    }
  },

  _stop: function () {
    this._workers.forEach(function(wrkr) {
      wrkr.terminate();
    });
  }
};

var promiseMap = new Map();
var babelWorker = new WorkerPool('babel-worker.js', 3);
babelWorker.onmessage = function (evt) {
    var promFuncs = promiseMap.get(evt.data.key);
    promFuncs.resolve(evt.data);
    promiseMap.delete(evt.data.key);
};

// instantiate just needs to run System.register
// so we fetch the source, convert into the Babel System module format, then evaluate it
BrowserESModuleLoader.prototype[RegisterLoader$1.instantiate] = function(key, processAnonRegister) {
  var loader = this;

  // load as ES with Babel converting into System.register
  return new Promise(function(resolve, reject) {
    // anonymous module
    if (anonSources[key]) {
      resolve(anonSources[key]);
      anonSources[key] = undefined;
    }
    // otherwise we fetch
    else {
      xhrFetch(key, resolve, reject);
    }
  })
  .then(function(source) {
    // check our cache first
    var cacheEntry = localStorage.getItem(key);
    if (cacheEntry) {
      cacheEntry = JSON.parse(cacheEntry);
      // TODO: store a hash instead
      if (cacheEntry.source === source) {
        return Promise.resolve({key: key, code: cacheEntry.code, source: cacheEntry.source});
      }
    }
    return new Promise(function (resolve, reject) {
      promiseMap.set(key, {resolve: resolve, reject: reject});
      babelWorker.postMessage({key: key, source: source});
    });
  }).then(function (data) {
    // evaluate without require, exports and module variables
    // we leave module in for now to allow module.require access
    try {
      var cacheEntry = JSON.stringify({source: data.source, code: data.code});
      localStorage.setItem(key, cacheEntry);
    } catch (e) {
      if (window.console) {
        window.console.warn('Unable to cache transpiled version of ' + key + ': ' + e);
      }
    }
    (0, eval)(data.code + '\n//# sourceURL=' + data.key + '!transpiled');
    processAnonRegister();
  });
};

// create a default loader instance in the browser
if (isBrowser)
  loader = new BrowserESModuleLoader();

return BrowserESModuleLoader;

})));
//# sourceMappingURL=browser-es-module-loader.js.map