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

/* single-spa@5.3.0 - UMD - dev */
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
	typeof define === 'function' && define.amd ? define(['exports'], factory) :
	(global = global || self, factory(global.singleSpa = {}));
}(this, (function (exports) { 'use strict';

	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 getMountedApps () { return getMountedApps; },
		get getAppStatus () { return getAppStatus; },
		get unloadApplication () { return unloadApplication; },
		get checkActivityFunctions () { return checkActivityFunctions; },
		get getAppNames () { return getAppNames; },
		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; }
	});

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

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

	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 = "NOT_LOADED";
	var LOADING_SOURCE_CODE = "LOADING_SOURCE_CODE";
	var NOT_BOOTSTRAPPED = "NOT_BOOTSTRAPPED";
	var BOOTSTRAPPING = "BOOTSTRAPPING";
	var NOT_MOUNTED = "NOT_MOUNTED";
	var MOUNTING = "MOUNTING";
	var MOUNTED = "MOUNTED";
	var UPDATING = "UPDATING";
	var UNMOUNTING = "UNMOUNTING";
	var UNLOADING = "UNLOADING";
	var LOAD_ERROR = "LOAD_ERROR";
	var SKIP_BECAUSE_BROKEN = "SKIP_BECAUSE_BROKEN";
	function isActive(app) {
	  return app.status === MOUNTED;
	}
	function isntActive(app) {
	  return !isActive(app);
	}
	function isLoaded(app) {
	  return app.status !== NOT_LOADED && app.status !== LOADING_SOURCE_CODE && app.status !== LOAD_ERROR;
	}
	function isntLoaded(app) {
	  return !isLoaded(app);
	}
	function shouldBeActive(app) {
	  try {
	    return app.activeWhen(window.location);
	  } catch (err) {
	    handleAppError(err, app, SKIP_BECAUSE_BROKEN);
	  }
	}
	function shouldntBeActive(app) {
	  try {
	    return !shouldBeActive(app);
	  } catch (err) {
	    handleAppError(err, app, SKIP_BECAUSE_BROKEN);
	  }
	}
	function notSkipped(item) {
	  return item !== SKIP_BECAUSE_BROKEN && (!item || item.status !== SKIP_BECAUSE_BROKEN);
	}
	function withoutLoadErrors(app) {
	  return app.status === LOAD_ERROR ? new Date().getTime() - app.loadErrorTime >= 200 : true;
	}
	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;
	    return reasonableTime(appOrParcel, "bootstrap").then(function () {
	      appOrParcel.status = NOT_MOUNTED;
	      return appOrParcel;
	    }).catch(function (err) {
	      if (hardFail) {
	        throw transformErr(err, appOrParcel, SKIP_BECAUSE_BROKEN);
	      } else {
	        handleAppError(err, appOrParcel, SKIP_BECAUSE_BROKEN);
	        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() {
	      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 (!validLifecycleFn(config.bootstrap)) {
	      throw Error(formatErrorMessage(9,  "Parcel ".concat(name, " must have a valid 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 result = assign({}, appOrParcel.customProps, {
	    name: toName(appOrParcel),
	    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 (!validLifecycleFn(appOpts.bootstrap)) {
	          validationErrCode = 35;

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

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

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

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

	          {
	            validationErrMessage = "does not export a bootstrap 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.pathname) {
	    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);
	}

	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);
	  window.history.replaceState = patchedUpdateState(window.history.replaceState);

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

	      if (!urlRerouteOnly || urlBefore !== urlAfter) {
	        urlReroute(createPopStateEvent(window.history.state));
	      }

	      return result;
	    };
	  }

	  function createPopStateEvent(state) {
	    // 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.
	    try {
	      return 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
	      var evt = document.createEvent("PopStateEvent");
	      evt.initPopStateEvent("popstate", false, false, state);
	      return evt;
	    }
	  }
	  /* 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) {
	      /* The app cannot be unloaded until it is unmounted.
	       */
	      return app;
	    }

	    app.status = UNLOADING;
	    return reasonableTime(app, "unload").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];
	}
	function getAppsToUnload() {
	  return Object.keys(appsToUnload).map(function (appName) {
	    return appsToUnload[appName].app;
	  }).filter(isntActive);
	}

	var apps = [];
	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(location) {
	  return apps.filter(function (app) {
	    return app.activeWhen(location);
	  }).map(toName);
	}
	function getAppsToLoad() {
	  return apps.filter(notSkipped).filter(withoutLoadErrors).filter(isntLoaded).filter(shouldBeActive);
	}
	function getAppsToUnmount() {
	  return apps.filter(notSkipped).filter(isActive).filter(shouldntBeActive);
	}
	function getAppsToMount() {
	  return apps.filter(notSkipped).filter(isntActive).filter(isLoaded).filter(shouldBeActive);
	}
	function unregisterApplication(appName) {
	  if (!apps.find(function (app) {
	    return toName(app) === appName;
	  })) {
	    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.findIndex(function (app) {
	      return toName(app) === 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 (!!customProps && (_typeof(customProps) !== "object" || Array.isArray(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(31,  "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.includes(prop) ? invalidKeys : invalidKeys.concat(prop);
	  }, []);
	  if (invalidKeys.length !== 0) throw Error(formatErrorMessage(30,  "The configuration object accepts only: ".concat(validKeys.join(", "), ". Invalid keys: ").concat(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 (!(!config.customProps || _typeof(config.customProps) === "object" && !Array.isArray(config.customProps))) throw Error(formatErrorMessage(22,  "The optional config.customProps must be an object"));
	}

	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) {
	  var regex = toDynamicPathValidatorRegex(path);
	  return function (location) {
	    var route = location.href.replace(location.origin, "");
	    return regex.test(route);
	  };
	}

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

	  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;
	    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 = [];
	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 wasNoOp = true;

	  if (isStarted()) {
	    appChangeUnderway = true;
	    return performAppChanges();
	  } else {
	    return loadApps();
	  }

	  function loadApps() {
	    return Promise.resolve().then(function () {
	      var loadPromises = getAppsToLoad().map(toLoadPromise);

	      if (loadPromises.length > 0) {
	        wasNoOp = false;
	      }

	      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 () {
	      window.dispatchEvent(new customEvent("single-spa:before-routing-event", getCustomEventDetail()));
	      var unloadPromises = getAppsToUnload().map(toUnloadPromise);
	      var unmountUnloadPromises = getAppsToUnmount().map(toUnmountPromise).map(function (unmountPromise) {
	        return unmountPromise.then(toUnloadPromise);
	      });
	      var allUnmountPromises = unmountUnloadPromises.concat(unloadPromises);

	      if (allUnmountPromises.length > 0) {
	        wasNoOp = false;
	      }

	      var unmountAllPromise = Promise.all(allUnmountPromises);
	      var appsToLoad = getAppsToLoad();
	      /* 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(toBootstrapPromise).then(function (app) {
	          return unmountAllPromise.then(function () {
	            return toMountPromise(app);
	          });
	        });
	      });

	      if (loadThenMountPromises.length > 0) {
	        wasNoOp = false;
	      }
	      /* 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 = getAppsToMount().filter(function (appToMount) {
	        return appsToLoad.indexOf(appToMount) < 0;
	      }).map(function (appToMount) {
	        return toBootstrapPromise(appToMount).then(function () {
	          return unmountAllPromise;
	        }).then(function () {
	          return toMountPromise(appToMount);
	        });
	      });

	      if (mountPromises.length > 0) {
	        wasNoOp = false;
	      }

	      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 = wasNoOp ? "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 result = {
	      detail: {}
	    };

	    if (eventArguments && eventArguments[0]) {
	      result.detail.originalEvent = eventArguments[0];
	    }

	    return result;
	  }
	}

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

	exports.BOOTSTRAPPING = BOOTSTRAPPING;
	exports.LOADING_SOURCE_CODE = LOADING_SOURCE_CODE;
	exports.LOAD_ERROR = LOAD_ERROR;
	exports.MOUNTED = MOUNTED;
	exports.MOUNTING = MOUNTING;
	exports.NOT_BOOTSTRAPPED = NOT_BOOTSTRAPPED;
	exports.NOT_LOADED = NOT_LOADED;
	exports.NOT_MOUNTED = NOT_MOUNTED;
	exports.SKIP_BECAUSE_BROKEN = SKIP_BECAUSE_BROKEN;
	exports.UNMOUNTING = UNMOUNTING;
	exports.UPDATING = UPDATING;
	exports.addErrorHandler = addErrorHandler;
	exports.checkActivityFunctions = checkActivityFunctions;
	exports.ensureJQuerySupport = ensureJQuerySupport;
	exports.getAppNames = getAppNames;
	exports.getAppStatus = getAppStatus;
	exports.getMountedApps = getMountedApps;
	exports.mountRootParcel = mountRootParcel;
	exports.navigateToUrl = navigateToUrl;
	exports.registerApplication = registerApplication;
	exports.removeErrorHandler = removeErrorHandler;
	exports.setBootstrapMaxTime = setBootstrapMaxTime;
	exports.setMountMaxTime = setMountMaxTime;
	exports.setUnloadMaxTime = setUnloadMaxTime;
	exports.setUnmountMaxTime = setUnmountMaxTime;
	exports.start = start;
	exports.triggerAppChange = triggerAppChange;
	exports.unloadApplication = unloadApplication;

	Object.defineProperty(exports, '__esModule', { value: true });

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