minimal-piral 0.15.0-beta.4696 → 0.15.0-beta.4708

package/app/{index.21c15a.js → index.53636e.js}

@@ -1450,437 +1450,1294 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "requireModule": () => (/* binding */ requireModule),
 /* harmony export */   "unregisterModules": () => (/* binding */ unregisterModules)
 /* harmony export */ });
-/* harmony import */ var systemjs_dist_system_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! systemjs/dist/system.js */ "../../../node_modules/systemjs/dist/system.js");
-/* harmony import */ var systemjs_dist_system_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(systemjs_dist_system_js__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var systemjs_dist_extras_named_register_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! systemjs/dist/extras/named-register.js */ "../../../node_modules/systemjs/dist/extras/named-register.js");
-/* harmony import */ var systemjs_dist_extras_named_register_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(systemjs_dist_extras_named_register_js__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _version__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./version */ "../../framework/piral-base/esm/utils/version.js");
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-var systemResolve = System.constructor.prototype.resolve;
-var systemRegister = System.constructor.prototype.register;
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
-function getLoadedVersions(prefix) {
-  return _toConsumableArray(System.entries()).filter(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 1),
-        name = _ref2[0];
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-    return name.startsWith(prefix);
-  }).map(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 1),
-        name = _ref4[0];
+// ../../../node_modules/systemjs/dist/system.js
+(function () {
+  function errMsg(errCode, msg) {
+    return (msg || "") + " (SystemJS Error#" + errCode + " https://git.io/JvFET#" + errCode + ")";
+  }
 
-    return name.substring(prefix.length);
-  });
-}
+  var hasSymbol = typeof Symbol !== "undefined";
+  var hasSelf = typeof self !== "undefined";
+  var hasDocument = typeof document !== "undefined";
+  var envGlobal = hasSelf ? self : __webpack_require__.g;
+  var baseUrl;
 
-function findMatchingPackage(id) {
-  var sep = id.indexOf('@', 1);
+  if (hasDocument) {
+    var baseEl = document.querySelector("base[href]");
+    if (baseEl) baseUrl = baseEl.href;
+  }
 
-  if (sep > 1) {
-    var available = Object.keys(System.registerRegistry);
-    var name = id.substring(0, sep + 1);
-    var versionSpec = id.substring(sep + 1);
+  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);
+  }
 
-    if ((0,_version__WEBPACK_IMPORTED_MODULE_2__.validate)(versionSpec)) {
-      var loadedVersions = getLoadedVersions(name);
-      var allVersions = available.filter(function (m) {
-        return m.startsWith(name);
-      }).map(function (m) {
-        return m.substring(name.length);
-      }); // Moves the loaded versions to the top
+  var backslashRegEx = /\\/g;
 
-      var availableVersions = [].concat(_toConsumableArray(loadedVersions), _toConsumableArray(allVersions.filter(function (m) {
-        return !loadedVersions.includes(m);
-      })));
+  function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
+    if (relUrl.indexOf("\\") !== -1) relUrl = relUrl.replace(backslashRegEx, "/");
 
-      var _iterator = _createForOfIteratorHelper(availableVersions),
-          _step;
+    if (relUrl[0] === "/" && relUrl[1] === "/") {
+      return parentUrl.slice(0, parentUrl.indexOf(":") + 1) + relUrl;
+    } 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);
+      var pathname;
 
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var availableVersion = _step.value;
+      if (parentUrl[parentProtocol.length + 1] === "/") {
+        if (parentProtocol !== "file:") {
+          pathname = parentUrl.slice(parentProtocol.length + 2);
+          pathname = pathname.slice(pathname.indexOf("/") + 1);
+        } else {
+          pathname = parentUrl.slice(8);
+        }
+      } else {
+        pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === "/"));
+      }
 
-          if ((0,_version__WEBPACK_IMPORTED_MODULE_2__.validate)(availableVersion) && (0,_version__WEBPACK_IMPORTED_MODULE_2__.satisfies)(availableVersion, versionSpec)) {
-            return name + availableVersion;
+      if (relUrl[0] === "/") return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+      var segmented = pathname.slice(0, pathname.lastIndexOf("/") + 1) + relUrl;
+      var output = [];
+      var segmentIndex = -1;
+
+      for (var i = 0; i < segmented.length; i++) {
+        if (segmentIndex !== -1) {
+          if (segmented[i] === "/") {
+            output.push(segmented.slice(segmentIndex, i + 1));
+            segmentIndex = -1;
           }
+        } else if (segmented[i] === ".") {
+          if (segmented[i + 1] === "." && (segmented[i + 2] === "/" || i + 2 === segmented.length)) {
+            output.pop();
+            i += 2;
+          } else if (segmented[i + 1] === "/" || i + 1 === segmented.length) {
+            i += 1;
+          } else {
+            segmentIndex = i;
+          }
+        } else {
+          segmentIndex = i;
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
       }
+
+      if (segmentIndex !== -1) output.push(segmented.slice(segmentIndex));
+      return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join("");
     }
   }
 
-  return undefined;
-}
-
-function tryResolve(name, parent) {
-  try {
-    return System.resolve(name, parent);
-  } catch (_a) {
-    // just ignore - will be handled differently later.
-    return undefined;
+  function resolveUrl(relUrl, parentUrl) {
+    return resolveIfNotPlainOrUrl(relUrl, parentUrl) || (relUrl.indexOf(":") !== -1 ? relUrl : resolveIfNotPlainOrUrl("./" + relUrl, parentUrl));
   }
-}
 
-function isPrimitiveExport(content) {
-  var type = _typeof(content);
+  function resolveAndComposePackages(packages, outPackages, baseUrl2, parentMap, parentUrl) {
+    for (var p in packages) {
+      var resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl2) || p;
+      var rhs = packages[p];
+      if (typeof rhs !== "string") continue;
+      var mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(rhs, baseUrl2) || rhs, parentUrl);
 
-  return type === 'number' || type === 'boolean' || type === 'symbol' || type === 'string' || type === 'bigint' || Array.isArray(content);
-}
+      if (!mapped) {
+        targetWarning("W1", p, rhs, "bare specifier did not resolve");
+      } else outPackages[resolvedLhs] = mapped;
+    }
+  }
 
-System.constructor.prototype.resolve = function (id, parentUrl) {
-  try {
-    return systemResolve.call(this, id, parentUrl);
-  } catch (ex) {
-    var result = findMatchingPackage(id);
+  function resolveAndComposeImportMap(json, baseUrl2, outMap) {
+    if (json.imports) resolveAndComposePackages(json.imports, outMap.imports, baseUrl2, outMap, null);
+    var u;
 
-    if (!result) {
-      throw ex;
+    for (u in json.scopes || {}) {
+      var resolvedScope = resolveUrl(u, baseUrl2);
+      resolveAndComposePackages(json.scopes[u], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl2, outMap, resolvedScope);
     }
 
-    return result;
+    for (u in json.depcache || {}) {
+      outMap.depcache[resolveUrl(u, baseUrl2)] = json.depcache[u];
+    }
+
+    for (u in json.integrity || {}) {
+      outMap.integrity[resolveUrl(u, baseUrl2)] = json.integrity[u];
+    }
   }
-};
 
-System.constructor.prototype.register = function () {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
+  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);
   }
 
-  var getContent = args.pop();
-  args.push(function (_export, ctx) {
-    var exp = function exp() {
-      if (arguments.length === 1) {
-        var content = arguments.length <= 0 ? undefined : arguments[0];
+  function applyPackages(id, packages) {
+    var pkgName = getMatch(id, packages);
 
-        if (content instanceof Promise) {
-          return content.then(exp);
-        } else if (typeof content === 'function') {
-          _export('__esModule', true);
+    if (pkgName) {
+      var pkg = packages[pkgName];
+      if (pkg === null) return;
 
-          Object.keys(content).forEach(function (prop) {
-            _export(prop, content[prop]);
-          });
+      if (id.length > pkgName.length && pkg[pkg.length - 1] !== "/") {
+        targetWarning("W2", pkgName, pkg, "should have a trailing '/'");
+      } else return pkg + id.slice(pkgName.length);
+    }
+  }
 
-          _export('default', content);
-        } else if (isPrimitiveExport(content)) {
-          _export('__esModule', true);
+  function targetWarning(code, match, target, msg) {
+    console.warn(errMsg(code, "Package target " + msg + ", resolving target '" + target + "' for " + match));
+  }
 
-          _export('default', content);
-        } else if (content) {
-          _export(content);
+  function resolveImportMap(importMap2, resolvedOrPlain, parentUrl) {
+    var scopes = importMap2.scopes;
+    var scopeUrl = parentUrl && getMatch(parentUrl, scopes);
 
-          if (_typeof(content) === 'object' && !('default' in content)) {
-            _export('default', content);
-          }
-        }
-      } else {
-        _export.apply(void 0, arguments);
-      }
-    };
+    while (scopeUrl) {
+      var packageResolution = applyPackages(resolvedOrPlain, scopes[scopeUrl]);
+      if (packageResolution) return packageResolution;
+      scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf("/")), scopes);
+    }
 
-    return getContent(exp, ctx);
-  });
-  return systemRegister.apply(this, args);
-};
-/**
- * Registers all static global dependencies in the system.
- * @param modules The modules to register as dependencies.
- * @returns A promise when SystemJS included all dependencies.
- */
+    return applyPackages(resolvedOrPlain, importMap2.imports) || resolvedOrPlain.indexOf(":") !== -1 && resolvedOrPlain;
+  }
 
+  var toStringTag$1 = hasSymbol && Symbol.toStringTag;
+  var REGISTRY = hasSymbol ? Symbol() : "@";
 
-function registerDependencies(modules) {
-  var moduleNames = Object.keys(modules);
-  moduleNames.forEach(function (name) {
-    return registerModule(name, function () {
-      return modules[name];
+  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 (id2) {
+      var load = getOrCreateLoad(loader, id2);
+      return load.C || topLevelLoad(loader, load);
     });
-  });
-  return Promise.all(moduleNames.map(function (name) {
-    return System["import"](name);
-  }));
-}
-/**
- * Registers a plain module in SystemJS.
- * @param name The name of the module
- * @param resolve The resolver for the module's content.
- */
+  };
 
-function registerModule(name, resolve) {
-  System.register(name, [], function (_exports) {
+  systemJSPrototype.createContext = function (parentId) {
+    var loader = this;
     return {
-      execute: function execute() {
-        var content = resolve();
-
-        if (content instanceof Promise) {
-          return content.then(_exports);
-        } else {
-          _exports(content);
-        }
+      url: parentId,
+      resolve: function resolve(id, parentUrl) {
+        return Promise.resolve(loader.resolve(id, parentUrl || parentId));
       }
     };
-  });
-}
-/**
- * Unregisters all modules coming from the given base URL.
- * @param baseUrl The base URL used to identify the modules to delete to.
- * @param dependencies The shared dependencies from the pilet. These will be left alive.
- */
-
-function unregisterModules(baseUrl, dependencies) {
-  _toConsumableArray(System.entries()).map(function (_ref5) {
-    var _ref6 = _slicedToArray(_ref5, 1),
-        name = _ref6[0];
-
-    return name;
-  }).filter(function (name) {
-    return name.startsWith(baseUrl) && !dependencies.includes(name);
-  }).forEach(function (name) {
-    return System["delete"](name);
-  });
-}
-/**
- * Requires a module from SystemJS
- * @param name The name of the module to obtain
- * @returns The module's content, if any, otherwise throws an error.
- */
+  };
 
-function requireModule(name, parent) {
-  var moduleId = tryResolve(name, parent);
-  var dependency = moduleId && System.get(moduleId);
+  systemJSPrototype.onload = function () {};
 
-  if (!dependency) {
-    var error = new Error("Cannot find module '".concat(name, "'"));
-    error.code = 'MODULE_NOT_FOUND';
-    throw error;
+  function loadToId(load) {
+    return load.id;
   }
 
-  return dependency;
-}
-
-/***/ }),
-
-/***/ "../../framework/piral-base/esm/utils/version.js":
-/*!*******************************************************!*\
-  !*** ../../framework/piral-base/esm/utils/version.js ***!
-  \*******************************************************/
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+  function triggerOnload(loader, load, err, isErrSource) {
+    loader.onload(err, load.id, load.d && load.d.map(loadToId), !!isErrSource);
+    if (err) throw err;
+  }
 
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "satisfies": () => (/* binding */ satisfies),
-/* harmony export */   "validate": () => (/* binding */ validate)
-/* harmony export */ });
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+  var lastRegister;
 
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+  systemJSPrototype.register = function (deps, declare) {
+    lastRegister = [deps, declare];
+  };
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+  systemJSPrototype.getRegister = function () {
+    var _lastRegister = lastRegister;
+    lastRegister = void 0;
+    return _lastRegister;
+  };
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+  function getOrCreateLoad(loader, id, firstParentUrl) {
+    var load = loader[REGISTRY][id];
+    if (load) return load;
+    var importerSetters = [];
+    var ns = Object.create(null);
+    if (toStringTag$1) Object.defineProperty(ns, toStringTag$1, {
+      value: "Module"
+    });
+    var instantiatePromise = Promise.resolve().then(function () {
+      return loader.instantiate(id, firstParentUrl);
+    }).then(function (registration) {
+      if (!registration) throw Error(errMsg(2, "Module " + id + " did not instantiate"));
 
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+      function _export(name, value) {
+        load.h = true;
+        var changed = false;
 
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+        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];
 
-var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
-var acceptsAll = ['*', 'x', '>=0'];
-var operatorResMap = {
-  '>': [1],
-  '>=': [0, 1],
-  '=': [0],
-  '<=': [-1, 0],
-  '<': [-1]
-};
+            if (!(p in ns) || ns[p] !== value) {
+              ns[p] = value;
+              changed = true;
+            }
+          }
 
-function indexOrEnd(str, q) {
-  return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
-}
+          if (name && name.__esModule) {
+            ns.__esModule = name.__esModule;
+          }
+        }
 
-function splitVersion(v) {
-  var c = v.replace(/^v/, '').replace(/\+.*$/, '');
-  var patchIndex = indexOrEnd(c, '-');
-  var arr = c.substring(0, patchIndex).split('.');
-  arr.push(c.substring(patchIndex + 1));
-  return arr;
-}
+        if (changed) for (var i = 0; i < importerSetters.length; i++) {
+          var setter = importerSetters[i];
+          if (setter) setter(ns);
+        }
+        return value;
+      }
 
-function parseSegment(v) {
-  var n = parseInt(v, 10);
-  return isNaN(n) ? v : n;
-}
+      var declared = registration[1](_export, registration[1].length === 2 ? {
+        "import": function _import(importId) {
+          return loader["import"](importId, id);
+        },
+        meta: loader.createContext(id)
+      } : void 0);
 
-function validateAndParse(v) {
-  var match = v.match(semver);
-  match.shift();
-  return match;
-}
+      load.e = declared.execute || function () {};
 
-function compareStrings(a, b) {
-  var ap = parseSegment(a);
-  var bp = parseSegment(b);
+      return [registration[0], declared.setters || []];
+    }, function (err) {
+      load.e = null;
+      load.er = err;
+      triggerOnload(loader, load, err, true);
+      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);
+          return Promise.resolve(depLoad.I).then(function () {
+            if (setter) {
+              depLoad.i.push(setter);
+              if (depLoad.h || !depLoad.I) setter(depLoad.n);
+            }
 
-  if (ap > bp) {
-    return 1;
-  } else if (ap < bp) {
-    return -1;
-  } else {
-    return 0;
+            return depLoad;
+          });
+        });
+      })).then(function (depLoads) {
+        load.d = depLoads;
+      });
+    });
+    return load = loader[REGISTRY][id] = {
+      id: id,
+      i: importerSetters,
+      n: ns,
+      I: instantiatePromise,
+      L: linkPromise,
+      h: false,
+      d: void 0,
+      e: void 0,
+      er: void 0,
+      E: void 0,
+      C: void 0,
+      p: void 0
+    };
   }
