{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap 715417e960c628c22933","webpack:///./~/core-js/library/modules/_wks.js","webpack:///./~/core-js/library/modules/_global.js","webpack:///./~/core-js/library/modules/_core.js","webpack:///./src/child-applications/child-app.helpers.js","webpack:///./~/core-js/library/modules/_an-object.js","webpack:///./~/core-js/library/modules/_descriptors.js","webpack:///./~/core-js/library/modules/_has.js","webpack:///./~/core-js/library/modules/_hide.js","webpack:///./~/core-js/library/modules/_object-dp.js","webpack:///./~/core-js/library/modules/_to-iobject.js","webpack:///./src/child-applications/child-app-errors.js","webpack:///./src/child-applications/timeouts.js","webpack:///./~/babel-runtime/helpers/asyncToGenerator.js","webpack:///./~/babel-runtime/regenerator/index.js","webpack:///./~/core-js/library/modules/_cof.js","webpack:///./~/core-js/library/modules/_fails.js","webpack:///./~/core-js/library/modules/_is-object.js","webpack:///./~/core-js/library/modules/_iterators.js","webpack:///./~/core-js/library/modules/_object-keys.js","webpack:///./src/navigation/reroute.js","webpack:///./~/core-js/library/modules/_ctx.js","webpack:///./~/core-js/library/modules/_export.js","webpack:///./~/core-js/library/modules/_library.js","webpack:///./~/core-js/library/modules/_object-pie.js","webpack:///./~/core-js/library/modules/_property-desc.js","webpack:///./~/core-js/library/modules/_set-to-string-tag.js","webpack:///./~/core-js/library/modules/_uid.js","webpack:///./src/loader.js","webpack:///./src/navigation/navigation-events.js","webpack:///./src/utils/find.js","webpack:///./~/core-js/library/modules/_a-function.js","webpack:///./~/core-js/library/modules/_defined.js","webpack:///./~/core-js/library/modules/_dom-create.js","webpack:///./~/core-js/library/modules/_enum-bug-keys.js","webpack:///./~/core-js/library/modules/_object-gops.js","webpack:///./~/core-js/library/modules/_shared-key.js","webpack:///./~/core-js/library/modules/_shared.js","webpack:///./~/core-js/library/modules/_to-integer.js","webpack:///./~/core-js/library/modules/_to-primitive.js","webpack:///./~/core-js/library/modules/_wks-define.js","webpack:///./~/core-js/library/modules/_wks-ext.js","webpack:///(webpack)/buildin/global.js","webpack:///./src/child-applications/child-apps.js","webpack:///./src/jquery-support.js","webpack:///./src/start.js","webpack:///./~/core-js/library/modules/_classof.js","webpack:///./~/core-js/library/modules/_html.js","webpack:///./~/core-js/library/modules/_ie8-dom-define.js","webpack:///./~/core-js/library/modules/_iobject.js","webpack:///./~/core-js/library/modules/_iter-define.js","webpack:///./~/core-js/library/modules/_object-create.js","webpack:///./~/core-js/library/modules/_object-gopn.js","webpack:///./~/core-js/library/modules/_object-keys-internal.js","webpack:///./~/core-js/library/modules/_redefine.js","webpack:///./~/core-js/library/modules/_task.js","webpack:///./~/core-js/library/modules/_to-length.js","webpack:///./~/core-js/library/modules/_to-object.js","webpack:///./~/core-js/library/modules/es6.string.iterator.js","webpack:///./~/core-js/library/modules/web.dom.iterable.js","webpack:///./~/custom-event/index.js","webpack:///./src/single-spa.js","webpack:///./src/child-applications/lifecycles/bootstrap.js","webpack:///./src/child-applications/lifecycles/load.js","webpack:///./src/child-applications/lifecycles/mount.js","webpack:///./src/child-applications/lifecycles/unmount.js","webpack:///./~/babel-runtime/core-js/object/assign.js","webpack:///./~/babel-runtime/core-js/promise.js","webpack:///./~/babel-runtime/core-js/symbol.js","webpack:///./~/babel-runtime/core-js/symbol/iterator.js","webpack:///./~/babel-runtime/helpers/extends.js","webpack:///./~/babel-runtime/helpers/typeof.js","webpack:///./~/core-js/library/fn/object/assign.js","webpack:///./~/core-js/library/fn/promise.js","webpack:///./~/core-js/library/fn/symbol/index.js","webpack:///./~/core-js/library/fn/symbol/iterator.js","webpack:///./~/core-js/library/modules/_add-to-unscopables.js","webpack:///./~/core-js/library/modules/_an-instance.js","webpack:///./~/core-js/library/modules/_array-includes.js","webpack:///./~/core-js/library/modules/_enum-keys.js","webpack:///./~/core-js/library/modules/_for-of.js","webpack:///./~/core-js/library/modules/_invoke.js","webpack:///./~/core-js/library/modules/_is-array-iter.js","webpack:///./~/core-js/library/modules/_is-array.js","webpack:///./~/core-js/library/modules/_iter-call.js","webpack:///./~/core-js/library/modules/_iter-create.js","webpack:///./~/core-js/library/modules/_iter-detect.js","webpack:///./~/core-js/library/modules/_iter-step.js","webpack:///./~/core-js/library/modules/_keyof.js","webpack:///./~/core-js/library/modules/_meta.js","webpack:///./~/core-js/library/modules/_microtask.js","webpack:///./~/core-js/library/modules/_object-assign.js","webpack:///./~/core-js/library/modules/_object-dps.js","webpack:///./~/core-js/library/modules/_object-gopd.js","webpack:///./~/core-js/library/modules/_object-gopn-ext.js","webpack:///./~/core-js/library/modules/_object-gpo.js","webpack:///./~/core-js/library/modules/_redefine-all.js","webpack:///./~/core-js/library/modules/_set-species.js","webpack:///./~/core-js/library/modules/_species-constructor.js","webpack:///./~/core-js/library/modules/_string-at.js","webpack:///./~/core-js/library/modules/_to-index.js","webpack:///./~/core-js/library/modules/core.get-iterator-method.js","webpack:///./~/core-js/library/modules/es6.array.iterator.js","webpack:///./~/core-js/library/modules/es6.object.assign.js","webpack:///./~/core-js/library/modules/es6.promise.js","webpack:///./~/core-js/library/modules/es6.symbol.js","webpack:///./~/core-js/library/modules/es7.symbol.async-iterator.js","webpack:///./~/core-js/library/modules/es7.symbol.observable.js","webpack:///./~/process/browser.js","webpack:///./~/regenerator-runtime/runtime-module.js","webpack:///./~/regenerator-runtime/runtime.js"],"names":["isActive","isntActive","isLoaded","isntLoaded","shouldBeActive","shouldntBeActive","notBootstrapped","notSkipped","toName","NOT_LOADED","LOADING_SOURCE_CODE","NOT_BOOTSTRAPPED","BOOTSTRAPPING","NOT_MOUNTED","MOUNTING","MOUNTED","UNMOUNTING","SKIP_BECAUSE_BROKEN","app","status","activeWhen","window","location","err","item","name","handleChildAppError","childApp","transformedErr","transformErr","console","log","dispatchEvent","detail","appName","SINGLE_SPA_TESTING","error","setTimeout","ogErr","errPrefix","result","Error","message","warn","JSON","stringify","setBootstrapMaxTime","setMountMaxTime","setUnmountMaxTime","reasonableTime","ensureValidAppTimeouts","globalTimeoutConfig","bootstrap","millis","dieOnTimeout","mount","unmount","time","promise","description","timeoutConfig","warningPeriod","Promise","resolve","reject","finished","errored","then","val","catch","maybeTimingOut","shouldError","numWarnings","numMillis","timeouts","reroute","appChangeUnderway","peopleWaitingOnAppChange","pendingPromises","loadPromises","map","length","wasNoOp","all","callAllEventListeners","finishUpAndReturn","loadApps","unmountPromises","unmountAllPromise","appsToLoad","loadThenMountPromises","mountPromises","filter","indexOf","appToMount","concat","forEach","performAppChanges","eventArguments","push","returnValue","nextPendingPromises","pendingPromise","setLoader","Loader","loader","import","navigateToUrl","callCapturedEventListeners","capturedEventListeners","hashchange","popstate","routingEventsListeningTo","obj","url","href","currentTarget","preventDefault","current","parseUri","destination","hash","anchor","isSamePath","path","host","history","pushState","eventType","type","listener","apply","urlReroute","arguments","addEventListener","originalAddEventListener","originalRemoveEventListener","removeEventListener","eventName","fn","listenerFn","toString","originalPushState","state","originalReplaceState","replaceState","singleSpaNavigate","str","parseOptions","strictMode","key","q","parser","strict","loose","o","m","exec","uri","i","replace","$0","$1","$2","find","arr","func","getMountedApps","getAppStatus","declareChildApplication","getAppsToLoad","getAppsToUnmount","getAppsToMount","childApps","arg1","arg2","loadImpl","ensureJQuerySupport","hasInitialized","jQuery","$","jquery","originalJQueryOn","on","originalJQueryOff","off","eventString","captureRoutingEvents","call","originalJQueryFunction","nativeFunctionToCall","originalArgs","eventNames","split","trim","start","isStarted","started","toBootstrapPromise","appOpts","validationErrMessage","validLifecycleFn","flattenFnArray","toLoadPromise","isArrayOfFns","Array","isArray","fns","waitForPromises","index","toMountPromise","toUnmountPromise"],"mappings":"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A,yBAAyB,kBAAkB,EAAE;;AAE7C;AACA;AACA;AACA;AACA,GAAG,UAAU;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACtBA,6E;;;;;;ACAA;AACA,qEAAsE,gBAAgB,UAAU,GAAG;AACnG,CAAC,E;;;;;;ACFD;AACA;AACA;AACA;AACA,E;;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,4BAA4B,aAAa;;AAEzC;AACA;AACA;AACA;AACA;AACA,wCAAwC,oCAAoC;AAC5E,4CAA4C,oCAAoC;AAChF,KAAK,2BAA2B,oCAAoC;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,mBAAmB;AACnC;AACA;AACA,iCAAiC,2BAA2B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,E;;;;;;ACrEA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;;;;;;ACxCA;AACA;AACA;;AAEA;AACA;AACA,E;;;;;;ACNA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;AChBA,wC;;;;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;AC1EA;AACA;AACA;AACA;AACA,2DAA2D;AAC3D,E;;;;;;ACLA;AACA;AACA;AACA;AACA,E;;;;;;;;;;;;;ACJA;AACA;;AAEA;AACA;AACA,6BAA6B;AAC7B,cAAc;AACd;AACA,CAAC;AACD;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA,UAAU;AACV,CAAC,E;;;;;;AChBD;AACA;AACA;AACA;AACA;;AAEA,wGAAwG,OAAO;AAC/G;AACA;AACA;AACA;AACA;AACA,C;;;;;;;ACXA;;AAEA;AACA;AACA,0CAA0C,UAAU,aAAa,EAAE;AACnE;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;gBC/CSF,K;;;;;;;;;wBACAlB,mB;;;;;;;;;mBACAnI,mB;;;;;;mBAAqBC,e;;;;;;mBAAiBC,iB;;;;;;;;;oBACtCyH,uB;;;;;;oBAAyBF,c;;;;;;oBAAgBC,Y;;;;;;;;;2BACzC7D,a;;;;;;;;;kBACAhC,O;;;;;;;;;iBACA4B,S;;;;;;;;;0BAGR9F,U;;;;;;0BACAC,mB;;;;;;0BACAC,gB;;;;;;0BACAC,a;;;;;;0BACAC,W;;;;;;0BACAC,Q;;;;;;0BACAC,O;;;;;;0BACAC,U;;;;;;0BACAC,mB;;;;;;;;;;;;;;;;;;;;;;;;;uECbM,iBAAkCC,GAAlC;AAAA;AAAA;AAAA;AAAA;AAAA,YACFA,IAAI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AAErT,sCAAsC,uCAAuC,gBAAgB;;AAE7F;AACA;AACA,CAAC;AACD;AACA,E;;;;;;ACpBA;AACA,sD;;;;;;ACDA;AACA;AACA;AACA;AACA,gD;;;;;;ACJA;AACA;AACA;AACA;AACA,+C;;;;;;ACJA;AACA;AACA,uD;;;;;;ACFA,4BAA4B,e;;;;;;ACA5B;AACA;AACA;AACA,GAAG;AACH,E;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,WAAW,eAAe;AAC/B;AACA,KAAK;AACL;AACA,E;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,E;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,iBAAiB,EAAE;AACxD;AACA;AACA;AACA;AACA;AACA,gEAAgE,gBAAgB;AAChF;AACA;AACA,GAAG,2CAA2C,gCAAgC;AAC9E;AACA;AACA;AACA;AACA;AACA,wB;;;;;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,E;;;;;;ACfA;AACA;AACA;AACA;;AAEA;AACA;AACA,E;;;;;;ACPA;AACA;AACA;AACA;AACA,E;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,E;;;;;;;ACXA;AACA;AACA;AACA;AACA;;AAEA;AACA,yFAAgF,aAAa,EAAE;;AAE/F;AACA,qDAAqD,0BAA0B;AAC/E;AACA,E;;;;;;ACZA;AACA;;AAEA;AACA;AACA,+BAA+B,qBAAqB;AACpD,+BAA+B,SAAS,EAAE;AAC1C,CAAC,UAAU;;AAEX;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,SAAS,mBAAmB;AACvD,+BAA+B,aAAa;AAC5C;AACA,GAAG,UAAU;AACb;AACA,E;;;;;;ACpBA;AACA,UAAU;AACV,E;;;;;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD;AACjD,CAAC;AACD;AACA,qBAAqB;AACrB;AACA,SAAS;AACT,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACpDA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,uCAAuC,oBAAoB,EAAE;AAC7D;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,E;;;;;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,UAAU,EAAE;AAC9C,mBAAmB,sCAAsC;AACzD,CAAC,oCAAoC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,CAAC,W;;;;;;AChCD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG,UAAU;AACb;AACA,E;;;;;;ACfA;AACA;AACA;AACA,kBAAkB;;AAElB;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;;;;;;AClBA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,E;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,E;;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oBAAoB,aAAa;AACjC,GAAG;AACH,E;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;;ACPA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC,cAAc;AACd,iBAAiB;AACjB;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;;AAEA;AACA;AACA,4B;;;;;;ACjCA;AACA;;AAEA,0CAA0C,gCAAoC,E;;;;;;;ACH9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;;AAEA;AACA;AACA;AACA;AACA,+CAA+C,sDAAiD,oBAAoB;AACpH;AACA;AACA,GAAG,UAAU;AACb,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA,WAAW;AACX,SAAS;AACT,OAAO;AACP;AACA;AACA;AACA,2CAA2C;AAC3C;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,mBAAmB,gCAAgC;AACnD,SAAS;AACT;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,eAAe,qCAAqC;AACpD;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA,uBAAuB,wBAAwB;AAC/C;AACA;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA,GAAG;AACH,kBAAkB,uBAAuB,KAAK;AAC9C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,iBAAiB;AACjB,wBAAwB;AACxB,gBAAgB;AAChB,oBAAoB;AACpB,wBAAwB;AACxB,gBAAgB;AAChB,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,0DAA0D,kBAAkB;AAC5E;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA,CAAC,E;;;;;;;AC1SD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,sBAAsB;AACtB,oBAAoB,uBAAuB,SAAS,IAAI;AACxD,GAAG;AACH,CAAC;AACD;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,CAAC;AACD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA,KAAK;AACL;AACA,sBAAsB,iCAAiC;AACvD,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,8BAA8B;AAC5F;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,0DAA0D,gBAAgB;;AAE1E;AACA;AACA;AACA,oBAAoB,oBAAoB;;AAExC,0CAA0C,oBAAoB;;AAE9D;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH,wBAAwB,eAAe,EAAE;AACzC,wBAAwB,gBAAgB;AACxC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,KAAK,QAAQ,iCAAiC;AAClG,CAAC;AACD;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0C;;;;;;AC1OA,yC;;;;;;ACAA,sC;;;;;;ACAA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA,4BAA4B,UAAU;;;;;;;ACnLtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,gBAAgB;AAChB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,KAAK;AACL,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA,WAAW;AACX;;AAEA;AACA;AACA,wCAAwC,WAAW;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAAS;AACT;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;;AAEA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iCAAiC,kBAAkB;AACnD;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA,iBAAiB;;AAEjB;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,wBAAwB,iBAAiB;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,YAAY;AACZ;AACA;;AAEA;AACA,YAAY;AACZ;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,8CAA8C,QAAQ;AACtD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA,WAAW;AACX;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA","file":"single-spa.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"singleSpa\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"singleSpa\"] = factory();\n\telse\n\t\troot[\"singleSpa\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmory imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmory exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tObject.defineProperty(exports, name, {\n \t\t\tconfigurable: false,\n \t\t\tenumerable: true,\n \t\t\tget: getter\n \t\t});\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 111);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 715417e960c628c22933","var store = require('./_shared')('wks')\n , uid = require('./_uid')\n , Symbol = require('./_global').Symbol\n , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n return store[name] || (store[name] =\n USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks.js\n// module id = 0\n// module chunks = 0","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_global.js\n// module id = 1\n// module chunks = 0","var core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_core.js\n// module id = 2\n// module chunks = 0","import { handleChildAppError } from './child-app-errors.js';\n\n// App statuses\nexport const NOT_LOADED = 'NOT_LOADED';\nexport const LOADING_SOURCE_CODE = 'LOADING_SOURCE_CODE';\nexport const NOT_BOOTSTRAPPED = 'NOT_BOOTSTRAPPED';\nexport const BOOTSTRAPPING = 'BOOTSTRAPPING';\nexport const NOT_MOUNTED = 'NOT_MOUNTED';\nexport const MOUNTING = 'MOUNTING';\nexport const MOUNTED = 'MOUNTED';\nexport const UNMOUNTING = 'UNMOUNTING';\nexport const SKIP_BECAUSE_BROKEN = 'SKIP_BECAUSE_BROKEN';\n\nexport function isActive(app) {\n\treturn app.status === MOUNTED;\n}\n\nexport function isntActive(app) {\n\treturn !isActive(app);\n}\n\nexport function isLoaded(app) {\n\treturn app.status !== NOT_LOADED && app.status !== LOADING_SOURCE_CODE;\n}\n\nexport function isntLoaded(app) {\n\treturn !isLoaded(app);\n}\n\nexport function shouldBeActive(app) {\n\ttry {\n\t\treturn app.activeWhen(window.location);\n\t} catch (err) {\n\t\thandleChildAppError(err, app);\n\t\tapp.status = SKIP_BECAUSE_BROKEN;\n\t}\n}\n\nexport function shouldntBeActive(app) {\n\ttry {\n\t\treturn !app.activeWhen(window.location);\n\t} catch (err) {\n\t\thandleChildAppError(err, app);\n\t\tapp.status = SKIP_BECAUSE_BROKEN;\n\t}\n}\n\nexport function notBootstrapped(app) {\n\treturn app.status !== NOT_BOOTSTRAPPED;\n}\n\nexport function notSkipped(item) {\n\treturn item !== SKIP_BECAUSE_BROKEN && (!item || item.status !== SKIP_BECAUSE_BROKEN);\n}\n\nexport function toName(app) {\n\treturn app.name;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/child-app.helpers.js","var isObject = require('./_is-object');\nmodule.exports = function(it){\n if(!isObject(it))throw TypeError(it + ' is not an object!');\n return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_an-object.js\n// module id = 4\n// module chunks = 0","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_descriptors.js\n// module id = 5\n// module chunks = 0","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n return hasOwnProperty.call(it, key);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_has.js\n// module id = 6\n// module chunks = 0","var dP = require('./_object-dp')\n , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n object[key] = value;\n return object;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_hide.js\n// module id = 7\n// module chunks = 0","var anObject = require('./_an-object')\n , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n , toPrimitive = require('./_to-primitive')\n , dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n anObject(O);\n P = toPrimitive(P, true);\n anObject(Attributes);\n if(IE8_DOM_DEFINE)try {\n return dP(O, P, Attributes);\n } catch(e){ /* empty */ }\n if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n if('value' in Attributes)O[P] = Attributes.value;\n return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dp.js\n// module id = 8\n// module chunks = 0","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n , defined = require('./_defined');\nmodule.exports = function(it){\n return IObject(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-iobject.js\n// module id = 9\n// module chunks = 0","import CustomEvent from 'custom-event';\n\nexport function handleChildAppError(err, childApp) {\n\tconst transformedErr = transformErr(err, childApp);\n\n\tconsole.log(\"dispatching\")\n\twindow.dispatchEvent(new CustomEvent(\"single-spa:application-broken\", {detail: {appName: childApp.name}}));\n\tconsole.log(\"done dispatching\")\n\n\tif (window.SINGLE_SPA_TESTING) {\n\t\tconsole.error(transformedErr);\n\t} else {\n\t\tsetTimeout(() => {\n\t\t\tthrow transformedErr;\n\t\t});\n\t}\n}\n\nfunction transformErr(ogErr, childApp) {\n\tconst errPrefix = `'${childApp.name}' died in status ${childApp.status}: `;\n\n\tlet result;\n\n\tif (ogErr instanceof Error) {\n\t\togErr.message = errPrefix + ogErr.message;\n\t\tresult = ogErr;\n\t} else {\n\t\tconsole.warn(`While ${childApp.status}, '${childApp.name}' rejected its lifecycle function promise with a non-Error. This will cause stack traces to not be accurate.`);\n\t\ttry {\n\t\t\tresult = new Error(errPrefix + JSON.stringify(ogErr));\n\t\t} catch(err) {\n\t\t\t// If it's not an Error and you can't stringify it, then what else can you even do to it?\n\t\t\tresult = ogErr;\n\t\t}\n\t}\n\n\treturn result;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/child-app-errors.js","const globalTimeoutConfig = {\n\tbootstrap: {\n\t\tmillis: 4000,\n\t\tdieOnTimeout: false,\n\t},\n\tmount: {\n\t\tmillis: 3000,\n\t\tdieOnTimeout: false,\n\t},\n\tunmount: {\n\t\tmillis: 3000,\n\t\tdieOnTimeout: false,\n\t},\n};\n\nexport function setBootstrapMaxTime(time, dieOnTimeout = false) {\n\tif (typeof time !== 'number' || time <= 0) {\n\t\tthrow new Error(`bootstrap max time must be a positive integer number of milliseconds`);\n\t}\n\n\tglobalTimeoutConfig.bootstrap = {\n\t\tmillis: time,\n\t\tdieOnTimeout,\n\t};\n}\n\nexport function setMountMaxTime(time, dieOnTimeout = false) {\n\tif (typeof time !== 'number' || time <= 0) {\n\t\tthrow new Error(`mount max time must be a positive integer number of milliseconds`);\n\t}\n\n\tglobalTimeoutConfig.mount = {\n\t\tmillis: time,\n\t\tdieOnTimeout,\n\t};\n}\n\nexport function setUnmountMaxTime(time, dieOnTimeout = false) {\n\tif (typeof time !== 'number' || time <= 0) {\n\t\tthrow new Error(`unmount max time must be a positive integer number of milliseconds`);\n\t}\n\n\tglobalTimeoutConfig.unmount = {\n\t\tmillis: time,\n\t\tdieOnTimeout,\n\t};\n}\n\nexport function reasonableTime(promise, description, timeoutConfig, app) {\n\tconst warningPeriod = 1000;\n\n\treturn new Promise((resolve, reject) => {\n\t\tlet finished = false;\n\t\tlet errored = false;\n\n\t\tpromise\n\t\t.then(val => {\n\t\t\tfinished = true;\n\t\t\tresolve(val);\n\t\t})\n\t\t.catch(val => {\n\t\t\tfinished = true;\n\t\t\treject(val);\n\t\t});\n\n\t\tsetTimeout(() => maybeTimingOut(1), warningPeriod);\n\t\tsetTimeout(() => maybeTimingOut(true), timeoutConfig.millis);\n\n\t\tfunction maybeTimingOut(shouldError) {\n\t\t\tif (!finished) {\n\t\t\t\tif (shouldError === true) {\n\t\t\t\t\terrored = true;\n\t\t\t\t\tif (timeoutConfig.dieOnTimeout) {\n\t\t\t\t\t\treject(`${description} did not resolve or reject for ${timeoutConfig.millis} milliseconds`);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconsole.error(`${description} did not resolve or reject for ${timeoutConfig.millis} milliseconds -- we're no longer going to warn you about it.`);\n\t\t\t\t\t\t//don't resolve or reject, we're waiting this one out\n\t\t\t\t\t}\n\t\t\t\t} else if (!errored) {\n\t\t\t\t\tconst numWarnings = shouldError;\n\t\t\t\t\tconst numMillis = numWarnings * warningPeriod;\n\t\t\t\t\tconsole.warn(`${description} did not resolve or reject within ${numMillis} milliseconds`);\n\t\t\t\t\tif (numMillis + warningPeriod < timeoutConfig.millis) {\n\t\t\t\t\t\tsetTimeout(() => maybeTimingOut(numWarnings + 1), warningPeriod);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t});\n}\n\nexport function ensureValidAppTimeouts(timeouts = {}) {\n\treturn {\n\t\t...globalTimeoutConfig,\n\t\t...timeouts,\n\t};\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/timeouts.js","\"use strict\";\n\nexports.__esModule = true;\n\nvar _promise = require(\"../core-js/promise\");\n\nvar _promise2 = _interopRequireDefault(_promise);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (fn) {\n return function () {\n var gen = fn.apply(this, arguments);\n return new _promise2.default(function (resolve, reject) {\n function step(key, arg) {\n try {\n var info = gen[key](arg);\n var value = info.value;\n } catch (error) {\n reject(error);\n return;\n }\n\n if (info.done) {\n resolve(value);\n } else {\n return _promise2.default.resolve(value).then(function (value) {\n step(\"next\", value);\n }, function (err) {\n step(\"throw\", err);\n });\n }\n }\n\n return step(\"next\");\n });\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/asyncToGenerator.js\n// module id = 12\n// module chunks = 0","module.exports = require(\"regenerator-runtime\");\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/regenerator/index.js\n// module id = 13\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = function(it){\n return toString.call(it).slice(8, -1);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_cof.js\n// module id = 14\n// module chunks = 0","module.exports = function(exec){\n try {\n return !!exec();\n } catch(e){\n return true;\n }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_fails.js\n// module id = 15\n// module chunks = 0","module.exports = function(it){\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-object.js\n// module id = 16\n// module chunks = 0","module.exports = {};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iterators.js\n// module id = 17\n// module chunks = 0","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal')\n , enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O){\n return $keys(O, enumBugKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys.js\n// module id = 18\n// module chunks = 0","import CustomEvent from 'custom-event';\nimport { isStarted } from 'src/start.js';\nimport { toLoadPromise } from 'src/child-applications/lifecycles/load.js';\nimport { toBootstrapPromise } from 'src/child-applications/lifecycles/bootstrap.js';\nimport { toMountPromise } from 'src/child-applications/lifecycles/mount.js';\nimport { toUnmountPromise } from 'src/child-applications/lifecycles/unmount.js';\nimport { getMountedApps, getAppsToLoad, getAppsToUnmount, getAppsToMount } from 'src/child-applications/child-apps.js';\nimport { notSkipped } from 'src/child-applications/child-app.helpers.js';\nimport { callCapturedEventListeners } from './navigation-events.js';\n\nlet appChangeUnderway = false, peopleWaitingOnAppChange = [];\n\nexport function reroute(pendingPromises = [], eventArguments) {\n\tif (appChangeUnderway) {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tpeopleWaitingOnAppChange.push({\n\t\t\t\tresolve,\n\t\t\t\treject,\n\t\t\t\teventArguments,\n\t\t\t});\n\t\t});\n\t}\n\n\tappChangeUnderway = true;\n\tlet wasNoOp = true;\n\n\tif (isStarted()) {\n\t\treturn performAppChanges();\n\t} else {\n\t\treturn loadApps();\n\t}\n\n\tasync function loadApps() {\n\t\tconst loadPromises = getAppsToLoad().map(toLoadPromise);\n\n\t\tif (loadPromises.length > 0) {\n\t\t\twasNoOp = false;\n\t\t}\n\n\t\ttry {\n\t\t\tawait Promise.all(loadPromises);\n\t\t} catch(err) {\n\t\t\tcallAllEventListeners();\n\t\t\tthrow err;\n\t\t}\n\n\t\treturn finishUpAndReturn();\n\t}\n\n\tasync function performAppChanges() {\n\t\tconst unmountPromises = getAppsToUnmount().map(toUnmountPromise);\n\t\tif (unmountPromises.length > 0) {\n\t\t\twasNoOp = false;\n\t\t}\n\t\tconst unmountAllPromise = Promise.all(unmountPromises);\n\n\t\tconst appsToLoad = getAppsToLoad();\n\n\t\t/* We load and bootstrap apps while other apps are unmounting, but we\n\t\t * wait to mount the app until all apps are finishing unmounting\n\t\t */\n\t\tconst loadThenMountPromises = appsToLoad.map(app => {\n\t\t\treturn toLoadPromise(app)\n\t\t\t\t.then(toBootstrapPromise)\n\t\t\t\t.then(async function(app) {\n\t\t\t\t\tawait unmountAllPromise;\n\t\t\t\t\treturn toMountPromise(app);\n\t\t\t\t})\n\t\t})\n\t\tif (loadThenMountPromises.length > 0) {\n\t\t\twasNoOp = false;\n\t\t}\n\n\t\t/* These are the apps that are already bootstrapped and just need\n\t\t * to be mounted. They each wait for all unmounting apps to finish up\n\t\t * before they mount.\n\t\t */\n\t\tconst mountPromises = getAppsToMount()\n\t\t\t.filter(appToMount => appsToLoad.indexOf(appToMount) < 0)\n\t\t\t.map(async function(appToMount) {\n\t\t\t\tawait toBootstrapPromise(appToMount);\n\t\t\t\tawait unmountAllPromise;\n\t\t\t\treturn toMountPromise(appToMount);\n\t\t\t})\n\t\tif (mountPromises.length > 0) {\n\t\t\twasNoOp = false;\n\t\t}\n\n\t\ttry {\n\t\t\tawait Promise.all(unmountPromises);\n\t\t} catch(err) {\n\t\t\tcallAllEventListeners();\n\t\t\tthrow err;\n\t\t}\n\n\t\t/* Now that the apps that needed to be unmounted are unmounted, their DOM navigation\n\t\t * events (like hashchange or popstate) should have been cleaned up. So it's safe\n\t\t * to let the remaining captured event listeners to handle about the DOM event.\n\t\t */\n\t\tcallAllEventListeners();\n\n\t\ttry {\n\t\t\tawait Promise.all(loadThenMountPromises.concat(mountPromises));\n\t\t} catch(err) {\n\t\t\tpendingPromises.forEach(promise => promise.reject(err));\n\t\t\tthrow err;\n\t\t}\n\n\t\treturn finishUpAndReturn();\n\t}\n\n\tfunction finishUpAndReturn() {\n\t\tconst returnValue = getMountedApps();\n\n\t\tcallAllEventListeners();\n\t\tpendingPromises.forEach(promise => promise.resolve(returnValue));\n\n\t\t/* Setting this allows for subsequent calls to reroute() to actually perform\n\t\t * a reroute instead of just getting queued behind the current reroute call.\n\t\t * We want to do this after the mounting/unmounting is done but before we\n\t\t * resolve the promise for the `reroute` async function.\n\t\t */\n\t\tappChangeUnderway = false;\n\n\t\tif (peopleWaitingOnAppChange.length > 0) {\n\t\t\t/* While we were rerouting, someone else triggered another reroute that got queued.\n\t\t\t * So we need reroute again.\n\t\t\t */\n\t\t\tconst nextPendingPromises = peopleWaitingOnAppChange;\n\t\t\tpeopleWaitingOnAppChange = [];\n\t\t\treroute(nextPendingPromises);\n\t\t} else {\n\t\t\tsetTimeout(() => {\n\t\t\t\tif (!wasNoOp) {\n\t\t\t\t\twindow.dispatchEvent(new CustomEvent(\"single-spa:app-change\"));\n\t\t\t\t}\n\n\t\t\t\twindow.dispatchEvent(new CustomEvent(\"single-spa:routing-event\"));\n\t\t\t});\n\t\t}\n\n\t\treturn returnValue;\n\t}\n\n\t/* We need to call all event listeners that have been delayed because they were\n\t * waiting on single-spa. This includes haschange and popstate events for both\n\t * the current run of performAppChanges(), but also all of the queued event listeners.\n\t * We want to call the listeners in the same order as if they had not been delayed by\n\t * single-spa, which means queued ones first and then the most recent one.\n\t */\n\tfunction callAllEventListeners() {\n\t\tpendingPromises.forEach(pendingPromise => {\n\t\t\tcallCapturedEventListeners(pendingPromise.eventArguments);\n\t\t});\n\n\t\tcallCapturedEventListeners(eventArguments);\n\t}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/navigation/reroute.js","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n aFunction(fn);\n if(that === undefined)return fn;\n switch(length){\n case 1: return function(a){\n return fn.call(that, a);\n };\n case 2: return function(a, b){\n return fn.call(that, a, b);\n };\n case 3: return function(a, b, c){\n return fn.call(that, a, b, c);\n };\n }\n return function(/* ...args */){\n return fn.apply(that, arguments);\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ctx.js\n// module id = 20\n// module chunks = 0","var global = require('./_global')\n , core = require('./_core')\n , ctx = require('./_ctx')\n , hide = require('./_hide')\n , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n var IS_FORCED = type & $export.F\n , IS_GLOBAL = type & $export.G\n , IS_STATIC = type & $export.S\n , IS_PROTO = type & $export.P\n , IS_BIND = type & $export.B\n , IS_WRAP = type & $export.W\n , exports = IS_GLOBAL ? core : core[name] || (core[name] = {})\n , expProto = exports[PROTOTYPE]\n , target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n , key, own, out;\n if(IS_GLOBAL)source = name;\n for(key in source){\n // contains in native\n own = !IS_FORCED && target && target[key] !== undefined;\n if(own && key in exports)continue;\n // export native or passed\n out = own ? target[key] : source[key];\n // prevent global pollution for namespaces\n exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n // bind timers to global for call from export context\n : IS_BIND && own ? ctx(out, global)\n // wrap global constructors for prevent change them in library\n : IS_WRAP && target[key] == out ? (function(C){\n var F = function(a, b, c){\n if(this instanceof C){\n switch(arguments.length){\n case 0: return new C;\n case 1: return new C(a);\n case 2: return new C(a, b);\n } return new C(a, b, c);\n } return C.apply(this, arguments);\n };\n F[PROTOTYPE] = C[PROTOTYPE];\n return F;\n // make static versions for prototype methods\n })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n if(IS_PROTO){\n (exports.virtual || (exports.virtual = {}))[key] = out;\n // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n }\n }\n};\n// type bitmap\n$export.F = 1; // forced\n$export.G = 2; // global\n$export.S = 4; // static\n$export.P = 8; // proto\n$export.B = 16; // bind\n$export.W = 32; // wrap\n$export.U = 64; // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_export.js\n// module id = 21\n// module chunks = 0","module.exports = true;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_library.js\n// module id = 22\n// module chunks = 0","exports.f = {}.propertyIsEnumerable;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-pie.js\n// module id = 23\n// module chunks = 0","module.exports = function(bitmap, value){\n return {\n enumerable : !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable : !(bitmap & 4),\n value : value\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_property-desc.js\n// module id = 24\n// module chunks = 0","var def = require('./_object-dp').f\n , has = require('./_has')\n , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-to-string-tag.js\n// module id = 25\n// module chunks = 0","var id = 0\n , px = Math.random();\nmodule.exports = function(key){\n return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_uid.js\n// module id = 26\n// module chunks = 0","export let Loader = null;\n\nexport function setLoader(loader) {\n\tif (!loader || typeof loader.import !== 'function') {\n\t\tthrow new Error(`'loader' is not a real loader. Must have an import function that returns a Promise`);\n\t}\n\tLoader = loader;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/loader.js","import { reroute } from './reroute.js';\nimport { find } from 'src/utils/find.js';\n\n/* We capture navigation event listeners so that we can make sure\n * that child application navigation listeners are not called until\n * single-spa has ensured that the correct child applications are\n * unmounted and mounted.\n */\nconst capturedEventListeners = {\n\thashchange: [],\n\tpopstate: [],\n};\n\nexport const routingEventsListeningTo = ['hashchange', 'popstate'];\n\nexport function navigateToUrl(obj) {\n\tlet url;\n\tif (typeof obj === 'string') {\n\t\turl = obj ;\n\t} else if (this && this.href) {\n\t\turl = this.href;\n\t} else if (obj && obj.currentTarget && obj.currentTarget.href && obj.preventDefault) {\n\t\turl = obj.currentTarget.href;\n\t\tobj.preventDefault();\n\t} else {\n\t\tthrow new Error(`singleSpaNavigate must be either called with a string url, with an tag as its context, or with an event whose currentTarget is an tag`);\n\t}\n\n\tconst current = parseUri(window.location.href);\n\tconst destination = parseUri(url);\n\n\tif (url.indexOf('#') === 0) {\n\t\twindow.location.hash = '#' + destination.anchor;\n\t} else if (!isSamePath(destination.path, current.path) || (current.host !== destination.host && destination.host)) {\n\t\t// different path or a different host\n\t\twindow.history.pushState(null, null, url);\n\t} else {\n\t\twindow.location.hash = '#' + destination.anchor;\n\t}\n\n\tfunction isSamePath(destination, current) {\n\t\t// if the destination has a path but no domain, it doesn't include the root '/'\n\t\treturn current === destination || current === '/' + destination;\n\t}\n}\n\nexport function callCapturedEventListeners(eventArguments) {\n\tif (eventArguments) {\n\t\tconst eventType = eventArguments[0].type;\n\t\tif (routingEventsListeningTo.indexOf(eventType) >= 0) {\n\t\t\tcapturedEventListeners[eventType].forEach(listener => {\n\t\t\t\tlistener.apply(this, eventArguments);\n\t\t\t});\n\t\t}\n\t}\n}\n\nfunction urlReroute() {\n\treroute([], arguments)\n}\n\n\n// We will trigger an app change for any routing events.\nwindow.addEventListener('hashchange', urlReroute);\nwindow.addEventListener('popstate', urlReroute);\n\n// Monkeypatch addEventListener so that we can ensure correct timing\nconst originalAddEventListener = window.addEventListener;\nconst originalRemoveEventListener = window.removeEventListener;\nwindow.addEventListener = function(eventName, fn) {\n\tif (typeof fn === 'function') {\n\t\tif (routingEventsListeningTo.indexOf(eventName) >= 0 && !find(capturedEventListeners[eventName], listener => listener === fn)) {\n\t\t\tcapturedEventListeners[eventName].push(fn);\n\t\t\treturn;\n\t\t}\n\t}\n\n\treturn originalAddEventListener.apply(this, arguments);\n}\n\nwindow.removeEventListener = function(eventName, listenerFn) {\n\tif (typeof listenerFn === 'function') {\n\t\tif (routingEventsListeningTo.indexOf(eventName) >= 0) {\n\t\t\tcapturedEventListeners[eventName] = capturedEventListeners[eventName].filter(fn => fn.toString() !== listenerFn.toString());\n\t\t\treturn;\n\t\t}\n\t}\n\n\treturn originalRemoveEventListener.apply(this, arguments);\n}\n\nconst originalPushState = window.history.pushState;\nwindow.history.pushState = function(state) {\n\tconst result = originalPushState.apply(this, arguments);\n\n\treroute();\n\t\n\treturn result;\n}\n\nconst originalReplaceState = window.history.replaceState;\nwindow.history.replaceState = function() {\n\tconst result = originalReplaceState.apply(this, arguments);\n\treroute();\n\treturn result;\n}\n\n/* For convenience in `onclick` attributes, we expose a global function for navigating to\n * whatever an tag's href is.\n */\nwindow.singleSpaNavigate = navigateToUrl;\n\nfunction parseUri(str) {\n\t// parseUri 1.2.2\n\t// (c) Steven Levithan \n\t// MIT License\n\t// http://blog.stevenlevithan.com/archives/parseuri\n\tconst parseOptions = {\n\t\tstrictMode: true,\n\t\tkey: [\"source\",\"protocol\",\"authority\",\"userInfo\",\"user\",\"password\",\"host\",\"port\",\"relative\",\"path\",\"directory\",\"file\",\"query\",\"anchor\"],\n\t\tq: {\n\t\t\tname: \"queryKey\",\n\t\t\tparser: /(?:^|&)([^&=]*)=?([^&]*)/g\n\t\t},\n\t\tparser: {\n\t\t\tstrict: /^(?:([^:\\/?#]+):)?(?:\\/\\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\\/?#]*)(?::(\\d*))?))?((((?:[^?#\\/]*\\/)*)([^?#]*))(?:\\?([^#]*))?(?:#(.*))?)/,\n\t\t\tloose: /^(?:(?![^:@]+:[^:@\\/]*@)([^:\\/?#.]+):)?(?:\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/\n\t\t}\n\t};\n\n\tlet\to = parseOptions;\n\tlet m = o.parser[o.strictMode ? \"strict\" : \"loose\"].exec(str);\n\tlet uri = {};\n\tlet i = 14;\n\n\twhile (i--) uri[o.key[i]] = m[i] || \"\";\n\n\turi[o.q.name] = {};\n\turi[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {\n\t\tif ($1) uri[o.q.name][$1] = $2;\n\t});\n\n\treturn uri;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/navigation/navigation-events.js","/* the array.prototype.find polyfill on npmjs.com is ~20kb (not worth it)\n * and lodash is ~200kb (not worth it)\n */\n\nexport function find(arr, func) {\n\tfor (let i=0; i 0 ? floor : ceil)(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-integer.js\n// module id = 37\n// module chunks = 0","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n if(!isObject(it))return it;\n var fn, val;\n if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-primitive.js\n// module id = 38\n// module chunks = 0","var global = require('./_global')\n , core = require('./_core')\n , LIBRARY = require('./_library')\n , wksExt = require('./_wks-ext')\n , defineProperty = require('./_object-dp').f;\nmodule.exports = function(name){\n var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks-define.js\n// module id = 39\n// module chunks = 0","exports.f = require('./_wks');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks-ext.js\n// module id = 40\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() { return this; })();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 41\n// module chunks = 0","import { Loader } from '../loader.js';\nimport { ensureJQuerySupport } from '../jquery-support.js';\nimport { isActive, isLoaded, isntLoaded, toName, NOT_LOADED, shouldBeActive, shouldntBeActive, isntActive, notSkipped } from './child-app.helpers.js';\nimport { reroute } from 'src/navigation/reroute.js';\nimport { find } from 'src/utils/find.js';\n\nconst childApps = [];\n\nexport function getMountedApps() {\n\treturn childApps.filter(isActive).map(toName);\n}\n\nexport function getAppStatus(appName) {\n\tconst app = find(childApps, app => app.name === appName);\n\treturn app ? app.status : null;\n}\n\nexport function declareChildApplication(appName, arg1, arg2) {\n\tif (typeof appName !== 'string' || appName.length === 0)\n\t\tthrow new Error(`The first argument must be a non-empty string 'appName'`);\n\tif (childApps[appName])\n\t\tthrow new Error(`There is already an app declared with name ${appName}`);\n\n\tlet loadImpl, activeWhen;\n\tif (!arg2) {\n\t\tif (!Loader) {\n\t\t\tthrow new Error(`You cannot declare a single-spa child application without either providing a way to load the application or a Loader. See https://github.com/CanopyTax/single-spa/blob/master/docs/single-spa-api.md#declarechildapplication`);\n\t\t}\n\t\tloadImpl = () => Loader.import(appName);\n\t\tactiveWhen = arg1;\n\t} else {\n\t\tloadImpl = arg1;\n\t\tactiveWhen = arg2;\n\t}\n\tif (typeof activeWhen !== 'function')\n\t\tthrow new Error(`The activeWhen argument must be a function`);\n\n\tchildApps.push({\n\t\tname: appName,\n\t\tloadImpl,\n\t\tactiveWhen,\n\t\tstatus: NOT_LOADED,\n\t});\n\n\tensureJQuerySupport();\n\n\treroute();\n}\n\nexport function getAppsToLoad() {\n\treturn childApps\n\t\t.filter(shouldBeActive)\n\t\t.filter(notSkipped)\n\t\t.filter(isntLoaded)\n}\n\nexport function getAppsToUnmount() {\n\treturn childApps\n\t\t.filter(shouldntBeActive)\n\t\t.filter(notSkipped)\n\t\t.filter(isActive)\n}\n\nexport function getAppsToMount() {\n\treturn childApps\n\t\t.filter(shouldBeActive)\n\t\t.filter(notSkipped)\n\t\t.filter(isntActive)\n\t\t.filter(isLoaded)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/child-apps.js","import { routingEventsListeningTo } from './navigation/navigation-events.js';\n\nlet hasInitialized = false;\n\nexport function ensureJQuerySupport(jQuery = window.jQuery) {\n\tif (!jQuery) {\n\t\tif (window.$ && window.$.fn && window.$.fn.jquery) {\n\t\t\tjQuery = window.$;\n\t\t}\n\t}\n\n\tif (jQuery && !hasInitialized) {\n\t\tconst originalJQueryOn = jQuery.fn.on;\n\t\tconst originalJQueryOff = jQuery.fn.off;\n\n\t\tjQuery.fn.on = function(eventString, fn) {\n\t\t\treturn captureRoutingEvents.call(this, originalJQueryOn, window.addEventListener, eventString, fn, arguments);\n\t\t}\n\n\t\tjQuery.fn.off = function(eventString, fn) {\n\t\t\treturn captureRoutingEvents.call(this, originalJQueryOff, window.removeEventListener, eventString, fn, arguments);\n\t\t}\n\n\t\thasInitialized = true;\n\t}\n}\n\nfunction captureRoutingEvents(originalJQueryFunction, nativeFunctionToCall, eventString, fn, originalArgs) {\n\tif (typeof eventString !== 'string') {\n\t\treturn originalJQueryFunction.apply(this, originalArgs);\n\t}\n\n\tconst eventNames = eventString.split(/\\s+/);\n\teventNames.forEach(eventName => {\n\t\tif (routingEventsListeningTo.indexOf(eventName) >= 0) {\n\t\t\tnativeFunctionToCall(eventName, fn);\n\t\t\teventString = eventString.replace(eventName, '');\n\t\t}\n\t});\n\n\tif (eventString.trim() === '') {\n\t\treturn this;\n\t} else {\n\t\treturn originalJQueryFunction.apply(this, originalArgs);\n\t}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/jquery-support.js","import { reroute } from './navigation/reroute.js';\nimport { setLoader } from './loader.js';\n\nexport let started = false;\n\nexport function start() {\n\tstarted = true;\n\treroute();\n}\n\nexport function isStarted() {\n\treturn started;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/start.js","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof')\n , TAG = require('./_wks')('toStringTag')\n // ES3 wrong here\n , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n try {\n return it[key];\n } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n var O, T, B;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n // builtinTag case\n : ARG ? cof(O)\n // ES3 arguments fallback\n : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_classof.js\n// module id = 45\n// module chunks = 0","module.exports = require('./_global').document && document.documentElement;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_html.js\n// module id = 46\n// module chunks = 0","module.exports = !require('./_descriptors') && !require('./_fails')(function(){\n return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ie8-dom-define.js\n// module id = 47\n// module chunks = 0","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iobject.js\n// module id = 48\n// module chunks = 0","'use strict';\nvar LIBRARY = require('./_library')\n , $export = require('./_export')\n , redefine = require('./_redefine')\n , hide = require('./_hide')\n , has = require('./_has')\n , Iterators = require('./_iterators')\n , $iterCreate = require('./_iter-create')\n , setToStringTag = require('./_set-to-string-tag')\n , getPrototypeOf = require('./_object-gpo')\n , ITERATOR = require('./_wks')('iterator')\n , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n , FF_ITERATOR = '@@iterator'\n , KEYS = 'keys'\n , VALUES = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n $iterCreate(Constructor, NAME, next);\n var getMethod = function(kind){\n if(!BUGGY && kind in proto)return proto[kind];\n switch(kind){\n case KEYS: return function keys(){ return new Constructor(this, kind); };\n case VALUES: return function values(){ return new Constructor(this, kind); };\n } return function entries(){ return new Constructor(this, kind); };\n };\n var TAG = NAME + ' Iterator'\n , DEF_VALUES = DEFAULT == VALUES\n , VALUES_BUG = false\n , proto = Base.prototype\n , $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n , $default = $native || getMethod(DEFAULT)\n , $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n , methods, key, IteratorPrototype;\n // Fix native\n if($anyNative){\n IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n if(IteratorPrototype !== Object.prototype){\n // Set @@toStringTag to native iterators\n setToStringTag(IteratorPrototype, TAG, true);\n // fix for some old engines\n if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n }\n }\n // fix Array#{values, @@iterator}.name in V8 / FF\n if(DEF_VALUES && $native && $native.name !== VALUES){\n VALUES_BUG = true;\n $default = function values(){ return $native.call(this); };\n }\n // Define iterator\n if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n hide(proto, ITERATOR, $default);\n }\n // Plug for library\n Iterators[NAME] = $default;\n Iterators[TAG] = returnThis;\n if(DEFAULT){\n methods = {\n values: DEF_VALUES ? $default : getMethod(VALUES),\n keys: IS_SET ? $default : getMethod(KEYS),\n entries: $entries\n };\n if(FORCED)for(key in methods){\n if(!(key in proto))redefine(proto, key, methods[key]);\n } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n }\n return methods;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-define.js\n// module id = 49\n// module chunks = 0","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = require('./_an-object')\n , dPs = require('./_object-dps')\n , enumBugKeys = require('./_enum-bug-keys')\n , IE_PROTO = require('./_shared-key')('IE_PROTO')\n , Empty = function(){ /* empty */ }\n , PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n // Thrash, waste and sodomy: IE GC bug\n var iframe = require('./_dom-create')('iframe')\n , i = enumBugKeys.length\n , lt = '<'\n , gt = '>'\n , iframeDocument;\n iframe.style.display = 'none';\n require('./_html').appendChild(iframe);\n iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n // createDict = iframe.contentWindow.Object;\n // html.removeChild(iframe);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n iframeDocument.close();\n createDict = iframeDocument.F;\n while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties){\n var result;\n if(O !== null){\n Empty[PROTOTYPE] = anObject(O);\n result = new Empty;\n Empty[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = createDict();\n return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-create.js\n// module id = 50\n// module chunks = 0","// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\nvar $keys = require('./_object-keys-internal')\n , hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');\n\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){\n return $keys(O, hiddenKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gopn.js\n// module id = 51\n// module chunks = 0","var has = require('./_has')\n , toIObject = require('./_to-iobject')\n , arrayIndexOf = require('./_array-includes')(false)\n , IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function(object, names){\n var O = toIObject(object)\n , i = 0\n , result = []\n , key;\n for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n // Don't enum bug & hidden keys\n while(names.length > i)if(has(O, key = names[i++])){\n ~arrayIndexOf(result, key) || result.push(key);\n }\n return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys-internal.js\n// module id = 52\n// module chunks = 0","module.exports = require('./_hide');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine.js\n// module id = 53\n// module chunks = 0","var ctx = require('./_ctx')\n , invoke = require('./_invoke')\n , html = require('./_html')\n , cel = require('./_dom-create')\n , global = require('./_global')\n , process = global.process\n , setTask = global.setImmediate\n , clearTask = global.clearImmediate\n , MessageChannel = global.MessageChannel\n , counter = 0\n , queue = {}\n , ONREADYSTATECHANGE = 'onreadystatechange'\n , defer, channel, port;\nvar run = function(){\n var id = +this;\n if(queue.hasOwnProperty(id)){\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\nvar listener = function(event){\n run.call(event.data);\n};\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif(!setTask || !clearTask){\n setTask = function setImmediate(fn){\n var args = [], i = 1;\n while(arguments.length > i)args.push(arguments[i++]);\n queue[++counter] = function(){\n invoke(typeof fn == 'function' ? fn : Function(fn), args);\n };\n defer(counter);\n return counter;\n };\n clearTask = function clearImmediate(id){\n delete queue[id];\n };\n // Node.js 0.8-\n if(require('./_cof')(process) == 'process'){\n defer = function(id){\n process.nextTick(ctx(run, id, 1));\n };\n // Browsers with MessageChannel, includes WebWorkers\n } else if(MessageChannel){\n channel = new MessageChannel;\n port = channel.port2;\n channel.port1.onmessage = listener;\n defer = ctx(port.postMessage, port, 1);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){\n defer = function(id){\n global.postMessage(id + '', '*');\n };\n global.addEventListener('message', listener, false);\n // IE8-\n } else if(ONREADYSTATECHANGE in cel('script')){\n defer = function(id){\n html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){\n html.removeChild(this);\n run.call(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function(id){\n setTimeout(ctx(run, id, 1), 0);\n };\n }\n}\nmodule.exports = {\n set: setTask,\n clear: clearTask\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_task.js\n// module id = 54\n// module chunks = 0","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n , min = Math.min;\nmodule.exports = function(it){\n return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-length.js\n// module id = 55\n// module chunks = 0","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n return Object(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-object.js\n// module id = 56\n// module chunks = 0","'use strict';\nvar $at = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function(iterated){\n this._t = String(iterated); // target\n this._i = 0; // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n var O = this._t\n , index = this._i\n , point;\n if(index >= O.length)return {value: undefined, done: true};\n point = $at(O, index);\n this._i += point.length;\n return {value: point, done: false};\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.string.iterator.js\n// module id = 58\n// module chunks = 0","require('./es6.array.iterator');\nvar global = require('./_global')\n , hide = require('./_hide')\n , Iterators = require('./_iterators')\n , TO_STRING_TAG = require('./_wks')('toStringTag');\n\nfor(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){\n var NAME = collections[i]\n , Collection = global[NAME]\n , proto = Collection && Collection.prototype;\n if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);\n Iterators[NAME] = Iterators.Array;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/web.dom.iterable.js\n// module id = 59\n// module chunks = 0","\nvar NativeCustomEvent = global.CustomEvent;\n\nfunction useNative () {\n try {\n var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });\n return 'cat' === p.type && 'bar' === p.detail.foo;\n } catch (e) {\n }\n return false;\n}\n\n/**\n * Cross-browser `CustomEvent` constructor.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent\n *\n * @public\n */\n\nmodule.exports = useNative() ? NativeCustomEvent :\n\n// IE >= 9\n'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) {\n var e = document.createEvent('CustomEvent');\n if (params) {\n e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);\n } else {\n e.initCustomEvent(type, false, false, void 0);\n }\n return e;\n} :\n\n// IE <= 8\nfunction CustomEvent (type, params) {\n var e = document.createEventObject();\n e.type = type;\n if (params) {\n e.bubbles = Boolean(params.bubbles);\n e.cancelable = Boolean(params.cancelable);\n e.detail = params.detail;\n } else {\n e.bubbles = false;\n e.cancelable = false;\n e.detail = void 0;\n }\n return e;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/custom-event/index.js\n// module id = 60\n// module chunks = 0","export { start } from './start.js';\nexport { ensureJQuerySupport } from './jquery-support.js';\nexport { setBootstrapMaxTime, setMountMaxTime, setUnmountMaxTime } from './child-applications/timeouts.js';\nexport { declareChildApplication, getMountedApps, getAppStatus } from './child-applications/child-apps.js';\nexport { navigateToUrl } from './navigation/navigation-events.js';\nexport { reroute as triggerAppChange } from './navigation/reroute.js';\nexport { setLoader } from './loader.js';\n\nexport {\n\tNOT_LOADED,\n\tLOADING_SOURCE_CODE,\n\tNOT_BOOTSTRAPPED,\n\tBOOTSTRAPPING,\n\tNOT_MOUNTED,\n\tMOUNTING,\n\tMOUNTED,\n\tUNMOUNTING,\n\tSKIP_BECAUSE_BROKEN,\n} from './child-applications/child-app.helpers.js';\n\n\n\n// WEBPACK FOOTER //\n// ./src/single-spa.js","import { NOT_BOOTSTRAPPED, BOOTSTRAPPING, NOT_MOUNTED, SKIP_BECAUSE_BROKEN } from '../child-app.helpers.js';\nimport { reasonableTime } from '../timeouts.js';\nimport { handleChildAppError } from 'src/child-applications/child-app-errors.js';\n\nexport async function toBootstrapPromise(app) {\n\tif (app.status !== NOT_BOOTSTRAPPED) {\n\t\treturn app;\n\t}\n\n\tapp.status = BOOTSTRAPPING;\n\n\ttry {\n\t\tawait reasonableTime(app.bootstrap(), `Bootstrapping app '${app.name}'`, app.timeouts.bootstrap);\n\t\tapp.status = NOT_MOUNTED;\n\t} catch(err) {\n\t\tapp.status = SKIP_BECAUSE_BROKEN;\n\t\thandleChildAppError(err, app);\n\t}\n\n\treturn app;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/lifecycles/bootstrap.js","import { NOT_BOOTSTRAPPED, LOADING_SOURCE_CODE, SKIP_BECAUSE_BROKEN, NOT_LOADED } from '../child-app.helpers.js';\nimport { ensureValidAppTimeouts } from '../timeouts.js';\nimport { handleChildAppError } from '../child-app-errors.js';\nimport { find } from 'src/utils/find.js';\n\nexport async function toLoadPromise(app) {\n\tif (app.status !== NOT_LOADED) {\n\t\treturn app;\n\t}\n\n\tapp.status = LOADING_SOURCE_CODE;\n\n\tlet appOpts;\n\n\ttry {\n\t\tappOpts = await app.loadImpl();\n\t} catch(err) {\n\t\thandleChildAppError(err, app);\n\t\tapp.status = SKIP_BECAUSE_BROKEN;\n\t\treturn app;\n\t}\n\n\tlet validationErrMessage;\n\n\tif (typeof appOpts !== 'object') {\n\t\tvalidationErrMessage = `does not export anything`;\n\t}\n\n\tif (!validLifecycleFn(appOpts.bootstrap)) {\n\t\tvalidationErrMessage = `does not export a bootstrap function or array of functions`;\n\t}\n\n\tif (!validLifecycleFn(appOpts.mount)) {\n\t\tvalidationErrMessage = `does not export a mount function or array of functions`;\n\t}\n\n\tif (!validLifecycleFn(appOpts.unmount)) {\n\t\tvalidationErrMessage = `does not export an unmount function or array of functions`;\n\t}\n\n\tif (validationErrMessage) {\n\t\thandleChildAppError(validationErrMessage, app);\n\t\tapp.status = SKIP_BECAUSE_BROKEN;\n\t\treturn app;\n\t}\n\n\tapp.status = NOT_BOOTSTRAPPED;\n\tapp.bootstrap = flattenFnArray(appOpts.bootstrap, `App '${app.name}' bootstrap function`);\n\tapp.mount = flattenFnArray(appOpts.mount, `App '${app.name}' mount function`);\n\tapp.unmount = flattenFnArray(appOpts.unmount, `App '${app.name}' unmount function`);\n\tapp.timeouts = ensureValidAppTimeouts(appOpts.timeouts);\n\n\treturn app;\n}\n\nfunction validLifecycleFn(fn) {\n\treturn fn && (typeof fn === 'function' || isArrayOfFns(fn));\n\n\tfunction isArrayOfFns(arr) {\n\t\treturn Array.isArray(arr) && !find(arr, item => typeof item !== 'function');\n\t}\n}\n\nfunction flattenFnArray(fns, description) {\n\tfns = Array.isArray(fns) ? fns : [fns];\n\tif (fns.length === 0) {\n\t\tfns = [() => Promise.resolve()];\n\t}\n\n\treturn function() {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\twaitForPromises(0);\n\n\t\t\tfunction waitForPromises(index) {\n\t\t\t\tconst promise = fns[index]();\n\t\t\t\tif (!promise || typeof promise.then !== 'function' || typeof promise.catch !== 'function') {\n\t\t\t\t\treject(`${description} at index ${index} did not return a promise`);\n\t\t\t\t} else {\n\t\t\t\t\tpromise\n\t\t\t\t\t.then(() => {\n\t\t\t\t\t\tif (index === fns.length - 1) {\n\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\twaitForPromises(index + 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t\t.catch(reject);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/lifecycles/load.js","import { NOT_MOUNTED, MOUNTED, SKIP_BECAUSE_BROKEN } from '../child-app.helpers.js';\nimport { handleChildAppError } from '../child-app-errors.js';\nimport { reasonableTime } from '../timeouts.js';\n\nexport async function toMountPromise(app) {\n\tif (app.status !== NOT_MOUNTED) {\n\t\treturn app;\n\t}\n\ttry {\n\t\tawait reasonableTime(app.mount(), `Mounting application ${app.name}'`, app.timeouts.mount);\n\t\tapp.status = MOUNTED;\n\t} catch (err) {\n\t\thandleChildAppError(err, app);\n\t\tapp.status = SKIP_BECAUSE_BROKEN;\n\t}\n\n\treturn app;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/lifecycles/mount.js","import { UNMOUNTING, NOT_MOUNTED, MOUNTED, SKIP_BECAUSE_BROKEN } from '../child-app.helpers.js';\nimport { handleChildAppError } from '../child-app-errors.js';\nimport { reasonableTime } from '../timeouts.js';\n\nexport async function toUnmountPromise(app) {\n\tif (app.status !== MOUNTED) {\n\t\treturn app;\n\t}\n\tapp.status = UNMOUNTING;\n\n\ttry {\n\t\tawait reasonableTime(app.unmount(), `Unmounting application ${app.name}'`, app.timeouts.unmount);\n\t\tapp.status = NOT_MOUNTED;\n\t} catch (err) {\n\t\thandleChildAppError(err, app);\n\t\tapp.status = SKIP_BECAUSE_BROKEN;\n\t}\n\n\treturn app;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/child-applications/lifecycles/unmount.js","module.exports = { \"default\": require(\"core-js/library/fn/object/assign\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/assign.js\n// module id = 66\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/promise\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/promise.js\n// module id = 67\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/symbol\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/symbol.js\n// module id = 68\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/symbol/iterator\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/symbol/iterator.js\n// module id = 69\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _assign = require(\"../core-js/object/assign\");\n\nvar _assign2 = _interopRequireDefault(_assign);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _assign2.default || function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n\n return target;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/extends.js\n// module id = 70\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _iterator = require(\"../core-js/symbol/iterator\");\n\nvar _iterator2 = _interopRequireDefault(_iterator);\n\nvar _symbol = require(\"../core-js/symbol\");\n\nvar _symbol2 = _interopRequireDefault(_symbol);\n\nvar _typeof = typeof _symbol2.default === \"function\" && typeof _iterator2.default === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj; };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = typeof _symbol2.default === \"function\" && _typeof(_iterator2.default) === \"symbol\" ? function (obj) {\n return typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n} : function (obj) {\n return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/typeof.js\n// module id = 71\n// module chunks = 0","require('../../modules/es6.object.assign');\nmodule.exports = require('../../modules/_core').Object.assign;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/assign.js\n// module id = 72\n// module chunks = 0","require('../modules/es6.object.to-string');\nrequire('../modules/es6.string.iterator');\nrequire('../modules/web.dom.iterable');\nrequire('../modules/es6.promise');\nmodule.exports = require('../modules/_core').Promise;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/promise.js\n// module id = 73\n// module chunks = 0","require('../../modules/es6.symbol');\nrequire('../../modules/es6.object.to-string');\nrequire('../../modules/es7.symbol.async-iterator');\nrequire('../../modules/es7.symbol.observable');\nmodule.exports = require('../../modules/_core').Symbol;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/symbol/index.js\n// module id = 74\n// module chunks = 0","require('../../modules/es6.string.iterator');\nrequire('../../modules/web.dom.iterable');\nmodule.exports = require('../../modules/_wks-ext').f('iterator');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/symbol/iterator.js\n// module id = 75\n// module chunks = 0","module.exports = function(){ /* empty */ };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_add-to-unscopables.js\n// module id = 76\n// module chunks = 0","module.exports = function(it, Constructor, name, forbiddenField){\n if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){\n throw TypeError(name + ': incorrect invocation!');\n } return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_an-instance.js\n// module id = 77\n// module chunks = 0","// false -> Array#indexOf\n// true -> Array#includes\nvar toIObject = require('./_to-iobject')\n , toLength = require('./_to-length')\n , toIndex = require('./_to-index');\nmodule.exports = function(IS_INCLUDES){\n return function($this, el, fromIndex){\n var O = toIObject($this)\n , length = toLength(O.length)\n , index = toIndex(fromIndex, length)\n , value;\n // Array#includes uses SameValueZero equality algorithm\n if(IS_INCLUDES && el != el)while(length > index){\n value = O[index++];\n if(value != value)return true;\n // Array#toIndex ignores holes, Array#includes - not\n } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n if(O[index] === el)return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_array-includes.js\n// module id = 78\n// module chunks = 0","// all enumerable object keys, includes symbols\nvar getKeys = require('./_object-keys')\n , gOPS = require('./_object-gops')\n , pIE = require('./_object-pie');\nmodule.exports = function(it){\n var result = getKeys(it)\n , getSymbols = gOPS.f;\n if(getSymbols){\n var symbols = getSymbols(it)\n , isEnum = pIE.f\n , i = 0\n , key;\n while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);\n } return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_enum-keys.js\n// module id = 79\n// module chunks = 0","var ctx = require('./_ctx')\n , call = require('./_iter-call')\n , isArrayIter = require('./_is-array-iter')\n , anObject = require('./_an-object')\n , toLength = require('./_to-length')\n , getIterFn = require('./core.get-iterator-method')\n , BREAK = {}\n , RETURN = {};\nvar exports = module.exports = function(iterable, entries, fn, that, ITERATOR){\n var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)\n , f = ctx(fn, that, entries ? 2 : 1)\n , index = 0\n , length, step, iterator, result;\n if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');\n // fast case for arrays with default iterator\n if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){\n result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n if(result === BREAK || result === RETURN)return result;\n } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){\n result = call(iterator, f, step.value, entries);\n if(result === BREAK || result === RETURN)return result;\n }\n};\nexports.BREAK = BREAK;\nexports.RETURN = RETURN;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_for-of.js\n// module id = 80\n// module chunks = 0","// fast apply, http://jsperf.lnkit.com/fast-apply/5\nmodule.exports = function(fn, args, that){\n var un = that === undefined;\n switch(args.length){\n case 0: return un ? fn()\n : fn.call(that);\n case 1: return un ? fn(args[0])\n : fn.call(that, args[0]);\n case 2: return un ? fn(args[0], args[1])\n : fn.call(that, args[0], args[1]);\n case 3: return un ? fn(args[0], args[1], args[2])\n : fn.call(that, args[0], args[1], args[2]);\n case 4: return un ? fn(args[0], args[1], args[2], args[3])\n : fn.call(that, args[0], args[1], args[2], args[3]);\n } return fn.apply(that, args);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_invoke.js\n// module id = 81\n// module chunks = 0","// check on default Array iterator\nvar Iterators = require('./_iterators')\n , ITERATOR = require('./_wks')('iterator')\n , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-array-iter.js\n// module id = 82\n// module chunks = 0","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg){\n return cof(arg) == 'Array';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-array.js\n// module id = 83\n// module chunks = 0","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function(iterator, fn, value, entries){\n try {\n return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n // 7.4.6 IteratorClose(iterator, completion)\n } catch(e){\n var ret = iterator['return'];\n if(ret !== undefined)anObject(ret.call(iterator));\n throw e;\n }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-call.js\n// module id = 84\n// module chunks = 0","'use strict';\nvar create = require('./_object-create')\n , descriptor = require('./_property-desc')\n , setToStringTag = require('./_set-to-string-tag')\n , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-create.js\n// module id = 85\n// module chunks = 0","var ITERATOR = require('./_wks')('iterator')\n , SAFE_CLOSING = false;\n\ntry {\n var riter = [7][ITERATOR]();\n riter['return'] = function(){ SAFE_CLOSING = true; };\n Array.from(riter, function(){ throw 2; });\n} catch(e){ /* empty */ }\n\nmodule.exports = function(exec, skipClosing){\n if(!skipClosing && !SAFE_CLOSING)return false;\n var safe = false;\n try {\n var arr = [7]\n , iter = arr[ITERATOR]();\n iter.next = function(){ return {done: safe = true}; };\n arr[ITERATOR] = function(){ return iter; };\n exec(arr);\n } catch(e){ /* empty */ }\n return safe;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-detect.js\n// module id = 86\n// module chunks = 0","module.exports = function(done, value){\n return {value: value, done: !!done};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-step.js\n// module id = 87\n// module chunks = 0","var getKeys = require('./_object-keys')\n , toIObject = require('./_to-iobject');\nmodule.exports = function(object, el){\n var O = toIObject(object)\n , keys = getKeys(O)\n , length = keys.length\n , index = 0\n , key;\n while(length > index)if(O[key = keys[index++]] === el)return key;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_keyof.js\n// module id = 88\n// module chunks = 0","var META = require('./_uid')('meta')\n , isObject = require('./_is-object')\n , has = require('./_has')\n , setDesc = require('./_object-dp').f\n , id = 0;\nvar isExtensible = Object.isExtensible || function(){\n return true;\n};\nvar FREEZE = !require('./_fails')(function(){\n return isExtensible(Object.preventExtensions({}));\n});\nvar setMeta = function(it){\n setDesc(it, META, {value: {\n i: 'O' + ++id, // object ID\n w: {} // weak collections IDs\n }});\n};\nvar fastKey = function(it, create){\n // return primitive with prefix\n if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if(!has(it, META)){\n // can't set metadata to uncaught frozen object\n if(!isExtensible(it))return 'F';\n // not necessary to add metadata\n if(!create)return 'E';\n // add missing metadata\n setMeta(it);\n // return object ID\n } return it[META].i;\n};\nvar getWeak = function(it, create){\n if(!has(it, META)){\n // can't set metadata to uncaught frozen object\n if(!isExtensible(it))return true;\n // not necessary to add metadata\n if(!create)return false;\n // add missing metadata\n setMeta(it);\n // return hash weak collections IDs\n } return it[META].w;\n};\n// add metadata on freeze-family methods calling\nvar onFreeze = function(it){\n if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);\n return it;\n};\nvar meta = module.exports = {\n KEY: META,\n NEED: false,\n fastKey: fastKey,\n getWeak: getWeak,\n onFreeze: onFreeze\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_meta.js\n// module id = 89\n// module chunks = 0","var global = require('./_global')\n , macrotask = require('./_task').set\n , Observer = global.MutationObserver || global.WebKitMutationObserver\n , process = global.process\n , Promise = global.Promise\n , isNode = require('./_cof')(process) == 'process';\n\nmodule.exports = function(){\n var head, last, notify;\n\n var flush = function(){\n var parent, fn;\n if(isNode && (parent = process.domain))parent.exit();\n while(head){\n fn = head.fn;\n head = head.next;\n try {\n fn();\n } catch(e){\n if(head)notify();\n else last = undefined;\n throw e;\n }\n } last = undefined;\n if(parent)parent.enter();\n };\n\n // Node.js\n if(isNode){\n notify = function(){\n process.nextTick(flush);\n };\n // browsers with MutationObserver\n } else if(Observer){\n var toggle = true\n , node = document.createTextNode('');\n new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new\n notify = function(){\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if(Promise && Promise.resolve){\n var promise = Promise.resolve();\n notify = function(){\n promise.then(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessag\n // - onreadystatechange\n // - setTimeout\n } else {\n notify = function(){\n // strange IE + webpack dev server bug - use .call(global)\n macrotask.call(global, flush);\n };\n }\n\n return function(fn){\n var task = {fn: fn, next: undefined};\n if(last)last.next = task;\n if(!head){\n head = task;\n notify();\n } last = task;\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_microtask.js\n// module id = 90\n// module chunks = 0","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar getKeys = require('./_object-keys')\n , gOPS = require('./_object-gops')\n , pIE = require('./_object-pie')\n , toObject = require('./_to-object')\n , IObject = require('./_iobject')\n , $assign = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function(){\n var A = {}\n , B = {}\n , S = Symbol()\n , K = 'abcdefghijklmnopqrst';\n A[S] = 7;\n K.split('').forEach(function(k){ B[k] = k; });\n return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source){ // eslint-disable-line no-unused-vars\n var T = toObject(target)\n , aLen = arguments.length\n , index = 1\n , getSymbols = gOPS.f\n , isEnum = pIE.f;\n while(aLen > index){\n var S = IObject(arguments[index++])\n , keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)\n , length = keys.length\n , j = 0\n , key;\n while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];\n } return T;\n} : $assign;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-assign.js\n// module id = 91\n// module chunks = 0","var dP = require('./_object-dp')\n , anObject = require('./_an-object')\n , getKeys = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){\n anObject(O);\n var keys = getKeys(Properties)\n , length = keys.length\n , i = 0\n , P;\n while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dps.js\n// module id = 92\n// module chunks = 0","var pIE = require('./_object-pie')\n , createDesc = require('./_property-desc')\n , toIObject = require('./_to-iobject')\n , toPrimitive = require('./_to-primitive')\n , has = require('./_has')\n , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n , gOPD = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P){\n O = toIObject(O);\n P = toPrimitive(P, true);\n if(IE8_DOM_DEFINE)try {\n return gOPD(O, P);\n } catch(e){ /* empty */ }\n if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gopd.js\n// module id = 93\n// module chunks = 0","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./_to-iobject')\n , gOPN = require('./_object-gopn').f\n , toString = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function(it){\n try {\n return gOPN(it);\n } catch(e){\n return windowNames.slice();\n }\n};\n\nmodule.exports.f = function getOwnPropertyNames(it){\n return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gopn-ext.js\n// module id = 94\n// module chunks = 0","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = require('./_has')\n , toObject = require('./_to-object')\n , IE_PROTO = require('./_shared-key')('IE_PROTO')\n , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n O = toObject(O);\n if(has(O, IE_PROTO))return O[IE_PROTO];\n if(typeof O.constructor == 'function' && O instanceof O.constructor){\n return O.constructor.prototype;\n } return O instanceof Object ? ObjectProto : null;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gpo.js\n// module id = 95\n// module chunks = 0","var hide = require('./_hide');\nmodule.exports = function(target, src, safe){\n for(var key in src){\n if(safe && target[key])target[key] = src[key];\n else hide(target, key, src[key]);\n } return target;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine-all.js\n// module id = 96\n// module chunks = 0","'use strict';\nvar global = require('./_global')\n , core = require('./_core')\n , dP = require('./_object-dp')\n , DESCRIPTORS = require('./_descriptors')\n , SPECIES = require('./_wks')('species');\n\nmodule.exports = function(KEY){\n var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];\n if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {\n configurable: true,\n get: function(){ return this; }\n });\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-species.js\n// module id = 97\n// module chunks = 0","// 7.3.20 SpeciesConstructor(O, defaultConstructor)\nvar anObject = require('./_an-object')\n , aFunction = require('./_a-function')\n , SPECIES = require('./_wks')('species');\nmodule.exports = function(O, D){\n var C = anObject(O).constructor, S;\n return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_species-constructor.js\n// module id = 98\n// module chunks = 0","var toInteger = require('./_to-integer')\n , defined = require('./_defined');\n// true -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n return function(that, pos){\n var s = String(defined(that))\n , i = toInteger(pos)\n , l = s.length\n , a, b;\n if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n a = s.charCodeAt(i);\n return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n ? TO_STRING ? s.charAt(i) : a\n : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_string-at.js\n// module id = 99\n// module chunks = 0","var toInteger = require('./_to-integer')\n , max = Math.max\n , min = Math.min;\nmodule.exports = function(index, length){\n index = toInteger(index);\n return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-index.js\n// module id = 100\n// module chunks = 0","var classof = require('./_classof')\n , ITERATOR = require('./_wks')('iterator')\n , Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function(it){\n if(it != undefined)return it[ITERATOR]\n || it['@@iterator']\n || Iterators[classof(it)];\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/core.get-iterator-method.js\n// module id = 101\n// module chunks = 0","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables')\n , step = require('./_iter-step')\n , Iterators = require('./_iterators')\n , toIObject = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){\n this._t = toIObject(iterated); // target\n this._i = 0; // next index\n this._k = kind; // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function(){\n var O = this._t\n , kind = this._k\n , index = this._i++;\n if(!O || index >= O.length){\n this._t = undefined;\n return step(1);\n }\n if(kind == 'keys' )return step(0, index);\n if(kind == 'values')return step(0, O[index]);\n return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.array.iterator.js\n// module id = 102\n// module chunks = 0","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', {assign: require('./_object-assign')});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.assign.js\n// module id = 103\n// module chunks = 0","'use strict';\nvar LIBRARY = require('./_library')\n , global = require('./_global')\n , ctx = require('./_ctx')\n , classof = require('./_classof')\n , $export = require('./_export')\n , isObject = require('./_is-object')\n , aFunction = require('./_a-function')\n , anInstance = require('./_an-instance')\n , forOf = require('./_for-of')\n , speciesConstructor = require('./_species-constructor')\n , task = require('./_task').set\n , microtask = require('./_microtask')()\n , PROMISE = 'Promise'\n , TypeError = global.TypeError\n , process = global.process\n , $Promise = global[PROMISE]\n , process = global.process\n , isNode = classof(process) == 'process'\n , empty = function(){ /* empty */ }\n , Internal, GenericPromiseCapability, Wrapper;\n\nvar USE_NATIVE = !!function(){\n try {\n // correct subclassing with @@species support\n var promise = $Promise.resolve(1)\n , FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function(exec){ exec(empty, empty); };\n // unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;\n } catch(e){ /* empty */ }\n}();\n\n// helpers\nvar sameConstructor = function(a, b){\n // with library wrapper special case\n return a === b || a === $Promise && b === Wrapper;\n};\nvar isThenable = function(it){\n var then;\n return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n};\nvar newPromiseCapability = function(C){\n return sameConstructor($Promise, C)\n ? new PromiseCapability(C)\n : new GenericPromiseCapability(C);\n};\nvar PromiseCapability = GenericPromiseCapability = function(C){\n var resolve, reject;\n this.promise = new C(function($$resolve, $$reject){\n if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aFunction(resolve);\n this.reject = aFunction(reject);\n};\nvar perform = function(exec){\n try {\n exec();\n } catch(e){\n return {error: e};\n }\n};\nvar notify = function(promise, isReject){\n if(promise._n)return;\n promise._n = true;\n var chain = promise._c;\n microtask(function(){\n var value = promise._v\n , ok = promise._s == 1\n , i = 0;\n var run = function(reaction){\n var handler = ok ? reaction.ok : reaction.fail\n , resolve = reaction.resolve\n , reject = reaction.reject\n , domain = reaction.domain\n , result, then;\n try {\n if(handler){\n if(!ok){\n if(promise._h == 2)onHandleUnhandled(promise);\n promise._h = 1;\n }\n if(handler === true)result = value;\n else {\n if(domain)domain.enter();\n result = handler(value);\n if(domain)domain.exit();\n }\n if(result === reaction.promise){\n reject(TypeError('Promise-chain cycle'));\n } else if(then = isThenable(result)){\n then.call(result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch(e){\n reject(e);\n }\n };\n while(chain.length > i)run(chain[i++]); // variable length - can't use forEach\n promise._c = [];\n promise._n = false;\n if(isReject && !promise._h)onUnhandled(promise);\n });\n};\nvar onUnhandled = function(promise){\n task.call(global, function(){\n var value = promise._v\n , abrupt, handler, console;\n if(isUnhandled(promise)){\n abrupt = perform(function(){\n if(isNode){\n process.emit('unhandledRejection', value, promise);\n } else if(handler = global.onunhandledrejection){\n handler({promise: promise, reason: value});\n } else if((console = global.console) && console.error){\n console.error('Unhandled promise rejection', value);\n }\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n promise._h = isNode || isUnhandled(promise) ? 2 : 1;\n } promise._a = undefined;\n if(abrupt)throw abrupt.error;\n });\n};\nvar isUnhandled = function(promise){\n if(promise._h == 1)return false;\n var chain = promise._a || promise._c\n , i = 0\n , reaction;\n while(chain.length > i){\n reaction = chain[i++];\n if(reaction.fail || !isUnhandled(reaction.promise))return false;\n } return true;\n};\nvar onHandleUnhandled = function(promise){\n task.call(global, function(){\n var handler;\n if(isNode){\n process.emit('rejectionHandled', promise);\n } else if(handler = global.onrejectionhandled){\n handler({promise: promise, reason: promise._v});\n }\n });\n};\nvar $reject = function(value){\n var promise = this;\n if(promise._d)return;\n promise._d = true;\n promise = promise._w || promise; // unwrap\n promise._v = value;\n promise._s = 2;\n if(!promise._a)promise._a = promise._c.slice();\n notify(promise, true);\n};\nvar $resolve = function(value){\n var promise = this\n , then;\n if(promise._d)return;\n promise._d = true;\n promise = promise._w || promise; // unwrap\n try {\n if(promise === value)throw TypeError(\"Promise can't be resolved itself\");\n if(then = isThenable(value)){\n microtask(function(){\n var wrapper = {_w: promise, _d: false}; // wrap\n try {\n then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));\n } catch(e){\n $reject.call(wrapper, e);\n }\n });\n } else {\n promise._v = value;\n promise._s = 1;\n notify(promise, false);\n }\n } catch(e){\n $reject.call({_w: promise, _d: false}, e); // wrap\n }\n};\n\n// constructor polyfill\nif(!USE_NATIVE){\n // 25.4.3.1 Promise(executor)\n $Promise = function Promise(executor){\n anInstance(this, $Promise, PROMISE, '_h');\n aFunction(executor);\n Internal.call(this);\n try {\n executor(ctx($resolve, this, 1), ctx($reject, this, 1));\n } catch(err){\n $reject.call(this, err);\n }\n };\n Internal = function Promise(executor){\n this._c = []; // <- awaiting reactions\n this._a = undefined; // <- checked in isUnhandled reactions\n this._s = 0; // <- state\n this._d = false; // <- done\n this._v = undefined; // <- value\n this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled\n this._n = false; // <- notify\n };\n Internal.prototype = require('./_redefine-all')($Promise.prototype, {\n // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)\n then: function then(onFulfilled, onRejected){\n var reaction = newPromiseCapability(speciesConstructor(this, $Promise));\n reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;\n reaction.fail = typeof onRejected == 'function' && onRejected;\n reaction.domain = isNode ? process.domain : undefined;\n this._c.push(reaction);\n if(this._a)this._a.push(reaction);\n if(this._s)notify(this, false);\n return reaction.promise;\n },\n // 25.4.5.1 Promise.prototype.catch(onRejected)\n 'catch': function(onRejected){\n return this.then(undefined, onRejected);\n }\n });\n PromiseCapability = function(){\n var promise = new Internal;\n this.promise = promise;\n this.resolve = ctx($resolve, promise, 1);\n this.reject = ctx($reject, promise, 1);\n };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});\nrequire('./_set-to-string-tag')($Promise, PROMISE);\nrequire('./_set-species')(PROMISE);\nWrapper = require('./_core')[PROMISE];\n\n// statics\n$export($export.S + $export.F * !USE_NATIVE, PROMISE, {\n // 25.4.4.5 Promise.reject(r)\n reject: function reject(r){\n var capability = newPromiseCapability(this)\n , $$reject = capability.reject;\n $$reject(r);\n return capability.promise;\n }\n});\n$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {\n // 25.4.4.6 Promise.resolve(x)\n resolve: function resolve(x){\n // instanceof instead of internal slot check because we should fix it without replacement native Promise core\n if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;\n var capability = newPromiseCapability(this)\n , $$resolve = capability.resolve;\n $$resolve(x);\n return capability.promise;\n }\n});\n$export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function(iter){\n $Promise.all(iter)['catch'](empty);\n})), PROMISE, {\n // 25.4.4.1 Promise.all(iterable)\n all: function all(iterable){\n var C = this\n , capability = newPromiseCapability(C)\n , resolve = capability.resolve\n , reject = capability.reject;\n var abrupt = perform(function(){\n var values = []\n , index = 0\n , remaining = 1;\n forOf(iterable, false, function(promise){\n var $index = index++\n , alreadyCalled = false;\n values.push(undefined);\n remaining++;\n C.resolve(promise).then(function(value){\n if(alreadyCalled)return;\n alreadyCalled = true;\n values[$index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if(abrupt)reject(abrupt.error);\n return capability.promise;\n },\n // 25.4.4.4 Promise.race(iterable)\n race: function race(iterable){\n var C = this\n , capability = newPromiseCapability(C)\n , reject = capability.reject;\n var abrupt = perform(function(){\n forOf(iterable, false, function(promise){\n C.resolve(promise).then(capability.resolve, reject);\n });\n });\n if(abrupt)reject(abrupt.error);\n return capability.promise;\n }\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.promise.js\n// module id = 104\n// module chunks = 0","'use strict';\n// ECMAScript 6 symbols shim\nvar global = require('./_global')\n , has = require('./_has')\n , DESCRIPTORS = require('./_descriptors')\n , $export = require('./_export')\n , redefine = require('./_redefine')\n , META = require('./_meta').KEY\n , $fails = require('./_fails')\n , shared = require('./_shared')\n , setToStringTag = require('./_set-to-string-tag')\n , uid = require('./_uid')\n , wks = require('./_wks')\n , wksExt = require('./_wks-ext')\n , wksDefine = require('./_wks-define')\n , keyOf = require('./_keyof')\n , enumKeys = require('./_enum-keys')\n , isArray = require('./_is-array')\n , anObject = require('./_an-object')\n , toIObject = require('./_to-iobject')\n , toPrimitive = require('./_to-primitive')\n , createDesc = require('./_property-desc')\n , _create = require('./_object-create')\n , gOPNExt = require('./_object-gopn-ext')\n , $GOPD = require('./_object-gopd')\n , $DP = require('./_object-dp')\n , $keys = require('./_object-keys')\n , gOPD = $GOPD.f\n , dP = $DP.f\n , gOPN = gOPNExt.f\n , $Symbol = global.Symbol\n , $JSON = global.JSON\n , _stringify = $JSON && $JSON.stringify\n , PROTOTYPE = 'prototype'\n , HIDDEN = wks('_hidden')\n , TO_PRIMITIVE = wks('toPrimitive')\n , isEnum = {}.propertyIsEnumerable\n , SymbolRegistry = shared('symbol-registry')\n , AllSymbols = shared('symbols')\n , OPSymbols = shared('op-symbols')\n , ObjectProto = Object[PROTOTYPE]\n , USE_NATIVE = typeof $Symbol == 'function'\n , QObject = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function(){\n return _create(dP({}, 'a', {\n get: function(){ return dP(this, 'a', {value: 7}).a; }\n })).a != 7;\n}) ? function(it, key, D){\n var protoDesc = gOPD(ObjectProto, key);\n if(protoDesc)delete ObjectProto[key];\n dP(it, key, D);\n if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);\n} : dP;\n\nvar wrap = function(tag){\n var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n sym._k = tag;\n return sym;\n};\n\nvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){\n return typeof it == 'symbol';\n} : function(it){\n return it instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(it, key, D){\n if(it === ObjectProto)$defineProperty(OPSymbols, key, D);\n anObject(it);\n key = toPrimitive(key, true);\n anObject(D);\n if(has(AllSymbols, key)){\n if(!D.enumerable){\n if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));\n it[HIDDEN][key] = true;\n } else {\n if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;\n D = _create(D, {enumerable: createDesc(0, false)});\n } return setSymbolDesc(it, key, D);\n } return dP(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P){\n anObject(it);\n var keys = enumKeys(P = toIObject(P))\n , i = 0\n , l = keys.length\n , key;\n while(l > i)$defineProperty(it, key = keys[i++], P[key]);\n return it;\n};\nvar $create = function create(it, P){\n return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key){\n var E = isEnum.call(this, key = toPrimitive(key, true));\n if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;\n return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){\n it = toIObject(it);\n key = toPrimitive(key, true);\n if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;\n var D = gOPD(it, key);\n if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;\n return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it){\n var names = gOPN(toIObject(it))\n , result = []\n , i = 0\n , key;\n while(names.length > i){\n if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);\n } return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it){\n var IS_OP = it === ObjectProto\n , names = gOPN(IS_OP ? OPSymbols : toIObject(it))\n , result = []\n , i = 0\n , key;\n while(names.length > i){\n if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);\n } return result;\n};\n\n// 19.4.1.1 Symbol([description])\nif(!USE_NATIVE){\n $Symbol = function Symbol(){\n if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');\n var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n var $set = function(value){\n if(this === ObjectProto)$set.call(OPSymbols, value);\n if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;\n setSymbolDesc(this, tag, createDesc(1, value));\n };\n if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});\n return wrap(tag);\n };\n redefine($Symbol[PROTOTYPE], 'toString', function toString(){\n return this._k;\n });\n\n $GOPD.f = $getOwnPropertyDescriptor;\n $DP.f = $defineProperty;\n require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;\n require('./_object-pie').f = $propertyIsEnumerable;\n require('./_object-gops').f = $getOwnPropertySymbols;\n\n if(DESCRIPTORS && !require('./_library')){\n redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n }\n\n wksExt.f = function(name){\n return wrap(wks(name));\n }\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});\n\nfor(var symbols = (\n // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);\n\nfor(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);\n\n$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n // 19.4.2.1 Symbol.for(key)\n 'for': function(key){\n return has(SymbolRegistry, key += '')\n ? SymbolRegistry[key]\n : SymbolRegistry[key] = $Symbol(key);\n },\n // 19.4.2.5 Symbol.keyFor(sym)\n keyFor: function keyFor(key){\n if(isSymbol(key))return keyOf(SymbolRegistry, key);\n throw TypeError(key + ' is not a symbol!');\n },\n useSetter: function(){ setter = true; },\n useSimple: function(){ setter = false; }\n});\n\n$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n // 19.1.2.2 Object.create(O [, Properties])\n create: $create,\n // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n defineProperty: $defineProperty,\n // 19.1.2.3 Object.defineProperties(O, Properties)\n defineProperties: $defineProperties,\n // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n // 19.1.2.7 Object.getOwnPropertyNames(O)\n getOwnPropertyNames: $getOwnPropertyNames,\n // 19.1.2.8 Object.getOwnPropertySymbols(O)\n getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){\n var S = $Symbol();\n // MS Edge converts symbol values to JSON as {}\n // WebKit converts symbol values to JSON as null\n // V8 throws on boxed symbols\n return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';\n})), 'JSON', {\n stringify: function stringify(it){\n if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined\n var args = [it]\n , i = 1\n , replacer, $replacer;\n while(arguments.length > i)args.push(arguments[i++]);\n replacer = args[1];\n if(typeof replacer == 'function')$replacer = replacer;\n if($replacer || !isArray(replacer))replacer = function(key, value){\n if($replacer)value = $replacer.call(this, key, value);\n if(!isSymbol(value))return value;\n };\n args[1] = replacer;\n return _stringify.apply($JSON, args);\n }\n});\n\n// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.symbol.js\n// module id = 105\n// module chunks = 0","require('./_wks-define')('asyncIterator');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es7.symbol.async-iterator.js\n// module id = 106\n// module chunks = 0","require('./_wks-define')('observable');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es7.symbol.observable.js\n// module id = 107\n// module chunks = 0","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/process/browser.js\n// module id = 108\n// module chunks = 0","// This method of obtaining a reference to the global object needs to be\n// kept identical to the way it is obtained in runtime.js\nvar g =\n typeof global === \"object\" ? global :\n typeof window === \"object\" ? window :\n typeof self === \"object\" ? self : this;\n\n// Use `getOwnPropertyNames` because not all browsers support calling\n// `hasOwnProperty` on the global `self` object in a worker. See #183.\nvar hadRuntime = g.regeneratorRuntime &&\n Object.getOwnPropertyNames(g).indexOf(\"regeneratorRuntime\") >= 0;\n\n// Save the old regeneratorRuntime in case it needs to be restored later.\nvar oldRuntime = hadRuntime && g.regeneratorRuntime;\n\n// Force reevalutation of runtime.js.\ng.regeneratorRuntime = undefined;\n\nmodule.exports = require(\"./runtime\");\n\nif (hadRuntime) {\n // Restore the original runtime.\n g.regeneratorRuntime = oldRuntime;\n} else {\n // Remove the global property added by runtime.js.\n try {\n delete g.regeneratorRuntime;\n } catch(e) {\n g.regeneratorRuntime = undefined;\n }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/regenerator-runtime/runtime-module.js\n// module id = 109\n// module chunks = 0","/**\n * Copyright (c) 2014, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * https://raw.github.com/facebook/regenerator/master/LICENSE file. An\n * additional grant of patent rights can be found in the PATENTS file in\n * the same directory.\n */\n\n!(function(global) {\n \"use strict\";\n\n var hasOwn = Object.prototype.hasOwnProperty;\n var undefined; // More compressible than void 0.\n var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n var inModule = typeof module === \"object\";\n var runtime = global.regeneratorRuntime;\n if (runtime) {\n if (inModule) {\n // If regeneratorRuntime is defined globally and we're in a module,\n // make the exports object identical to regeneratorRuntime.\n module.exports = runtime;\n }\n // Don't bother evaluating the rest of this file if the runtime was\n // already defined globally.\n return;\n }\n\n // Define the runtime globally (as expected by generated code) as either\n // module.exports (if we're in a module) or a new, empty object.\n runtime = global.regeneratorRuntime = inModule ? module.exports : {};\n\n function wrap(innerFn, outerFn, self, tryLocsList) {\n // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n var generator = Object.create(protoGenerator.prototype);\n var context = new Context(tryLocsList || []);\n\n // The ._invoke method unifies the implementations of the .next,\n // .throw, and .return methods.\n generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n return generator;\n }\n runtime.wrap = wrap;\n\n // Try/catch helper to minimize deoptimizations. Returns a completion\n // record like context.tryEntries[i].completion. This interface could\n // have been (and was previously) designed to take a closure to be\n // invoked without arguments, but in all the cases we care about we\n // already have an existing method we want to call, so there's no need\n // to create a new function object. We can even get away with assuming\n // the method takes exactly one argument, since that happens to be true\n // in every case, so we don't have to touch the arguments object. The\n // only additional allocation required is the completion record, which\n // has a stable shape and so hopefully should be cheap to allocate.\n function tryCatch(fn, obj, arg) {\n try {\n return { type: \"normal\", arg: fn.call(obj, arg) };\n } catch (err) {\n return { type: \"throw\", arg: err };\n }\n }\n\n var GenStateSuspendedStart = \"suspendedStart\";\n var GenStateSuspendedYield = \"suspendedYield\";\n var GenStateExecuting = \"executing\";\n var GenStateCompleted = \"completed\";\n\n // Returning this object from the innerFn has the same effect as\n // breaking out of the dispatch switch statement.\n var ContinueSentinel = {};\n\n // Dummy constructor functions that we use as the .constructor and\n // .constructor.prototype properties for functions that return Generator\n // objects. For full spec compliance, you may wish to configure your\n // minifier not to mangle the names of these two functions.\n function Generator() {}\n function GeneratorFunction() {}\n function GeneratorFunctionPrototype() {}\n\n var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;\n GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n GeneratorFunctionPrototype.constructor = GeneratorFunction;\n GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = \"GeneratorFunction\";\n\n // Helper for defining the .next, .throw, and .return methods of the\n // Iterator interface in terms of a single ._invoke method.\n function defineIteratorMethods(prototype) {\n [\"next\", \"throw\", \"return\"].forEach(function(method) {\n prototype[method] = function(arg) {\n return this._invoke(method, arg);\n };\n });\n }\n\n runtime.isGeneratorFunction = function(genFun) {\n var ctor = typeof genFun === \"function\" && genFun.constructor;\n return ctor\n ? ctor === GeneratorFunction ||\n // For the native GeneratorFunction constructor, the best we can\n // do is to check its .name property.\n (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n : false;\n };\n\n runtime.mark = function(genFun) {\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n } else {\n genFun.__proto__ = GeneratorFunctionPrototype;\n if (!(toStringTagSymbol in genFun)) {\n genFun[toStringTagSymbol] = \"GeneratorFunction\";\n }\n }\n genFun.prototype = Object.create(Gp);\n return genFun;\n };\n\n // Within the body of any async function, `await x` is transformed to\n // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n // `value instanceof AwaitArgument` to determine if the yielded value is\n // meant to be awaited. Some may consider the name of this method too\n // cutesy, but they are curmudgeons.\n runtime.awrap = function(arg) {\n return new AwaitArgument(arg);\n };\n\n function AwaitArgument(arg) {\n this.arg = arg;\n }\n\n function AsyncIterator(generator) {\n function invoke(method, arg, resolve, reject) {\n var record = tryCatch(generator[method], generator, arg);\n if (record.type === \"throw\") {\n reject(record.arg);\n } else {\n var result = record.arg;\n var value = result.value;\n if (value instanceof AwaitArgument) {\n return Promise.resolve(value.arg).then(function(value) {\n invoke(\"next\", value, resolve, reject);\n }, function(err) {\n invoke(\"throw\", err, resolve, reject);\n });\n }\n\n return Promise.resolve(value).then(function(unwrapped) {\n // When a yielded Promise is resolved, its final value becomes\n // the .value of the Promise<{value,done}> result for the\n // current iteration. If the Promise is rejected, however, the\n // result for this iteration will be rejected with the same\n // reason. Note that rejections of yielded Promises are not\n // thrown back into the generator function, as is the case\n // when an awaited Promise is rejected. This difference in\n // behavior between yield and await is important, because it\n // allows the consumer to decide what to do with the yielded\n // rejection (swallow it and continue, manually .throw it back\n // into the generator, abandon iteration, whatever). With\n // await, by contrast, there is no opportunity to examine the\n // rejection reason outside the generator function, so the\n // only option is to throw it from the await expression, and\n // let the generator function handle the exception.\n result.value = unwrapped;\n resolve(result);\n }, reject);\n }\n }\n\n if (typeof process === \"object\" && process.domain) {\n invoke = process.domain.bind(invoke);\n }\n\n var previousPromise;\n\n function enqueue(method, arg) {\n function callInvokeWithMethodAndArg() {\n return new Promise(function(resolve, reject) {\n invoke(method, arg, resolve, reject);\n });\n }\n\n return previousPromise =\n // If enqueue has been called before, then we want to wait until\n // all previous Promises have been resolved before calling invoke,\n // so that results are always delivered in the correct order. If\n // enqueue has not been called before, then it is important to\n // call invoke immediately, without waiting on a callback to fire,\n // so that the async generator function has the opportunity to do\n // any necessary setup in a predictable way. This predictability\n // is why the Promise constructor synchronously invokes its\n // executor callback, and why async functions synchronously\n // execute code before the first await. Since we implement simple\n // async functions in terms of async generators, it is especially\n // important to get this right, even though it requires care.\n previousPromise ? previousPromise.then(\n callInvokeWithMethodAndArg,\n // Avoid propagating failures to Promises returned by later\n // invocations of the iterator.\n callInvokeWithMethodAndArg\n ) : callInvokeWithMethodAndArg();\n }\n\n // Define the unified helper method that is used to implement .next,\n // .throw, and .return (see defineIteratorMethods).\n this._invoke = enqueue;\n }\n\n defineIteratorMethods(AsyncIterator.prototype);\n\n // Note that simple async functions are implemented on top of\n // AsyncIterator objects; they just return a Promise for the value of\n // the final result produced by the iterator.\n runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n var iter = new AsyncIterator(\n wrap(innerFn, outerFn, self, tryLocsList)\n );\n\n return runtime.isGeneratorFunction(outerFn)\n ? iter // If outerFn is a generator, return the full iterator.\n : iter.next().then(function(result) {\n return result.done ? result.value : iter.next();\n });\n };\n\n function makeInvokeMethod(innerFn, self, context) {\n var state = GenStateSuspendedStart;\n\n return function invoke(method, arg) {\n if (state === GenStateExecuting) {\n throw new Error(\"Generator is already running\");\n }\n\n if (state === GenStateCompleted) {\n if (method === \"throw\") {\n throw arg;\n }\n\n // Be forgiving, per 25.3.3.3.3 of the spec:\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n return doneResult();\n }\n\n while (true) {\n var delegate = context.delegate;\n if (delegate) {\n if (method === \"return\" ||\n (method === \"throw\" && delegate.iterator[method] === undefined)) {\n // A return or throw (when the delegate iterator has no throw\n // method) always terminates the yield* loop.\n context.delegate = null;\n\n // If the delegate iterator has a return method, give it a\n // chance to clean up.\n var returnMethod = delegate.iterator[\"return\"];\n if (returnMethod) {\n var record = tryCatch(returnMethod, delegate.iterator, arg);\n if (record.type === \"throw\") {\n // If the return method threw an exception, let that\n // exception prevail over the original return or throw.\n method = \"throw\";\n arg = record.arg;\n continue;\n }\n }\n\n if (method === \"return\") {\n // Continue with the outer return, now that the delegate\n // iterator has been terminated.\n continue;\n }\n }\n\n var record = tryCatch(\n delegate.iterator[method],\n delegate.iterator,\n arg\n );\n\n if (record.type === \"throw\") {\n context.delegate = null;\n\n // Like returning generator.throw(uncaught), but without the\n // overhead of an extra function call.\n method = \"throw\";\n arg = record.arg;\n continue;\n }\n\n // Delegate generator ran and handled its own exceptions so\n // regardless of what the method was, we continue as if it is\n // \"next\" with an undefined arg.\n method = \"next\";\n arg = undefined;\n\n var info = record.arg;\n if (info.done) {\n context[delegate.resultName] = info.value;\n context.next = delegate.nextLoc;\n } else {\n state = GenStateSuspendedYield;\n return info;\n }\n\n context.delegate = null;\n }\n\n if (method === \"next\") {\n // Setting context._sent for legacy support of Babel's\n // function.sent implementation.\n context.sent = context._sent = arg;\n\n } else if (method === \"throw\") {\n if (state === GenStateSuspendedStart) {\n state = GenStateCompleted;\n throw arg;\n }\n\n if (context.dispatchException(arg)) {\n // If the dispatched exception was caught by a catch block,\n // then let that catch block handle the exception normally.\n method = \"next\";\n arg = undefined;\n }\n\n } else if (method === \"return\") {\n context.abrupt(\"return\", arg);\n }\n\n state = GenStateExecuting;\n\n var record = tryCatch(innerFn, self, context);\n if (record.type === \"normal\") {\n // If an exception is thrown from innerFn, we leave state ===\n // GenStateExecuting and loop back for another invocation.\n state = context.done\n ? GenStateCompleted\n : GenStateSuspendedYield;\n\n var info = {\n value: record.arg,\n done: context.done\n };\n\n if (record.arg === ContinueSentinel) {\n if (context.delegate && method === \"next\") {\n // Deliberately forget the last sent value so that we don't\n // accidentally pass it on to the delegate.\n arg = undefined;\n }\n } else {\n return info;\n }\n\n } else if (record.type === \"throw\") {\n state = GenStateCompleted;\n // Dispatch the exception by looping back around to the\n // context.dispatchException(arg) call above.\n method = \"throw\";\n arg = record.arg;\n }\n }\n };\n }\n\n // Define Generator.prototype.{next,throw,return} in terms of the\n // unified ._invoke helper method.\n defineIteratorMethods(Gp);\n\n Gp[iteratorSymbol] = function() {\n return this;\n };\n\n Gp[toStringTagSymbol] = \"Generator\";\n\n Gp.toString = function() {\n return \"[object Generator]\";\n };\n\n function pushTryEntry(locs) {\n var entry = { tryLoc: locs[0] };\n\n if (1 in locs) {\n entry.catchLoc = locs[1];\n }\n\n if (2 in locs) {\n entry.finallyLoc = locs[2];\n entry.afterLoc = locs[3];\n }\n\n this.tryEntries.push(entry);\n }\n\n function resetTryEntry(entry) {\n var record = entry.completion || {};\n record.type = \"normal\";\n delete record.arg;\n entry.completion = record;\n }\n\n function Context(tryLocsList) {\n // The root entry object (effectively a try statement without a catch\n // or a finally block) gives us a place to store values thrown from\n // locations where there is no enclosing try statement.\n this.tryEntries = [{ tryLoc: \"root\" }];\n tryLocsList.forEach(pushTryEntry, this);\n this.reset(true);\n }\n\n runtime.keys = function(object) {\n var keys = [];\n for (var key in object) {\n keys.push(key);\n }\n keys.reverse();\n\n // Rather than returning an object with a next method, we keep\n // things simple and return the next function itself.\n return function next() {\n while (keys.length) {\n var key = keys.pop();\n if (key in object) {\n next.value = key;\n next.done = false;\n return next;\n }\n }\n\n // To avoid creating an additional object, we just hang the .value\n // and .done properties off the next function object itself. This\n // also ensures that the minifier will not anonymize the function.\n next.done = true;\n return next;\n };\n };\n\n function values(iterable) {\n if (iterable) {\n var iteratorMethod = iterable[iteratorSymbol];\n if (iteratorMethod) {\n return iteratorMethod.call(iterable);\n }\n\n if (typeof iterable.next === \"function\") {\n return iterable;\n }\n\n if (!isNaN(iterable.length)) {\n var i = -1, next = function next() {\n while (++i < iterable.length) {\n if (hasOwn.call(iterable, i)) {\n next.value = iterable[i];\n next.done = false;\n return next;\n }\n }\n\n next.value = undefined;\n next.done = true;\n\n return next;\n };\n\n return next.next = next;\n }\n }\n\n // Return an iterator with no values.\n return { next: doneResult };\n }\n runtime.values = values;\n\n function doneResult() {\n return { value: undefined, done: true };\n }\n\n Context.prototype = {\n constructor: Context,\n\n reset: function(skipTempReset) {\n this.prev = 0;\n this.next = 0;\n // Resetting context._sent for legacy support of Babel's\n // function.sent implementation.\n this.sent = this._sent = undefined;\n this.done = false;\n this.delegate = null;\n\n this.tryEntries.forEach(resetTryEntry);\n\n if (!skipTempReset) {\n for (var name in this) {\n // Not sure about the optimal order of these conditions:\n if (name.charAt(0) === \"t\" &&\n hasOwn.call(this, name) &&\n !isNaN(+name.slice(1))) {\n this[name] = undefined;\n }\n }\n }\n },\n\n stop: function() {\n this.done = true;\n\n var rootEntry = this.tryEntries[0];\n var rootRecord = rootEntry.completion;\n if (rootRecord.type === \"throw\") {\n throw rootRecord.arg;\n }\n\n return this.rval;\n },\n\n dispatchException: function(exception) {\n if (this.done) {\n throw exception;\n }\n\n var context = this;\n function handle(loc, caught) {\n record.type = \"throw\";\n record.arg = exception;\n context.next = loc;\n return !!caught;\n }\n\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n var record = entry.completion;\n\n if (entry.tryLoc === \"root\") {\n // Exception thrown outside of any try block that could handle\n // it, so set the completion value of the entire function to\n // throw the exception.\n return handle(\"end\");\n }\n\n if (entry.tryLoc <= this.prev) {\n var hasCatch = hasOwn.call(entry, \"catchLoc\");\n var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n if (hasCatch && hasFinally) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n } else if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else if (hasCatch) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n }\n\n } else if (hasFinally) {\n if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else {\n throw new Error(\"try statement without catch or finally\");\n }\n }\n }\n },\n\n abrupt: function(type, arg) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc <= this.prev &&\n hasOwn.call(entry, \"finallyLoc\") &&\n this.prev < entry.finallyLoc) {\n var finallyEntry = entry;\n break;\n }\n }\n\n if (finallyEntry &&\n (type === \"break\" ||\n type === \"continue\") &&\n finallyEntry.tryLoc <= arg &&\n arg <= finallyEntry.finallyLoc) {\n // Ignore the finally entry if control is not jumping to a\n // location outside the try/catch block.\n finallyEntry = null;\n }\n\n var record = finallyEntry ? finallyEntry.completion : {};\n record.type = type;\n record.arg = arg;\n\n if (finallyEntry) {\n this.next = finallyEntry.finallyLoc;\n } else {\n this.complete(record);\n }\n\n return ContinueSentinel;\n },\n\n complete: function(record, afterLoc) {\n if (record.type === \"throw\") {\n throw record.arg;\n }\n\n if (record.type === \"break\" ||\n record.type === \"continue\") {\n this.next = record.arg;\n } else if (record.type === \"return\") {\n this.rval = record.arg;\n this.next = \"end\";\n } else if (record.type === \"normal\" && afterLoc) {\n this.next = afterLoc;\n }\n },\n\n finish: function(finallyLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.finallyLoc === finallyLoc) {\n this.complete(entry.completion, entry.afterLoc);\n resetTryEntry(entry);\n return ContinueSentinel;\n }\n }\n },\n\n \"catch\": function(tryLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc === tryLoc) {\n var record = entry.completion;\n if (record.type === \"throw\") {\n var thrown = record.arg;\n resetTryEntry(entry);\n }\n return thrown;\n }\n }\n\n // The context.catch method must only be called with a location\n // argument that corresponds to a known catch block.\n throw new Error(\"illegal catch attempt\");\n },\n\n delegateYield: function(iterable, resultName, nextLoc) {\n this.delegate = {\n iterator: values(iterable),\n resultName: resultName,\n nextLoc: nextLoc\n };\n\n return ContinueSentinel;\n }\n };\n})(\n // Among the various tricks for obtaining a reference to the global\n // object, this seems to be the most reliable technique that does not\n // use indirect eval (which violates Content Security Policy).\n typeof global === \"object\" ? global :\n typeof window === \"object\" ? window :\n typeof self === \"object\" ? self : this\n);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/regenerator-runtime/runtime.js\n// module id = 110\n// module chunks = 0"],"sourceRoot":""}