npm - @jsenv/core - Versions diffs - 24.1.0-alpha.0 → 24.3.1 - Mend

@jsenv/core 24.1.0-alpha.0 → 24.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (180) hide show

package/dist/redirector/redirector-237cd168.html ADDED Viewed

@@ -0,0 +1,2118 @@
+<!DOCTYPE html><html><head>
+    <title>Jsenv redirector</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta charset="utf-8">
+    <link rel="icon" href="data:,">
+  <script id="jsenv_inject_systemjs">/*
+* SJS 6.11.0
+* Minimal SystemJS Build
+*/
+(function () {
+  function errMsg(errCode, msg) {
+    return (msg || "") + " (SystemJS https://git.io/JvFET#" + errCode + ")";
+  }
+  var hasSymbol = typeof Symbol !== 'undefined';
+  var hasSelf = typeof self !== 'undefined';
+  var hasDocument = typeof document !== 'undefined';
+  var envGlobal = hasSelf ? self : global;
+  var baseUrl;
+  if (hasDocument) {
+    var baseEl = document.querySelector('base[href]');
+    if (baseEl) baseUrl = baseEl.href;
+  }
+  if (!baseUrl && typeof location !== 'undefined') {
+    baseUrl = location.href.split('#')[0].split('?')[0];
+    var lastSepIndex = baseUrl.lastIndexOf('/');
+    if (lastSepIndex !== -1) baseUrl = baseUrl.slice(0, lastSepIndex + 1);
+  }
+  var 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] === '/') {
+      var parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1); // Disabled, but these cases will give inconsistent results for deep backtracking
+      //if (parentUrl[parentProtocol.length] !== '/')
+      //  throw Error('Cannot resolve');
+      // read pathname from parent URL
+      // pathname taken to be part after leading "/"
+      var 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'
+      var segmented = pathname.slice(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.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('');
+    }
+  }
+  /*
+   * Import maps implementation
+   *
+   * To make lookups fast we pre-resolve the entire import map
+   * and then match based on backtracked hash lookups
+   *
+   */
+  function resolveUrl(relUrl, parentUrl) {
+    return resolveIfNotPlainOrUrl(relUrl, parentUrl) || (relUrl.indexOf(':') !== -1 ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
+  }
+  function resolveAndComposePackages(packages, outPackages, baseUrl, parentMap, parentUrl) {
+    for (var p in packages) {
+      var resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
+      var rhs = packages[p]; // package fallbacks not currently supported
+      if (typeof rhs !== 'string') continue;
+      var mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(rhs, baseUrl) || rhs, parentUrl);
+      if (!mapped) {
+        targetWarning('W1', p, rhs);
+      } else outPackages[resolvedLhs] = mapped;
+    }
+  }
+  function resolveAndComposeImportMap(json, baseUrl, outMap) {
+    if (json.imports) resolveAndComposePackages(json.imports, outMap.imports, baseUrl, outMap, null);
+    var u;
+    for (u in json.scopes || {}) {
+      var resolvedScope = resolveUrl(u, baseUrl);
+      resolveAndComposePackages(json.scopes[u], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, outMap, resolvedScope);
+    }
+    for (u in json.depcache || {}) outMap.depcache[resolveUrl(u, baseUrl)] = json.depcache[u];
+    for (u in json.integrity || {}) outMap.integrity[resolveUrl(u, baseUrl)] = json.integrity[u];
+  }
+  function getMatch(path, matchObj) {
+    if (matchObj[path]) return path;
+    var sepIndex = path.length;
+    do {
+      var segment = path.slice(0, sepIndex + 1);
+      if (segment in matchObj) return segment;
+    } while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1);
+  }
+  function applyPackages(id, packages) {
+    var pkgName = getMatch(id, packages);
+    if (pkgName) {
+      var pkg = packages[pkgName];
+      if (pkg === null) return;
+      if (id.length > pkgName.length && pkg[pkg.length - 1] !== '/') {
+        targetWarning('W2', pkgName, pkg);
+      } else return pkg + id.slice(pkgName.length);
+    }
+  }
+  function targetWarning(code, match, target, msg) {
+    console.warn(errMsg(code, [target, match].join(', ')));
+  }
+  function resolveImportMap(importMap, resolvedOrPlain, parentUrl) {
+    var scopes = importMap.scopes;
+    var scopeUrl = parentUrl && getMatch(parentUrl, scopes);
+    while (scopeUrl) {
+      var packageResolution = applyPackages(resolvedOrPlain, scopes[scopeUrl]);
+      if (packageResolution) return packageResolution;
+      scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf('/')), scopes);
+    }
+    return applyPackages(resolvedOrPlain, importMap.imports) || resolvedOrPlain.indexOf(':') !== -1 && resolvedOrPlain;
+  }
+  /*
+   * 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(err, id, deps) handler for tracing / hot-reloading
+   *
+   * Core comes with no System.prototype.resolve or
+   * System.prototype.instantiate implementations
+   */
+  var toStringTag = hasSymbol && Symbol.toStringTag;
+  var REGISTRY = hasSymbol ? Symbol() : '@';
+  function SystemJS() {
+    this[REGISTRY] = {};
+  }
+  var systemJSPrototype = SystemJS.prototype;
+  systemJSPrototype.import = function (id, parentUrl) {
+    var loader = this;
+    return Promise.resolve(loader.prepareImport()).then(function () {
+      return loader.resolve(id, parentUrl);
+    }).then(function (id) {
+      var load = getOrCreateLoad(loader, id);
+      return load.C || topLevelLoad(loader, load);
+    });
+  }; // Hookable createContext function -> allowing eg custom import meta
+  systemJSPrototype.createContext = function (parentId) {
+    var loader = this;
+    return {
+      url: parentId,
+      resolve: function (id, parentUrl) {
+        return Promise.resolve(loader.resolve(id, parentUrl || parentId));
+      }
+    };
+  };
+  function loadToId(load) {
+    return load.id;
+  }
+  function triggerOnload(loader, load, err, isErrSource) {
+    loader.onload(err, load.id, load.d && load.d.map(loadToId), !!isErrSource);
+    if (err) throw err;
+  }
+  var lastRegister;
+  systemJSPrototype.register = function (deps, declare) {
+    lastRegister = [deps, declare];
+  };
+  /*
+   * getRegister provides the last anonymous System.register call
+   */
+  systemJSPrototype.getRegister = function () {
+    var _lastRegister = lastRegister;
+    lastRegister = undefined;
+    return _lastRegister;
+  };
+  function getOrCreateLoad(loader, id, firstParentUrl) {
+    var load = loader[REGISTRY][id];
+    if (load) return load;
+    var importerSetters = [];
+    var ns = Object.create(null);
+    if (toStringTag) Object.defineProperty(ns, toStringTag, {
+      value: 'Module'
+    });
+    var instantiatePromise = Promise.resolve().then(function () {
+      return loader.instantiate(id, firstParentUrl);
+    }).then(function (registration) {
+      if (!registration) throw Error(errMsg(2, id));
+      function _export(name, value) {
+        // note if we have hoisted exports (including reexports)
+        load.h = true;
+        var changed = false;
+        if (typeof name === 'string') {
+          if (!(name in ns) || ns[name] !== value) {
+            ns[name] = value;
+            changed = true;
+          }
+        } else {
+          for (var p in name) {
+            var value = name[p];
+            if (!(p in ns) || ns[p] !== value) {
+              ns[p] = value;
+              changed = true;
+            }
+          }
+          if (name && name.__esModule) {
+            ns.__esModule = name.__esModule;
+          }
+        }
+        if (changed) for (var i = 0; i < importerSetters.length; i++) {
+          var setter = importerSetters[i];
+          if (setter) setter(ns);
+        }
+        return value;
+      }
+      var 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 || []];
+    }, function (err) {
+      load.e = null;
+      load.er = err;
+      throw err;
+    });
+    var linkPromise = instantiatePromise.then(function (instantiation) {
+      return Promise.all(instantiation[0].map(function (dep, i) {
+        var setter = instantiation[1][i];
+        return Promise.resolve(loader.resolve(dep, id)).then(function (depId) {
+          var 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;
+      });
+    }); // Capital 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
+      e: undefined,
+      // On execution we have populated:
+      // the execution error if any
+      er: undefined,
+      // in the case of TLA, the execution promise
+      E: undefined,
+      // On execution, L, I, E cleared
+      // Promise for top-level completion
+      C: undefined,
+      // parent instantiator / executor
+      p: undefined
+    };
+  }
+  function instantiateAll(loader, load, parent, loaded) {
+    if (!loaded[load.id]) {
+      loaded[load.id] = true; // load.L may be undefined for already-instantiated
+      return Promise.resolve(load.L).then(function () {
+        if (!load.p || load.p.e === null) load.p = parent;
+        return Promise.all(load.d.map(function (dep) {
+          return instantiateAll(loader, dep, parent, loaded);
+        }));
+      }).catch(function (err) {
+        if (load.er) throw err;
+        load.e = null;
+        throw err;
+      });
+    }
+  }
+  function topLevelLoad(loader, load) {
+    return load.C = instantiateAll(loader, load, load, {}).then(function () {
+      return postOrderExec(loader, load, {});
+    }).then(function () {
+      return load.n;
+    });
+  } // the closest we can get to call(undefined)
+  var 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.er) throw load.er;
+      if (load.E) return load.E;
+      return;
+    } // deps execute first, unless circular
+    var depLoadPromises;
+    load.d.forEach(function (depLoad) {
+      try {
+        var depLoadPromise = postOrderExec(loader, depLoad, seen);
+        if (depLoadPromise) (depLoadPromises = depLoadPromises || []).push(depLoadPromise);
+      } catch (err) {
+        load.e = null;
+        load.er = err;
+        throw err;
+      }
+    });
+    if (depLoadPromises) return Promise.all(depLoadPromises).then(doExec);
+    return doExec();
+    function doExec() {
+      try {
+        var execPromise = load.e.call(nullContext);
+        if (execPromise) {
+          execPromise = execPromise.then(function () {
+            load.C = load.n;
+            load.E = null; // indicates completion
+            if (!true) ;
+          }, function (err) {
+            load.er = err;
+            load.E = null;
+            if (!true) ;
+            throw err;
+          });
+          return load.E = execPromise;
+        } // (should be a promise, but a minify optimization to leave out Promise.resolve)
+        load.C = load.n;
+        load.L = load.I = undefined;
+      } catch (err) {
+        load.er = err;
+        throw err;
+      } finally {
+        load.e = null;
+      }
+    }
+  }
+  envGlobal.System = new SystemJS();
+  /*
+   * SystemJS browser attachments for script and import map processing
+   */
+  var importMapPromise = Promise.resolve();
+  var importMap = {
+    imports: {},
+    scopes: {},
+    depcache: {},
+    integrity: {}
+  }; // Scripts are processed immediately, on the first System.import, and on DOMReady.
+  // Import map scripts are processed only once (by being marked) and in order for each phase.
+  // This is to avoid using DOM mutation observers in core, although that would be an alternative.
+  var processFirst = hasDocument;
+  systemJSPrototype.prepareImport = function (doProcessScripts) {
+    if (processFirst || doProcessScripts) {
+      processScripts();
+      processFirst = false;
+    }
+    return importMapPromise;
+  };
+  if (hasDocument) {
+    processScripts();
+    window.addEventListener('DOMContentLoaded', processScripts);
+  }
+  function processScripts() {
+    [].forEach.call(document.querySelectorAll('script'), function (script) {
+      if (script.sp) // sp marker = systemjs processed
+        return; // TODO: deprecate systemjs-module in next major now that we have auto import
+      if (script.type === 'systemjs-module') {
+        script.sp = true;
+        if (!script.src) return;
+        System.import(script.src.slice(0, 7) === 'import:' ? script.src.slice(7) : resolveUrl(script.src, baseUrl)).catch(function (e) {
+          // if there is a script load error, dispatch an "error" event
+          // on the script tag.
+          if (e.message.indexOf('https://git.io/JvFET#3') > -1) {
+            var event = document.createEvent('Event');
+            event.initEvent('error', false, false);
+            script.dispatchEvent(event);
+          }
+          return Promise.reject(e);
+        });
+      } else if (script.type === 'systemjs-importmap') {
+        script.sp = true;
+        var fetchPromise = script.src ? fetch(script.src, {
+          integrity: script.integrity
+        }).then(function (res) {
+          if (!res.ok) throw Error(res.status);
+          return res.text();
+        }).catch(function (err) {
+          err.message = errMsg('W4', script.src) + '\n' + err.message;
+          console.warn(err);
+          if (typeof script.onerror === 'function') {
+            script.onerror();
+          }
+          return '{}';
+        }) : script.innerHTML;
+        importMapPromise = importMapPromise.then(function () {
+          return fetchPromise;
+        }).then(function (text) {
+          extendImportMap(importMap, text, script.src || baseUrl);
+        });
+      }
+    });
+  }
+  function extendImportMap(importMap, newMapText, newMapUrl) {
+    var newMap = {};
+    try {
+      newMap = JSON.parse(newMapText);
+    } catch (err) {
+      console.warn(Error(errMsg('W5')));
+    }
+    resolveAndComposeImportMap(newMap, newMapUrl, importMap);
+  }
+  /*
+   * Script instantiation loading
+   */
+  if (hasDocument) {
+    window.addEventListener('error', function (evt) {
+      lastWindowErrorUrl = evt.filename;
+      lastWindowError = evt.error;
+    });
+    var baseOrigin = location.origin;
+  }
+  systemJSPrototype.createScript = function (url) {
+    var script = document.createElement('script');
+    script.async = true; // Only add cross origin for actual cross origin
+    // this is because Safari triggers for all
+    // - https://bugs.webkit.org/show_bug.cgi?id=171566
+    if (url.indexOf(baseOrigin + '/')) script.crossOrigin = 'anonymous';
+    var integrity = importMap.integrity[url];
+    if (integrity) script.integrity = integrity;
+    script.src = url;
+    return script;
+  }; // Auto imports -> script tags can be inlined directly for load phase
+  var lastAutoImportDeps, lastAutoImportTimeout;
+  var autoImportCandidates = {};
+  var systemRegister = systemJSPrototype.register;
+  var inlineScriptCount = 0;
+  systemJSPrototype.register = function (deps, declare) {
+    if (hasDocument && document.readyState === 'loading' && typeof deps !== 'string') {
+      var scripts = document.querySelectorAll('script[src]');
+      var lastScript = scripts[scripts.length - 1];
+      var lastAutoImportUrl;
+      lastAutoImportDeps = deps;
+      if (lastScript) {
+        lastAutoImportUrl = lastScript.src;
+      } else {
+        inlineScriptCount++;
+        lastAutoImportUrl = document.location.href + "__inline_script__" + inlineScriptCount;
+      } // if this is already a System load, then the instantiate has already begun
+      // so this re-import has no consequence
+      var loader = this;
+      lastAutoImportTimeout = setTimeout(function () {
+        autoImportCandidates[lastAutoImportUrl] = [deps, declare];
+        loader.import(lastAutoImportUrl);
+      });
+    } else {
+      lastAutoImportDeps = undefined;
+    }
+    return systemRegister.call(this, deps, declare);
+  };
+  var lastWindowErrorUrl, lastWindowError;
+  systemJSPrototype.instantiate = function (url, firstParentUrl) {
+    var autoImportRegistration = autoImportCandidates[url];
+    if (autoImportRegistration) {
+      delete autoImportCandidates[url];
+      return autoImportRegistration;
+    }
+    var loader = this;
+    return Promise.resolve(systemJSPrototype.createScript(url)).then(function (script) {
+      return new Promise(function (resolve, reject) {
+        script.addEventListener('error', function () {
+          reject(Error(errMsg(3, [url, firstParentUrl].join(', '))));
+        });
+        script.addEventListener('load', function () {
+          document.head.removeChild(script); // Note that if an error occurs that isn't caught by this if statement,
+          // that getRegister will return null and a "did not instantiate" error will be thrown.
+          if (lastWindowErrorUrl === url) {
+            reject(lastWindowError);
+          } else {
+            var register = loader.getRegister(url); // Clear any auto import registration for dynamic import scripts during load
+            if (register && register[0] === lastAutoImportDeps) clearTimeout(lastAutoImportTimeout);
+            resolve(register);
+          }
+        });
+        document.head.appendChild(script);
+      });
+    });
+  };
+  /*
+   * Fetch loader, sets up shouldFetch and fetch hooks
+   */
+  systemJSPrototype.shouldFetch = function () {
+    return false;
+  };
+  if (typeof fetch !== 'undefined') systemJSPrototype.fetch = fetch;
+  var instantiate = systemJSPrototype.instantiate;
+  var jsContentTypeRegEx = /^(text|application)\/(x-)?javascript(;|$)/;
+  systemJSPrototype.instantiate = function (url, parent) {
+    var loader = this;
+    if (!this.shouldFetch(url)) return instantiate.apply(this, arguments);
+    return this.fetch(url, {
+      credentials: 'same-origin',
+      integrity: importMap.integrity[url]
+    }).then(function (res) {
+      if (!res.ok) throw Error(errMsg(7, [res.status, res.statusText, url, parent].join(', ')));
+      var contentType = res.headers.get('content-type');
+      if (!contentType || !jsContentTypeRegEx.test(contentType)) throw Error(errMsg(4, contentType));
+      return res.text().then(function (source) {
+        if (source.indexOf('//# sourceURL=') < 0) source += '\n//# sourceURL=' + url;
+        (0, eval)(source);
+        return loader.getRegister(url);
+      });
+    });
+  };
+  systemJSPrototype.resolve = function (id, parentUrl) {
+    parentUrl = parentUrl || !true || baseUrl;
+    return resolveImportMap(importMap, resolveIfNotPlainOrUrl(id, parentUrl) || id, parentUrl) || throwUnresolved(id, parentUrl);
+  };
+  function throwUnresolved(id, parentUrl) {
+    throw Error(errMsg(8, [id, parentUrl].join(', ')));
+  }
+  var systemInstantiate = systemJSPrototype.instantiate;
+  systemJSPrototype.instantiate = function (url, firstParentUrl) {
+    var preloads = importMap.depcache[url];
+    if (preloads) {
+      for (var i = 0; i < preloads.length; i++) getOrCreateLoad(this, this.resolve(preloads[i], url), url);
+    }
+    return systemInstantiate.call(this, url, firstParentUrl);
+  };
+  /*
+   * Supports loading System.register in workers
+   */
+  if (hasSelf && typeof importScripts === 'function') systemJSPrototype.instantiate = function (url) {
+    var loader = this;
+    return Promise.resolve().then(function () {
+      importScripts(url);
+      return loader.getRegister(url);
+    });
+  };
+})();
+//# sourceMappingURL=assets/s.js-749702e8.map</script>
+      </head>
+  <body>
+    <script type="systemjs-importmap">
+{
+  "imports": {}
+}</script>
+    <script>System.register([], (function () {
+  'use strict';
+  return {
+    execute: (function () {
+      var _defineProperty = (function (obj, key, value) {
+        // Shortcircuit the slow defineProperty path when possible.
+        // We are trying to avoid issues where setters defined on the
+        // prototype cause side effects under the fast path of simple
+        // assignment. By checking for existence of the property with
+        // the in operator, we can optimize most of this overhead away.
+        if (key in obj) {
+          Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+        } else {
+          obj[key] = value;
+        }
+        return obj;
+      });
+      var createDetailedMessage = function createDetailedMessage(message) {
+        var details = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var string = "".concat(message);
+        Object.keys(details).forEach(function (key) {
+          var value = details[key];
+          string += "\n--- ".concat(key, " ---\n").concat(Array.isArray(value) ? value.join("\n") : value);
+        });
+        return string;
+      };
+      var COMPILE_ID_OTHERWISE = "otherwise";
+      var computeCompileIdFromGroupId = function computeCompileIdFromGroupId(_ref) {
+        var groupId = _ref.groupId,
+            groupMap = _ref.groupMap;
+        if (typeof groupId === "undefined") {
+          if (COMPILE_ID_OTHERWISE in groupMap) {
+            return COMPILE_ID_OTHERWISE;
+          }
+          var keys = Object.keys(groupMap);
+          if (keys.length === 1) {
+            return keys[0];
+          }
+          throw new Error(createUnexpectedGroupIdMessage({
+            groupMap: groupMap
+          }));
+        }
+        if (groupId in groupMap === false) {
+          throw new Error(createUnexpectedGroupIdMessage({
+            groupId: groupId,
+            groupMap: groupMap
+          }));
+        }
+        return groupId;
+      };
+      var createUnexpectedGroupIdMessage = function createUnexpectedGroupIdMessage(_ref2) {
+        var _createDetailedMessag;
+        var compileId = _ref2.compileId,
+            groupMap = _ref2.groupMap;
+        return createDetailedMessage("unexpected groupId.", (_createDetailedMessag = {}, _defineProperty(_createDetailedMessag, "expected compiled id", Object.keys(groupMap)), _defineProperty(_createDetailedMessag, "received compile id", compileId), _createDetailedMessag));
+      };
+      var valueToVersion = function valueToVersion(value) {
+        if (typeof value === "number") {
+          return numberToVersion(value);
+        }
+        if (typeof value === "string") {
+          return stringToVersion(value);
+        }
+        throw new TypeError("version must be a number or a string, got ".concat(value));
+      };
+      var numberToVersion = function numberToVersion(number) {
+        return {
+          major: number,
+          minor: 0,
+          patch: 0
+        };
+      };
+      var stringToVersion = function stringToVersion(string) {
+        if (string.indexOf(".") > -1) {
+          var parts = string.split(".");
+          return {
+            major: Number(parts[0]),
+            minor: parts[1] ? Number(parts[1]) : 0,
+            patch: parts[2] ? Number(parts[2]) : 0
+          };
+        }
+        if (isNaN(string)) {
+          return {
+            major: 0,
+            minor: 0,
+            patch: 0
+          };
+        }
+        return {
+          major: Number(string),
+          minor: 0,
+          patch: 0
+        };
+      };
+      var versionCompare = function versionCompare(versionA, versionB) {
+        var semanticVersionA = valueToVersion(versionA);
+        var semanticVersionB = valueToVersion(versionB);
+        var majorDiff = semanticVersionA.major - semanticVersionB.major;
+        if (majorDiff > 0) {
+          return majorDiff;
+        }
+        if (majorDiff < 0) {
+          return majorDiff;
+        }
+        var minorDiff = semanticVersionA.minor - semanticVersionB.minor;
+        if (minorDiff > 0) {
+          return minorDiff;
+        }
+        if (minorDiff < 0) {
+          return minorDiff;
+        }
+        var patchDiff = semanticVersionA.patch - semanticVersionB.patch;
+        if (patchDiff > 0) {
+          return patchDiff;
+        }
+        if (patchDiff < 0) {
+          return patchDiff;
+        }
+        return 0;
+      };
+      var versionIsBelow = function versionIsBelow(versionSupposedBelow, versionSupposedAbove) {
+        return versionCompare(versionSupposedBelow, versionSupposedAbove) < 0;
+      };
+      var findHighestVersion = function findHighestVersion() {
+        for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+          values[_key] = arguments[_key];
+        }
+        if (values.length === 0) throw new Error("missing argument");
+        return values.reduce(function (highestVersion, value) {
+          if (versionIsBelow(highestVersion, value)) {
+            return value;
+          }
+          return highestVersion;
+        });
+      };
+      var resolveGroup = function resolveGroup(_ref, groupMap) {
+        var name = _ref.name,
+            version = _ref.version;
+        return Object.keys(groupMap).find(function (compileIdCandidate) {
+          var minRuntimeVersions = groupMap[compileIdCandidate].minRuntimeVersions;
+          var versionForGroup = minRuntimeVersions[name];
+          if (!versionForGroup) {
+            return false;
+          }
+          var highestVersion = findHighestVersion(version, versionForGroup);
+          return highestVersion === version;
+        });
+      };
+      function ownKeys(object, enumerableOnly) {
+        var keys = Object.keys(object);
+        if (Object.getOwnPropertySymbols) {
+          var symbols = Object.getOwnPropertySymbols(object);
+          if (enumerableOnly) {
+            symbols = symbols.filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+          }
+          keys.push.apply(keys, symbols);
+        }
+        return keys;
+      }
+      function _objectSpread2(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i] != null ? arguments[i] : {};
+          if (i % 2) {
+            ownKeys(Object(source), true).forEach(function (key) {
+              _defineProperty(target, key, source[key]);
+            });
+          } else if (Object.getOwnPropertyDescriptors) {
+            Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+          } else {
+            ownKeys(Object(source)).forEach(function (key) {
+              Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+            });
+          }
+        }
+        return target;
+      }
+      var objectWithoutPropertiesLoose = (function (source, excluded) {
+        if (source === null) return {};
+        var target = {};
+        var sourceKeys = Object.keys(source);
+        var key;
+        var i;
+        for (i = 0; i < sourceKeys.length; i++) {
+          key = sourceKeys[i];
+          if (excluded.indexOf(key) >= 0) continue;
+          target[key] = source[key];
+        }
+        return target;
+      });
+      var _objectWithoutProperties = (function (source, excluded) {
+        if (source === null) return {};
+        var target = objectWithoutPropertiesLoose(source, excluded);
+        var key;
+        var i;
+        if (Object.getOwnPropertySymbols) {
+          var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+          for (i = 0; i < sourceSymbolKeys.length; i++) {
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+          }
+        }
+        return target;
+      });
+      var nativeTypeOf = function nativeTypeOf(obj) {
+        return typeof obj;
+      };
+      var customTypeOf = function customTypeOf(obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+      };
+      var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? nativeTypeOf : customTypeOf;
+      /* eslint-env browser */
+      function _await$4(value, then, direct) {
+        if (direct) {
+          return then ? then(value) : value;
+        }
+        if (!value || !value.then) {
+          value = Promise.resolve(value);
+        }
+        return then ? value.then(then) : value;
+      }
+      function _async$4(f) {
+        return function () {
+          for (var args = [], i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+          }
+          try {
+            return Promise.resolve(f.apply(this, args));
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+      }
+      function _call$1(body, then, direct) {
+        if (direct) {
+          return then ? then(body()) : body();
+        }
+        try {
+          var result = Promise.resolve(body());
+          return then ? result.then(then) : result;
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+      var fetchUsingXHR = _async$4(function (url) {
+        var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+            signal = _ref.signal,
+            _ref$method = _ref.method,
+            method = _ref$method === void 0 ? "GET" : _ref$method,
+            _ref$credentials = _ref.credentials,
+            credentials = _ref$credentials === void 0 ? "same-origin" : _ref$credentials,
+            _ref$headers = _ref.headers,
+            headers = _ref$headers === void 0 ? {} : _ref$headers,
+            _ref$body = _ref.body,
+            body = _ref$body === void 0 ? null : _ref$body;
+        var headersPromise = createPromiseAndHooks();
+        var bodyPromise = createPromiseAndHooks();
+        var xhr = new XMLHttpRequest();
+        var failure = function failure(error) {
+          // if it was already resolved, we must reject the body promise
+          if (headersPromise.settled) {
+            bodyPromise.reject(error);
+          } else {
+            headersPromise.reject(error);
+          }
+        };
+        var cleanup = function cleanup() {
+          xhr.ontimeout = null;
+          xhr.onerror = null;
+          xhr.onload = null;
+          xhr.onreadystatechange = null;
+        };
+        xhr.ontimeout = function () {
+          cleanup();
+          failure(new Error("xhr request timeout on ".concat(url, ".")));
+        };
+        xhr.onerror = function (error) {
+          cleanup(); // unfortunately with have no clue why it fails
+          // might be cors for instance
+          failure(createRequestError(error, {
+            url: url
+          }));
+        };
+        xhr.onload = function () {
+          cleanup();
+          bodyPromise.resolve();
+        };
+        signal.addEventListener("abort", function () {
+          xhr.abort();
+          var abortError = new Error("aborted");
+          abortError.name = "AbortError";
+          failure(abortError);
+        });
+        xhr.onreadystatechange = function () {
+          // https://developer.mozilla.org/fr/docs/Web/API/XMLHttpRequest/readyState
+          var readyState = xhr.readyState;
+          if (readyState === 2) {
+            headersPromise.resolve();
+          } else if (readyState === 4) {
+            cleanup();
+            bodyPromise.resolve();
+          }
+        };
+        xhr.open(method, url, true);
+        Object.keys(headers).forEach(function (key) {
+          xhr.setRequestHeader(key, headers[key]);
+        });
+        xhr.withCredentials = computeWithCredentials({
+          credentials: credentials,
+          url: url
+        });
+        if ("responseType" in xhr && hasBlob) {
+          xhr.responseType = "blob";
+        }
+        xhr.send(body);
+        return _await$4(headersPromise, function () {
+          // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseURL
+          var responseUrl = "responseURL" in xhr ? xhr.responseURL : headers["x-request-url"];
+          var responseStatus = xhr.status;
+          var responseStatusText = xhr.statusText;
+          var responseHeaders = getHeadersFromXHR(xhr);
+          var readBody = function readBody() {
+            return _await$4(bodyPromise, function () {
+              var status = xhr.status; // in Chrome on file:/// URLs, status is 0
+              if (status === 0) {
+                responseStatus = 200;
+              }
+              var body = "response" in xhr ? xhr.response : xhr.responseText;
+              return {
+                responseBody: body,
+                responseBodyType: detectBodyType(body)
+              };
+            });
+          };
+          var text = function text() {
+            return _call$1(readBody, function (_ref2) {
+              var responseBody = _ref2.responseBody,
+                  responseBodyType = _ref2.responseBodyType;
+              if (responseBodyType === "blob") {
+                return blobToText(responseBody);
+              }
+              if (responseBodyType === "formData") {
+                throw new Error("could not read FormData body as text");
+              }
+              return responseBodyType === "dataView" ? arrayBufferToText(responseBody.buffer) : responseBodyType === "arrayBuffer" ? arrayBufferToText(responseBody) : String(responseBody);
+            });
+          };
+          var json = function json() {
+            return _call$1(text, JSON.parse);
+          };
+          var blob = _async$4(function () {
+            if (!hasBlob) {
+              throw new Error("blob not supported");
+            }
+            return _call$1(readBody, function (_ref3) {
+              var responseBody = _ref3.responseBody,
+                  responseBodyType = _ref3.responseBodyType;
+              if (responseBodyType === "blob") {
+                return responseBody;
+              }
+              if (responseBodyType === "dataView") {
+                return new Blob([cloneBuffer(responseBody.buffer)]);
+              }
+              if (responseBodyType === "arrayBuffer") {
+                return new Blob([cloneBuffer(responseBody)]);
+              }
+              if (responseBodyType === "formData") {
+                throw new Error("could not read FormData body as blob");
+              }
+              return new Blob([String(responseBody)]);
+            });
+          });
+          var arrayBuffer = function arrayBuffer() {
+            return _call$1(readBody, function (_ref4) {
+              var responseBody = _ref4.responseBody,
+                  responseBodyType = _ref4.responseBodyType;
+              return responseBodyType === "arrayBuffer" ? cloneBuffer(responseBody) : _call$1(blob, blobToArrayBuffer);
+            });
+          };
+          var formData = _async$4(function () {
+            if (!hasFormData) {
+              throw new Error("formData not supported");
+            }
+            return _call$1(text, textToFormData);
+          });
+          return {
+            url: responseUrl,
+            status: responseStatus,
+            statusText: responseStatusText,
+            headers: responseHeaders,
+            text: text,
+            json: json,
+            blob: blob,
+            arrayBuffer: arrayBuffer,
+            formData: formData
+          };
+        });
+      });
+      var canUseBlob = function canUseBlob() {
+        if (typeof window.FileReader !== "function") return false;
+        if (typeof window.Blob !== "function") return false;
+        try {
+          // eslint-disable-next-line no-new
+          new Blob();
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      var hasBlob = canUseBlob();
+      var hasFormData = typeof window.FormData === "function";
+      var hasArrayBuffer = typeof window.ArrayBuffer === "function";
+      var hasSearchParams = typeof window.URLSearchParams === "function";
+      var createRequestError = function createRequestError(error, _ref5) {
+        var url = _ref5.url;
+        return new Error("error during xhr request on ".concat(url, ".\n--- error stack ---\n").concat(error.stack));
+      };
+      var createPromiseAndHooks = function createPromiseAndHooks() {
+        var resolve;
+        var reject;
+        var promise = new Promise(function (res, rej) {
+          resolve = function resolve(value) {
+            promise.settled = true;
+            res(value);
+          };
+          reject = function reject(value) {
+            promise.settled = true;
+            rej(value);
+          };
+        });
+        promise.resolve = resolve;
+        promise.reject = reject;
+        return promise;
+      }; // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch
+      var computeWithCredentials = function computeWithCredentials(_ref6) {
+        var credentials = _ref6.credentials,
+            url = _ref6.url;
+        if (credentials === "same-origin") {
+          return originSameAsGlobalOrigin(url);
+        }
+        return credentials === "include";
+      };
+      var originSameAsGlobalOrigin = function originSameAsGlobalOrigin(url) {
+        // if we cannot read globalOrigin from window.location.origin, let's consider it's ok
+        if ((typeof window === "undefined" ? "undefined" : _typeof(window)) !== "object") return true;
+        if (_typeof(window.location) !== "object") return true;
+        var globalOrigin = window.location.origin;
+        if (globalOrigin === "null") return true;
+        return hrefToOrigin(url) === globalOrigin;
+      };
+      var detectBodyType = function detectBodyType(body) {
+        if (!body) {
+          return "";
+        }
+        if (typeof body === "string") {
+          return "text";
+        }
+        if (hasBlob && Blob.prototype.isPrototypeOf(body)) {
+          return "blob";
+        }
+        if (hasFormData && FormData.prototype.isPrototypeOf(body)) {
+          return "formData";
+        }
+        if (hasArrayBuffer) {
+          if (hasBlob && isDataView(body)) {
+            return "dataView";
+          }
+          if (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body)) {
+            return "arrayBuffer";
+          }
+        }
+        if (hasSearchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          return "searchParams";
+        }
+        return "";
+      }; // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/getAllResponseHeaders#Example
+      var getHeadersFromXHR = function getHeadersFromXHR(xhr) {
+        var headerMap = {};
+        var headersString = xhr.getAllResponseHeaders();
+        if (headersString === "") return headerMap;
+        var lines = headersString.trim().split(/[\r\n]+/);
+        lines.forEach(function (line) {
+          var parts = line.split(": ");
+          var name = parts.shift();
+          var value = parts.join(": ");
+          headerMap[name.toLowerCase()] = value;
+        });
+        return headerMap;
+      };
+      var hrefToOrigin = function hrefToOrigin(href) {
+        var scheme = hrefToScheme(href);
+        if (scheme === "file") {
+          return "file://";
+        }
+        if (scheme === "http" || scheme === "https") {
+          var secondProtocolSlashIndex = scheme.length + "://".length;
+          var pathnameSlashIndex = href.indexOf("/", secondProtocolSlashIndex);
+          if (pathnameSlashIndex === -1) return href;
+          return href.slice(0, pathnameSlashIndex);
+        }
+        return href.slice(0, scheme.length + 1);
+      };
+      var hrefToScheme = function hrefToScheme(href) {
+        var colonIndex = href.indexOf(":");
+        if (colonIndex === -1) return "";
+        return href.slice(0, colonIndex);
+      };
+      var isDataView = function isDataView(obj) {
+        return obj && DataView.prototype.isPrototypeOf(obj);
+      };
+      var isArrayBufferView = ArrayBuffer.isView || function () {
+        var viewClasses = ["[object Int8Array]", "[object Uint8Array]", "[object Uint8ClampedArray]", "[object Int16Array]", "[object Uint16Array]", "[object Int32Array]", "[object Uint32Array]", "[object Float32Array]", "[object Float64Array]"];
+        return function (value) {
+          return value && viewClasses.includes(Object.prototype.toString.call(value));
+        };
+      }();
+      var textToFormData = function textToFormData(text) {
+        var form = new FormData();
+        text.trim().split("&").forEach(function (bytes) {
+          if (bytes) {
+            var split = bytes.split("=");
+            var name = split.shift().replace(/\+/g, " ");
+            var value = split.join("=").replace(/\+/g, " ");
+            form.append(decodeURIComponent(name), decodeURIComponent(value));
+          }
+        });
+        return form;
+      };
+      var blobToArrayBuffer = _async$4(function (blob) {
+        var reader = new FileReader();
+        var promise = fileReaderReady(reader);
+        reader.readAsArrayBuffer(blob);
+        return promise;
+      });
+      var blobToText = function blobToText(blob) {
+        var reader = new FileReader();
+        var promise = fileReaderReady(reader);
+        reader.readAsText(blob);
+        return promise;
+      };
+      var arrayBufferToText = function arrayBufferToText(arrayBuffer) {
+        var view = new Uint8Array(arrayBuffer);
+        var chars = new Array(view.length);
+        var i = 0;
+        while (i < view.length) {
+          chars[i] = String.fromCharCode(view[i]);
+          i++;
+        }
+        return chars.join("");
+      };
+      var fileReaderReady = function fileReaderReady(reader) {
+        return new Promise(function (resolve, reject) {
+          reader.onload = function () {
+            resolve(reader.result);
+          };
+          reader.onerror = function () {
+            reject(reader.error);
+          };
+        });
+      };
+      var cloneBuffer = function cloneBuffer(buffer) {
+        if (buffer.slice) {
+          return buffer.slice(0);
+        }
+        var view = new Uint8Array(buffer.byteLength);
+        view.set(new Uint8Array(buffer));
+        return view.buffer;
+      };
+      var _excluded = ["mode"];
+      function _await$3(value, then, direct) {
+        if (direct) {
+          return then ? then(value) : value;
+        }
+        if (!value || !value.then) {
+          value = Promise.resolve(value);
+        }
+        return then ? value.then(then) : value;
+      }
+      var fetchNative = _async$3(function (url) {
+        var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var _ref$mode = _ref.mode,
+            mode = _ref$mode === void 0 ? "cors" : _ref$mode,
+            options = _objectWithoutProperties(_ref, _excluded);
+        return _await$3(window.fetch(url, _objectSpread2({
+          mode: mode
+        }, options)), function (response) {
+          return {
+            url: response.url,
+            status: response.status,
+            statusText: "",
+            headers: responseToHeaders(response),
+            text: function text() {
+              return response.text();
+            },
+            json: function json() {
+              return response.json();
+            },
+            blob: function blob() {
+              return response.blob();
+            },
+            arrayBuffer: function arrayBuffer() {
+              return response.arrayBuffer();
+            },
+            formData: function formData() {
+              return response.formData();
+            }
+          };
+        });
+      });
+      function _async$3(f) {
+        return function () {
+          for (var args = [], i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+          }
+          try {
+            return Promise.resolve(f.apply(this, args));
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+      }
+      var responseToHeaders = function responseToHeaders(response) {
+        var headers = {};
+        response.headers.forEach(function (value, name) {
+          headers[name] = value;
+        });
+        return headers;
+      };
+      var fetchUrl = typeof window.fetch === "function" && typeof window.AbortController === "function" ? fetchNative : fetchUsingXHR;
+      function _await$2(value, then, direct) {
+        if (direct) {
+          return then ? then(value) : value;
+        }
+        if (!value || !value.then) {
+          value = Promise.resolve(value);
+        }
+        return then ? value.then(then) : value;
+      }
+      function _async$2(f) {
+        return function () {
+          for (var args = [], i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+          }
+          try {
+            return Promise.resolve(f.apply(this, args));
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+      }
+      var fetchJson = _async$2(function (url) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        return _await$2(fetchUrl(url, options), function (response) {
+          return _await$2(response.json());
+        });
+      });
+      var firstMatch = function firstMatch(regexp, string) {
+        var match = string.match(regexp);
+        return match && match.length > 0 ? match[1] || undefined : undefined;
+      };
+      var secondMatch = function secondMatch(regexp, string) {
+        var match = string.match(regexp);
+        return match && match.length > 1 ? match[2] || undefined : undefined;
+      };
+      var userAgentToVersion = function userAgentToVersion(userAgent) {
+        return firstMatch(/version\/(\d+(\.?_?\d+)+)/i, userAgent) || undefined;
+      };
+      var detectAndroid = function detectAndroid() {
+        return navigatorToBrowser$1(window.navigator);
+      };
+      var navigatorToBrowser$1 = function navigatorToBrowser(_ref) {
+        var userAgent = _ref.userAgent,
+            appVersion = _ref.appVersion;
+        if (/(android)/i.test(userAgent)) {
+          return {
+            name: "android",
+            version: firstMatch(/Android (\d+(\.?_?\d+)+)/i, appVersion)
+          };
+        }
+        return null;
+      };
+      var detectInternetExplorer = function detectInternetExplorer() {
+        return userAgentToBrowser$5(window.navigator.userAgent);
+      };
+      var userAgentToBrowser$5 = function userAgentToBrowser(userAgent) {
+        if (/msie|trident/i.test(userAgent)) {
+          return {
+            name: "ie",
+            version: firstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, userAgent)
+          };
+        }
+        return null;
+      };
+      var detectOpera = function detectOpera() {
+        return userAgentToBrowser$4(window.navigator.userAgent);
+      };
+      var userAgentToBrowser$4 = function userAgentToBrowser(userAgent) {
+        // opera below 13
+        if (/opera/i.test(userAgent)) {
+          return {
+            name: "opera",
+            version: userAgentToVersion(userAgent) || firstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, userAgent)
+          };
+        } // opera above 13
+        if (/opr\/|opios/i.test(userAgent)) {
+          return {
+            name: "opera",
+            version: firstMatch(/(?:opr|opios)[\s/](\S+)/i, userAgent) || userAgentToVersion(userAgent)
+          };
+        }
+        return null;
+      };
+      var detectEdge = function detectEdge() {
+        return userAgentToBrowser$3(window.navigator.userAgent);
+      };
+      var userAgentToBrowser$3 = function userAgentToBrowser(userAgent) {
+        if (/edg([ea]|ios)/i.test(userAgent)) {
+          return {
+            name: "edge",
+            version: secondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, userAgent)
+          };
+        }
+        return null;
+      };
+      var detectFirefox = function detectFirefox() {
+        return userAgentToBrowser$2(window.navigator.userAgent);
+      };
+      var userAgentToBrowser$2 = function userAgentToBrowser(userAgent) {
+        if (/firefox|iceweasel|fxios/i.test(userAgent)) {
+          return {
+            name: "firefox",
+            version: firstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, userAgent)
+          };
+        }
+        return null;
+      };
+      var detectChrome = function detectChrome() {
+        return userAgentToBrowser$1(window.navigator.userAgent);
+      };
+      var userAgentToBrowser$1 = function userAgentToBrowser(userAgent) {
+        if (/chromium/i.test(userAgent)) {
+          return {
+            name: "chrome",
+            version: firstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, userAgent) || userAgentToVersion(userAgent)
+          };
+        }
+        if (/chrome|crios|crmo/i.test(userAgent)) {
+          return {
+            name: "chrome",
+            version: firstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, userAgent)
+          };
+        }
+        return null;
+      };
+      var detectSafari = function detectSafari() {
+        return userAgentToBrowser(window.navigator.userAgent);
+      };
+      var userAgentToBrowser = function userAgentToBrowser(userAgent) {
+        if (/safari|applewebkit/i.test(userAgent)) {
+          return {
+            name: "safari",
+            version: userAgentToVersion(userAgent)
+          };
+        }
+        return null;
+      };
+      var detectElectron = function detectElectron() {
+        return null;
+      }; // TODO
+      var detectIOS = function detectIOS() {
+        return navigatorToBrowser(window.navigator);
+      };
+      var navigatorToBrowser = function navigatorToBrowser(_ref) {
+        var userAgent = _ref.userAgent,
+            appVersion = _ref.appVersion;
+        if (/iPhone;/.test(userAgent)) {
+          return {
+            name: "ios",
+            version: firstMatch(/OS (\d+(\.?_?\d+)+)/i, appVersion)
+          };
+        }
+        if (/iPad;/.test(userAgent)) {
+          return {
+            name: "ios",
+            version: firstMatch(/OS (\d+(\.?_?\d+)+)/i, appVersion)
+          };
+        }
+        return null;
+      };
+      // https://github.com/Ahmdrza/detect-browser/blob/26254f85cf92795655a983bfd759d85f3de850c6/detect-browser.js#L1
+      var detectorCompose = function detectorCompose(detectors) {
+        return function () {
+          var i = 0;
+          while (i < detectors.length) {
+            var _detector = detectors[i];
+            i++;
+            var result = _detector();
+            if (result) {
+              return result;
+            }
+          }
+          return null;
+        };
+      };
+      var detector = detectorCompose([detectOpera, detectInternetExplorer, detectEdge, detectFirefox, detectChrome, detectSafari, detectElectron, detectIOS, detectAndroid]);
+      var detectBrowser = function detectBrowser() {
+        var _ref = detector() || {},
+            _ref$name = _ref.name,
+            name = _ref$name === void 0 ? "other" : _ref$name,
+            _ref$version = _ref.version,
+            version = _ref$version === void 0 ? "unknown" : _ref$version;
+        return {
+          name: normalizeName(name),
+          version: normalizeVersion(version)
+        };
+      };
+      var normalizeName = function normalizeName(name) {
+        return name.toLowerCase();
+      };
+      var normalizeVersion = function normalizeVersion(version) {
+        if (version.indexOf(".") > -1) {
+          var parts = version.split("."); // remove extraneous .
+          return parts.slice(0, 3).join(".");
+        }
+        if (version.indexOf("_") > -1) {
+          var _parts = version.split("_"); // remove extraneous _
+          return _parts.slice(0, 3).join("_");
+        }
+        return version;
+      };
+      function _await$1(value, then, direct) {
+        if (direct) {
+          return then ? then(value) : value;
+        }
+        if (!value || !value.then) {
+          value = Promise.resolve(value);
+        }
+        return then ? value.then(then) : value;
+      }
+      function _async$1(f) {
+        return function () {
+          for (var args = [], i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+          }
+          try {
+            return Promise.resolve(f.apply(this, args));
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+      }
+      function _call(body, then, direct) {
+        if (direct) {
+          return then ? then(body()) : body();
+        }
+        try {
+          var result = Promise.resolve(body());
+          return then ? result.then(then) : result;
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+      function _invoke(body, then) {
+        var result = body();
+        if (result && result.then) {
+          return result.then(then);
+        }
+        return then(result);
+      }
+      function _catch(body, recover) {
+        try {
+          var result = body();
+        } catch (e) {
+          return recover(e);
+        }
+        if (result && result.then) {
+          return result.then(void 0, recover);
+        }
+        return result;
+      }
+      var scanBrowserRuntimeFeatures = _async$1(function () {
+        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+            _ref$coverageHandledF = _ref.coverageHandledFromOutside,
+            coverageHandledFromOutside = _ref$coverageHandledF === void 0 ? false : _ref$coverageHandledF,
+            _ref$failFastOnFeatur = _ref.failFastOnFeatureDetection,
+            failFastOnFeatureDetection = _ref$failFastOnFeatur === void 0 ? false : _ref$failFastOnFeatur;
+        return _await$1(fetchJson("/.jsenv/__compile_server_meta__.json"), function (_ref2) {
+          var outDirectoryRelativeUrl = _ref2.outDirectoryRelativeUrl,
+              inlineImportMapIntoHTML = _ref2.inlineImportMapIntoHTML,
+              customCompilerPatterns = _ref2.customCompilerPatterns,
+              compileServerGroupMap = _ref2.compileServerGroupMap;
+          var browser = detectBrowser();
+          var compileId = computeCompileIdFromGroupId({
+            groupId: resolveGroup(browser, compileServerGroupMap),
+            groupMap: compileServerGroupMap
+          });
+          var groupInfo = compileServerGroupMap[compileId];
+          var featuresReport = {
+            importmap: undefined,
+            dynamicImport: undefined,
+            topLevelAwait: undefined,
+            jsonImportAssertions: undefined,
+            cssImportAssertions: undefined,
+            newStylesheet: undefined
+          };
+          return _await$1(detectSupportedFeatures({
+            featuresReport: featuresReport,
+            failFastOnFeatureDetection: failFastOnFeatureDetection,
+            inlineImportMapIntoHTML: inlineImportMapIntoHTML
+          }), function () {
+            return _await$1(pluginRequiredNamesFromGroupInfo(groupInfo, {
+              featuresReport: featuresReport,
+              coverageHandledFromOutside: coverageHandledFromOutside
+            }), function (pluginRequiredNameArray) {
+              var canAvoidCompilation = customCompilerPatterns.length === 0 && pluginRequiredNameArray.length === 0 && featuresReport.importmap && featuresReport.dynamicImport && featuresReport.topLevelAwait;
+              return {
+                canAvoidCompilation: canAvoidCompilation,
+                featuresReport: featuresReport,
+                customCompilerPatterns: customCompilerPatterns,
+                pluginRequiredNameArray: pluginRequiredNameArray,
+                inlineImportMapIntoHTML: inlineImportMapIntoHTML,
+                outDirectoryRelativeUrl: outDirectoryRelativeUrl,
+                compileId: compileId,
+                browser: browser
+              };
+            });
+          });
+        });
+      });
+      var pluginRequiredNamesFromGroupInfo = _async$1(function (groupInfo, _ref3) {
+        var featuresReport = _ref3.featuresReport,
+            coverageHandledFromOutside = _ref3.coverageHandledFromOutside;
+        var pluginRequiredNameArray = groupInfo.pluginRequiredNameArray;
+        var requiredPluginNames = pluginRequiredNameArray.slice();
+        var markPluginAsSupported = function markPluginAsSupported(name) {
+          var index = requiredPluginNames.indexOf(name);
+          if (index > -1) {
+            requiredPluginNames.splice(index, 1);
+          }
+        }; // When instrumentation CAN be handed by playwright
+        // https://playwright.dev/docs/api/class-chromiumcoverage#chromiumcoveragestartjscoverageoptions
+        // coverageHandledFromOutside is true and "transform-instrument" becomes non mandatory
+        if (coverageHandledFromOutside) {
+          markPluginAsSupported("transform-instrument");
+        }
+        return _invoke(function () {
+          if (pluginRequiredNameArray.includes("transform-import-assertions")) {
+            return _call(supportsJsonImportAssertions, function (jsonImportAssertions) {
+              featuresReport.jsonImportAssertions = jsonImportAssertions;
+              return _call(supportsCssImportAssertions, function (cssImportAssertions) {
+                featuresReport.cssImportAssertions = cssImportAssertions;
+                if (jsonImportAssertions && cssImportAssertions) {
+                  markPluginAsSupported("transform-import-assertions");
+                }
+              });
+            });
+          }
+        }, function () {
+          if (pluginRequiredNameArray.includes("new-stylesheet-as-jsenv-import")) {
+            var newStylesheet = supportsNewStylesheet();
+            featuresReport.newStylesheet = newStylesheet;
+            markPluginAsSupported("new-stylesheet-as-jsenv-import");
+          }
+          return requiredPluginNames;
+        });
+      });
+      var detectSupportedFeatures = _async$1(function (_ref4) {
+        var featuresReport = _ref4.featuresReport,
+            failFastOnFeatureDetection = _ref4.failFastOnFeatureDetection,
+            inlineImportMapIntoHTML = _ref4.inlineImportMapIntoHTML;
+        // start testing importmap support first and not in paralell
+        // so that there is not module script loaded beore importmap is injected
+        // it would log an error in chrome console and return undefined
+        return _await$1(supportsImportmap({
+          // chrome supports inline but not remote importmap
+          // https://github.com/WICG/import-maps/issues/235
+          // at this stage we won't know if the html file will use
+          // an importmap or not and if that importmap is inline or specified with an src
+          // so we should test if browser support local and remote importmap.
+          // But there exploring server can inline importmap by transforming html
+          // and in that case we can test only the local importmap support
+          // so we test importmap support and the remote one
+          remote: !inlineImportMapIntoHTML
+        }), function (importmap) {
+          featuresReport.importmap = importmap;
+          if (!importmap && failFastOnFeatureDetection) {
+            return;
+          }
+          return _call(supportsDynamicImport, function (dynamicImport) {
+            featuresReport.dynamicImport = dynamicImport;
+            if (!dynamicImport && failFastOnFeatureDetection) {
+              return;
+            }
+            return _call(supportsTopLevelAwait, function (topLevelAwait) {
+              featuresReport.topLevelAwait = topLevelAwait;
+            });
+          });
+        });
+      });
+      var supportsImportmap = _async$1(function () {
+        var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+            _ref5$remote = _ref5.remote,
+            remote = _ref5$remote === void 0 ? true : _ref5$remote;
+        var specifier = asBase64Url("export default false");
+        var importMap = {
+          imports: _defineProperty({}, specifier, asBase64Url("export default true"))
+        };
+        var importmapScript = document.createElement("script");
+        var importmapString = JSON.stringify(importMap, null, "  ");
+        importmapScript.type = "importmap";
+        if (remote) {
+          importmapScript.src = "data:application/json;base64,".concat(window.btoa(importmapString));
+        } else {
+          importmapScript.textContent = importmapString;
+        }
+        document.body.appendChild(importmapScript);
+        return _catch(function () {
+          return _await$1(executeWithScriptModuleInjection("import supported from \"".concat(specifier, "\"; window.__jsenv_runtime_test_importmap__ = supported")), function () {
+            document.body.removeChild(importmapScript);
+            return window.__jsenv_runtime_test_importmap__;
+          });
+        }, function () {
+          document.body.removeChild(importmapScript);
+          return false;
+        });
+      });
+      var supportsDynamicImport = _async$1(function () {
+        var moduleSource = asBase64Url("export default 42");
+        return _catch(function () {
+          return _await$1(executeWithScriptModuleInjection("window.__jsenv_runtime_test_dynamic_import__ = import(".concat(JSON.stringify(moduleSource), ")")), function () {
+            return _await$1(window.__jsenv_runtime_test_dynamic_import__, function (namespace) {
+              return namespace.default === 42;
+            });
+          });
+        }, function () {
+          return false;
+        });
+      });
+      var supportsNewStylesheet = function supportsNewStylesheet() {
+        try {
+          // eslint-disable-next-line no-new
+          new CSSStyleSheet();
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      var supportsTopLevelAwait = function supportsTopLevelAwait() {
+        return _await$1(_catch(function () {
+          return _await$1(executeWithScriptModuleInjection("window.__jsenv_runtime_test_top_level_await__ = await Promise.resolve(42)"), function () {
+            return window.__jsenv_runtime_test_top_level_await__ === 42;
+          });
+        }, function () {
+          return false;
+        }));
+      }; // to execute in a browser devtools
+      // const featuresReport = {}
+      // await detectSupportedFeatures({ featuresReport, inlineImportMapIntoHTML: true })
+      // console.log(featuresReport)
+      var supportsJsonImportAssertions = _async$1(function () {
+        var jsonBase64Url = asBase64Url("42", "application/json");
+        var moduleSource = asBase64Url("import data from \"".concat(jsonBase64Url, "\" assert { type: \"json\" }\nexport default data"));
+        return _catch(function () {
+          return _await$1(executeWithScriptModuleInjection("window.__jsenv_runtime_test_json_import_assertion__ = import(".concat(JSON.stringify(moduleSource), ")")), function () {
+            return _await$1(window.__jsenv_runtime_test_json_import_assertion__, function (namespace) {
+              return namespace.default === 42;
+            });
+          });
+        }, function () {
+          return false;
+        });
+      });
+      var supportsCssImportAssertions = _async$1(function () {
+        var cssBase64Url = asBase64Url("p { color: red; }", "text/css");
+        var moduleSource = asBase64Url("import css from \"".concat(cssBase64Url, "\" assert { type: \"css\" }\nexport default css"));
+        return _catch(function () {
+          return _await$1(executeWithScriptModuleInjection("window.__jsenv_runtime_test_css_import_assertion__ = import(".concat(JSON.stringify(moduleSource), ")")), function () {
+            return _await$1(window.__jsenv_runtime_test_css_import_assertion__, function (namespace) {
+              return namespace.default instanceof CSSStyleSheet;
+            });
+          });
+        }, function () {
+          return false;
+        });
+      });
+      var executeWithScriptModuleInjection = function executeWithScriptModuleInjection(code) {
+        var scriptModule = document.createElement("script");
+        scriptModule.type = "module";
+        var loadPromise = new Promise(function (resolve, reject) {
+          scriptModule.onload = function () {
+            document.body.removeChild(scriptModule);
+            resolve();
+          };
+          scriptModule.onerror = function () {
+            document.body.removeChild(scriptModule);
+            reject();
+          };
+          document.body.appendChild(scriptModule);
+        });
+        scriptModule.src = asBase64Url(code);
+        return loadPromise;
+      };
+      var asBase64Url = function asBase64Url(text) {
+        var mimeType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "application/javascript";
+        return "data:".concat(mimeType, ";base64,").concat(window.btoa(text));
+      }; // const cssImportAssertions = await supportsCssImportAssertions()
+      // console.log({ cssImportAssertions })
+      function _await(value, then, direct) {
+        if (direct) {
+          return then ? then(value) : value;
+        }
+        if (!value || !value.then) {
+          value = Promise.resolve(value);
+        }
+        return then ? value.then(then) : value;
+      }
+      var redirect = _async(function () {
+        var redirectTarget = new URLSearchParams(window.location.search).get("redirect");
+        return _await(scanBrowserRuntimeFeatures({
+          failFastOnFeatureDetection: true
+        }), function (browserRuntimeFeaturesReport) {
+          var href = "".concat(getDirectoryUrl(browserRuntimeFeaturesReport)).concat(redirectTarget); // It's IMPORTANT to use location.replace and NOT location.href = url
+          // otherwise it would break the back button
+          window.location.replace(href);
+        });
+      });
+      function _async(f) {
+        return function () {
+          for (var args = [], i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+          }
+          try {
+            return Promise.resolve(f.apply(this, args));
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+      }
+      var getDirectoryUrl = function getDirectoryUrl(_ref) {
+        var canAvoidCompilation = _ref.canAvoidCompilation,
+            outDirectoryRelativeUrl = _ref.outDirectoryRelativeUrl,
+            compileId = _ref.compileId;
+        if (canAvoidCompilation) {
+          return "/";
+        }
+        return "/".concat(outDirectoryRelativeUrl).concat(compileId, "/");
+      };
+      redirect();
+    })
+  };
+}));
+//# sourceMappingURL=redirector.html__inline__15-33acb0b9.js.map</script>
+</body></html>