-}
-
-function compareSegments(a, b) {
-  for (var i = 0; i < 2; i++) {
-    var r = compareStrings(a[i] || '0', b[i] || '0');
 
-    if (r !== 0) {
-      return r;
+  function instantiateAll(loader, load, parent, loaded) {
+    if (!loaded[load.id]) {
+      loaded[load.id] = true;
+      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;
+        triggerOnload(loader, load, err, false);
+        throw err;
+      });
     }
   }
 
-  return 0;
-}
+  function topLevelLoad(loader, load) {
+    return load.C = instantiateAll(loader, load, load, {}).then(function () {
+      return postOrderExec(loader, load, {});
+    }).then(function () {
+      return load.n;
+    });
+  }
 
-function compareVersions(v1, v2) {
-  var s1 = splitVersion(v1);
-  var s2 = splitVersion(v2);
-  var len = Math.max(s1.length - 1, s2.length - 1);
+  var nullContext = Object.freeze(Object.create(null));
 
-  for (var i = 0; i < len; i++) {
-    var n1 = parseInt(s1[i] || '0', 10);
-    var n2 = parseInt(s2[i] || '0', 10);
+  function postOrderExec(loader, load, seen) {
+    if (seen[load.id]) return;
+    seen[load.id] = true;
 
-    if (n1 > n2) {
-      return 1;
-    } else if (n2 > n1) {
-      return -1;
+    if (!load.e) {
+      if (load.er) throw load.er;
+      if (load.E) return load.E;
+      return;
     }
-  }
 
-  var sp1 = s1[s1.length - 1];
-  var sp2 = s2[s2.length - 1];
+    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;
+        triggerOnload(loader, load, err, false);
+        throw err;
+      }
+    });
+    if (depLoadPromises) return Promise.all(depLoadPromises).then(doExec);
+    return doExec();
 
-  if (sp1 && sp2) {
-    var p1 = sp1.split('.').map(parseSegment);
-    var p2 = sp2.split('.').map(parseSegment);
+    function doExec() {
+      try {
+        var execPromise = load.e.call(nullContext);
 
-    var _len = Math.max(p1.length, p2.length);
+        if (execPromise) {
+          execPromise = execPromise.then(function () {
+            load.C = load.n;
+            load.E = null;
+            if (true) triggerOnload(loader, load, null, true);
+          }, function (err) {
+            load.er = err;
+            load.E = null;
+            if (true) triggerOnload(loader, load, err, true);
+            throw err;
+          });
+          return load.E = execPromise;
+        }
 
-    for (var _i = 0; _i < _len; _i++) {
-      if (p1[_i] === undefined || typeof p2[_i] === 'string' && typeof p1[_i] === 'number') {
-        return -1;
-      } else if (p2[_i] === undefined || typeof p1[_i] === 'string' && typeof p2[_i] === 'number') {
-        return 1;
-      } else if (p1[_i] > p2[_i]) {
-        return 1;
-      } else if (p2[_i] > p1[_i]) {
-        return -1;
+        load.C = load.n;
+        load.L = load.I = void 0;
+      } catch (err) {
+        load.er = err;
+        throw err;
+      } finally {
+        load.e = null;
+        triggerOnload(loader, load, load.er, true);
       }
     }
-  } else if (sp1 || sp2) {
-    return sp1 ? -1 : 1;
   }
 
-  return 0;
-}
+  envGlobal.System = new SystemJS();
+  var importMapPromise = Promise.resolve();
+  var importMap = {
+    imports: {},
+    scopes: {},
+    depcache: {},
+    integrity: {}
+  };
+  var processFirst = hasDocument;
 
-function compare(v1, v2, operator) {
-  // since result of compareVersions can only be -1 or 0 or 1
-  // a simple map can be used to replace switch
-  var res = compareVersions(v1, v2);
-  return operatorResMap[operator].indexOf(res) > -1;
-}
+  systemJSPrototype.prepareImport = function (doProcessScripts) {
+    if (processFirst || doProcessScripts) {
+      processScripts();
+      processFirst = false;
+    }
 
-function validate(version) {
-  return acceptsAll.includes(version) || semver.test(version);
-}
-function satisfies(v, r) {
-  if (!acceptsAll.includes(r)) {
-    // if no range operator then "="
-    var match = r.match(/^([<>=~^]+)/);
-    var op = match ? match[1] : '='; // if gt/lt/eq then operator compare
+    return importMapPromise;
+  };
 
-    if (op !== '^' && op !== '~') {
-      return compare(v, r, op);
-    } // else range of either "~" or "^" is assumed
+  if (hasDocument) {
+    processScripts();
+    window.addEventListener("DOMContentLoaded", processScripts);
+  }
 
+  function processScripts() {
+    [].forEach.call(document.querySelectorAll("script"), function (script) {
+      if (script.sp) return;
 
-    var _validateAndParse = validateAndParse(v),
-        _validateAndParse2 = _slicedToArray(_validateAndParse, 3),
-        v1 = _validateAndParse2[0],
-        v2 = _validateAndParse2[1],
-        v3 = _validateAndParse2[2];
+      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 (e.message.indexOf("https://git.io/JvFET#3") > -1) {
+            var event = document.createEvent("Event");
+            event.initEvent("error", false, false);
+            script.dispatchEvent(event);
+          }
 
-    var _validateAndParse3 = validateAndParse(r),
-        _validateAndParse4 = _slicedToArray(_validateAndParse3, 3),
-        m1 = _validateAndParse4[0],
-        m2 = _validateAndParse4[1],
-        m3 = _validateAndParse4[2];
+          return Promise.reject(e);
+        });
+      } else if (script.type === "systemjs-importmap") {
+        script.sp = true;
+        var fetchPromise = script.src ? (System.fetch || fetch)(script.src, {
+          integrity: script.integrity,
+          passThrough: true
+        }).then(function (res) {
+          if (!res.ok) throw Error("Invalid status code: " + res.status);
+          return res.text();
+        })["catch"](function (err) {
+          err.message = errMsg("W4", "Error fetching systemjs-import map " + script.src) + "\n" + err.message;
+          console.warn(err);
 
-    if (compareStrings(v1, m1) !== 0) {
-      return false;
-    } else if (op === '^') {
-      return compareSegments([v2, v3], [m2, m3]) >= 0;
-    } else if (compareStrings(v2, m2) !== 0) {
-      return false;
-    }
+          if (typeof script.onerror === "function") {
+            script.onerror();
+          }
 
-    return compareStrings(v3, m3) >= 0;
+          return "{}";
+        }) : script.innerHTML;
+        importMapPromise = importMapPromise.then(function () {
+          return fetchPromise;
+        }).then(function (text) {
+          extendImportMap(importMap, text, script.src || baseUrl);
+        });
+      }
+    });
   }
 
