text: /*
  * SystemJS 2.0.2
  */
  (function () {
      const hasSelf = typeof self !== 'undefined';
    
      const envGlobal = hasSelf ? self : global;
    
      let baseUrl;
      if (typeof location !== 'undefined') {
        baseUrl = location.href.split('#')[0].split('?')[0];
        const lastSepIndex = baseUrl.lastIndexOf('/');
        if (lastSepIndex !== -1)
          baseUrl = baseUrl.slice(0, lastSepIndex + 1);
      }
    
      const backslashRegEx = /\\/g;
      function resolveIfNotPlainOrUrl (relUrl, parentUrl) {
        if (relUrl.indexOf('\\') !== -1)
          relUrl = relUrl.replace(backslashRegEx, '/');
        // protocol-relative
        if (relUrl[0] === '/' && relUrl[1] === '/') {
          return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
        }
        // relative-url
        else if (relUrl[0] === '.' && (relUrl[1] === '/' || relUrl[1] === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) ||
            relUrl.length === 1  && (relUrl += '/')) ||
            relUrl[0] === '/') {
          const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1);
          // Disabled, but these cases will give inconsistent results for deep backtracking
          //if (parentUrl[parentProtocol.length] !== '/')
          //  throw new Error('Cannot resolve');
          // read pathname from parent URL
          // pathname taken to be part after leading "/"
          let pathname;
          if (parentUrl[parentProtocol.length + 1] === '/') {
            // resolving to a :// so we need to read out the auth and host
            if (parentProtocol !== 'file:') {
              pathname = parentUrl.slice(parentProtocol.length + 2);
              pathname = pathname.slice(pathname.indexOf('/') + 1);
            }
            else {
              pathname = parentUrl.slice(8);
            }
          }
          else {
            // resolving to :/ so pathname is the /... part
            pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/'));
          }
    
          if (relUrl[0] === '/')
            return parentUrl.slice(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'
          const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
    
          const output = [];
          let segmentIndex = -1;
          for (let i = 0; i < segmented.length; i++) {
            // busy reading a segment - only terminate on '/'
            if (segmentIndex !== -1) {
              if (segmented[i] === '/') {
                output.push(segmented.slice(segmentIndex, i + 1));
                segmentIndex = -1;
              }
            }
    
            // new segment - check if it is relative
            else 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;
              }
            }
            // it is the start of a new segment
            else {
              segmentIndex = i;
            }
          }
          // finish reading out the last segment
          if (segmentIndex !== -1)
            output.push(segmented.slice(segmentIndex));
          return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
        }
      }
    
      /*
       * Package name maps implementation
       *
       * Reduced implementation - only a single scope level is supported
       * 
       * To make lookups fast we pre-resolve the entire package name map
       * and then match based on backtracked hash lookups
       * 
       * path_prefix in scopes not supported
       * nested scopes not supported
       */
    
      function resolveUrl (relUrl, parentUrl) {
        return resolveIfNotPlainOrUrl(relUrl, parentUrl) ||
            relUrl.indexOf(':') !== -1 && relUrl ||
            resolveIfNotPlainOrUrl('./' + relUrl, parentUrl);
      }
    
      function createPackageMap (json, baseUrl) {
        if (json.path_prefix) {
          baseUrl = resolveUrl(json.path_prefix, baseUrl);
          if (baseUrl[baseUrl.length - 1] !== '/')
            baseUrl += '/';
        }
          
        const basePackages = json.packages || {};
        const scopes = {};
        if (json.scopes) {
          for (let scopeName in json.scopes) {
            const scope = json.scopes[scopeName];
            if (scope.path_prefix)
              throw new Error('Scope path_prefix not currently supported');
            if (scope.scopes)
              throw new Error('Nested scopes not currently supported');
            let resolvedScopeName = resolveUrl(scopeName, baseUrl);
            if (resolvedScopeName[resolvedScopeName.length - 1] === '/')
              resolvedScopeName = resolvedScopeName.substr(0, resolvedScopeName.length - 1);
            scopes[resolvedScopeName] = scope.packages || {};
          }
        }
    
        function getMatch (path, matchObj) {
          let sepIndex = path.length;
          do {
            const segment = path.slice(0, sepIndex);
            if (segment in matchObj)
              return segment;
          } while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1)
        }
    
        function applyPackages (id, packages, baseUrl) {
          const pkgName = getMatch(id, packages);
          if (pkgName) {
            const pkg = packages[pkgName];
            if (pkgName === id) {
              if (typeof pkg === 'string')
                return resolveUrl(pkg, baseUrl + pkgName + '/');
              if (!pkg.main)
                throw new Error('Package ' + pkgName + ' has no main');
              return resolveUrl(
                (pkg.path ? pkg.path + (pkg.path[pkg.path.length - 1] === '/' ? '' : '/') : pkgName + '/') + pkg.main,
                baseUrl
              );
            }
            else {
              return resolveUrl(
                (typeof pkg === 'string' || !pkg.path
                  ? pkgName + '/'
                  : pkg.path + (pkg.path[pkg.path.length - 1] === '/' ? '' : '/')
                ) + id.slice(pkgName.length + 1)
              , baseUrl);
            }
          }
        }
    
        return function (id, parentUrl) {
          const scopeName = getMatch(parentUrl, scopes);
          if (scopeName) {
            const scopePackages = scopes[scopeName];
            const packageResolution = applyPackages(id, scopePackages, scopeName + '/');
            if (packageResolution)
              return packageResolution;
          }
          return applyPackages(id, basePackages, baseUrl) || throwBare(id, parentUrl);
        };
      }
    
      function throwBare (id, parentUrl) {
        throw new Error('Unable to resolve bare specifier "' + id + (parentUrl ? '" from ' + parentUrl : '"'));
      }
    
      /*
       * SystemJS Core
       * 
       * Provides
       * - System.import
       * - System.register support for
       *     live bindings, function hoisting through circular references,
       *     reexports, dynamic import, import.meta.url, top-level await
       * - System.getRegister to get the registration
       * - Symbol.toStringTag support in Module objects
       * - Hookable System.createContext to customize import.meta
       * - System.onload(id, err?) handler for tracing / hot-reloading
       * 
       * Core comes with no System.prototype.resolve or
       * System.prototype.instantiate implementations
       */
    
      const hasSymbol = typeof Symbol !== 'undefined';
      const toStringTag = hasSymbol && Symbol.toStringTag;
      const REGISTRY = hasSymbol ? Symbol() : '@';
    
      function SystemJS () {
        this[REGISTRY] = {};
      }
    
      const systemJSPrototype = SystemJS.prototype;
      systemJSPrototype.import = function (id, parentUrl) {
        const loader = this;
        return Promise.resolve(loader.resolve(id, parentUrl))
        .then(function (id) {
          const load = getOrCreateLoad(loader, id);
          return load.C || topLevelLoad(loader, load);
        });
      };
    
      // Hookable createContext function -> allowing eg custom import meta
      systemJSPrototype.createContext = function (parentId) {
        return {
          url: parentId
        };
      };
    
      // onLoad(id, err) provided for tracing / hot-reloading
      systemJSPrototype.onload = function () {};
    
      let lastRegister;
      systemJSPrototype.register = function (deps, declare) {
        lastRegister = [deps, declare];
      };
    
      /*
       * getRegister provides the last anonymous System.register call
       */
      systemJSPrototype.getRegister = function () {
        const _lastRegister = lastRegister;
        lastRegister = undefined;
        return _lastRegister;
      };
    
      function getOrCreateLoad (loader, id, firstParentUrl) {
        let load = loader[REGISTRY][id];
        if (load)
          return load;
    
        const importerSetters = [];
        const ns = Object.create(null);
        if (toStringTag)
          Object.defineProperty(ns, toStringTag, { value: 'Module' });
        
        let instantiatePromise = Promise.resolve()
        .then(function () {
          return loader.instantiate(id, firstParentUrl);
        })
        .then(function (registration) {
          if (!registration)
            throw new Error('Module ' + id + ' did not instantiate');
          function _export (name, value) {
            // note if we have hoisted exports (including reexports)
            load.h = true;
            let changed = false;
            if (typeof name !== 'object') {
              if (!(name in ns) || ns[name] !== value) {
                ns[name] = value;
                changed = true;
              }
            }
            else {
              for (let p in name) {
                let value = name[p];
                if (!(p in ns) || ns[p] !== value) {
                  ns[p] = value;
                  changed = true;
                }
              }
            }
            if (changed)
              for (let i = 0; i < importerSetters.length; i++)
                importerSetters[i](ns);
            return value;
          }
          const declared = registration[1](_export, registration[1].length === 2 ? {
            import: function (importId) {
              return loader.import(importId, id);
            },
            meta: loader.createContext(id)
          } : undefined);
          load.e = declared.execute || function () {};
          return [registration[0], declared.setters || []];
        });
    
        instantiatePromise = instantiatePromise.catch(function (err) {
            loader.onload(load.id, err);
            throw err;
          });
    
        const linkPromise = instantiatePromise
        .then(function (instantiation) {
          return Promise.all(instantiation[0].map(function (dep, i) {
            const setter = instantiation[1][i];
            return Promise.resolve(loader.resolve(dep, id))
            .then(function (depId) {
              const depLoad = getOrCreateLoad(loader, depId, id);
              // depLoad.I may be undefined for already-evaluated
              return Promise.resolve(depLoad.I)
              .then(function () {
                if (setter) {
                  depLoad.i.push(setter);
                  // only run early setters when there are hoisted exports of that module
                  // the timing works here as pending hoisted export calls will trigger through importerSetters
                  if (depLoad.h || !depLoad.I)
                    setter(depLoad.n);
                }
                return depLoad;
              });
            })
          }))
          .then(function (depLoads) {
            load.d = depLoads;
          });
        });
    
        // disable unhandled rejections
        linkPromise.catch(function () {});
    
        // Captial letter = a promise function
        return load = loader[REGISTRY][id] = {
          id: id,
          // importerSetters, the setters functions registered to this dependency
          // we retain this to add more later
          i: importerSetters,
          // module namespace object
          n: ns,
    
          // instantiate
          I: instantiatePromise,
          // link
          L: linkPromise,
          // whether it has hoisted exports
          h: false,
    
          // On instantiate completion we have populated:
          // dependency load records
          d: undefined,
          // execution function
          // set to NULL immediately after execution (or on any failure) to indicate execution has happened
          // in such a case, pC should be used, and pLo, pLi will be emptied
          e: undefined,
    
          // On execution we have populated:
          // the execution error if any
          eE: undefined,
          // in the case of TLA, the execution promise
          E: undefined,
    
          // On execution, pLi, pLo, e cleared
    
          // Promise for top-level completion
          C: undefined
        };
      }
    
      function instantiateAll (loader, load, loaded) {
        if (!loaded[load.id]) {
          loaded[load.id] = true;
          // load.L may be undefined for already-instantiated
          return Promise.resolve(load.L)
          .then(function () {
            return Promise.all(load.d.map(function (dep) {
              return instantiateAll(loader, dep, loaded);
            }));
          })
        }
      }
    
      function topLevelLoad (loader, load) {
        return load.C = instantiateAll(loader, load, {})
        .then(function () {
          return postOrderExec(loader, load, {});
        })
        .then(function () {
          return load.n;
        });
      }
    
      // the closest we can get to call(undefined)
      const nullContext = Object.freeze(Object.create(null));
    
      // returns a promise if and only if a top-level await subgraph
      // throws on sync errors
      function postOrderExec (loader, load, seen) {
        if (seen[load.id])
          return;
        seen[load.id] = true;
    
        if (!load.e) {
          if (load.eE)
            throw load.eE;
          if (load.E)
            return load.E;
          return;
        }
    
        // deps execute first, unless circular
        let depLoadPromises;
        load.d.forEach(function (depLoad) {
          {
            try {
              const depLoadPromise = postOrderExec(loader, depLoad, seen);
              if (depLoadPromise)
                (depLoadPromises = depLoadPromises || []).push(depLoadPromise);
            }
            catch (err) {
              loader.onload(load.id, err);
              throw err;
            }
          }
        });
        if (depLoadPromises) {
          return Promise.all(depLoadPromises)
            .then(doExec)
            .catch(function (err) {
              loader.onload(load.id, err);
              throw err;
            });
        }
    
        return doExec();
    
        function doExec () {
          try {
            let execPromise = load.e.call(nullContext);
            if (execPromise) {
              execPromise = execPromise.then(function () {
                  load.C = load.n;
                  load.E = null; // indicates completion
                  loader.onload(load.id, null);
                }, function () {
                  loader.onload(load.id, err);
                  throw err;
                });
              execPromise.catch(function () {});
              return load.E = load.E || execPromise;
            }
            // (should be a promise, but a minify optimization to leave out Promise.resolve)
            load.C = load.n;
            loader.onload(load.id, null);
          }
          catch (err) {
            loader.onload(load.id, err);
            load.eE = err;
            throw err;
          }
          finally {
            load.L = load.I = undefined;
            load.e = null;
          }
        }
      }
    
      envGlobal.System = new SystemJS();
    
      /*
       * Supports loading System.register via script tag injection
       */
    
      let err$1;
      if (typeof window !== 'undefined')
        window.addEventListener('error', function (e) {
          err$1 = e.error;
        });
    
      const systemRegister = systemJSPrototype.register;
      systemJSPrototype.register = function (deps, declare) {
        err$1 = undefined;
        systemRegister.call(this, deps, declare);
      };
    
      systemJSPrototype.instantiate = function (url, firstParentUrl) {
        const loader = this;
        return new Promise(function (resolve, reject) {
          const script = document.createElement('script');
          script.charset = 'utf-8';
          script.async = true;
          script.crossOrigin = 'anonymous';
          script.addEventListener('error', function () {
            reject(new Error('Error loading ' + url + (firstParentUrl ? ' from ' + firstParentUrl : '')));
          });
          script.addEventListener('load', function () {
            document.head.removeChild(script);
            // Note URL normalization issues are going to be a careful concern here
            if (err$1)
              return reject(err$1);
            else
              resolve(loader.getRegister());
          });
          script.src = url;
          document.head.appendChild(script);
        });
      };
    
      /*
       * Supports loading System.register in workers
       */
    
      if (hasSelf && typeof importScripts === 'function')
        systemJSPrototype.instantiate = function (url) {
          const loader = this;
          return new Promise(function (resolve, reject) {
            try {
              importScripts(url);
            }
            catch (e) {
              reject(e);
            }
            resolve(loader.getRegister());
          });
        };
    
      /*
       * SystemJS global script loading support
       * Extra for the s.js build only
       * (Included by default in system.js build)
       */
      (function (global) {
    
      const systemJSPrototype = System.constructor.prototype;
    
      // safari unpredictably lists some new globals first or second in object order
      let firstGlobalProp, secondGlobalProp, lastGlobalProp;
      function getGlobalProp () {
        let cnt = 0;
        let lastProp;
        for (let p in global) {
          if (!global.hasOwnProperty(p))
            continue;
          if (cnt === 0 && p !== firstGlobalProp || cnt === 1 && p !== secondGlobalProp)
            return p;
          cnt++;
          lastProp = p;
        }
        if (lastProp !== lastGlobalProp)
          return lastProp;
      }
    
      function noteGlobalProps () {
        // alternatively Object.keys(global).pop()
        // but this may be faster (pending benchmarks)
        firstGlobalProp = secondGlobalProp = undefined;
        for (let p in global) {
          if (!global.hasOwnProperty(p))
            continue;
          if (!firstGlobalProp)
            firstGlobalProp = p;
          else if (!secondGlobalProp)
            secondGlobalProp = p;
          lastGlobalProp = p;
        }
        return lastGlobalProp;
      }
    
      const impt = systemJSPrototype.import;
      systemJSPrototype.import = function (id, parentUrl) {
        noteGlobalProps();
        return impt.call(this, id, parentUrl);
      };
    
      const emptyInstantiation = [[], function () { return {} }];
    
      const getRegister = systemJSPrototype.getRegister;
      systemJSPrototype.getRegister = function () {
        const lastRegister = getRegister.call(this);
        if (lastRegister)
          return lastRegister;
        
        // no registration -> attempt a global detection as difference from snapshot
        // when multiple globals, we take the global value to be the last defined new global object property
        // for performance, this will not support multi-version / global collisions as previous SystemJS versions did
        // note in Edge, deleting and re-adding a global does not change its ordering
        const globalProp = getGlobalProp();
        if (!globalProp)
          return emptyInstantiation;
        
        let globalExport;
        try {
          globalExport = global[globalProp];
        }
        catch (e) {
          return emptyInstantiation;
        }
    
        return [[], function (_export) {
          return { execute: function () { _export('default', globalExport); } };
        }];
      };
    
      })(typeof self !== 'undefined' ? self : global);
    
      /*
       * Loads WASM based on file extension detection
       * Assumes successive instantiate will handle other files
       */
      const instantiate = systemJSPrototype.instantiate;
      systemJSPrototype.instantiate = function (url, parent) {
        if (url.slice(-5) !== '.wasm')
          return instantiate.call(this, url, parent);
        
        return fetch(url)
        .then(function (res) {
          if (!res.ok)
            throw new Error(res.status + ' ' + res.statusText + ' ' + res.url + (parent ? ' loading from ' + parent : ''));
    
          if (WebAssembly.compileStreaming)
            return WebAssembly.compileStreaming(res);
          
          return res.arrayBuffer()
          .then(function (buf) {
            return WebAssembly.compile(buf);
          });
        })
        .then(function (module) {
          const deps = [];
          const setters = [];
          const importObj = {};
    
          // we can only set imports if supported (eg early Safari doesnt support)
          if (WebAssembly.Module.imports)
            WebAssembly.Module.imports(module).forEach(function (impt) {
              const key = impt.module;
              setters.push(function (m) {
                importObj[key] = m;
              });
              if (deps.indexOf(key) === -1)
                deps.push(key);
            });
    
          return [deps, function (_export) {
            return {
              setters: setters,
              execute: function () {
                return WebAssembly.instantiate(module, importObj)
                .then(function (instance) {
                  _export(instance.exports);
                });
              }
            };
          }];
        });
      };
    
      /*
       * Package name map support for SystemJS
       * 
       * <script type="systemjs-packagemap">{}</script>
       * OR
       * <script type="systemjs-packagemap" src=package.json></script>
       * 
       * Only supports loading the first package map
       */
    
      let packageMapPromise, packageMapResolve;
      if (typeof document !== 'undefined') {
        const scripts = document.getElementsByTagName('script');
        for (let i = 0; i < scripts.length; i++) {
          const script = scripts[i];
          if (script.type !== 'systemjs-packagemap')
            continue;
    
          if (!script.src) {
            packageMapResolve = createPackageMap(JSON.parse(script.innerHTML), baseUrl);
            packageMapPromise = Promise.resolve();
          }
          else {
            packageMapPromise = fetch(script.src)
            .then(function (res) {
              return res.json();
            })
            .then(function (json) {
              packageMapResolve = createPackageMap(json, script.src);
              packageMapPromise = undefined;
            }, function () {
              packageMapResolve = throwBare;
              packageMapPromise = undefined;
            });
          }
          break;
        }
      }
      if (!packageMapPromise)
        packageMapResolve = throwBare;
    
      systemJSPrototype.resolve = function (id, parentUrl) {
        parentUrl = parentUrl || baseUrl;
    
        const resolvedIfNotPlainOrUrl = resolveIfNotPlainOrUrl(id, parentUrl);
        if (resolvedIfNotPlainOrUrl)
          return resolvedIfNotPlainOrUrl;
        if (id.indexOf(':') !== -1)
          return id;
    
        // now just left with plain
        // (if not package map, packageMapResolve just throws)
        if (packageMapPromise)
          return packageMapPromise
          .then(function () {
            return packageMapResolve(id, parentUrl);
          });
    
        return packageMapResolve(id, parentUrl);
      };
    
      systemJSPrototype.get = function (id) {
        const load = this[REGISTRY][id];
        if (load && load.e === null && !load.E) {
          if (load.eE)
            return null;
          return load.n;
        }
      };
    
      // Delete function provided for hot-reloading use cases
      systemJSPrototype.delete = function (id) {
        const load = this.get(id);
        if (load === undefined)
          return false;
        // remove from importerSetters
        // (release for gc)
        if (load && load.d)
          load.d.forEach(function (depLoad) {
            const importerIndex = depLoad.i.indexOf(load);
            if (importerIndex !== -1)
              depLoad.i.splice(importerIndex, 1);
          });
        return delete this[REGISTRY][id];
      };
    
    }());