single-spa/lib/system/single-spa.dev.js

/* single-spa@5.9.2 - SystemJS - dev */
System.register(['single-spa'], function (exports) {
  'use strict';
  var LOAD_ERROR$1;
  return {
    setters: [function (module) {
      LOAD_ERROR$1 = module.LOAD_ERROR;
    }],
    execute: function () {

      exports({
        addErrorHandler: addErrorHandler,
        checkActivityFunctions: checkActivityFunctions,
        ensureJQuerySupport: ensureJQuerySupport,
        getAppNames: getAppNames,
        getAppStatus: getAppStatus,
        getMountedApps: getMountedApps,
        mountRootParcel: mountRootParcel,
        navigateToUrl: navigateToUrl,
        pathToActiveWhen: pathToActiveWhen,
        registerApplication: registerApplication,
        removeErrorHandler: removeErrorHandler,
        setBootstrapMaxTime: setBootstrapMaxTime,
        setMountMaxTime: setMountMaxTime,
        setUnloadMaxTime: setUnloadMaxTime,
        setUnmountMaxTime: setUnmountMaxTime,
        start: start,
        triggerAppChange: triggerAppChange,
        unloadApplication: unloadApplication,
        unregisterApplication: unregisterApplication
      });

      var singleSpa = /*#__PURE__*/Object.freeze({
        __proto__: null,
        get start () { return start; },
        get ensureJQuerySupport () { return ensureJQuerySupport; },
        get setBootstrapMaxTime () { return setBootstrapMaxTime; },
        get setMountMaxTime () { return setMountMaxTime; },
        get setUnmountMaxTime () { return setUnmountMaxTime; },
        get setUnloadMaxTime () { return setUnloadMaxTime; },
        get registerApplication () { return registerApplication; },
        get unregisterApplication () { return unregisterApplication; },
        get getMountedApps () { return getMountedApps; },
        get getAppStatus () { return getAppStatus; },
        get unloadApplication () { return unloadApplication; },
        get checkActivityFunctions () { return checkActivityFunctions; },
        get getAppNames () { return getAppNames; },
        get pathToActiveWhen () { return pathToActiveWhen; },
        get navigateToUrl () { return navigateToUrl; },
        get triggerAppChange () { return triggerAppChange; },
        get addErrorHandler () { return addErrorHandler; },
        get removeErrorHandler () { return removeErrorHandler; },
        get mountRootParcel () { return mountRootParcel; },
        get NOT_LOADED () { return NOT_LOADED; },
        get LOADING_SOURCE_CODE () { return LOADING_SOURCE_CODE; },
        get NOT_BOOTSTRAPPED () { return NOT_BOOTSTRAPPED; },
        get BOOTSTRAPPING () { return BOOTSTRAPPING; },
        get NOT_MOUNTED () { return NOT_MOUNTED; },
        get MOUNTING () { return MOUNTING; },
        get UPDATING () { return UPDATING; },
        get LOAD_ERROR () { return LOAD_ERROR; },
        get MOUNTED () { return MOUNTED; },
        get UNMOUNTING () { return UNMOUNTING; },
        get SKIP_BECAUSE_BROKEN () { return SKIP_BECAUSE_BROKEN; }
      });

      function _typeof(obj) {
        "@babel/helpers - typeof";

        if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
          _typeof = function (obj) {
            return typeof obj;
          };
        } else {
          _typeof = function (obj) {
            return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
          };
        }

        return _typeof(obj);
      }

      function _defineProperty(obj, key, value) {
        if (key in obj) {
          Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
          });
        } else {
          obj[key] = value;
        }

        return obj;
      }

      var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

      var NativeCustomEvent = commonjsGlobal.CustomEvent;

      function useNative () {
        try {
          var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });
          return  'cat' === p.type && 'bar' === p.detail.foo;
        } catch (e) {
        }
        return false;
      }

      /**
       * Cross-browser `CustomEvent` constructor.
       *
       * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent
       *
       * @public
       */

      var customEvent = useNative() ? NativeCustomEvent :

      // IE >= 9
      'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) {
        var e = document.createEvent('CustomEvent');
        if (params) {
          e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);
        } else {
          e.initCustomEvent(type, false, false, void 0);
        }
        return e;
      } :

      // IE <= 8
      function CustomEvent (type, params) {
        var e = document.createEventObject();
        e.type = type;
        if (params) {
          e.bubbles = Boolean(params.bubbles);
          e.cancelable = Boolean(params.cancelable);
          e.detail = params.detail;
        } else {
          e.bubbles = false;
          e.cancelable = false;
          e.detail = void 0;
        }
        return e;
      };

      var errorHandlers = [];
      function handleAppError(err, app, newStatus) {
        var transformedErr = transformErr(err, app, newStatus);

        if (errorHandlers.length) {
          errorHandlers.forEach(function (handler) {
            return handler(transformedErr);
          });
        } else {
          setTimeout(function () {
            throw transformedErr;
          });
        }
      }
      function addErrorHandler(handler) {
        if (typeof handler !== "function") {
          throw Error(formatErrorMessage(28,  "a single-spa error handler must be a function"));
        }

        errorHandlers.push(handler);
      }
      function removeErrorHandler(handler) {
        if (typeof handler !== "function") {
          throw Error(formatErrorMessage(29,  "a single-spa error handler must be a function"));
        }

        var removedSomething = false;
        errorHandlers = errorHandlers.filter(function (h) {
          var isHandler = h === handler;
          removedSomething = removedSomething || isHandler;
          return !isHandler;
        });
        return removedSomething;
      }
      function formatErrorMessage(code, msg) {
        for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
          args[_key - 2] = arguments[_key];
        }

        return "single-spa minified message #".concat(code, ": ").concat(msg ? msg + " " : "", "See https://single-spa.js.org/error/?code=").concat(code).concat(args.length ? "&arg=".concat(args.join("&arg=")) : "");
      }
      function transformErr(ogErr, appOrParcel, newStatus) {
        var errPrefix = "".concat(objectType(appOrParcel), " '").concat(toName(appOrParcel), "' died in status ").concat(appOrParcel.status, ": ");
        var result;

        if (ogErr instanceof Error) {
          try {
            ogErr.message = errPrefix + ogErr.message;
          } catch (err) {
            /* Some errors have read-only message properties, in which case there is nothing
             * that we can do.
             */
          }

          result = ogErr;
        } else {
          console.warn(formatErrorMessage(30,  "While ".concat(appOrParcel.status, ", '").concat(toName(appOrParcel), "' rejected its lifecycle function promise with a non-Error. This will cause stack traces to not be accurate."), appOrParcel.status, toName(appOrParcel)));

          try {
            result = Error(errPrefix + JSON.stringify(ogErr));
          } catch (err) {
            // If it's not an Error and you can't stringify it, then what else can you even do to it?
            result = ogErr;
          }
        }

        result.appOrParcelName = toName(appOrParcel); // We set the status after transforming the error so that the error message
        // references the state the application was in before the status change.

        appOrParcel.status = newStatus;
        return result;
      }

      var NOT_LOADED = exports('NOT_LOADED', "NOT_LOADED");
      var LOADING_SOURCE_CODE = exports('LOADING_SOURCE_CODE', "LOADING_SOURCE_CODE");
      var NOT_BOOTSTRAPPED = exports('NOT_BOOTSTRAPPED', "NOT_BOOTSTRAPPED");
      var BOOTSTRAPPING = exports('BOOTSTRAPPING', "BOOTSTRAPPING");
      var NOT_MOUNTED = exports('NOT_MOUNTED', "NOT_MOUNTED");
      var MOUNTING = exports('MOUNTING', "MOUNTING");
      var MOUNTED = exports('MOUNTED', "MOUNTED");
      var UPDATING = exports('UPDATING', "UPDATING");
      var UNMOUNTING = exports('UNMOUNTING', "UNMOUNTING");
      var UNLOADING = "UNLOADING";
      var LOAD_ERROR = exports('LOAD_ERROR', "LOAD_ERROR");
      var SKIP_BECAUSE_BROKEN = exports('SKIP_BECAUSE_BROKEN', "SKIP_BECAUSE_BROKEN");
      function isActive(app) {
        return app.status === MOUNTED;
      }
      function shouldBeActive(app) {
        try {
          return app.activeWhen(window.location);
        } catch (err) {
          handleAppError(err, app, SKIP_BECAUSE_BROKEN);
          return false;
        }
      }
      function toName(app) {
        return app.name;
      }
      function isParcel(appOrParcel) {
        return Boolean(appOrParcel.unmountThisParcel);
      }
      function objectType(appOrParcel) {
        return isParcel(appOrParcel) ? "parcel" : "application";
      }

      // Object.assign() is not available in IE11. And the babel compiled output for object spread
      // syntax checks a bunch of Symbol stuff and is almost a kb. So this function is the smaller replacement.
      function assign() {
        for (var i = arguments.length - 1; i > 0; i--) {
          for (var key in arguments[i]) {
            if (key === "__proto__") {
              continue;
            }

            arguments[i - 1][key] = arguments[i][key];
          }
        }

        return arguments[0];
      }

      /* the array.prototype.find polyfill on npmjs.com is ~20kb (not worth it)
       * and lodash is ~200kb (not worth it)
       */
      function find(arr, func) {
        for (var i = 0; i < arr.length; i++) {
          if (func(arr[i])) {
            return arr[i];
          }
        }

        return null;
      }

      function validLifecycleFn(fn) {
        return fn && (typeof fn === "function" || isArrayOfFns(fn));

        function isArrayOfFns(arr) {
          return Array.isArray(arr) && !find(arr, function (item) {
            return typeof item !== "function";
          });
        }
      }
      function flattenFnArray(appOrParcel, lifecycle) {
        var fns = appOrParcel[lifecycle] || [];
        fns = Array.isArray(fns) ? fns : [fns];

        if (fns.length === 0) {
          fns = [function () {
            return Promise.resolve();
          }];
        }

        var type = objectType(appOrParcel);
        var name = toName(appOrParcel);
        return function (props) {
          return fns.reduce(function (resultPromise, fn, index) {
            return resultPromise.then(function () {
              var thisPromise = fn(props);
              return smellsLikeAPromise(thisPromise) ? thisPromise : Promise.reject(formatErrorMessage(15,  "Within ".concat(type, " ").concat(name, ", the lifecycle function ").concat(lifecycle, " at array index ").concat(index, " did not return a promise"), type, name, lifecycle, index));
            });
          }, Promise.resolve());
        };
      }
      function smellsLikeAPromise(promise) {
        return promise && typeof promise.then === "function" && typeof promise.catch === "function";
      }

      function toBootstrapPromise(appOrParcel, hardFail) {
        return Promise.resolve().then(function () {
          if (appOrParcel.status !== NOT_BOOTSTRAPPED) {
            return appOrParcel;
          }

          appOrParcel.status = BOOTSTRAPPING;

          if (!appOrParcel.bootstrap) {
            // Default implementation of bootstrap
            return Promise.resolve().then(successfulBootstrap);
          }

          return reasonableTime(appOrParcel, "bootstrap").then(successfulBootstrap).catch(function (err) {
            if (hardFail) {
              throw transformErr(err, appOrParcel, SKIP_BECAUSE_BROKEN);
            } else {
              handleAppError(err, appOrParcel, SKIP_BECAUSE_BROKEN);
              return appOrParcel;
            }
          });
        });

        function successfulBootstrap() {
          appOrParcel.status = NOT_MOUNTED;
          return appOrParcel;
        }
      }

      function toUnmountPromise(appOrParcel, hardFail) {
        return Promise.resolve().then(function () {
          if (appOrParcel.status !== MOUNTED) {
            return appOrParcel;
          }

          appOrParcel.status = UNMOUNTING;
          var unmountChildrenParcels = Object.keys(appOrParcel.parcels).map(function (parcelId) {
            return appOrParcel.parcels[parcelId].unmountThisParcel();
          });
          return Promise.all(unmountChildrenParcels).then(unmountAppOrParcel, function (parcelError) {
            // There is a parcel unmount error
            return unmountAppOrParcel().then(function () {
              // Unmounting the app/parcel succeeded, but unmounting its children parcels did not
              var parentError = Error(parcelError.message);

              if (hardFail) {
                throw transformErr(parentError, appOrParcel, SKIP_BECAUSE_BROKEN);
              } else {
                handleAppError(parentError, appOrParcel, SKIP_BECAUSE_BROKEN);
              }
            });
          }).then(function () {
            return appOrParcel;
          });

          function unmountAppOrParcel() {
            // We always try to unmount the appOrParcel, even if the children parcels failed to unmount.
            return reasonableTime(appOrParcel, "unmount").then(function () {
              // The appOrParcel needs to stay in a broken status if its children parcels fail to unmount
              {
                appOrParcel.status = NOT_MOUNTED;
              }
            }).catch(function (err) {
              if (hardFail) {
                throw transformErr(err, appOrParcel, SKIP_BECAUSE_BROKEN);
              } else {
                handleAppError(err, appOrParcel, SKIP_BECAUSE_BROKEN);
              }
            });
          }
        });
      }

      var beforeFirstMountFired = false;
      var firstMountFired = false;
      function toMountPromise(appOrParcel, hardFail) {
        return Promise.resolve().then(function () {
          if (appOrParcel.status !== NOT_MOUNTED) {
            return appOrParcel;
          }

          if (!beforeFirstMountFired) {
            window.dispatchEvent(new customEvent("single-spa:before-first-mount"));
            beforeFirstMountFired = true;
          }

          return reasonableTime(appOrParcel, "mount").then(function () {
            appOrParcel.status = MOUNTED;

            if (!firstMountFired) {
              window.dispatchEvent(new customEvent("single-spa:first-mount"));
              firstMountFired = true;
            }

            return appOrParcel;
          }).catch(function (err) {
            // If we fail to mount the appOrParcel, we should attempt to unmount it before putting in SKIP_BECAUSE_BROKEN
            // We temporarily put the appOrParcel into MOUNTED status so that toUnmountPromise actually attempts to unmount it
            // instead of just doing a no-op.
            appOrParcel.status = MOUNTED;
            return toUnmountPromise(appOrParcel, true).then(setSkipBecauseBroken, setSkipBecauseBroken);

            function setSkipBecauseBroken() {
              if (!hardFail) {
                handleAppError(err, appOrParcel, SKIP_BECAUSE_BROKEN);
                return appOrParcel;
              } else {
                throw transformErr(err, appOrParcel, SKIP_BECAUSE_BROKEN);
              }
            }
          });
        });
      }

      function toUpdatePromise(parcel) {
        return Promise.resolve().then(function () {
          if (parcel.status !== MOUNTED) {
            throw Error(formatErrorMessage(32,  "Cannot update parcel '".concat(toName(parcel), "' because it is not mounted"), toName(parcel)));
          }

          parcel.status = UPDATING;
          return reasonableTime(parcel, "update").then(function () {
            parcel.status = MOUNTED;
            return parcel;
          }).catch(function (err) {
            throw transformErr(err, parcel, SKIP_BECAUSE_BROKEN);
          });
        });
      }

      var parcelCount = 0;
      var rootParcels = {
        parcels: {}
      }; // This is a public api, exported to users of single-spa

      function mountRootParcel() {
        return mountParcel.apply(rootParcels, arguments);
      }
      function mountParcel(config, customProps) {
        var owningAppOrParcel = this; // Validate inputs

        if (!config || _typeof(config) !== "object" && typeof config !== "function") {
          throw Error(formatErrorMessage(2,  "Cannot mount parcel without a config object or config loading function"));
        }

        if (config.name && typeof config.name !== "string") {
          throw Error(formatErrorMessage(3,  "Parcel name must be a string, if provided. Was given ".concat(_typeof(config.name)), _typeof(config.name)));
        }

        if (_typeof(customProps) !== "object") {
          throw Error(formatErrorMessage(4,  "Parcel ".concat(name, " has invalid customProps -- must be an object but was given ").concat(_typeof(customProps)), name, _typeof(customProps)));
        }

        if (!customProps.domElement) {
          throw Error(formatErrorMessage(5,  "Parcel ".concat(name, " cannot be mounted without a domElement provided as a prop"), name));
        }

        var id = parcelCount++;
        var passedConfigLoadingFunction = typeof config === "function";
        var configLoadingFunction = passedConfigLoadingFunction ? config : function () {
          return Promise.resolve(config);
        }; // Internal representation

        var parcel = {
          id: id,
          parcels: {},
          status: passedConfigLoadingFunction ? LOADING_SOURCE_CODE : NOT_BOOTSTRAPPED,
          customProps: customProps,
          parentName: toName(owningAppOrParcel),
          unmountThisParcel: function unmountThisParcel() {
            return mountPromise.then(function () {
              if (parcel.status !== MOUNTED) {
                throw Error(formatErrorMessage(6,  "Cannot unmount parcel '".concat(name, "' -- it is in a ").concat(parcel.status, " status"), name, parcel.status));
              }

              return toUnmountPromise(parcel, true);
            }).then(function (value) {
              if (parcel.parentName) {
                delete owningAppOrParcel.parcels[parcel.id];
              }

              return value;
            }).then(function (value) {
              resolveUnmount(value);
              return value;
            }).catch(function (err) {
              parcel.status = SKIP_BECAUSE_BROKEN;
              rejectUnmount(err);
              throw err;
            });
          }
        }; // We return an external representation

        var externalRepresentation; // Add to owning app or parcel

        owningAppOrParcel.parcels[id] = parcel;
        var loadPromise = configLoadingFunction();

        if (!loadPromise || typeof loadPromise.then !== "function") {
          throw Error(formatErrorMessage(7,  "When mounting a parcel, the config loading function must return a promise that resolves with the parcel config"));
        }

        loadPromise = loadPromise.then(function (config) {
          if (!config) {
            throw Error(formatErrorMessage(8,  "When mounting a parcel, the config loading function returned a promise that did not resolve with a parcel config"));
          }

          var name = config.name || "parcel-".concat(id);

          if ( // ES Module objects don't have the object prototype
          Object.prototype.hasOwnProperty.call(config, "bootstrap") && !validLifecycleFn(config.bootstrap)) {
            throw Error(formatErrorMessage(9,  "Parcel ".concat(name, " provided an invalid bootstrap function"), name));
          }

          if (!validLifecycleFn(config.mount)) {
            throw Error(formatErrorMessage(10,  "Parcel ".concat(name, " must have a valid mount function"), name));
          }

          if (!validLifecycleFn(config.unmount)) {
            throw Error(formatErrorMessage(11,  "Parcel ".concat(name, " must have a valid unmount function"), name));
          }

          if (config.update && !validLifecycleFn(config.update)) {
            throw Error(formatErrorMessage(12,  "Parcel ".concat(name, " provided an invalid update function"), name));
          }

          var bootstrap = flattenFnArray(config, "bootstrap");
          var mount = flattenFnArray(config, "mount");
          var unmount = flattenFnArray(config, "unmount");
          parcel.status = NOT_BOOTSTRAPPED;
          parcel.name = name;
          parcel.bootstrap = bootstrap;
          parcel.mount = mount;
          parcel.unmount = unmount;
          parcel.timeouts = ensureValidAppTimeouts(config.timeouts);

          if (config.update) {
            parcel.update = flattenFnArray(config, "update");

            externalRepresentation.update = function (customProps) {
              parcel.customProps = customProps;
              return promiseWithoutReturnValue(toUpdatePromise(parcel));
            };
          }
        }); // Start bootstrapping and mounting
        // The .then() causes the work to be put on the event loop instead of happening immediately

        var bootstrapPromise = loadPromise.then(function () {
          return toBootstrapPromise(parcel, true);
        });
        var mountPromise = bootstrapPromise.then(function () {
          return toMountPromise(parcel, true);
        });
        var resolveUnmount, rejectUnmount;
        var unmountPromise = new Promise(function (resolve, reject) {
          resolveUnmount = resolve;
          rejectUnmount = reject;
        });
        externalRepresentation = {
          mount: function mount() {
            return promiseWithoutReturnValue(Promise.resolve().then(function () {
              if (parcel.status !== NOT_MOUNTED) {
                throw Error(formatErrorMessage(13,  "Cannot mount parcel '".concat(name, "' -- it is in a ").concat(parcel.status, " status"), name, parcel.status));
              } // Add to owning app or parcel


              owningAppOrParcel.parcels[id] = parcel;
              return toMountPromise(parcel);
            }));
          },
          unmount: function unmount() {
            return promiseWithoutReturnValue(parcel.unmountThisParcel());
          },
          getStatus: function getStatus() {
            return parcel.status;
          },
          loadPromise: promiseWithoutReturnValue(loadPromise),
          bootstrapPromise: promiseWithoutReturnValue(bootstrapPromise),
          mountPromise: promiseWithoutReturnValue(mountPromise),
          unmountPromise: promiseWithoutReturnValue(unmountPromise)
        };
        return externalRepresentation;
      }

      function promiseWithoutReturnValue(promise) {
        return promise.then(function () {
          return null;
        });
      }

      function getProps(appOrParcel) {
        var name = toName(appOrParcel);
        var customProps = typeof appOrParcel.customProps === "function" ? appOrParcel.customProps(name, window.location) : appOrParcel.customProps;

        if (_typeof(customProps) !== "object" || customProps === null || Array.isArray(customProps)) {
          customProps = {};
          console.warn(formatErrorMessage(40,  "single-spa: ".concat(name, "'s customProps function must return an object. Received ").concat(customProps)), name, customProps);
        }

        var result = assign({}, customProps, {
          name: name,
          mountParcel: mountParcel.bind(appOrParcel),
          singleSpa: singleSpa
        });

        if (isParcel(appOrParcel)) {
          result.unmountSelf = appOrParcel.unmountThisParcel;
        }

        return result;
      }

      var defaultWarningMillis = 1000;
      var globalTimeoutConfig = {
        bootstrap: {
          millis: 4000,
          dieOnTimeout: false,
          warningMillis: defaultWarningMillis
        },
        mount: {
          millis: 3000,
          dieOnTimeout: false,
          warningMillis: defaultWarningMillis
        },
        unmount: {
          millis: 3000,
          dieOnTimeout: false,
          warningMillis: defaultWarningMillis
        },
        unload: {
          millis: 3000,
          dieOnTimeout: false,
          warningMillis: defaultWarningMillis
        },
        update: {
          millis: 3000,
          dieOnTimeout: false,
          warningMillis: defaultWarningMillis
        }
      };
      function setBootstrapMaxTime(time, dieOnTimeout, warningMillis) {
        if (typeof time !== "number" || time <= 0) {
          throw Error(formatErrorMessage(16,  "bootstrap max time must be a positive integer number of milliseconds"));
        }

        globalTimeoutConfig.bootstrap = {
          millis: time,
          dieOnTimeout: dieOnTimeout,
          warningMillis: warningMillis || defaultWarningMillis
        };
      }
      function setMountMaxTime(time, dieOnTimeout, warningMillis) {
        if (typeof time !== "number" || time <= 0) {
          throw Error(formatErrorMessage(17,  "mount max time must be a positive integer number of milliseconds"));
        }

        globalTimeoutConfig.mount = {
          millis: time,
          dieOnTimeout: dieOnTimeout,
          warningMillis: warningMillis || defaultWarningMillis
        };
      }
      function setUnmountMaxTime(time, dieOnTimeout, warningMillis) {
        if (typeof time !== "number" || time <= 0) {
          throw Error(formatErrorMessage(18,  "unmount max time must be a positive integer number of milliseconds"));
        }

        globalTimeoutConfig.unmount = {
          millis: time,
          dieOnTimeout: dieOnTimeout,
          warningMillis: warningMillis || defaultWarningMillis
        };
      }
      function setUnloadMaxTime(time, dieOnTimeout, warningMillis) {
        if (typeof time !== "number" || time <= 0) {
          throw Error(formatErrorMessage(19,  "unload max time must be a positive integer number of milliseconds"));
        }

        globalTimeoutConfig.unload = {
          millis: time,
          dieOnTimeout: dieOnTimeout,
          warningMillis: warningMillis || defaultWarningMillis
        };
      }
      function reasonableTime(appOrParcel, lifecycle) {
        var timeoutConfig = appOrParcel.timeouts[lifecycle];
        var warningPeriod = timeoutConfig.warningMillis;
        var type = objectType(appOrParcel);
        return new Promise(function (resolve, reject) {
          var finished = false;
          var errored = false;
          appOrParcel[lifecycle](getProps(appOrParcel)).then(function (val) {
            finished = true;
            resolve(val);
          }).catch(function (val) {
            finished = true;
            reject(val);
          });
          setTimeout(function () {
            return maybeTimingOut(1);
          }, warningPeriod);
          setTimeout(function () {
            return maybeTimingOut(true);
          }, timeoutConfig.millis);
          var errMsg = formatErrorMessage(31,  "Lifecycle function ".concat(lifecycle, " for ").concat(type, " ").concat(toName(appOrParcel), " lifecycle did not resolve or reject for ").concat(timeoutConfig.millis, " ms."), lifecycle, type, toName(appOrParcel), timeoutConfig.millis);

          function maybeTimingOut(shouldError) {
            if (!finished) {
              if (shouldError === true) {
                errored = true;

                if (timeoutConfig.dieOnTimeout) {
                  reject(Error(errMsg));
                } else {
                  console.error(errMsg); //don't resolve or reject, we're waiting this one out
                }
              } else if (!errored) {
                var numWarnings = shouldError;
                var numMillis = numWarnings * warningPeriod;
                console.warn(errMsg);

                if (numMillis + warningPeriod < timeoutConfig.millis) {
                  setTimeout(function () {
                    return maybeTimingOut(numWarnings + 1);
                  }, warningPeriod);
                }
              }
            }
          }
        });
      }
      function ensureValidAppTimeouts(timeouts) {
        var result = {};

        for (var key in globalTimeoutConfig) {
          result[key] = assign({}, globalTimeoutConfig[key], timeouts && timeouts[key] || {});
        }

        return result;
      }

      function toLoadPromise(app) {
        return Promise.resolve().then(function () {
          if (app.loadPromise) {
            return app.loadPromise;
          }

          if (app.status !== NOT_LOADED && app.status !== LOAD_ERROR) {
            return app;
          }

          app.status = LOADING_SOURCE_CODE;
          var appOpts, isUserErr;
          return app.loadPromise = Promise.resolve().then(function () {
            var loadPromise = app.loadApp(getProps(app));

            if (!smellsLikeAPromise(loadPromise)) {
              // The name of the app will be prepended to this error message inside of the handleAppError function
              isUserErr = true;
              throw Error(formatErrorMessage(33,  "single-spa loading function did not return a promise. Check the second argument to registerApplication('".concat(toName(app), "', loadingFunction, activityFunction)"), toName(app)));
            }

            return loadPromise.then(function (val) {
              app.loadErrorTime = null;
              appOpts = val;
              var validationErrMessage, validationErrCode;

              if (_typeof(appOpts) !== "object") {
                validationErrCode = 34;

                {
                  validationErrMessage = "does not export anything";
                }
              }

              if ( // ES Modules don't have the Object prototype
              Object.prototype.hasOwnProperty.call(appOpts, "bootstrap") && !validLifecycleFn(appOpts.bootstrap)) {
                validationErrCode = 35;

                {
                  validationErrMessage = "does not export a valid bootstrap function or array of functions";
                }
              }

              if (!validLifecycleFn(appOpts.mount)) {
                validationErrCode = 36;

                {
                  validationErrMessage = "does not export a mount function or array of functions";
                }
              }

              if (!validLifecycleFn(appOpts.unmount)) {
                validationErrCode = 37;

                {
                  validationErrMessage = "does not export a unmount function or array of functions";
                }
              }

              var type = objectType(appOpts);

              if (validationErrCode) {
                var appOptsStr;

                try {
                  appOptsStr = JSON.stringify(appOpts);
                } catch (_unused) {}

                console.error(formatErrorMessage(validationErrCode,  "The loading function for single-spa ".concat(type, " '").concat(toName(app), "' resolved with the following, which does not have bootstrap, mount, and unmount functions"), type, toName(app), appOptsStr), appOpts);
                handleAppError(validationErrMessage, app, SKIP_BECAUSE_BROKEN);
                return app;
              }

              if (appOpts.devtools && appOpts.devtools.overlays) {
                app.devtools.overlays = assign({}, app.devtools.overlays, appOpts.devtools.overlays);
              }

              app.status = NOT_BOOTSTRAPPED;
              app.bootstrap = flattenFnArray(appOpts, "bootstrap");
              app.mount = flattenFnArray(appOpts, "mount");
              app.unmount = flattenFnArray(appOpts, "unmount");
              app.unload = flattenFnArray(appOpts, "unload");
              app.timeouts = ensureValidAppTimeouts(appOpts.timeouts);
              delete app.loadPromise;
              return app;
            });
          }).catch(function (err) {
            delete app.loadPromise;
            var newStatus;

            if (isUserErr) {
              newStatus = SKIP_BECAUSE_BROKEN;
            } else {
              newStatus = LOAD_ERROR;
              app.loadErrorTime = new Date().getTime();
            }

            handleAppError(err, app, newStatus);
            return app;
          });
        });
      }

      var isInBrowser = typeof window !== "undefined";

      /* We capture navigation event listeners so that we can make sure
       * that application navigation listeners are not called until
       * single-spa has ensured that the correct applications are
       * unmounted and mounted.
       */

      var capturedEventListeners = {
        hashchange: [],
        popstate: []
      };
      var routingEventsListeningTo = ["hashchange", "popstate"];
      function navigateToUrl(obj) {
        var url;

        if (typeof obj === "string") {
          url = obj;
        } else if (this && this.href) {
          url = this.href;
        } else if (obj && obj.currentTarget && obj.currentTarget.href && obj.preventDefault) {
          url = obj.currentTarget.href;
          obj.preventDefault();
        } else {
          throw Error(formatErrorMessage(14,  "singleSpaNavigate/navigateToUrl must be either called with a string url, with an <a> tag as its context, or with an event whose currentTarget is an <a> tag"));
        }

        var current = parseUri(window.location.href);
        var destination = parseUri(url);

        if (url.indexOf("#") === 0) {
          window.location.hash = destination.hash;
        } else if (current.host !== destination.host && destination.host) {
          {
            window.location.href = url;
          }
        } else if (destination.pathname === current.pathname && destination.search === current.search) {
          window.location.hash = destination.hash;
        } else {
          // different path, host, or query params
          window.history.pushState(null, null, url);
        }
      }
      function callCapturedEventListeners(eventArguments) {
        var _this = this;

        if (eventArguments) {
          var eventType = eventArguments[0].type;

          if (routingEventsListeningTo.indexOf(eventType) >= 0) {
            capturedEventListeners[eventType].forEach(function (listener) {
              try {
                // The error thrown by application event listener should not break single-spa down.
                // Just like https://github.com/single-spa/single-spa/blob/85f5042dff960e40936f3a5069d56fc9477fac04/src/navigation/reroute.js#L140-L146 did
                listener.apply(_this, eventArguments);
              } catch (e) {
                setTimeout(function () {
                  throw e;
                });
              }
            });
          }
        }
      }
      var urlRerouteOnly;
      function setUrlRerouteOnly(val) {
        urlRerouteOnly = val;
      }

      function urlReroute() {
        reroute([], arguments);
      }

      function patchedUpdateState(updateState, methodName) {
        return function () {
          var urlBefore = window.location.href;
          var result = updateState.apply(this, arguments);
          var urlAfter = window.location.href;

          if (!urlRerouteOnly || urlBefore !== urlAfter) {
            if (isStarted()) {
              // fire an artificial popstate event once single-spa is started,
              // so that single-spa applications know about routing that
              // occurs in a different application
              window.dispatchEvent(createPopStateEvent(window.history.state, methodName));
            } else {
              // do not fire an artificial popstate event before single-spa is started,
              // since no single-spa applications need to know about routing events
              // outside of their own router.
              reroute([]);
            }
          }

          return result;
        };
      }

      function createPopStateEvent(state, originalMethodName) {
        // https://github.com/single-spa/single-spa/issues/224 and https://github.com/single-spa/single-spa-angular/issues/49
        // We need a popstate event even though the browser doesn't do one by default when you call replaceState, so that
        // all the applications can reroute. We explicitly identify this extraneous event by setting singleSpa=true and
        // singleSpaTrigger=<pushState|replaceState> on the event instance.
        var evt;

        try {
          evt = new PopStateEvent("popstate", {
            state: state
          });
        } catch (err) {
          // IE 11 compatibility https://github.com/single-spa/single-spa/issues/299
          // https://docs.microsoft.com/en-us/openspecs/ie_standards/ms-html5e/bd560f47-b349-4d2c-baa8-f1560fb489dd
          evt = document.createEvent("PopStateEvent");
          evt.initPopStateEvent("popstate", false, false, state);
        }

        evt.singleSpa = true;
        evt.singleSpaTrigger = originalMethodName;
        return evt;
      }

      if (isInBrowser) {
        // We will trigger an app change for any routing events.
        window.addEventListener("hashchange", urlReroute);
        window.addEventListener("popstate", urlReroute); // Monkeypatch addEventListener so that we can ensure correct timing

        var originalAddEventListener = window.addEventListener;
        var originalRemoveEventListener = window.removeEventListener;

        window.addEventListener = function (eventName, fn) {
          if (typeof fn === "function") {
            if (routingEventsListeningTo.indexOf(eventName) >= 0 && !find(capturedEventListeners[eventName], function (listener) {
              return listener === fn;
            })) {
              capturedEventListeners[eventName].push(fn);
              return;
            }
          }

          return originalAddEventListener.apply(this, arguments);
        };

        window.removeEventListener = function (eventName, listenerFn) {
          if (typeof listenerFn === "function") {
            if (routingEventsListeningTo.indexOf(eventName) >= 0) {
              capturedEventListeners[eventName] = capturedEventListeners[eventName].filter(function (fn) {
                return fn !== listenerFn;
              });
              return;
            }
          }

          return originalRemoveEventListener.apply(this, arguments);
        };

        window.history.pushState = patchedUpdateState(window.history.pushState, "pushState");
        window.history.replaceState = patchedUpdateState(window.history.replaceState, "replaceState");

        if (window.singleSpaNavigate) {
          console.warn(formatErrorMessage(41,  "single-spa has been loaded twice on the page. This can result in unexpected behavior."));
        } else {
          /* For convenience in `onclick` attributes, we expose a global function for navigating to
           * whatever an <a> tag's href is.
           */
          window.singleSpaNavigate = navigateToUrl;
        }
      }

      function parseUri(str) {
        var anchor = document.createElement("a");
        anchor.href = str;
        return anchor;
      }

      var hasInitialized = false;
      function ensureJQuerySupport() {
        var jQuery = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.jQuery;

        if (!jQuery) {
          if (window.$ && window.$.fn && window.$.fn.jquery) {
            jQuery = window.$;
          }
        }

        if (jQuery && !hasInitialized) {
          var originalJQueryOn = jQuery.fn.on;
          var originalJQueryOff = jQuery.fn.off;

          jQuery.fn.on = function (eventString, fn) {
            return captureRoutingEvents.call(this, originalJQueryOn, window.addEventListener, eventString, fn, arguments);
          };

          jQuery.fn.off = function (eventString, fn) {
            return captureRoutingEvents.call(this, originalJQueryOff, window.removeEventListener, eventString, fn, arguments);
          };

          hasInitialized = true;
        }
      }

      function captureRoutingEvents(originalJQueryFunction, nativeFunctionToCall, eventString, fn, originalArgs) {
        if (typeof eventString !== "string") {
          return originalJQueryFunction.apply(this, originalArgs);
        }

        var eventNames = eventString.split(/\s+/);
        eventNames.forEach(function (eventName) {
          if (routingEventsListeningTo.indexOf(eventName) >= 0) {
            nativeFunctionToCall(eventName, fn);
            eventString = eventString.replace(eventName, "");
          }
        });

        if (eventString.trim() === "") {
          return this;
        } else {
          return originalJQueryFunction.apply(this, originalArgs);
        }
      }

      var appsToUnload = {};
      function toUnloadPromise(app) {
        return Promise.resolve().then(function () {
          var unloadInfo = appsToUnload[toName(app)];

          if (!unloadInfo) {
            /* No one has called unloadApplication for this app,
             */
            return app;
          }

          if (app.status === NOT_LOADED) {
            /* This app is already unloaded. We just need to clean up
             * anything that still thinks we need to unload the app.
             */
            finishUnloadingApp(app, unloadInfo);
            return app;
          }

          if (app.status === UNLOADING) {
            /* Both unloadApplication and reroute want to unload this app.
             * It only needs to be done once, though.
             */
            return unloadInfo.promise.then(function () {
              return app;
            });
          }

          if (app.status !== NOT_MOUNTED && app.status !== LOAD_ERROR$1) {
            /* The app cannot be unloaded until it is unmounted.
             */
            return app;
          }

          var unloadPromise = app.status === LOAD_ERROR$1 ? Promise.resolve() : reasonableTime(app, "unload");
          app.status = UNLOADING;
          return unloadPromise.then(function () {
            finishUnloadingApp(app, unloadInfo);
            return app;
          }).catch(function (err) {
            errorUnloadingApp(app, unloadInfo, err);
            return app;
          });
        });
      }

      function finishUnloadingApp(app, unloadInfo) {
        delete appsToUnload[toName(app)]; // Unloaded apps don't have lifecycles

        delete app.bootstrap;
        delete app.mount;
        delete app.unmount;
        delete app.unload;
        app.status = NOT_LOADED;
        /* resolve the promise of whoever called unloadApplication.
         * This should be done after all other cleanup/bookkeeping
         */

        unloadInfo.resolve();
      }

      function errorUnloadingApp(app, unloadInfo, err) {
        delete appsToUnload[toName(app)]; // Unloaded apps don't have lifecycles

        delete app.bootstrap;
        delete app.mount;
        delete app.unmount;
        delete app.unload;
        handleAppError(err, app, SKIP_BECAUSE_BROKEN);
        unloadInfo.reject(err);
      }

      function addAppToUnload(app, promiseGetter, resolve, reject) {
        appsToUnload[toName(app)] = {
          app: app,
          resolve: resolve,
          reject: reject
        };
        Object.defineProperty(appsToUnload[toName(app)], "promise", {
          get: promiseGetter
        });
      }
      function getAppUnloadInfo(appName) {
        return appsToUnload[appName];
      }

      var apps = [];
      function getAppChanges() {
        var appsToUnload = [],
            appsToUnmount = [],
            appsToLoad = [],
            appsToMount = []; // We re-attempt to download applications in LOAD_ERROR after a timeout of 200 milliseconds

        var currentTime = new Date().getTime();
        apps.forEach(function (app) {
          var appShouldBeActive = app.status !== SKIP_BECAUSE_BROKEN && shouldBeActive(app);

          switch (app.status) {
            case LOAD_ERROR:
              if (appShouldBeActive && currentTime - app.loadErrorTime >= 200) {
                appsToLoad.push(app);
              }

              break;

            case NOT_LOADED:
            case LOADING_SOURCE_CODE:
              if (appShouldBeActive) {
                appsToLoad.push(app);
              }

              break;

            case NOT_BOOTSTRAPPED:
            case NOT_MOUNTED:
              if (!appShouldBeActive && getAppUnloadInfo(toName(app))) {
                appsToUnload.push(app);
              } else if (appShouldBeActive) {
                appsToMount.push(app);
              }

              break;

            case MOUNTED:
              if (!appShouldBeActive) {
                appsToUnmount.push(app);
              }

              break;
            // all other statuses are ignored
          }
        });
        return {
          appsToUnload: appsToUnload,
          appsToUnmount: appsToUnmount,
          appsToLoad: appsToLoad,
          appsToMount: appsToMount
        };
      }
      function getMountedApps() {
        return apps.filter(isActive).map(toName);
      }
      function getAppNames() {
        return apps.map(toName);
      } // used in devtools, not (currently) exposed as a single-spa API

      function getRawAppData() {
        return [].concat(apps);
      }
      function getAppStatus(appName) {
        var app = find(apps, function (app) {
          return toName(app) === appName;
        });
        return app ? app.status : null;
      }
      function registerApplication(appNameOrConfig, appOrLoadApp, activeWhen, customProps) {
        var registration = sanitizeArguments(appNameOrConfig, appOrLoadApp, activeWhen, customProps);
        if (getAppNames().indexOf(registration.name) !== -1) throw Error(formatErrorMessage(21,  "There is already an app registered with name ".concat(registration.name), registration.name));
        apps.push(assign({
          loadErrorTime: null,
          status: NOT_LOADED,
          parcels: {},
          devtools: {
            overlays: {
              options: {},
              selectors: []
            }
          }
        }, registration));

        if (isInBrowser) {
          ensureJQuerySupport();
          reroute();
        }
      }
      function checkActivityFunctions() {
        var location = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.location;
        return apps.filter(function (app) {
          return app.activeWhen(location);
        }).map(toName);
      }
      function unregisterApplication(appName) {
        if (apps.filter(function (app) {
          return toName(app) === appName;
        }).length === 0) {
          throw Error(formatErrorMessage(25,  "Cannot unregister application '".concat(appName, "' because no such application has been registered"), appName));
        }

        return unloadApplication(appName).then(function () {
          var appIndex = apps.map(toName).indexOf(appName);
          apps.splice(appIndex, 1);
        });
      }
      function unloadApplication(appName) {
        var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
          waitForUnmount: false
        };

        if (typeof appName !== "string") {
          throw Error(formatErrorMessage(26,  "unloadApplication requires a string 'appName'"));
        }

        var app = find(apps, function (App) {
          return toName(App) === appName;
        });

        if (!app) {
          throw Error(formatErrorMessage(27,  "Could not unload application '".concat(appName, "' because no such application has been registered"), appName));
        }

        var appUnloadInfo = getAppUnloadInfo(toName(app));

        if (opts && opts.waitForUnmount) {
          // We need to wait for unmount before unloading the app
          if (appUnloadInfo) {
            // Someone else is already waiting for this, too
            return appUnloadInfo.promise;
          } else {
            // We're the first ones wanting the app to be resolved.
            var promise = new Promise(function (resolve, reject) {
              addAppToUnload(app, function () {
                return promise;
              }, resolve, reject);
            });
            return promise;
          }
        } else {
          /* We should unmount the app, unload it, and remount it immediately.
           */
          var resultPromise;

          if (appUnloadInfo) {
            // Someone else is already waiting for this app to unload
            resultPromise = appUnloadInfo.promise;
            immediatelyUnloadApp(app, appUnloadInfo.resolve, appUnloadInfo.reject);
          } else {
            // We're the first ones wanting the app to be resolved.
            resultPromise = new Promise(function (resolve, reject) {
              addAppToUnload(app, function () {
                return resultPromise;
              }, resolve, reject);
              immediatelyUnloadApp(app, resolve, reject);
            });
          }

          return resultPromise;
        }
      }

      function immediatelyUnloadApp(app, resolve, reject) {
        toUnmountPromise(app).then(toUnloadPromise).then(function () {
          resolve();
          setTimeout(function () {
            // reroute, but the unload promise is done
            reroute();
          });
        }).catch(reject);
      }

      function validateRegisterWithArguments(name, appOrLoadApp, activeWhen, customProps) {
        if (typeof name !== "string" || name.length === 0) throw Error(formatErrorMessage(20,  "The 1st argument to registerApplication must be a non-empty string 'appName'"));
        if (!appOrLoadApp) throw Error(formatErrorMessage(23,  "The 2nd argument to registerApplication must be an application or loading application function"));
        if (typeof activeWhen !== "function") throw Error(formatErrorMessage(24,  "The 3rd argument to registerApplication must be an activeWhen function"));
        if (!validCustomProps(customProps)) throw Error(formatErrorMessage(22,  "The optional 4th argument is a customProps and must be an object"));
      }

      function validateRegisterWithConfig(config) {
        if (Array.isArray(config) || config === null) throw Error(formatErrorMessage(39,  "Configuration object can't be an Array or null!"));
        var validKeys = ["name", "app", "activeWhen", "customProps"];
        var invalidKeys = Object.keys(config).reduce(function (invalidKeys, prop) {
          return validKeys.indexOf(prop) >= 0 ? invalidKeys : invalidKeys.concat(prop);
        }, []);
        if (invalidKeys.length !== 0) throw Error(formatErrorMessage(38,  "The configuration object accepts only: ".concat(validKeys.join(", "), ". Invalid keys: ").concat(invalidKeys.join(", "), "."), validKeys.join(", "), invalidKeys.join(", ")));
        if (typeof config.name !== "string" || config.name.length === 0) throw Error(formatErrorMessage(20,  "The config.name on registerApplication must be a non-empty string"));
        if (_typeof(config.app) !== "object" && typeof config.app !== "function") throw Error(formatErrorMessage(20,  "The config.app on registerApplication must be an application or a loading function"));

        var allowsStringAndFunction = function allowsStringAndFunction(activeWhen) {
          return typeof activeWhen === "string" || typeof activeWhen === "function";
        };

        if (!allowsStringAndFunction(config.activeWhen) && !(Array.isArray(config.activeWhen) && config.activeWhen.every(allowsStringAndFunction))) throw Error(formatErrorMessage(24,  "The config.activeWhen on registerApplication must be a string, function or an array with both"));
        if (!validCustomProps(config.customProps)) throw Error(formatErrorMessage(22,  "The optional config.customProps must be an object"));
      }

      function validCustomProps(customProps) {
        return !customProps || typeof customProps === "function" || _typeof(customProps) === "object" && customProps !== null && !Array.isArray(customProps);
      }

      function sanitizeArguments(appNameOrConfig, appOrLoadApp, activeWhen, customProps) {
        var usingObjectAPI = _typeof(appNameOrConfig) === "object";
        var registration = {
          name: null,
          loadApp: null,
          activeWhen: null,
          customProps: null
        };

        if (usingObjectAPI) {
          validateRegisterWithConfig(appNameOrConfig);
          registration.name = appNameOrConfig.name;
          registration.loadApp = appNameOrConfig.app;
          registration.activeWhen = appNameOrConfig.activeWhen;
          registration.customProps = appNameOrConfig.customProps;
        } else {
          validateRegisterWithArguments(appNameOrConfig, appOrLoadApp, activeWhen, customProps);
          registration.name = appNameOrConfig;
          registration.loadApp = appOrLoadApp;
          registration.activeWhen = activeWhen;
          registration.customProps = customProps;
        }

        registration.loadApp = sanitizeLoadApp(registration.loadApp);
        registration.customProps = sanitizeCustomProps(registration.customProps);
        registration.activeWhen = sanitizeActiveWhen(registration.activeWhen);
        return registration;
      }

      function sanitizeLoadApp(loadApp) {
        if (typeof loadApp !== "function") {
          return function () {
            return Promise.resolve(loadApp);
          };
        }

        return loadApp;
      }

      function sanitizeCustomProps(customProps) {
        return customProps ? customProps : {};
      }

      function sanitizeActiveWhen(activeWhen) {
        var activeWhenArray = Array.isArray(activeWhen) ? activeWhen : [activeWhen];
        activeWhenArray = activeWhenArray.map(function (activeWhenOrPath) {
          return typeof activeWhenOrPath === "function" ? activeWhenOrPath : pathToActiveWhen(activeWhenOrPath);
        });
        return function (location) {
          return activeWhenArray.some(function (activeWhen) {
            return activeWhen(location);
          });
        };
      }

      function pathToActiveWhen(path, exactMatch) {
        var regex = toDynamicPathValidatorRegex(path, exactMatch);
        return function (location) {
          var route = location.href.replace(location.origin, "").replace(location.search, "").split("?")[0];
          return regex.test(route);
        };
      }

      function toDynamicPathValidatorRegex(path, exactMatch) {
        var lastIndex = 0,
            inDynamic = false,
            regexStr = "^";

        if (path[0] !== "/") {
          path = "/" + path;
        }

        for (var charIndex = 0; charIndex < path.length; charIndex++) {
          var char = path[charIndex];
          var startOfDynamic = !inDynamic && char === ":";
          var endOfDynamic = inDynamic && char === "/";

          if (startOfDynamic || endOfDynamic) {
            appendToRegex(charIndex);
          }
        }

        appendToRegex(path.length);
        return new RegExp(regexStr, "i");

        function appendToRegex(index) {
          var anyCharMaybeTrailingSlashRegex = "[^/]+/?";
          var commonStringSubPath = escapeStrRegex(path.slice(lastIndex, index));
          regexStr += inDynamic ? anyCharMaybeTrailingSlashRegex : commonStringSubPath;

          if (index === path.length) {
            if (inDynamic) {
              if (exactMatch) {
                // Ensure exact match paths that end in a dynamic portion don't match
                // urls with characters after a slash after the dynamic portion.
                regexStr += "$";
              }
            } else {
              // For exact matches, expect no more characters. Otherwise, allow
              // any characters.
              var suffix = exactMatch ? "" : ".*";
              regexStr = // use charAt instead as we could not use es6 method endsWith
              regexStr.charAt(regexStr.length - 1) === "/" ? "".concat(regexStr).concat(suffix, "$") : "".concat(regexStr, "(/").concat(suffix, ")?(#.*)?$");
            }
          }

          inDynamic = !inDynamic;
          lastIndex = index;
        }

        function escapeStrRegex(str) {
          // borrowed from https://github.com/sindresorhus/escape-string-regexp/blob/master/index.js
          return str.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
        }
      }

      var appChangeUnderway = false,
          peopleWaitingOnAppChange = [],
          currentUrl = isInBrowser && window.location.href;
      function triggerAppChange() {
        // Call reroute with no arguments, intentionally
        return reroute();
      }
      function reroute() {
        var pendingPromises = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
        var eventArguments = arguments.length > 1 ? arguments[1] : undefined;

        if (appChangeUnderway) {
          return new Promise(function (resolve, reject) {
            peopleWaitingOnAppChange.push({
              resolve: resolve,
              reject: reject,
              eventArguments: eventArguments
            });
          });
        }

        var _getAppChanges = getAppChanges(),
            appsToUnload = _getAppChanges.appsToUnload,
            appsToUnmount = _getAppChanges.appsToUnmount,
            appsToLoad = _getAppChanges.appsToLoad,
            appsToMount = _getAppChanges.appsToMount;

        var appsThatChanged,
            navigationIsCanceled = false,
            oldUrl = currentUrl,
            newUrl = currentUrl = window.location.href;

        if (isStarted()) {
          appChangeUnderway = true;
          appsThatChanged = appsToUnload.concat(appsToLoad, appsToUnmount, appsToMount);
          return performAppChanges();
        } else {
          appsThatChanged = appsToLoad;
          return loadApps();
        }

        function cancelNavigation() {
          navigationIsCanceled = true;
        }

        function loadApps() {
          return Promise.resolve().then(function () {
            var loadPromises = appsToLoad.map(toLoadPromise);
            return Promise.all(loadPromises).then(callAllEventListeners) // there are no mounted apps, before start() is called, so we always return []
            .then(function () {
              return [];
            }).catch(function (err) {
              callAllEventListeners();
              throw err;
            });
          });
        }

        function performAppChanges() {
          return Promise.resolve().then(function () {
            // https://github.com/single-spa/single-spa/issues/545
            window.dispatchEvent(new customEvent(appsThatChanged.length === 0 ? "single-spa:before-no-app-change" : "single-spa:before-app-change", getCustomEventDetail(true)));
            window.dispatchEvent(new customEvent("single-spa:before-routing-event", getCustomEventDetail(true, {
              cancelNavigation: cancelNavigation
            })));

            if (navigationIsCanceled) {
              window.dispatchEvent(new customEvent("single-spa:before-mount-routing-event", getCustomEventDetail(true)));
              finishUpAndReturn();
              navigateToUrl(oldUrl);
              return;
            }

            var unloadPromises = appsToUnload.map(toUnloadPromise);
            var unmountUnloadPromises = appsToUnmount.map(toUnmountPromise).map(function (unmountPromise) {
              return unmountPromise.then(toUnloadPromise);
            });
            var allUnmountPromises = unmountUnloadPromises.concat(unloadPromises);
            var unmountAllPromise = Promise.all(allUnmountPromises);
            unmountAllPromise.then(function () {
              window.dispatchEvent(new customEvent("single-spa:before-mount-routing-event", getCustomEventDetail(true)));
            });
            /* We load and bootstrap apps while other apps are unmounting, but we
             * wait to mount the app until all apps are finishing unmounting
             */

            var loadThenMountPromises = appsToLoad.map(function (app) {
              return toLoadPromise(app).then(function (app) {
                return tryToBootstrapAndMount(app, unmountAllPromise);
              });
            });
            /* These are the apps that are already bootstrapped and just need
             * to be mounted. They each wait for all unmounting apps to finish up
             * before they mount.
             */

            var mountPromises = appsToMount.filter(function (appToMount) {
              return appsToLoad.indexOf(appToMount) < 0;
            }).map(function (appToMount) {
              return tryToBootstrapAndMount(appToMount, unmountAllPromise);
            });
            return unmountAllPromise.catch(function (err) {
              callAllEventListeners();
              throw err;
            }).then(function () {
              /* Now that the apps that needed to be unmounted are unmounted, their DOM navigation
               * events (like hashchange or popstate) should have been cleaned up. So it's safe
               * to let the remaining captured event listeners to handle about the DOM event.
               */
              callAllEventListeners();
              return Promise.all(loadThenMountPromises.concat(mountPromises)).catch(function (err) {
                pendingPromises.forEach(function (promise) {
                  return promise.reject(err);
                });
                throw err;
              }).then(finishUpAndReturn);
            });
          });
        }

        function finishUpAndReturn() {
          var returnValue = getMountedApps();
          pendingPromises.forEach(function (promise) {
            return promise.resolve(returnValue);
          });

          try {
            var appChangeEventName = appsThatChanged.length === 0 ? "single-spa:no-app-change" : "single-spa:app-change";
            window.dispatchEvent(new customEvent(appChangeEventName, getCustomEventDetail()));
            window.dispatchEvent(new customEvent("single-spa:routing-event", getCustomEventDetail()));
          } catch (err) {
            /* We use a setTimeout because if someone else's event handler throws an error, single-spa
             * needs to carry on. If a listener to the event throws an error, it's their own fault, not
             * single-spa's.
             */
            setTimeout(function () {
              throw err;
            });
          }
          /* Setting this allows for subsequent calls to reroute() to actually perform
           * a reroute instead of just getting queued behind the current reroute call.
           * We want to do this after the mounting/unmounting is done but before we
           * resolve the promise for the `reroute` function.
           */


          appChangeUnderway = false;

          if (peopleWaitingOnAppChange.length > 0) {
            /* While we were rerouting, someone else triggered another reroute that got queued.
             * So we need reroute again.
             */
            var nextPendingPromises = peopleWaitingOnAppChange;
            peopleWaitingOnAppChange = [];
            reroute(nextPendingPromises);
          }

          return returnValue;
        }
        /* We need to call all event listeners that have been delayed because they were
         * waiting on single-spa. This includes haschange and popstate events for both
         * the current run of performAppChanges(), but also all of the queued event listeners.
         * We want to call the listeners in the same order as if they had not been delayed by
         * single-spa, which means queued ones first and then the most recent one.
         */


        function callAllEventListeners() {
          pendingPromises.forEach(function (pendingPromise) {
            callCapturedEventListeners(pendingPromise.eventArguments);
          });
          callCapturedEventListeners(eventArguments);
        }

        function getCustomEventDetail() {
          var _appsByNewStatus;

          var isBeforeChanges = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
          var extraProperties = arguments.length > 1 ? arguments[1] : undefined;
          var newAppStatuses = {};
          var appsByNewStatus = (_appsByNewStatus = {}, _defineProperty(_appsByNewStatus, MOUNTED, []), _defineProperty(_appsByNewStatus, NOT_MOUNTED, []), _defineProperty(_appsByNewStatus, NOT_LOADED, []), _defineProperty(_appsByNewStatus, SKIP_BECAUSE_BROKEN, []), _appsByNewStatus);

          if (isBeforeChanges) {
            appsToLoad.concat(appsToMount).forEach(function (app, index) {
              addApp(app, MOUNTED);
            });
            appsToUnload.forEach(function (app) {
              addApp(app, NOT_LOADED);
            });
            appsToUnmount.forEach(function (app) {
              addApp(app, NOT_MOUNTED);
            });
          } else {
            appsThatChanged.forEach(function (app) {
              addApp(app);
            });
          }

          var result = {
            detail: {
              newAppStatuses: newAppStatuses,
              appsByNewStatus: appsByNewStatus,
              totalAppChanges: appsThatChanged.length,
              originalEvent: eventArguments === null || eventArguments === void 0 ? void 0 : eventArguments[0],
              oldUrl: oldUrl,
              newUrl: newUrl,
              navigationIsCanceled: navigationIsCanceled
            }
          };

          if (extraProperties) {
            assign(result.detail, extraProperties);
          }

          return result;

          function addApp(app, status) {
            var appName = toName(app);
            status = status || getAppStatus(appName);
            newAppStatuses[appName] = status;
            var statusArr = appsByNewStatus[status] = appsByNewStatus[status] || [];
            statusArr.push(appName);
          }
        }
      }
      /**
       * Let's imagine that some kind of delay occurred during application loading.
       * The user without waiting for the application to load switched to another route,
       * this means that we shouldn't bootstrap and mount that application, thus we check
       * twice if that application should be active before bootstrapping and mounting.
       * https://github.com/single-spa/single-spa/issues/524
       */

      function tryToBootstrapAndMount(app, unmountAllPromise) {
        if (shouldBeActive(app)) {
          return toBootstrapPromise(app).then(function (app) {
            return unmountAllPromise.then(function () {
              return shouldBeActive(app) ? toMountPromise(app) : app;
            });
          });
        } else {
          return unmountAllPromise.then(function () {
            return app;
          });
        }
      }

      var started = false;
      function start(opts) {
        started = true;

        if (opts && opts.urlRerouteOnly) {
          setUrlRerouteOnly(opts.urlRerouteOnly);
        }

        if (isInBrowser) {
          reroute();
        }
      }
      function isStarted() {
        return started;
      }

      if (isInBrowser) {
        setTimeout(function () {
          if (!started) {
            console.warn(formatErrorMessage(1,  "singleSpa.start() has not been called, 5000ms after single-spa was loaded. Before start() is called, apps can be declared and loaded, but not bootstrapped or mounted."));
          }
        }, 5000);
      }

      var devtools = {
        getRawAppData: getRawAppData,
        reroute: reroute,
        NOT_LOADED: NOT_LOADED,
        toLoadPromise: toLoadPromise,
        toBootstrapPromise: toBootstrapPromise,
        unregisterApplication: unregisterApplication
      };

      if (isInBrowser && window.__SINGLE_SPA_DEVTOOLS__) {
        window.__SINGLE_SPA_DEVTOOLS__.exposedMethods = devtools;
      }

    }
  };
});
//# sourceMappingURL=single-spa.dev.js.map