-  return true;
-}
-
-/***/ }),
+  function extendImportMap(importMap2, newMapText, newMapUrl) {
+    var newMap = {};
 
-/***/ "../../framework/piral-core/esm/Piral.js":
-/*!***********************************************!*\
-  !*** ../../framework/piral-core/esm/Piral.js ***!
-  \***********************************************/
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+    try {
+      newMap = JSON.parse(newMapText);
+    } catch (err) {
+      console.warn(Error(errMsg("W5", "systemjs-importmap contains invalid JSON") + "\n\n" + newMapText + "\n"));
+    }
 
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "Piral": () => (/* binding */ Piral)
-/* harmony export */ });
-/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "../../../node_modules/react/index.js");
-/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _createInstance__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./createInstance */ "../../framework/piral-core/esm/createInstance.js");
-/* harmony import */ var _components__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./components */ "../../framework/piral-core/esm/components/components.js");
-/* harmony import */ var _components__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./components */ "../../framework/piral-core/esm/components/PiralView.js");
-/* harmony import */ var _PiralContext__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./PiralContext */ "../../framework/piral-core/esm/PiralContext.js");
-/* harmony import */ var _app_codegen__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../app.codegen */ "../../framework/piral-core/app.codegen");
+    resolveAndComposeImportMap(newMap, newMapUrl, importMap2);
+  }
+
+  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;
+    if (url.indexOf(baseOrigin + "/")) script.crossOrigin = "anonymous";
+    var integrity = importMap.integrity[url];
+    if (integrity) script.integrity = integrity;
+    script.src = url;
+    return script;
+  };
+
+  var lastAutoImportDeps, lastAutoImportTimeout;
+  var autoImportCandidates = {};
+  var systemRegister2 = systemJSPrototype.register;
+
+  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];
+
+      if (lastScript) {
+        lastAutoImportDeps = deps;
+        var loader = this;
+        lastAutoImportTimeout = setTimeout(function () {
+          autoImportCandidates[lastScript.src] = [deps, declare];
+          loader["import"](lastScript.src);
+        });
+      }
+    } else {
+      lastAutoImportDeps = void 0;
+    }
+
+    return systemRegister2.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, "Error loading " + url + (firstParentUrl ? " from " + firstParentUrl : ""))));
+        });
+        script.addEventListener("load", function () {
+          document.head.removeChild(script);
+
+          if (lastWindowErrorUrl === url) {
+            reject(lastWindowError);
+          } else {
+            var register = loader.getRegister(url);
+            if (register && register[0] === lastAutoImportDeps) clearTimeout(lastAutoImportTimeout);
+            resolve(register);
+          }
+        });
+        document.head.appendChild(script);
+      });
+    });
+  };
+
+  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 + ", loading " + url + (parent ? " from " + parent : "")));
+      var contentType = res.headers.get("content-type");
+      if (!contentType || !jsContentTypeRegEx.test(contentType)) throw Error(errMsg(4, 'Unknown Content-Type "' + contentType + '", loading ' + url + (parent ? " from " + parent : "")));
+      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 || false || baseUrl;
+    return resolveImportMap(importMap, resolveIfNotPlainOrUrl(id, parentUrl) || id, parentUrl) || throwUnresolved(id, parentUrl);
+  };
+
+  function throwUnresolved(id, parentUrl) {
+    throw Error(errMsg(8, "Unable to resolve bare specifier '" + id + (parentUrl ? "' from " + parentUrl : "'")));
+  }
+
+  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);
+  };
+
+  if (hasSelf && typeof importScripts === "function") systemJSPrototype.instantiate = function (url) {
+    var loader = this;
+    return Promise.resolve().then(function () {
+      importScripts(url);
+      return loader.getRegister(url);
+    });
+  };
+
+  (function (global2) {
+    var systemJSPrototype2 = global2.System.constructor.prototype;
+    var firstGlobalProp, secondGlobalProp, lastGlobalProp;
+
+    function getGlobalProp(useFirstGlobalProp) {
+      var cnt = 0;
+      var foundLastProp, result;
+
+      for (var p in global2) {
+        if (shouldSkipProperty(p)) continue;
+        if (cnt === 0 && p !== firstGlobalProp || cnt === 1 && p !== secondGlobalProp) return p;
+
+        if (foundLastProp) {
+          lastGlobalProp = p;
+          result = useFirstGlobalProp && result || p;
+        } else {
+          foundLastProp = p === lastGlobalProp;
+        }
+
+        cnt++;
+      }
+
+      return result;
+    }
+
+    function noteGlobalProps() {
+      firstGlobalProp = secondGlobalProp = void 0;
+
+      for (var p in global2) {
+        if (shouldSkipProperty(p)) continue;
+        if (!firstGlobalProp) firstGlobalProp = p;else if (!secondGlobalProp) secondGlobalProp = p;
+        lastGlobalProp = p;
+      }
+
+      return lastGlobalProp;
+    }
+
+    var impt = systemJSPrototype2["import"];
+
+    systemJSPrototype2["import"] = function (id, parentUrl) {
+      noteGlobalProps();
+      return impt.call(this, id, parentUrl);
+    };
+
+    var emptyInstantiation = [[], function () {
+      return {};
+    }];
+    var getRegister = systemJSPrototype2.getRegister;
+
+    systemJSPrototype2.getRegister = function () {
+      var lastRegister2 = getRegister.call(this);
+      if (lastRegister2) return lastRegister2;
+      var globalProp = getGlobalProp(this.firstGlobalProp);
+      if (!globalProp) return emptyInstantiation;
+      var globalExport;
+
+      try {
+        globalExport = global2[globalProp];
+      } catch (e) {
+        return emptyInstantiation;
+      }
+
+      return [[], function (_export) {
+        return {
+          execute: function execute() {
+            _export(globalExport);
+
+            _export({
+              "default": globalExport,
+              __useDefault: true
+            });
+          }
+        };
+      }];
+    };
+
+    var isIE11 = typeof navigator !== "undefined" && navigator.userAgent.indexOf("Trident") !== -1;
+
+    function shouldSkipProperty(p) {
+      return !global2.hasOwnProperty(p) || !isNaN(p) && p < global2.length || isIE11 && global2[p] && typeof window !== "undefined" && global2[p].parent === window;
+    }
+  })(typeof self !== "undefined" ? self : __webpack_require__.g);
+
+  (function (global2) {
+    var systemJSPrototype2 = global2.System.constructor.prototype;
+    var moduleTypesRegEx = /^[^#?]+\.(css|html|json|wasm)([?#].*)?$/;
+
+    systemJSPrototype2.shouldFetch = function (url) {
+      return moduleTypesRegEx.test(url);
+    };
+
+    var jsonContentType = /^application\/json(;|$)/;
+    var cssContentType = /^text\/css(;|$)/;
+    var wasmContentType = /^application\/wasm(;|$)/;
+    var fetch2 = systemJSPrototype2.fetch;
+
+    systemJSPrototype2.fetch = function (url, options) {
+      return fetch2(url, options).then(function (res) {
+        if (options.passThrough) return res;
+        if (!res.ok) return res;
+        var contentType = res.headers.get("content-type");
+        if (jsonContentType.test(contentType)) return res.json().then(function (json) {
+          return new Response(new Blob(['System.register([],function(e){return{execute:function(){e("default",' + JSON.stringify(json) + ")}}})"], {
+            type: "application/javascript"
+          }));
+        });
+        if (cssContentType.test(contentType)) return res.text().then(function (source) {
+          source = source.replace(/url\(\s*(?:(["'])((?:\\.|[^\n\\"'])+)\1|((?:\\.|[^\s,"'()\\])+))\s*\)/g, function (match, quotes, relUrl1, relUrl2) {
+            return "url(" + quotes + resolveUrl(relUrl1 || relUrl2, url) + quotes + ")";
+          });
+          return new Response(new Blob(["System.register([],function(e){return{execute:function(){var s=new CSSStyleSheet();s.replaceSync(" + JSON.stringify(source) + ');e("default",s)}}})'], {
+            type: "application/javascript"
+          }));
+        });
+        if (wasmContentType.test(contentType)) return (WebAssembly.compileStreaming ? WebAssembly.compileStreaming(res) : res.arrayBuffer().then(WebAssembly.compile)).then(function (module) {
+          if (!global2.System.wasmModules) global2.System.wasmModules = Object.create(null);
+          global2.System.wasmModules[url] = module;
+          var deps = [];
+          var setterSources = [];
+          if (WebAssembly.Module.imports) WebAssembly.Module.imports(module).forEach(function (impt) {
+            var key = JSON.stringify(impt.module);
+
+            if (deps.indexOf(key) === -1) {
+              deps.push(key);
+              setterSources.push("function(m){i[" + key + "]=m}");
+            }
+          });
+          return new Response(new Blob(["System.register([" + deps.join(",") + "],function(e){var i={};return{setters:[" + setterSources.join(",") + "],execute:function(){return WebAssembly.instantiate(System.wasmModules[" + JSON.stringify(url) + "],i).then(function(m){e(m.exports)})}}})"], {
+            type: "application/javascript"
+          }));
+        });
+        return res;
+      });
+    };
+  })(typeof self !== "undefined" ? self : __webpack_require__.g);
+
+  var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag;
+
+  systemJSPrototype.get = function (id) {
+    var load = this[REGISTRY][id];
+
+    if (load && load.e === null && !load.E) {
+      if (load.er) return null;
+      return load.n;
+    }
+  };
+
+  systemJSPrototype.set = function (id, module) {
+    {
+      try {
+        new URL(id);
+      } catch (err) {
+        console.warn(Error(errMsg("W3", '"' + id + '" is not a valid URL to set in the module registry')));
+      }
+    }
+    var ns;
+
+    if (toStringTag && module[toStringTag] === "Module") {
+      ns = module;
+    } else {
+      ns = Object.assign(Object.create(null), module);
+      if (toStringTag) Object.defineProperty(ns, toStringTag, {
+        value: "Module"
+      });
+    }
+
+    var done = Promise.resolve(ns);
+    var load = this[REGISTRY][id] || (this[REGISTRY][id] = {
+      id: id,
+      i: [],
+      h: false,
+      d: [],
+      e: null,
+      er: void 0,
+      E: void 0
+    });
+    if (load.e || load.E) return false;
+    Object.assign(load, {
+      n: ns,
+      I: void 0,
+      L: void 0,
+      C: done
+    });
+    return ns;
+  };
+
+  systemJSPrototype.has = function (id) {
+    var load = this[REGISTRY][id];
+    return !!load;
+  };
+
+  systemJSPrototype["delete"] = function (id) {
+    var registry = this[REGISTRY];
+    var load = registry[id];
+    if (!load || load.p && load.p.e !== null || load.E) return false;
+    var importerSetters = load.i;
+    if (load.d) load.d.forEach(function (depLoad) {
+      var importerIndex = depLoad.i.indexOf(load);
+      if (importerIndex !== -1) depLoad.i.splice(importerIndex, 1);
+    });
+    delete registry[id];
+    return function () {
+      var load2 = registry[id];
+      if (!load2 || !importerSetters || load2.e !== null || load2.E) return false;
+      importerSetters.forEach(function (setter) {
+        load2.i.push(setter);
+        setter(load2.n);
+      });
+      importerSetters = null;
+    };
+  };
+
+  var iterator = typeof Symbol !== "undefined" && Symbol.iterator;
+
+  systemJSPrototype.entries = function () {
+    var loader = this,
+        keys = Object.keys(loader[REGISTRY]);
+    var index = 0,
+        ns,
+        key;
+    var result = {
+      next: function next() {
+        while ((key = keys[index++]) !== void 0 && (ns = loader.get(key)) === void 0) {
+          ;
+        }
+
+        return {
+          done: key === void 0,
+          value: key !== void 0 && [key, ns]
+        };
+      }
+    };
+
+    result[iterator] = function () {
+      return this;
+    };
+
+    return result;
+  };
+})(); // ../../../node_modules/systemjs/dist/extras/named-register.js
+
+
+(function () {
+  (function (global2) {
+    var System2 = global2.System;
+    setRegisterRegistry(System2);
+    var systemJSPrototype = System2.constructor.prototype;
+    var constructor = System2.constructor;
+
+    var SystemJS = function SystemJS() {
+      constructor.call(this);
+      setRegisterRegistry(this);
+    };
+
+    SystemJS.prototype = systemJSPrototype;
+    System2.constructor = SystemJS;
+    var firstNamedDefine, firstName;
+
+    function setRegisterRegistry(systemInstance) {
+      systemInstance.registerRegistry = Object.create(null);
+      systemInstance.namedRegisterAliases = Object.create(null);
+    }
+
+    var register = systemJSPrototype.register;
+
+    systemJSPrototype.register = function (name, deps, declare) {
+      if (typeof name !== "string") return register.apply(this, arguments);
+      var define = [deps, declare];
+      this.registerRegistry[name] = define;
+
+      if (!firstNamedDefine) {
+        firstNamedDefine = define;
+        firstName = name;
+      }
+
+      Promise.resolve().then(function () {
+        firstNamedDefine = null;
+        firstName = null;
+      });
+      return register.apply(this, [deps, declare]);
+    };
+
+    var resolve = systemJSPrototype.resolve;
+
+    systemJSPrototype.resolve = function (id, parentURL) {
+      try {
+        return resolve.call(this, id, parentURL);
+      } catch (err) {
+        if (id in this.registerRegistry) {
+          return this.namedRegisterAliases[id] || id;
+        }
+
+        throw err;
+      }
+    };
+
+    var instantiate = systemJSPrototype.instantiate;
+
+    systemJSPrototype.instantiate = function (url, firstParentUrl) {
+      var result = this.registerRegistry[url];
+
+      if (result) {
+        this.registerRegistry[url] = null;
+        return result;
+      } else {
+        return instantiate.call(this, url, firstParentUrl);
+      }
+    };
+
+    var getRegister = systemJSPrototype.getRegister;
+
+    systemJSPrototype.getRegister = function (url) {
+      var register2 = getRegister.call(this, url);
+
+      if (firstName && url) {
+        this.namedRegisterAliases[firstName] = url;
+      }
+
+      var result = firstNamedDefine || register2;
+      firstNamedDefine = null;
+      firstName = null;
+      return result;
+    };
+  })(typeof self !== "undefined" ? self : __webpack_require__.g);
+})(); // ../../tooling/piral-cli/src/common/version.ts
+
+
+var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+var acceptsAll = ["*", "x", ">=0"];
+var operatorResMap = {
+  ">": [1],
+  ">=": [0, 1],
+  "=": [0],
+  "<=": [-1, 0],
+  "<": [-1]
+};
+
+function indexOrEnd(str, q) {
+  return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
+}
+
+function splitVersion(v) {
+  var c = v.replace(/^v/, "").replace(/\+.*$/, "");
+  var patchIndex = indexOrEnd(c, "-");
+  var arr = c.substring(0, patchIndex).split(".");
+  arr.push(c.substring(patchIndex + 1));
+  return arr;
+}
+
+function parseSegment(v) {
+  var n = parseInt(v, 10);
+  return isNaN(n) ? v : n;
+}
+
+function validateAndParse(v) {
+  var match = v.match(semver);
+  match.shift();
+  return match;
+}
+
+function compareStrings(a, b) {
+  var ap = parseSegment(a);
+  var bp = parseSegment(b);
+
+  if (ap > bp) {
+    return 1;
+  } else if (ap < bp) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+function compareSegments(a, b) {
+  for (var i = 0; i < 2; i++) {
+    var r = compareStrings(a[i] || "0", b[i] || "0");
+
+    if (r !== 0) {
+      return r;
+    }
+  }
+
+  return 0;
+}
+
+function compareVersions(v1, v2) {
+  var s1 = splitVersion(v1);
+  var s2 = splitVersion(v2);
+  var len = Math.max(s1.length - 1, s2.length - 1);
+
+  for (var i = 0; i < len; i++) {
+    var n1 = parseInt(s1[i] || "0", 10);
+    var n2 = parseInt(s2[i] || "0", 10);
+
+    if (n1 > n2) {
+      return 1;
+    } else if (n2 > n1) {
+      return -1;
+    }
+  }
+
+  var sp1 = s1[s1.length - 1];
+  var sp2 = s2[s2.length - 1];
+
+  if (sp1 && sp2) {
+    var p1 = sp1.split(".").map(parseSegment);
+    var p2 = sp2.split(".").map(parseSegment);
+    var len2 = Math.max(p1.length, p2.length);
+
+    for (var _i = 0; _i < len2; _i++) {
+      if (p1[_i] === void 0 || typeof p2[_i] === "string" && typeof p1[_i] === "number") {
+        return -1;
+      } else if (p2[_i] === void 0 || typeof p1[_i] === "string" && typeof p2[_i] === "number") {
+        return 1;
+      } else if (p1[_i] > p2[_i]) {
+        return 1;
+      } else if (p2[_i] > p1[_i]) {
+        return -1;
+      }
+    }
+  } else if (sp1 || sp2) {
+    return sp1 ? -1 : 1;
+  }
+
+  return 0;
+}
+
+function compare(v1, v2, operator) {
+  var res = compareVersions(v1, v2);
+  return operatorResMap[operator].indexOf(res) > -1;
+}
+
+function validate(version) {
+  return acceptsAll.includes(version) || semver.test(version);
+}
+
+function satisfies(v, r) {
+  if (!acceptsAll.includes(r)) {
+    var match = r.match(/^([<>=~^]+)/);
+    var op = match ? match[1] : "=";
+
+    if (op !== "^" && op !== "~") {
+      return compare(v, r, op);
+    }
+
+    var _validateAndParse = validateAndParse(v),
+        _validateAndParse2 = _slicedToArray(_validateAndParse, 3),
+        v1 = _validateAndParse2[0],
+        v2 = _validateAndParse2[1],
+        v3 = _validateAndParse2[2];
+
+    var _validateAndParse3 = validateAndParse(r),
+        _validateAndParse4 = _slicedToArray(_validateAndParse3, 3),
+        m1 = _validateAndParse4[0],
+        m2 = _validateAndParse4[1],
+        m3 = _validateAndParse4[2];
+
+    if (compareStrings(v1, m1) !== 0) {
+      return false;
+    } else if (op === "^") {
+      return compareSegments([v2, v3], [m2, m3]) >= 0;
+    } else if (compareStrings(v2, m2) !== 0) {
+      return false;
+    }
+
+    return compareStrings(v3, m3) >= 0;
+  }
+
+  return true;
+} // src/utils/system.ts
+
+
+var systemResolve = System.constructor.prototype.resolve;
+var systemRegister = System.constructor.prototype.register;
+
+function getLoadedVersions(prefix) {
+  return _toConsumableArray(System.entries()).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+        name = _ref2[0];
+
+    return name.startsWith(prefix);
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 1),
+        name = _ref4[0];
+
+    return name.substring(prefix.length);
+  });
+}
+
+function findMatchingPackage(id) {
+  var sep = id.indexOf("@", 1);
+
+  if (sep > 1) {
+    var available = Object.keys(System.registerRegistry);
+    var name = id.substring(0, sep + 1);
+    var versionSpec = id.substring(sep + 1);
+
+    if (validate(versionSpec)) {
+      var loadedVersions = getLoadedVersions(name);
+      var allVersions = available.filter(function (m) {
+        return m.startsWith(name);
+      }).map(function (m) {
+        return m.substring(name.length);
+      });
+      var availableVersions = [].concat(_toConsumableArray(loadedVersions), _toConsumableArray(allVersions.filter(function (m) {
+        return !loadedVersions.includes(m);
+      })));
+
+      var _iterator = _createForOfIteratorHelper(availableVersions),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var availableVersion = _step.value;
+
+          if (validate(availableVersion) && satisfies(availableVersion, versionSpec)) {
+            return name + availableVersion;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }
+
+  return void 0;
+}
+
+function isPrimitiveExport(content) {
+  var type = _typeof(content);
+
+  return type === "number" || type === "boolean" || type === "symbol" || type === "string" || type === "bigint" || Array.isArray(content);
+}
+
+System.constructor.prototype.resolve = function (id, parentUrl) {
+  try {
+    return systemResolve.call(this, id, parentUrl);
+  } catch (ex) {
+    var result = findMatchingPackage(id);
+
+    if (!result) {
+      throw ex;
+    }
+
+    return result;
+  }
+};
+
+System.constructor.prototype.register = function () {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var getContent = args.pop();
+  args.push(function (_export, ctx) {
+    var exp = function exp() {
+      if (arguments.length === 1) {
+        var content = arguments.length <= 0 ? undefined : arguments[0];
+
+        if (content instanceof Promise) {
+          return content.then(exp);
+        } else if (typeof content === "function") {
+          _export("__esModule", true);
+
+          Object.keys(content).forEach(function (prop) {
+            _export(prop, content[prop]);
+          });
+
+          _export("default", content);
+        } else if (isPrimitiveExport(content)) {
+          _export("__esModule", true);
+
+          _export("default", content);
+        } else if (content) {
+          _export(content);
+
+          if (_typeof(content) === "object" && !("default" in content)) {
+            _export("default", content);
+          }
+        }
+      } else {
+        _export.apply(void 0, arguments);
+      }
+    };
+
+    return getContent(exp, ctx);
+  });
+  return systemRegister.apply(this, args);
+};
+
+function tryResolve(name, parent) {
+  try {
+    return System.resolve(name, parent);
+  } catch (e) {
+    return void 0;
+  }
+}
+
+function registerDependencies(modules) {
+  var moduleNames = Object.keys(modules);
+  moduleNames.forEach(function (name) {
+    return registerModule(name, function () {
+      return modules[name];
+    });
+  });
+  return Promise.all(moduleNames.map(function (name) {
+    return System["import"](name);
+  }));
+}
+
+function registerModule(name, resolve) {
+  System.register(name, [], function (_exports) {
+    return {
+      execute: function execute() {
+        var content = resolve();
+
+        if (content instanceof Promise) {
+          return content.then(_exports);
+        } else {
+          _exports(content);
+        }
+      }
+    };
+  });
+}
+
+function unregisterModules(baseUrl, dependencies) {
+  _toConsumableArray(System.entries()).map(function (_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 1),
+        name = _ref6[0];
+
+    return name;
+  }).filter(function (name) {
+    return name.startsWith(baseUrl) && !dependencies.includes(name);
+  }).forEach(function (name) {
+    return System["delete"](name);
+  });
+}
+
+function requireModule(name, parent) {
+  var moduleId = tryResolve(name, parent);
+  var dependency = moduleId && System.get(moduleId);
+
+  if (!dependency) {
+    var error = new Error("Cannot find module '".concat(name, "'"));
+    error.code = "MODULE_NOT_FOUND";
+    throw error;
+  }
+
+  return dependency;
+}
+
+
+
+/***/ }),
+
+/***/ "../../framework/piral-core/esm/Piral.js":
+/*!***********************************************!*\
+  !*** ../../framework/piral-core/esm/Piral.js ***!
+  \***********************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Piral": () => (/* binding */ Piral)
+/* harmony export */ });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "../../../node_modules/react/index.js");
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _createInstance__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./createInstance */ "../../framework/piral-core/esm/createInstance.js");
+/* harmony import */ var _components__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./components */ "../../framework/piral-core/esm/components/components.js");
+/* harmony import */ var _components__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./components */ "../../framework/piral-core/esm/components/PiralView.js");
+/* harmony import */ var _PiralContext__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./PiralContext */ "../../framework/piral-core/esm/PiralContext.js");
+/* harmony import */ var _app_codegen__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../app.codegen */ "../../framework/piral-core/app.codegen");
 
 
 
@@ -3341,110 +4198,6 @@ function createInstance() {
 
 /***/ }),
 
-/***/ "../../framework/piral-core/esm/debugger.js":
-/*!**************************************************!*\
-  !*** ../../framework/piral-core/esm/debugger.js ***!
-  \**************************************************/
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "integrateDebugger": () => (/* binding */ integrateDebugger)
-/* harmony export */ });
-/* harmony import */ var piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! piral-debug-utils */ "../../utilities/piral-debug-utils/esm/debug.js");
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-
-function integrateDebugger(context, options) {
-  var debug = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  (0,piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__.installPiralDebug)(Object.assign(Object.assign({}, debug), {
-    addPilet: context.addPilet,
-    removePilet: context.removePilet,
-    updatePilet: function updatePilet(pilet) {
-      if (!pilet.disabled) {
-        var createApi = options.createApi;
-        var newApi = createApi(pilet);
-
-        try {
-          context.injectPilet(pilet);
-          pilet.setup(newApi);
-        } catch (error) {
-          console.error(error);
-        }
-      } else {
-        context.injectPilet(pilet);
-      }
-    },
-    fireEvent: context.emit,
-    getDependencies: function getDependencies() {
-      return Object.keys(options.dependencies);
-    },
-    getExtensions: function getExtensions() {
-      return context.readState(function (s) {
-        return Object.keys(s.registry.extensions);
-      });
-    },
-    getRoutes: function getRoutes() {
-      var registeredRoutes = context.readState(function (state) {
-        return Object.keys(state.registry.pages);
-      });
-      var componentRoutes = context.readState(function (state) {
-        return Object.keys(state.routes);
-      });
-      return [].concat(_toConsumableArray(componentRoutes), _toConsumableArray(registeredRoutes));
-    },
-    getGlobalState: function getGlobalState() {
-      return context.readState(function (s) {
-        return s;
-      });
-    },
-    navigate: function navigate(path, state) {
-      return context.navigation.push(path, state);
-    },
-    getPilets: function getPilets() {
-      return context.readState(function (s) {
-        return s.modules;
-      });
-    },
-    integrate: function integrate(dbg) {
-      context.dispatch(function (s) {
-        return Object.assign(Object.assign({}, s), {
-          components: Object.assign(Object.assign({}, s.components), dbg.components),
-          routes: Object.assign(Object.assign({}, s.routes), dbg.routes),
-          registry: Object.assign(Object.assign({}, s.registry), {
-            wrappers: Object.assign(Object.assign({}, s.registry.wrappers), dbg.wrappers)
-          })
-        });
-      });
-      context.state.subscribe(function (current, previous) {
-        var pilets = current.modules !== previous.modules;
-        var pages = current.registry.pages !== previous.registry.pages || current.routes !== previous.routes;
-        var extensions = current.registry.extensions !== previous.registry.extensions;
-        var state = current !== previous;
-        dbg.onChange(previous, current, {
-          pilets: pilets,
-          pages: pages,
-          extensions: extensions,
-          state: state
-        });
-      });
-    }
-  }));
-}
-
-/***/ }),
-
 /***/ "../../framework/piral-core/esm/defaults/DefaultErrorInfo.js":
 /*!*******************************************************************!*\
   !*** ../../framework/piral-core/esm/defaults/DefaultErrorInfo.js ***!
@@ -3715,31 +4468,6 @@ function createNavigation() {
 
 /***/ }),
 
-/***/ "../../framework/piral-core/esm/emulator.js":
-/*!**************************************************!*\
-  !*** ../../framework/piral-core/esm/emulator.js ***!
-  \**************************************************/
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "integrateEmulator": () => (/* binding */ integrateEmulator)
-/* harmony export */ });
-/* harmony import */ var piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! piral-debug-utils */ "../../utilities/piral-debug-utils/esm/emulator.js");
-
-function integrateEmulator(context, options) {
-  (0,piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__.installPiletEmulator)(options.fetchPilets, {
-    addPilet: context.addPilet,
-    removePilet: context.removePilet,
-    integrate: function integrate(requester) {
-      options.fetchPilets = requester;
-    }
-  });
-}
-
-/***/ }),
-
 /***/ "../../framework/piral-core/esm/helpers.js":
 /*!*************************************************!*\
   !*** ../../framework/piral-core/esm/helpers.js ***!
@@ -3753,8 +4481,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var piral_base__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! piral-base */ "../../framework/piral-base/esm/loader.js");
 /* harmony import */ var _modules__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./modules */ "../../framework/piral-core/esm/modules/dependencies.js");
-/* harmony import */ var _app_codegen__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../app.codegen */ "../../framework/piral-core/esm/debugger.js");
-/* harmony import */ var _app_codegen__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../app.codegen */ "../../framework/piral-core/esm/emulator.js");
+/* harmony import */ var _app_codegen__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../app.codegen */ "../../framework/piral-core/esm/tools/debugger.js");
+/* harmony import */ var _app_codegen__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../app.codegen */ "../../framework/piral-core/esm/tools/emulator.js");
 
 
 
@@ -4572,6 +5300,135 @@ function withApi(context, component, piral, errorType) {
 
 /***/ }),
 
+/***/ "../../framework/piral-core/esm/tools/debugger.js":
+/*!********************************************************!*\
+  !*** ../../framework/piral-core/esm/tools/debugger.js ***!
+  \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "integrateDebugger": () => (/* binding */ integrateDebugger)
+/* harmony export */ });
+/* harmony import */ var piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! piral-debug-utils */ "../../utilities/piral-debug-utils/esm/debug.js");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+
+function integrateDebugger(context, options) {
+  var debug = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  (0,piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__.installPiralDebug)(Object.assign(Object.assign({}, debug), {
+    addPilet: context.addPilet,
+    removePilet: context.removePilet,
+    updatePilet: function updatePilet(pilet) {
+      if (!pilet.disabled) {
+        var createApi = options.createApi;
+        var newApi = createApi(pilet);
+
+        try {
+          context.injectPilet(pilet);
+          pilet.setup(newApi);
+        } catch (error) {
+          console.error(error);
+        }
+      } else {
+        context.injectPilet(pilet);
+      }
+    },
+    fireEvent: context.emit,
+    getDependencies: function getDependencies() {
+      return Object.keys(options.dependencies);
+    },
+    getExtensions: function getExtensions() {
+      return context.readState(function (s) {
+        return Object.keys(s.registry.extensions);
+      });
+    },
+    getRoutes: function getRoutes() {
+      var registeredRoutes = context.readState(function (state) {
+        return Object.keys(state.registry.pages);
+      });
+      var componentRoutes = context.readState(function (state) {
+        return Object.keys(state.routes);
+      });
+      return [].concat(_toConsumableArray(componentRoutes), _toConsumableArray(registeredRoutes));
+    },
+    getGlobalState: function getGlobalState() {
+      return context.readState(function (s) {
+        return s;
+      });
+    },
+    navigate: function navigate(path, state) {
+      return context.navigation.push(path, state);
+    },
+    getPilets: function getPilets() {
+      return context.readState(function (s) {
+        return s.modules;
+      });
+    },
+    integrate: function integrate(dbg) {
+      context.dispatch(function (s) {
+        return Object.assign(Object.assign({}, s), {
+          components: Object.assign(Object.assign({}, s.components), dbg.components),
+          routes: Object.assign(Object.assign({}, s.routes), dbg.routes),
+          registry: Object.assign(Object.assign({}, s.registry), {
+            wrappers: Object.assign(Object.assign({}, s.registry.wrappers), dbg.wrappers)
+          })
+        });
+      });
+      context.state.subscribe(function (current, previous) {
+        var pilets = current.modules !== previous.modules;
+        var pages = current.registry.pages !== previous.registry.pages || current.routes !== previous.routes;
+        var extensions = current.registry.extensions !== previous.registry.extensions;
+        var state = current !== previous;
+        dbg.onChange(previous, current, {
+          pilets: pilets,
+          pages: pages,
+          extensions: extensions,
+          state: state
+        });
+      });
+    }
+  }));
+}
+
+/***/ }),
+
+/***/ "../../framework/piral-core/esm/tools/emulator.js":
+/*!********************************************************!*\
+  !*** ../../framework/piral-core/esm/tools/emulator.js ***!
+  \********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "integrateEmulator": () => (/* binding */ integrateEmulator)
+/* harmony export */ });
+/* harmony import */ var piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! piral-debug-utils */ "../../utilities/piral-debug-utils/esm/emulator.js");
+
+function integrateEmulator(context, options) {
+  (0,piral_debug_utils__WEBPACK_IMPORTED_MODULE_0__.installPiletEmulator)(options.fetchPilets, {
+    addPilet: context.addPilet,
+    removePilet: context.removePilet,
+    integrate: function integrate(requester) {
+      options.fetchPilets = requester;
+    }
+  });
+}
+
+/***/ }),
+
 /***/ "../../framework/piral-core/esm/utils/compare.js":
 /*!*******************************************************!*\
   !*** ../../framework/piral-core/esm/utils/compare.js ***!
@@ -5784,11 +6641,11 @@ function installPiralDebug(options) {
     debug: debugApiVersion,
     instance: {
       name: "minimal-piral",
-      version: "0.15.0-beta.4696",
+      version: "0.15.0-beta.4708",
       dependencies: "tslib,react,react-dom,react-router,react-router-dom"
     },
     build: {
-      date: "2022-09-29T15:32:18.496Z",
+      date: "2022-10-02T21:47:58.594Z",
       cli: "0.14.32",
       compat: "0.14"
     }
@@ -7790,8 +8647,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "createNavigation": () => (/* reexport safe */ piral_core_defaults_navigator_v5__WEBPACK_IMPORTED_MODULE_5__.createNavigation),
 /* harmony export */   "createRedirect": () => (/* reexport safe */ piral_core_defaults_navigator_v5__WEBPACK_IMPORTED_MODULE_5__.createRedirect),
 /* harmony export */   "fillDependencies": () => (/* binding */ fillDependencies),
-/* harmony export */   "integrateDebugger": () => (/* reexport safe */ piral_core_debugger__WEBPACK_IMPORTED_MODULE_11__.integrateDebugger),
-/* harmony export */   "integrateEmulator": () => (/* reexport safe */ piral_core_emulator__WEBPACK_IMPORTED_MODULE_12__.integrateEmulator),
+/* harmony export */   "integrateDebugger": () => (/* reexport safe */ piral_core_tools_debugger__WEBPACK_IMPORTED_MODULE_11__.integrateDebugger),
+/* harmony export */   "integrateEmulator": () => (/* reexport safe */ piral_core_tools_emulator__WEBPACK_IMPORTED_MODULE_12__.integrateEmulator),
 /* harmony export */   "publicPath": () => (/* binding */ publicPath),
 /* harmony export */   "useRouteFilter": () => (/* binding */ useRouteFilter),
 /* harmony export */   "useRouterContext": () => (/* reexport safe */ piral_core_defaults_navigator_v5__WEBPACK_IMPORTED_MODULE_5__.useRouterContext)
@@ -7808,8 +8665,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var piral_core_defaults_DefaultRouter_v5__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! piral-core/_/defaults/DefaultRouter_v5 */ "../../framework/piral-core/esm/defaults/DefaultRouter_v5.js");
 /* harmony import */ var piral_core_defaults_DefaultRouteSwitch_v5__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! piral-core/_/defaults/DefaultRouteSwitch_v5 */ "../../framework/piral-core/esm/defaults/DefaultRouteSwitch_v5.js");
 /* harmony import */ var piral_core_defaults_navigator_v5__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! piral-core/_/defaults/navigator_v5 */ "../../framework/piral-core/esm/defaults/navigator_v5.js");
-/* harmony import */ var piral_core_debugger__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! piral-core/_/debugger */ "../../framework/piral-core/esm/debugger.js");
-/* harmony import */ var piral_core_emulator__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! piral-core/_/emulator */ "../../framework/piral-core/esm/emulator.js");
+/* harmony import */ var piral_core_tools_debugger__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! piral-core/_/tools/debugger */ "../../framework/piral-core/esm/tools/debugger.js");
+/* harmony import */ var piral_core_tools_emulator__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! piral-core/_/tools/emulator */ "../../framework/piral-core/esm/tools/emulator.js");
 /* harmony import */ var piral_debug_utils__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! piral-debug-utils */ "../../utilities/piral-debug-utils/esm/emulator.js");
 
     
@@ -7827,10 +8684,9 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-
     
     function fillDependencies(deps) {
-      deps['minimal-piral']={};deps["tslib"]=tslib__WEBPACK_IMPORTED_MODULE_2__;deps["tslib@2.3.1"]=tslib__WEBPACK_IMPORTED_MODULE_2__;deps["react"]=react__WEBPACK_IMPORTED_MODULE_0__;deps["react@18.2.0"]=react__WEBPACK_IMPORTED_MODULE_0__;deps["react-dom"]=/*#__PURE__*/ (react_dom__WEBPACK_IMPORTED_MODULE_1___namespace_cache || (react_dom__WEBPACK_IMPORTED_MODULE_1___namespace_cache = __webpack_require__.t(react_dom__WEBPACK_IMPORTED_MODULE_1__, 2)));deps["react-dom@18.2.0"]=/*#__PURE__*/ (react_dom__WEBPACK_IMPORTED_MODULE_1___namespace_cache || (react_dom__WEBPACK_IMPORTED_MODULE_1___namespace_cache = __webpack_require__.t(react_dom__WEBPACK_IMPORTED_MODULE_1__, 2)));deps["react-router"]=react_router__WEBPACK_IMPORTED_MODULE_3__;deps["react-router@5.3.3"]=react_router__WEBPACK_IMPORTED_MODULE_3__;deps["react-router-dom"]=react_router_dom__WEBPACK_IMPORTED_MODULE_4__;deps["react-router-dom@5.3.3"]=react_router_dom__WEBPACK_IMPORTED_MODULE_4__
+      deps['minimal-piral']={};deps["tslib"]=tslib__WEBPACK_IMPORTED_MODULE_2__;deps["react"]=react__WEBPACK_IMPORTED_MODULE_0__;deps["react-dom"]=/*#__PURE__*/ (react_dom__WEBPACK_IMPORTED_MODULE_1___namespace_cache || (react_dom__WEBPACK_IMPORTED_MODULE_1___namespace_cache = __webpack_require__.t(react_dom__WEBPACK_IMPORTED_MODULE_1__, 2)));deps["react-router"]=react_router__WEBPACK_IMPORTED_MODULE_3__;deps["react-router-dom"]=react_router_dom__WEBPACK_IMPORTED_MODULE_4__
     }
   
 
@@ -43043,2032 +43899,916 @@ function describeNativeComponentFrame(fn, construct) {
       }
     }
   } finally {
-    reentry = false;
-
-    {
-      ReactCurrentDispatcher$1.current = previousDispatcher;
-      reenableLogs();
-    }
-
-    Error.prepareStackTrace = previousPrepareStackTrace;
-  } // Fallback to just using the name if we couldn't make it throw.
-
-
-  var name = fn ? fn.displayName || fn.name : '';
-  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
-
-  {
-    if (typeof fn === 'function') {
-      componentFrameCache.set(fn, syntheticFrame);
-    }
-  }
-
-  return syntheticFrame;
-}
-function describeFunctionComponentFrame(fn, source, ownerFn) {
-  {
-    return describeNativeComponentFrame(fn, false);
-  }
-}
-
-function shouldConstruct(Component) {
-  var prototype = Component.prototype;
-  return !!(prototype && prototype.isReactComponent);
-}
-
-function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
-
-  if (type == null) {
-    return '';
-  }
-
-  if (typeof type === 'function') {
-    {
-      return describeNativeComponentFrame(type, shouldConstruct(type));
-    }
-  }
-
-  if (typeof type === 'string') {
-    return describeBuiltInComponentFrame(type);
-  }
-
-  switch (type) {
-    case REACT_SUSPENSE_TYPE:
-      return describeBuiltInComponentFrame('Suspense');
-
-    case REACT_SUSPENSE_LIST_TYPE:
-      return describeBuiltInComponentFrame('SuspenseList');
-  }
-
-  if (typeof type === 'object') {
-    switch (type.$$typeof) {
-      case REACT_FORWARD_REF_TYPE:
-        return describeFunctionComponentFrame(type.render);
-
-      case REACT_MEMO_TYPE:
-        // Memo may contain any component type so we recursively resolve it.
-        return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
-
-      case REACT_LAZY_TYPE:
-        {
-          var lazyComponent = type;
-          var payload = lazyComponent._payload;
-          var init = lazyComponent._init;
-
-          try {
-            // Lazy may contain any component type so we recursively resolve it.
-            return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
-          } catch (x) {}
-        }
-    }
-  }
-
-  return '';
-}
-
-var loggedTypeFailures = {};
-var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
-
-function setCurrentlyValidatingElement(element) {
-  {
-    if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
-      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
-    } else {
-      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
-    }
-  }
-}
-
-function checkPropTypes(typeSpecs, values, location, componentName, element) {
-  {
-    // $FlowFixMe This is okay but Flow doesn't know it.
-    var has = Function.call.bind(hasOwnProperty);
-
-    for (var typeSpecName in typeSpecs) {
-      if (has(typeSpecs, typeSpecName)) {
-        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
-        // fail the render phase where it didn't fail before. So we log it.
-        // After these have been cleaned up, we'll let them throw.
-
-        try {
-          // This is intentionally an invariant that gets caught. It's the same
-          // behavior as without this statement except with a better message.
-          if (typeof typeSpecs[typeSpecName] !== 'function') {
-            // eslint-disable-next-line react-internal/prod-error-codes
-            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
-            err.name = 'Invariant Violation';
-            throw err;
-          }
-
-          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
-        } catch (ex) {
-          error$1 = ex;
-        }
-
-        if (error$1 && !(error$1 instanceof Error)) {
-          setCurrentlyValidatingElement(element);
-
-          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
-
-          setCurrentlyValidatingElement(null);
-        }
-
-        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
-          // Only monitor this failure once because there tends to be a lot of the
-          // same error.
-          loggedTypeFailures[error$1.message] = true;
-          setCurrentlyValidatingElement(element);
-
-          error('Failed %s type: %s', location, error$1.message);
-
-          setCurrentlyValidatingElement(null);
-        }
-      }
-    }
-  }
-}
-
-function setCurrentlyValidatingElement$1(element) {
-  {
-    if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
-      setExtraStackFrame(stack);
-    } else {
-      setExtraStackFrame(null);
-    }
-  }
-}
-
-var propTypesMisspellWarningShown;
-
-{
-  propTypesMisspellWarningShown = false;
-}
-
-function getDeclarationErrorAddendum() {
-  if (ReactCurrentOwner.current) {
-    var name = getComponentNameFromType(ReactCurrentOwner.current.type);
-
-    if (name) {
-      return '\n\nCheck the render method of `' + name + '`.';
-    }
-  }
-
-  return '';
-}
-
-function getSourceInfoErrorAddendum(source) {
-  if (source !== undefined) {
-    var fileName = source.fileName.replace(/^.*[\\\/]/, '');
-    var lineNumber = source.lineNumber;
-    return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
-  }
-
-  return '';
-}
-
-function getSourceInfoErrorAddendumForProps(elementProps) {
-  if (elementProps !== null && elementProps !== undefined) {
-    return getSourceInfoErrorAddendum(elementProps.__source);
-  }
-
-  return '';
-}
-/**
- * Warn if there's no key explicitly set on dynamic arrays of children or
- * object keys are not valid. This allows us to keep track of children between
- * updates.
- */
-
-
-var ownerHasKeyUseWarning = {};
-
-function getCurrentComponentErrorInfo(parentType) {
-  var info = getDeclarationErrorAddendum();
-
-  if (!info) {
-    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
-
-    if (parentName) {
-      info = "\n\nCheck the top-level render call using <" + parentName + ">.";
-    }
-  }
-
-  return info;
-}
-/**
- * Warn if the element doesn't have an explicit key assigned to it.
- * This element is in an array. The array could grow and shrink or be
- * reordered. All children that haven't already been validated are required to
- * have a "key" property assigned to it. Error statuses are cached so a warning
- * will only be shown once.
- *
- * @internal
- * @param {ReactElement} element Element that requires a key.
- * @param {*} parentType element's parent's type.
- */
-
-
-function validateExplicitKey(element, parentType) {
-  if (!element._store || element._store.validated || element.key != null) {
-    return;
-  }
-
-  element._store.validated = true;
-  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
-
-  if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
-    return;
-  }
-
-  ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
-  // property, it may be the creator of the child that's responsible for
-  // assigning it a key.
-
-  var childOwner = '';
-
-  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
-    // Give the component that originally created this child.
-    childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
-  }
-
-  {
-    setCurrentlyValidatingElement$1(element);
-
-    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
-
-    setCurrentlyValidatingElement$1(null);
-  }
-}
-/**
- * Ensure that every element either is passed in a static location, in an
- * array with an explicit keys property defined, or in an object literal
- * with valid key property.
- *
- * @internal
- * @param {ReactNode} node Statically passed child of any type.
- * @param {*} parentType node's parent's type.
- */
-
-
-function validateChildKeys(node, parentType) {
-  if (typeof node !== 'object') {
-    return;
-  }
-
-  if (isArray(node)) {
-    for (var i = 0; i < node.length; i++) {
-      var child = node[i];
-
-      if (isValidElement(child)) {
-        validateExplicitKey(child, parentType);
-      }
-    }
-  } else if (isValidElement(node)) {
-    // This element was passed in a valid location.
-    if (node._store) {
-      node._store.validated = true;
-    }
-  } else if (node) {
-    var iteratorFn = getIteratorFn(node);
-
-    if (typeof iteratorFn === 'function') {
-      // Entry iterators used to provide implicit keys,
-      // but now we print a separate warning for them later.
-      if (iteratorFn !== node.entries) {
-        var iterator = iteratorFn.call(node);
-        var step;
-
-        while (!(step = iterator.next()).done) {
-          if (isValidElement(step.value)) {
-            validateExplicitKey(step.value, parentType);
-          }
-        }
-      }
-    }
-  }
-}
-/**
- * Given an element, validate that its props follow the propTypes definition,
- * provided by the type.
- *
- * @param {ReactElement} element
- */
-
-
-function validatePropTypes(element) {
-  {
-    var type = element.type;
-
-    if (type === null || type === undefined || typeof type === 'string') {
-      return;
-    }
-
-    var propTypes;
-
-    if (typeof type === 'function') {
-      propTypes = type.propTypes;
-    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
-    // Inner props are checked in the reconciler.
-    type.$$typeof === REACT_MEMO_TYPE)) {
-      propTypes = type.propTypes;
-    } else {
-      return;
-    }
-
-    if (propTypes) {
-      // Intentionally inside to avoid triggering lazy initializers:
-      var name = getComponentNameFromType(type);
-      checkPropTypes(propTypes, element.props, 'prop', name, element);
-    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
-      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
-
-      var _name = getComponentNameFromType(type);
-
-      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
-    }
-
-    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
-      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
-    }
-  }
-}
-/**
- * Given a fragment, validate that it can only be provided with fragment props
- * @param {ReactElement} fragment
- */
-
-
-function validateFragmentProps(fragment) {
-  {
-    var keys = Object.keys(fragment.props);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-
-      if (key !== 'children' && key !== 'key') {
-        setCurrentlyValidatingElement$1(fragment);
-
-        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
-
-        setCurrentlyValidatingElement$1(null);
-        break;
-      }
-    }
-
-    if (fragment.ref !== null) {
-      setCurrentlyValidatingElement$1(fragment);
-
-      error('Invalid attribute `ref` supplied to `React.Fragment`.');
-
-      setCurrentlyValidatingElement$1(null);
-    }
-  }
-}
-function createElementWithValidation(type, props, children) {
-  var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
-  // succeed and there will likely be errors in render.
-
-  if (!validType) {
-    var info = '';
-
-    if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
-      info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
-    }
-
-    var sourceInfo = getSourceInfoErrorAddendumForProps(props);
-
-    if (sourceInfo) {
-      info += sourceInfo;
-    } else {
-      info += getDeclarationErrorAddendum();
-    }
-
-    var typeString;
-
-    if (type === null) {
-      typeString = 'null';
-    } else if (isArray(type)) {
-      typeString = 'array';
-    } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
-      typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
-      info = ' Did you accidentally export a JSX literal instead of a component?';
-    } else {
-      typeString = typeof type;
-    }
-
-    {
-      error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
-    }
-  }
-
-  var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
-  // TODO: Drop this when these are no longer allowed as the type argument.
-
-  if (element == null) {
-    return element;
-  } // Skip key warning if the type isn't valid since our key validation logic
-  // doesn't expect a non-string/function type and can throw confusing errors.
-  // We don't want exception behavior to differ between dev and prod.
-  // (Rendering will throw with a helpful message and as soon as the type is
-  // fixed, the key warnings will appear.)
-
-
-  if (validType) {
-    for (var i = 2; i < arguments.length; i++) {
-      validateChildKeys(arguments[i], type);
-    }
-  }
-
-  if (type === REACT_FRAGMENT_TYPE) {
-    validateFragmentProps(element);
-  } else {
-    validatePropTypes(element);
-  }
-
-  return element;
-}
-var didWarnAboutDeprecatedCreateFactory = false;
-function createFactoryWithValidation(type) {
-  var validatedFactory = createElementWithValidation.bind(null, type);
-  validatedFactory.type = type;
+    reentry = false;
 
-  {
-    if (!didWarnAboutDeprecatedCreateFactory) {
-      didWarnAboutDeprecatedCreateFactory = true;
+    {
+      ReactCurrentDispatcher$1.current = previousDispatcher;
+      reenableLogs();
+    }
 
-      warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.');
-    } // Legacy hook: remove it
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
 
 
-    Object.defineProperty(validatedFactory, 'type', {
-      enumerable: false,
-      get: function () {
-        warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
+  var name = fn ? fn.displayName || fn.name : '';
+  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
 
-        Object.defineProperty(this, 'type', {
-          value: type
-        });
-        return type;
-      }
-    });
+  {
+    if (typeof fn === 'function') {
+      componentFrameCache.set(fn, syntheticFrame);
+    }
   }
 
-  return validatedFactory;
+  return syntheticFrame;
 }
-function cloneElementWithValidation(element, props, children) {
-  var newElement = cloneElement.apply(this, arguments);
-
-  for (var i = 2; i < arguments.length; i++) {
-    validateChildKeys(arguments[i], newElement.type);
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
   }
+}
 
-  validatePropTypes(newElement);
-  return newElement;
+function shouldConstruct(Component) {
+  var prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
 }
 
-function startTransition(scope, options) {
-  var prevTransition = ReactCurrentBatchConfig.transition;
-  ReactCurrentBatchConfig.transition = {};
-  var currentTransition = ReactCurrentBatchConfig.transition;
+function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
 
-  {
-    ReactCurrentBatchConfig.transition._updatedFibers = new Set();
+  if (type == null) {
+    return '';
   }
 
-  try {
-    scope();
-  } finally {
-    ReactCurrentBatchConfig.transition = prevTransition;
-
+  if (typeof type === 'function') {
     {
-      if (prevTransition === null && currentTransition._updatedFibers) {
-        var updatedFibersCount = currentTransition._updatedFibers.size;
+      return describeNativeComponentFrame(type, shouldConstruct(type));
+    }
+  }
 
-        if (updatedFibersCount > 10) {
-          warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.');
-        }
+  if (typeof type === 'string') {
+    return describeBuiltInComponentFrame(type);
+  }
 
-        currentTransition._updatedFibers.clear();
-      }
-    }
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return describeBuiltInComponentFrame('SuspenseList');
   }
-}
 
-var didWarnAboutMessageChannel = false;
-var enqueueTaskImpl = null;
-function enqueueTask(task) {
-  if (enqueueTaskImpl === null) {
-    try {
-      // read require off the module object to get around the bundlers.
-      // we don't want them to detect a require and bundle a Node polyfill.
-      var requireString = ('require' + Math.random()).slice(0, 7);
-      var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
-      // version of setImmediate, bypassing fake timers if any.
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeFunctionComponentFrame(type.render);
 
-      enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;
-    } catch (_err) {
-      // we're in a browser
-      // we can't use regular timers because they may still be faked
-      // so we try MessageChannel+postMessage instead
-      enqueueTaskImpl = function (callback) {
+      case REACT_MEMO_TYPE:
+        // Memo may contain any component type so we recursively resolve it.
+        return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+
+      case REACT_LAZY_TYPE:
         {
-          if (didWarnAboutMessageChannel === false) {
-            didWarnAboutMessageChannel = true;
+          var lazyComponent = type;
+          var payload = lazyComponent._payload;
+          var init = lazyComponent._init;
 
-            if (typeof MessageChannel === 'undefined') {
-              error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');
-            }
-          }
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
+          } catch (x) {}
         }
-
-        var channel = new MessageChannel();
-        channel.port1.onmessage = callback;
-        channel.port2.postMessage(undefined);
-      };
     }
   }
 
-  return enqueueTaskImpl(task);
+  return '';
 }
 
-var actScopeDepth = 0;
-var didWarnNoAwaitAct = false;
-function act(callback) {
-  {
-    // `act` calls can be nested, so we track the depth. This represents the
-    // number of `act` scopes on the stack.
-    var prevActScopeDepth = actScopeDepth;
-    actScopeDepth++;
+var loggedTypeFailures = {};
+var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
 
-    if (ReactCurrentActQueue.current === null) {
-      // This is the outermost `act` scope. Initialize the queue. The reconciler
-      // will detect the queue and use it instead of Scheduler.
-      ReactCurrentActQueue.current = [];
+function setCurrentlyValidatingElement(element) {
+  {
+    if (element) {
+      var owner = element._owner;
+      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+    } else {
+      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
     }
+  }
+}
 
-    var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
-    var result;
+function checkPropTypes(typeSpecs, values, location, componentName, element) {
+  {
+    // $FlowFixMe This is okay but Flow doesn't know it.
+    var has = Function.call.bind(hasOwnProperty);
 
-    try {
-      // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
-      // set to `true` while the given callback is executed, not for updates
-      // triggered during an async event, because this is how the legacy
-      // implementation of `act` behaved.
-      ReactCurrentActQueue.isBatchingLegacy = true;
-      result = callback(); // Replicate behavior of original `act` implementation in legacy mode,
-      // which flushed updates immediately after the scope function exits, even
-      // if it's an async function.
+    for (var typeSpecName in typeSpecs) {
+      if (has(typeSpecs, typeSpecName)) {
+        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
 
-      if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
-        var queue = ReactCurrentActQueue.current;
+        try {
+          // This is intentionally an invariant that gets caught. It's the same
+          // behavior as without this statement except with a better message.
+          if (typeof typeSpecs[typeSpecName] !== 'function') {
+            // eslint-disable-next-line react-internal/prod-error-codes
+            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
+            err.name = 'Invariant Violation';
+            throw err;
+          }
 
-        if (queue !== null) {
-          ReactCurrentActQueue.didScheduleLegacyUpdate = false;
-          flushActQueue(queue);
+          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
+        } catch (ex) {
+          error$1 = ex;
         }
-      }
-    } catch (error) {
-      popActScope(prevActScopeDepth);
-      throw error;
-    } finally {
-      ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
-    }
-
-    if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
-      var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait
-      // for it to resolve before exiting the current scope.
-
-      var wasAwaited = false;
-      var thenable = {
-        then: function (resolve, reject) {
-          wasAwaited = true;
-          thenableResult.then(function (returnValue) {
-            popActScope(prevActScopeDepth);
 
-            if (actScopeDepth === 0) {
-              // We've exited the outermost act scope. Recursively flush the
-              // queue until there's no remaining work.
-              recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-            } else {
-              resolve(returnValue);
-            }
-          }, function (error) {
-            // The callback threw an error.
-            popActScope(prevActScopeDepth);
-            reject(error);
-          });
-        }
-      };
+        if (error$1 && !(error$1 instanceof Error)) {
+          setCurrentlyValidatingElement(element);
 
-      {
-        if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') {
-          // eslint-disable-next-line no-undef
-          Promise.resolve().then(function () {}).then(function () {
-            if (!wasAwaited) {
-              didWarnNoAwaitAct = true;
+          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
 
-              error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);');
-            }
-          });
+          setCurrentlyValidatingElement(null);
         }
-      }
-
-      return thenable;
-    } else {
-      var returnValue = result; // The callback is not an async function. Exit the current scope
-      // immediately, without awaiting.
-
-      popActScope(prevActScopeDepth);
-
-      if (actScopeDepth === 0) {
-        // Exiting the outermost act scope. Flush the queue.
-        var _queue = ReactCurrentActQueue.current;
 
-        if (_queue !== null) {
-          flushActQueue(_queue);
-          ReactCurrentActQueue.current = null;
-        } // Return a thenable. If the user awaits it, we'll flush again in
-        // case additional work was scheduled by a microtask.
+        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error$1.message] = true;
+          setCurrentlyValidatingElement(element);
 
+          error('Failed %s type: %s', location, error$1.message);
 
-        var _thenable = {
-          then: function (resolve, reject) {
-            // Confirm we haven't re-entered another `act` scope, in case
-            // the user does something weird like await the thenable
-            // multiple times.
-            if (ReactCurrentActQueue.current === null) {
-              // Recursively flush the queue until there's no remaining work.
-              ReactCurrentActQueue.current = [];
-              recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-            } else {
-              resolve(returnValue);
-            }
-          }
-        };
-        return _thenable;
-      } else {
-        // Since we're inside a nested `act` scope, the returned thenable
-        // immediately resolves. The outer scope will flush the queue.
-        var _thenable2 = {
-          then: function (resolve, reject) {
-            resolve(returnValue);
-          }
-        };
-        return _thenable2;
+          setCurrentlyValidatingElement(null);
+        }
       }
     }
   }
 }
 
-function popActScope(prevActScopeDepth) {
-  {
-    if (prevActScopeDepth !== actScopeDepth - 1) {
-      error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
-    }
-
-    actScopeDepth = prevActScopeDepth;
-  }
-}
-
-function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+function setCurrentlyValidatingElement$1(element) {
   {
-    var queue = ReactCurrentActQueue.current;
-
-    if (queue !== null) {
-      try {
-        flushActQueue(queue);
-        enqueueTask(function () {
-          if (queue.length === 0) {
-            // No additional work was scheduled. Finish.
-            ReactCurrentActQueue.current = null;
-            resolve(returnValue);
-          } else {
-            // Keep flushing work until there's none left.
-            recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-          }
-        });
-      } catch (error) {
-        reject(error);
-      }
+    if (element) {
+      var owner = element._owner;
+      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+      setExtraStackFrame(stack);
     } else {
-      resolve(returnValue);
+      setExtraStackFrame(null);
     }
   }
 }
 
-var isFlushing = false;
-
-function flushActQueue(queue) {
-  {
-    if (!isFlushing) {
-      // Prevent re-entrance.
-      isFlushing = true;
-      var i = 0;
+var propTypesMisspellWarningShown;
 
-      try {
-        for (; i < queue.length; i++) {
-          var callback = queue[i];
+{
+  propTypesMisspellWarningShown = false;
+}
 
-          do {
-            callback = callback(true);
-          } while (callback !== null);
-        }
+function getDeclarationErrorAddendum() {
+  if (ReactCurrentOwner.current) {
+    var name = getComponentNameFromType(ReactCurrentOwner.current.type);
 
-        queue.length = 0;
-      } catch (error) {
-        // If something throws, leave the remaining callbacks on the queue.
-        queue = queue.slice(i + 1);
-        throw error;
-      } finally {
-        isFlushing = false;
-      }
+    if (name) {
+      return '\n\nCheck the render method of `' + name + '`.';
     }
   }
-}
-
-var createElement$1 =  createElementWithValidation ;
-var cloneElement$1 =  cloneElementWithValidation ;
-var createFactory =  createFactoryWithValidation ;
-var Children = {
-  map: mapChildren,
-  forEach: forEachChildren,
-  count: countChildren,
-  toArray: toArray,
-  only: onlyChild
-};
-
-exports.Children = Children;
-exports.Component = Component;
-exports.Fragment = REACT_FRAGMENT_TYPE;
-exports.Profiler = REACT_PROFILER_TYPE;
-exports.PureComponent = PureComponent;
-exports.StrictMode = REACT_STRICT_MODE_TYPE;
-exports.Suspense = REACT_SUSPENSE_TYPE;
-exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
-exports.cloneElement = cloneElement$1;
-exports.createContext = createContext;
-exports.createElement = createElement$1;
-exports.createFactory = createFactory;
-exports.createRef = createRef;
-exports.forwardRef = forwardRef;
-exports.isValidElement = isValidElement;
-exports.lazy = lazy;
-exports.memo = memo;
-exports.startTransition = startTransition;
-exports.unstable_act = act;
-exports.useCallback = useCallback;
-exports.useContext = useContext;
-exports.useDebugValue = useDebugValue;
-exports.useDeferredValue = useDeferredValue;
-exports.useEffect = useEffect;
-exports.useId = useId;
-exports.useImperativeHandle = useImperativeHandle;
-exports.useInsertionEffect = useInsertionEffect;
-exports.useLayoutEffect = useLayoutEffect;
-exports.useMemo = useMemo;
-exports.useReducer = useReducer;
-exports.useRef = useRef;
-exports.useState = useState;
-exports.useSyncExternalStore = useSyncExternalStore;
-exports.useTransition = useTransition;
-exports.version = ReactVersion;
-          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-if (
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
-    'function'
-) {
-  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
-}
-        
-  })();
-}
-
-
-/***/ }),
-
-/***/ "../../../node_modules/react/index.js":
-/*!********************************************!*\
-  !*** ../../../node_modules/react/index.js ***!
-  \********************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
-
-
-if (false) {} else {
-  module.exports = __webpack_require__(/*! ./cjs/react.development.js */ "../../../node_modules/react/cjs/react.development.js");
+  return '';
 }
 
+function getSourceInfoErrorAddendum(source) {
+  if (source !== undefined) {
+    var fileName = source.fileName.replace(/^.*[\\\/]/, '');
+    var lineNumber = source.lineNumber;
+    return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
+  }
 
-/***/ }),
-
-/***/ "../../../node_modules/resolve-pathname/esm/resolve-pathname.js":
-/*!**********************************************************************!*\
-  !*** ../../../node_modules/resolve-pathname/esm/resolve-pathname.js ***!
-  \**********************************************************************/
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-function isAbsolute(pathname) {
-  return pathname.charAt(0) === '/';
+  return '';
 }
 
-// About 1.5x faster than the two-arg version of Array#splice()
-function spliceOne(list, index) {
-  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) {
-    list[i] = list[k];
+function getSourceInfoErrorAddendumForProps(elementProps) {
+  if (elementProps !== null && elementProps !== undefined) {
+    return getSourceInfoErrorAddendum(elementProps.__source);
   }
 
-  list.pop();
+  return '';
 }
+/**
+ * Warn if there's no key explicitly set on dynamic arrays of children or
+ * object keys are not valid. This allows us to keep track of children between
+ * updates.
+ */
 
-// This implementation is based heavily on node's url.parse
-function resolvePathname(to, from) {
-  if (from === undefined) from = '';
-
-  var toParts = (to && to.split('/')) || [];
-  var fromParts = (from && from.split('/')) || [];
-
-  var isToAbs = to && isAbsolute(to);
-  var isFromAbs = from && isAbsolute(from);
-  var mustEndAbs = isToAbs || isFromAbs;
-
-  if (to && isAbsolute(to)) {
-    // to is absolute
-    fromParts = toParts;
-  } else if (toParts.length) {
-    // to is relative, drop the filename
-    fromParts.pop();
-    fromParts = fromParts.concat(toParts);
-  }
 
-  if (!fromParts.length) return '/';
+var ownerHasKeyUseWarning = {};
 
-  var hasTrailingSlash;
-  if (fromParts.length) {
-    var last = fromParts[fromParts.length - 1];
-    hasTrailingSlash = last === '.' || last === '..' || last === '';
-  } else {
-    hasTrailingSlash = false;
-  }
+function getCurrentComponentErrorInfo(parentType) {
+  var info = getDeclarationErrorAddendum();
 
-  var up = 0;
-  for (var i = fromParts.length; i >= 0; i--) {
-    var part = fromParts[i];
+  if (!info) {
+    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
 
-    if (part === '.') {
-      spliceOne(fromParts, i);
-    } else if (part === '..') {
-      spliceOne(fromParts, i);
-      up++;
-    } else if (up) {
-      spliceOne(fromParts, i);
-      up--;
+    if (parentName) {
+      info = "\n\nCheck the top-level render call using <" + parentName + ">.";
     }
   }
 
-  if (!mustEndAbs) for (; up--; up) fromParts.unshift('..');
+  return info;
+}
+/**
+ * Warn if the element doesn't have an explicit key assigned to it.
+ * This element is in an array. The array could grow and shrink or be
+ * reordered. All children that haven't already been validated are required to
+ * have a "key" property assigned to it. Error statuses are cached so a warning
+ * will only be shown once.
+ *
+ * @internal
+ * @param {ReactElement} element Element that requires a key.
+ * @param {*} parentType element's parent's type.
+ */
+
 
-  if (
-    mustEndAbs &&
-    fromParts[0] !== '' &&
-    (!fromParts[0] || !isAbsolute(fromParts[0]))
-  )
-    fromParts.unshift('');
+function validateExplicitKey(element, parentType) {
+  if (!element._store || element._store.validated || element.key != null) {
+    return;
+  }
 
-  var result = fromParts.join('/');
+  element._store.validated = true;
+  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
 
-  if (hasTrailingSlash && result.substr(-1) !== '/') result += '/';
+  if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+    return;
+  }
 
-  return result;
-}
+  ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
+  // property, it may be the creator of the child that's responsible for
+  // assigning it a key.
 
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (resolvePathname);
+  var childOwner = '';
+
+  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
+    // Give the component that originally created this child.
+    childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+  }
 
+  {
+    setCurrentlyValidatingElement$1(element);
 
-/***/ }),
+    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
 
-/***/ "../../../node_modules/systemjs/dist/extras/named-register.js":
-/*!********************************************************************!*\
-  !*** ../../../node_modules/systemjs/dist/extras/named-register.js ***!
-  \********************************************************************/
-/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
-
-(function(){/*
- * SystemJS named register extension
- * Supports System.register('name', [..deps..], function (_export, _context) { ... })
- * 
- * Names are written to the registry as-is
- * System.register('x', ...) can be imported as System.import('x')
+    setCurrentlyValidatingElement$1(null);
+  }
+}
+/**
+ * Ensure that every element either is passed in a static location, in an
+ * array with an explicit keys property defined, or in an object literal
+ * with valid key property.
+ *
+ * @internal
+ * @param {ReactNode} node Statically passed child of any type.
+ * @param {*} parentType node's parent's type.
  */
-(function (global) {
-  var System = global.System;
-  setRegisterRegistry(System);
-  var systemJSPrototype = System.constructor.prototype;
-  var constructor = System.constructor;
-  var SystemJS = function () {
-    constructor.call(this);
-    setRegisterRegistry(this);
-  };
-  SystemJS.prototype = systemJSPrototype;
-  System.constructor = SystemJS;
 
-  var firstNamedDefine, firstName;
 
-  function setRegisterRegistry(systemInstance) {
-    systemInstance.registerRegistry = Object.create(null);
-    systemInstance.namedRegisterAliases = Object.create(null);
+function validateChildKeys(node, parentType) {
+  if (typeof node !== 'object') {
+    return;
   }
 
-  var register = systemJSPrototype.register;
-  systemJSPrototype.register = function (name, deps, declare) {
-    if (typeof name !== 'string')
-      return register.apply(this, arguments);
-    var define = [deps, declare];
-    this.registerRegistry[name] = define;
-    if (!firstNamedDefine) {
-      firstNamedDefine = define;
-      firstName = name;
-    }
-    Promise.resolve().then(function () {
-      firstNamedDefine = null;
-      firstName = null;
-    });
-    return register.apply(this, [deps, declare]);
-  };
+  if (isArray(node)) {
+    for (var i = 0; i < node.length; i++) {
+      var child = node[i];
 
-  var resolve = systemJSPrototype.resolve;
-  systemJSPrototype.resolve = function (id, parentURL) {
-    try {
-      // Prefer import map (or other existing) resolution over the registerRegistry
-      return resolve.call(this, id, parentURL);
-    } catch (err) {
-      if (id in this.registerRegistry) {
-        return this.namedRegisterAliases[id] || id;
+      if (isValidElement(child)) {
+        validateExplicitKey(child, parentType);
       }
-      throw err;
     }
-  };
-
-  var instantiate = systemJSPrototype.instantiate;
-  systemJSPrototype.instantiate = function (url, firstParentUrl) {
-    var result = this.registerRegistry[url];
-    if (result) {
-      this.registerRegistry[url] = null;
-      return result;
-    } else {
-      return instantiate.call(this, url, firstParentUrl);
+  } else if (isValidElement(node)) {
+    // This element was passed in a valid location.
+    if (node._store) {
+      node._store.validated = true;
     }
-  };
+  } else if (node) {
+    var iteratorFn = getIteratorFn(node);
 
-  var getRegister = systemJSPrototype.getRegister;
-  systemJSPrototype.getRegister = function (url) {
-    // Calling getRegister() because other extras need to know it was called so they can perform side effects
-    var register = getRegister.call(this, url);
+    if (typeof iteratorFn === 'function') {
+      // Entry iterators used to provide implicit keys,
+      // but now we print a separate warning for them later.
+      if (iteratorFn !== node.entries) {
+        var iterator = iteratorFn.call(node);
+        var step;
 
-    if (firstName && url) {
-      this.namedRegisterAliases[firstName] = url;
+        while (!(step = iterator.next()).done) {
+          if (isValidElement(step.value)) {
+            validateExplicitKey(step.value, parentType);
+          }
+        }
+      }
     }
-    var result = firstNamedDefine || register;
-    firstNamedDefine = null;
-    firstName = null;
-    return result;
-  };
-})(typeof self !== 'undefined' ? self : __webpack_require__.g);})();
+  }
+}
+/**
+ * Given an element, validate that its props follow the propTypes definition,
+ * provided by the type.
+ *
+ * @param {ReactElement} element
+ */
 
-/***/ }),
 
-/***/ "../../../node_modules/systemjs/dist/system.js":
-/*!*****************************************************!*\
-  !*** ../../../node_modules/systemjs/dist/system.js ***!
-  \*****************************************************/
-/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+function validatePropTypes(element) {
+  {
+    var type = element.type;
 
-/*
-* SystemJS 6.12.1
-*/
-(function () {
+    if (type === null || type === undefined || typeof type === 'string') {
+      return;
+    }
 
-  function errMsg(errCode, msg) {
-    return (msg || "") + " (SystemJS Error#" + errCode + " " + "https://git.io/JvFET#" + errCode + ")";
-  }
+    var propTypes;
+
+    if (typeof type === 'function') {
+      propTypes = type.propTypes;
+    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
+    // Inner props are checked in the reconciler.
+    type.$$typeof === REACT_MEMO_TYPE)) {
+      propTypes = type.propTypes;
+    } else {
+      return;
+    }
 
-  var hasSymbol = typeof Symbol !== 'undefined';
-  var hasSelf = typeof self !== 'undefined';
-  var hasDocument = typeof document !== 'undefined';
+    if (propTypes) {
+      // Intentionally inside to avoid triggering lazy initializers:
+      var name = getComponentNameFromType(type);
+      checkPropTypes(propTypes, element.props, 'prop', name, element);
+    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
 
-  var envGlobal = hasSelf ? self : __webpack_require__.g;
+      var _name = getComponentNameFromType(type);
 
-  var baseUrl;
+      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
+    }
 
-  if (hasDocument) {
-    var baseEl = document.querySelector('base[href]');
-    if (baseEl)
-      baseUrl = baseEl.href;
+    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
+      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
+    }
   }
+}
+/**
+ * Given a fragment, validate that it can only be provided with fragment props
+ * @param {ReactElement} fragment
+ */
 
-  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] === '/'));
-      }
+function validateFragmentProps(fragment) {
+  {
+    var keys = Object.keys(fragment.props);
 
-      if (relUrl[0] === '/')
-        return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
 
-      // 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;
+      if (key !== 'children' && key !== 'key') {
+        setCurrentlyValidatingElement$1(fragment);
 
-      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;
-          }
-        }
+        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
 
-        // 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;
-        }
+        setCurrentlyValidatingElement$1(null);
+        break;
       }
-      // 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
-   *
-   */
+    if (fragment.ref !== null) {
+      setCurrentlyValidatingElement$1(fragment);
 
-  function resolveUrl (relUrl, parentUrl) {
-    return resolveIfNotPlainOrUrl(relUrl, parentUrl) || (relUrl.indexOf(':') !== -1 ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
-  }
+      error('Invalid attribute `ref` supplied to `React.Fragment`.');
 
-  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, 'bare specifier did not resolve');
-      }
-      else
-        outPackages[resolvedLhs] = mapped;
+      setCurrentlyValidatingElement$1(null);
     }
   }
+}
+function createElementWithValidation(type, props, children) {
+  var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
+  // succeed and there will likely be errors in render.
 
-  function resolveAndComposeImportMap (json, baseUrl, outMap) {
-    if (json.imports)
-      resolveAndComposePackages(json.imports, outMap.imports, baseUrl, outMap, null);
+  if (!validType) {
+    var info = '';
 
-    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);
+    if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
+      info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
     }
 
-    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)
-  }
+    var sourceInfo = getSourceInfoErrorAddendumForProps(props);
 
-  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, "should have a trailing '/'");
-      }
-      else
-        return pkg + id.slice(pkgName.length);
+    if (sourceInfo) {
+      info += sourceInfo;
+    } else {
+      info += getDeclarationErrorAddendum();
     }
-  }
 
-  function targetWarning (code, match, target, msg) {
-    console.warn(errMsg(code, "Package target " + msg + ", resolving target '" + target + "' for " + match));
-  }
-
-  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 typeString;
 
-  var toStringTag$1 = hasSymbol && Symbol.toStringTag;
-  var REGISTRY = hasSymbol ? Symbol() : '@';
+    if (type === null) {
+      typeString = 'null';
+    } else if (isArray(type)) {
+      typeString = 'array';
+    } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+      typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+      info = ' Did you accidentally export a JSX literal instead of a component?';
+    } else {
+      typeString = typeof type;
+    }
 
-  function SystemJS () {
-    this[REGISTRY] = {};
+    {
+      error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+    }
   }
 
-  var systemJSPrototype = SystemJS.prototype;
+  var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
+  // TODO: Drop this when these are no longer allowed as the type argument.
 
-  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);
-    });
-  };
+  if (element == null) {
+    return element;
+  } // Skip key warning if the type isn't valid since our key validation logic
+  // doesn't expect a non-string/function type and can throw confusing errors.
+  // We don't want exception behavior to differ between dev and prod.
+  // (Rendering will throw with a helpful message and as soon as the type is
+  // fixed, the key warnings will appear.)
 
-  // 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));
-      }
-    };
-  };
 
-  // onLoad(err, id, deps) provided for tracing / hot-reloading
-  systemJSPrototype.onload = function () {};
-  function loadToId (load) {
-    return load.id;
+  if (validType) {
+    for (var i = 2; i < arguments.length; i++) {
+      validateChildKeys(arguments[i], type);
+    }
   }
-  function triggerOnload (loader, load, err, isErrSource) {
-    loader.onload(err, load.id, load.d && load.d.map(loadToId), !!isErrSource);
-    if (err)
-      throw err;
+
+  if (type === REACT_FRAGMENT_TYPE) {
+    validateFragmentProps(element);
+  } else {
+    validatePropTypes(element);
   }
 
-  var lastRegister;
-  systemJSPrototype.register = function (deps, declare) {
-    lastRegister = [deps, declare];
-  };
+  return element;
+}
+var didWarnAboutDeprecatedCreateFactory = false;
+function createFactoryWithValidation(type) {
+  var validatedFactory = createElementWithValidation.bind(null, type);
+  validatedFactory.type = type;
 
-  /*
-   * getRegister provides the last anonymous System.register call
-   */
-  systemJSPrototype.getRegister = function () {
-    var _lastRegister = lastRegister;
-    lastRegister = undefined;
-    return _lastRegister;
-  };
+  {
+    if (!didWarnAboutDeprecatedCreateFactory) {
+      didWarnAboutDeprecatedCreateFactory = true;
 
-  function getOrCreateLoad (loader, id, firstParentUrl) {
-    var load = loader[REGISTRY][id];
-    if (load)
-      return load;
+      warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.');
+    } // Legacy hook: remove it
 
-    var importerSetters = [];
-    var ns = Object.create(null);
-    if (toStringTag$1)
-      Object.defineProperty(ns, toStringTag$1, { value: 'Module' });
-    
-    var instantiatePromise = Promise.resolve()
-    .then(function () {
-      return loader.instantiate(id, firstParentUrl);
-    })
-    .then(function (registration) {
-      if (!registration)
-        throw Error(errMsg(2, 'Module ' + id + ' did not instantiate'));
-      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;
-      triggerOnload(loader, load, err, true);
-      throw err;
-    });
+    Object.defineProperty(validatedFactory, 'type', {
+      enumerable: false,
+      get: function () {
+        warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
 
-    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;
-          });
+        Object.defineProperty(this, 'type', {
+          value: type
         });
-      }))
-      .then(function (depLoads) {
-        load.d = depLoads;
-      });
+        return type;
+      }
     });
+  }
 
-    // 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,
+  return validatedFactory;
+}
+function cloneElementWithValidation(element, props, children) {
+  var newElement = cloneElement.apply(this, arguments);
 
-      // instantiate
-      I: instantiatePromise,
-      // link
-      L: linkPromise,
-      // whether it has hoisted exports
-      h: false,
+  for (var i = 2; i < arguments.length; i++) {
+    validateChildKeys(arguments[i], newElement.type);
+  }
+
+  validatePropTypes(newElement);
+  return newElement;
+}
 
-      // On instantiate completion we have populated:
-      // dependency load records
-      d: undefined,
-      // execution function
-      e: undefined,
+function startTransition(scope, options) {
+  var prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = {};
+  var currentTransition = ReactCurrentBatchConfig.transition;
 
-      // On execution we have populated:
-      // the execution error if any
-      er: undefined,
-      // in the case of TLA, the execution promise
-      E: undefined,
+  {
+    ReactCurrentBatchConfig.transition._updatedFibers = new Set();
+  }
 
-      // On execution, L, I, E cleared
+  try {
+    scope();
+  } finally {
+    ReactCurrentBatchConfig.transition = prevTransition;
 
-      // Promise for top-level completion
-      C: undefined,
+    {
+      if (prevTransition === null && currentTransition._updatedFibers) {
+        var updatedFibersCount = currentTransition._updatedFibers.size;
 
-      // parent instantiator / executor
-      p: undefined
-    };
-  }
+        if (updatedFibersCount > 10) {
+          warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.');
+        }
 
-  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;
-        triggerOnload(loader, load, err, false);
-        throw err;
-      });
+        currentTransition._updatedFibers.clear();
+      }
     }
   }
+}
 
-  function topLevelLoad (loader, load) {
-    return load.C = instantiateAll(loader, load, load, {})
-    .then(function () {
-      return postOrderExec(loader, load, {});
-    })
-    .then(function () {
-      return load.n;
-    });
+var didWarnAboutMessageChannel = false;
+var enqueueTaskImpl = null;
+function enqueueTask(task) {
+  if (enqueueTaskImpl === null) {
+    try {
+      // read require off the module object to get around the bundlers.
+      // we don't want them to detect a require and bundle a Node polyfill.
+      var requireString = ('require' + Math.random()).slice(0, 7);
+      var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
+      // version of setImmediate, bypassing fake timers if any.
+
+      enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;
+    } catch (_err) {
+      // we're in a browser
+      // we can't use regular timers because they may still be faked
+      // so we try MessageChannel+postMessage instead
+      enqueueTaskImpl = function (callback) {
+        {
+          if (didWarnAboutMessageChannel === false) {
+            didWarnAboutMessageChannel = true;
+
+            if (typeof MessageChannel === 'undefined') {
+              error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');
+            }
+          }
+        }
+
+        var channel = new MessageChannel();
+        channel.port1.onmessage = callback;
+        channel.port2.postMessage(undefined);
+      };
+    }
   }
 
-  // the closest we can get to call(undefined)
-  var nullContext = Object.freeze(Object.create(null));
+  return enqueueTaskImpl(task);
+}
 
-  // 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;
+var actScopeDepth = 0;
+var didWarnNoAwaitAct = false;
+function act(callback) {
+  {
+    // `act` calls can be nested, so we track the depth. This represents the
+    // number of `act` scopes on the stack.
+    var prevActScopeDepth = actScopeDepth;
+    actScopeDepth++;
 
-    if (!load.e) {
-      if (load.er)
-        throw load.er;
-      if (load.E)
-        return load.E;
-      return;
+    if (ReactCurrentActQueue.current === null) {
+      // This is the outermost `act` scope. Initialize the queue. The reconciler
+      // will detect the queue and use it instead of Scheduler.
+      ReactCurrentActQueue.current = [];
     }
 
-    // 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;
-        triggerOnload(loader, load, err, false);
-        throw err;
+    var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
+    var result;
+
+    try {
+      // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
+      // set to `true` while the given callback is executed, not for updates
+      // triggered during an async event, because this is how the legacy
+      // implementation of `act` behaved.
+      ReactCurrentActQueue.isBatchingLegacy = true;
+      result = callback(); // Replicate behavior of original `act` implementation in legacy mode,
+      // which flushed updates immediately after the scope function exits, even
+      // if it's an async function.
+
+      if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
+        var queue = ReactCurrentActQueue.current;
+
+        if (queue !== null) {
+          ReactCurrentActQueue.didScheduleLegacyUpdate = false;
+          flushActQueue(queue);
+        }
       }
-    });
-    if (depLoadPromises)
-      return Promise.all(depLoadPromises).then(doExec);
+    } catch (error) {
+      popActScope(prevActScopeDepth);
+      throw error;
+    } finally {
+      ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
+    }
+
+    if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
+      var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait
+      // for it to resolve before exiting the current scope.
 
-    return doExec();
+      var wasAwaited = false;
+      var thenable = {
+        then: function (resolve, reject) {
+          wasAwaited = true;
+          thenableResult.then(function (returnValue) {
+            popActScope(prevActScopeDepth);
 
-    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) triggerOnload(loader, load, null, true);
-          }, function (err) {
-            load.er = err;
-            load.E = null;
-            if (true) triggerOnload(loader, load, err, true);
-            throw err;
+            if (actScopeDepth === 0) {
+              // We've exited the outermost act scope. Recursively flush the
+              // queue until there's no remaining work.
+              recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+            } else {
+              resolve(returnValue);
+            }
+          }, function (error) {
+            // The callback threw an error.
+            popActScope(prevActScopeDepth);
+            reject(error);
+          });
+        }
+      };
+
+      {
+        if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') {
+          // eslint-disable-next-line no-undef
+          Promise.resolve().then(function () {}).then(function () {
+            if (!wasAwaited) {
+              didWarnNoAwaitAct = true;
+
+              error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);');
+            }
           });
-          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;
-        triggerOnload(loader, load, load.er, true);
       }
-    }
-  }
 
-  envGlobal.System = new SystemJS();
+      return thenable;
+    } else {
+      var returnValue = result; // The callback is not an async function. Exit the current scope
+      // immediately, without awaiting.
 
-  /*
-   * SystemJS browser attachments for script and import map processing
-   */
+      popActScope(prevActScopeDepth);
 
-  var importMapPromise = Promise.resolve();
-  var importMap = { imports: {}, scopes: {}, depcache: {}, integrity: {} };
+      if (actScopeDepth === 0) {
+        // Exiting the outermost act scope. Flush the queue.
+        var _queue = ReactCurrentActQueue.current;
 
-  // 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);
-  }
+        if (_queue !== null) {
+          flushActQueue(_queue);
+          ReactCurrentActQueue.current = null;
+        } // Return a thenable. If the user awaits it, we'll flush again in
+        // case additional work was scheduled by a microtask.
 
-  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);
+
+        var _thenable = {
+          then: function (resolve, reject) {
+            // Confirm we haven't re-entered another `act` scope, in case
+            // the user does something weird like await the thenable
+            // multiple times.
+            if (ReactCurrentActQueue.current === null) {
+              // Recursively flush the queue until there's no remaining work.
+              ReactCurrentActQueue.current = [];
+              recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+            } else {
+              resolve(returnValue);
+            }
           }
-          return Promise.reject(e);
-        });
-      }
-      else if (script.type === 'systemjs-importmap') {
-        script.sp = true;
-        // The passThrough property is for letting the module types fetch implementation know that this is not a SystemJS module.
-        var fetchPromise = script.src ? (System.fetch || fetch)(script.src, { integrity: script.integrity, passThrough: true }).then(function (res) {
-          if (!res.ok)
-            throw Error('Invalid status code: ' + res.status);
-          return res.text();
-        }).catch(function (err) {
-          err.message = errMsg('W4', 'Error fetching systemjs-import map ' + script.src) + '\n' + err.message;
-          console.warn(err);
-          if (typeof script.onerror === 'function') {
-              script.onerror();
+        };
+        return _thenable;
+      } else {
+        // Since we're inside a nested `act` scope, the returned thenable
+        // immediately resolves. The outer scope will flush the queue.
+        var _thenable2 = {
+          then: function (resolve, reject) {
+            resolve(returnValue);
           }
-          return '{}';
-        }) : script.innerHTML;
-        importMapPromise = importMapPromise.then(function () {
-          return fetchPromise;
-        }).then(function (text) {
-          extendImportMap(importMap, text, script.src || baseUrl);
-        });
+        };
+        return _thenable2;
       }
-    });
-  }
-
-  function extendImportMap (importMap, newMapText, newMapUrl) {
-    var newMap = {};
-    try {
-      newMap = JSON.parse(newMapText);
-    } catch (err) {
-      console.warn(Error((errMsg('W5', "systemjs-importmap contains invalid JSON") + '\n\n' + newMapText + '\n' )));
     }
-    resolveAndComposeImportMap(newMap, newMapUrl, importMap);
   }
+}
 
-  /*
-   * Script instantiation loading
-   */
+function popActScope(prevActScopeDepth) {
+  {
+    if (prevActScopeDepth !== actScopeDepth - 1) {
+      error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
+    }
 
-  if (hasDocument) {
-    window.addEventListener('error', function (evt) {
-      lastWindowErrorUrl = evt.filename;
-      lastWindowError = evt.error;
-    });
-    var baseOrigin = location.origin;
+    actScopeDepth = prevActScopeDepth;
   }
+}
 
-  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;
-  };
+function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+  {
+    var queue = ReactCurrentActQueue.current;
 
-  // Auto imports -> script tags can be inlined directly for load phase
-  var lastAutoImportDeps, lastAutoImportTimeout;
-  var autoImportCandidates = {};
-  var systemRegister = systemJSPrototype.register;
-  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];
-      if (lastScript) {
-        lastAutoImportDeps = deps;
-        // 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[lastScript.src] = [deps, declare];
-          loader.import(lastScript.src);
+    if (queue !== null) {
+      try {
+        flushActQueue(queue);
+        enqueueTask(function () {
+          if (queue.length === 0) {
+            // No additional work was scheduled. Finish.
+            ReactCurrentActQueue.current = null;
+            resolve(returnValue);
+          } else {
+            // Keep flushing work until there's none left.
+            recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+          }
         });
+      } catch (error) {
+        reject(error);
       }
+    } else {
+      resolve(returnValue);
     }
-    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, 'Error loading ' + url + (firstParentUrl ? ' from ' + firstParentUrl : ''))));
-        });
-        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 + ', loading ' + url + (parent ? ' from ' + parent : '')));
-      var contentType = res.headers.get('content-type');
-      if (!contentType || !jsContentTypeRegEx.test(contentType))
-        throw Error(errMsg(4, 'Unknown Content-Type "' + contentType + '", loading ' + url + (parent ? ' from ' + parent : '')));
-      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, "Unable to resolve bare specifier '" + id + (parentUrl ? "' from " + parentUrl : "'")));
   }
+}
 
-  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
-   */
+var isFlushing = false;
 
-  if (hasSelf && typeof importScripts === 'function')
-    systemJSPrototype.instantiate = function (url) {
-      var loader = this;
-      return Promise.resolve().then(function () {
-        importScripts(url);
-        return loader.getRegister(url);
-      });
-    };
+function flushActQueue(queue) {
+  {
+    if (!isFlushing) {
+      // Prevent re-entrance.
+      isFlushing = true;
+      var i = 0;
 
-  /*
-   * SystemJS global script loading support
-   * Extra for the s.js build only
-   * (Included by default in system.js build)
-   */
-  (function (global) {
-    var systemJSPrototype = global.System.constructor.prototype;
+      try {
+        for (; i < queue.length; i++) {
+          var callback = queue[i];
 
-    // safari unpredictably lists some new globals first or second in object order
-    var firstGlobalProp, secondGlobalProp, lastGlobalProp;
-    function getGlobalProp (useFirstGlobalProp) {
-      var cnt = 0;
-      var foundLastProp, result;
-      for (var p in global) {
-        // do not check frames cause it could be removed during import
-        if (shouldSkipProperty(p))
-          continue;
-        if (cnt === 0 && p !== firstGlobalProp || cnt === 1 && p !== secondGlobalProp)
-          return p;
-        if (foundLastProp) {
-          lastGlobalProp = p;
-          result = useFirstGlobalProp && result || p;
-        }
-        else {
-          foundLastProp = p === lastGlobalProp;
+          do {
+            callback = callback(true);
+          } while (callback !== null);
         }
-        cnt++;
-      }
-      return result;
-    }
 
-    function noteGlobalProps () {
-      // alternatively Object.keys(global).pop()
-      // but this may be faster (pending benchmarks)
-      firstGlobalProp = secondGlobalProp = undefined;
-      for (var p in global) {
-        // do not check frames cause it could be removed during import
-        if (shouldSkipProperty(p))
-          continue;
-        if (!firstGlobalProp)
-          firstGlobalProp = p;
-        else if (!secondGlobalProp)
-          secondGlobalProp = p;
-        lastGlobalProp = p;
+        queue.length = 0;
+      } catch (error) {
+        // If something throws, leave the remaining callbacks on the queue.
+        queue = queue.slice(i + 1);
+        throw error;
+      } finally {
+        isFlushing = false;
       }
-      return lastGlobalProp;
     }
+  }
+}
 
-    var impt = systemJSPrototype.import;
-    systemJSPrototype.import = function (id, parentUrl) {
-      noteGlobalProps();
-      return impt.call(this, id, parentUrl);
-    };
+var createElement$1 =  createElementWithValidation ;
+var cloneElement$1 =  cloneElementWithValidation ;
+var createFactory =  createFactoryWithValidation ;
+var Children = {
+  map: mapChildren,
+  forEach: forEachChildren,
+  count: countChildren,
+  toArray: toArray,
+  only: onlyChild
+};
+
+exports.Children = Children;
+exports.Component = Component;
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.Profiler = REACT_PROFILER_TYPE;
+exports.PureComponent = PureComponent;
+exports.StrictMode = REACT_STRICT_MODE_TYPE;
+exports.Suspense = REACT_SUSPENSE_TYPE;
+exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+exports.cloneElement = cloneElement$1;
+exports.createContext = createContext;
+exports.createElement = createElement$1;
+exports.createFactory = createFactory;
+exports.createRef = createRef;
+exports.forwardRef = forwardRef;
+exports.isValidElement = isValidElement;
+exports.lazy = lazy;
+exports.memo = memo;
+exports.startTransition = startTransition;
+exports.unstable_act = act;
+exports.useCallback = useCallback;
+exports.useContext = useContext;
+exports.useDebugValue = useDebugValue;
+exports.useDeferredValue = useDeferredValue;
+exports.useEffect = useEffect;
+exports.useId = useId;
+exports.useImperativeHandle = useImperativeHandle;
+exports.useInsertionEffect = useInsertionEffect;
+exports.useLayoutEffect = useLayoutEffect;
+exports.useMemo = useMemo;
+exports.useReducer = useReducer;
+exports.useRef = useRef;
+exports.useState = useState;
+exports.useSyncExternalStore = useSyncExternalStore;
+exports.useTransition = useTransition;
+exports.version = ReactVersion;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
+  })();
+}
 
-    var emptyInstantiation = [[], function () { return {} }];
 
-    var getRegister = systemJSPrototype.getRegister;
-    systemJSPrototype.getRegister = function () {
-      var 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
-      var globalProp = getGlobalProp(this.firstGlobalProp);
-      if (!globalProp)
-        return emptyInstantiation;
+/***/ }),
 
-      var globalExport;
-      try {
-        globalExport = global[globalProp];
-      }
-      catch (e) {
-        return emptyInstantiation;
-      }
+/***/ "../../../node_modules/react/index.js":
+/*!********************************************!*\
+  !*** ../../../node_modules/react/index.js ***!
+  \********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-      return [[], function (_export) {
-        return {
-          execute: function () {
-            _export(globalExport);
-            _export({ default: globalExport, __useDefault: true });
-          }
-        };
-      }];
-    };
+"use strict";
 
-    var isIE11 = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('Trident') !== -1;
 
-    function shouldSkipProperty(p) {
-      return !global.hasOwnProperty(p)
-        || !isNaN(p) && p < global.length
-        || isIE11 && global[p] && typeof window !== 'undefined' && global[p].parent === window;
-    }
-  })(typeof self !== 'undefined' ? self : __webpack_require__.g);
+if (false) {} else {
+  module.exports = __webpack_require__(/*! ./cjs/react.development.js */ "../../../node_modules/react/cjs/react.development.js");
+}
 
-  /*
-   * Loads JSON, CSS, Wasm module types based on file extension
-   * filters and content type verifications
-   */
-  (function(global) {
-    var systemJSPrototype = global.System.constructor.prototype;
 
-    var moduleTypesRegEx = /^[^#?]+\.(css|html|json|wasm)([?#].*)?$/;
-    systemJSPrototype.shouldFetch = function (url) {
-      return moduleTypesRegEx.test(url);
-    };
+/***/ }),
 
-    var jsonContentType = /^application\/json(;|$)/;
-    var cssContentType = /^text\/css(;|$)/;
-    var wasmContentType = /^application\/wasm(;|$)/;
+/***/ "../../../node_modules/resolve-pathname/esm/resolve-pathname.js":
+/*!**********************************************************************!*\
+  !*** ../../../node_modules/resolve-pathname/esm/resolve-pathname.js ***!
+  \**********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-    var fetch = systemJSPrototype.fetch;
-    systemJSPrototype.fetch = function (url, options) {
-      return fetch(url, options)
-      .then(function (res) {
-        if (options.passThrough)
-          return res;
-
-        if (!res.ok)
-          return res;
-        var contentType = res.headers.get('content-type');
-        if (jsonContentType.test(contentType))
-          return res.json()
-          .then(function (json) {
-            return new Response(new Blob([
-              'System.register([],function(e){return{execute:function(){e("default",' + JSON.stringify(json) + ')}}})'
-            ], {
-              type: 'application/javascript'
-            }));
-          });
-        if (cssContentType.test(contentType))
-          return res.text()
-          .then(function (source) {
-            source = source.replace(/url\(\s*(?:(["'])((?:\\.|[^\n\\"'])+)\1|((?:\\.|[^\s,"'()\\])+))\s*\)/g, function (match, quotes, relUrl1, relUrl2) {
-              return 'url(' + quotes + resolveUrl(relUrl1 || relUrl2, url) + quotes + ')';
-            });
-            return new Response(new Blob([
-              'System.register([],function(e){return{execute:function(){var s=new CSSStyleSheet();s.replaceSync(' + JSON.stringify(source) + ');e("default",s)}}})'
-            ], {
-              type: 'application/javascript'
-            }));
-          });
-        if (wasmContentType.test(contentType))
-          return (WebAssembly.compileStreaming ? WebAssembly.compileStreaming(res) : res.arrayBuffer().then(WebAssembly.compile))
-          .then(function (module) {
-            if (!global.System.wasmModules)
-              global.System.wasmModules = Object.create(null);
-            global.System.wasmModules[url] = module;
-            // we can only set imports if supported (eg early Safari doesnt support)
-            var deps = [];
-            var setterSources = [];
-            if (WebAssembly.Module.imports)
-              WebAssembly.Module.imports(module).forEach(function (impt) {
-                var key = JSON.stringify(impt.module);
-                if (deps.indexOf(key) === -1) {
-                  deps.push(key);
-                  setterSources.push('function(m){i[' + key + ']=m}');
-                }
-              });
-            return new Response(new Blob([
-              'System.register([' + deps.join(',') + '],function(e){var i={};return{setters:[' + setterSources.join(',') +
-              '],execute:function(){return WebAssembly.instantiate(System.wasmModules[' + JSON.stringify(url) +
-              '],i).then(function(m){e(m.exports)})}}})'
-            ], {
-              type: 'application/javascript'
-            }));
-          });
-        return res;
-      });
-    };
-  })(typeof self !== 'undefined' ? self : __webpack_require__.g);
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+function isAbsolute(pathname) {
+  return pathname.charAt(0) === '/';
+}
 
-  var toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
+// About 1.5x faster than the two-arg version of Array#splice()
+function spliceOne(list, index) {
+  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) {
+    list[i] = list[k];
+  }
 
-  systemJSPrototype.get = function (id) {
-    var load = this[REGISTRY][id];
-    if (load && load.e === null && !load.E) {
-      if (load.er)
-        return null;
-      return load.n;
-    }
-  };
+  list.pop();
+}
 
-  systemJSPrototype.set = function (id, module) {
-    {
-      try {
-        // No page-relative URLs allowed
-        new URL(id);
-      } catch (err) {
-        console.warn(Error(errMsg('W3', '"' + id + '" is not a valid URL to set in the module registry')));
-      }
-    }
-    var ns;
-    if (toStringTag && module[toStringTag] === 'Module') {
-      ns = module;
-    }
-    else {
-      ns = Object.assign(Object.create(null), module);
-      if (toStringTag)
-        Object.defineProperty(ns, toStringTag, { value: 'Module' });
-    }
+// This implementation is based heavily on node's url.parse
+function resolvePathname(to, from) {
+  if (from === undefined) from = '';
 
-    var done = Promise.resolve(ns);
+  var toParts = (to && to.split('/')) || [];
+  var fromParts = (from && from.split('/')) || [];
 
-    var load = this[REGISTRY][id] || (this[REGISTRY][id] = {
-      id: id,
-      i: [],
-      h: false,
-      d: [],
-      e: null,
-      er: undefined,
-      E: undefined
-    });
+  var isToAbs = to && isAbsolute(to);
+  var isFromAbs = from && isAbsolute(from);
+  var mustEndAbs = isToAbs || isFromAbs;
 
-    if (load.e || load.E)
-      return false;
-    
-    Object.assign(load, {
-      n: ns,
-      I: undefined,
-      L: undefined,
-      C: done
-    });
-    return ns;
-  };
+  if (to && isAbsolute(to)) {
+    // to is absolute
+    fromParts = toParts;
+  } else if (toParts.length) {
+    // to is relative, drop the filename
+    fromParts.pop();
+    fromParts = fromParts.concat(toParts);
+  }
 
-  systemJSPrototype.has = function (id) {
-    var load = this[REGISTRY][id];
-    return !!load;
-  };
+  if (!fromParts.length) return '/';
 
-  // Delete function provided for hot-reloading use cases
-  systemJSPrototype.delete = function (id) {
-    var registry = this[REGISTRY];
-    var load = registry[id];
-    // in future we can support load.E case by failing load first
-    // but that will require TLA callbacks to be implemented
-    if (!load || (load.p && load.p.e !== null) || load.E)
-      return false;
+  var hasTrailingSlash;
+  if (fromParts.length) {
+    var last = fromParts[fromParts.length - 1];
+    hasTrailingSlash = last === '.' || last === '..' || last === '';
+  } else {
+    hasTrailingSlash = false;
+  }
 
-    var importerSetters = load.i;
-    // remove from importerSetters
-    // (release for gc)
-    if (load.d)
-      load.d.forEach(function (depLoad) {
-        var importerIndex = depLoad.i.indexOf(load);
-        if (importerIndex !== -1)
-          depLoad.i.splice(importerIndex, 1);
-      });
-    delete registry[id];
-    return function () {
-      var load = registry[id];
-      if (!load || !importerSetters || load.e !== null || load.E)
-        return false;
-      // add back the old setters
-      importerSetters.forEach(function (setter) {
-        load.i.push(setter);
-        setter(load.n);
-      });
-      importerSetters = null;
-    };
-  };
+  var up = 0;
+  for (var i = fromParts.length; i >= 0; i--) {
+    var part = fromParts[i];
+
+    if (part === '.') {
+      spliceOne(fromParts, i);
+    } else if (part === '..') {
+      spliceOne(fromParts, i);
+      up++;
+    } else if (up) {
+      spliceOne(fromParts, i);
+      up--;
+    }
+  }
 
-  var iterator = typeof Symbol !== 'undefined' && Symbol.iterator;
+  if (!mustEndAbs) for (; up--; up) fromParts.unshift('..');
 
-  systemJSPrototype.entries = function () {
-    var loader = this, keys = Object.keys(loader[REGISTRY]);
-    var index = 0, ns, key;
-    var result = {
-      next: function () {
-        while (
-          (key = keys[index++]) !== undefined && 
-          (ns = loader.get(key)) === undefined
-        );
-        return {
-          done: key === undefined,
-          value: key !== undefined && [key, ns]
-        };
-      }
-    };
+  if (
+    mustEndAbs &&
+    fromParts[0] !== '' &&
+    (!fromParts[0] || !isAbsolute(fromParts[0]))
+  )
+    fromParts.unshift('');
+
+  var result = fromParts.join('/');
 
-    result[iterator] = function() { return this };
+  if (hasTrailingSlash && result.substr(-1) !== '/') result += '/';
 
-    return result;
-  };
+  return result;
+}
 
-})();
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (resolvePathname);
 
 
 /***/ }),
@@ -45846,4 +45586,4 @@ var instance = (0,piral_core__WEBPACK_IMPORTED_MODULE_2__.createInstance)({
 
 /******/ })()
 ;
-//# sourceMappingURL=index.21c15a.js.map
+//# sourceMappingURL=index.53636e.js.map