NPM/site
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
be30918595
site/admin/netlify-identity-widget.js.map
Alexander Nozik be30918595 Updates
2020-03-21 20:12:32 +03:00

1 line
795 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{"version":3,"sources":["webpack:///netlify-identity-widget.js","webpack:///webpack/bootstrap a8e669399e83701167ff","webpack:///../node_modules/preact/dist/preact.mjs","webpack:///../node_modules/mobx/lib/mobx.module.js","webpack:///../node_modules/mobx-preact/lib/index.js","webpack:///../node_modules/mobx-preact/lib/observer.js","webpack:///../node_modules/mobx-preact/lib/utils/utils.js","webpack:///../node_modules/mobx-preact/lib/inject.js","webpack:///../node_modules/micro-api-client/lib/index.js","webpack:///./components/forms/button.js","webpack:///./components/forms/message.js","webpack:///./index.js","webpack:///./netlify-identity.js","webpack:///../node_modules/webpack/buildin/global.js","webpack:///../node_modules/mobx-preact/lib/connect.js","webpack:///../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack:///../node_modules/mobx-preact/lib/Provider.js","webpack:///../node_modules/gotrue-js/lib/index.js","webpack:///../node_modules/micro-api-client/lib/pagination.js","webpack:///../node_modules/gotrue-js/lib/user.js","webpack:///../node_modules/gotrue-js/lib/admin.js","webpack:///./components/app.js","webpack:///./components/modal/index.js","webpack:///./components/forms/siteurl.js","webpack:///./components/forms/logout.js","webpack:///./components/forms/user.js","webpack:///./components/forms/providers.js","webpack:///./state/store.js","webpack:///./components/controls.js","webpack:///./components/modal.css","webpack:///../node_modules/css-loader/lib/css-base.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","__webpack_exports__","h","nodeName","attributes","lastSimple","child","simple","children","EMPTY_CHILDREN","arguments","length","stack","push","pop","undefined","String","VNode","key","options","vnode","extend","obj","props","cloneElement","slice","enqueueRender","component","_dirty","items","debounceRendering","defer","rerender","list","renderComponent","isSameNodeType","node","hydrating","splitText","_componentConstructor","isNamedNode","normalizedNodeName","toLowerCase","getNodeProps","defaultProps","createNode","isSvg","document","createElementNS","createElement","removeNode","parentNode","removeChild","setAccessor","old","value","style","cssText","IS_NON_DIMENSIONAL","test","innerHTML","__html","useCapture","replace","substring","addEventListener","eventProxy","removeEventListener","_listeners","e","removeAttribute","ns","removeAttributeNS","setAttributeNS","setAttribute","className","this","type","event","flushMounts","mounts","afterMount","componentDidMount","diff","dom","context","mountAll","parent","componentRoot","diffLevel","isSvgMode","ownerSVGElement","ret","idiff","appendChild","out","prevSvgMode","_component","nodeValue","createTextNode","replaceChild","recollectNodeTree","vnodeName","buildComponentFromVNode","firstChild","fc","vchildren","a","nextSibling","innerDiffNode","dangerouslySetInnerHTML","diffAttributes","isHydrating","j","f","vchild","originalChildren","childNodes","keyed","keyedLen","min","len","childrenLen","vlen","_child","__key","trim","insertBefore","unmountOnly","unmountComponent","ref","removeChildren","lastChild","next","previousSibling","attrs","createComponent","Ctor","inst","recyclerComponents","render","Component","constructor","doRender","nextBase","splice","state","setComponentProps","renderMode","_disable","__ref","getDerivedStateFromProps","base","componentWillMount","componentWillReceiveProps","prevContext","prevProps","syncComponentUpdates","isChild","rendered","cbase","previousProps","previousState","prevState","previousContext","isUpdate","initialBase","initialChildComponent","skip","snapshot","shouldComponentUpdate","componentWillUpdate","getChildContext","getSnapshotBeforeUpdate","toUnmount","childComponent","childProps","_parentComponent","baseParent","componentRef","t","unshift","componentDidUpdate","afterUpdate","_renderCallbacks","originalComponent","oldDom","isDirectOwner","isOwner","beforeUnmount","componentWillUnmount","inner","merge","Promise","resolve","then","bind","setTimeout","setState","callback","forceUpdate","global","__extends","b","__","extendStatics","create","hasInterceptors","interceptable","interceptors","registerInterceptor","handler","once","idx","indexOf","interceptChange","change","prevU","untrackedStart","invariant","untrackedEnd","hasListeners","listenable","changeListeners","registerListener","listeners","notifyListeners","isSpyEnabled","globalState","spyListeners","spyReport","spyReportStart","objectAssign","spyReportEnd","END_EVENT","spy","listener","iteratorSymbol","Symbol","iterator","arrayAsIterator","array","IS_ITERATING_MARKER","addHiddenFinalProp","done","declareIterator","prototType","iteratorFactory","createArrayEntryDescriptor","index","set","createArrayBufferItem","ObservableArray","reserveArrayBuffer","max","OBSERVABLE_ARRAY_BUFFER_SIZE","isObservableArray","thing","isObject","isObservableArrayAdministration","$mobx","getMessage","id","messages","createAction","actionName","fn","res","executeAction","originalFn","isMobxAction","scope","args","runInfo","startAction","apply","endAction","notifySpy","startTime","Date","now","flattendArgs","Array","prevDerivation","startBatch","prevAllowStateChanges","allowStateChangesStart","allowStateChangesEnd","endBatch","time","useStrict","strict","trackingDerivation","strictMode","allowStateChanges","isStrictModeEnabled","func","prev","createClassPropertyDecorator","onInitialize","allowCustomArguments","classPropertyDecorator","target","descriptor","customArgs","argLen","quacksLikeADecorator","addHiddenProp","__mobxLazyInitializers","value_1","initializer_1","initializer","instance","__mobxDidRunLazyInitializers","runLazyInitializers","v","newDescriptor","__mobxInitializedProps","typescriptInitializeProperty","outerArgs","baseDescriptor","forEach","namedActionDecorator","prop","Error","actionFieldDecorator","runInAction","arg1","arg2","arg3","isAction","defineBoundAction","propertyName","deepEqual","eq","aStack","bStack","_typeof","deepEq","unwrap","toString","valueOf","areArrays","aCtor","bCtor","keys","has","peek","isObservableMap","entries","isES6Map","iteratorToArray","identityComparer","structuralComparer","defaultComparer","areBothNaN","autorun","reactionRunner","view","reaction","getNextId","Reaction","track","schedule","getDisposer","when","arg4","predicate","effect","r","dispose","prevUntracked","autorunAsync","delay","isScheduled","isDisposed","expression","changed","nextValue","firstTime","equals","opts","fireImmediately","fail","isModifierDescriptor","compareStructural","struct","action","comparer","structural","default","asObservableObject","isObservableObject","isExtensible","isPlainObject","adm","ObservableObjectAdministration","defineObservablePropertyFromDescriptor","propName","defaultEnhancer","values","isComputedValue","modifierDescriptor","defineObservableProperty","initialValue","enhancer","autoBind","defineComputedPropertyFromComputedValue","defineComputedProperty","newValue","assertPropertyConfigurable","ObservableValue","generateObservablePropConfig","notifyPropertyAddition","setter","asInstanceProperty","ComputedValue","generateComputedPropConfig","computedValue","observablePropertyConfigs","setPropertyValue","computedPropertyConfigs","observable","prepareNewValue","UNCHANGED","notify","oldValue","setNewValue","isObservableObjectAdministration","isObservable","isAtom","isReaction","createDecoratorForEnhancer","baseValue","_","extendObservable","properties","_i","extendObservableHelper","deepEnhancer","extendShallowObservable","referenceEnhancer","propSet","definedProps","isPropertyConfigurable","getOwnPropertyDescriptor","createObservable","deepDecorator","box","incorrectlyUsedAsDecorator","methodName","isMobxModifierDescriptor","createModifierDescriptor","isArray","map","shallowEnhancer","shallowArray","shallowObject","shallowMap","deepStructEnhancer","ObservableMap","refStructEnhancer","transaction","thisArg","initialValues","deprecated","getGlobal","window","mobxGuid","message","check","msg","deprecatedMessages","console","error","invoked","unique","item","joinStrings","things","limit","separator","join","proto","getPrototypeOf","source","prototypeHasOwnProperty","writable","createInstanceofPredicate","clazz","x","isNaN","isArrayLike","Map","getMapLikeKeys","map$$1","_a","from","it","primitiveSymbol","toPrimitive","isolateGlobalState","runInIsolationCalled","__mobxInstanceCount","shareGlobalState","shareGlobalStateCalled","ownState","__mobservableTrackingStack","__mobservableViewStack","__mobxGlobal","version","getGlobalState","resetGlobalState","resetId","defaultGlobals","MobXGlobals","persistentKeys","getAtom","atom","anyThing","_keys","_data","_hasMap","getDebugName","getAdministration","named","getDependencyTree","nodeToDependencyTree","result","observing","dependencies","getObserverTree","nodeToObserverTree","hasObservers","observers","getObservers","addObserver","observersIndexes","__mapid","lowestObserverState","dependenciesState","removeObserver","queueForUnobservation","filler","isPendingUnobservation","pendingUnobservations","inBatch","runReactions","onBecomeUnobserved","reportObserved","derivation","runId","lastAccessedBy","newObserving","unboundDepsCount","propagateChanged","IDerivationState","STALE","UP_TO_DATE","isTracing","TraceMode","NONE","logTraceInfo","onBecomeStale","propagateChangeConfirmed","POSSIBLY_STALE","propagateMaybeChanged","log","BREAK","lines","printDepTree","Function","tree","depth","isCaughtException","CaughtException","shouldCompute","NOT_TRACKING","obs","changeDependenciesStateTo0","isComputingDerivation","checkIfStateModificationsAreAllowed","hasObservers$$1","computationDepth","trackDerivedFunction","prevTracking","bindDependencies","prevObserving","lowestNewObservingDerivationState","i0","dep","diffValue","clearObserving","untracked","whyRun","getAtomFromArgs","trace","enterBreakPoint","LOG","registerErrorHandler","errorHandler","onReactionError","globalReactionErrorHandlers","isRunningReactions","reactionScheduler","runReactionsHelper","allReactions","pendingReactions","iterations","MAX_REACTION_ITERATIONS","remainingReactions","runReaction","setReactionScheduler","baseScheduler","asReference","asStructure","asFlat","shallow","asMap","data","createComputedDecorator","originalDescriptor","isComputed","observe","propOrCb","cbOrFire","observeObservableProperty","observeObservable","intercept","propOrHandler","interceptProperty","interceptInterceptable","expr","warn","computed","toJS","detectCycles","__alreadySeen","cache","toAdd","res_1","isObservableValue","createTransformer","transformer","onCleanup","objectCache","Transformer","_super","sourceIdentifier","sourceObject","_this","lastValue","identifier","getMemoizationId","reactiveTransformer","tid","$transformId","interceptReads","dehancer","setPrototypeOf","__proto__","BaseAtom","reportChanged","Atom","onBecomeObservedHandler","onBecomeUnobservedHandler","noop","isBeingTracked","safariPrototypeSetterInheritanceBug","StubArray","ctor","isFrozen","ObservableArrayAdministration","owned","lastKnownLength","newV","oldV","dehanceValue","dehanceValues","added","addedCount","removed","removedCount","getArrayLength","setArrayLength","newLength","currentLength","newItems","spliceWithArray","updateArrayLength","oldLength","delta","deleteCount","Math","EMPTY_ARRAY","spliceItemsIntoValues","notifyArraySplice","concat","notifyArrayChildUpdate","ENTRY_0","clear","arrays","toJSON","find","fromIndex","findIndex","shift","reverse","clone","sort","remove","move","toIndex","checkIndex","oldItems","impl","funcName","baseFunc","propNames","hasUnreportedChange","m001","m002","m003","m004","m005","m006","m007","m008","m009","m010","m011","m012","m013","m014","m015","m016","m017","m018","m019","m020","m021","m022","m024","m025","m026","m028","m029","m030a","m030b","m031","m032","m033","m034","m035","m036","m037","m038","boundActionDecorator","bound","action_1","identity","isComputing","isRunningSetter","computeValue","trackAndCompute","cause","wasSuspended","prevValue","isTracking","shallowDecorator","refDecorator","deepStructDecorator","refStructDecorator","observableFactories","shallowBox","deep","ObservableMapMarker","initialData","_has","isValidKey","_updateHasMapEntry","assertValidKey","hasKey","_updateValue","_addValue","delete","entry","observable$$1","other","newKeys","filter","k","freeze","warnedAboutMultipleInstances","global_1","onInvalidate","_isScheduled","_isTrackPending","_isRunning","reportExceptionInDerivation","messageToUser","onError","computedDecorator","computedStructDecorator","extras","everything","isBoxedObservable","warnedAboutDefaultExport","val","__MOBX_DEVTOOLS_GLOBAL_HOOK__","injectMobx","Provider","inject","connect","useStaticRendering","Observer","observer","_observer","require","_connect","_inject","_Provider","_mobx","_classCallCheck","Constructor","TypeError","_possibleConstructorReturn","self","ReferenceError","_typeof2","_inherits","subClass","superClass","isUsingStaticRendering","patch","runMixinFirst","mixinFunc","reactiveMixin","isObjectShallowModified","componentClass","logger","isMobxInjector","_utils","isStateless","_class","_temp","_Component","_createClass","_preact","displayName","makeDisplayName","mixinLifecycleEvents","isMobXReactObserver","defineProperties","protoProps","staticProps","makePropertyObservableReference","valueHolder","isForcingUpdate","skipRender","initialName","baseRender","isRenderingPending","initialRender","componentWillReact","__$mobxIsUnmounted","hasError","reactComponent","reactiveRender","exception","rendering","nextProps","nextState","_ref","isPrototypeOf","_ref$prefix","prefix","_ref$suffix","suffix","createStoreInjector","grabStoresFn","injectNames","Injector","newProps","additionalProps","mobxStores","_key","_hoistNonReactStatics2","wrappedComponent","proxiedInjectorProps","grabStoresByName","storeNames","baseStores","storeName","injected","_hoistNonReactStatics","JSONHTTPError","TextHTTPError","HTTPError","getPagination","_extends","assign","_pagination","_extendableBuiltin2","response","statusText","captureStackTrace","status","cls","ExtendableBuiltin","Reflect","construct","_HTTPError","_this2","_HTTPError2","json","_this3","API","apiURL","match","_sameOrigin","defaultHeaders","Content-Type","ok","reject","pagination","path","_this4","headers","credentials","fetch","contentType","parseJsonResponse","text","Button","_props","saving","saving_text","confirm","password_mail","email_changed","verfication_error","signup_disabled","Message","_netlifyIdentity","_netlifyIdentity2","netlifyIdentity","readyState","init","_interopRequireDefault","trigger","_arguments","callbacks","cb","setStyle","el","css","queuedIframeStyle","instantiateGotrue","APIUrl","isLocal","localHosts","location","host","split","siteURL","localStorage","getItem","GoTrue","setCookie","parts","store","setIsLocal","setSiteURL","runRoutes","hash","routes","verifyToken","errorRoute","openModal","accessTokenRoute","params","pair","_pair$split","_pair$split2","_slicedToArray","cookie","decodeURIComponent","JSON","parse","auth_type","completeExternalLogin","_options$logo","logo","namePlaceholder","controlEls","querySelectorAll","mode","getAttribute","_mobxPreact","_controls2","innerText","modal","setNamePlaceholder","iframe","title","onload","styles","contentDocument","modalCSS","head","root","_app2","body","iframeStyle","src","container","querySelector","sliceIterator","arr","_arr","_n","_d","_e","_s","err","_gotrueJs","_gotrueJs2","_app","_store","_store2","_controls","_modal","_modal2","validActions","login","signup","on","open","user","close","closeModal","currentUser","gotrue","logout","localhost","127.0.0.1","0.0.0.0","position","top","left","border","width","height","overflow","background","display","z-index","settings","loadSettings","isOpen","page","removeItem","setItem","g","eval","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","objectPrototype","inheritedComponent","getOwnPropertyNames","getOwnPropertySymbols","REACT_STATICS","KNOWN_STATICS","childContextTypes","contextTypes","getDefaultProps","mixins","propTypes","caller","callee","arity","specialReactKeys","stores","suppressChangedStoreWarning","_microApiClient","_microApiClient2","_user","_user2","HTTPRegexp","defaultApiURL","_ref$APIUrl","_ref$audience","audience","_ref$setCookie","api","aud","request","catch","error_description","_request","email","password","method","stringify","remember","_setRememberHeaders","encodeURIComponent","removeSavedSession","createUser","provider","token","verify","tokenResponse","getUserData","_saveSession","recoverSession","_fromStorage","links","total","link","_link$split","_link$split2","url","rel","parseInt","last","first","current","urlBase64Decode","str","output","atob","escape","_admin","_admin2","refreshPromises","forbiddenUpdateAttributes","forbiddenSaveAttributes","User","_processTokenResponse","_saveUserData","_refreshSavedSession","forceRefresh","_tokenDetails","tokenDetails","expires_at","refresh_token","access_token","_refreshToken","clearSession","jwt","Authorization","fromStorage","claims","exp","_details","userCopy","apiInstance","ex","Admin","_siteurl","_siteurl2","_logout","_logout2","_providers","_providers2","_message","_message2","pagesWithHeader","pages","button","button_saving","link_text","providers","amnesia","recovery","invite","App","_ret","_len","handleClose","handlePage","handleLogout","handleSiteURL","clearSiteURL","handleExternalLogin","externalLogin","handleUser","_ref2","requestPasswordRecovery","acceptInvite","updatePassword","pageLinkHandler","devMode","onSiteURL","onLogout","disable_signup","onSubmit","onclick","external","labels","external_labels","onLogin","showHeader","showSignup","devSettings","loading","onPage","onClose","renderBody","renderProviders","formatError","Modal","preventDefault","blockEvent","stopPropagation","linkHandler","role","aria-hidden","onClick","href","_defineProperty","SiteURLForm","handleInput","addSiteURL","development","_state","class","onsubmit","placeholder","autocapitalize","required","oninput","_button","_button2","LogoutForm","user_metadata","full_name","UserForm","handleLogin","label","_Component2","Providers","pId","_props2","getLabel","recovered_user","invite_token","email_change_token","setError","reloadSettings","doEmailChange","acceptInviteExternalUrl","loginExternalUrl","autoconfirm","update","recover","Controls","handleSignup","handleButton","cssWithMappingToString","useSourceMap","content","cssMapping","btoa","sourceMapping","toComment","sources","sourceRoot","sourceMap","unescape","mediaQuery","alreadyImportedModules"],"mappings":"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ACzBuL,QAASA,GACTK,UAAWA,GACXhR,QAASA,EACTgB,aAAcA,EACdP,KAAMA,EACNN,SAAUA,EACV4B,OAAQA,GACRzD,SAAUA,EACVJ,YAAaA,EACbkT,KAAMA,GACNG,KAAMA,GACNO,kBAAmBA,GACnBhD,OAAQA,GACRtG,YAAaA,GACbwT,OAAQA,IAERG,IAA2B,CAe/B,KAAK,GAAIxyB,MAAKsyB,KAdA,SAAUtyB,GACpB,GAAIyyB,GAAMH,GAAWtyB,EACrBX,QAAOC,eAAegzB,GAAYtyB,GAC9BP,IAAK,WAOD,MANK+yB,MACDA,IAA2B,EAC3B9U,QAAQgK,KAAK,4IAIV+K,MAKPzyB,GAEiC,aAAzC,mBAAO0yB,+BAAP,YAAAxd,GAAOwd,iCACPA,8BAA8BC,YAAa/jB,IAAKA,EAAKyjB,OAAQA,KH2hBjE3zB,EGxhBS2zB,UHyhBT3zB,EGzhBiBgY,YH0hBjBhY,EG1hB2BwmB,aH2hB3BxmB,EG3hBsCmkB,oBH4hBtCnkB,EG5hBwD8qB,QH6hBxD9qB,EG7hB8D4qB,YH8hB9D5qB,EG9hBwEyT,YH+hBxEzT,EG/hBmF8T,sBHgiBnF9T,EGhiBwGkQ,MHiiBxGlQ,EGjiB6G2Z,YHkiB7G3Z,EGliBuH6nB,eHmiBvH7nB,EGniBoI+nB,UHoiBpI/nB,EGpiB4I8nB,eHqiB5I9nB,EGriByJioB,SHsiBzJjoB,EGtiBgKuZ,wBHuiBhKvZ,EGviBsL+Z,sBHwiBtL/Z,EGxiB+N6zB,kBAArBrK,GHyiB1MxpB,EGziBkPuR,oBH0iBlPvR,EG1iBqQme,iBH2iBrQne,EG3iBoRmX,mBH4iBpRnX,EG5iBqS6d,OH6iBrS7d,EG7iB0Sqe,eH8iB1Sre,EG9iBuT6b,cH+iBvT7b,EG/iBmUipB,YHgjBnUjpB,EGhjB6Uoc,gBHijB7Upc,EGjjB2VqoB,cHkjB3VroB,EGljBuW0c,oBHmjBvW1c,EGnjByX+c,2BHojBzX/c,EGpjBkZsoB,WHqjBlZtoB,EGrjB2Z2oB,aHsjB3Z3oB,EGtjBsa2X,UHujBta3X,EGvjB+a2Y,eHwjB/a3Y,EGxjB6boY,OHyjB7bpY,EGzjBmc8X,WH0jBnc9X,EG1jB6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","file":"netlify-identity-widget.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \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/******/ \t\t}\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// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\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 = 9);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"h\", function() { return h; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"createElement\", function() { return h; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"cloneElement\", function() { return cloneElement; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Component\", function() { return Component; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"render\", function() { return render; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"rerender\", function() { return rerender; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"options\", function() { return options; });\nvar VNode = function VNode() {};\n\nvar options = {};\n\nvar stack = [];\n\nvar EMPTY_CHILDREN = [];\n\nfunction h(nodeName, attributes) {\n\tvar children = EMPTY_CHILDREN,\n\t lastSimple,\n\t child,\n\t simple,\n\t i;\n\tfor (i = arguments.length; i-- > 2;) {\n\t\tstack.push(arguments[i]);\n\t}\n\tif (attributes && attributes.children != null) {\n\t\tif (!stack.length) stack.push(attributes.children);\n\t\tdelete attributes.children;\n\t}\n\twhile (stack.length) {\n\t\tif ((child = stack.pop()) && child.pop !== undefined) {\n\t\t\tfor (i = child.length; i--;) {\n\t\t\t\tstack.push(child[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tif (typeof child === 'boolean') child = null;\n\n\t\t\tif (simple = typeof nodeName !== 'function') {\n\t\t\t\tif (child == null) child = '';else if (typeof child === 'number') child = String(child);else if (typeof child !== 'string') simple = false;\n\t\t\t}\n\n\t\t\tif (simple && lastSimple) {\n\t\t\t\tchildren[children.length - 1] += child;\n\t\t\t} else if (children === EMPTY_CHILDREN) {\n\t\t\t\tchildren = [child];\n\t\t\t} else {\n\t\t\t\tchildren.push(child);\n\t\t\t}\n\n\t\t\tlastSimple = simple;\n\t\t}\n\t}\n\n\tvar p = new VNode();\n\tp.nodeName = nodeName;\n\tp.children = children;\n\tp.attributes = attributes == null ? undefined : attributes;\n\tp.key = attributes == null ? undefined : attributes.key;\n\n\tif (options.vnode !== undefined) options.vnode(p);\n\n\treturn p;\n}\n\nfunction extend(obj, props) {\n for (var i in props) {\n obj[i] = props[i];\n }return obj;\n}\n\nvar defer = typeof Promise == 'function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;\n\nfunction cloneElement(vnode, props) {\n return h(vnode.nodeName, extend(extend({}, vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children);\n}\n\nvar IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;\n\nvar items = [];\n\nfunction enqueueRender(component) {\n\tif (!component._dirty && (component._dirty = true) && items.push(component) == 1) {\n\t\t(options.debounceRendering || defer)(rerender);\n\t}\n}\n\nfunction rerender() {\n\tvar p,\n\t list = items;\n\titems = [];\n\twhile (p = list.pop()) {\n\t\tif (p._dirty) renderComponent(p);\n\t}\n}\n\nfunction isSameNodeType(node, vnode, hydrating) {\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\t\treturn node.splitText !== undefined;\n\t}\n\tif (typeof vnode.nodeName === 'string') {\n\t\treturn !node._componentConstructor && isNamedNode(node, vnode.nodeName);\n\t}\n\treturn hydrating || node._componentConstructor === vnode.nodeName;\n}\n\nfunction isNamedNode(node, nodeName) {\n\treturn node.normalizedNodeName === nodeName || node.nodeName.toLowerCase() === nodeName.toLowerCase();\n}\n\nfunction getNodeProps(vnode) {\n\tvar props = extend({}, vnode.attributes);\n\tprops.children = vnode.children;\n\n\tvar defaultProps = vnode.nodeName.defaultProps;\n\tif (defaultProps !== undefined) {\n\t\tfor (var i in defaultProps) {\n\t\t\tif (props[i] === undefined) {\n\t\t\t\tprops[i] = defaultProps[i];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn props;\n}\n\nfunction createNode(nodeName, isSvg) {\n\tvar node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName);\n\tnode.normalizedNodeName = nodeName;\n\treturn node;\n}\n\nfunction removeNode(node) {\n\tvar parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\nfunction setAccessor(node, name, old, value, isSvg) {\n\tif (name === 'className') name = 'class';\n\n\tif (name === 'key') {} else if (name === 'ref') {\n\t\tif (old) old(null);\n\t\tif (value) value(node);\n\t} else if (name === 'class' && !isSvg) {\n\t\tnode.className = value || '';\n\t} else if (name === 'style') {\n\t\tif (!value || typeof value === 'string' || typeof old === 'string') {\n\t\t\tnode.style.cssText = value || '';\n\t\t}\n\t\tif (value && typeof value === 'object') {\n\t\t\tif (typeof old !== 'string') {\n\t\t\t\tfor (var i in old) {\n\t\t\t\t\tif (!(i in value)) node.style[i] = '';\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i in value) {\n\t\t\t\tnode.style[i] = typeof value[i] === 'number' && IS_NON_DIMENSIONAL.test(i) === false ? value[i] + 'px' : value[i];\n\t\t\t}\n\t\t}\n\t} else if (name === 'dangerouslySetInnerHTML') {\n\t\tif (value) node.innerHTML = value.__html || '';\n\t} else if (name[0] == 'o' && name[1] == 'n') {\n\t\tvar useCapture = name !== (name = name.replace(/Capture$/, ''));\n\t\tname = name.toLowerCase().substring(2);\n\t\tif (value) {\n\t\t\tif (!old) node.addEventListener(name, eventProxy, useCapture);\n\t\t} else {\n\t\t\tnode.removeEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\t(node._listeners || (node._listeners = {}))[name] = value;\n\t} else if (name !== 'list' && name !== 'type' && !isSvg && name in node) {\n\t\ttry {\n\t\t\tnode[name] = value == null ? '' : value;\n\t\t} catch (e) {}\n\t\tif ((value == null || value === false) && name != 'spellcheck') node.removeAttribute(name);\n\t} else {\n\t\tvar ns = isSvg && name !== (name = name.replace(/^xlink:?/, ''));\n\n\t\tif (value == null || value === false) {\n\t\t\tif (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase());else node.removeAttribute(name);\n\t\t} else if (typeof value !== 'function') {\n\t\t\tif (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value);else node.setAttribute(name, value);\n\t\t}\n\t}\n}\n\nfunction eventProxy(e) {\n\treturn this._listeners[e.type](options.event && options.event(e) || e);\n}\n\nvar mounts = [];\n\nvar diffLevel = 0;\n\nvar isSvgMode = false;\n\nvar hydrating = false;\n\nfunction flushMounts() {\n\tvar c;\n\twhile (c = mounts.pop()) {\n\t\tif (options.afterMount) options.afterMount(c);\n\t\tif (c.componentDidMount) c.componentDidMount();\n\t}\n}\n\nfunction diff(dom, vnode, context, mountAll, parent, componentRoot) {\n\tif (!diffLevel++) {\n\t\tisSvgMode = parent != null && parent.ownerSVGElement !== undefined;\n\n\t\thydrating = dom != null && !('__preactattr_' in dom);\n\t}\n\n\tvar ret = idiff(dom, vnode, context, mountAll, componentRoot);\n\n\tif (parent && ret.parentNode !== parent) parent.appendChild(ret);\n\n\tif (! --diffLevel) {\n\t\thydrating = false;\n\n\t\tif (!componentRoot) flushMounts();\n\t}\n\n\treturn ret;\n}\n\nfunction idiff(dom, vnode, context, mountAll, componentRoot) {\n\tvar out = dom,\n\t prevSvgMode = isSvgMode;\n\n\tif (vnode == null || typeof vnode === 'boolean') vnode = '';\n\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\t\tif (dom && dom.splitText !== undefined && dom.parentNode && (!dom._component || componentRoot)) {\n\t\t\tif (dom.nodeValue != vnode) {\n\t\t\t\tdom.nodeValue = vnode;\n\t\t\t}\n\t\t} else {\n\t\t\tout = document.createTextNode(vnode);\n\t\t\tif (dom) {\n\t\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\t\t\t\trecollectNodeTree(dom, true);\n\t\t\t}\n\t\t}\n\n\t\tout['__preactattr_'] = true;\n\n\t\treturn out;\n\t}\n\n\tvar vnodeName = vnode.nodeName;\n\tif (typeof vnodeName === 'function') {\n\t\treturn buildComponentFromVNode(dom, vnode, context, mountAll);\n\t}\n\n\tisSvgMode = vnodeName === 'svg' ? true : vnodeName === 'foreignObject' ? false : isSvgMode;\n\n\tvnodeName = String(vnodeName);\n\tif (!dom || !isNamedNode(dom, vnodeName)) {\n\t\tout = createNode(vnodeName, isSvgMode);\n\n\t\tif (dom) {\n\t\t\twhile (dom.firstChild) {\n\t\t\t\tout.appendChild(dom.firstChild);\n\t\t\t}\n\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\n\t\t\trecollectNodeTree(dom, true);\n\t\t}\n\t}\n\n\tvar fc = out.firstChild,\n\t props = out['__preactattr_'],\n\t vchildren = vnode.children;\n\n\tif (props == null) {\n\t\tprops = out['__preactattr_'] = {};\n\t\tfor (var a = out.attributes, i = a.length; i--;) {\n\t\t\tprops[a[i].name] = a[i].value;\n\t\t}\n\t}\n\n\tif (!hydrating && vchildren && vchildren.length === 1 && typeof vchildren[0] === 'string' && fc != null && fc.splitText !== undefined && fc.nextSibling == null) {\n\t\tif (fc.nodeValue != vchildren[0]) {\n\t\t\tfc.nodeValue = vchildren[0];\n\t\t}\n\t} else if (vchildren && vchildren.length || fc != null) {\n\t\t\tinnerDiffNode(out, vchildren, context, mountAll, hydrating || props.dangerouslySetInnerHTML != null);\n\t\t}\n\n\tdiffAttributes(out, vnode.attributes, props);\n\n\tisSvgMode = prevSvgMode;\n\n\treturn out;\n}\n\nfunction innerDiffNode(dom, vchildren, context, mountAll, isHydrating) {\n\tvar originalChildren = dom.childNodes,\n\t children = [],\n\t keyed = {},\n\t keyedLen = 0,\n\t min = 0,\n\t len = originalChildren.length,\n\t childrenLen = 0,\n\t vlen = vchildren ? vchildren.length : 0,\n\t j,\n\t c,\n\t f,\n\t vchild,\n\t child;\n\n\tif (len !== 0) {\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar _child = originalChildren[i],\n\t\t\t props = _child['__preactattr_'],\n\t\t\t key = vlen && props ? _child._component ? _child._component.__key : props.key : null;\n\t\t\tif (key != null) {\n\t\t\t\tkeyedLen++;\n\t\t\t\tkeyed[key] = _child;\n\t\t\t} else if (props || (_child.splitText !== undefined ? isHydrating ? _child.nodeValue.trim() : true : isHydrating)) {\n\t\t\t\tchildren[childrenLen++] = _child;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (vlen !== 0) {\n\t\tfor (var i = 0; i < vlen; i++) {\n\t\t\tvchild = vchildren[i];\n\t\t\tchild = null;\n\n\t\t\tvar key = vchild.key;\n\t\t\tif (key != null) {\n\t\t\t\tif (keyedLen && keyed[key] !== undefined) {\n\t\t\t\t\tchild = keyed[key];\n\t\t\t\t\tkeyed[key] = undefined;\n\t\t\t\t\tkeyedLen--;\n\t\t\t\t}\n\t\t\t} else if (min < childrenLen) {\n\t\t\t\t\tfor (j = min; j < childrenLen; j++) {\n\t\t\t\t\t\tif (children[j] !== undefined && isSameNodeType(c = children[j], vchild, isHydrating)) {\n\t\t\t\t\t\t\tchild = c;\n\t\t\t\t\t\t\tchildren[j] = undefined;\n\t\t\t\t\t\t\tif (j === childrenLen - 1) childrenLen--;\n\t\t\t\t\t\t\tif (j === min) min++;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\tchild = idiff(child, vchild, context, mountAll);\n\n\t\t\tf = originalChildren[i];\n\t\t\tif (child && child !== dom && child !== f) {\n\t\t\t\tif (f == null) {\n\t\t\t\t\tdom.appendChild(child);\n\t\t\t\t} else if (child === f.nextSibling) {\n\t\t\t\t\tremoveNode(f);\n\t\t\t\t} else {\n\t\t\t\t\tdom.insertBefore(child, f);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (keyedLen) {\n\t\tfor (var i in keyed) {\n\t\t\tif (keyed[i] !== undefined) recollectNodeTree(keyed[i], false);\n\t\t}\n\t}\n\n\twhile (min <= childrenLen) {\n\t\tif ((child = children[childrenLen--]) !== undefined) recollectNodeTree(child, false);\n\t}\n}\n\nfunction recollectNodeTree(node, unmountOnly) {\n\tvar component = node._component;\n\tif (component) {\n\t\tunmountComponent(component);\n\t} else {\n\t\tif (node['__preactattr_'] != null && node['__preactattr_'].ref) node['__preactattr_'].ref(null);\n\n\t\tif (unmountOnly === false || node['__preactattr_'] == null) {\n\t\t\tremoveNode(node);\n\t\t}\n\n\t\tremoveChildren(node);\n\t}\n}\n\nfunction removeChildren(node) {\n\tnode = node.lastChild;\n\twhile (node) {\n\t\tvar next = node.previousSibling;\n\t\trecollectNodeTree(node, true);\n\t\tnode = next;\n\t}\n}\n\nfunction diffAttributes(dom, attrs, old) {\n\tvar name;\n\n\tfor (name in old) {\n\t\tif (!(attrs && attrs[name] != null) && old[name] != null) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = undefined, isSvgMode);\n\t\t}\n\t}\n\n\tfor (name in attrs) {\n\t\tif (name !== 'children' && name !== 'innerHTML' && (!(name in old) || attrs[name] !== (name === 'value' || name === 'checked' ? dom[name] : old[name]))) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode);\n\t\t}\n\t}\n}\n\nvar recyclerComponents = [];\n\nfunction createComponent(Ctor, props, context) {\n\tvar inst,\n\t i = recyclerComponents.length;\n\n\tif (Ctor.prototype && Ctor.prototype.render) {\n\t\tinst = new Ctor(props, context);\n\t\tComponent.call(inst, props, context);\n\t} else {\n\t\tinst = new Component(props, context);\n\t\tinst.constructor = Ctor;\n\t\tinst.render = doRender;\n\t}\n\n\twhile (i--) {\n\t\tif (recyclerComponents[i].constructor === Ctor) {\n\t\t\tinst.nextBase = recyclerComponents[i].nextBase;\n\t\t\trecyclerComponents.splice(i, 1);\n\t\t\treturn inst;\n\t\t}\n\t}\n\n\treturn inst;\n}\n\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n\nfunction setComponentProps(component, props, renderMode, context, mountAll) {\n\tif (component._disable) return;\n\tcomponent._disable = true;\n\n\tcomponent.__ref = props.ref;\n\tcomponent.__key = props.key;\n\tdelete props.ref;\n\tdelete props.key;\n\n\tif (typeof component.constructor.getDerivedStateFromProps === 'undefined') {\n\t\tif (!component.base || mountAll) {\n\t\t\tif (component.componentWillMount) component.componentWillMount();\n\t\t} else if (component.componentWillReceiveProps) {\n\t\t\tcomponent.componentWillReceiveProps(props, context);\n\t\t}\n\t}\n\n\tif (context && context !== component.context) {\n\t\tif (!component.prevContext) component.prevContext = component.context;\n\t\tcomponent.context = context;\n\t}\n\n\tif (!component.prevProps) component.prevProps = component.props;\n\tcomponent.props = props;\n\n\tcomponent._disable = false;\n\n\tif (renderMode !== 0) {\n\t\tif (renderMode === 1 || options.syncComponentUpdates !== false || !component.base) {\n\t\t\trenderComponent(component, 1, mountAll);\n\t\t} else {\n\t\t\tenqueueRender(component);\n\t\t}\n\t}\n\n\tif (component.__ref) component.__ref(component);\n}\n\nfunction renderComponent(component, renderMode, mountAll, isChild) {\n\tif (component._disable) return;\n\n\tvar props = component.props,\n\t state = component.state,\n\t context = component.context,\n\t previousProps = component.prevProps || props,\n\t previousState = component.prevState || state,\n\t previousContext = component.prevContext || context,\n\t isUpdate = component.base,\n\t nextBase = component.nextBase,\n\t initialBase = isUpdate || nextBase,\n\t initialChildComponent = component._component,\n\t skip = false,\n\t snapshot = previousContext,\n\t rendered,\n\t inst,\n\t cbase;\n\n\tif (component.constructor.getDerivedStateFromProps) {\n\t\tstate = extend(extend({}, state), component.constructor.getDerivedStateFromProps(props, state));\n\t\tcomponent.state = state;\n\t}\n\n\tif (isUpdate) {\n\t\tcomponent.props = previousProps;\n\t\tcomponent.state = previousState;\n\t\tcomponent.context = previousContext;\n\t\tif (renderMode !== 2 && component.shouldComponentUpdate && component.shouldComponentUpdate(props, state, context) === false) {\n\t\t\tskip = true;\n\t\t} else if (component.componentWillUpdate) {\n\t\t\tcomponent.componentWillUpdate(props, state, context);\n\t\t}\n\t\tcomponent.props = props;\n\t\tcomponent.state = state;\n\t\tcomponent.context = context;\n\t}\n\n\tcomponent.prevProps = component.prevState = component.prevContext = component.nextBase = null;\n\tcomponent._dirty = false;\n\n\tif (!skip) {\n\t\trendered = component.render(props, state, context);\n\n\t\tif (component.getChildContext) {\n\t\t\tcontext = extend(extend({}, context), component.getChildContext());\n\t\t}\n\n\t\tif (isUpdate && component.getSnapshotBeforeUpdate) {\n\t\t\tsnapshot = component.getSnapshotBeforeUpdate(previousProps, previousState);\n\t\t}\n\n\t\tvar childComponent = rendered && rendered.nodeName,\n\t\t toUnmount,\n\t\t base;\n\n\t\tif (typeof childComponent === 'function') {\n\n\t\t\tvar childProps = getNodeProps(rendered);\n\t\t\tinst = initialChildComponent;\n\n\t\t\tif (inst && inst.constructor === childComponent && childProps.key == inst.__key) {\n\t\t\t\tsetComponentProps(inst, childProps, 1, context, false);\n\t\t\t} else {\n\t\t\t\ttoUnmount = inst;\n\n\t\t\t\tcomponent._component = inst = createComponent(childComponent, childProps, context);\n\t\t\t\tinst.nextBase = inst.nextBase || nextBase;\n\t\t\t\tinst._parentComponent = component;\n\t\t\t\tsetComponentProps(inst, childProps, 0, context, false);\n\t\t\t\trenderComponent(inst, 1, mountAll, true);\n\t\t\t}\n\n\t\t\tbase = inst.base;\n\t\t} else {\n\t\t\tcbase = initialBase;\n\n\t\t\ttoUnmount = initialChildComponent;\n\t\t\tif (toUnmount) {\n\t\t\t\tcbase = component._component = null;\n\t\t\t}\n\n\t\t\tif (initialBase || renderMode === 1) {\n\t\t\t\tif (cbase) cbase._component = null;\n\t\t\t\tbase = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, true);\n\t\t\t}\n\t\t}\n\n\t\tif (initialBase && base !== initialBase && inst !== initialChildComponent) {\n\t\t\tvar baseParent = initialBase.parentNode;\n\t\t\tif (baseParent && base !== baseParent) {\n\t\t\t\tbaseParent.replaceChild(base, initialBase);\n\n\t\t\t\tif (!toUnmount) {\n\t\t\t\t\tinitialBase._component = null;\n\t\t\t\t\trecollectNodeTree(initialBase, false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (toUnmount) {\n\t\t\tunmountComponent(toUnmount);\n\t\t}\n\n\t\tcomponent.base = base;\n\t\tif (base && !isChild) {\n\t\t\tvar componentRef = component,\n\t\t\t t = component;\n\t\t\twhile (t = t._parentComponent) {\n\t\t\t\t(componentRef = t).base = base;\n\t\t\t}\n\t\t\tbase._component = componentRef;\n\t\t\tbase._componentConstructor = componentRef.constructor;\n\t\t}\n\t}\n\n\tif (!isUpdate || mountAll) {\n\t\tmounts.unshift(component);\n\t} else if (!skip) {\n\n\t\tif (component.componentDidUpdate) {\n\t\t\tcomponent.componentDidUpdate(previousProps, previousState, snapshot);\n\t\t}\n\t\tif (options.afterUpdate) options.afterUpdate(component);\n\t}\n\n\twhile (component._renderCallbacks.length) {\n\t\tcomponent._renderCallbacks.pop().call(component);\n\t}if (!diffLevel && !isChild) flushMounts();\n}\n\nfunction buildComponentFromVNode(dom, vnode, context, mountAll) {\n\tvar c = dom && dom._component,\n\t originalComponent = c,\n\t oldDom = dom,\n\t isDirectOwner = c && dom._componentConstructor === vnode.nodeName,\n\t isOwner = isDirectOwner,\n\t props = getNodeProps(vnode);\n\twhile (c && !isOwner && (c = c._parentComponent)) {\n\t\tisOwner = c.constructor === vnode.nodeName;\n\t}\n\n\tif (c && isOwner && (!mountAll || c._component)) {\n\t\tsetComponentProps(c, props, 3, context, mountAll);\n\t\tdom = c.base;\n\t} else {\n\t\tif (originalComponent && !isDirectOwner) {\n\t\t\tunmountComponent(originalComponent);\n\t\t\tdom = oldDom = null;\n\t\t}\n\n\t\tc = createComponent(vnode.nodeName, props, context);\n\t\tif (dom && !c.nextBase) {\n\t\t\tc.nextBase = dom;\n\n\t\t\toldDom = null;\n\t\t}\n\t\tsetComponentProps(c, props, 1, context, mountAll);\n\t\tdom = c.base;\n\n\t\tif (oldDom && dom !== oldDom) {\n\t\t\toldDom._component = null;\n\t\t\trecollectNodeTree(oldDom, false);\n\t\t}\n\t}\n\n\treturn dom;\n}\n\nfunction unmountComponent(component) {\n\tif (options.beforeUnmount) options.beforeUnmount(component);\n\n\tvar base = component.base;\n\n\tcomponent._disable = true;\n\n\tif (component.componentWillUnmount) component.componentWillUnmount();\n\n\tcomponent.base = null;\n\n\tvar inner = component._component;\n\tif (inner) {\n\t\tunmountComponent(inner);\n\t} else if (base) {\n\t\tif (base['__preactattr_'] && base['__preactattr_'].ref) base['__preactattr_'].ref(null);\n\n\t\tcomponent.nextBase = base;\n\n\t\tremoveNode(base);\n\t\trecyclerComponents.push(component);\n\n\t\tremoveChildren(base);\n\t}\n\n\tif (component.__ref) component.__ref(null);\n}\n\nfunction Component(props, context) {\n\tthis._dirty = true;\n\n\tthis.context = context;\n\n\tthis.props = props;\n\n\tthis.state = this.state || {};\n\n\tthis._renderCallbacks = [];\n}\n\nextend(Component.prototype, {\n\tsetState: function setState(state, callback) {\n\t\tif (!this.prevState) this.prevState = this.state;\n\t\tthis.state = extend(extend({}, this.state), typeof state === 'function' ? state(this.state, this.props) : state);\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\tenqueueRender(this);\n\t},\n\tforceUpdate: function forceUpdate(callback) {\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\trenderComponent(this, 2);\n\t},\n\trender: function render() {}\n});\n\nfunction render(vnode, parent, merge) {\n return diff(merge, vnode, {}, false, parent, false);\n}\n\nvar preact = {\n\th: h,\n\tcreateElement: h,\n\tcloneElement: cloneElement,\n\tComponent: Component,\n\trender: render,\n\trerender: rerender,\n\toptions: options\n};\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (preact);\n\n//# sourceMappingURL=preact.mjs.map\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/** MobX - (c) Michel Weststrate 2015, 2016 - MIT Licensed */\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\n/* global Reflect, Promise */\n\nvar extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d, b) {\n d.__proto__ = b;\n} || function (d, b) {\n for (var p in b) {\n if (b.hasOwnProperty(p)) d[p] = b[p];\n }\n};\n\nfunction __extends(d, b) {\n extendStatics(d, b);\n function __() {\n this.constructor = d;\n }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\n/**\n * Anything that can be used to _store_ state is an Atom in mobx. Atoms have two important jobs\n *\n * 1) detect when they are being _used_ and report this (using reportObserved). This allows mobx to make the connection between running functions and the data they used\n * 2) they should notify mobx whenever they have _changed_. This way mobx can re-run any functions (derivations) that are using this atom.\n */\nvar BaseAtom = /** @class */function () {\n /**\n * Create a new atom. For debugging purposes it is recommended to give it a name.\n * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.\n */\n function BaseAtom(name) {\n if (name === void 0) {\n name = \"Atom@\" + getNextId();\n }\n this.name = name;\n this.isPendingUnobservation = true; // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed\n this.observers = [];\n this.observersIndexes = {};\n this.diffValue = 0;\n this.lastAccessedBy = 0;\n this.lowestObserverState = IDerivationState.NOT_TRACKING;\n }\n BaseAtom.prototype.onBecomeUnobserved = function () {\n // noop\n };\n /**\n * Invoke this method to notify mobx that your atom has been used somehow.\n */\n BaseAtom.prototype.reportObserved = function () {\n reportObserved(this);\n };\n /**\n * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.\n */\n BaseAtom.prototype.reportChanged = function () {\n startBatch();\n propagateChanged(this);\n endBatch();\n };\n BaseAtom.prototype.toString = function () {\n return this.name;\n };\n return BaseAtom;\n}();\nvar Atom = /** @class */function (_super) {\n __extends(Atom, _super);\n /**\n * Create a new atom. For debugging purposes it is recommended to give it a name.\n * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.\n */\n function Atom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) {\n if (name === void 0) {\n name = \"Atom@\" + getNextId();\n }\n if (onBecomeObservedHandler === void 0) {\n onBecomeObservedHandler = noop;\n }\n if (onBecomeUnobservedHandler === void 0) {\n onBecomeUnobservedHandler = noop;\n }\n var _this = _super.call(this, name) || this;\n _this.name = name;\n _this.onBecomeObservedHandler = onBecomeObservedHandler;\n _this.onBecomeUnobservedHandler = onBecomeUnobservedHandler;\n _this.isPendingUnobservation = false; // for effective unobserving.\n _this.isBeingTracked = false;\n return _this;\n }\n Atom.prototype.reportObserved = function () {\n startBatch();\n _super.prototype.reportObserved.call(this);\n if (!this.isBeingTracked) {\n this.isBeingTracked = true;\n this.onBecomeObservedHandler();\n }\n endBatch();\n return !!globalState.trackingDerivation;\n // return doesn't really give useful info, because it can be as well calling computed which calls atom (no reactions)\n // also it could not trigger when calculating reaction dependent on Atom because Atom's value was cached by computed called by given reaction.\n };\n Atom.prototype.onBecomeUnobserved = function () {\n this.isBeingTracked = false;\n this.onBecomeUnobservedHandler();\n };\n return Atom;\n}(BaseAtom);\nvar isAtom = createInstanceofPredicate(\"Atom\", BaseAtom);\n\nfunction hasInterceptors(interceptable) {\n return interceptable.interceptors && interceptable.interceptors.length > 0;\n}\nfunction registerInterceptor(interceptable, handler) {\n var interceptors = interceptable.interceptors || (interceptable.interceptors = []);\n interceptors.push(handler);\n return once(function () {\n var idx = interceptors.indexOf(handler);\n if (idx !== -1) interceptors.splice(idx, 1);\n });\n}\nfunction interceptChange(interceptable, change) {\n var prevU = untrackedStart();\n try {\n var interceptors = interceptable.interceptors;\n if (interceptors) for (var i = 0, l = interceptors.length; i < l; i++) {\n change = interceptors[i](change);\n invariant(!change || change.type, \"Intercept handlers should return nothing or a change object\");\n if (!change) break;\n }\n return change;\n } finally {\n untrackedEnd(prevU);\n }\n}\n\nfunction hasListeners(listenable) {\n return listenable.changeListeners && listenable.changeListeners.length > 0;\n}\nfunction registerListener(listenable, handler) {\n var listeners = listenable.changeListeners || (listenable.changeListeners = []);\n listeners.push(handler);\n return once(function () {\n var idx = listeners.indexOf(handler);\n if (idx !== -1) listeners.splice(idx, 1);\n });\n}\nfunction notifyListeners(listenable, change) {\n var prevU = untrackedStart();\n var listeners = listenable.changeListeners;\n if (!listeners) return;\n listeners = listeners.slice();\n for (var i = 0, l = listeners.length; i < l; i++) {\n listeners[i](change);\n }\n untrackedEnd(prevU);\n}\n\nfunction isSpyEnabled() {\n return !!globalState.spyListeners.length;\n}\nfunction spyReport(event) {\n if (!globalState.spyListeners.length) return;\n var listeners = globalState.spyListeners;\n for (var i = 0, l = listeners.length; i < l; i++) {\n listeners[i](event);\n }\n}\nfunction spyReportStart(event) {\n var change = objectAssign({}, event, { spyReportStart: true });\n spyReport(change);\n}\nvar END_EVENT = { spyReportEnd: true };\nfunction spyReportEnd(change) {\n if (change) spyReport(objectAssign({}, change, END_EVENT));else spyReport(END_EVENT);\n}\nfunction spy(listener) {\n globalState.spyListeners.push(listener);\n return once(function () {\n var idx = globalState.spyListeners.indexOf(listener);\n if (idx !== -1) globalState.spyListeners.splice(idx, 1);\n });\n}\n\nfunction iteratorSymbol() {\n return typeof Symbol === \"function\" && Symbol.iterator || \"@@iterator\";\n}\nvar IS_ITERATING_MARKER = \"__$$iterating\";\nfunction arrayAsIterator(array) {\n // returning an array for entries(), values() etc for maps was a mis-interpretation of the specs..,\n // yet it is quite convenient to be able to use the response both as array directly and as iterator\n // it is suboptimal, but alas...\n invariant(array[IS_ITERATING_MARKER] !== true, \"Illegal state: cannot recycle array as iterator\");\n addHiddenFinalProp(array, IS_ITERATING_MARKER, true);\n var idx = -1;\n addHiddenFinalProp(array, \"next\", function next() {\n idx++;\n return {\n done: idx >= this.length,\n value: idx < this.length ? this[idx] : undefined\n };\n });\n return array;\n}\nfunction declareIterator(prototType, iteratorFactory) {\n addHiddenFinalProp(prototType, iteratorSymbol(), iteratorFactory);\n}\n\nvar MAX_SPLICE_SIZE = 10000; // See e.g. https://github.com/mobxjs/mobx/issues/859\n// Detects bug in safari 9.1.1 (or iOS 9 safari mobile). See #364\nvar safariPrototypeSetterInheritanceBug = function () {\n var v = false;\n var p = {};\n Object.defineProperty(p, \"0\", {\n set: function set() {\n v = true;\n }\n });\n Object.create(p)[\"0\"] = 1;\n return v === false;\n}();\n/**\n * This array buffer contains two lists of properties, so that all arrays\n * can recycle their property definitions, which significantly improves performance of creating\n * properties on the fly.\n */\nvar OBSERVABLE_ARRAY_BUFFER_SIZE = 0;\n// Typescript workaround to make sure ObservableArray extends Array\nvar StubArray = /** @class */function () {\n function StubArray() {}\n return StubArray;\n}();\nfunction inherit(ctor, proto) {\n if (typeof Object[\"setPrototypeOf\"] !== \"undefined\") {\n Object[\"setPrototypeOf\"](ctor.prototype, proto);\n } else if (typeof ctor.prototype.__proto__ !== \"undefined\") {\n ctor.prototype.__proto__ = proto;\n } else {\n ctor[\"prototype\"] = proto;\n }\n}\ninherit(StubArray, Array.prototype);\n// Weex freeze Array.prototype\n// Make them writeable and configurable in prototype chain\n// https://github.com/alibaba/weex/pull/1529\nif (Object.isFrozen(Array)) {\n\n [\"constructor\", \"push\", \"shift\", \"concat\", \"pop\", \"unshift\", \"replace\", \"find\", \"findIndex\", \"splice\", \"reverse\", \"sort\"].forEach(function (key) {\n Object.defineProperty(StubArray.prototype, key, {\n configurable: true,\n writable: true,\n value: Array.prototype[key]\n });\n });\n}\nvar ObservableArrayAdministration = /** @class */function () {\n function ObservableArrayAdministration(name, enhancer, array, owned) {\n this.array = array;\n this.owned = owned;\n this.values = [];\n this.lastKnownLength = 0;\n this.interceptors = null;\n this.changeListeners = null;\n this.atom = new BaseAtom(name || \"ObservableArray@\" + getNextId());\n this.enhancer = function (newV, oldV) {\n return enhancer(newV, oldV, name + \"[..]\");\n };\n }\n ObservableArrayAdministration.prototype.dehanceValue = function (value) {\n if (this.dehancer !== undefined) return this.dehancer(value);\n return value;\n };\n ObservableArrayAdministration.prototype.dehanceValues = function (values) {\n if (this.dehancer !== undefined) return values.map(this.dehancer);\n return values;\n };\n ObservableArrayAdministration.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n ObservableArrayAdministration.prototype.observe = function (listener, fireImmediately) {\n if (fireImmediately === void 0) {\n fireImmediately = false;\n }\n if (fireImmediately) {\n listener({\n object: this.array,\n type: \"splice\",\n index: 0,\n added: this.values.slice(),\n addedCount: this.values.length,\n removed: [],\n removedCount: 0\n });\n }\n return registerListener(this, listener);\n };\n ObservableArrayAdministration.prototype.getArrayLength = function () {\n this.atom.reportObserved();\n return this.values.length;\n };\n ObservableArrayAdministration.prototype.setArrayLength = function (newLength) {\n if (typeof newLength !== \"number\" || newLength < 0) throw new Error(\"[mobx.array] Out of range: \" + newLength);\n var currentLength = this.values.length;\n if (newLength === currentLength) return;else if (newLength > currentLength) {\n var newItems = new Array(newLength - currentLength);\n for (var i = 0; i < newLength - currentLength; i++) {\n newItems[i] = undefined;\n } // No Array.fill everywhere...\n this.spliceWithArray(currentLength, 0, newItems);\n } else this.spliceWithArray(newLength, currentLength - newLength);\n };\n // adds / removes the necessary numeric properties to this object\n ObservableArrayAdministration.prototype.updateArrayLength = function (oldLength, delta) {\n if (oldLength !== this.lastKnownLength) throw new Error(\"[mobx] Modification exception: the internal structure of an observable array was changed. Did you use peek() to change it?\");\n this.lastKnownLength += delta;\n if (delta > 0 && oldLength + delta + 1 > OBSERVABLE_ARRAY_BUFFER_SIZE) reserveArrayBuffer(oldLength + delta + 1);\n };\n ObservableArrayAdministration.prototype.spliceWithArray = function (index, deleteCount, newItems) {\n var _this = this;\n checkIfStateModificationsAreAllowed(this.atom);\n var length = this.values.length;\n if (index === undefined) index = 0;else if (index > length) index = length;else if (index < 0) index = Math.max(0, length + index);\n if (arguments.length === 1) deleteCount = length - index;else if (deleteCount === undefined || deleteCount === null) deleteCount = 0;else deleteCount = Math.max(0, Math.min(deleteCount, length - index));\n if (newItems === undefined) newItems = [];\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n object: this.array,\n type: \"splice\",\n index: index,\n removedCount: deleteCount,\n added: newItems\n });\n if (!change) return EMPTY_ARRAY;\n deleteCount = change.removedCount;\n newItems = change.added;\n }\n newItems = newItems.map(function (v) {\n return _this.enhancer(v, undefined);\n });\n var lengthDelta = newItems.length - deleteCount;\n this.updateArrayLength(length, lengthDelta); // create or remove new entries\n var res = this.spliceItemsIntoValues(index, deleteCount, newItems);\n if (deleteCount !== 0 || newItems.length !== 0) this.notifyArraySplice(index, newItems, res);\n return this.dehanceValues(res);\n };\n ObservableArrayAdministration.prototype.spliceItemsIntoValues = function (index, deleteCount, newItems) {\n if (newItems.length < MAX_SPLICE_SIZE) {\n return (_a = this.values).splice.apply(_a, [index, deleteCount].concat(newItems));\n } else {\n var res = this.values.slice(index, index + deleteCount);\n this.values = this.values.slice(0, index).concat(newItems, this.values.slice(index + deleteCount));\n return res;\n }\n var _a;\n };\n ObservableArrayAdministration.prototype.notifyArrayChildUpdate = function (index, newValue, oldValue) {\n var notifySpy = !this.owned && isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy ? {\n object: this.array,\n type: \"update\",\n index: index,\n newValue: newValue,\n oldValue: oldValue\n } : null;\n if (notifySpy) spyReportStart(change);\n this.atom.reportChanged();\n if (notify) notifyListeners(this, change);\n if (notifySpy) spyReportEnd();\n };\n ObservableArrayAdministration.prototype.notifyArraySplice = function (index, added, removed) {\n var notifySpy = !this.owned && isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy ? {\n object: this.array,\n type: \"splice\",\n index: index,\n removed: removed,\n added: added,\n removedCount: removed.length,\n addedCount: added.length\n } : null;\n if (notifySpy) spyReportStart(change);\n this.atom.reportChanged();\n // conform: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/observe\n if (notify) notifyListeners(this, change);\n if (notifySpy) spyReportEnd();\n };\n return ObservableArrayAdministration;\n}();\nvar ObservableArray = /** @class */function (_super) {\n __extends(ObservableArray, _super);\n function ObservableArray(initialValues, enhancer, name, owned) {\n if (name === void 0) {\n name = \"ObservableArray@\" + getNextId();\n }\n if (owned === void 0) {\n owned = false;\n }\n var _this = _super.call(this) || this;\n var adm = new ObservableArrayAdministration(name, enhancer, _this, owned);\n addHiddenFinalProp(_this, \"$mobx\", adm);\n if (initialValues && initialValues.length) {\n _this.spliceWithArray(0, 0, initialValues);\n }\n if (safariPrototypeSetterInheritanceBug) {\n // Seems that Safari won't use numeric prototype setter untill any * numeric property is\n // defined on the instance. After that it works fine, even if this property is deleted.\n Object.defineProperty(adm.array, \"0\", ENTRY_0);\n }\n return _this;\n }\n ObservableArray.prototype.intercept = function (handler) {\n return this.$mobx.intercept(handler);\n };\n ObservableArray.prototype.observe = function (listener, fireImmediately) {\n if (fireImmediately === void 0) {\n fireImmediately = false;\n }\n return this.$mobx.observe(listener, fireImmediately);\n };\n ObservableArray.prototype.clear = function () {\n return this.splice(0);\n };\n ObservableArray.prototype.concat = function () {\n var arrays = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n arrays[_i] = arguments[_i];\n }\n this.$mobx.atom.reportObserved();\n return Array.prototype.concat.apply(this.peek(), arrays.map(function (a) {\n return isObservableArray(a) ? a.peek() : a;\n }));\n };\n ObservableArray.prototype.replace = function (newItems) {\n return this.$mobx.spliceWithArray(0, this.$mobx.values.length, newItems);\n };\n /**\n * Converts this array back to a (shallow) javascript structure.\n * For a deep clone use mobx.toJS\n */\n ObservableArray.prototype.toJS = function () {\n return this.slice();\n };\n ObservableArray.prototype.toJSON = function () {\n // Used by JSON.stringify\n return this.toJS();\n };\n ObservableArray.prototype.peek = function () {\n this.$mobx.atom.reportObserved();\n return this.$mobx.dehanceValues(this.$mobx.values);\n };\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find\n ObservableArray.prototype.find = function (predicate, thisArg, fromIndex) {\n if (fromIndex === void 0) {\n fromIndex = 0;\n }\n var idx = this.findIndex.apply(this, arguments);\n return idx === -1 ? undefined : this.get(idx);\n };\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex\n ObservableArray.prototype.findIndex = function (predicate, thisArg, fromIndex) {\n if (fromIndex === void 0) {\n fromIndex = 0;\n }\n var items = this.peek(),\n l = items.length;\n for (var i = fromIndex; i < l; i++) {\n if (predicate.call(thisArg, items[i], i, this)) return i;\n }return -1;\n };\n /*\n * functions that do alter the internal structure of the array, (based on lib.es6.d.ts)\n * since these functions alter the inner structure of the array, the have side effects.\n * Because the have side effects, they should not be used in computed function,\n * and for that reason the do not call dependencyState.notifyObserved\n */\n ObservableArray.prototype.splice = function (index, deleteCount) {\n var newItems = [];\n for (var _i = 2; _i < arguments.length; _i++) {\n newItems[_i - 2] = arguments[_i];\n }\n switch (arguments.length) {\n case 0:\n return [];\n case 1:\n return this.$mobx.spliceWithArray(index);\n case 2:\n return this.$mobx.spliceWithArray(index, deleteCount);\n }\n return this.$mobx.spliceWithArray(index, deleteCount, newItems);\n };\n ObservableArray.prototype.spliceWithArray = function (index, deleteCount, newItems) {\n return this.$mobx.spliceWithArray(index, deleteCount, newItems);\n };\n ObservableArray.prototype.push = function () {\n var items = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n items[_i] = arguments[_i];\n }\n var adm = this.$mobx;\n adm.spliceWithArray(adm.values.length, 0, items);\n return adm.values.length;\n };\n ObservableArray.prototype.pop = function () {\n return this.splice(Math.max(this.$mobx.values.length - 1, 0), 1)[0];\n };\n ObservableArray.prototype.shift = function () {\n return this.splice(0, 1)[0];\n };\n ObservableArray.prototype.unshift = function () {\n var items = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n items[_i] = arguments[_i];\n }\n var adm = this.$mobx;\n adm.spliceWithArray(0, 0, items);\n return adm.values.length;\n };\n ObservableArray.prototype.reverse = function () {\n // reverse by default mutates in place before returning the result\n // which makes it both a 'derivation' and a 'mutation'.\n // so we deviate from the default and just make it an dervitation\n var clone = this.slice();\n return clone.reverse.apply(clone, arguments);\n };\n ObservableArray.prototype.sort = function (compareFn) {\n // sort by default mutates in place before returning the result\n // which goes against all good practices. Let's not change the array in place!\n var clone = this.slice();\n return clone.sort.apply(clone, arguments);\n };\n ObservableArray.prototype.remove = function (value) {\n var idx = this.$mobx.dehanceValues(this.$mobx.values).indexOf(value);\n if (idx > -1) {\n this.splice(idx, 1);\n return true;\n }\n return false;\n };\n ObservableArray.prototype.move = function (fromIndex, toIndex) {\n function checkIndex(index) {\n if (index < 0) {\n throw new Error(\"[mobx.array] Index out of bounds: \" + index + \" is negative\");\n }\n var length = this.$mobx.values.length;\n if (index >= length) {\n throw new Error(\"[mobx.array] Index out of bounds: \" + index + \" is not smaller than \" + length);\n }\n }\n checkIndex.call(this, fromIndex);\n checkIndex.call(this, toIndex);\n if (fromIndex === toIndex) {\n return;\n }\n var oldItems = this.$mobx.values;\n var newItems;\n if (fromIndex < toIndex) {\n newItems = oldItems.slice(0, fromIndex).concat(oldItems.slice(fromIndex + 1, toIndex + 1), [oldItems[fromIndex]], oldItems.slice(toIndex + 1));\n } else {\n // toIndex < fromIndex\n newItems = oldItems.slice(0, toIndex).concat([oldItems[fromIndex]], oldItems.slice(toIndex, fromIndex), oldItems.slice(fromIndex + 1));\n }\n this.replace(newItems);\n };\n // See #734, in case property accessors are unreliable...\n ObservableArray.prototype.get = function (index) {\n var impl = this.$mobx;\n if (impl) {\n if (index < impl.values.length) {\n impl.atom.reportObserved();\n return impl.dehanceValue(impl.values[index]);\n }\n console.warn(\"[mobx.array] Attempt to read an array index (\" + index + \") that is out of bounds (\" + impl.values.length + \"). Please check length first. Out of bound indices will not be tracked by MobX\");\n }\n return undefined;\n };\n // See #734, in case property accessors are unreliable...\n ObservableArray.prototype.set = function (index, newValue) {\n var adm = this.$mobx;\n var values = adm.values;\n if (index < values.length) {\n // update at index in range\n checkIfStateModificationsAreAllowed(adm.atom);\n var oldValue = values[index];\n if (hasInterceptors(adm)) {\n var change = interceptChange(adm, {\n type: \"update\",\n object: this,\n index: index,\n newValue: newValue\n });\n if (!change) return;\n newValue = change.newValue;\n }\n newValue = adm.enhancer(newValue, oldValue);\n var changed = newValue !== oldValue;\n if (changed) {\n values[index] = newValue;\n adm.notifyArrayChildUpdate(index, newValue, oldValue);\n }\n } else if (index === values.length) {\n // add a new item\n adm.spliceWithArray(index, 0, [newValue]);\n } else {\n // out of bounds\n throw new Error(\"[mobx.array] Index out of bounds, \" + index + \" is larger than \" + values.length);\n }\n };\n return ObservableArray;\n}(StubArray);\ndeclareIterator(ObservableArray.prototype, function () {\n return arrayAsIterator(this.slice());\n});\nObject.defineProperty(ObservableArray.prototype, \"length\", {\n enumerable: false,\n configurable: true,\n get: function get() {\n return this.$mobx.getArrayLength();\n },\n set: function set(newLength) {\n this.$mobx.setArrayLength(newLength);\n }\n});\n[\"every\", \"filter\", \"forEach\", \"indexOf\", \"join\", \"lastIndexOf\", \"map\", \"reduce\", \"reduceRight\", \"slice\", \"some\", \"toString\", \"toLocaleString\"].forEach(function (funcName) {\n var baseFunc = Array.prototype[funcName];\n invariant(typeof baseFunc === \"function\", \"Base function not defined on Array prototype: '\" + funcName + \"'\");\n addHiddenProp(ObservableArray.prototype, funcName, function () {\n return baseFunc.apply(this.peek(), arguments);\n });\n});\n/**\n * We don't want those to show up in `for (const key in ar)` ...\n */\nmakeNonEnumerable(ObservableArray.prototype, [\"constructor\", \"intercept\", \"observe\", \"clear\", \"concat\", \"get\", \"replace\", \"toJS\", \"toJSON\", \"peek\", \"find\", \"findIndex\", \"splice\", \"spliceWithArray\", \"push\", \"pop\", \"set\", \"shift\", \"unshift\", \"reverse\", \"sort\", \"remove\", \"move\", \"toString\", \"toLocaleString\"]);\n// See #364\nvar ENTRY_0 = createArrayEntryDescriptor(0);\nfunction createArrayEntryDescriptor(index) {\n return {\n enumerable: false,\n configurable: false,\n get: function get() {\n // TODO: Check `this`?, see #752?\n return this.get(index);\n },\n set: function set(value) {\n this.set(index, value);\n }\n };\n}\nfunction createArrayBufferItem(index) {\n Object.defineProperty(ObservableArray.prototype, \"\" + index, createArrayEntryDescriptor(index));\n}\nfunction reserveArrayBuffer(max) {\n for (var index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max; index++) {\n createArrayBufferItem(index);\n }OBSERVABLE_ARRAY_BUFFER_SIZE = max;\n}\nreserveArrayBuffer(1000);\nvar isObservableArrayAdministration = createInstanceofPredicate(\"ObservableArrayAdministration\", ObservableArrayAdministration);\nfunction isObservableArray(thing) {\n return isObject(thing) && isObservableArrayAdministration(thing.$mobx);\n}\n\nvar UNCHANGED = {};\nvar ObservableValue = /** @class */function (_super) {\n __extends(ObservableValue, _super);\n function ObservableValue(value, enhancer, name, notifySpy) {\n if (name === void 0) {\n name = \"ObservableValue@\" + getNextId();\n }\n if (notifySpy === void 0) {\n notifySpy = true;\n }\n var _this = _super.call(this, name) || this;\n _this.enhancer = enhancer;\n _this.hasUnreportedChange = false;\n _this.dehancer = undefined;\n _this.value = enhancer(value, undefined, name);\n if (notifySpy && isSpyEnabled()) {\n // only notify spy if this is a stand-alone observable\n spyReport({ type: \"create\", object: _this, newValue: _this.value });\n }\n return _this;\n }\n ObservableValue.prototype.dehanceValue = function (value) {\n if (this.dehancer !== undefined) return this.dehancer(value);\n return value;\n };\n ObservableValue.prototype.set = function (newValue) {\n var oldValue = this.value;\n newValue = this.prepareNewValue(newValue);\n if (newValue !== UNCHANGED) {\n var notifySpy = isSpyEnabled();\n if (notifySpy) {\n spyReportStart({\n type: \"update\",\n object: this,\n newValue: newValue,\n oldValue: oldValue\n });\n }\n this.setNewValue(newValue);\n if (notifySpy) spyReportEnd();\n }\n };\n ObservableValue.prototype.prepareNewValue = function (newValue) {\n checkIfStateModificationsAreAllowed(this);\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n object: this,\n type: \"update\",\n newValue: newValue\n });\n if (!change) return UNCHANGED;\n newValue = change.newValue;\n }\n // apply modifier\n newValue = this.enhancer(newValue, this.value, this.name);\n return this.value !== newValue ? newValue : UNCHANGED;\n };\n ObservableValue.prototype.setNewValue = function (newValue) {\n var oldValue = this.value;\n this.value = newValue;\n this.reportChanged();\n if (hasListeners(this)) {\n notifyListeners(this, {\n type: \"update\",\n object: this,\n newValue: newValue,\n oldValue: oldValue\n });\n }\n };\n ObservableValue.prototype.get = function () {\n this.reportObserved();\n return this.dehanceValue(this.value);\n };\n ObservableValue.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n ObservableValue.prototype.observe = function (listener, fireImmediately) {\n if (fireImmediately) listener({\n object: this,\n type: \"update\",\n newValue: this.value,\n oldValue: undefined\n });\n return registerListener(this, listener);\n };\n ObservableValue.prototype.toJSON = function () {\n return this.get();\n };\n ObservableValue.prototype.toString = function () {\n return this.name + \"[\" + this.value + \"]\";\n };\n ObservableValue.prototype.valueOf = function () {\n return toPrimitive(this.get());\n };\n return ObservableValue;\n}(BaseAtom);\nObservableValue.prototype[primitiveSymbol()] = ObservableValue.prototype.valueOf;\nvar isObservableValue = createInstanceofPredicate(\"ObservableValue\", ObservableValue);\n\nvar messages = {\n m001: \"It is not allowed to assign new values to @action fields\",\n m002: \"`runInAction` expects a function\",\n m003: \"`runInAction` expects a function without arguments\",\n m004: \"autorun expects a function\",\n m005: \"Warning: attempted to pass an action to autorun. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.\",\n m006: \"Warning: attempted to pass an action to autorunAsync. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.\",\n m007: \"reaction only accepts 2 or 3 arguments. If migrating from MobX 2, please provide an options object\",\n m008: \"wrapping reaction expression in `asReference` is no longer supported, use options object instead\",\n m009: \"@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'. It looks like it was used on a property.\",\n m010: \"@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'\",\n m011: \"First argument to `computed` should be an expression. If using computed as decorator, don't pass it arguments\",\n m012: \"computed takes one or two arguments if used as function\",\n m013: \"[mobx.expr] 'expr' should only be used inside other reactive functions.\",\n m014: \"extendObservable expected 2 or more arguments\",\n m015: \"extendObservable expects an object as first argument\",\n m016: \"extendObservable should not be used on maps, use map.merge instead\",\n m017: \"all arguments of extendObservable should be objects\",\n m018: \"extending an object with another observable (object) is not supported. Please construct an explicit propertymap, using `toJS` if need. See issue #540\",\n m019: \"[mobx.isObservable] isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.\",\n m020: \"modifiers can only be used for individual object properties\",\n m021: \"observable expects zero or one arguments\",\n m022: \"@observable can not be used on getters, use @computed instead\",\n m024: \"whyRun() can only be used if a derivation is active, or by passing an computed value / reaction explicitly. If you invoked whyRun from inside a computation; the computation is currently suspended but re-evaluating because somebody requested its value.\",\n m025: \"whyRun can only be used on reactions and computed values\",\n m026: \"`action` can only be invoked on functions\",\n m028: \"It is not allowed to set `useStrict` when a derivation is running\",\n m029: \"INTERNAL ERROR only onBecomeUnobserved shouldn't be called twice in a row\",\n m030a: \"Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: \",\n m030b: \"Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, the render function of a React component? Tried to modify: \",\n m031: \"Computed values are not allowed to cause side effects by changing observables that are already being observed. Tried to modify: \",\n m032: \"* This computation is suspended (not in use by any reaction) and won't run automatically.\\n\tDidn't expect this computation to be suspended at this point?\\n\t 1. Make sure this computation is used by a reaction (reaction, autorun, observer).\\n\t 2. Check whether you are using this computation synchronously (in the same stack as they reaction that needs it).\",\n m033: \"`observe` doesn't support the fire immediately property for observable maps.\",\n m034: \"`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead\",\n m035: \"Cannot make the designated object observable; it is not extensible\",\n m036: \"It is not possible to get index atoms from arrays\",\n m037: \"Hi there! I'm sorry you have just run into an exception.\\nIf your debugger ends up here, know that some reaction (like the render() of an observer component, autorun or reaction)\\nthrew an exception and that mobx caught it, to avoid that it brings the rest of your application down.\\nThe original cause of the exception (the code that caused this reaction to run (again)), is still in the stack.\\n\\nHowever, more interesting is the actual stack trace of the error itself.\\nHopefully the error is an instanceof Error, because in that case you can inspect the original stack of the error from where it was thrown.\\nSee `error.stack` property, or press the very subtle \\\"(...)\\\" link you see near the console.error message that probably brought you here.\\nThat stack is more interesting than the stack of this console.error itself.\\n\\nIf the exception you see is an exception you created yourself, make sure to use `throw new Error(\\\"Oops\\\")` instead of `throw \\\"Oops\\\"`,\\nbecause the javascript environment will only preserve the original stack trace in the first form.\\n\\nYou can also make sure the debugger pauses the next time this very same exception is thrown by enabling \\\"Pause on caught exception\\\".\\n(Note that it might pause on many other, unrelated exception as well).\\n\\nIf that all doesn't help you out, feel free to open an issue https://github.com/mobxjs/mobx/issues!\\n\",\n m038: \"Missing items in this list?\\n 1. Check whether all used values are properly marked as observable (use isObservable to verify)\\n 2. Make sure you didn't dereference values too early. MobX observes props, not primitives. E.g: use 'person.name' instead of 'name' in your computation.\\n\"\n};\nfunction getMessage(id) {\n return messages[id];\n}\n\nfunction createAction(actionName, fn) {\n invariant(typeof fn === \"function\", getMessage(\"m026\"));\n invariant(typeof actionName === \"string\" && actionName.length > 0, \"actions should have valid names, got: '\" + actionName + \"'\");\n var res = function res() {\n return executeAction(actionName, fn, this, arguments);\n };\n res.originalFn = fn;\n res.isMobxAction = true;\n return res;\n}\nfunction executeAction(actionName, fn, scope, args) {\n var runInfo = startAction(actionName, fn, scope, args);\n try {\n return fn.apply(scope, args);\n } finally {\n endAction(runInfo);\n }\n}\nfunction startAction(actionName, fn, scope, args) {\n var notifySpy = isSpyEnabled() && !!actionName;\n var startTime = 0;\n if (notifySpy) {\n startTime = Date.now();\n var l = args && args.length || 0;\n var flattendArgs = new Array(l);\n if (l > 0) for (var i = 0; i < l; i++) {\n flattendArgs[i] = args[i];\n }spyReportStart({\n type: \"action\",\n name: actionName,\n fn: fn,\n object: scope,\n arguments: flattendArgs\n });\n }\n var prevDerivation = untrackedStart();\n startBatch();\n var prevAllowStateChanges = allowStateChangesStart(true);\n return {\n prevDerivation: prevDerivation,\n prevAllowStateChanges: prevAllowStateChanges,\n notifySpy: notifySpy,\n startTime: startTime\n };\n}\nfunction endAction(runInfo) {\n allowStateChangesEnd(runInfo.prevAllowStateChanges);\n endBatch();\n untrackedEnd(runInfo.prevDerivation);\n if (runInfo.notifySpy) spyReportEnd({ time: Date.now() - runInfo.startTime });\n}\nfunction useStrict(strict) {\n invariant(globalState.trackingDerivation === null, getMessage(\"m028\"));\n globalState.strictMode = strict;\n globalState.allowStateChanges = !strict;\n}\nfunction isStrictModeEnabled() {\n return globalState.strictMode;\n}\nfunction allowStateChanges(allowStateChanges, func) {\n // TODO: deprecate / refactor this function in next major\n // Currently only used by `@observer`\n // Proposed change: remove first param, rename to `forbidStateChanges`,\n // require error callback instead of the hardcoded error message now used\n // Use `inAction` instead of allowStateChanges in derivation.ts to check strictMode\n var prev = allowStateChangesStart(allowStateChanges);\n var res;\n try {\n res = func();\n } finally {\n allowStateChangesEnd(prev);\n }\n return res;\n}\nfunction allowStateChangesStart(allowStateChanges) {\n var prev = globalState.allowStateChanges;\n globalState.allowStateChanges = allowStateChanges;\n return prev;\n}\nfunction allowStateChangesEnd(prev) {\n globalState.allowStateChanges = prev;\n}\n\n/**\n * Constructs a decorator, that normalizes the differences between\n * TypeScript and Babel. Mainly caused by the fact that legacy-decorator cannot assign\n * values during instance creation to properties that have a getter setter.\n *\n * - Sigh -\n *\n * Also takes care of the difference between @decorator field and @decorator(args) field, and different forms of values.\n * For performance (cpu and mem) reasons the properties are always defined on the prototype (at least initially).\n * This means that these properties despite being enumerable might not show up in Object.keys() (but they will show up in for...in loops).\n */\nfunction createClassPropertyDecorator(\n/**\n * This function is invoked once, when the property is added to a new instance.\n * When this happens is not strictly determined due to differences in TS and Babel:\n * Typescript: Usually when constructing the new instance\n * Babel, sometimes Typescript: during the first get / set\n * Both: when calling `runLazyInitializers(instance)`\n */\nonInitialize, _get, _set, enumerable,\n/**\n * Can this decorator invoked with arguments? e.g. @decorator(args)\n */\nallowCustomArguments) {\n function classPropertyDecorator(target, key, descriptor, customArgs, argLen) {\n if (argLen === void 0) {\n argLen = 0;\n }\n invariant(allowCustomArguments || quacksLikeADecorator(arguments), \"This function is a decorator, but it wasn't invoked like a decorator\");\n if (!descriptor) {\n // typescript (except for getter / setters)\n var newDescriptor = {\n enumerable: enumerable,\n configurable: true,\n get: function get() {\n if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true) typescriptInitializeProperty(this, key, undefined, onInitialize, customArgs, descriptor);\n return _get.call(this, key);\n },\n set: function set(v) {\n if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true) {\n typescriptInitializeProperty(this, key, v, onInitialize, customArgs, descriptor);\n } else {\n _set.call(this, key, v);\n }\n }\n };\n if (arguments.length < 3 || arguments.length === 5 && argLen < 3) {\n // Typescript target is ES3, so it won't define property for us\n // or using Reflect.decorate polyfill, which will return no descriptor\n // (see https://github.com/mobxjs/mobx/issues/333)\n Object.defineProperty(target, key, newDescriptor);\n }\n return newDescriptor;\n } else {\n // babel and typescript getter / setter props\n if (!hasOwnProperty(target, \"__mobxLazyInitializers\")) {\n addHiddenProp(target, \"__mobxLazyInitializers\", target.__mobxLazyInitializers && target.__mobxLazyInitializers.slice() || [] // support inheritance\n );\n }\n var value_1 = descriptor.value,\n initializer_1 = descriptor.initializer;\n target.__mobxLazyInitializers.push(function (instance) {\n onInitialize(instance, key, initializer_1 ? initializer_1.call(instance) : value_1, customArgs, descriptor);\n });\n return {\n enumerable: enumerable,\n configurable: true,\n get: function get() {\n if (this.__mobxDidRunLazyInitializers !== true) runLazyInitializers(this);\n return _get.call(this, key);\n },\n set: function set(v) {\n if (this.__mobxDidRunLazyInitializers !== true) runLazyInitializers(this);\n _set.call(this, key, v);\n }\n };\n }\n }\n if (allowCustomArguments) {\n /** If custom arguments are allowed, we should return a function that returns a decorator */\n return function () {\n /** Direct invocation: @decorator bla */\n if (quacksLikeADecorator(arguments)) return classPropertyDecorator.apply(null, arguments);\n /** Indirect invocation: @decorator(args) bla */\n var outerArgs = arguments;\n var argLen = arguments.length;\n return function (target, key, descriptor) {\n return classPropertyDecorator(target, key, descriptor, outerArgs, argLen);\n };\n };\n }\n return classPropertyDecorator;\n}\nfunction typescriptInitializeProperty(instance, key, v, onInitialize, customArgs, baseDescriptor) {\n if (!hasOwnProperty(instance, \"__mobxInitializedProps\")) addHiddenProp(instance, \"__mobxInitializedProps\", {});\n instance.__mobxInitializedProps[key] = true;\n onInitialize(instance, key, v, customArgs, baseDescriptor);\n}\nfunction runLazyInitializers(instance) {\n if (instance.__mobxDidRunLazyInitializers === true) return;\n if (instance.__mobxLazyInitializers) {\n addHiddenProp(instance, \"__mobxDidRunLazyInitializers\", true);\n instance.__mobxDidRunLazyInitializers && instance.__mobxLazyInitializers.forEach(function (initializer) {\n return initializer(instance);\n });\n }\n}\nfunction quacksLikeADecorator(args) {\n return (args.length === 2 || args.length === 3) && typeof args[1] === \"string\";\n}\n\nvar actionFieldDecorator = createClassPropertyDecorator(function (target, key, value, args, originalDescriptor) {\n var actionName = args && args.length === 1 ? args[0] : value.name || key || \"<unnamed action>\";\n var wrappedAction = action(actionName, value);\n addHiddenProp(target, key, wrappedAction);\n}, function (key) {\n return this[key];\n}, function () {\n invariant(false, getMessage(\"m001\"));\n}, false, true);\nvar boundActionDecorator = createClassPropertyDecorator(function (target, key, value) {\n defineBoundAction(target, key, value);\n}, function (key) {\n return this[key];\n}, function () {\n invariant(false, getMessage(\"m001\"));\n}, false, false);\nvar action = function action(arg1, arg2, arg3, arg4) {\n if (arguments.length === 1 && typeof arg1 === \"function\") return createAction(arg1.name || \"<unnamed action>\", arg1);\n if (arguments.length === 2 && typeof arg2 === \"function\") return createAction(arg1, arg2);\n if (arguments.length === 1 && typeof arg1 === \"string\") return namedActionDecorator(arg1);\n return namedActionDecorator(arg2).apply(null, arguments);\n};\naction.bound = function boundAction(arg1, arg2, arg3) {\n if (typeof arg1 === \"function\") {\n var action_1 = createAction(\"<not yet bound action>\", arg1);\n action_1.autoBind = true;\n return action_1;\n }\n return boundActionDecorator.apply(null, arguments);\n};\nfunction namedActionDecorator(name) {\n return function (target, prop, descriptor) {\n if (descriptor && typeof descriptor.value === \"function\") {\n // TypeScript @action method() { }. Defined on proto before being decorated\n // Don't use the field decorator if we are just decorating a method\n descriptor.value = createAction(name, descriptor.value);\n descriptor.enumerable = false;\n descriptor.configurable = true;\n return descriptor;\n }\n if (descriptor !== undefined && descriptor.get !== undefined) {\n throw new Error(\"[mobx] action is not expected to be used with getters\");\n }\n // bound instance methods\n return actionFieldDecorator(name).apply(this, arguments);\n };\n}\nfunction runInAction(arg1, arg2, arg3) {\n var actionName = typeof arg1 === \"string\" ? arg1 : arg1.name || \"<unnamed action>\";\n var fn = typeof arg1 === \"function\" ? arg1 : arg2;\n var scope = typeof arg1 === \"function\" ? arg2 : arg3;\n invariant(typeof fn === \"function\", getMessage(\"m002\"));\n invariant(fn.length === 0, getMessage(\"m003\"));\n invariant(typeof actionName === \"string\" && actionName.length > 0, \"actions should have valid names, got: '\" + actionName + \"'\");\n return executeAction(actionName, fn, scope, undefined);\n}\nfunction isAction(thing) {\n return typeof thing === \"function\" && thing.isMobxAction === true;\n}\nfunction defineBoundAction(target, propertyName, fn) {\n var res = function res() {\n return executeAction(propertyName, fn, target, arguments);\n };\n res.isMobxAction = true;\n addHiddenProp(target, propertyName, res);\n}\n\nvar toString = Object.prototype.toString;\nfunction deepEqual(a, b) {\n return eq(a, b);\n}\n// Copied from https://github.com/jashkenas/underscore/blob/5c237a7c682fb68fd5378203f0bf22dce1624854/underscore.js#L1186-L1289\n// Internal recursive comparison function for `isEqual`.\nfunction eq(a, b, aStack, bStack) {\n // Identical objects are equal. `0 === -0`, but they aren't identical.\n // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n if (a === b) return a !== 0 || 1 / a === 1 / b;\n // `null` or `undefined` only equal to itself (strict comparison).\n if (a == null || b == null) return false;\n // `NaN`s are equivalent, but non-reflexive.\n if (a !== a) return b !== b;\n // Exhaust primitive checks\n var type = typeof a === \"undefined\" ? \"undefined\" : _typeof(a);\n if (type !== \"function\" && type !== \"object\" && (typeof b === \"undefined\" ? \"undefined\" : _typeof(b)) != \"object\") return false;\n return deepEq(a, b, aStack, bStack);\n}\n// Internal recursive comparison function for `isEqual`.\nfunction deepEq(a, b, aStack, bStack) {\n // Unwrap any wrapped objects.\n a = unwrap(a);\n b = unwrap(b);\n // Compare `[[Class]]` names.\n var className = toString.call(a);\n if (className !== toString.call(b)) return false;\n switch (className) {\n // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n case \"[object RegExp]\":\n // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n case \"[object String]\":\n // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n // equivalent to `new String(\"5\")`.\n return \"\" + a === \"\" + b;\n case \"[object Number]\":\n // `NaN`s are equivalent, but non-reflexive.\n // Object(NaN) is equivalent to NaN.\n if (+a !== +a) return +b !== +b;\n // An `egal` comparison is performed for other numeric values.\n return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n case \"[object Date]\":\n case \"[object Boolean]\":\n // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n // millisecond representations. Note that invalid dates with millisecond representations\n // of `NaN` are not equivalent.\n return +a === +b;\n case \"[object Symbol]\":\n return typeof Symbol !== \"undefined\" && Symbol.valueOf.call(a) === Symbol.valueOf.call(b);\n }\n var areArrays = className === \"[object Array]\";\n if (!areArrays) {\n if ((typeof a === \"undefined\" ? \"undefined\" : _typeof(a)) != \"object\" || (typeof b === \"undefined\" ? \"undefined\" : _typeof(b)) != \"object\") return false;\n // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n // from different frames are.\n var aCtor = a.constructor,\n bCtor = b.constructor;\n if (aCtor !== bCtor && !(typeof aCtor === \"function\" && aCtor instanceof aCtor && typeof bCtor === \"function\" && bCtor instanceof bCtor) && \"constructor\" in a && \"constructor\" in b) {\n return false;\n }\n }\n // Assume equality for cyclic structures. The algorithm for detecting cyclic\n // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n // Initializing stack of traversed objects.\n // It's done here since we only need them for objects and arrays comparison.\n aStack = aStack || [];\n bStack = bStack || [];\n var length = aStack.length;\n while (length--) {\n // Linear search. Performance is inversely proportional to the number of\n // unique nested structures.\n if (aStack[length] === a) return bStack[length] === b;\n }\n // Add the first object to the stack of traversed objects.\n aStack.push(a);\n bStack.push(b);\n // Recursively compare objects and arrays.\n if (areArrays) {\n // Compare array lengths to determine if a deep comparison is necessary.\n length = a.length;\n if (length !== b.length) return false;\n // Deep compare the contents, ignoring non-numeric properties.\n while (length--) {\n if (!eq(a[length], b[length], aStack, bStack)) return false;\n }\n } else {\n // Deep compare objects.\n var keys = Object.keys(a),\n key;\n length = keys.length;\n // Ensure that both objects contain the same number of properties before comparing deep equality.\n if (Object.keys(b).length !== length) return false;\n while (length--) {\n // Deep compare each member\n key = keys[length];\n if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n }\n }\n // Remove the first object from the stack of traversed objects.\n aStack.pop();\n bStack.pop();\n return true;\n}\nfunction unwrap(a) {\n if (isObservableArray(a)) return a.peek();\n if (isObservableMap(a)) return a.entries();\n if (isES6Map(a)) return iteratorToArray(a.entries());\n return a;\n}\nfunction has(a, key) {\n return Object.prototype.hasOwnProperty.call(a, key);\n}\n\nfunction identityComparer(a, b) {\n return a === b;\n}\nfunction structuralComparer(a, b) {\n return deepEqual(a, b);\n}\nfunction defaultComparer(a, b) {\n return areBothNaN(a, b) || identityComparer(a, b);\n}\nvar comparer = {\n identity: identityComparer,\n structural: structuralComparer,\n default: defaultComparer\n};\n\nfunction autorun(arg1, arg2, arg3) {\n var name, view, scope;\n if (typeof arg1 === \"string\") {\n name = arg1;\n view = arg2;\n scope = arg3;\n } else {\n name = arg1.name || \"Autorun@\" + getNextId();\n view = arg1;\n scope = arg2;\n }\n invariant(typeof view === \"function\", getMessage(\"m004\"));\n invariant(isAction(view) === false, getMessage(\"m005\"));\n if (scope) view = view.bind(scope);\n var reaction = new Reaction(name, function () {\n this.track(reactionRunner);\n });\n function reactionRunner() {\n view(reaction);\n }\n reaction.schedule();\n return reaction.getDisposer();\n}\nfunction when(arg1, arg2, arg3, arg4) {\n var name, predicate, effect, scope;\n if (typeof arg1 === \"string\") {\n name = arg1;\n predicate = arg2;\n effect = arg3;\n scope = arg4;\n } else {\n name = \"When@\" + getNextId();\n predicate = arg1;\n effect = arg2;\n scope = arg3;\n }\n var disposer = autorun(name, function (r) {\n if (predicate.call(scope)) {\n r.dispose();\n var prevUntracked = untrackedStart();\n effect.call(scope);\n untrackedEnd(prevUntracked);\n }\n });\n return disposer;\n}\nfunction autorunAsync(arg1, arg2, arg3, arg4) {\n var name, func, delay, scope;\n if (typeof arg1 === \"string\") {\n name = arg1;\n func = arg2;\n delay = arg3;\n scope = arg4;\n } else {\n name = arg1.name || \"AutorunAsync@\" + getNextId();\n func = arg1;\n delay = arg2;\n scope = arg3;\n }\n invariant(isAction(func) === false, getMessage(\"m006\"));\n if (delay === void 0) delay = 1;\n if (scope) func = func.bind(scope);\n var isScheduled = false;\n var r = new Reaction(name, function () {\n if (!isScheduled) {\n isScheduled = true;\n setTimeout(function () {\n isScheduled = false;\n if (!r.isDisposed) r.track(reactionRunner);\n }, delay);\n }\n });\n function reactionRunner() {\n func(r);\n }\n r.schedule();\n return r.getDisposer();\n}\nfunction reaction(expression, effect, arg3) {\n if (arguments.length > 3) {\n fail(getMessage(\"m007\"));\n }\n if (isModifierDescriptor(expression)) {\n fail(getMessage(\"m008\"));\n }\n var opts;\n if ((typeof arg3 === \"undefined\" ? \"undefined\" : _typeof(arg3)) === \"object\") {\n opts = arg3;\n } else {\n opts = {};\n }\n opts.name = opts.name || expression.name || effect.name || \"Reaction@\" + getNextId();\n opts.fireImmediately = arg3 === true || opts.fireImmediately === true;\n opts.delay = opts.delay || 0;\n opts.compareStructural = opts.compareStructural || opts.struct || false;\n // TODO: creates ugly spy events, use `effect = (r) => runInAction(opts.name, () => effect(r))` instead\n effect = action(opts.name, opts.context ? effect.bind(opts.context) : effect);\n if (opts.context) {\n expression = expression.bind(opts.context);\n }\n var firstTime = true;\n var isScheduled = false;\n var value;\n var equals = opts.equals ? opts.equals : opts.compareStructural || opts.struct ? comparer.structural : comparer.default;\n var r = new Reaction(opts.name, function () {\n if (firstTime || opts.delay < 1) {\n reactionRunner();\n } else if (!isScheduled) {\n isScheduled = true;\n setTimeout(function () {\n isScheduled = false;\n reactionRunner();\n }, opts.delay);\n }\n });\n function reactionRunner() {\n if (r.isDisposed) return;\n var changed = false;\n r.track(function () {\n var nextValue = expression(r);\n changed = firstTime || !equals(value, nextValue);\n value = nextValue;\n });\n if (firstTime && opts.fireImmediately) effect(value, r);\n if (!firstTime && changed === true) effect(value, r);\n if (firstTime) firstTime = false;\n }\n r.schedule();\n return r.getDisposer();\n}\n\n/**\n * A node in the state dependency root that observes other nodes, and can be observed itself.\n *\n * ComputedValue will remember the result of the computation for the duration of the batch, or\n * while being observed.\n *\n * During this time it will recompute only when one of its direct dependencies changed,\n * but only when it is being accessed with `ComputedValue.get()`.\n *\n * Implementation description:\n * 1. First time it's being accessed it will compute and remember result\n * give back remembered result until 2. happens\n * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.\n * 3. When it's being accessed, recompute if any shallow dependency changed.\n * if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.\n * go to step 2. either way\n *\n * If at any point it's outside batch and it isn't observed: reset everything and go to 1.\n */\nvar ComputedValue = /** @class */function () {\n /**\n * Create a new computed value based on a function expression.\n *\n * The `name` property is for debug purposes only.\n *\n * The `equals` property specifies the comparer function to use to determine if a newly produced\n * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`\n * compares based on identity comparison (===), and `structualComparer` deeply compares the structure.\n * Structural comparison can be convenient if you always produce an new aggregated object and\n * don't want to notify observers if it is structurally the same.\n * This is useful for working with vectors, mouse coordinates etc.\n */\n function ComputedValue(derivation, scope, equals, name, setter) {\n this.derivation = derivation;\n this.scope = scope;\n this.equals = equals;\n this.dependenciesState = IDerivationState.NOT_TRACKING;\n this.observing = []; // nodes we are looking at. Our value depends on these nodes\n this.newObserving = null; // during tracking it's an array with new observed observers\n this.isPendingUnobservation = false;\n this.observers = [];\n this.observersIndexes = {};\n this.diffValue = 0;\n this.runId = 0;\n this.lastAccessedBy = 0;\n this.lowestObserverState = IDerivationState.UP_TO_DATE;\n this.unboundDepsCount = 0;\n this.__mapid = \"#\" + getNextId();\n this.value = new CaughtException(null);\n this.isComputing = false; // to check for cycles\n this.isRunningSetter = false;\n this.isTracing = TraceMode.NONE;\n this.name = name || \"ComputedValue@\" + getNextId();\n if (setter) this.setter = createAction(name + \"-setter\", setter);\n }\n ComputedValue.prototype.onBecomeStale = function () {\n propagateMaybeChanged(this);\n };\n ComputedValue.prototype.onBecomeUnobserved = function () {\n clearObserving(this);\n this.value = undefined;\n };\n /**\n * Returns the current value of this computed value.\n * Will evaluate its computation first if needed.\n */\n ComputedValue.prototype.get = function () {\n invariant(!this.isComputing, \"Cycle detected in computation \" + this.name, this.derivation);\n if (globalState.inBatch === 0) {\n // This is an minor optimization which could be omitted to simplify the code\n // The computedValue is accessed outside of any mobx stuff. Batch observing should be enough and don't need\n // tracking as it will never be called again inside this batch.\n startBatch();\n if (shouldCompute(this)) {\n if (this.isTracing !== TraceMode.NONE) {\n console.log(\"[mobx.trace] '\" + this.name + \"' is being read outside a reactive context and doing a full recompute\");\n }\n this.value = this.computeValue(false);\n }\n endBatch();\n } else {\n reportObserved(this);\n if (shouldCompute(this)) if (this.trackAndCompute()) propagateChangeConfirmed(this);\n }\n var result = this.value;\n if (isCaughtException(result)) throw result.cause;\n return result;\n };\n ComputedValue.prototype.peek = function () {\n var res = this.computeValue(false);\n if (isCaughtException(res)) throw res.cause;\n return res;\n };\n ComputedValue.prototype.set = function (value) {\n if (this.setter) {\n invariant(!this.isRunningSetter, \"The setter of computed value '\" + this.name + \"' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?\");\n this.isRunningSetter = true;\n try {\n this.setter.call(this.scope, value);\n } finally {\n this.isRunningSetter = false;\n }\n } else invariant(false, \"[ComputedValue '\" + this.name + \"'] It is not possible to assign a new value to a computed value.\");\n };\n ComputedValue.prototype.trackAndCompute = function () {\n if (isSpyEnabled()) {\n spyReport({\n object: this.scope,\n type: \"compute\",\n fn: this.derivation\n });\n }\n var oldValue = this.value;\n var wasSuspended =\n /* see #1208 */this.dependenciesState === IDerivationState.NOT_TRACKING;\n var newValue = this.value = this.computeValue(true);\n return wasSuspended || isCaughtException(oldValue) || isCaughtException(newValue) || !this.equals(oldValue, newValue);\n };\n ComputedValue.prototype.computeValue = function (track) {\n this.isComputing = true;\n globalState.computationDepth++;\n var res;\n if (track) {\n res = trackDerivedFunction(this, this.derivation, this.scope);\n } else {\n try {\n res = this.derivation.call(this.scope);\n } catch (e) {\n res = new CaughtException(e);\n }\n }\n globalState.computationDepth--;\n this.isComputing = false;\n return res;\n };\n ComputedValue.prototype.observe = function (listener, fireImmediately) {\n var _this = this;\n var firstTime = true;\n var prevValue = undefined;\n return autorun(function () {\n var newValue = _this.get();\n if (!firstTime || fireImmediately) {\n var prevU = untrackedStart();\n listener({\n type: \"update\",\n object: _this,\n newValue: newValue,\n oldValue: prevValue\n });\n untrackedEnd(prevU);\n }\n firstTime = false;\n prevValue = newValue;\n });\n };\n ComputedValue.prototype.toJSON = function () {\n return this.get();\n };\n ComputedValue.prototype.toString = function () {\n return this.name + \"[\" + this.derivation.toString() + \"]\";\n };\n ComputedValue.prototype.valueOf = function () {\n return toPrimitive(this.get());\n };\n ComputedValue.prototype.whyRun = function () {\n var isTracking = Boolean(globalState.trackingDerivation);\n var observing = unique(this.isComputing ? this.newObserving : this.observing).map(function (dep) {\n return dep.name;\n });\n var observers = unique(getObservers(this).map(function (dep) {\n return dep.name;\n }));\n return \"\\nWhyRun? computation '\" + this.name + \"':\\n * Running because: \" + (isTracking ? \"[active] the value of this computation is needed by a reaction\" : this.isComputing ? \"[get] The value of this computed was requested outside a reaction\" : \"[idle] not running at the moment\") + \"\\n\" + (this.dependenciesState === IDerivationState.NOT_TRACKING ? getMessage(\"m032\") : \" * This computation will re-run if any of the following observables changes:\\n \" + joinStrings(observing) + \"\\n \" + (this.isComputing && isTracking ? \" (... or any observable accessed during the remainder of the current run)\" : \"\") + \"\\n \" + getMessage(\"m038\") + \"\\n\\n * If the outcome of this computation changes, the following observers will be re-run:\\n \" + joinStrings(observers) + \"\\n\");\n };\n return ComputedValue;\n}();\nComputedValue.prototype[primitiveSymbol()] = ComputedValue.prototype.valueOf;\nvar isComputedValue = createInstanceofPredicate(\"ComputedValue\", ComputedValue);\n\nvar ObservableObjectAdministration = /** @class */function () {\n function ObservableObjectAdministration(target, name) {\n this.target = target;\n this.name = name;\n this.values = {};\n this.changeListeners = null;\n this.interceptors = null;\n }\n /**\n * Observes this object. Triggers for the events 'add', 'update' and 'delete'.\n * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe\n * for callback details\n */\n ObservableObjectAdministration.prototype.observe = function (callback, fireImmediately) {\n invariant(fireImmediately !== true, \"`observe` doesn't support the fire immediately property for observable objects.\");\n return registerListener(this, callback);\n };\n ObservableObjectAdministration.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n return ObservableObjectAdministration;\n}();\nfunction asObservableObject(target, name) {\n if (isObservableObject(target) && target.hasOwnProperty(\"$mobx\")) return target.$mobx;\n invariant(Object.isExtensible(target), getMessage(\"m035\"));\n if (!isPlainObject(target)) name = (target.constructor.name || \"ObservableObject\") + \"@\" + getNextId();\n if (!name) name = \"ObservableObject@\" + getNextId();\n var adm = new ObservableObjectAdministration(target, name);\n addHiddenFinalProp(target, \"$mobx\", adm);\n return adm;\n}\nfunction defineObservablePropertyFromDescriptor(adm, propName, descriptor, defaultEnhancer) {\n if (adm.values[propName] && !isComputedValue(adm.values[propName])) {\n // already observable property\n invariant(\"value\" in descriptor, \"The property \" + propName + \" in \" + adm.name + \" is already observable, cannot redefine it as computed property\");\n adm.target[propName] = descriptor.value; // the property setter will make 'value' reactive if needed.\n return;\n }\n // not yet observable property\n if (\"value\" in descriptor) {\n // not a computed value\n if (isModifierDescriptor(descriptor.value)) {\n // x : ref(someValue)\n var modifierDescriptor = descriptor.value;\n defineObservableProperty(adm, propName, modifierDescriptor.initialValue, modifierDescriptor.enhancer);\n } else if (isAction(descriptor.value) && descriptor.value.autoBind === true) {\n defineBoundAction(adm.target, propName, descriptor.value.originalFn);\n } else if (isComputedValue(descriptor.value)) {\n // x: computed(someExpr)\n defineComputedPropertyFromComputedValue(adm, propName, descriptor.value);\n } else {\n // x: someValue\n defineObservableProperty(adm, propName, descriptor.value, defaultEnhancer);\n }\n } else {\n // get x() { return 3 } set x(v) { }\n defineComputedProperty(adm, propName, descriptor.get, descriptor.set, comparer.default, true);\n }\n}\nfunction defineObservableProperty(adm, propName, newValue, enhancer) {\n assertPropertyConfigurable(adm.target, propName);\n if (hasInterceptors(adm)) {\n var change = interceptChange(adm, {\n object: adm.target,\n name: propName,\n type: \"add\",\n newValue: newValue\n });\n if (!change) return;\n newValue = change.newValue;\n }\n var observable = adm.values[propName] = new ObservableValue(newValue, enhancer, adm.name + \".\" + propName, false);\n newValue = observable.value; // observableValue might have changed it\n Object.defineProperty(adm.target, propName, generateObservablePropConfig(propName));\n notifyPropertyAddition(adm, adm.target, propName, newValue);\n}\nfunction defineComputedProperty(adm, propName, getter, setter, equals, asInstanceProperty) {\n if (asInstanceProperty) assertPropertyConfigurable(adm.target, propName);\n adm.values[propName] = new ComputedValue(getter, adm.target, equals, adm.name + \".\" + propName, setter);\n if (asInstanceProperty) {\n Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName));\n }\n}\nfunction defineComputedPropertyFromComputedValue(adm, propName, computedValue) {\n var name = adm.name + \".\" + propName;\n computedValue.name = name;\n if (!computedValue.scope) computedValue.scope = adm.target;\n adm.values[propName] = computedValue;\n Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName));\n}\nvar observablePropertyConfigs = {};\nvar computedPropertyConfigs = {};\nfunction generateObservablePropConfig(propName) {\n return observablePropertyConfigs[propName] || (observablePropertyConfigs[propName] = {\n configurable: true,\n enumerable: true,\n get: function get() {\n return this.$mobx.values[propName].get();\n },\n set: function set(v) {\n setPropertyValue(this, propName, v);\n }\n });\n}\nfunction generateComputedPropConfig(propName) {\n return computedPropertyConfigs[propName] || (computedPropertyConfigs[propName] = {\n configurable: true,\n enumerable: false,\n get: function get() {\n return this.$mobx.values[propName].get();\n },\n set: function set(v) {\n return this.$mobx.values[propName].set(v);\n }\n });\n}\nfunction setPropertyValue(instance, name, newValue) {\n var adm = instance.$mobx;\n var observable = adm.values[name];\n // intercept\n if (hasInterceptors(adm)) {\n var change = interceptChange(adm, {\n type: \"update\",\n object: instance,\n name: name,\n newValue: newValue\n });\n if (!change) return;\n newValue = change.newValue;\n }\n newValue = observable.prepareNewValue(newValue);\n // notify spy & observers\n if (newValue !== UNCHANGED) {\n var notify = hasListeners(adm);\n var notifySpy = isSpyEnabled();\n var change = notify || notifySpy ? {\n type: \"update\",\n object: instance,\n oldValue: observable.value,\n name: name,\n newValue: newValue\n } : null;\n if (notifySpy) spyReportStart(change);\n observable.setNewValue(newValue);\n if (notify) notifyListeners(adm, change);\n if (notifySpy) spyReportEnd();\n }\n}\nfunction notifyPropertyAddition(adm, object, name, newValue) {\n var notify = hasListeners(adm);\n var notifySpy = isSpyEnabled();\n var change = notify || notifySpy ? {\n type: \"add\",\n object: object,\n name: name,\n newValue: newValue\n } : null;\n if (notifySpy) spyReportStart(change);\n if (notify) notifyListeners(adm, change);\n if (notifySpy) spyReportEnd();\n}\nvar isObservableObjectAdministration = createInstanceofPredicate(\"ObservableObjectAdministration\", ObservableObjectAdministration);\nfunction isObservableObject(thing) {\n if (isObject(thing)) {\n // Initializers run lazily when transpiling to babel, so make sure they are run...\n runLazyInitializers(thing);\n return isObservableObjectAdministration(thing.$mobx);\n }\n return false;\n}\n\n/**\n * Returns true if the provided value is reactive.\n * @param value object, function or array\n * @param property if property is specified, checks whether value.property is reactive.\n */\nfunction isObservable(value, property) {\n if (value === null || value === undefined) return false;\n if (property !== undefined) {\n if (isObservableArray(value) || isObservableMap(value)) throw new Error(getMessage(\"m019\"));else if (isObservableObject(value)) {\n var o = value.$mobx;\n return o.values && !!o.values[property];\n }\n return false;\n }\n // For first check, see #701\n return isObservableObject(value) || !!value.$mobx || isAtom(value) || isReaction(value) || isComputedValue(value);\n}\n\nfunction createDecoratorForEnhancer(enhancer) {\n invariant(!!enhancer, \":(\");\n return createClassPropertyDecorator(function (target, name, baseValue, _, baseDescriptor) {\n assertPropertyConfigurable(target, name);\n invariant(!baseDescriptor || !baseDescriptor.get, getMessage(\"m022\"));\n var adm = asObservableObject(target, undefined);\n defineObservableProperty(adm, name, baseValue, enhancer);\n }, function (name) {\n var observable = this.$mobx.values[name];\n if (observable === undefined // See #505\n ) return undefined;\n return observable.get();\n }, function (name, value) {\n setPropertyValue(this, name, value);\n }, true, false);\n}\n\nfunction extendObservable(target) {\n var properties = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n properties[_i - 1] = arguments[_i];\n }\n return extendObservableHelper(target, deepEnhancer, properties);\n}\nfunction extendShallowObservable(target) {\n var properties = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n properties[_i - 1] = arguments[_i];\n }\n return extendObservableHelper(target, referenceEnhancer, properties);\n}\nfunction extendObservableHelper(target, defaultEnhancer, properties) {\n invariant(arguments.length >= 2, getMessage(\"m014\"));\n invariant((typeof target === \"undefined\" ? \"undefined\" : _typeof(target)) === \"object\", getMessage(\"m015\"));\n invariant(!isObservableMap(target), getMessage(\"m016\"));\n properties.forEach(function (propSet) {\n invariant((typeof propSet === \"undefined\" ? \"undefined\" : _typeof(propSet)) === \"object\", getMessage(\"m017\"));\n invariant(!isObservable(propSet), getMessage(\"m018\"));\n });\n var adm = asObservableObject(target);\n var definedProps = {};\n // Note could be optimised if properties.length === 1\n for (var i = properties.length - 1; i >= 0; i--) {\n var propSet = properties[i];\n for (var key in propSet) {\n if (definedProps[key] !== true && hasOwnProperty(propSet, key)) {\n definedProps[key] = true;\n if (target === propSet && !isPropertyConfigurable(target, key)) continue; // see #111, skip non-configurable or non-writable props for `observable(object)`.\n var descriptor = Object.getOwnPropertyDescriptor(propSet, key);\n defineObservablePropertyFromDescriptor(adm, key, descriptor, defaultEnhancer);\n }\n }\n }\n return target;\n}\n\nvar deepDecorator = createDecoratorForEnhancer(deepEnhancer);\nvar shallowDecorator = createDecoratorForEnhancer(shallowEnhancer);\nvar refDecorator = createDecoratorForEnhancer(referenceEnhancer);\nvar deepStructDecorator = createDecoratorForEnhancer(deepStructEnhancer);\nvar refStructDecorator = createDecoratorForEnhancer(refStructEnhancer);\n/**\n * Turns an object, array or function into a reactive structure.\n * @param v the value which should become observable.\n */\nfunction createObservable(v) {\n if (v === void 0) {\n v = undefined;\n }\n // @observable someProp;\n if (typeof arguments[1] === \"string\") return deepDecorator.apply(null, arguments);\n invariant(arguments.length <= 1, getMessage(\"m021\"));\n invariant(!isModifierDescriptor(v), getMessage(\"m020\"));\n // it is an observable already, done\n if (isObservable(v)) return v;\n // something that can be converted and mutated?\n var res = deepEnhancer(v, undefined, undefined);\n // this value could be converted to a new observable data structure, return it\n if (res !== v) return res;\n // otherwise, just box it\n return observable.box(v);\n}\nvar observableFactories = {\n box: function box(value, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"box\");\n return new ObservableValue(value, deepEnhancer, name);\n },\n shallowBox: function shallowBox(value, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"shallowBox\");\n return new ObservableValue(value, referenceEnhancer, name);\n },\n array: function array(initialValues, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"array\");\n return new ObservableArray(initialValues, deepEnhancer, name);\n },\n shallowArray: function shallowArray(initialValues, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"shallowArray\");\n return new ObservableArray(initialValues, referenceEnhancer, name);\n },\n map: function map(initialValues, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"map\");\n return new ObservableMap(initialValues, deepEnhancer, name);\n },\n shallowMap: function shallowMap(initialValues, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"shallowMap\");\n return new ObservableMap(initialValues, referenceEnhancer, name);\n },\n object: function object(props, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"object\");\n var res = {};\n // convert to observable object\n asObservableObject(res, name);\n // add properties\n extendObservable(res, props);\n return res;\n },\n shallowObject: function shallowObject(props, name) {\n if (arguments.length > 2) incorrectlyUsedAsDecorator(\"shallowObject\");\n var res = {};\n asObservableObject(res, name);\n extendShallowObservable(res, props);\n return res;\n },\n ref: function ref() {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(referenceEnhancer, arguments[0]);\n } else {\n return refDecorator.apply(null, arguments);\n }\n },\n shallow: function shallow() {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(shallowEnhancer, arguments[0]);\n } else {\n return shallowDecorator.apply(null, arguments);\n }\n },\n deep: function deep() {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(deepEnhancer, arguments[0]);\n } else {\n return deepDecorator.apply(null, arguments);\n }\n },\n struct: function struct() {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(deepStructEnhancer, arguments[0]);\n } else {\n return deepStructDecorator.apply(null, arguments);\n }\n }\n};\nvar observable = createObservable;\n// weird trick to keep our typings nicely with our funcs, and still extend the observable function\nObject.keys(observableFactories).forEach(function (name) {\n return observable[name] = observableFactories[name];\n});\nobservable.deep.struct = observable.struct;\nobservable.ref.struct = function () {\n if (arguments.length < 2) {\n return createModifierDescriptor(refStructEnhancer, arguments[0]);\n } else {\n return refStructDecorator.apply(null, arguments);\n }\n};\nfunction incorrectlyUsedAsDecorator(methodName) {\n fail(\"Expected one or two arguments to observable.\" + methodName + \". Did you accidentally try to use observable.\" + methodName + \" as decorator?\");\n}\n\nfunction isModifierDescriptor(thing) {\n return (typeof thing === \"undefined\" ? \"undefined\" : _typeof(thing)) === \"object\" && thing !== null && thing.isMobxModifierDescriptor === true;\n}\nfunction createModifierDescriptor(enhancer, initialValue) {\n invariant(!isModifierDescriptor(initialValue), \"Modifiers cannot be nested\");\n return {\n isMobxModifierDescriptor: true,\n initialValue: initialValue,\n enhancer: enhancer\n };\n}\nfunction deepEnhancer(v, _, name) {\n if (isModifierDescriptor(v)) fail(\"You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it\");\n // it is an observable already, done\n if (isObservable(v)) return v;\n // something that can be converted and mutated?\n if (Array.isArray(v)) return observable.array(v, name);\n if (isPlainObject(v)) return observable.object(v, name);\n if (isES6Map(v)) return observable.map(v, name);\n return v;\n}\nfunction shallowEnhancer(v, _, name) {\n if (isModifierDescriptor(v)) fail(\"You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it\");\n if (v === undefined || v === null) return v;\n if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v)) return v;\n if (Array.isArray(v)) return observable.shallowArray(v, name);\n if (isPlainObject(v)) return observable.shallowObject(v, name);\n if (isES6Map(v)) return observable.shallowMap(v, name);\n return fail(\"The shallow modifier / decorator can only used in combination with arrays, objects and maps\");\n}\nfunction referenceEnhancer(newValue) {\n // never turn into an observable\n return newValue;\n}\nfunction deepStructEnhancer(v, oldValue, name) {\n // don't confuse structurally compare enhancer with ref enhancer! The latter is probably\n // more suited for immutable objects\n if (deepEqual(v, oldValue)) return oldValue;\n // it is an observable already, done\n if (isObservable(v)) return v;\n // something that can be converted and mutated?\n if (Array.isArray(v)) return new ObservableArray(v, deepStructEnhancer, name);\n if (isES6Map(v)) return new ObservableMap(v, deepStructEnhancer, name);\n if (isPlainObject(v)) {\n var res = {};\n asObservableObject(res, name);\n extendObservableHelper(res, deepStructEnhancer, [v]);\n return res;\n }\n return v;\n}\nfunction refStructEnhancer(v, oldValue, name) {\n if (deepEqual(v, oldValue)) return oldValue;\n return v;\n}\n\n/**\n * During a transaction no views are updated until the end of the transaction.\n * The transaction will be run synchronously nonetheless.\n *\n * @param action a function that updates some reactive state\n * @returns any value that was returned by the 'action' parameter.\n */\nfunction transaction(action, thisArg) {\n if (thisArg === void 0) {\n thisArg = undefined;\n }\n startBatch();\n try {\n return action.apply(thisArg);\n } finally {\n endBatch();\n }\n}\n\nvar ObservableMapMarker = {};\nvar ObservableMap = /** @class */function () {\n function ObservableMap(initialData, enhancer, name) {\n if (enhancer === void 0) {\n enhancer = deepEnhancer;\n }\n if (name === void 0) {\n name = \"ObservableMap@\" + getNextId();\n }\n this.enhancer = enhancer;\n this.name = name;\n this.$mobx = ObservableMapMarker;\n this._data = Object.create(null);\n this._hasMap = Object.create(null); // hasMap, not hashMap >-).\n this._keys = new ObservableArray(undefined, referenceEnhancer, this.name + \".keys()\", true);\n this.interceptors = null;\n this.changeListeners = null;\n this.dehancer = undefined;\n this.merge(initialData);\n }\n ObservableMap.prototype._has = function (key) {\n return typeof this._data[key] !== \"undefined\";\n };\n ObservableMap.prototype.has = function (key) {\n if (!this.isValidKey(key)) return false;\n key = \"\" + key;\n if (this._hasMap[key]) return this._hasMap[key].get();\n return this._updateHasMapEntry(key, false).get();\n };\n ObservableMap.prototype.set = function (key, value) {\n this.assertValidKey(key);\n key = \"\" + key;\n var hasKey = this._has(key);\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n type: hasKey ? \"update\" : \"add\",\n object: this,\n newValue: value,\n name: key\n });\n if (!change) return this;\n value = change.newValue;\n }\n if (hasKey) {\n this._updateValue(key, value);\n } else {\n this._addValue(key, value);\n }\n return this;\n };\n ObservableMap.prototype.delete = function (key) {\n var _this = this;\n this.assertValidKey(key);\n key = \"\" + key;\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n type: \"delete\",\n object: this,\n name: key\n });\n if (!change) return false;\n }\n if (this._has(key)) {\n var notifySpy = isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy ? {\n type: \"delete\",\n object: this,\n oldValue: this._data[key].value,\n name: key\n } : null;\n if (notifySpy) spyReportStart(change);\n transaction(function () {\n _this._keys.remove(key);\n _this._updateHasMapEntry(key, false);\n var observable$$1 = _this._data[key];\n observable$$1.setNewValue(undefined);\n _this._data[key] = undefined;\n });\n if (notify) notifyListeners(this, change);\n if (notifySpy) spyReportEnd();\n return true;\n }\n return false;\n };\n ObservableMap.prototype._updateHasMapEntry = function (key, value) {\n // optimization; don't fill the hasMap if we are not observing, or remove entry if there are no observers anymore\n var entry = this._hasMap[key];\n if (entry) {\n entry.setNewValue(value);\n } else {\n entry = this._hasMap[key] = new ObservableValue(value, referenceEnhancer, this.name + \".\" + key + \"?\", false);\n }\n return entry;\n };\n ObservableMap.prototype._updateValue = function (name, newValue) {\n var observable$$1 = this._data[name];\n newValue = observable$$1.prepareNewValue(newValue);\n if (newValue !== UNCHANGED) {\n var notifySpy = isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy ? {\n type: \"update\",\n object: this,\n oldValue: observable$$1.value,\n name: name,\n newValue: newValue\n } : null;\n if (notifySpy) spyReportStart(change);\n observable$$1.setNewValue(newValue);\n if (notify) notifyListeners(this, change);\n if (notifySpy) spyReportEnd();\n }\n };\n ObservableMap.prototype._addValue = function (name, newValue) {\n var _this = this;\n transaction(function () {\n var observable$$1 = _this._data[name] = new ObservableValue(newValue, _this.enhancer, _this.name + \".\" + name, false);\n newValue = observable$$1.value; // value might have been changed\n _this._updateHasMapEntry(name, true);\n _this._keys.push(name);\n });\n var notifySpy = isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy ? {\n type: \"add\",\n object: this,\n name: name,\n newValue: newValue\n } : null;\n if (notifySpy) spyReportStart(change);\n if (notify) notifyListeners(this, change);\n if (notifySpy) spyReportEnd();\n };\n ObservableMap.prototype.get = function (key) {\n key = \"\" + key;\n if (this.has(key)) return this.dehanceValue(this._data[key].get());\n return this.dehanceValue(undefined);\n };\n ObservableMap.prototype.dehanceValue = function (value) {\n if (this.dehancer !== undefined) {\n return this.dehancer(value);\n }\n return value;\n };\n ObservableMap.prototype.keys = function () {\n return arrayAsIterator(this._keys.slice());\n };\n ObservableMap.prototype.values = function () {\n return arrayAsIterator(this._keys.map(this.get, this));\n };\n ObservableMap.prototype.entries = function () {\n var _this = this;\n return arrayAsIterator(this._keys.map(function (key) {\n return [key, _this.get(key)];\n }));\n };\n ObservableMap.prototype.forEach = function (callback, thisArg) {\n var _this = this;\n this.keys().forEach(function (key) {\n return callback.call(thisArg, _this.get(key), key, _this);\n });\n };\n /** Merge another object into this object, returns this. */\n ObservableMap.prototype.merge = function (other) {\n var _this = this;\n if (isObservableMap(other)) {\n other = other.toJS();\n }\n transaction(function () {\n if (isPlainObject(other)) Object.keys(other).forEach(function (key) {\n return _this.set(key, other[key]);\n });else if (Array.isArray(other)) other.forEach(function (_a) {\n var key = _a[0],\n value = _a[1];\n return _this.set(key, value);\n });else if (isES6Map(other)) other.forEach(function (value, key) {\n return _this.set(key, value);\n });else if (other !== null && other !== undefined) fail(\"Cannot initialize map from \" + other);\n });\n return this;\n };\n ObservableMap.prototype.clear = function () {\n var _this = this;\n transaction(function () {\n untracked(function () {\n _this.keys().forEach(_this.delete, _this);\n });\n });\n };\n ObservableMap.prototype.replace = function (values) {\n var _this = this;\n transaction(function () {\n // grab all the keys that are present in the new map but not present in the current map\n // and delete them from the map, then merge the new map\n // this will cause reactions only on changed values\n var newKeys = getMapLikeKeys(values);\n var oldKeys = _this.keys();\n var missingKeys = oldKeys.filter(function (k) {\n return newKeys.indexOf(k) === -1;\n });\n missingKeys.forEach(function (k) {\n return _this.delete(k);\n });\n _this.merge(values);\n });\n return this;\n };\n Object.defineProperty(ObservableMap.prototype, \"size\", {\n get: function get() {\n return this._keys.length;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Returns a shallow non observable object clone of this map.\n * Note that the values might still be observable. For a deep clone use mobx.toJS.\n */\n ObservableMap.prototype.toJS = function () {\n var _this = this;\n var res = {};\n this.keys().forEach(function (key) {\n return res[key] = _this.get(key);\n });\n return res;\n };\n ObservableMap.prototype.toJSON = function () {\n // Used by JSON.stringify\n return this.toJS();\n };\n ObservableMap.prototype.isValidKey = function (key) {\n if (key === null || key === undefined) return false;\n if (typeof key === \"string\" || typeof key === \"number\" || typeof key === \"boolean\") return true;\n return false;\n };\n ObservableMap.prototype.assertValidKey = function (key) {\n if (!this.isValidKey(key)) throw new Error(\"[mobx.map] Invalid key: '\" + key + \"', only strings, numbers and booleans are accepted as key in observable maps.\");\n };\n ObservableMap.prototype.toString = function () {\n var _this = this;\n return this.name + \"[{ \" + this.keys().map(function (key) {\n return key + \": \" + (\"\" + _this.get(key));\n }).join(\", \") + \" }]\";\n };\n /**\n * Observes this object. Triggers for the events 'add', 'update' and 'delete'.\n * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe\n * for callback details\n */\n ObservableMap.prototype.observe = function (listener, fireImmediately) {\n invariant(fireImmediately !== true, getMessage(\"m033\"));\n return registerListener(this, listener);\n };\n ObservableMap.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n return ObservableMap;\n}();\ndeclareIterator(ObservableMap.prototype, function () {\n return this.entries();\n});\nfunction map(initialValues) {\n deprecated(\"`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead\");\n return observable.map(initialValues);\n}\n/* 'var' fixes small-build issue */\nvar isObservableMap = createInstanceofPredicate(\"ObservableMap\", ObservableMap);\n\nvar EMPTY_ARRAY = [];\nObject.freeze(EMPTY_ARRAY);\nfunction getGlobal() {\n return typeof window !== \"undefined\" ? window : global;\n}\nfunction getNextId() {\n return ++globalState.mobxGuid;\n}\nfunction fail(message, thing) {\n invariant(false, message, thing);\n throw \"X\"; // unreachable\n}\nfunction invariant(check, message, thing) {\n if (!check) throw new Error(\"[mobx] Invariant failed: \" + message + (thing ? \" in '\" + thing + \"'\" : \"\"));\n}\n/**\n * Prints a deprecation message, but only one time.\n * Returns false if the deprecated message was already printed before\n */\nvar deprecatedMessages = [];\nfunction deprecated(msg) {\n if (deprecatedMessages.indexOf(msg) !== -1) return false;\n deprecatedMessages.push(msg);\n console.error(\"[mobx] Deprecated: \" + msg);\n return true;\n}\n/**\n * Makes sure that the provided function is invoked at most once.\n */\nfunction once(func) {\n var invoked = false;\n return function () {\n if (invoked) return;\n invoked = true;\n return func.apply(this, arguments);\n };\n}\nvar noop = function noop() {};\nfunction unique(list) {\n var res = [];\n list.forEach(function (item) {\n if (res.indexOf(item) === -1) res.push(item);\n });\n return res;\n}\nfunction joinStrings(things, limit, separator) {\n if (limit === void 0) {\n limit = 100;\n }\n if (separator === void 0) {\n separator = \" - \";\n }\n if (!things) return \"\";\n var sliced = things.slice(0, limit);\n return \"\" + sliced.join(separator) + (things.length > limit ? \" (... and \" + (things.length - limit) + \"more)\" : \"\");\n}\nfunction isObject(value) {\n return value !== null && (typeof value === \"undefined\" ? \"undefined\" : _typeof(value)) === \"object\";\n}\nfunction isPlainObject(value) {\n if (value === null || (typeof value === \"undefined\" ? \"undefined\" : _typeof(value)) !== \"object\") return false;\n var proto = Object.getPrototypeOf(value);\n return proto === Object.prototype || proto === null;\n}\nfunction objectAssign() {\n var res = arguments[0];\n for (var i = 1, l = arguments.length; i < l; i++) {\n var source = arguments[i];\n for (var key in source) {\n if (hasOwnProperty(source, key)) {\n res[key] = source[key];\n }\n }\n }\n return res;\n}\nvar prototypeHasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwnProperty(object, propName) {\n return prototypeHasOwnProperty.call(object, propName);\n}\nfunction makeNonEnumerable(object, propNames) {\n for (var i = 0; i < propNames.length; i++) {\n addHiddenProp(object, propNames[i], object[propNames[i]]);\n }\n}\nfunction addHiddenProp(object, propName, value) {\n Object.defineProperty(object, propName, {\n enumerable: false,\n writable: true,\n configurable: true,\n value: value\n });\n}\nfunction addHiddenFinalProp(object, propName, value) {\n Object.defineProperty(object, propName, {\n enumerable: false,\n writable: false,\n configurable: true,\n value: value\n });\n}\nfunction isPropertyConfigurable(object, prop) {\n var descriptor = Object.getOwnPropertyDescriptor(object, prop);\n return !descriptor || descriptor.configurable !== false && descriptor.writable !== false;\n}\nfunction assertPropertyConfigurable(object, prop) {\n invariant(isPropertyConfigurable(object, prop), \"Cannot make property '\" + prop + \"' observable, it is not configurable and writable in the target object\");\n}\nfunction createInstanceofPredicate(name, clazz) {\n var propName = \"isMobX\" + name;\n clazz.prototype[propName] = true;\n return function (x) {\n return isObject(x) && x[propName] === true;\n };\n}\nfunction areBothNaN(a, b) {\n return typeof a === \"number\" && typeof b === \"number\" && isNaN(a) && isNaN(b);\n}\n/**\n * Returns whether the argument is an array, disregarding observability.\n */\nfunction isArrayLike(x) {\n return Array.isArray(x) || isObservableArray(x);\n}\nfunction isES6Map(thing) {\n if (getGlobal().Map !== undefined && thing instanceof getGlobal().Map) return true;\n return false;\n}\nfunction getMapLikeKeys(map$$1) {\n if (isPlainObject(map$$1)) return Object.keys(map$$1);\n if (Array.isArray(map$$1)) return map$$1.map(function (_a) {\n var key = _a[0];\n return key;\n });\n if (isES6Map(map$$1)) return Array.from(map$$1.keys());\n if (isObservableMap(map$$1)) return map$$1.keys();\n return fail(\"Cannot get keys from \" + map$$1);\n}\nfunction iteratorToArray(it) {\n var res = [];\n while (true) {\n var r = it.next();\n if (r.done) break;\n res.push(r.value);\n }\n return res;\n}\nfunction primitiveSymbol() {\n return typeof Symbol === \"function\" && Symbol.toPrimitive || \"@@toPrimitive\";\n}\nfunction toPrimitive(value) {\n return value === null ? null : (typeof value === \"undefined\" ? \"undefined\" : _typeof(value)) === \"object\" ? \"\" + value : value;\n}\n\n/**\n * These values will persist if global state is reset\n */\nvar persistentKeys = [\"mobxGuid\", \"resetId\", \"spyListeners\", \"strictMode\", \"runId\"];\nvar MobXGlobals = /** @class */function () {\n function MobXGlobals() {\n /**\n * MobXGlobals version.\n * MobX compatiblity with other versions loaded in memory as long as this version matches.\n * It indicates that the global state still stores similar information\n */\n this.version = 5;\n /**\n * Currently running derivation\n */\n this.trackingDerivation = null;\n /**\n * Are we running a computation currently? (not a reaction)\n */\n this.computationDepth = 0;\n /**\n * Each time a derivation is tracked, it is assigned a unique run-id\n */\n this.runId = 0;\n /**\n * 'guid' for general purpose. Will be persisted amongst resets.\n */\n this.mobxGuid = 0;\n /**\n * Are we in a batch block? (and how many of them)\n */\n this.inBatch = 0;\n /**\n * Observables that don't have observers anymore, and are about to be\n * suspended, unless somebody else accesses it in the same batch\n *\n * @type {IObservable[]}\n */\n this.pendingUnobservations = [];\n /**\n * List of scheduled, not yet executed, reactions.\n */\n this.pendingReactions = [];\n /**\n * Are we currently processing reactions?\n */\n this.isRunningReactions = false;\n /**\n * Is it allowed to change observables at this point?\n * In general, MobX doesn't allow that when running computations and React.render.\n * To ensure that those functions stay pure.\n */\n this.allowStateChanges = true;\n /**\n * If strict mode is enabled, state changes are by default not allowed\n */\n this.strictMode = false;\n /**\n * Used by createTransformer to detect that the global state has been reset.\n */\n this.resetId = 0;\n /**\n * Spy callbacks\n */\n this.spyListeners = [];\n /**\n * Globally attached error handlers that react specifically to errors in reactions\n */\n this.globalReactionErrorHandlers = [];\n }\n return MobXGlobals;\n}();\nvar globalState = new MobXGlobals();\nvar shareGlobalStateCalled = false;\nvar runInIsolationCalled = false;\nvar warnedAboutMultipleInstances = false;\n{\n var global_1 = getGlobal();\n if (!global_1.__mobxInstanceCount) {\n global_1.__mobxInstanceCount = 1;\n } else {\n global_1.__mobxInstanceCount++;\n setTimeout(function () {\n if (!shareGlobalStateCalled && !runInIsolationCalled && !warnedAboutMultipleInstances) {\n warnedAboutMultipleInstances = true;\n console.warn(\"[mobx] Warning: there are multiple mobx instances active. This might lead to unexpected results. See https://github.com/mobxjs/mobx/issues/1082 for details.\");\n }\n }, 1);\n }\n}\nfunction isolateGlobalState() {\n runInIsolationCalled = true;\n getGlobal().__mobxInstanceCount--;\n}\nfunction shareGlobalState() {\n // TODO: remove in 4.0; just use peer dependencies instead.\n deprecated(\"Using `shareGlobalState` is not recommended, use peer dependencies instead. See https://github.com/mobxjs/mobx/issues/1082 for details.\");\n shareGlobalStateCalled = true;\n var global = getGlobal();\n var ownState = globalState;\n /**\n * Backward compatibility check\n */\n if (global.__mobservableTrackingStack || global.__mobservableViewStack) throw new Error(\"[mobx] An incompatible version of mobservable is already loaded.\");\n if (global.__mobxGlobal && global.__mobxGlobal.version !== ownState.version) throw new Error(\"[mobx] An incompatible version of mobx is already loaded.\");\n if (global.__mobxGlobal) globalState = global.__mobxGlobal;else global.__mobxGlobal = ownState;\n}\nfunction getGlobalState() {\n return globalState;\n}\n\n/**\n * For testing purposes only; this will break the internal state of existing observables,\n * but can be used to get back at a stable state after throwing errors\n */\nfunction resetGlobalState() {\n globalState.resetId++;\n var defaultGlobals = new MobXGlobals();\n for (var key in defaultGlobals) {\n if (persistentKeys.indexOf(key) === -1) globalState[key] = defaultGlobals[key];\n }globalState.allowStateChanges = !globalState.strictMode;\n}\n\nfunction getAtom(thing, property) {\n if ((typeof thing === \"undefined\" ? \"undefined\" : _typeof(thing)) === \"object\" && thing !== null) {\n if (isObservableArray(thing)) {\n invariant(property === undefined, getMessage(\"m036\"));\n return thing.$mobx.atom;\n }\n if (isObservableMap(thing)) {\n var anyThing = thing;\n if (property === undefined) return getAtom(anyThing._keys);\n var observable = anyThing._data[property] || anyThing._hasMap[property];\n invariant(!!observable, \"the entry '\" + property + \"' does not exist in the observable map '\" + getDebugName(thing) + \"'\");\n return observable;\n }\n // Initializers run lazily when transpiling to babel, so make sure they are run...\n runLazyInitializers(thing);\n if (property && !thing.$mobx) thing[property]; // See #1072 // TODO: remove in 4.0\n if (isObservableObject(thing)) {\n if (!property) return fail(\"please specify a property\");\n var observable = thing.$mobx.values[property];\n invariant(!!observable, \"no observable property '\" + property + \"' found on the observable object '\" + getDebugName(thing) + \"'\");\n return observable;\n }\n if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {\n return thing;\n }\n } else if (typeof thing === \"function\") {\n if (isReaction(thing.$mobx)) {\n // disposer function\n return thing.$mobx;\n }\n }\n return fail(\"Cannot obtain atom from \" + thing);\n}\nfunction getAdministration(thing, property) {\n invariant(thing, \"Expecting some object\");\n if (property !== undefined) return getAdministration(getAtom(thing, property));\n if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) return thing;\n if (isObservableMap(thing)) return thing;\n // Initializers run lazily when transpiling to babel, so make sure they are run...\n runLazyInitializers(thing);\n if (thing.$mobx) return thing.$mobx;\n invariant(false, \"Cannot obtain administration from \" + thing);\n}\nfunction getDebugName(thing, property) {\n var named;\n if (property !== undefined) named = getAtom(thing, property);else if (isObservableObject(thing) || isObservableMap(thing)) named = getAdministration(thing);else named = getAtom(thing); // valid for arrays as well\n return named.name;\n}\n\nfunction getDependencyTree(thing, property) {\n return nodeToDependencyTree(getAtom(thing, property));\n}\nfunction nodeToDependencyTree(node) {\n var result = {\n name: node.name\n };\n if (node.observing && node.observing.length > 0) result.dependencies = unique(node.observing).map(nodeToDependencyTree);\n return result;\n}\nfunction getObserverTree(thing, property) {\n return nodeToObserverTree(getAtom(thing, property));\n}\nfunction nodeToObserverTree(node) {\n var result = {\n name: node.name\n };\n if (hasObservers(node)) result.observers = getObservers(node).map(nodeToObserverTree);\n return result;\n}\n\nfunction hasObservers(observable) {\n return observable.observers && observable.observers.length > 0;\n}\nfunction getObservers(observable) {\n return observable.observers;\n}\nfunction addObserver(observable, node) {\n // invariant(node.dependenciesState !== -1, \"INTERNAL ERROR, can add only dependenciesState !== -1\");\n // invariant(observable._observers.indexOf(node) === -1, \"INTERNAL ERROR add already added node\");\n // invariantObservers(observable);\n var l = observable.observers.length;\n if (l) {\n // because object assignment is relatively expensive, let's not store data about index 0.\n observable.observersIndexes[node.__mapid] = l;\n }\n observable.observers[l] = node;\n if (observable.lowestObserverState > node.dependenciesState) observable.lowestObserverState = node.dependenciesState;\n // invariantObservers(observable);\n // invariant(observable._observers.indexOf(node) !== -1, \"INTERNAL ERROR didn't add node\");\n}\nfunction removeObserver(observable, node) {\n // invariant(globalState.inBatch > 0, \"INTERNAL ERROR, remove should be called only inside batch\");\n // invariant(observable._observers.indexOf(node) !== -1, \"INTERNAL ERROR remove already removed node\");\n // invariantObservers(observable);\n if (observable.observers.length === 1) {\n // deleting last observer\n observable.observers.length = 0;\n queueForUnobservation(observable);\n } else {\n // deleting from _observersIndexes is straight forward, to delete from _observers, let's swap `node` with last element\n var list = observable.observers;\n var map = observable.observersIndexes;\n var filler = list.pop(); // get last element, which should fill the place of `node`, so the array doesn't have holes\n if (filler !== node) {\n // otherwise node was the last element, which already got removed from array\n var index = map[node.__mapid] || 0; // getting index of `node`. this is the only place we actually use map.\n if (index) {\n // map store all indexes but 0, see comment in `addObserver`\n map[filler.__mapid] = index;\n } else {\n delete map[filler.__mapid];\n }\n list[index] = filler;\n }\n delete map[node.__mapid];\n }\n // invariantObservers(observable);\n // invariant(observable._observers.indexOf(node) === -1, \"INTERNAL ERROR remove already removed node2\");\n}\nfunction queueForUnobservation(observable) {\n if (!observable.isPendingUnobservation) {\n // invariant(globalState.inBatch > 0, \"INTERNAL ERROR, remove should be called only inside batch\");\n // invariant(observable._observers.length === 0, \"INTERNAL ERROR, should only queue for unobservation unobserved observables\");\n observable.isPendingUnobservation = true;\n globalState.pendingUnobservations.push(observable);\n }\n}\n/**\n * Batch starts a transaction, at least for purposes of memoizing ComputedValues when nothing else does.\n * During a batch `onBecomeUnobserved` will be called at most once per observable.\n * Avoids unnecessary recalculations.\n */\nfunction startBatch() {\n globalState.inBatch++;\n}\nfunction endBatch() {\n if (--globalState.inBatch === 0) {\n runReactions();\n // the batch is actually about to finish, all unobserving should happen here.\n var list = globalState.pendingUnobservations;\n for (var i = 0; i < list.length; i++) {\n var observable = list[i];\n observable.isPendingUnobservation = false;\n if (observable.observers.length === 0) {\n observable.onBecomeUnobserved();\n // NOTE: onBecomeUnobserved might push to `pendingUnobservations`\n }\n }\n globalState.pendingUnobservations = [];\n }\n}\nfunction reportObserved(observable) {\n var derivation = globalState.trackingDerivation;\n if (derivation !== null) {\n /**\n * Simple optimization, give each derivation run an unique id (runId)\n * Check if last time this observable was accessed the same runId is used\n * if this is the case, the relation is already known\n */\n if (derivation.runId !== observable.lastAccessedBy) {\n observable.lastAccessedBy = derivation.runId;\n derivation.newObserving[derivation.unboundDepsCount++] = observable;\n }\n } else if (observable.observers.length === 0) {\n queueForUnobservation(observable);\n }\n}\n/**\n * NOTE: current propagation mechanism will in case of self reruning autoruns behave unexpectedly\n * It will propagate changes to observers from previous run\n * It's hard or maybe impossible (with reasonable perf) to get it right with current approach\n * Hopefully self reruning autoruns aren't a feature people should depend on\n * Also most basic use cases should be ok\n */\n// Called by Atom when its value changes\nfunction propagateChanged(observable) {\n // invariantLOS(observable, \"changed start\");\n if (observable.lowestObserverState === IDerivationState.STALE) return;\n observable.lowestObserverState = IDerivationState.STALE;\n var observers = observable.observers;\n var i = observers.length;\n while (i--) {\n var d = observers[i];\n if (d.dependenciesState === IDerivationState.UP_TO_DATE) {\n if (d.isTracing !== TraceMode.NONE) {\n logTraceInfo(d, observable);\n }\n d.onBecomeStale();\n }\n d.dependenciesState = IDerivationState.STALE;\n }\n // invariantLOS(observable, \"changed end\");\n}\n// Called by ComputedValue when it recalculate and its value changed\nfunction propagateChangeConfirmed(observable) {\n // invariantLOS(observable, \"confirmed start\");\n if (observable.lowestObserverState === IDerivationState.STALE) return;\n observable.lowestObserverState = IDerivationState.STALE;\n var observers = observable.observers;\n var i = observers.length;\n while (i--) {\n var d = observers[i];\n if (d.dependenciesState === IDerivationState.POSSIBLY_STALE) d.dependenciesState = IDerivationState.STALE;else if (d.dependenciesState === IDerivationState.UP_TO_DATE // this happens during computing of `d`, just keep lowestObserverState up to date.\n ) observable.lowestObserverState = IDerivationState.UP_TO_DATE;\n }\n // invariantLOS(observable, \"confirmed end\");\n}\n// Used by computed when its dependency changed, but we don't wan't to immediately recompute.\nfunction propagateMaybeChanged(observable) {\n // invariantLOS(observable, \"maybe start\");\n if (observable.lowestObserverState !== IDerivationState.UP_TO_DATE) return;\n observable.lowestObserverState = IDerivationState.POSSIBLY_STALE;\n var observers = observable.observers;\n var i = observers.length;\n while (i--) {\n var d = observers[i];\n if (d.dependenciesState === IDerivationState.UP_TO_DATE) {\n d.dependenciesState = IDerivationState.POSSIBLY_STALE;\n if (d.isTracing !== TraceMode.NONE) {\n logTraceInfo(d, observable);\n }\n d.onBecomeStale();\n }\n }\n // invariantLOS(observable, \"maybe end\");\n}\nfunction logTraceInfo(derivation, observable) {\n console.log(\"[mobx.trace] '\" + derivation.name + \"' is invalidated due to a change in: '\" + observable.name + \"'\");\n if (derivation.isTracing === TraceMode.BREAK) {\n var lines = [];\n printDepTree(getDependencyTree(derivation), lines, 1);\n // prettier-ignore\n new Function(\"debugger;\\n/*\\nTracing '\" + derivation.name + \"'\\n\\nYou are entering this break point because derivation '\" + derivation.name + \"' is being traced and '\" + observable.name + \"' is now forcing it to update.\\nJust follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update\\nThe stackframe you are looking for is at least ~6-8 stack-frames up.\\n\\n\" + (derivation instanceof ComputedValue ? derivation.derivation.toString() : \"\") + \"\\n\\nThe dependencies for this derivation are:\\n\\n\" + lines.join(\"\\n\") + \"\\n*/\\n \")();\n }\n}\nfunction printDepTree(tree, lines, depth) {\n if (lines.length >= 1000) {\n lines.push(\"(and many more)\");\n return;\n }\n lines.push(\"\" + new Array(depth).join(\"\\t\") + tree.name); // MWE: not the fastest, but the easiest way :)\n if (tree.dependencies) tree.dependencies.forEach(function (child) {\n return printDepTree(child, lines, depth + 1);\n });\n}\n\nvar IDerivationState;\n(function (IDerivationState) {\n // before being run or (outside batch and not being observed)\n // at this point derivation is not holding any data about dependency tree\n IDerivationState[IDerivationState[\"NOT_TRACKING\"] = -1] = \"NOT_TRACKING\";\n // no shallow dependency changed since last computation\n // won't recalculate derivation\n // this is what makes mobx fast\n IDerivationState[IDerivationState[\"UP_TO_DATE\"] = 0] = \"UP_TO_DATE\";\n // some deep dependency changed, but don't know if shallow dependency changed\n // will require to check first if UP_TO_DATE or POSSIBLY_STALE\n // currently only ComputedValue will propagate POSSIBLY_STALE\n //\n // having this state is second big optimization:\n // don't have to recompute on every dependency change, but only when it's needed\n IDerivationState[IDerivationState[\"POSSIBLY_STALE\"] = 1] = \"POSSIBLY_STALE\";\n // A shallow dependency has changed since last computation and the derivation\n // will need to recompute when it's needed next.\n IDerivationState[IDerivationState[\"STALE\"] = 2] = \"STALE\";\n})(IDerivationState || (exports.IDerivationState = IDerivationState = {}));\nvar TraceMode;\n(function (TraceMode) {\n TraceMode[TraceMode[\"NONE\"] = 0] = \"NONE\";\n TraceMode[TraceMode[\"LOG\"] = 1] = \"LOG\";\n TraceMode[TraceMode[\"BREAK\"] = 2] = \"BREAK\";\n})(TraceMode || (TraceMode = {}));\nvar CaughtException = /** @class */function () {\n function CaughtException(cause) {\n this.cause = cause;\n // Empty\n }\n return CaughtException;\n}();\nfunction isCaughtException(e) {\n return e instanceof CaughtException;\n}\n/**\n * Finds out whether any dependency of the derivation has actually changed.\n * If dependenciesState is 1 then it will recalculate dependencies,\n * if any dependency changed it will propagate it by changing dependenciesState to 2.\n *\n * By iterating over the dependencies in the same order that they were reported and\n * stopping on the first change, all the recalculations are only called for ComputedValues\n * that will be tracked by derivation. That is because we assume that if the first x\n * dependencies of the derivation doesn't change then the derivation should run the same way\n * up until accessing x-th dependency.\n */\nfunction shouldCompute(derivation) {\n switch (derivation.dependenciesState) {\n case IDerivationState.UP_TO_DATE:\n return false;\n case IDerivationState.NOT_TRACKING:\n case IDerivationState.STALE:\n return true;\n case IDerivationState.POSSIBLY_STALE:\n {\n var prevUntracked = untrackedStart(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.\n var obs = derivation.observing,\n l = obs.length;\n for (var i = 0; i < l; i++) {\n var obj = obs[i];\n if (isComputedValue(obj)) {\n try {\n obj.get();\n } catch (e) {\n // we are not interested in the value *or* exception at this moment, but if there is one, notify all\n untrackedEnd(prevUntracked);\n return true;\n }\n // if ComputedValue `obj` actually changed it will be computed and propagated to its observers.\n // and `derivation` is an observer of `obj`\n if (derivation.dependenciesState === IDerivationState.STALE) {\n untrackedEnd(prevUntracked);\n return true;\n }\n }\n }\n changeDependenciesStateTo0(derivation);\n untrackedEnd(prevUntracked);\n return false;\n }\n }\n}\nfunction isComputingDerivation() {\n return globalState.trackingDerivation !== null; // filter out actions inside computations\n}\nfunction checkIfStateModificationsAreAllowed(atom) {\n var hasObservers$$1 = atom.observers.length > 0;\n // Should never be possible to change an observed observable from inside computed, see #798\n if (globalState.computationDepth > 0 && hasObservers$$1) fail(getMessage(\"m031\") + atom.name);\n // Should not be possible to change observed state outside strict mode, except during initialization, see #563\n if (!globalState.allowStateChanges && hasObservers$$1) fail(getMessage(globalState.strictMode ? \"m030a\" : \"m030b\") + atom.name);\n}\n/**\n * Executes the provided function `f` and tracks which observables are being accessed.\n * The tracking information is stored on the `derivation` object and the derivation is registered\n * as observer of any of the accessed observables.\n */\nfunction trackDerivedFunction(derivation, f, context) {\n // pre allocate array allocation + room for variation in deps\n // array will be trimmed by bindDependencies\n changeDependenciesStateTo0(derivation);\n derivation.newObserving = new Array(derivation.observing.length + 100);\n derivation.unboundDepsCount = 0;\n derivation.runId = ++globalState.runId;\n var prevTracking = globalState.trackingDerivation;\n globalState.trackingDerivation = derivation;\n var result;\n try {\n result = f.call(context);\n } catch (e) {\n result = new CaughtException(e);\n }\n globalState.trackingDerivation = prevTracking;\n bindDependencies(derivation);\n return result;\n}\n/**\n * diffs newObserving with observing.\n * update observing to be newObserving with unique observables\n * notify observers that become observed/unobserved\n */\nfunction bindDependencies(derivation) {\n // invariant(derivation.dependenciesState !== IDerivationState.NOT_TRACKING, \"INTERNAL ERROR bindDependencies expects derivation.dependenciesState !== -1\");\n var prevObserving = derivation.observing;\n var observing = derivation.observing = derivation.newObserving;\n var lowestNewObservingDerivationState = IDerivationState.UP_TO_DATE;\n // Go through all new observables and check diffValue: (this list can contain duplicates):\n // 0: first occurrence, change to 1 and keep it\n // 1: extra occurrence, drop it\n var i0 = 0,\n l = derivation.unboundDepsCount;\n for (var i = 0; i < l; i++) {\n var dep = observing[i];\n if (dep.diffValue === 0) {\n dep.diffValue = 1;\n if (i0 !== i) observing[i0] = dep;\n i0++;\n }\n // Upcast is 'safe' here, because if dep is IObservable, `dependenciesState` will be undefined,\n // not hitting the condition\n if (dep.dependenciesState > lowestNewObservingDerivationState) {\n lowestNewObservingDerivationState = dep.dependenciesState;\n }\n }\n observing.length = i0;\n derivation.newObserving = null; // newObserving shouldn't be needed outside tracking (statement moved down to work around FF bug, see #614)\n // Go through all old observables and check diffValue: (it is unique after last bindDependencies)\n // 0: it's not in new observables, unobserve it\n // 1: it keeps being observed, don't want to notify it. change to 0\n l = prevObserving.length;\n while (l--) {\n var dep = prevObserving[l];\n if (dep.diffValue === 0) {\n removeObserver(dep, derivation);\n }\n dep.diffValue = 0;\n }\n // Go through all new observables and check diffValue: (now it should be unique)\n // 0: it was set to 0 in last loop. don't need to do anything.\n // 1: it wasn't observed, let's observe it. set back to 0\n while (i0--) {\n var dep = observing[i0];\n if (dep.diffValue === 1) {\n dep.diffValue = 0;\n addObserver(dep, derivation);\n }\n }\n // Some new observed derivations may become stale during this derivation computation\n // so they have had no chance to propagate staleness (#916)\n if (lowestNewObservingDerivationState !== IDerivationState.UP_TO_DATE) {\n derivation.dependenciesState = lowestNewObservingDerivationState;\n derivation.onBecomeStale();\n }\n}\nfunction clearObserving(derivation) {\n // invariant(globalState.inBatch > 0, \"INTERNAL ERROR clearObserving should be called only inside batch\");\n var obs = derivation.observing;\n derivation.observing = [];\n var i = obs.length;\n while (i--) {\n removeObserver(obs[i], derivation);\n }derivation.dependenciesState = IDerivationState.NOT_TRACKING;\n}\nfunction untracked(action) {\n var prev = untrackedStart();\n var res = action();\n untrackedEnd(prev);\n return res;\n}\nfunction untrackedStart() {\n var prev = globalState.trackingDerivation;\n globalState.trackingDerivation = null;\n return prev;\n}\nfunction untrackedEnd(prev) {\n globalState.trackingDerivation = prev;\n}\n/**\n * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0\n *\n */\nfunction changeDependenciesStateTo0(derivation) {\n if (derivation.dependenciesState === IDerivationState.UP_TO_DATE) return;\n derivation.dependenciesState = IDerivationState.UP_TO_DATE;\n var obs = derivation.observing;\n var i = obs.length;\n while (i--) {\n obs[i].lowestObserverState = IDerivationState.UP_TO_DATE;\n }\n}\n\nfunction log(msg) {\n console.log(msg);\n return msg;\n}\nfunction whyRun(thing, prop) {\n deprecated(\"`whyRun` is deprecated in favor of `trace`\");\n thing = getAtomFromArgs(arguments);\n if (!thing) return log(getMessage(\"m024\"));\n if (isComputedValue(thing) || isReaction(thing)) return log(thing.whyRun());\n return fail(getMessage(\"m025\"));\n}\nfunction trace() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n var enterBreakPoint = false;\n if (typeof args[args.length - 1] === \"boolean\") enterBreakPoint = args.pop();\n var derivation = getAtomFromArgs(args);\n if (!derivation) {\n return fail(\"'trace(break?)' can only be used inside a tracked computed value or a Reaction. Consider passing in the computed value or reaction explicitly\");\n }\n if (derivation.isTracing === TraceMode.NONE) {\n console.log(\"[mobx.trace] '\" + derivation.name + \"' tracing enabled\");\n }\n derivation.isTracing = enterBreakPoint ? TraceMode.BREAK : TraceMode.LOG;\n}\nfunction getAtomFromArgs(args) {\n switch (args.length) {\n case 0:\n return globalState.trackingDerivation;\n case 1:\n return getAtom(args[0]);\n case 2:\n return getAtom(args[0], args[1]);\n }\n}\n\nvar Reaction = /** @class */function () {\n function Reaction(name, onInvalidate) {\n if (name === void 0) {\n name = \"Reaction@\" + getNextId();\n }\n this.name = name;\n this.onInvalidate = onInvalidate;\n this.observing = []; // nodes we are looking at. Our value depends on these nodes\n this.newObserving = [];\n this.dependenciesState = IDerivationState.NOT_TRACKING;\n this.diffValue = 0;\n this.runId = 0;\n this.unboundDepsCount = 0;\n this.__mapid = \"#\" + getNextId();\n this.isDisposed = false;\n this._isScheduled = false;\n this._isTrackPending = false;\n this._isRunning = false;\n this.isTracing = TraceMode.NONE;\n }\n Reaction.prototype.onBecomeStale = function () {\n this.schedule();\n };\n Reaction.prototype.schedule = function () {\n if (!this._isScheduled) {\n this._isScheduled = true;\n globalState.pendingReactions.push(this);\n runReactions();\n }\n };\n Reaction.prototype.isScheduled = function () {\n return this._isScheduled;\n };\n /**\n * internal, use schedule() if you intend to kick off a reaction\n */\n Reaction.prototype.runReaction = function () {\n if (!this.isDisposed) {\n startBatch();\n this._isScheduled = false;\n if (shouldCompute(this)) {\n this._isTrackPending = true;\n this.onInvalidate();\n if (this._isTrackPending && isSpyEnabled()) {\n // onInvalidate didn't trigger track right away..\n spyReport({\n object: this,\n type: \"scheduled-reaction\"\n });\n }\n }\n endBatch();\n }\n };\n Reaction.prototype.track = function (fn) {\n startBatch();\n var notify = isSpyEnabled();\n var startTime;\n if (notify) {\n startTime = Date.now();\n spyReportStart({\n object: this,\n type: \"reaction\",\n fn: fn\n });\n }\n this._isRunning = true;\n var result = trackDerivedFunction(this, fn, undefined);\n this._isRunning = false;\n this._isTrackPending = false;\n if (this.isDisposed) {\n // disposed during last run. Clean up everything that was bound after the dispose call.\n clearObserving(this);\n }\n if (isCaughtException(result)) this.reportExceptionInDerivation(result.cause);\n if (notify) {\n spyReportEnd({\n time: Date.now() - startTime\n });\n }\n endBatch();\n };\n Reaction.prototype.reportExceptionInDerivation = function (error) {\n var _this = this;\n if (this.errorHandler) {\n this.errorHandler(error, this);\n return;\n }\n var message = \"[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '\" + this;\n var messageToUser = getMessage(\"m037\");\n console.error(message || messageToUser /* latter will not be true, make sure uglify doesn't remove */, error);\n /** If debugging brought you here, please, read the above message :-). Tnx! */\n if (isSpyEnabled()) {\n spyReport({\n type: \"error\",\n message: message,\n error: error,\n object: this\n });\n }\n globalState.globalReactionErrorHandlers.forEach(function (f) {\n return f(error, _this);\n });\n };\n Reaction.prototype.dispose = function () {\n if (!this.isDisposed) {\n this.isDisposed = true;\n if (!this._isRunning) {\n // if disposed while running, clean up later. Maybe not optimal, but rare case\n startBatch();\n clearObserving(this);\n endBatch();\n }\n }\n };\n Reaction.prototype.getDisposer = function () {\n var r = this.dispose.bind(this);\n r.$mobx = this;\n r.onError = registerErrorHandler;\n return r;\n };\n Reaction.prototype.toString = function () {\n return \"Reaction[\" + this.name + \"]\";\n };\n Reaction.prototype.whyRun = function () {\n var observing = unique(this._isRunning ? this.newObserving : this.observing).map(function (dep) {\n return dep.name;\n });\n return \"\\nWhyRun? reaction '\" + this.name + \"':\\n * Status: [\" + (this.isDisposed ? \"stopped\" : this._isRunning ? \"running\" : this.isScheduled() ? \"scheduled\" : \"idle\") + \"]\\n * This reaction will re-run if any of the following observables changes:\\n \" + joinStrings(observing) + \"\\n \" + (this._isRunning ? \" (... or any observable accessed during the remainder of the current run)\" : \"\") + \"\\n\\t\" + getMessage(\"m038\") + \"\\n\";\n };\n Reaction.prototype.trace = function (enterBreakPoint) {\n if (enterBreakPoint === void 0) {\n enterBreakPoint = false;\n }\n trace(this, enterBreakPoint);\n };\n return Reaction;\n}();\nfunction registerErrorHandler(handler) {\n invariant(this && this.$mobx && isReaction(this.$mobx), \"Invalid `this`\");\n invariant(!this.$mobx.errorHandler, \"Only one onErrorHandler can be registered\");\n this.$mobx.errorHandler = handler;\n}\nfunction onReactionError(handler) {\n globalState.globalReactionErrorHandlers.push(handler);\n return function () {\n var idx = globalState.globalReactionErrorHandlers.indexOf(handler);\n if (idx >= 0) globalState.globalReactionErrorHandlers.splice(idx, 1);\n };\n}\n/**\n * Magic number alert!\n * Defines within how many times a reaction is allowed to re-trigger itself\n * until it is assumed that this is gonna be a never ending loop...\n */\nvar MAX_REACTION_ITERATIONS = 100;\nvar reactionScheduler = function reactionScheduler(f) {\n return f();\n};\nfunction runReactions() {\n // Trampolining, if runReactions are already running, new reactions will be picked up\n if (globalState.inBatch > 0 || globalState.isRunningReactions) return;\n reactionScheduler(runReactionsHelper);\n}\nfunction runReactionsHelper() {\n globalState.isRunningReactions = true;\n var allReactions = globalState.pendingReactions;\n var iterations = 0;\n // While running reactions, new reactions might be triggered.\n // Hence we work with two variables and check whether\n // we converge to no remaining reactions after a while.\n while (allReactions.length > 0) {\n if (++iterations === MAX_REACTION_ITERATIONS) {\n console.error(\"Reaction doesn't converge to a stable state after \" + MAX_REACTION_ITERATIONS + \" iterations.\" + (\" Probably there is a cycle in the reactive function: \" + allReactions[0]));\n allReactions.splice(0); // clear reactions\n }\n var remainingReactions = allReactions.splice(0);\n for (var i = 0, l = remainingReactions.length; i < l; i++) {\n remainingReactions[i].runReaction();\n }\n }\n globalState.isRunningReactions = false;\n}\nvar isReaction = createInstanceofPredicate(\"Reaction\", Reaction);\nfunction setReactionScheduler(fn) {\n var baseScheduler = reactionScheduler;\n reactionScheduler = function reactionScheduler(f) {\n return fn(function () {\n return baseScheduler(f);\n });\n };\n}\n\nfunction asReference(value) {\n deprecated(\"asReference is deprecated, use observable.ref instead\");\n return observable.ref(value);\n}\nfunction asStructure(value) {\n deprecated(\"asStructure is deprecated. Use observable.struct, computed.struct or reaction options instead.\");\n return observable.struct(value);\n}\nfunction asFlat(value) {\n deprecated(\"asFlat is deprecated, use observable.shallow instead\");\n return observable.shallow(value);\n}\nfunction asMap(data) {\n deprecated(\"asMap is deprecated, use observable.map or observable.shallowMap instead\");\n return observable.map(data || {});\n}\n\nfunction createComputedDecorator(equals) {\n return createClassPropertyDecorator(function (target, name, _, __, originalDescriptor) {\n invariant(typeof originalDescriptor !== \"undefined\", getMessage(\"m009\"));\n invariant(typeof originalDescriptor.get === \"function\", getMessage(\"m010\"));\n var adm = asObservableObject(target, \"\");\n defineComputedProperty(adm, name, originalDescriptor.get, originalDescriptor.set, equals, false);\n }, function (name) {\n var observable = this.$mobx.values[name];\n if (observable === undefined // See #505\n ) return undefined;\n return observable.get();\n }, function (name, value) {\n this.$mobx.values[name].set(value);\n }, false, false);\n}\nvar computedDecorator = createComputedDecorator(comparer.default);\nvar computedStructDecorator = createComputedDecorator(comparer.structural);\n/**\n * Decorator for class properties: @computed get value() { return expr; }.\n * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;\n */\nvar computed = function computed(arg1, arg2, arg3) {\n if (typeof arg2 === \"string\") {\n return computedDecorator.apply(null, arguments);\n }\n invariant(typeof arg1 === \"function\", getMessage(\"m011\"));\n invariant(arguments.length < 3, getMessage(\"m012\"));\n var opts = (typeof arg2 === \"undefined\" ? \"undefined\" : _typeof(arg2)) === \"object\" ? arg2 : {};\n opts.setter = typeof arg2 === \"function\" ? arg2 : opts.setter;\n var equals = opts.equals ? opts.equals : opts.compareStructural || opts.struct ? comparer.structural : comparer.default;\n return new ComputedValue(arg1, opts.context, equals, opts.name || arg1.name || \"\", opts.setter);\n};\ncomputed.struct = computedStructDecorator;\ncomputed.equals = createComputedDecorator;\n\nfunction isComputed(value, property) {\n if (value === null || value === undefined) return false;\n if (property !== undefined) {\n if (isObservableObject(value) === false) return false;\n if (!value.$mobx.values[property]) return false;\n var atom = getAtom(value, property);\n return isComputedValue(atom);\n }\n return isComputedValue(value);\n}\n\nfunction observe(thing, propOrCb, cbOrFire, fireImmediately) {\n if (typeof cbOrFire === \"function\") return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately);else return observeObservable(thing, propOrCb, cbOrFire);\n}\nfunction observeObservable(thing, listener, fireImmediately) {\n return getAdministration(thing).observe(listener, fireImmediately);\n}\nfunction observeObservableProperty(thing, property, listener, fireImmediately) {\n return getAdministration(thing, property).observe(listener, fireImmediately);\n}\n\nfunction intercept(thing, propOrHandler, handler) {\n if (typeof handler === \"function\") return interceptProperty(thing, propOrHandler, handler);else return interceptInterceptable(thing, propOrHandler);\n}\nfunction interceptInterceptable(thing, handler) {\n return getAdministration(thing).intercept(handler);\n}\nfunction interceptProperty(thing, property, handler) {\n return getAdministration(thing, property).intercept(handler);\n}\n\n/**\n * expr can be used to create temporarily views inside views.\n * This can be improved to improve performance if a value changes often, but usually doesn't affect the outcome of an expression.\n *\n * In the following example the expression prevents that a component is rerender _each time_ the selection changes;\n * instead it will only rerenders when the current todo is (de)selected.\n *\n * reactiveComponent((props) => {\n * const todo = props.todo;\n * const isSelected = mobx.expr(() => props.viewState.selection === todo);\n * return <div className={isSelected ? \"todo todo-selected\" : \"todo\"}>{todo.title}</div>\n * });\n *\n */\nfunction expr(expr, scope) {\n if (!isComputingDerivation()) console.warn(getMessage(\"m013\"));\n // optimization: would be more efficient if the expr itself wouldn't be evaluated first on the next change, but just a 'changed' signal would be fired\n return computed(expr, { context: scope }).get();\n}\n\nfunction toJS(source, detectCycles, __alreadySeen) {\n if (detectCycles === void 0) {\n detectCycles = true;\n }\n if (__alreadySeen === void 0) {\n __alreadySeen = [];\n }\n // optimization: using ES6 map would be more efficient!\n // optimization: lift this function outside toJS, this makes recursion expensive\n function cache(value) {\n if (detectCycles) __alreadySeen.push([source, value]);\n return value;\n }\n if (isObservable(source)) {\n if (detectCycles && __alreadySeen === null) __alreadySeen = [];\n if (detectCycles && source !== null && (typeof source === \"undefined\" ? \"undefined\" : _typeof(source)) === \"object\") {\n for (var i = 0, l = __alreadySeen.length; i < l; i++) {\n if (__alreadySeen[i][0] === source) return __alreadySeen[i][1];\n }\n }\n if (isObservableArray(source)) {\n var res = cache([]);\n var toAdd = source.map(function (value) {\n return toJS(value, detectCycles, __alreadySeen);\n });\n res.length = toAdd.length;\n for (var i = 0, l = toAdd.length; i < l; i++) {\n res[i] = toAdd[i];\n }return res;\n }\n if (isObservableObject(source)) {\n var res = cache({});\n for (var key in source) {\n res[key] = toJS(source[key], detectCycles, __alreadySeen);\n }return res;\n }\n if (isObservableMap(source)) {\n var res_1 = cache({});\n source.forEach(function (value, key) {\n return res_1[key] = toJS(value, detectCycles, __alreadySeen);\n });\n return res_1;\n }\n if (isObservableValue(source)) return toJS(source.get(), detectCycles, __alreadySeen);\n }\n return source;\n}\n\nfunction createTransformer(transformer, onCleanup) {\n invariant(typeof transformer === \"function\" && transformer.length < 2, \"createTransformer expects a function that accepts one argument\");\n // Memoizes: object id -> reactive view that applies transformer to the object\n var objectCache = {};\n // If the resetId changes, we will clear the object cache, see #163\n // This construction is used to avoid leaking refs to the objectCache directly\n var resetId = globalState.resetId;\n // Local transformer class specifically for this transformer\n var Transformer = /** @class */function (_super) {\n __extends(Transformer, _super);\n function Transformer(sourceIdentifier, sourceObject) {\n var _this = _super.call(this, function () {\n return transformer(sourceObject);\n }, undefined, comparer.default, \"Transformer-\" + transformer.name + \"-\" + sourceIdentifier, undefined) || this;\n _this.sourceIdentifier = sourceIdentifier;\n _this.sourceObject = sourceObject;\n return _this;\n }\n Transformer.prototype.onBecomeUnobserved = function () {\n var lastValue = this.value;\n _super.prototype.onBecomeUnobserved.call(this);\n delete objectCache[this.sourceIdentifier];\n if (onCleanup) onCleanup(lastValue, this.sourceObject);\n };\n return Transformer;\n }(ComputedValue);\n return function (object) {\n if (resetId !== globalState.resetId) {\n objectCache = {};\n resetId = globalState.resetId;\n }\n var identifier = getMemoizationId(object);\n var reactiveTransformer = objectCache[identifier];\n if (reactiveTransformer) return reactiveTransformer.get();\n // Not in cache; create a reactive view\n reactiveTransformer = objectCache[identifier] = new Transformer(identifier, object);\n return reactiveTransformer.get();\n };\n}\nfunction getMemoizationId(object) {\n if (typeof object === \"string\" || typeof object === \"number\") return object;\n if (object === null || (typeof object === \"undefined\" ? \"undefined\" : _typeof(object)) !== \"object\") throw new Error(\"[mobx] transform expected some kind of object or primitive value, got: \" + object);\n var tid = object.$transformId;\n if (tid === undefined) {\n tid = getNextId();\n addHiddenProp(object, \"$transformId\", tid);\n }\n return tid;\n}\n\nfunction interceptReads(thing, propOrHandler, handler) {\n var target;\n if (isObservableMap(thing) || isObservableArray(thing) || isObservableValue(thing)) {\n target = getAdministration(thing);\n } else if (isObservableObject(thing)) {\n if (typeof propOrHandler !== \"string\") return fail(\"InterceptReads can only be used with a specific property, not with an object in general\");\n target = getAdministration(thing, propOrHandler);\n } else {\n return fail(\"Expected observable map, object or array as first array\");\n }\n if (target.dehancer !== undefined) return fail(\"An intercept reader was already established\");\n target.dehancer = typeof propOrHandler === \"function\" ? propOrHandler : handler;\n return function () {\n target.dehancer = undefined;\n };\n}\n\n/**\n * (c) Michel Weststrate 2015 - 2016\n * MIT Licensed\n *\n * Welcome to the mobx sources! To get an global overview of how MobX internally works,\n * this is a good place to start:\n * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74\n *\n * Source folders:\n * ===============\n *\n * - api/ Most of the public static methods exposed by the module can be found here.\n * - core/ Implementation of the MobX algorithm; atoms, derivations, reactions, dependency trees, optimizations. Cool stuff can be found here.\n * - types/ All the magic that is need to have observable objects, arrays and values is in this folder. Including the modifiers like `asFlat`.\n * - utils/ Utility stuff.\n *\n */\nvar extras = {\n allowStateChanges: allowStateChanges,\n deepEqual: deepEqual,\n getAtom: getAtom,\n getDebugName: getDebugName,\n getDependencyTree: getDependencyTree,\n getAdministration: getAdministration,\n getGlobalState: getGlobalState,\n getObserverTree: getObserverTree,\n interceptReads: interceptReads,\n isComputingDerivation: isComputingDerivation,\n isSpyEnabled: isSpyEnabled,\n onReactionError: onReactionError,\n reserveArrayBuffer: reserveArrayBuffer,\n resetGlobalState: resetGlobalState,\n isolateGlobalState: isolateGlobalState,\n shareGlobalState: shareGlobalState,\n spyReport: spyReport,\n spyReportEnd: spyReportEnd,\n spyReportStart: spyReportStart,\n setReactionScheduler: setReactionScheduler\n};\nvar everything = {\n Reaction: Reaction,\n untracked: untracked,\n Atom: Atom,\n BaseAtom: BaseAtom,\n useStrict: useStrict,\n isStrictModeEnabled: isStrictModeEnabled,\n spy: spy,\n comparer: comparer,\n asReference: asReference,\n asFlat: asFlat,\n asStructure: asStructure,\n asMap: asMap,\n isModifierDescriptor: isModifierDescriptor,\n isObservableObject: isObservableObject,\n isBoxedObservable: isObservableValue,\n isObservableArray: isObservableArray,\n ObservableMap: ObservableMap,\n isObservableMap: isObservableMap,\n map: map,\n transaction: transaction,\n observable: observable,\n computed: computed,\n isObservable: isObservable,\n isComputed: isComputed,\n extendObservable: extendObservable,\n extendShallowObservable: extendShallowObservable,\n observe: observe,\n intercept: intercept,\n autorun: autorun,\n autorunAsync: autorunAsync,\n when: when,\n reaction: reaction,\n action: action,\n isAction: isAction,\n runInAction: runInAction,\n expr: expr,\n toJS: toJS,\n createTransformer: createTransformer,\n whyRun: whyRun,\n isArrayLike: isArrayLike,\n extras: extras\n};\nvar warnedAboutDefaultExport = false;\nvar _loop_1 = function _loop_1(p) {\n var val = everything[p];\n Object.defineProperty(everything, p, {\n get: function get() {\n if (!warnedAboutDefaultExport) {\n warnedAboutDefaultExport = true;\n console.warn(\"Using default export (`import mobx from 'mobx'`) is deprecated \" + \"and won’t work in mobx@4.0.0\\n\" + \"Use `import * as mobx from 'mobx'` instead\");\n }\n return val;\n }\n });\n};\nfor (var p in everything) {\n _loop_1(p);\n}\nif ((typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === \"undefined\" ? \"undefined\" : _typeof(__MOBX_DEVTOOLS_GLOBAL_HOOK__)) === \"object\") {\n __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx({ spy: spy, extras: extras });\n}\n\nexports.extras = extras;\nexports.Reaction = Reaction;\nexports.untracked = untracked;\nexports.IDerivationState = IDerivationState;\nexports.Atom = Atom;\nexports.BaseAtom = BaseAtom;\nexports.useStrict = useStrict;\nexports.isStrictModeEnabled = isStrictModeEnabled;\nexports.spy = spy;\nexports.comparer = comparer;\nexports.asReference = asReference;\nexports.asFlat = asFlat;\nexports.asStructure = asStructure;\nexports.asMap = asMap;\nexports.isModifierDescriptor = isModifierDescriptor;\nexports.isObservableObject = isObservableObject;\nexports.isBoxedObservable = isObservableValue;\nexports.isObservableArray = isObservableArray;\nexports.ObservableMap = ObservableMap;\nexports.isObservableMap = isObservableMap;\nexports.map = map;\nexports.transaction = transaction;\nexports.observable = observable;\nexports.computed = computed;\nexports.isObservable = isObservable;\nexports.isComputed = isComputed;\nexports.extendObservable = extendObservable;\nexports.extendShallowObservable = extendShallowObservable;\nexports.observe = observe;\nexports.intercept = intercept;\nexports.autorun = autorun;\nexports.autorunAsync = autorunAsync;\nexports.when = when;\nexports.reaction = reaction;\nexports.action = action;\nexports.isAction = isAction;\nexports.runInAction = runInAction;\nexports.expr = expr;\nexports.toJS = toJS;\nexports.createTransformer = createTransformer;\nexports.whyRun = whyRun;\nexports.trace = trace;\nexports.isArrayLike = isArrayLike;\nexports.default = everything;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(11)))\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Provider = exports.inject = exports.connect = exports.useStaticRendering = exports.Observer = exports.observer = undefined;\n\nvar _observer = __webpack_require__(3);\n\nObject.defineProperty(exports, 'observer', {\n enumerable: true,\n get: function get() {\n return _observer.observer;\n }\n});\nObject.defineProperty(exports, 'Observer', {\n enumerable: true,\n get: function get() {\n return _observer.Observer;\n }\n});\nObject.defineProperty(exports, 'useStaticRendering', {\n enumerable: true,\n get: function get() {\n return _observer.useStaticRendering;\n }\n});\n\nvar _connect = __webpack_require__(12);\n\nObject.defineProperty(exports, 'connect', {\n enumerable: true,\n get: function get() {\n return _connect.connect;\n }\n});\n\nvar _inject = __webpack_require__(5);\n\nObject.defineProperty(exports, 'inject', {\n enumerable: true,\n get: function get() {\n return _inject.inject;\n }\n});\n\nvar _Provider = __webpack_require__(14);\n\nObject.defineProperty(exports, 'Provider', {\n enumerable: true,\n get: function get() {\n return _Provider.Provider;\n }\n});\n\nvar _mobx = __webpack_require__(1);\n\nvar _preact = __webpack_require__(0);\n\nif (!_preact.Component) {\n throw new Error('mobx-preact requires Preact to be available');\n}\nif (!_mobx.extras) {\n throw new Error('mobx-preact requires mobx to be available');\n}\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof2 = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Observer = undefined;\n\nvar _createClass = function () {\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if (\"value\" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);\n }\n }return function (Constructor, protoProps, staticProps) {\n if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;\n };\n}();\n\nvar _typeof = typeof Symbol === \"function\" && _typeof2(Symbol.iterator) === \"symbol\" ? function (obj) {\n return typeof obj === \"undefined\" ? \"undefined\" : _typeof2(obj);\n} : function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj === \"undefined\" ? \"undefined\" : _typeof2(obj);\n};\n\nexports.useStaticRendering = useStaticRendering;\nexports.observer = observer;\n\nvar _mobx = __webpack_require__(1);\n\nvar _preact = __webpack_require__(0);\n\nvar _utils = __webpack_require__(4);\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _possibleConstructorReturn(self, call) {\n if (!self) {\n throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n }return call && ((typeof call === \"undefined\" ? \"undefined\" : _typeof2(call)) === \"object\" || typeof call === \"function\") ? call : self;\n}\n\nfunction _inherits(subClass, superClass) {\n if (typeof superClass !== \"function\" && superClass !== null) {\n throw new TypeError(\"Super expression must either be null or a function, not \" + (typeof superClass === \"undefined\" ? \"undefined\" : _typeof2(superClass)));\n }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n}\n\nvar isUsingStaticRendering = false;\n\nvar logger = console; // eslint-disable-line no-console\n\nfunction useStaticRendering(useStaticRendering) {\n isUsingStaticRendering = useStaticRendering;\n}\n\n/**\n Workaround\n\n allowStateChanges from mobX must be patched so that props, state and args are passed to the render() function\n */\n\nfunction allowStateChangesStart(allowStateChanges) {\n var prev = _mobx.extras.getGlobalState().allowStateChanges;\n _mobx.extras.getGlobalState().allowStateChanges = allowStateChanges;\n return prev;\n}\nfunction allowStateChangesEnd(prev) {\n _mobx.extras.getGlobalState().allowStateChanges = prev;\n}\n\nfunction allowStateChanges(allowStateChanges, func, props, state, context) {\n var prev = allowStateChangesStart(allowStateChanges);\n var res = void 0;\n try {\n res = func(props, state, context);\n } finally {\n allowStateChangesEnd(prev);\n }\n return res;\n}\n\n/**\n * Utilities\n */\n\nfunction patch(target, funcName) {\n var runMixinFirst = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n var base = target[funcName];\n var mixinFunc = reactiveMixin[funcName];\n var f = !base ? mixinFunc : runMixinFirst === true ? function () {\n mixinFunc.apply(this, arguments);\n base.apply(this, arguments);\n } : function () {\n base.apply(this, arguments);\n mixinFunc.apply(this, arguments);\n };\n\n // MWE: ideally we freeze here to protect against accidental overwrites in component instances, see #195\n // ...but that breaks react-hot-loader, see #231...\n target[funcName] = f;\n}\n\nfunction isObjectShallowModified(prev, next) {\n if (null == prev || null == next || (typeof prev === 'undefined' ? 'undefined' : _typeof(prev)) !== 'object' || (typeof next === 'undefined' ? 'undefined' : _typeof(next)) !== 'object') {\n return prev !== next;\n }\n var keys = Object.keys(prev);\n if (keys.length !== Object.keys(next).length) {\n return true;\n }\n var key = void 0;\n for (var i = keys.length - 1; i >= 0, key = keys[i]; i--) {\n if (next[key] !== prev[key]) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * ReactiveMixin\n */\nvar reactiveMixin = {\n componentWillMount: function componentWillMount() {\n var _this = this;\n\n if (isUsingStaticRendering === true) {\n return;\n }\n // Generate friendly name for debugging\n var initialName = (0, _utils.makeDisplayName)(this);\n\n /**\n * If props are shallowly modified, react will render anyway,\n * so atom.reportChanged() should not result in yet another re-render\n */\n var skipRender = false;\n /**\n * forceUpdate will re-assign this.props. We don't want that to cause a loop,\n * so detect these changes\n */\n var isForcingUpdate = false;\n\n function makePropertyObservableReference(propName) {\n var valueHolder = this[propName];\n var atom = new _mobx.Atom('reactive ' + propName);\n Object.defineProperty(this, propName, {\n configurable: true,\n enumerable: true,\n get: function get() {\n atom.reportObserved();\n return valueHolder;\n },\n set: function set(v) {\n if (!isForcingUpdate && isObjectShallowModified(valueHolder, v)) {\n valueHolder = v;\n skipRender = true;\n atom.reportChanged();\n skipRender = false;\n } else {\n valueHolder = v;\n }\n }\n });\n }\n\n // make this.props an observable reference, see #124\n makePropertyObservableReference.call(this, 'props');\n // make state an observable reference\n makePropertyObservableReference.call(this, 'state');\n\n // wire up reactive render\n var baseRender = this.render.bind(this);\n var reaction = null;\n var isRenderingPending = false;\n\n var initialRender = function initialRender() {\n reaction = new _mobx.Reaction(initialName + '.render()', function () {\n if (!isRenderingPending) {\n // N.B. Getting here *before mounting* means that a component constructor has side effects (see the relevant test in misc.js)\n // This unidiomatic React usage but React will correctly warn about this so we continue as usual\n // See #85 / Pull #44\n isRenderingPending = true;\n if (typeof _this.componentWillReact === 'function') {\n _this.componentWillReact();\n } // TODO: wrap in action?\n if (_this.__$mobxIsUnmounted !== true) {\n // If we are unmounted at this point, componentWillReact() had a side effect causing the component to unmounted\n // TODO: remove this check? Then react will properly warn about the fact that this should not happen? See #73\n // However, people also claim this migth happen during unit tests..\n var hasError = true;\n try {\n isForcingUpdate = true;\n if (!skipRender) {\n _preact.Component.prototype.forceUpdate.call(_this);\n }\n hasError = false;\n } finally {\n isForcingUpdate = false;\n if (hasError) {\n reaction.dispose();\n }\n }\n }\n }\n });\n reaction.reactComponent = _this;\n reactiveRender.$mobx = reaction;\n _this.render = reactiveRender;\n return reactiveRender(_this.props, _this.state, _this.context);\n };\n\n var reactiveRender = function reactiveRender(props, state, context) {\n isRenderingPending = false;\n var exception = undefined;\n var rendering = undefined;\n reaction.track(function () {\n try {\n rendering = allowStateChanges(false, baseRender, props, state, context);\n } catch (e) {\n exception = e;\n }\n });\n if (exception) {\n throw exception;\n }\n return rendering;\n };\n\n this.render = initialRender;\n },\n\n componentWillUnmount: function componentWillUnmount() {\n if (isUsingStaticRendering === true) {\n return;\n }\n this.render.$mobx && this.render.$mobx.dispose();\n this.__$mobxIsUnmounted = true;\n },\n\n componentDidMount: function componentDidMount() {},\n\n componentDidUpdate: function componentDidUpdate() {},\n\n shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {\n if (isUsingStaticRendering) {\n logger.warn('[mobx-preact] It seems that a re-rendering of a React component is triggered while in static (server-side) mode. Please make sure components are rendered only once server-side.');\n }\n // update on any state changes (as is the default)\n if (this.state !== nextState) {\n return true;\n }\n // update if props are shallowly not equal, inspired by PureRenderMixin\n // we could return just 'false' here, and avoid the `skipRender` checks etc\n // however, it is nicer if lifecycle events are triggered like usually,\n // so we return true here if props are shallowly modified.\n return isObjectShallowModified(this.props, nextProps);\n }\n};\n\n/**\n * Observer function / decorator\n */\nfunction observer(componentClass) {\n if (arguments.length > 1) {\n logger.warn('Mobx observer: Using observer to inject stores is not supported. Use `@connect([\"store1\", \"store2\"]) ComponentClass instead or preferably, use `@inject(\"store1\", \"store2\") @observer ComponentClass` or `inject(\"store1\", \"store2\")(observer(componentClass))``');\n }\n\n if (componentClass.isMobxInjector === true) {\n logger.warn('Mobx observer: You are trying to use \\'observer\\' on a component that already has \\'inject\\'. Please apply \\'observer\\' before applying \\'inject\\'');\n }\n\n // Stateless function component:\n if ((0, _utils.isStateless)(componentClass)) {\n var _class, _temp;\n\n return observer((_temp = _class = function (_Component) {\n _inherits(_class, _Component);\n\n function _class() {\n _classCallCheck(this, _class);\n\n return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments));\n }\n\n _createClass(_class, [{\n key: 'render',\n value: function render() {\n return componentClass.call(this, this.props, this.context);\n }\n }]);\n\n return _class;\n }(_preact.Component), _class.displayName = (0, _utils.makeDisplayName)(componentClass), _temp));\n }\n\n if (!componentClass) {\n throw new Error('Please pass a valid component to \\'observer\\'');\n }\n\n var target = componentClass.prototype || componentClass;\n mixinLifecycleEvents(target);\n componentClass.isMobXReactObserver = true;\n return componentClass;\n}\n\nfunction mixinLifecycleEvents(target) {\n patch(target, 'componentWillMount', true);\n patch(target, 'componentDidMount');\n\n if (!target.shouldComponentUpdate) {\n target.shouldComponentUpdate = reactiveMixin.shouldComponentUpdate;\n }\n}\n\nvar Observer = exports.Observer = observer(function (_ref) {\n var children = _ref.children;\n return children[0]();\n});\n\nObserver.displayName = 'Observer';\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.isStateless = isStateless;\nexports.makeDisplayName = makeDisplayName;\n\nvar _preact = __webpack_require__(0);\n\nfunction isStateless(component) {\n // `function() {}` has prototype, but `() => {}` doesn't\n // `() => {}` via Babel has prototype too.\n return !(component.prototype && component.prototype.render) && !_preact.Component.isPrototypeOf(component);\n}\n\nfunction makeDisplayName(component) {\n var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n _ref$prefix = _ref.prefix,\n prefix = _ref$prefix === undefined ? '' : _ref$prefix,\n _ref$suffix = _ref.suffix,\n suffix = _ref$suffix === undefined ? '' : _ref$suffix;\n\n var displayName = component.displayName || component.name || component.constructor && component.constructor.name || '<component>';\n return prefix + displayName + suffix;\n}\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () {\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if (\"value\" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);\n }\n }return function (Constructor, protoProps, staticProps) {\n if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;\n };\n}();\n\nexports.inject = inject;\n\nvar _preact = __webpack_require__(0);\n\nvar _hoistNonReactStatics = __webpack_require__(13);\n\nvar _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);\n\nvar _observer = __webpack_require__(3);\n\nvar _utils = __webpack_require__(4);\n\nfunction _interopRequireDefault(obj) {\n return obj && obj.__esModule ? obj : { default: obj };\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _possibleConstructorReturn(self, call) {\n if (!self) {\n throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n }return call && ((typeof call === \"undefined\" ? \"undefined\" : _typeof(call)) === \"object\" || typeof call === \"function\") ? call : self;\n}\n\nfunction _inherits(subClass, superClass) {\n if (typeof superClass !== \"function\" && superClass !== null) {\n throw new TypeError(\"Super expression must either be null or a function, not \" + (typeof superClass === \"undefined\" ? \"undefined\" : _typeof(superClass)));\n }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n}\n\nvar proxiedInjectorProps = {\n isMobxInjector: {\n value: true,\n writable: true,\n configurable: true,\n enumerable: true\n }\n};\n\n/**\n * Store Injection\n */\nfunction createStoreInjector(grabStoresFn, component, injectNames) {\n var _class, _temp;\n\n var prefix = 'inject-';\n var suffix = injectNames ? '-with-' + injectNames : '';\n var displayName = (0, _utils.makeDisplayName)(component, { prefix: prefix, suffix: suffix });\n\n var Injector = (_temp = _class = function (_Component) {\n _inherits(Injector, _Component);\n\n function Injector() {\n _classCallCheck(this, Injector);\n\n return _possibleConstructorReturn(this, (Injector.__proto__ || Object.getPrototypeOf(Injector)).apply(this, arguments));\n }\n\n _createClass(Injector, [{\n key: 'render',\n value: function render() {\n // Optimization: it might be more efficient to apply the mapper function *outside* the render method\n // (if the mapper is a function), that could avoid expensive(?) re-rendering of the injector component\n // See this test: 'using a custom injector is not too reactive' in inject.js\n var newProps = {};\n for (var key in this.props) {\n if (this.props.hasOwnProperty(key)) {\n newProps[key] = this.props[key];\n }\n }\n var additionalProps = grabStoresFn(this.context.mobxStores || {}, newProps, this.context) || {};\n for (var _key in additionalProps) {\n newProps[_key] = additionalProps[_key];\n }\n\n return (0, _preact.h)(component, newProps);\n }\n }]);\n\n return Injector;\n }(_preact.Component), _class.displayName = displayName, _temp);\n\n // Static fields from component should be visible on the generated Injector\n\n (0, _hoistNonReactStatics2.default)(Injector, component);\n\n Injector.wrappedComponent = component;\n Object.defineProperties(Injector, proxiedInjectorProps);\n\n return Injector;\n}\n\nfunction grabStoresByName(storeNames) {\n return function (baseStores, nextProps) {\n storeNames.forEach(function (storeName) {\n // prefer props over stores\n if (storeName in nextProps) {\n return;\n }\n if (!(storeName in baseStores)) {\n throw new Error('MobX injector: Store \\'' + storeName + '\\' is not available! Make sure it is provided by some Provider');\n }\n nextProps[storeName] = baseStores[storeName];\n });\n return nextProps;\n };\n}\n\n/**\n * higher order component that injects stores to a child.\n * takes either a varargs list of strings, which are stores read from the context,\n * or a function that manually maps the available stores from the context to props:\n * storesToProps(mobxStores, props, context) => newProps\n */\nfunction inject() /* fn(stores, nextProps) or ...storeNames */{\n var grabStoresFn = void 0;\n if (typeof arguments[0] === 'function') {\n grabStoresFn = arguments[0];\n return function (componentClass) {\n var injected = createStoreInjector(grabStoresFn, componentClass);\n injected.isMobxInjector = false; // suppress warning\n // mark the Injector as observer, to make it react to expressions in `grabStoresFn`,\n // see #111\n injected = (0, _observer.observer)(injected);\n injected.isMobxInjector = true; // restore warning\n return injected;\n };\n } else {\n var storeNames = [];\n for (var i = 0; i < arguments.length; i++) {\n storeNames[i] = arguments[i];\n }\n grabStoresFn = grabStoresByName(storeNames);\n return function (componentClass) {\n return createStoreInjector(grabStoresFn, componentClass, storeNames.join('-'));\n };\n }\n}\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.JSONHTTPError = exports.TextHTTPError = exports.HTTPError = exports.getPagination = undefined;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _pagination = __webpack_require__(16);\n\nObject.defineProperty(exports, \"getPagination\", {\n enumerable: true,\n get: function get() {\n return _pagination.getPagination;\n }\n});\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nfunction _extendableBuiltin(cls) {\n function ExtendableBuiltin() {\n var instance = Reflect.construct(cls, Array.from(arguments));\n Object.setPrototypeOf(instance, Object.getPrototypeOf(this));\n return instance;\n }\n\n ExtendableBuiltin.prototype = Object.create(cls.prototype, {\n constructor: {\n value: cls,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(ExtendableBuiltin, cls);\n } else {\n ExtendableBuiltin.__proto__ = cls;\n }\n\n return ExtendableBuiltin;\n}\n\nvar HTTPError = exports.HTTPError = function (_extendableBuiltin2) {\n _inherits(HTTPError, _extendableBuiltin2);\n\n function HTTPError(response) {\n _classCallCheck(this, HTTPError);\n\n var _this = _possibleConstructorReturn(this, (HTTPError.__proto__ || Object.getPrototypeOf(HTTPError)).call(this, response.statusText));\n\n _this.name = _this.constructor.name;\n if (typeof Error.captureStackTrace === \"function\") {\n Error.captureStackTrace(_this, _this.constructor);\n } else {\n _this.stack = new Error(response.statusText).stack;\n }\n _this.status = response.status;\n return _this;\n }\n\n return HTTPError;\n}(_extendableBuiltin(Error));\n\nvar TextHTTPError = exports.TextHTTPError = function (_HTTPError) {\n _inherits(TextHTTPError, _HTTPError);\n\n function TextHTTPError(response, data) {\n _classCallCheck(this, TextHTTPError);\n\n var _this2 = _possibleConstructorReturn(this, (TextHTTPError.__proto__ || Object.getPrototypeOf(TextHTTPError)).call(this, response));\n\n _this2.data = data;\n return _this2;\n }\n\n return TextHTTPError;\n}(HTTPError);\n\nvar JSONHTTPError = exports.JSONHTTPError = function (_HTTPError2) {\n _inherits(JSONHTTPError, _HTTPError2);\n\n function JSONHTTPError(response, json) {\n _classCallCheck(this, JSONHTTPError);\n\n var _this3 = _possibleConstructorReturn(this, (JSONHTTPError.__proto__ || Object.getPrototypeOf(JSONHTTPError)).call(this, response));\n\n _this3.json = json;\n return _this3;\n }\n\n return JSONHTTPError;\n}(HTTPError);\n\nvar API = function () {\n function API() {\n var apiURL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n var options = arguments[1];\n\n _classCallCheck(this, API);\n\n this.apiURL = apiURL;\n if (this.apiURL.match(/\\/[^\\/]?/)) {\n // eslint-disable-line no-useless-escape\n this._sameOrigin = true;\n }\n this.defaultHeaders = options && options.defaultHeaders || {};\n }\n\n _createClass(API, [{\n key: \"headers\",\n value: function headers() {\n var _headers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n return _extends({}, this.defaultHeaders, {\n \"Content-Type\": \"application/json\"\n }, _headers);\n }\n }, {\n key: \"parseJsonResponse\",\n value: function parseJsonResponse(response) {\n return response.json().then(function (json) {\n if (!response.ok) {\n return Promise.reject(new JSONHTTPError(response, json));\n }\n\n var pagination = (0, _pagination.getPagination)(response);\n return pagination ? { pagination: pagination, items: json } : json;\n });\n }\n }, {\n key: \"request\",\n value: function request(path) {\n var _this4 = this;\n\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n var headers = this.headers(options.headers || {});\n if (this._sameOrigin) {\n options.credentials = options.credentials || \"same-origin\";\n }\n return fetch(this.apiURL + path, _extends({}, options, { headers: headers })).then(function (response) {\n var contentType = response.headers.get(\"Content-Type\");\n if (contentType && contentType.match(/json/)) {\n return _this4.parseJsonResponse(response);\n }\n\n if (!response.ok) {\n return response.text().then(function (data) {\n return Promise.reject(new TextHTTPError(response, data));\n });\n }\n return response.text().then(function (data) {\n data;\n });\n });\n }\n }]);\n\n return API;\n}();\n\nexports.default = API;\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Button = function (_Component) {\n _inherits(Button, _Component);\n\n function Button() {\n _classCallCheck(this, Button);\n\n return _possibleConstructorReturn(this, (Button.__proto__ || Object.getPrototypeOf(Button)).apply(this, arguments));\n }\n\n _createClass(Button, [{\n key: \"render\",\n value: function render() {\n var _props = this.props,\n saving = _props.saving,\n text = _props.text,\n saving_text = _props.saving_text;\n\n\n return (0, _preact.h)(\n \"button\",\n { type: \"submit\", className: \"btn\" + (saving ? \" saving\" : \"\") },\n saving ? saving_text || \"Saving\" : text || \"Save\"\n );\n }\n }]);\n\n return Button;\n}(_preact.Component);\n\nexports.default = Button;\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar messages = {\n confirm: {\n type: \"success\",\n text: \"A confirmation message was sent to your email, click the link there to continue.\"\n },\n password_mail: {\n type: \"success\",\n text: \"We've sent a recovery email to your account, follow the link there to reset your password.\"\n },\n email_changed: {\n type: \"sucess\",\n text: \"Your email address has been updated!\"\n },\n verfication_error: {\n type: \"error\",\n text: \"There was an error verifying your account. Please try again or contact an administrator.\"\n },\n signup_disabled: {\n type: \"error\",\n text: \"Public signups are disabled. Contact an administrator and ask for an invite.\"\n }\n};\n\nvar Message = function (_Component) {\n _inherits(Message, _Component);\n\n function Message() {\n _classCallCheck(this, Message);\n\n return _possibleConstructorReturn(this, (Message.__proto__ || Object.getPrototypeOf(Message)).apply(this, arguments));\n }\n\n _createClass(Message, [{\n key: \"render\",\n value: function render() {\n var type = this.props.type;\n\n var msg = messages[type];\n\n return (0, _preact.h)(\n \"div\",\n { className: \"flashMessage \" + msg.type },\n (0, _preact.h)(\n \"span\",\n null,\n msg.text\n )\n );\n }\n }]);\n\n return Message;\n}(_preact.Component);\n\nexports.default = Message;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _netlifyIdentity = __webpack_require__(10);\n\nvar _netlifyIdentity2 = _interopRequireDefault(_netlifyIdentity);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nif (( false ? \"undefined\" : _typeof(exports)) !== undefined) {\n exports.netlifyIdentity = _netlifyIdentity2.default;\n}\nif ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) !== undefined) {\n window.netlifyIdentity = _netlifyIdentity2.default;\n}\nif (document.readyState === \"loading\") {\n document.addEventListener(\"DOMContentLoaded\", function () {\n _netlifyIdentity2.default.init();\n });\n} else {\n _netlifyIdentity2.default.init();\n}\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _mobx = __webpack_require__(1);\n\nvar _mobxPreact = __webpack_require__(2);\n\nvar _gotrueJs = __webpack_require__(15);\n\nvar _gotrueJs2 = _interopRequireDefault(_gotrueJs);\n\nvar _app = __webpack_require__(19);\n\nvar _app2 = _interopRequireDefault(_app);\n\nvar _store = __webpack_require__(25);\n\nvar _store2 = _interopRequireDefault(_store);\n\nvar _controls = __webpack_require__(26);\n\nvar _controls2 = _interopRequireDefault(_controls);\n\nvar _modal = __webpack_require__(27);\n\nvar _modal2 = _interopRequireDefault(_modal);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar callbacks = {};\nfunction trigger(callback) {\n var _arguments = arguments;\n\n (callbacks[callback] || []).forEach(function (cb) {\n cb.apply(cb, Array.prototype.slice.call(_arguments, 1));\n });\n}\n\nvar validActions = {\n login: true,\n signup: true,\n error: true\n};\n\nvar netlifyIdentity = {\n on: function on(event, cb) {\n callbacks[event] = callbacks[event] || [];\n callbacks[event].push(cb);\n },\n open: function open(action) {\n action = action || \"login\";\n if (!validActions[action]) {\n throw new Error(\"Invalid action for open: \" + action);\n }\n _store2.default.openModal(_store2.default.user ? \"user\" : action);\n },\n close: function close() {\n _store2.default.closeModal();\n },\n currentUser: function currentUser() {\n return _store2.default.gotrue && _store2.default.gotrue.currentUser();\n },\n logout: function logout() {\n return _store2.default.logout();\n },\n get gotrue() {\n if (!_store2.default.gotrue) {\n _store2.default.openModal(\"login\");\n }\n return _store2.default.gotrue;\n },\n init: function init(options) {\n _init(options);\n },\n store: _store2.default\n};\n\nvar queuedIframeStyle = null;\nfunction setStyle(el, css) {\n var style = \"\";\n for (var key in css) {\n style += key + \": \" + css[key] + \"; \";\n }\n if (el) {\n el.setAttribute(\"style\", style);\n } else {\n queuedIframeStyle = style;\n }\n}\n\nvar localHosts = {\n localhost: true,\n \"127.0.0.1\": true,\n \"0.0.0.0\": true\n};\n\nfunction instantiateGotrue(APIUrl) {\n var isLocal = localHosts[document.location.host.split(\":\").shift()];\n var siteURL = isLocal && localStorage.getItem(\"netlifySiteURL\");\n if (APIUrl) {\n return new _gotrueJs2.default({ APIUrl: APIUrl, setCookie: !isLocal });\n }\n if (isLocal && siteURL) {\n var parts = [siteURL];\n if (!siteURL.match(/\\/$/)) {\n parts.push(\"/\");\n }\n parts.push(\".netlify/identity\");\n _store2.default.setIsLocal(isLocal);\n _store2.default.setSiteURL(siteURL);\n return new _gotrueJs2.default({ APIUrl: parts.join(\"\"), setCookie: !isLocal });\n }\n if (isLocal) {\n _store2.default.setIsLocal(isLocal);\n return null;\n }\n\n return new _gotrueJs2.default({ setCookie: !isLocal });\n}\n\nvar root = void 0;\nvar iframe = void 0;\nvar iframeStyle = {\n position: \"fixed\",\n top: 0,\n left: 0,\n border: \"none\",\n width: \"100%\",\n height: \"100%\",\n overflow: \"visible\",\n background: \"transparent\",\n display: \"none\",\n \"z-index\": 99\n};\n\n(0, _mobx.observe)(_store2.default.modal, \"isOpen\", function () {\n if (!_store2.default.settings) {\n _store2.default.loadSettings();\n }\n setStyle(iframe, Object.assign({}, iframeStyle, {\n display: _store2.default.modal.isOpen ? \"block !important\" : \"none\"\n }));\n if (_store2.default.modal.isOpen) {\n trigger(\"open\", _store2.default.modal.page);\n } else {\n trigger(\"close\");\n }\n});\n\n(0, _mobx.observe)(_store2.default, \"siteURL\", function () {\n if (_store2.default.siteURL === null || _store2.default.siteURL === undefined) {\n localStorage.removeItem(\"netlifySiteURL\");\n } else {\n localStorage.setItem(\"netlifySiteURL\", _store2.default.siteURL);\n }\n _store2.default.init(instantiateGotrue(), true);\n});\n\n(0, _mobx.observe)(_store2.default, \"user\", function () {\n if (_store2.default.user) {\n trigger(\"login\", _store2.default.user);\n } else {\n trigger(\"logout\");\n }\n});\n\n(0, _mobx.observe)(_store2.default, \"gotrue\", function () {\n _store2.default.gotrue && trigger(\"init\", _store2.default.gotrue.currentUser());\n});\n\n(0, _mobx.observe)(_store2.default, \"error\", function () {\n trigger(\"error\", _store2.default.error);\n});\n\nvar routes = /(confirmation|invite|recovery|email_change)_token=([^&]+)/;\nvar errorRoute = /error=access_denied&error_description=403/;\nvar accessTokenRoute = /access_token=/;\n\nfunction runRoutes() {\n var hash = (document.location.hash || \"\").replace(/^#\\/?/, \"\");\n if (!hash) {\n return;\n }\n\n var m = hash.match(routes);\n if (m) {\n _store2.default.verifyToken(m[1], m[2]);\n document.location.hash = \"\";\n }\n\n var em = hash.match(errorRoute);\n if (em) {\n _store2.default.openModal(\"signup\");\n document.location.hash = \"\";\n }\n\n var am = hash.match(accessTokenRoute);\n if (am) {\n var params = {};\n hash.split(\"&\").forEach(function (pair) {\n var _pair$split = pair.split(\"=\"),\n _pair$split2 = _slicedToArray(_pair$split, 2),\n key = _pair$split2[0],\n value = _pair$split2[1];\n\n params[key] = value;\n });\n if (!!document && params[\"access_token\"]) {\n document.cookie = \"nf_jwt=\" + params[\"access_token\"];\n }\n if (params[\"state\"]) {\n try {\n // skip initialization for implicit auth\n var state = decodeURIComponent(params[\"state\"]);\n\n var _JSON$parse = JSON.parse(state),\n auth_type = _JSON$parse.auth_type;\n\n if (auth_type === \"implicit\") {\n return;\n }\n // eslint-disable-next-line no-empty\n } catch (e) {}\n }\n document.location.hash = \"\";\n _store2.default.openModal(\"login\");\n _store2.default.completeExternalLogin(params);\n }\n}\n\nfunction _init() {\n var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n var APIUrl = options.APIUrl,\n _options$logo = options.logo,\n logo = _options$logo === undefined ? true : _options$logo,\n namePlaceholder = options.namePlaceholder;\n\n var controlEls = document.querySelectorAll(\"[data-netlify-identity-menu],[data-netlify-identity-button]\");\n Array.prototype.slice.call(controlEls).forEach(function (el) {\n var controls = null;\n var mode = el.getAttribute(\"data-netlify-identity-menu\") === null ? \"button\" : \"menu\";\n (0, _preact.render)((0, _preact.h)(\n _mobxPreact.Provider,\n { store: _store2.default },\n (0, _preact.h)(_controls2.default, { mode: mode, text: el.innerText.trim() })\n ), el, controls);\n });\n\n _store2.default.init(instantiateGotrue(APIUrl));\n _store2.default.modal.logo = logo;\n _store2.default.setNamePlaceholder(namePlaceholder);\n iframe = document.createElement(\"iframe\");\n iframe.id = \"netlify-identity-widget\";\n iframe.title = \"Netlify identity widget\";\n iframe.onload = function () {\n var styles = iframe.contentDocument.createElement(\"style\");\n styles.innerHTML = _modal2.default.toString();\n iframe.contentDocument.head.appendChild(styles);\n root = (0, _preact.render)((0, _preact.h)(\n _mobxPreact.Provider,\n { store: _store2.default },\n (0, _preact.h)(_app2.default, null)\n ), iframe.contentDocument.body, root);\n runRoutes();\n };\n setStyle(iframe, iframeStyle);\n iframe.src = \"about:blank\";\n var container = options.container ? document.querySelector(options.container) : document.body;\n container.appendChild(iframe);\n /* There's a certain case where we might have called setStyle before the iframe was ready.\n Make sure we take the last style and apply it */\n if (queuedIframeStyle) {\n iframe.setAttribute(\"style\", queuedIframeStyle);\n queuedIframeStyle = null;\n }\n}\n\nexports.default = netlifyIdentity;\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar g;\n\n// This works in non-strict mode\ng = function () {\n\treturn this;\n}();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.connect = connect;\n\nvar _observer = __webpack_require__(3);\n\nvar _inject = __webpack_require__(5);\n\nfunction connect(arg1, arg2) {\n if (typeof arg1 === 'string') {\n throw new Error('Store names should be provided as array');\n }\n if (Array.isArray(arg1)) {\n if (!arg2) {\n // invoked as decorator\n return function (componentClass) {\n return connect(arg1, componentClass);\n };\n } else {\n return _inject.inject.apply(null, arg1)(connect(arg2));\n }\n }\n return (0, _observer.observer)(arg1);\n}\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\n\nvar REACT_STATICS = {\n childContextTypes: true,\n contextTypes: true,\n defaultProps: true,\n displayName: true,\n getDefaultProps: true,\n getDerivedStateFromProps: true,\n mixins: true,\n propTypes: true,\n type: true\n};\n\nvar KNOWN_STATICS = {\n name: true,\n length: true,\n prototype: true,\n caller: true,\n callee: true,\n arguments: true,\n arity: true\n};\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = getPrototypeOf && getPrototypeOf(Object);\n\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n if (typeof sourceComponent !== 'string') {\n // don't hoist over string (html) components\n\n if (objectPrototype) {\n var inheritedComponent = getPrototypeOf(sourceComponent);\n if (inheritedComponent && inheritedComponent !== objectPrototype) {\n hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n }\n }\n\n var keys = getOwnPropertyNames(sourceComponent);\n\n if (getOwnPropertySymbols) {\n keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n }\n\n for (var i = 0; i < keys.length; ++i) {\n var key = keys[i];\n if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) {\n var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n try {\n // Avoid failures from read-only properties\n defineProperty(targetComponent, key, descriptor);\n } catch (e) {}\n }\n }\n\n return targetComponent;\n }\n\n return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Provider = undefined;\n\nvar _createClass = function () {\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if (\"value\" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);\n }\n }return function (Constructor, protoProps, staticProps) {\n if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;\n };\n}();\n\nvar _preact = __webpack_require__(0);\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _possibleConstructorReturn(self, call) {\n if (!self) {\n throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n }return call && ((typeof call === \"undefined\" ? \"undefined\" : _typeof(call)) === \"object\" || typeof call === \"function\") ? call : self;\n}\n\nfunction _inherits(subClass, superClass) {\n if (typeof superClass !== \"function\" && superClass !== null) {\n throw new TypeError(\"Super expression must either be null or a function, not \" + (typeof superClass === \"undefined\" ? \"undefined\" : _typeof(superClass)));\n }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n}\n\nvar specialReactKeys = { children: true, key: true, ref: true };\n\nvar logger = console; // eslint-disable-line no-console\n\nvar Provider = exports.Provider = function (_Component) {\n _inherits(Provider, _Component);\n\n function Provider() {\n _classCallCheck(this, Provider);\n\n return _possibleConstructorReturn(this, (Provider.__proto__ || Object.getPrototypeOf(Provider)).apply(this, arguments));\n }\n\n _createClass(Provider, [{\n key: 'render',\n value: function render(_ref) {\n var children = _ref.children;\n\n return children.length > 1 ? (0, _preact.h)('div', null, ' ', children, ' ') : children[0];\n }\n }, {\n key: 'getChildContext',\n value: function getChildContext() {\n var stores = {};\n // inherit stores\n var baseStores = this.context.mobxStores;\n if (baseStores) {\n for (var key in baseStores) {\n stores[key] = baseStores[key];\n }\n }\n // add own stores\n for (var _key in this.props) {\n if (!specialReactKeys[_key] && _key !== 'suppressChangedStoreWarning') {\n stores[_key] = this.props[_key];\n }\n }\n\n return {\n mobxStores: stores\n };\n }\n }, {\n key: 'componentWillReceiveProps',\n value: function componentWillReceiveProps(nextProps) {\n // Maybe this warning is too aggressive?\n if (Object.keys(nextProps).length !== Object.keys(this.props).length) {\n logger.warn('MobX Provider: The set of provided stores has changed. Please avoid changing stores as the change might not propagate to all children');\n }\n if (!nextProps.suppressChangedStoreWarning) {\n for (var key in nextProps) {\n if (!specialReactKeys[key] && this.props[key] !== nextProps[key]) {\n logger.warn('MobX Provider: Provided store \\'' + key + '\\' has changed. Please avoid replacing stores as the change might not propagate to all children');\n }\n }\n }\n }\n }]);\n\n return Provider;\n}(_preact.Component);\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () {\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if (\"value\" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);\n }\n }return function (Constructor, protoProps, staticProps) {\n if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;\n };\n}();\n\nvar _microApiClient = __webpack_require__(6);\n\nvar _microApiClient2 = _interopRequireDefault(_microApiClient);\n\nvar _user = __webpack_require__(17);\n\nvar _user2 = _interopRequireDefault(_user);\n\nfunction _interopRequireDefault(obj) {\n return obj && obj.__esModule ? obj : { default: obj };\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nvar HTTPRegexp = /^http:\\/\\//;\nvar defaultApiURL = \"/.netlify/identity\";\n\nvar GoTrue = function () {\n function GoTrue() {\n var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n _ref$APIUrl = _ref.APIUrl,\n APIUrl = _ref$APIUrl === undefined ? defaultApiURL : _ref$APIUrl,\n _ref$audience = _ref.audience,\n audience = _ref$audience === undefined ? \"\" : _ref$audience,\n _ref$setCookie = _ref.setCookie,\n setCookie = _ref$setCookie === undefined ? false : _ref$setCookie;\n\n _classCallCheck(this, GoTrue);\n\n if (APIUrl.match(HTTPRegexp)) {\n console.warn(\"Warning:\\n\\nDO NOT USE HTTP IN PRODUCTION FOR GOTRUE EVER!\\nGoTrue REQUIRES HTTPS to work securely.\");\n }\n\n if (audience) {\n this.audience = audience;\n }\n\n this.setCookie = setCookie;\n\n this.api = new _microApiClient2.default(APIUrl);\n }\n\n _createClass(GoTrue, [{\n key: \"_request\",\n value: function _request(path) {\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n options.headers = options.headers || {};\n var aud = options.audience || this.audience;\n if (aud) {\n options.headers[\"X-JWT-AUD\"] = aud;\n }\n return this.api.request(path, options).catch(function (err) {\n if (err instanceof _microApiClient.JSONHTTPError && err.json) {\n if (err.json.msg) {\n err.message = err.json.msg;\n } else if (err.json.error) {\n err.message = err.json.error + \": \" + err.json.error_description;\n }\n }\n return Promise.reject(err);\n });\n }\n }, {\n key: \"settings\",\n value: function settings() {\n return this._request(\"/settings\");\n }\n }, {\n key: \"signup\",\n value: function signup(email, password, data) {\n return this._request(\"/signup\", {\n method: \"POST\",\n body: JSON.stringify({ email: email, password: password, data: data })\n });\n }\n }, {\n key: \"login\",\n value: function login(email, password, remember) {\n var _this = this;\n\n this._setRememberHeaders(remember);\n return this._request(\"/token\", {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n body: \"grant_type=password&username=\" + encodeURIComponent(email) + \"&password=\" + encodeURIComponent(password)\n }).then(function (response) {\n _user2.default.removeSavedSession();\n return _this.createUser(response, remember);\n });\n }\n }, {\n key: \"loginExternalUrl\",\n value: function loginExternalUrl(provider) {\n return this.api.apiURL + \"/authorize?provider=\" + provider;\n }\n }, {\n key: \"confirm\",\n value: function confirm(token, remember) {\n this._setRememberHeaders(remember);\n return this.verify(\"signup\", token, remember);\n }\n }, {\n key: \"requestPasswordRecovery\",\n value: function requestPasswordRecovery(email) {\n return this._request(\"/recover\", {\n method: \"POST\",\n body: JSON.stringify({ email: email })\n });\n }\n }, {\n key: \"recover\",\n value: function recover(token, remember) {\n this._setRememberHeaders(remember);\n return this.verify(\"recovery\", token, remember);\n }\n }, {\n key: \"acceptInvite\",\n value: function acceptInvite(token, password, remember) {\n var _this2 = this;\n\n this._setRememberHeaders(remember);\n return this._request(\"/verify\", {\n method: \"POST\",\n body: JSON.stringify({ token: token, password: password, type: \"signup\" })\n }).then(function (response) {\n return _this2.createUser(response, remember);\n });\n }\n }, {\n key: \"acceptInviteExternalUrl\",\n value: function acceptInviteExternalUrl(provider, token) {\n return this.api.apiURL + \"/authorize?provider=\" + provider + \"&invite_token=\" + token;\n }\n }, {\n key: \"createUser\",\n value: function createUser(tokenResponse) {\n var remember = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n this._setRememberHeaders(remember);\n var user = new _user2.default(this.api, tokenResponse, this.audience);\n return user.getUserData().then(function (user) {\n if (remember) {\n user._saveSession();\n }\n return user;\n });\n }\n }, {\n key: \"currentUser\",\n value: function currentUser() {\n var user = _user2.default.recoverSession(this.api);\n user && this._setRememberHeaders(user._fromStorage);\n return user;\n }\n }, {\n key: \"verify\",\n value: function verify(type, token, remember) {\n var _this3 = this;\n\n this._setRememberHeaders(remember);\n return this._request(\"/verify\", {\n method: \"POST\",\n body: JSON.stringify({ token: token, type: type })\n }).then(function (response) {\n return _this3.createUser(response, remember);\n });\n }\n }, {\n key: \"_setRememberHeaders\",\n value: function _setRememberHeaders(remember) {\n if (this.setCookie) {\n this.api.defaultHeaders = this.api.defaultHeaders || {};\n this.api.defaultHeaders[\"X-Use-Cookie\"] = remember ? \"1\" : \"session\";\n }\n }\n }]);\n\n return GoTrue;\n}();\n\nexports.default = GoTrue;\n\nif (typeof window !== \"undefined\") {\n window.GoTrue = GoTrue;\n}\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nexports.getPagination = getPagination;\nfunction getPagination(response) {\n var links = response.headers.get(\"Link\");\n var pagination = {};\n //var link, url, rel, m, page;\n if (links == null) {\n return null;\n }\n links = links.split(\",\");\n var total = response.headers.get(\"X-Total-Count\");\n\n for (var i = 0, len = links.length; i < len; i++) {\n var link = links[i].replace(/(^\\s*|\\s*$)/, \"\");\n\n var _link$split = link.split(\";\"),\n _link$split2 = _slicedToArray(_link$split, 2),\n url = _link$split2[0],\n rel = _link$split2[1];\n\n var m = url.match(/page=(\\d+)/);\n var page = m && parseInt(m[1], 10);\n if (rel.match(/last/)) {\n pagination.last = page;\n } else if (rel.match(/next/)) {\n pagination.next = page;\n } else if (rel.match(/prev/)) {\n pagination.prev = page;\n } else if (rel.match(/first/)) {\n pagination.first = page;\n }\n }\n\n pagination.last = Math.max(pagination.last || 0, pagination.prev && pagination.prev + 1 || 0);\n pagination.current = pagination.next ? pagination.next - 1 : pagination.last || 1;\n pagination.total = total ? parseInt(total, 10) : null;\n\n return pagination;\n}\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _extends = Object.assign || function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }return target;\n};\n\nvar _createClass = function () {\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if (\"value\" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);\n }\n }return function (Constructor, protoProps, staticProps) {\n if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;\n };\n}();\n\nvar _microApiClient = __webpack_require__(6);\n\nvar _microApiClient2 = _interopRequireDefault(_microApiClient);\n\nvar _admin = __webpack_require__(18);\n\nvar _admin2 = _interopRequireDefault(_admin);\n\nfunction _interopRequireDefault(obj) {\n return obj && obj.__esModule ? obj : { default: obj };\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nvar ExpiryMargin = 60 * 1000;\nvar storageKey = \"gotrue.user\";\nvar refreshPromises = {};\nvar currentUser = null;\nvar forbiddenUpdateAttributes = { api: 1, token: 1, audience: 1, url: 1 };\nvar forbiddenSaveAttributes = { api: 1 };\n\nvar User = function () {\n function User(api, tokenResponse, audience) {\n _classCallCheck(this, User);\n\n this.api = api;\n this.url = api.apiURL;\n this.audience = audience;\n this._processTokenResponse(tokenResponse);\n currentUser = this;\n }\n\n _createClass(User, [{\n key: \"update\",\n value: function update(attributes) {\n var _this = this;\n\n return this._request(\"/user\", {\n method: \"PUT\",\n body: JSON.stringify(attributes)\n }).then(function (response) {\n return _this._saveUserData(response)._refreshSavedSession();\n });\n }\n }, {\n key: \"jwt\",\n value: function jwt(forceRefresh) {\n var _tokenDetails = this.tokenDetails(),\n expires_at = _tokenDetails.expires_at,\n refresh_token = _tokenDetails.refresh_token,\n access_token = _tokenDetails.access_token;\n\n if (forceRefresh || expires_at - ExpiryMargin < Date.now()) {\n return this._refreshToken(refresh_token);\n }\n return Promise.resolve(access_token);\n }\n }, {\n key: \"logout\",\n value: function logout() {\n return this._request(\"/logout\", { method: \"POST\" }).then(this.clearSession.bind(this)).catch(this.clearSession.bind(this));\n }\n }, {\n key: \"_refreshToken\",\n value: function _refreshToken(refresh_token) {\n var _this2 = this;\n\n if (refreshPromises[refresh_token]) {\n return refreshPromises[refresh_token];\n }\n return refreshPromises[refresh_token] = this.api.request(\"/token\", {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n body: \"grant_type=refresh_token&refresh_token=\" + refresh_token\n }).then(function (response) {\n delete refreshPromises[refresh_token];\n _this2._processTokenResponse(response);\n _this2._refreshSavedSession();\n return _this2.token.access_token;\n }).catch(function (error) {\n delete refreshPromises[refresh_token];\n _this2.clearSession();\n return Promise.reject(error);\n });\n }\n }, {\n key: \"_request\",\n value: function _request(path) {\n var _this3 = this;\n\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n options.headers = options.headers || {};\n\n var aud = options.audience || this.audience;\n if (aud) {\n options.headers[\"X-JWT-AUD\"] = aud;\n }\n\n return this.jwt().then(function (token) {\n return _this3.api.request(path, _extends({\n headers: Object.assign(options.headers, {\n Authorization: \"Bearer \" + token\n })\n }, options)).catch(function (err) {\n if (err instanceof _microApiClient.JSONHTTPError && err.json) {\n if (err.json.msg) {\n err.message = err.json.msg;\n } else if (err.json.error) {\n err.message = err.json.error + \": \" + err.json.error_description;\n }\n }\n return Promise.reject(err);\n });\n });\n }\n }, {\n key: \"getUserData\",\n value: function getUserData() {\n return this._request(\"/user\").then(this._saveUserData.bind(this)).then(this._refreshSavedSession.bind(this));\n }\n }, {\n key: \"_saveUserData\",\n value: function _saveUserData(attributes, fromStorage) {\n for (var key in attributes) {\n if (key in User.prototype || key in forbiddenUpdateAttributes) {\n continue;\n }\n this[key] = attributes[key];\n }\n if (fromStorage) {\n this._fromStorage = true;\n }\n return this;\n }\n }, {\n key: \"_processTokenResponse\",\n value: function _processTokenResponse(tokenResponse) {\n this.token = tokenResponse;\n var claims = void 0;\n try {\n claims = JSON.parse(urlBase64Decode(tokenResponse.access_token.split(\".\")[1]));\n this.token.expires_at = claims.exp * 1000;\n } catch (e) {\n console.error(new Error(\"Gotrue-js: Failed to parse tokenResponse claims: \" + JSON.stringify(tokenResponse)));\n }\n }\n }, {\n key: \"_refreshSavedSession\",\n value: function _refreshSavedSession() {\n // only update saved session if we previously saved something\n if (localStorage.getItem(storageKey)) {\n this._saveSession();\n }\n return this;\n }\n }, {\n key: \"_saveSession\",\n value: function _saveSession() {\n localStorage.setItem(storageKey, JSON.stringify(this._details));\n return this;\n }\n }, {\n key: \"tokenDetails\",\n value: function tokenDetails() {\n return this.token;\n }\n }, {\n key: \"clearSession\",\n value: function clearSession() {\n User.removeSavedSession();\n this.token = null;\n currentUser = null;\n }\n }, {\n key: \"admin\",\n get: function get() {\n return new _admin2.default(this);\n }\n }, {\n key: \"_details\",\n get: function get() {\n var userCopy = {};\n for (var key in this) {\n if (key in User.prototype || key in forbiddenSaveAttributes) {\n continue;\n }\n userCopy[key] = this[key];\n }\n return userCopy;\n }\n }], [{\n key: \"removeSavedSession\",\n value: function removeSavedSession() {\n localStorage.removeItem(storageKey);\n }\n }, {\n key: \"recoverSession\",\n value: function recoverSession(apiInstance) {\n if (currentUser) {\n return currentUser;\n }\n\n var json = localStorage.getItem(storageKey);\n if (json) {\n try {\n var data = JSON.parse(json);\n var url = data.url,\n token = data.token,\n audience = data.audience;\n\n if (!url || !token) {\n return null;\n }\n\n var api = apiInstance || new _microApiClient2.default(url, {});\n return new User(api, token, audience)._saveUserData(data, true);\n } catch (ex) {\n console.error(new Error(\"Gotrue-js: Error recovering session: \" + ex));\n return null;\n }\n }\n\n return null;\n }\n }]);\n\n return User;\n}();\n\nexports.default = User;\n\nfunction urlBase64Decode(str) {\n // From https://jwt.io/js/jwt.js\n var output = str.replace(/-/g, '+').replace(/_/g, '/');\n switch (output.length % 4) {\n case 0:\n break;\n case 2:\n output += '==';\n break;\n case 3:\n output += '=';\n break;\n default:\n throw 'Illegal base64url string!';\n }\n var result = window.atob(output); //polifyll https://github.com/davidchambers/Base64.js\n try {\n return decodeURIComponent(escape(result));\n } catch (err) {\n return result;\n }\n}\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () {\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if (\"value\" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);\n }\n }return function (Constructor, protoProps, staticProps) {\n if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;\n };\n}();\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nvar Admin = function () {\n function Admin(user) {\n _classCallCheck(this, Admin);\n\n this.user = user;\n }\n\n // Return a list of all users in an audience\n\n\n _createClass(Admin, [{\n key: \"listUsers\",\n value: function listUsers(aud) {\n return this.user._request(\"/admin/users\", {\n method: \"GET\",\n audience: aud\n });\n }\n }, {\n key: \"getUser\",\n value: function getUser(user) {\n return this.user._request(\"/admin/users/\" + user.id);\n }\n }, {\n key: \"updateUser\",\n value: function updateUser(user) {\n var attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n return this.user._request(\"/admin/users/\" + user.id, {\n method: \"PUT\",\n body: JSON.stringify(attributes)\n });\n }\n }, {\n key: \"createUser\",\n value: function createUser(email, password) {\n var attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n attributes.email = email;\n attributes.password = password;\n return this.user._request(\"/admin/users\", {\n method: \"POST\",\n body: JSON.stringify(attributes)\n });\n }\n }, {\n key: \"deleteUser\",\n value: function deleteUser(user) {\n return this.user._request(\"/admin/users/\" + user.id, {\n method: \"DELETE\"\n });\n }\n }]);\n\n return Admin;\n}();\n\nexports.default = Admin;\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _dec, _class;\n\nvar _preact = __webpack_require__(0);\n\nvar _mobxPreact = __webpack_require__(2);\n\nvar _modal = __webpack_require__(20);\n\nvar _modal2 = _interopRequireDefault(_modal);\n\nvar _siteurl = __webpack_require__(21);\n\nvar _siteurl2 = _interopRequireDefault(_siteurl);\n\nvar _logout = __webpack_require__(22);\n\nvar _logout2 = _interopRequireDefault(_logout);\n\nvar _user = __webpack_require__(23);\n\nvar _user2 = _interopRequireDefault(_user);\n\nvar _providers = __webpack_require__(24);\n\nvar _providers2 = _interopRequireDefault(_providers);\n\nvar _message = __webpack_require__(8);\n\nvar _message2 = _interopRequireDefault(_message);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar pagesWithHeader = { login: true, signup: true };\nvar pages = {\n login: {\n login: true,\n button: \"Log in\",\n button_saving: \"Logging in\",\n email: true,\n password: true,\n link: \"amnesia\",\n link_text: \"Forgot password?\",\n providers: true\n },\n signup: {\n signup: true,\n button: \"Sign up\",\n button_saving: \"Signing Up\",\n name: true,\n email: true,\n password: true,\n providers: true\n },\n amnesia: {\n title: \"Recover password\",\n button: \"Send recovery email\",\n button_saving: \"Sending recovery email\",\n email: true,\n link: \"login\",\n link_text: \"Never mind\"\n },\n recovery: {\n title: \"Recover password\",\n button: \"Update password\",\n button_saving: \"Updating password\",\n password: true,\n link: \"login\",\n link_text: \"Never mind\"\n },\n invite: {\n title: \"Complete your signup\",\n button: \"Sign up\",\n button_saving: \"Signing Up\",\n password: true,\n providers: true\n },\n user: {\n title: \"Logged in\"\n }\n};\n\nvar App = (_dec = (0, _mobxPreact.connect)([\"store\"]), _dec(_class = function (_Component) {\n _inherits(App, _Component);\n\n function App() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, App);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = App.__proto__ || Object.getPrototypeOf(App)).call.apply(_ref, [this].concat(args))), _this), _this.handleClose = function () {\n return _this.props.store.closeModal();\n }, _this.handlePage = function (page) {\n return _this.props.store.openModal(page);\n }, _this.handleLogout = function () {\n return _this.props.store.logout();\n }, _this.handleSiteURL = function (url) {\n return _this.props.store.setSiteURL(url);\n }, _this.clearSiteURL = function (url) {\n return _this.props.store.clearSiteURL();\n }, _this.handleExternalLogin = function (provider) {\n return _this.props.store.externalLogin(provider);\n }, _this.handleUser = function (_ref2) {\n var name = _ref2.name,\n email = _ref2.email,\n password = _ref2.password;\n var store = _this.props.store;\n\n\n switch (store.modal.page) {\n case \"login\":\n store.login(email, password);\n break;\n case \"signup\":\n store.signup(name, email, password);\n break;\n case \"amnesia\":\n store.requestPasswordRecovery(email);\n break;\n case \"invite\":\n store.acceptInvite(password);\n break;\n case \"recovery\":\n store.updatePassword(password);\n break;\n }\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _createClass(App, [{\n key: \"renderBody\",\n value: function renderBody() {\n var _this2 = this;\n\n var store = this.props.store;\n\n var page = pages[store.modal.page] || {};\n var pageLinkHandler = function pageLinkHandler() {\n return _this2.handlePage(page.link);\n };\n\n if (store.isLocal && store.siteURL === null) {\n return (0, _preact.h)(_siteurl2.default, {\n devMode: store.siteURL != null,\n onSiteURL: store.siteURL ? this.clearSiteURL : this.handleSiteURL\n });\n }\n if (!store.settings) {\n return;\n }\n if (store.user) {\n return (0, _preact.h)(_logout2.default, {\n user: store.user,\n saving: store.saving,\n onLogout: this.handleLogout\n });\n }\n if (store.modal.page === \"signup\" && store.settings.disable_signup) {\n return (0, _preact.h)(_message2.default, { type: \"signup_disabled\" });\n }\n\n return (0, _preact.h)(\n \"div\",\n null,\n (0, _preact.h)(_user2.default, {\n page: pages[store.modal.page] || {},\n message: store.message,\n saving: store.saving,\n onSubmit: this.handleUser,\n namePlaceholder: store.namePlaceholder\n }),\n !store.user && page.link && store.gotrue && (0, _preact.h)(\n \"button\",\n {\n onclick: pageLinkHandler,\n className: \"btnLink forgotPasswordLink\"\n },\n page.link_text\n ),\n store.isLocal ? (0, _preact.h)(_siteurl2.default, {\n devMode: store.siteURL != null,\n onSiteURL: store.siteURL ? this.clearSiteURL : this.handleSiteURL\n }) : (0, _preact.h)(\"div\", null)\n );\n }\n }, {\n key: \"renderProviders\",\n value: function renderProviders() {\n var store = this.props.store;\n\n\n if (!(store.gotrue && store.settings)) {\n return null;\n }\n if (store.modal.page === \"signup\" && store.settings.disable_signup) {\n return null;\n }\n var page = pages[store.modal.page] || {};\n\n if (!page.providers) {\n return null;\n }\n\n var providers = [\"Google\", \"GitHub\", \"GitLab\", \"BitBucket\", \"SAML\"].filter(function (p) {\n return store.settings.external[p.toLowerCase()];\n });\n\n return providers.length ? (0, _preact.h)(_providers2.default, {\n providers: providers,\n labels: store.settings.external_labels || {},\n onLogin: this.handleExternalLogin\n }) : null;\n }\n }, {\n key: \"render\",\n value: function render() {\n var store = this.props.store;\n\n var showHeader = pagesWithHeader[store.modal.page];\n var showSignup = store.settings && !store.settings.disable_signup;\n var page = pages[store.modal.page] || {};\n\n return (0, _preact.h)(\n \"div\",\n null,\n (0, _preact.h)(\n _modal2.default,\n {\n page: page,\n error: store.error,\n showHeader: showHeader,\n showSignup: showSignup,\n devSettings: !store.gotrue,\n loading: !store.error && store.gotrue && !store.settings,\n isOpen: store.modal.isOpen,\n onPage: this.handlePage,\n onClose: this.handleClose,\n logo: store.modal.logo\n },\n this.renderBody(),\n this.renderProviders()\n )\n );\n }\n }]);\n\n return App;\n}(_preact.Component)) || _class);\nexports.default = App;\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nfunction formatError(error) {\n return error.json && error.json.error_description || error.message || error.toString();\n}\n\nvar Modal = function (_Component) {\n _inherits(Modal, _Component);\n\n function Modal() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, Modal);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Modal.__proto__ || Object.getPrototypeOf(Modal)).call.apply(_ref, [this].concat(args))), _this), _this.handleClose = function (e) {\n e.preventDefault();\n _this.props.onClose();\n }, _this.blockEvent = function (e) {\n e.stopPropagation();\n }, _this.linkHandler = function (page) {\n return function (e) {\n e.preventDefault();\n _this.props.onPage(page);\n };\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _createClass(Modal, [{\n key: \"render\",\n value: function render() {\n var _props = this.props,\n page = _props.page,\n error = _props.error,\n loading = _props.loading,\n showHeader = _props.showHeader,\n showSignup = _props.showSignup,\n devSettings = _props.devSettings,\n isOpen = _props.isOpen,\n children = _props.children,\n logo = _props.logo;\n\n var hidden = loading || !isOpen;\n return (0, _preact.h)(\n \"div\",\n {\n className: \"modalContainer\",\n role: \"dialog\",\n \"aria-hidden\": \"\" + hidden,\n onClick: this.handleClose\n },\n (0, _preact.h)(\n \"div\",\n {\n className: \"modalDialog\" + (loading ? \" visuallyHidden\" : \"\"),\n onClick: this.blockEvent\n },\n (0, _preact.h)(\n \"div\",\n { className: \"modalContent\" },\n (0, _preact.h)(\n \"button\",\n { onclick: this.handleClose, className: \"btn btnClose\" },\n (0, _preact.h)(\n \"span\",\n { className: \"visuallyHidden\" },\n \"Close\"\n )\n ),\n showHeader && (0, _preact.h)(\n \"div\",\n { className: \"header\" },\n showSignup && (0, _preact.h)(\n \"button\",\n {\n className: \"btn btnHeader \" + (page.signup ? \"active\" : \"\"),\n onclick: this.linkHandler(\"signup\")\n },\n \"Sign up\"\n ),\n !devSettings && (0, _preact.h)(\n \"button\",\n {\n className: \"btn btnHeader \" + (page.login ? \"active\" : \"\"),\n onclick: this.linkHandler(\"login\")\n },\n \"Log in\"\n )\n ),\n page.title && (0, _preact.h)(\n \"div\",\n { className: \"header\" },\n (0, _preact.h)(\n \"button\",\n { className: \"btn btnHeader active\" },\n page.title\n )\n ),\n devSettings && (0, _preact.h)(\n \"div\",\n { className: \"header\" },\n (0, _preact.h)(\n \"button\",\n { className: \"btn btnHeader active\" },\n \"Development Settings\"\n )\n ),\n error && (0, _preact.h)(\n \"div\",\n { className: \"flashMessage error\" },\n (0, _preact.h)(\n \"span\",\n null,\n formatError(error)\n )\n ),\n children\n )\n ),\n logo && (0, _preact.h)(\n \"a\",\n {\n href: \"https://www.netlify.com\",\n className: \"callOut\" + (loading ? \" visuallyHidden\" : \"\")\n },\n (0, _preact.h)(\"span\", { className: \"netlifyLogo\" }),\n \"Coded by Netlify\"\n )\n );\n }\n }]);\n\n return Modal;\n}(_preact.Component);\n\nexports.default = Modal;\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar SiteURLForm = function (_Component) {\n _inherits(SiteURLForm, _Component);\n\n function SiteURLForm(props) {\n _classCallCheck(this, SiteURLForm);\n\n var _this = _possibleConstructorReturn(this, (SiteURLForm.__proto__ || Object.getPrototypeOf(SiteURLForm)).call(this, props));\n\n _this.handleInput = function (e) {\n _this.setState(_defineProperty({}, e.target.name, e.target.value));\n };\n\n _this.addSiteURL = function (e) {\n e.preventDefault();\n _this.props.onSiteURL(_this.state.url);\n };\n\n _this.clearSiteURL = function (e) {\n e.preventDefault;\n _this.props.onSiteURL();\n };\n\n _this.state = { url: \"\", development: props.devMode || false };\n return _this;\n }\n\n _createClass(SiteURLForm, [{\n key: \"render\",\n value: function render() {\n var _this2 = this;\n\n var _state = this.state,\n url = _state.url,\n development = _state.development;\n\n\n return (0, _preact.h)(\n \"div\",\n null,\n development ? (0, _preact.h)(\n \"div\",\n { \"class\": \"subheader\" },\n (0, _preact.h)(\n \"h3\",\n null,\n \"Development Settings\"\n ),\n (0, _preact.h)(\n \"button\",\n {\n onclick: function onclick(e) {\n return _this2.clearSiteURL(e);\n },\n className: \"btnLink forgotPasswordLink\"\n },\n \"Clear localhost URL\"\n )\n ) : (0, _preact.h)(\n \"form\",\n { onsubmit: this.addSiteURL, className: \"form\" },\n (0, _preact.h)(\n \"div\",\n { className: \"flashMessage\" },\n \"Looks like you're running a local server. Please let us know the URL of your Netlify site.\"\n ),\n (0, _preact.h)(\n \"div\",\n { className: \"formGroup\" },\n (0, _preact.h)(\n \"label\",\n null,\n (0, _preact.h)(\n \"span\",\n { className: \"visuallyHidden\" },\n \"Enter your Netlify Site URL\"\n ),\n (0, _preact.h)(\"input\", {\n className: \"formControl\",\n type: \"url\",\n name: \"url\",\n value: url,\n placeholder: \"URL of your Netlify site\",\n autocapitalize: \"off\",\n required: true,\n oninput: this.handleInput\n }),\n (0, _preact.h)(\"div\", { className: \"inputFieldIcon inputFieldUrl\" })\n )\n ),\n (0, _preact.h)(\n \"button\",\n { type: \"submit\", className: \"btn\" },\n \"Set site's URL\"\n )\n )\n );\n }\n }]);\n\n return SiteURLForm;\n}(_preact.Component);\n\nexports.default = SiteURLForm;\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _button = __webpack_require__(7);\n\nvar _button2 = _interopRequireDefault(_button);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar LogoutForm = function (_Component) {\n _inherits(LogoutForm, _Component);\n\n function LogoutForm() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, LogoutForm);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = LogoutForm.__proto__ || Object.getPrototypeOf(LogoutForm)).call.apply(_ref, [this].concat(args))), _this), _this.handleLogout = function (e) {\n e.preventDefault();\n _this.props.onLogout();\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _createClass(LogoutForm, [{\n key: \"render\",\n value: function render() {\n var _props = this.props,\n user = _props.user,\n saving = _props.saving;\n\n\n return (0, _preact.h)(\n \"form\",\n {\n onSubmit: this.handleLogout,\n className: \"form \" + (saving ? \"disabled\" : \"\")\n },\n (0, _preact.h)(\n \"p\",\n { className: \"infoText\" },\n \"Logged in as \",\n (0, _preact.h)(\"br\", null),\n (0, _preact.h)(\n \"span\",\n { className: \"infoTextEmail\" },\n user.user_metadata.full_name || user.user_metadata.name || user.email\n )\n ),\n (0, _preact.h)(_button2.default, { saving: saving, text: \"Log out\", saving_text: \"Logging out\" })\n );\n }\n }]);\n\n return LogoutForm;\n}(_preact.Component);\n\nexports.default = LogoutForm;\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _message = __webpack_require__(8);\n\nvar _message2 = _interopRequireDefault(_message);\n\nvar _button = __webpack_require__(7);\n\nvar _button2 = _interopRequireDefault(_button);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar UserForm = function (_Component) {\n _inherits(UserForm, _Component);\n\n function UserForm(props) {\n _classCallCheck(this, UserForm);\n\n var _this = _possibleConstructorReturn(this, (UserForm.__proto__ || Object.getPrototypeOf(UserForm)).call(this, props));\n\n _this.handleInput = function (e) {\n _this.setState(_defineProperty({}, e.target.name, e.target.value));\n };\n\n _this.handleLogin = function (e) {\n e.preventDefault();\n _this.props.onSubmit(_this.state);\n };\n\n _this.state = { name: \"\", email: \"\", password: \"\" };\n return _this;\n }\n\n _createClass(UserForm, [{\n key: \"render\",\n value: function render() {\n var _props = this.props,\n page = _props.page,\n message = _props.message,\n saving = _props.saving,\n namePlaceholder = _props.namePlaceholder;\n var _state = this.state,\n name = _state.name,\n email = _state.email,\n password = _state.password;\n\n\n return (0, _preact.h)(\n \"form\",\n {\n onsubmit: this.handleLogin,\n className: \"form \" + (saving ? \"disabled\" : \"\")\n },\n message && (0, _preact.h)(_message2.default, { type: message }),\n page.name && (0, _preact.h)(\n \"div\",\n { className: \"formGroup\" },\n (0, _preact.h)(\n \"label\",\n null,\n (0, _preact.h)(\n \"span\",\n { className: \"visuallyHidden\" },\n \"Enter your name\"\n ),\n (0, _preact.h)(\"input\", {\n className: \"formControl\",\n type: \"name\",\n name: \"name\",\n value: name,\n placeholder: namePlaceholder ? namePlaceholder : \"Name\",\n autocapitalize: \"off\",\n required: true,\n oninput: this.handleInput\n }),\n (0, _preact.h)(\"div\", { className: \"inputFieldIcon inputFieldName\" })\n )\n ),\n page.email && (0, _preact.h)(\n \"div\",\n { className: \"formGroup\" },\n (0, _preact.h)(\n \"label\",\n null,\n (0, _preact.h)(\n \"span\",\n { className: \"visuallyHidden\" },\n \"Enter your email\"\n ),\n (0, _preact.h)(\"input\", {\n className: \"formControl\",\n type: \"email\",\n name: \"email\",\n value: email,\n placeholder: \"Email\",\n autocapitalize: \"off\",\n required: true,\n oninput: this.handleInput\n }),\n (0, _preact.h)(\"div\", { className: \"inputFieldIcon inputFieldEmail\" })\n )\n ),\n page.password && (0, _preact.h)(\n \"div\",\n { className: \"formGroup\" },\n (0, _preact.h)(\n \"label\",\n null,\n (0, _preact.h)(\n \"span\",\n { className: \"visuallyHidden\" },\n \"Enter your password\"\n ),\n (0, _preact.h)(\"input\", {\n className: \"formControl\",\n type: \"password\",\n name: \"password\",\n value: password,\n placeholder: \"Password\",\n required: true,\n oninput: this.handleInput\n }),\n (0, _preact.h)(\"div\", { className: \"inputFieldIcon inputFieldPassword\" })\n )\n ),\n (0, _preact.h)(_button2.default, {\n saving: saving,\n text: page.button,\n saving_text: page.button_saving\n })\n );\n }\n }]);\n\n return UserForm;\n}(_preact.Component);\n\nexports.default = UserForm;\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Provider = function (_Component) {\n _inherits(Provider, _Component);\n\n function Provider() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, Provider);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Provider.__proto__ || Object.getPrototypeOf(Provider)).call.apply(_ref, [this].concat(args))), _this), _this.handleLogin = function (e) {\n e.preventDefault();\n _this.props.onLogin(_this.props.provider.toLowerCase());\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _createClass(Provider, [{\n key: \"render\",\n value: function render() {\n var _props = this.props,\n provider = _props.provider,\n label = _props.label;\n\n\n return (0, _preact.h)(\n \"button\",\n {\n onClick: this.handleLogin,\n className: \"provider\" + provider + \" btn btnProvider\"\n },\n \"Continue with \",\n label\n );\n }\n }]);\n\n return Provider;\n}(_preact.Component);\n\nvar Providers = function (_Component2) {\n _inherits(Providers, _Component2);\n\n function Providers() {\n _classCallCheck(this, Providers);\n\n return _possibleConstructorReturn(this, (Providers.__proto__ || Object.getPrototypeOf(Providers)).apply(this, arguments));\n }\n\n _createClass(Providers, [{\n key: \"getLabel\",\n value: function getLabel(p) {\n var pId = p.toLowerCase();\n if (pId in this.props.labels) {\n return this.props.labels[pId];\n }\n return p;\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this3 = this;\n\n var _props2 = this.props,\n providers = _props2.providers,\n onLogin = _props2.onLogin;\n\n\n return (0, _preact.h)(\n \"div\",\n { className: \"providersGroup\" },\n (0, _preact.h)(\"hr\", { className: \"hr\" }),\n providers.map(function (p) {\n return (0, _preact.h)(Provider, {\n key: p,\n provider: p,\n label: _this3.getLabel(p),\n onLogin: onLogin\n });\n })\n );\n }\n }]);\n\n return Providers;\n}(_preact.Component);\n\nexports.default = Providers;\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _mobx = __webpack_require__(1);\n\nvar store = (0, _mobx.observable)({\n user: null,\n recovered_user: null,\n message: null,\n settings: null,\n gotrue: null,\n error: null,\n siteURL: null,\n remember: true,\n saving: false,\n invite_token: null,\n email_change_token: null,\n namePlaceholder: null,\n modal: {\n page: \"login\",\n isOpen: false,\n logo: true\n }\n});\n\nstore.setNamePlaceholder = (0, _mobx.action)(function setNamePlaceholder(namePlaceholder) {\n store.namePlaceholder = namePlaceholder;\n});\n\nstore.startAction = (0, _mobx.action)(function startAction() {\n store.saving = true;\n store.error = null;\n store.message = null;\n});\n\nstore.setError = (0, _mobx.action)(function setError(err) {\n store.saving = false;\n store.error = err;\n});\n\nstore.init = (0, _mobx.action)(function init(gotrue, reloadSettings) {\n if (gotrue) {\n store.gotrue = gotrue;\n store.user = gotrue.currentUser();\n if (store.user) {\n store.modal.page = \"user\";\n }\n }\n if (reloadSettings) {\n store.loadSettings();\n }\n});\n\nstore.loadSettings = (0, _mobx.action)(function loadSettings() {\n if (store.settings) {\n return;\n }\n if (!store.gotrue) {\n return;\n }\n\n store.gotrue.settings().then((0, _mobx.action)(function (settings) {\n return store.settings = settings;\n })).catch((0, _mobx.action)(function (err) {\n store.error = new Error(\"Failed to load settings from \" + store.gotrue.api.apiURL);\n }));\n});\n\nstore.setIsLocal = (0, _mobx.action)(function setIsLocal(isLocal) {\n store.isLocal = isLocal;\n});\n\nstore.setSiteURL = (0, _mobx.action)(function setSiteURL(url) {\n store.siteURL = url;\n});\n\nstore.clearSiteURL = (0, _mobx.action)(function clearSiteURL() {\n store.gotrue = null;\n store.siteURL = null;\n store.settings = null;\n});\n\nstore.login = (0, _mobx.action)(function login(email, password) {\n store.startAction();\n return store.gotrue.login(email, password, store.remember).then((0, _mobx.action)(function (user) {\n store.user = user;\n store.modal.page = \"user\";\n store.invite_token = null;\n if (store.email_change_token) {\n store.doEmailChange();\n }\n store.saving = false;\n })).catch(store.setError);\n});\n\nstore.externalLogin = (0, _mobx.action)(function externalLogin(provider) {\n // store.startAction();\n store.error = null;\n store.message = null;\n var url = store.invite_token ? store.gotrue.acceptInviteExternalUrl(provider, store.invite_token) : store.gotrue.loginExternalUrl(provider);\n window.location.href = url;\n});\n\nstore.completeExternalLogin = (0, _mobx.action)(function completeExternalLogin(params) {\n store.startAction();\n store.gotrue.createUser(params, store.remember).then(function (user) {\n store.user = user;\n store.modal.page = \"user\";\n store.saving = false;\n }).catch(store.setError);\n});\n\nstore.signup = (0, _mobx.action)(function signup(name, email, password) {\n store.startAction();\n return store.gotrue.signup(email, password, { full_name: name }).then((0, _mobx.action)(function () {\n if (store.settings.autoconfirm) {\n store.login(email, password, store.remember);\n } else {\n store.message = \"confirm\";\n }\n store.saving = false;\n })).catch(store.setError);\n});\n\nstore.logout = (0, _mobx.action)(function logout() {\n if (store.user) {\n store.startAction();\n return store.user.logout().then((0, _mobx.action)(function () {\n store.user = null;\n store.modal.page = \"login\";\n store.saving = false;\n })).catch(store.setError);\n } else {\n store.modal.page = \"login\";\n store.saving = false;\n }\n});\n\nstore.updatePassword = (0, _mobx.action)(function updatePassword(password) {\n store.startAction();\n var user = store.recovered_user || store.user;\n user.update({ password: password }).then(function (user) {\n store.user = user;\n store.recovered_user = null;\n store.modal.page = \"user\";\n store.saving = false;\n }).catch(store.setError);\n});\n\nstore.acceptInvite = (0, _mobx.action)(function acceptInvite(password) {\n store.startAction();\n store.gotrue.acceptInvite(store.invite_token, password, store.remember).then(function (user) {\n store.saving = false;\n store.invite_token = null;\n store.user = user;\n store.modal.page = \"user\";\n }).catch(store.setError);\n});\n\nstore.doEmailChange = (0, _mobx.action)(function doEmailChange() {\n store.startAction();\n return store.user.update({ email_change_token: store.email_change_token }).then((0, _mobx.action)(function (user) {\n store.user = user;\n store.email_change_token = null;\n store.message = \"email_changed\";\n store.saving = false;\n })).catch(store.setError);\n});\n\nstore.verifyToken = (0, _mobx.action)(function verifyToken(type, token) {\n var gotrue = store.gotrue;\n store.modal.isOpen = true;\n\n switch (type) {\n case \"confirmation\":\n store.startAction();\n store.modal.page = \"signup\";\n gotrue.confirm(token, store.remember).then((0, _mobx.action)(function (user) {\n store.user = user;\n store.saving = false;\n })).catch((0, _mobx.action)(function (err) {\n console.error(err);\n store.message = \"verfication_error\";\n store.modal.page = \"signup\";\n store.saving = false;\n }));\n break;\n case \"email_change\":\n store.email_change_token = token;\n store.modal.page = \"message\";\n if (store.user) {\n store.doEmailChange();\n } else {\n store.modal.page = \"login\";\n }\n break;\n case \"invite\":\n store.modal.page = type;\n store.invite_token = token;\n break;\n case \"recovery\":\n store.startAction();\n store.modal.page = type;\n store.gotrue.recover(token, store.remember).then(function (user) {\n store.saving = false;\n store.recovered_user = user;\n }).catch(function (err) {\n store.saving = false;\n store.error = err;\n store.modal.page = \"login\";\n });\n break;\n default:\n store.error = \"Unkown token type\";\n }\n});\n\nstore.requestPasswordRecovery = (0, _mobx.action)(function requestPasswordRecovery(email) {\n store.startAction();\n store.gotrue.requestPasswordRecovery(email).then((0, _mobx.action)(function () {\n store.message = \"password_mail\";\n store.saving = false;\n })).catch(store.setError);\n});\n\nstore.openModal = (0, _mobx.action)(function open(page) {\n store.modal.page = page;\n store.modal.isOpen = true;\n});\n\nstore.closeModal = (0, _mobx.action)(function close() {\n store.modal.isOpen = false;\n store.error = null;\n store.message = null;\n store.saving = false;\n});\n\nexports.default = store;\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _dec, _class;\n\nvar _preact = __webpack_require__(0);\n\nvar _mobxPreact = __webpack_require__(2);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Controls = (_dec = (0, _mobxPreact.connect)([\"store\"]), _dec(_class = function (_Component) {\n _inherits(Controls, _Component);\n\n function Controls() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, Controls);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Controls.__proto__ || Object.getPrototypeOf(Controls)).call.apply(_ref, [this].concat(args))), _this), _this.handleSignup = function (e) {\n e.preventDefault();\n _this.props.store.openModal(\"signup\");\n }, _this.handleLogin = function (e) {\n e.preventDefault();\n _this.props.store.openModal(\"login\");\n }, _this.handleLogout = function (e) {\n e.preventDefault();\n _this.props.store.openModal(\"user\");\n }, _this.handleButton = function (e) {\n e.preventDefault();\n _this.props.store.openModal(_this.props.store.user ? \"user\" : \"login\");\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n _createClass(Controls, [{\n key: \"render\",\n value: function render() {\n var user = this.props.store.user;\n\n\n if (this.props.mode === \"button\") {\n return (0, _preact.h)(\n \"a\",\n {\n className: \"netlify-identity-button\",\n href: \"#\",\n onClick: this.handleButton\n },\n this.props.text || (user ? \"Log out\" : \"Log in\")\n );\n }\n\n if (user) {\n return (0, _preact.h)(\n \"ul\",\n { className: \"netlify-identity-menu\" },\n (0, _preact.h)(\n \"li\",\n { className: \"netlify-identity-item netlify-identity-user-details\" },\n \"Logged in as\",\n \" \",\n (0, _preact.h)(\n \"span\",\n { className: \"netlify-identity-user\" },\n user.user_metadata.name || user.email\n )\n ),\n (0, _preact.h)(\n \"li\",\n { className: \"netlify-identity-item\" },\n (0, _preact.h)(\n \"a\",\n {\n className: \"netlify-identity-logout\",\n href: \"#\",\n onClick: this.handleLogout\n },\n \"Log out\"\n )\n )\n );\n }\n\n return (0, _preact.h)(\n \"ul\",\n { className: \"netlify-identity-menu\" },\n (0, _preact.h)(\n \"li\",\n { className: \"netlify-identity-item\" },\n (0, _preact.h)(\n \"a\",\n {\n className: \"netlify-identity-signup\",\n href: \"#\",\n onClick: this.handleSignup\n },\n \"Sign up\"\n )\n ),\n (0, _preact.h)(\n \"li\",\n { className: \"netlify-identity-item\" },\n (0, _preact.h)(\n \"a\",\n {\n className: \"netlify-identity-login\",\n href: \"#\",\n onClick: this.handleLogin\n },\n \"Log in\"\n )\n )\n );\n }\n }]);\n\n return Controls;\n}(_preact.Component)) || _class);\nexports.default = Controls;\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\nexports = module.exports = __webpack_require__(28)(false);\n// imports\n\n\n// module\nexports.push([module.i, \"::-webkit-input-placeholder {\\n /* Chrome/Opera/Safari */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n::-moz-placeholder {\\n /* Firefox 19+ */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n:-ms-input-placeholder {\\n /* IE 10+ */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n:-moz-placeholder {\\n /* Firefox 18- */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n.modalContainer {\\n position: absolute;\\n top: 0;\\n left: 0;\\n width: 100%;\\n min-height: 100%;\\n overflow-x: hidden;\\n overflow-y: auto;\\n -webkit-box-sizing: border-box;\\n box-sizing: border-box;\\n font-family: -apple-system, BlinkMacSystemFont, \\\"Segoe UI\\\", Roboto, Helvetica,\\n Arial, sans-serif, \\\"Apple Color Emoji\\\", \\\"Segoe UI Emoji\\\", \\\"Segoe UI Symbol\\\";\\n font-size: 14px;\\n line-height: 1.5;\\n display: -webkit-box;\\n display: -ms-flexbox;\\n display: flex;\\n -webkit-box-orient: vertical;\\n -webkit-box-direction: normal;\\n -ms-flex-direction: column;\\n flex-direction: column;\\n -webkit-box-align: center;\\n -ms-flex-align: center;\\n align-items: center;\\n z-index: 99999;\\n}\\n\\n.modalContainer::before {\\n content: \\\"\\\";\\n display: block;\\n position: fixed;\\n top: 0;\\n bottom: 0;\\n left: 0;\\n right: 0;\\n background-color: #fff;\\n z-index: -1;\\n}\\n\\n.modalDialog {\\n -webkit-box-flex: 1;\\n -ms-flex-positive: 1;\\n flex-grow: 1;\\n display: -webkit-box;\\n display: -ms-flexbox;\\n display: flex;\\n -webkit-box-orient: vertical;\\n -webkit-box-direction: normal;\\n -ms-flex-direction: column;\\n flex-direction: column;\\n width: 100%;\\n}\\n\\n.modalContent {\\n position: relative;\\n padding: 32px;\\n opacity: 0;\\n -webkit-transform: translateY(10px) scale(1);\\n transform: translateY(10px) scale(1);\\n background: #fff;\\n}\\n\\n[aria-hidden=\\\"false\\\"] .modalContent {\\n -webkit-animation: bouncyEntrance 0.2s cubic-bezier(0.18, 0.89, 0.32, 1.28);\\n animation: bouncyEntrance 0.2s cubic-bezier(0.18, 0.89, 0.32, 1.28);\\n -webkit-animation-fill-mode: forwards;\\n animation-fill-mode: forwards;\\n }\\n\\n@-webkit-keyframes bouncyEntrance {\\n 0% {\\n opacity: 0;\\n -webkit-transform: translateY(10px) scale(0.9);\\n transform: translateY(10px) scale(0.9);\\n }\\n\\n 100% {\\n opacity: 1;\\n -webkit-transform: translateY(0) scale(1);\\n transform: translateY(0) scale(1);\\n }\\n}\\n\\n@keyframes bouncyEntrance {\\n 0% {\\n opacity: 0;\\n -webkit-transform: translateY(10px) scale(0.9);\\n transform: translateY(10px) scale(0.9);\\n }\\n\\n 100% {\\n opacity: 1;\\n -webkit-transform: translateY(0) scale(1);\\n transform: translateY(0) scale(1);\\n }\\n}\\n\\n@media (min-width: 480px) {\\n .modalContainer::before {\\n background-color: rgb(14, 30, 37);\\n -webkit-animation: fadeIn 0.1s ease-in;\\n animation: fadeIn 0.1s ease-in;\\n -webkit-animation-fill-mode: forwards;\\n animation-fill-mode: forwards;\\n }\\n\\n .modalDialog {\\n max-width: 364px;\\n -webkit-box-pack: center;\\n -ms-flex-pack: center;\\n justify-content: center;\\n }\\n\\n .modalContent {\\n background: #fff;\\n -webkit-box-shadow: 0 4px 12px 0 rgba(0, 0, 0, .07),\\n 0 12px 32px 0 rgba(14, 30, 37, .1);\\n box-shadow: 0 4px 12px 0 rgba(0, 0, 0, .07),\\n 0 12px 32px 0 rgba(14, 30, 37, .1);\\n border-radius: 8px;\\n margin-top: 32px;\\n }\\n}\\n\\n@-webkit-keyframes fadeIn {\\n 0% {\\n opacity: 0;\\n }\\n\\n 100% {\\n opacity: 0.67;\\n }\\n}\\n\\n@keyframes fadeIn {\\n 0% {\\n opacity: 0;\\n }\\n\\n 100% {\\n opacity: 0.67;\\n }\\n}\\n\\n.flashMessage {\\n text-align: center;\\n color: rgb(14, 30, 37);\\n font-weight: 500;\\n font-size: 14px;\\n background-color: #f2f3f3;\\n padding: 6px;\\n border-radius: 4px;\\n opacity: 0.7;\\n -webkit-transition: opacity 0.2s linear;\\n transition: opacity 0.2s linear;\\n}\\n\\n.flashMessage:hover,\\n.flashMessage:focus {\\n opacity: 1;\\n}\\n\\n.error {\\n color: #fa3946;\\n background-color: #fceef0;\\n opacity: 1;\\n}\\n\\n.error span::before {\\n content: \\\"\\\";\\n display: inline-block;\\n position: relative;\\n top: 3px;\\n margin-right: 4px;\\n width: 16px;\\n height: 16px;\\n background: no-repeat center center;\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgdmlld0JveD0iMCAwIDE2IDE2Ij4KICA8cGF0aCBmaWxsPSIjRkEzOTQ2IiBkPSJNOCwxLjMzMzMzMzMzIEMxMS42NzYsMS4zMzMzMzMzMyAxNC42NjY2NjY3LDQuMzI0IDE0LjY2NjY2NjcsOCBDMTQuNjY2NjY2NywxMS42NzYgMTEuNjc2LDE0LjY2NjY2NjcgOCwxNC42NjY2NjY3IEM0LjMyNCwxNC42NjY2NjY3IDEuMzMzMzMzMzMsMTEuNjc2IDEuMzMzMzMzMzMsOCBDMS4zMzMzMzMzMyw0LjMyNCA0LjMyNCwxLjMzMzMzMzMzIDgsMS4zMzMzMzMzMyBaIE04LDAgQzMuNTgyLDAgMCwzLjU4MiAwLDggQzAsMTIuNDE4IDMuNTgyLDE2IDgsMTYgQzEyLjQxOCwxNiAxNiwxMi40MTggMTYsOCBDMTYsMy41ODIgMTIuNDE4LDAgOCwwIFogTTcuMTI2NjY2NjcsNS4wMTczMzMzMyBDNy4wNjA2NjY2Nyw0LjQ3OTMzMzMzIDcuNDc4NjY2NjcsNCA4LjAyNTMzMzMzLDQgQzguNTM5MzMzMzMsNCA4Ljk0MzMzMzMzLDQuNDUwNjY2NjcgOC44Nzg2NjY2Nyw0Ljk2NzMzMzMzIEw4LjM3NCw5LjAwMjY2NjY3IEM4LjM1MDY2NjY3LDkuMTkxMzMzMzMgOC4xOSw5LjMzMzMzMzMzIDgsOS4zMzMzMzMzMyBDNy44MSw5LjMzMzMzMzMzIDcuNjQ5MzMzMzMsOS4xOTEzMzMzMyA3LjYyNTMzMzMzLDkuMDAyNjY2NjcgTDcuMTI2NjY2NjcsNS4wMTczMzMzMyBMNy4xMjY2NjY2Nyw1LjAxNzMzMzMzIFogTTgsMTIuMTY2NjY2NyBDNy41NCwxMi4xNjY2NjY3IDcuMTY2NjY2NjcsMTEuNzkzMzMzMyA3LjE2NjY2NjY3LDExLjMzMzMzMzMgQzcuMTY2NjY2NjcsMTAuODczMzMzMyA3LjU0LDEwLjUgOCwxMC41IEM4LjQ2LDEwLjUgOC44MzMzMzMzMywxMC44NzMzMzMzIDguODMzMzMzMzMsMTEuMzMzMzMzMyBDOC44MzMzMzMzMywxMS43OTMzMzMzIDguNDYsMTIuMTY2NjY2NyA4LDEyLjE2NjY2NjcgWiIvPgo8L3N2Zz4K);\\n}\\n\\n.success {\\n}\\n\\n.disabled {\\n opacity: 0.38;\\n pointer-events: none;\\n}\\n\\n.infoText {\\n text-align: center;\\n margin: 32px 0;\\n}\\n\\n.infoTextEmail {\\n font-size: 16px;\\n font-weight: 500;\\n}\\n\\n.saving {\\n background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABQCAMAAACeYYN3AAAAxlBMVEUAAAD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////DTx3aAAAAQnRSTlMAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEGgjKRfAAACk0lEQVR4AYXQDXP5WhAG8CUhiSQqSv4RRRMVL1Fa1VZf3PL9v9Tde9wc9M8+P8/M7s6czJiHgNIvVCJO6YiAMlAiWckASiQrm4bJMZTDrmbBIEC9qpgVjp6n4B+oyEwCzKrMQBVaQIlkpmXZln1dhQB+49gOh5dLexlV6MhsAqyazEQVugCqsOK5nsQmwPWZ53ucvyczSGb4l9T9OsdnLgFOXVZFFd4AqEKrIasR4AdBI2hw1GR6VzMwSWY2A60ZNDl6KnUC3KbMRhXeAqhCpyXzCAjarNVucdqXVEhWaRfCdsj5vQcE1EOZQ7Jy+EcUlklWi2Q3BLQ6nagTcTra2Y0qrHZirRN3OOezTUAjvq4bd7suqpDfSGJUoXcnCwiIerIqqlC96vf6HD1ZsUcE3PYH/QGnrx3uYnqoQn4l6aMK/XtZi4BuIrNIZqVJkiapkhx37Y6AcDgcpsNU44Nz3OuoQn4jSVGFNw+ykID+SGaTzM5G2YiTFVM73AMConE2zjhj7XAXs4EqHE/4d12GKgwmsoiAZCpzSObMptPZdHZVSkCc5/ksnym8cPRUmiQzpvNcmedzTl4o7qlBsuZc1iVg9ChDFdYWshEBveV/FssFZ/l7Z7eowsfl0/JJ4UXj43A/ogpbT7IeAZNnWQ1VuJJNCBi8HKxeVhw9tRaq8JkfrV/WHDULxb1CFbbX7HX9yllfck9A/ipzSea+yeYEJO+yEFX4tim8b94VXjj/zzdU4Z/NmY/NB+fkTglYfMg8knmfsiUBD1+yCFX4+X309f3FOds/UYVR8fH2e6vwovExIuB5K/NJ5v8jWxGQ/chiVOF2d+pn98M5zt3WJFm83+/2O4UXjprabkzAWn+o56k9qvBfX4hMaM+SxOMAAAAASUVORK5CYII=);\\n background-repeat: repeat-x;\\n background-size: contain;\\n background-origin: border-box;\\n background-position: 0% 0%;\\n -webkit-animation: loading 20s linear infinite;\\n animation: loading 20s linear infinite;\\n pointer-events: none;\\n}\\n\\n.saving::after {\\n content: \\\"\\\\2026\\\";\\n}\\n\\n@-webkit-keyframes loading {\\n 0% {\\n background-position: 0% 0%;\\n }\\n\\n 100% {\\n background-position: 700% 0%;\\n }\\n}\\n\\n@keyframes loading {\\n 0% {\\n background-position: 0% 0%;\\n }\\n\\n 100% {\\n background-position: 700% 0%;\\n }\\n}\\n\\n.btn {\\n display: block;\\n position: relative;\\n width: 100%;\\n height: auto;\\n margin: 14px 0 0;\\n padding: 6px;\\n outline: 0;\\n cursor: pointer;\\n border: 2px solid rgb(14, 30, 37);\\n border-radius: 4px;\\n background-color: #2d3b41;\\n color: #fff;\\n -webkit-transition: background-color 0.2s ease;\\n transition: background-color 0.2s ease;\\n font-family: -apple-system, BlinkMacSystemFont, \\\"Segoe UI\\\", Roboto, Helvetica,\\n Arial, sans-serif, \\\"Apple Color Emoji\\\", \\\"Segoe UI Emoji\\\", \\\"Segoe UI Symbol\\\";\\n font-size: 14px;\\n font-weight: 500;\\n line-height: 24px;\\n text-align: center;\\n text-decoration: none;\\n white-space: nowrap;\\n}\\n\\n.btn:hover,\\n.btn:focus {\\n background-color: rgb(14, 30, 37);\\n text-decoration: none;\\n}\\n\\n.btnClose {\\n position: absolute;\\n top: 0;\\n right: 0;\\n margin: 0;\\n padding: 0;\\n border: 0;\\n width: 24px;\\n height: 24px;\\n border-radius: 50%;\\n margin: 6px;\\n background: #fff;\\n color: #a3a9ac;\\n}\\n\\n.btnClose::before {\\n content: \\\"\\\\D7\\\";\\n font-size: 25px;\\n line-height: 9px;\\n}\\n\\n.btnClose:hover,\\n.btnClose:focus {\\n background: #e9ebeb;\\n color: rgb(14, 30, 37);\\n}\\n\\n.header {\\n display: -webkit-box;\\n display: -ms-flexbox;\\n display: flex;\\n margin-top: -8px;\\n margin-bottom: 32px;\\n}\\n\\n.btnHeader {\\n font-size: 16px;\\n line-height: 24px;\\n background: #fff;\\n color: #a3a9ac;\\n border: 0;\\n border-bottom: 2px solid #e9ebeb;\\n border-radius: 4px 4px 0 0;\\n margin: 0;\\n}\\n\\n.btnHeader:focus,\\n.btnHeader.active {\\n background: #fff;\\n color: rgb(14, 30, 37);\\n border-color: rgb(14, 30, 37);\\n font-weight: 700;\\n}\\n\\n.btnHeader:not(:only-child):hover {\\n background-color: #e9ebeb;\\n color: rgb(14, 30, 37);\\n}\\n\\n.btnHeader:only-child {\\n cursor: auto;\\n}\\n\\n.btnLink {\\n display: block;\\n position: relative;\\n width: auto;\\n height: auto;\\n margin: 14px auto 0;\\n padding: 6px;\\n padding-bottom: 0;\\n outline: 0;\\n cursor: pointer;\\n color: rgb(14, 30, 37);\\n border: none;\\n border-bottom: 2px solid #e9ebeb;\\n border-radius: 0;\\n background-color: inherit;\\n -webkit-transition: border-color 0.2s ease;\\n transition: border-color 0.2s ease;\\n font-family: -apple-system, BlinkMacSystemFont, \\\"Segoe UI\\\", Roboto, Helvetica,\\n Arial, sans-serif, \\\"Apple Color Emoji\\\", \\\"Segoe UI Emoji\\\", \\\"Segoe UI Symbol\\\";\\n font-size: 14px;\\n font-weight: 500;\\n line-height: 24px;\\n text-align: center;\\n white-space: nowrap;\\n}\\n\\n.btnLink:hover,\\n.btnLink:focus {\\n background-color: inherit;\\n border-color: #a3a9ac;\\n}\\n\\n.form {\\n}\\n\\n.formGroup {\\n position: relative;\\n margin-top: 14px;\\n}\\n\\n.formControl {\\n -webkit-box-sizing: border-box;\\n box-sizing: border-box;\\n display: block;\\n width: 100%;\\n height: 40px;\\n margin: 0;\\n padding: 6px 12px 6px 34px;\\n border: 2px solid #e9ebeb;\\n border-radius: 4px;\\n background: #fff;\\n color: rgb(14, 30, 37);\\n -webkit-box-shadow: none;\\n box-shadow: none;\\n font-size: 14px;\\n font-weight: 500;\\n line-height: 24px;\\n -webkit-transition: -webkit-box-shadow ease-in-out 0.15s;\\n transition: -webkit-box-shadow ease-in-out 0.15s;\\n transition: box-shadow ease-in-out 0.15s;\\n transition: box-shadow ease-in-out 0.15s, -webkit-box-shadow ease-in-out 0.15s;\\n -webkit-appearance: none;\\n -moz-appearance: none;\\n}\\n\\n.inputFieldIcon {\\n position: absolute;\\n top: 12px;\\n left: 12px;\\n display: inline-block;\\n width: 16px;\\n height: 16px;\\n background-repeat: no-repeat;\\n background-position: center;\\n pointer-events: none;\\n}\\n\\n.inputFieldName {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMCAwIDE0IDE0Ij4gIDxwYXRoIGZpbGw9IiNBM0E5QUMiIGZpbGwtcnVsZT0iZXZlbm9kZCIgZD0iTTgsNyBDNi4zNDMxNDU3NSw3IDUsNS42NTY4NTQyNSA1LDQgQzUsMi4zNDMxNDU3NSA2LjM0MzE0NTc1LDEgOCwxIEM5LjY1Njg1NDI1LDEgMTEsMi4zNDMxNDU3NSAxMSw0IEMxMSw1LjY1Njg1NDI1IDkuNjU2ODU0MjUsNyA4LDcgWiBNOCwxNSBMMS41LDE1IEMxLjUsMTEuMTM0MDA2OCA0LjQxMDE0OTEzLDggOCw4IEMxMS41ODk4NTA5LDggMTQuNSwxMS4xMzQwMDY4IDE0LjUsMTUgTDgsMTUgWiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEgLTEpIi8+PC9zdmc+);\\n}\\n\\n.inputFieldEmail {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxMSIgdmlld0JveD0iMCAwIDE2IDExIj4gIDxwYXRoIGZpbGw9IiNBM0E5QUMiIGQ9Ik0xLjE3MDczMTcxLDMgQzAuNTIyMTQ2MzQxLDMgMy45MDI0NTk4N2UtMDgsMy41NDUxMTA4MSAzLjkwMjQ1OTg3ZS0wOCw0LjIyMjIyMTU0IEwzLjkwMjQ1OTg3ZS0wOCwxMi43Nzc3Nzg1IEMzLjkwMjQ1OTg3ZS0wOCwxMy40NTQ4ODkyIDAuNTIyMTQ2MzQxLDE0IDEuMTcwNzMxNzEsMTQgTDE0LjgyOTI2ODMsMTQgQzE1LjQ3Nzg1MzcsMTQgMTYsMTMuNDU0ODg5MiAxNiwxMi43Nzc3Nzg1IEwxNiw0LjIyMjIyMTU0IEMxNiwzLjU0NTExMDgxIDE1LjQ3Nzg1MzcsMyAxNC44MjkyNjgzLDMgTDEuMTcwNzMxNzEsMyBaIE0yLjMzNzQyMTE5LDUuMDAxODY1NjYgQzIuNDU3NTExNzUsNC45ODk1NTIxNCAyLjU2MDcxNDU3LDUuMDM5MzM5OCAyLjYzNjM1OTg1LDUuMTE3Mjg0MzcgTDcuNDgyNjA2MTcsMTAuMTEzMjU0NSBDNy43ODQ0ODgyMiwxMC40MjQ3NDU1IDguMjAzMjc4MjksMTAuNDI0NzY2IDguNTA1ODk2MTksMTAuMTEzMjU0NSBMMTMuMzYzNjQwMiw1LjExNzI4NDM3IEMxMy41MDUxMjU1LDQuOTcxMjA0OTkgMTMuNzUyOTc3OSw0Ljk4MTg5NzIzIDEzLjg4MzkyMjIsNS4xMzk3MzYwMiBDMTQuMDE0ODY2NSw1LjI5NzU3NDgxIDE0LjAwNTI4MjEsNS41NzQwNzQ4OCAxMy44NjM3OTY3LDUuNzIwMTU0MjYgTDExLjExNTg2MDYsOC41NDg0MTE1MiBMMTMuODU4MDU3MSwxMS4yNjc2NDY5IEMxNC4wMjE3ODM1LDExLjQwMzE5ODIgMTQuMDQ4OTM2MywxMS43MDE0OTMyIDEzLjkxMjk4ODIsMTEuODcwOTg4OCBDMTMuNzc3MDQwMSwxMi4wNDA1MDQ5IDEzLjUwODI4OTcsMTIuMDQzNDE5MSAxMy4zNjkzOTgyLDExLjg3Njk0MDQgTDEwLjU3NTQ3MTUsOS4xMDYzOTg2MiBMOS4wMDYwNTI3NSwxMC43MTYxMjQ0IEM4LjQzNDk0MTk1LDExLjMwNDAzMzQgNy41NTMzMDI4NiwxMS4zMDUxNjIxIDYuOTgyNDY4LDEwLjcxNjEyNDQgTDUuNDI0NTI4NSw5LjEwNjM5ODYyIEwyLjYzMDYwMTgzLDExLjg3Njk0MDQgQzIuNDkxNzEwMzMsMTIuMDQzNDM5NyAyLjIyMjk1OTg4LDEyLjA0MDUyNTUgMi4wODcwMTE3OCwxMS44NzA5ODg4IEMxLjk1MTA2MzY3LDExLjcwMTQ5MzIgMS45NzgyMTY1LDExLjQwMzE5ODIgMi4xNDE5NDI5LDExLjI2NzY0NjkgTDQuODg0MTM5MzksOC41NDg0MTE1MiBMMi4xMzYyMDMyOCw1LjcyMDE1NDI2IEMyLjAyODcxNDE0LDUuNjE2MjI4MTYgMS45ODM1NTE0MSw1LjQzODk1NDUzIDIuMDI1OTkxNSw1LjI4NzQ5ODI1IEMyLjA2ODQxMzE5LDUuMTM2MDYyNDkgMi4xOTYwMjc4MSw1LjAxOTAyMjQ5IDIuMzM3NDIxMTksNS4wMDE4NjU2NiBaIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0zKSIvPjwvc3ZnPg==);\\n}\\n\\n.inputFieldPassword {\\n background-image: url(data:image/svg+xml;base64,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);\\n}\\n\\n.inputFieldUrl {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMCAwIDE0IDE0Ij4gIDxwYXRoIGZpbGw9IiNBM0E5QUMiIGQ9Ik0xMCw1IEMxMCwzLjg5NTQzMDUgOS4xMDQ1Njk1LDMgOCwzIEM2Ljg5NTQzMDUsMyA2LDMuODk1NDMwNSA2LDUgTTQsMTAgTDQsMTEgTDYsMTEgTDYsMTAgQzYsOS40NDc3MTUyNSA1LjU1MjI4NDc1LDkgNSw5IEM0LjQ0NzcxNTI1LDkgNCw5LjQ0NzcxNTI1IDQsMTAgWiBNMTIsMTAgQzEyLDkuNDQ3NzE1MjUgMTEuNTUyMjg0Nyw5IDExLDkgQzEwLjQ0NzcxNTMsOSAxMCw5LjQ0NzcxNTI1IDEwLDEwIEwxMCwxMSBMMTIsMTEgTDEyLDEwIFogTTYsNiBMNiw1IEw0LDUgTDQsNiBDNCw2LjU1MjI4NDc1IDQuNDQ3NzE1MjUsNyA1LDcgQzUuNTUyMjg0NzUsNyA2LDYuNTUyMjg0NzUgNiw2IFogTTEwLDYgQzEwLDYuNTUyMjg0NzUgMTAuNDQ3NzE1Myw3IDExLDcgQzExLjU1MjI4NDcsNyAxMiw2LjU1MjI4NDc1IDEyLDYgTDEyLDUgTDEwLDUgTDEwLDYgWiBNNCw1IEM0LDIuNzkwODYxIDUuNzkwODYxLDEgOCwxIEMxMC4yMDkxMzksMSAxMiwyLjc5MDg2MSAxMiw1IEw0LDUgWiBNNCwxMSBMMTIsMTEgQzEyLDEzLjIwOTEzOSAxMC4yMDkxMzksMTUgOCwxNSBDNS43OTA4NjEsMTUgNCwxMy4yMDkxMzkgNCwxMSBaIE0xMCwxMSBMNiwxMSBDNiwxMi4xMDQ1Njk1IDYuODk1NDMwNSwxMyA4LDEzIEM5LjEwNDU2OTUsMTMgMTAsMTIuMTA0NTY5NSAxMCwxMSBaIE04LDExIEM3LjQ0NzcxNTI1LDExIDcsMTAuNTUyMjg0NyA3LDEwIEw3LDYgQzcsNS40NDc3MTUyNSA3LjQ0NzcxNTI1LDUgOCw1IEM4LjU1MjI4NDc1LDUgOSw1LjQ0NzcxNTI1IDksNiBMOSwxMCBDOSwxMC41NTIyODQ3IDguNTUyMjg0NzUsMTEgOCwxMSBaIiB0cmFuc2Zvcm09InJvdGF0ZSg0NSA4LjcwNyA2LjI5MykiLz48L3N2Zz4=);\\n}\\n\\n.formLabel {\\n}\\n\\n.hr {\\n border: 0;\\n border-top: 2px solid #e9ebeb;\\n margin: 32px 0 -1px;\\n text-align: center;\\n overflow: visible;\\n}\\n\\n.hr::before {\\n content: \\\"or\\\";\\n position: relative;\\n display: inline-block;\\n font-size: 12px;\\n font-weight: 800;\\n line-height: 1;\\n text-transform: uppercase;\\n background-color: #fff;\\n color: rgb(14, 30, 37);\\n padding: 4px;\\n top: -11px;\\n}\\n\\n.btnProvider {\\n padding-left: 40px;\\n padding-right: 40px;\\n}\\n\\n.btnProvider::before {\\n content: \\\"\\\";\\n position: absolute;\\n display: inline-block;\\n vertical-align: middle;\\n width: 32px;\\n height: 40px;\\n background-repeat: no-repeat;\\n background-position: left center;\\n top: -2px;\\n left: 14px;\\n}\\n\\n.providerGoogle {\\n background-color: #4285f4;\\n border-color: #366dc7;\\n}\\n\\n.providerGoogle:hover,\\n.providerGoogle:focus {\\n background-color: #366dc7;\\n}\\n\\n.providerGitHub {\\n background-color: #333;\\n border-color: #000;\\n}\\n\\n.providerGitHub:hover,\\n.providerGitHub:focus {\\n background-color: #000;\\n}\\n\\n.providerGitLab {\\n background-color: #e24329;\\n border-color: #b03320;\\n}\\n\\n.providerGitLab:hover,\\n.providerGitLab:focus {\\n background-color: #b03320;\\n}\\n\\n.providerBitbucket {\\n background-color: #205081;\\n border-color: #14314f;\\n}\\n\\n.providerBitbucket:hover,\\n.providerBitbucket:focus {\\n background-color: #14314f;\\n}\\n\\n.providerGoogle:before {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMyIgaGVpZ2h0PSIxMiIgdmlld0JveD0iMCAwIDEzIDEyIj4gIDxnIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEuNDg4IC0yKSI+ICAgIDxyZWN0IHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIvPiAgICA8cGF0aCBmaWxsPSIjRkZGRkZGIiBmaWxsLXJ1bGU9Im5vbnplcm8iIGQ9Ik0wLjY1MjczNDM3NSwzLjI5NTI4MjQ0IEMwLjIzNzk4NDM3NSw0LjEwNTgzMjA2IDIuODQyMTcwOTRlLTE0LDUuMDE2MDQ1OCAyLjg0MjE3MDk0ZS0xNCw1Ljk3OTM4OTMxIEMyLjg0MjE3MDk0ZS0xNCw2Ljk0MjczMjgyIDAuMjM3OTg0Mzc1LDcuODUyOTAwNzYgMC42NTI3MzQzNzUsOC42NjM0NTAzOCBDMS42NTkwNDY4NywxMC42MTY3MDIzIDMuNzI2MDkzNzUsMTEuOTU4Nzc4NiA2LjExOTUzMTI1LDExLjk1ODc3ODYgQzcuNzcxNzgxMjUsMTEuOTU4Nzc4NiA5LjE1ODg1OTM3LDExLjQyNzI1MTkgMTAuMTcyMDE1NiwxMC41MTA0NDI3IEMxMS4zMjc5MDYyLDkuNDY3MzU4NzggMTEuOTk0MjgxMiw3LjkzMjY0MTIyIDExLjk5NDI4MTIsNi4xMTIyNTk1NCBDMTEuOTk0MjgxMiw1LjYyMDYyNTk1IDExLjk1MzQ1MzEsNS4yNjE4NjI2IDExLjg2NTA5MzcsNC44ODk4MTY3OSBMNi4xMTk1MzEyNSw0Ljg4OTgxNjc5IEw2LjExOTUzMTI1LDcuMTA4ODA5MTYgTDkuNDkyMDQ2ODcsNy4xMDg4MDkxNiBDOS40MjQwNzgxMiw3LjY2MDI1OTU0IDkuMDU2OTA2MjUsOC40OTA3MzI4MiA4LjI0MDk1MzEyLDkuMDQ4Nzc4NjMgQzcuNzI0MjAzMTIsOS40MDA5MDA3NiA3LjAzMDY0MDYyLDkuNjQ2NzE3NTYgNi4xMTk1MzEyNSw5LjY0NjcxNzU2IEM0LjUwMTI2NTYyLDkuNjQ2NzE3NTYgMy4xMjc3ODEyNSw4LjYwMzY3OTM5IDIuNjM4MTcxODcsNy4xNjE5ODQ3MyBMMi42Mjg3MTIwNSw3LjE2Mjc2OTU5IEMyLjUwNTM0MTU4LDYuNzk3Mjk0NjggMi40MzQyMTg3NSw2LjM4MTEyMjg1IDIuNDM0MjE4NzUsNS45NzkzODkzMSBDMi40MzQyMTg3NSw1LjU2NzQ1MDM4IDIuNTA4OTg0MzgsNS4xNjg4Mzk2OSAyLjYzMTM3NSw0Ljc5Njc5Mzg5IEMzLjEyNzc4MTI1LDMuMzU1MDk5MjQgNC41MDEyNjU2MiwyLjMxMjAxNTI3IDYuMTE5NTMxMjUsMi4zMTIwMTUyNyBDNy4yNjg2MjUsMi4zMTIwMTUyNyA4LjA0Mzc1LDIuNzk3MDA3NjMgOC40ODU3MzQzNywzLjIwMjMwNTM0IEwxMC4yMTI3OTY5LDEuNTU0NjQxMjIgQzkuMTUyMTA5MzcsMC41OTEyOTc3MSA3Ljc3MTc4MTI1LDguODgxNzg0MmUtMTYgNi4xMTk1MzEyNSw4Ljg4MTc4NDJlLTE2IEMzLjcyNjA5Mzc1LDguODgxNzg0MmUtMTYgMS42NTkwNDY4NywxLjM0MjAzMDUzIDAuNjUyNzM0Mzc1LDMuMjk1MjgyNDQgTDAuNjUyNzM0Mzc1LDMuMjk1MjgyNDQgWiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMiAyKSIvPiAgPC9nPjwvc3ZnPg==);\\n}\\n\\n.providerGitHub:before {\\n background-image: url(data:image/svg+xml;base64,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);\\n}\\n\\n.providerGitLab:before {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxMyIgdmlld0JveD0iMCAwIDE0IDEzIj4gIDxnIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEgLTIpIj4gICAgPHJlY3Qgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+ICAgIDxwYXRoIGZpbGw9IiNGRkZGRkYiIGZpbGwtcnVsZT0ibm9uemVybyIgZD0iTTcuMDA0MDkzMzYsMTIuOTQ5MjQzMyBMNC40MjgwOTMzMyw0Ljk5NzI4MjU0IEw5LjU4MDA5MzM2LDQuOTk3MjgyNTQgTDcuMDA0MDkzMzYsMTIuOTQ5MjQzMyBaIE03LjAwNDA5MzM2LDEyLjk0OTIzIEwwLjgxNzg5MzMzMyw0Ljk5NzI2OTE3IEw0LjQyODA5MzMzLDQuOTk3MjY5MTcgTDcuMDA0MDkzMzYsMTIuOTQ5MjMgWiBNMC44MTc4OTk5OTksNC45OTcyODkyMyBMNy4wMDQwOTk5OCwxMi45NDkyNSBMMC4yMjg4MzMzMzMsOC4wMTE4ODA4IEMwLjA0MTksNy44NzU2NzE1MiAtMC4wMzYzLDcuNjM0MjEyNyAwLjAzNTEsNy40MTM4MTcxMiBMMC44MTc4OTk5OTksNC45OTcyODkyMyBaIE0wLjgxNzg5OTk5OSw0Ljk5NzI5NTkxIEwyLjM2OTM2NjY3LDAuMjA3OTA0NzE0IEMyLjQ0OTE2NjY3LC0wLjAzODUwMjM1ODggMi43OTY3NjY2NywtMC4wMzg1NjkyMjY1IDIuODc2NTY2NjcsMC4yMDc5MDQ3MTQgTDQuNDI4MSw0Ljk5NzI5NTkxIEwwLjgxNzg5OTk5OSw0Ljk5NzI5NTkxIFogTTcuMDA0MDkzMzYsMTIuOTQ5MjMgTDkuNTgwMDkzMzYsNC45OTcyNjkxNyBMMTMuMTkwMjkzMyw0Ljk5NzI2OTE3IEw3LjAwNDA5MzM2LDEyLjk0OTIzIFogTTEzLjE5MDI5MzMsNC45OTcyODkyMyBMMTMuOTczMDkzMyw3LjQxMzgxNzEyIEMxNC4wNDQ0OTMzLDcuNjM0MjEyNyAxMy45NjYyOTM0LDcuODc1NjcxNTIgMTMuNzc5MzYsOC4wMTE4ODA4IEw3LjAwNDA5MzM2LDEyLjk0OTI1IEwxMy4xOTAyOTMzLDQuOTk3Mjg5MjMgWiBNMTMuMTkwMjkzMyw0Ljk5NzI5NTkxIEw5LjU4MDA5MzM2LDQuOTk3Mjk1OTEgTDExLjEzMTYyNjcsMC4yMDc5MDQ3MTQgQzExLjIxMTQyNjcsLTAuMDM4NTY5MjI2NSAxMS41NTkwMjY3LC0wLjAzODUwMjM1ODggMTEuNjM4ODI2NywwLjIwNzkwNDcxNCBMMTMuMTkwMjkzMyw0Ljk5NzI5NTkxIFoiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDEgMikiLz4gIDwvZz48L3N2Zz4=);\\n}\\n\\n.providerBitbucket:before {\\n background-image: url(data:image/svg+xml;base64,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);\\n}\\n\\n.callOut {\\n display: block;\\n padding: 32px;\\n font-size: 14px;\\n font-weight: 500;\\n text-decoration: none;\\n color: #a3a9ac;\\n text-align: center;\\n}\\n\\n.callOut:after {\\n content: \\\" \\\\2665\\\";\\n -webkit-transition: color 4s ease;\\n transition: color 4s ease;\\n}\\n\\n.callOut:hover:after {\\n color: red;\\n}\\n\\n.callOut .netlifyLogo {\\n display: block;\\n margin: auto;\\n width: 32px;\\n height: 32px;\\n margin-bottom: 8px;\\n background-image: url(data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">  <defs>    <radialGradient id="a" cy="0%" r="100%" fx="50%" fy="0%" gradientTransform="matrix(0 1 -1.15185 0 .5 -.5)">      <stop stop-color="#20C6B7" offset="0%"/>      <stop stop-color="#4D9ABF" offset="100%"/>    </radialGradient>  </defs>  <path fill="url(#a)" fill-rule="evenodd" d="M22.980623,11.6262377 C22.8717107,11.5051306 22.7355704,11.3974798 22.5722021,11.3167418 C22.5585881,11.3167418 22.544974,11.2898291 22.53136,11.2763727 L23.1712194,7.36057661 C23.1712194,7.33366392 23.1848334,7.32020758 23.1984475,7.32020758 L23.2120615,7.32020758 C23.2120615,7.32020758 23.2256755,7.32020758 23.2392896,7.33366392 L26.166306,10.2267779 C26.17992,10.2402343 26.17992,10.2536906 26.17992,10.2671469 C26.17992,10.2806033 26.166306,10.2940596 26.1526919,10.307516 L23.0214651,11.639694 L23.007851,11.639694 C22.994237,11.639694 22.994237,11.639694 22.980623,11.6262377 Z M16.3505736,9.4597381 C16.3233453,9.19061274 16.2280463,8.92148738 16.0782906,8.69273083 C16.0646765,8.67927456 16.0646765,8.65236202 16.0782906,8.62544949 L19.359301,3.53898022 C19.359301,3.52552395 19.3729151,3.51206768 19.3865293,3.51206768 C19.4001434,3.51206768 19.4001434,3.51206768 19.4137576,3.52552395 L22.3271858,6.41862155 C22.3408,6.43207782 22.3408,6.44553409 22.3408,6.45899035 L21.5784076,11.1821404 C21.5784076,11.2090529 21.5647934,11.2225092 21.5511793,11.2225092 C21.3741953,11.2763343 21.2108255,11.3570719 21.074684,11.464722 C21.074684,11.4781783 21.0610698,11.4781783 21.0338415,11.4781783 L16.3778019,9.5001069 C16.3641878,9.48665063 16.3505736,9.47319437 16.3505736,9.4597381 Z M26.9831907,11.0207669 L31.9795788,15.972664 C32.0068071,15.9861202 32.0068071,16.0264889 31.9795788,16.0264889 L31.9523505,16.0534014 C31.9523505,16.0668577 31.9387364,16.0668577 31.9115081,16.0668577 L23.5524283,12.527866 C23.5388141,12.527866 23.5252,12.5009535 23.5252,12.4874973 C23.5252,12.474041 23.5388141,12.4605848 23.5524283,12.4471286 L26.9559624,11.0073107 C26.9559624,11.0073107 26.9695765,11.0073107 26.9831907,11.0207669 Z M23.1304363,13.3890881 L31.1491858,16.7800761 C31.1628,16.7935324 31.1628,16.8069887 31.1628,16.820445 C31.1628,16.8339013 31.1628,16.8473576 31.1491858,16.8608139 L26.7109645,21.2610245 C26.7109645,21.2744808 26.6973503,21.2744808 26.670122,21.2744808 L21.8234754,20.2652582 C21.796247,20.2652582 21.7826329,20.2518019 21.7826329,20.2248893 C21.7417903,19.8481128 21.564806,19.5117053 21.2652942,19.2829481 C21.25168,19.2694918 21.25168,19.2560355 21.25168,19.2425792 L22.1093731,13.9811653 C22.1093731,13.9542527 22.1366014,13.9407964 22.1502156,13.9407964 C22.5314125,13.8869712 22.8581527,13.698583 23.0759796,13.4025444 C23.0895937,13.3890881 23.1032079,13.3890881 23.1304363,13.3890881 Z M16.146379,10.4286859 L20.5301317,12.2856532 C20.5437459,12.2991095 20.55736,12.3125658 20.55736,12.3394783 C20.5437459,12.4067598 20.5301317,12.4874975 20.5301317,12.5682352 L20.5301317,12.6355166 L20.5301317,12.6893417 C20.5301317,12.702798 20.5165176,12.7162543 20.5029034,12.7297106 C20.5029034,12.7297106 10.8777072,16.8338775 10.864093,16.8338775 C10.8504789,16.8338775 10.8368647,16.8338775 10.8232506,16.8204212 C10.8096365,16.8069649 10.8096365,16.7800524 10.8232506,16.7665961 L14.4309974,11.1822378 C14.4446116,11.1687815 14.4582257,11.1553253 14.485454,11.1553253 C14.580753,11.1687815 14.6624378,11.1822378 14.7441226,11.1822378 C15.2886882,11.1822378 15.7924113,10.9131121 16.0919224,10.4555984 C16.1055365,10.4421422 16.1191507,10.4286859 16.146379,10.4286859 Z M21.5511429,21.1802433 L25.8123717,22.0549053 C25.8259859,22.0549053 25.8396,22.0683616 25.8396,22.1087307 C25.8396,22.122187 25.8396,22.1356433 25.8259859,22.1490997 L19.9174449,28.0026072 C19.9174449,28.0160636 19.9038307,28.0160636 19.8902166,28.0160636 L19.8629883,28.0160636 C19.8493741,28.0026072 19.83576,27.9891509 19.83576,27.9622382 L20.8568212,21.6915841 C20.8568212,21.6781278 20.8704354,21.6512151 20.8840495,21.6512151 C21.1291042,21.5570208 21.3333165,21.3955447 21.4966863,21.1936996 C21.5103004,21.1936996 21.5239146,21.1802433 21.5511429,21.1802433 Z M19.0461679,20.682403 C19.1550814,21.0995487 19.4545933,21.4628692 19.8630187,21.6243449 C19.8902471,21.6378012 19.8902471,21.6647139 19.8630187,21.6647139 C19.8630187,21.6647139 18.6241283,29.2137054 18.6241283,29.2271617 L18.1884746,29.6577637 C18.1884746,29.6712201 18.1748604,29.6712201 18.1612462,29.6712201 C18.147632,29.6712201 18.147632,29.6712201 18.1340178,29.6577637 L10.9457306,19.2694901 C10.9321165,19.2560338 10.9321165,19.2291212 10.9457306,19.2156649 C10.9865732,19.1618396 11.0138015,19.1080144 11.0546441,19.0407328 C11.0682583,19.0272765 11.0818724,19.0138202 11.1091008,19.0138202 L19.0053254,20.6420341 C19.0325537,20.6554904 19.0461679,20.6689467 19.0461679,20.682403 Z M11.3133647,18.0987286 C11.2861365,18.0987286 11.2725224,18.0852724 11.2725224,18.0583598 C11.2725224,17.9507096 11.2452941,17.8565157 11.23168,17.7488654 C11.23168,17.7219529 11.23168,17.7084966 11.2589082,17.6950403 C11.2589082,17.6950403 20.9385459,13.5639635 20.95216,13.5639635 C20.95216,13.5639635 20.9657741,13.5639635 20.9793882,13.5774197 C21.0474588,13.6447011 21.1019153,13.6850699 21.1563718,13.7254388 C21.1836,13.7254388 21.1836,13.7523513 21.1836,13.7658076 L20.3395247,18.9464741 C20.3395247,18.9733866 20.3259106,18.9868429 20.2986824,18.9868429 C19.8358024,19.0137554 19.4273788,19.282881 19.1959388,19.6865693 C19.1823247,19.7000255 19.1687106,19.7134818 19.1414824,19.7134818 L11.3133647,18.0987286 Z M7.86897758,19.1887291 C7.9098203,19.2560111 7.95066303,19.3098367 7.99150576,19.3636623 C8.00512,19.3771187 8.00512,19.3905751 8.00512,19.3905751 L6.13996879,22.2837007 C6.12635455,22.2971571 6.1127403,22.3106135 6.09912606,22.3106135 C6.09912606,22.3106135 6.08551182,22.3106135 6.07189758,22.2971571 L4.42457424,20.6689329 C4.41096,20.6554765 4.41096,20.6420201 4.41096,20.6285637 C4.41096,20.6151073 4.42457424,20.6016509 4.43818848,20.6016509 L7.81452061,19.1618163 L7.82813485,19.1618163 C7.84174909,19.1618163 7.85536333,19.1752727 7.86897758,19.1887291 Z M10.1833191,19.8615579 C10.1969332,19.8615579 10.2105473,19.8750142 10.2241614,19.8884706 L17.4396294,30.3574878 C17.4532435,30.3709441 17.4532435,30.3978567 17.4396294,30.4113131 L15.8603949,31.9857025 C15.8603949,31.9991589 15.8467808,31.9991589 15.8059386,31.9857025 L6.79341057,23.0641622 C6.77979648,23.0507058 6.77979648,23.0237932 6.80702466,22.9968806 L8.76745371,19.9557522 C8.7810678,19.9422958 8.79468189,19.9288395 8.82191007,19.9288395 C9.02612143,19.9961211 9.2167187,20.0230338 9.42093006,20.0230338 C9.67959778,20.0230338 9.92465141,19.9692085 10.1833191,19.8615579 Z M8.99891856,16.4032322 C8.98530439,16.4032322 8.97169022,16.3897759 8.95807604,16.3763196 L5.09165063,10.7381388 C5.07803646,10.7246825 5.07803646,10.69777 5.09165063,10.6843137 L8.563265,7.23950633 C8.563265,7.22605006 8.57687917,7.22605006 8.60410752,7.22605006 C8.60410752,7.23950633 12.7019739,8.96191002 13.1648558,9.1637542 C13.17847,9.17721048 13.1920842,9.19066676 13.1920842,9.21757932 C13.1648558,9.33868583 13.1512416,9.45979234 13.1512416,9.58089884 C13.1512416,9.99804349 13.3146117,10.3882756 13.6005094,10.6843137 C13.6141235,10.69777 13.6141235,10.7246825 13.6005094,10.7381388 L9.95191074,16.3897759 C9.93829657,16.4032322 9.92468239,16.4166885 9.89745405,16.4166885 C9.74769813,16.3763196 9.58432804,16.3494071 9.43457213,16.3494071 C9.29843039,16.3494071 9.14867448,16.3763196 8.99891856,16.4032322 Z M13.6686019,8.35642034 C13.4916186,8.27568198 9.35293324,6.52635083 9.35293324,6.52635083 C9.33931914,6.51289444 9.32570505,6.51289444 9.33931914,6.48598165 C9.33931914,6.47252526 9.33931914,6.45906886 9.35293324,6.44561247 L15.8332432,0.0134563935 C15.8332432,0 15.8468573,0 15.8604714,0 C15.8740855,0 15.8740855,0 15.8876996,0.0134563935 L18.6785894,2.77201705 C18.6922035,2.78547345 18.6922035,2.81238623 18.6785894,2.82584263 L15.3159076,8.0334669 C15.3022935,8.04692329 15.2886794,8.06037969 15.2614512,8.06037969 C15.0844679,8.00655411 14.9074847,7.97964133 14.7305014,7.97964133 C14.3629208,7.97964133 13.9953402,8.11420526 13.7094442,8.34296395 C13.6958301,8.35642034 13.6958301,8.35642034 13.6686019,8.35642034 Z M7.78728995,17.3317511 C7.77367581,17.3452074 7.76006167,17.3586637 7.74644752,17.3586637 L0.0408424298,15.743908 C0.0136141433,15.743908 0,15.7304517 0,15.7169954 C0,15.7035391 0,15.6900828 0.0136141433,15.6766265 L4.31568342,11.4244363 C4.31568342,11.4109801 4.32929756,11.4109801 4.34291171,11.4109801 C4.37013999,11.4244363 4.37013999,11.4244363 4.38375413,11.4378926 C4.38375413,11.4513489 8.07318696,16.7800429 8.11402939,16.8338681 C8.12764354,16.8473244 8.12764354,16.874237 8.11402939,16.8876933 C7.9915021,17.0222563 7.86897481,17.1702755 7.78728995,17.3317511 Z M7.35155783,18.2467464 C7.37878594,18.2467464 7.3924,18.2602027 7.3924,18.2871151 C7.3924,18.3005713 7.37878594,18.3140275 7.35155783,18.3409399 L3.63492,19.9153165 C3.63492,19.9153165 3.62130594,19.9153165 3.60769188,19.9018603 L0.626213185,16.9414941 C0.612599127,16.9280378 0.598985069,16.9011254 0.612599127,16.8876692 C0.626213185,16.874213 0.639827243,16.8607568 0.667055359,16.8607568 L7.35155783,18.2467464 Z"/></svg>);\\n}\\n\\n.visuallyHidden {\\n border: 0;\\n clip: rect(0 0 0 0);\\n height: 1px;\\n margin: -1px;\\n overflow: hidden;\\n padding: 0;\\n position: absolute;\\n width: 1px;\\n #fff-space: nowrap;\\n}\\n\\n.subheader {\\n margin-top: 2em;\\n border-top: 1px solid rgb(14, 30, 37);\\n}\\n\\n.subheader h3 {\\n padding-top: 1em;\\n text-align: center;\\n }\\n\", \"\"]);\n\n// exports\n\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n// css base code, injected by the css-loader\nmodule.exports = function (useSourceMap) {\n\tvar list = [];\n\n\t// return the list of modules as css string\n\tlist.toString = function toString() {\n\t\treturn this.map(function (item) {\n\t\t\tvar content = cssWithMappingToString(item, useSourceMap);\n\t\t\tif (item[2]) {\n\t\t\t\treturn \"@media \" + item[2] + \"{\" + content + \"}\";\n\t\t\t} else {\n\t\t\t\treturn content;\n\t\t\t}\n\t\t}).join(\"\");\n\t};\n\n\t// import a list of modules into the list\n\tlist.i = function (modules, mediaQuery) {\n\t\tif (typeof modules === \"string\") modules = [[null, modules, \"\"]];\n\t\tvar alreadyImportedModules = {};\n\t\tfor (var i = 0; i < this.length; i++) {\n\t\t\tvar id = this[i][0];\n\t\t\tif (typeof id === \"number\") alreadyImportedModules[id] = true;\n\t\t}\n\t\tfor (i = 0; i < modules.length; i++) {\n\t\t\tvar item = modules[i];\n\t\t\t// skip already imported module\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\n\t\t\t// when a module is imported multiple times with different media queries.\n\t\t\t// I hope this will never occur (Hey this way we have smaller bundles)\n\t\t\tif (typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\n\t\t\t\tif (mediaQuery && !item[2]) {\n\t\t\t\t\titem[2] = mediaQuery;\n\t\t\t\t} else if (mediaQuery) {\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\n\t\t\t\t}\n\t\t\t\tlist.push(item);\n\t\t\t}\n\t\t}\n\t};\n\treturn list;\n};\n\nfunction cssWithMappingToString(item, useSourceMap) {\n\tvar content = item[1] || '';\n\tvar cssMapping = item[3];\n\tif (!cssMapping) {\n\t\treturn content;\n\t}\n\n\tif (useSourceMap && typeof btoa === 'function') {\n\t\tvar sourceMapping = toComment(cssMapping);\n\t\tvar sourceURLs = cssMapping.sources.map(function (source) {\n\t\t\treturn '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */';\n\t\t});\n\n\t\treturn [content].concat(sourceURLs).concat([sourceMapping]).join('\\n');\n\t}\n\n\treturn [content].join('\\n');\n}\n\n// Adapted from convert-source-map (MIT)\nfunction toComment(sourceMap) {\n\t// eslint-disable-next-line no-undef\n\tvar base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));\n\tvar data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;\n\n\treturn '/*# ' + data + ' */';\n}\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// netlify-identity-widget.js"," \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 \t\t}\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// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\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 = 9);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap a8e669399e83701167ff","var VNode = function VNode() {};\n\nvar options = {};\n\nvar stack = [];\n\nvar EMPTY_CHILDREN = [];\n\nfunction h(nodeName, attributes) {\n\tvar children = EMPTY_CHILDREN,\n\t lastSimple,\n\t child,\n\t simple,\n\t i;\n\tfor (i = arguments.length; i-- > 2;) {\n\t\tstack.push(arguments[i]);\n\t}\n\tif (attributes && attributes.children != null) {\n\t\tif (!stack.length) stack.push(attributes.children);\n\t\tdelete attributes.children;\n\t}\n\twhile (stack.length) {\n\t\tif ((child = stack.pop()) && child.pop !== undefined) {\n\t\t\tfor (i = child.length; i--;) {\n\t\t\t\tstack.push(child[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tif (typeof child === 'boolean') child = null;\n\n\t\t\tif (simple = typeof nodeName !== 'function') {\n\t\t\t\tif (child == null) child = '';else if (typeof child === 'number') child = String(child);else if (typeof child !== 'string') simple = false;\n\t\t\t}\n\n\t\t\tif (simple && lastSimple) {\n\t\t\t\tchildren[children.length - 1] += child;\n\t\t\t} else if (children === EMPTY_CHILDREN) {\n\t\t\t\tchildren = [child];\n\t\t\t} else {\n\t\t\t\tchildren.push(child);\n\t\t\t}\n\n\t\t\tlastSimple = simple;\n\t\t}\n\t}\n\n\tvar p = new VNode();\n\tp.nodeName = nodeName;\n\tp.children = children;\n\tp.attributes = attributes == null ? undefined : attributes;\n\tp.key = attributes == null ? undefined : attributes.key;\n\n\tif (options.vnode !== undefined) options.vnode(p);\n\n\treturn p;\n}\n\nfunction extend(obj, props) {\n for (var i in props) {\n obj[i] = props[i];\n }return obj;\n}\n\nvar defer = typeof Promise == 'function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;\n\nfunction cloneElement(vnode, props) {\n return h(vnode.nodeName, extend(extend({}, vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children);\n}\n\nvar IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;\n\nvar items = [];\n\nfunction enqueueRender(component) {\n\tif (!component._dirty && (component._dirty = true) && items.push(component) == 1) {\n\t\t(options.debounceRendering || defer)(rerender);\n\t}\n}\n\nfunction rerender() {\n\tvar p,\n\t list = items;\n\titems = [];\n\twhile (p = list.pop()) {\n\t\tif (p._dirty) renderComponent(p);\n\t}\n}\n\nfunction isSameNodeType(node, vnode, hydrating) {\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\t\treturn node.splitText !== undefined;\n\t}\n\tif (typeof vnode.nodeName === 'string') {\n\t\treturn !node._componentConstructor && isNamedNode(node, vnode.nodeName);\n\t}\n\treturn hydrating || node._componentConstructor === vnode.nodeName;\n}\n\nfunction isNamedNode(node, nodeName) {\n\treturn node.normalizedNodeName === nodeName || node.nodeName.toLowerCase() === nodeName.toLowerCase();\n}\n\nfunction getNodeProps(vnode) {\n\tvar props = extend({}, vnode.attributes);\n\tprops.children = vnode.children;\n\n\tvar defaultProps = vnode.nodeName.defaultProps;\n\tif (defaultProps !== undefined) {\n\t\tfor (var i in defaultProps) {\n\t\t\tif (props[i] === undefined) {\n\t\t\t\tprops[i] = defaultProps[i];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn props;\n}\n\nfunction createNode(nodeName, isSvg) {\n\tvar node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName);\n\tnode.normalizedNodeName = nodeName;\n\treturn node;\n}\n\nfunction removeNode(node) {\n\tvar parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\nfunction setAccessor(node, name, old, value, isSvg) {\n\tif (name === 'className') name = 'class';\n\n\tif (name === 'key') {} else if (name === 'ref') {\n\t\tif (old) old(null);\n\t\tif (value) value(node);\n\t} else if (name === 'class' && !isSvg) {\n\t\tnode.className = value || '';\n\t} else if (name === 'style') {\n\t\tif (!value || typeof value === 'string' || typeof old === 'string') {\n\t\t\tnode.style.cssText = value || '';\n\t\t}\n\t\tif (value && typeof value === 'object') {\n\t\t\tif (typeof old !== 'string') {\n\t\t\t\tfor (var i in old) {\n\t\t\t\t\tif (!(i in value)) node.style[i] = '';\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i in value) {\n\t\t\t\tnode.style[i] = typeof value[i] === 'number' && IS_NON_DIMENSIONAL.test(i) === false ? value[i] + 'px' : value[i];\n\t\t\t}\n\t\t}\n\t} else if (name === 'dangerouslySetInnerHTML') {\n\t\tif (value) node.innerHTML = value.__html || '';\n\t} else if (name[0] == 'o' && name[1] == 'n') {\n\t\tvar useCapture = name !== (name = name.replace(/Capture$/, ''));\n\t\tname = name.toLowerCase().substring(2);\n\t\tif (value) {\n\t\t\tif (!old) node.addEventListener(name, eventProxy, useCapture);\n\t\t} else {\n\t\t\tnode.removeEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\t(node._listeners || (node._listeners = {}))[name] = value;\n\t} else if (name !== 'list' && name !== 'type' && !isSvg && name in node) {\n\t\ttry {\n\t\t\tnode[name] = value == null ? '' : value;\n\t\t} catch (e) {}\n\t\tif ((value == null || value === false) && name != 'spellcheck') node.removeAttribute(name);\n\t} else {\n\t\tvar ns = isSvg && name !== (name = name.replace(/^xlink:?/, ''));\n\n\t\tif (value == null || value === false) {\n\t\t\tif (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase());else node.removeAttribute(name);\n\t\t} else if (typeof value !== 'function') {\n\t\t\tif (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value);else node.setAttribute(name, value);\n\t\t}\n\t}\n}\n\nfunction eventProxy(e) {\n\treturn this._listeners[e.type](options.event && options.event(e) || e);\n}\n\nvar mounts = [];\n\nvar diffLevel = 0;\n\nvar isSvgMode = false;\n\nvar hydrating = false;\n\nfunction flushMounts() {\n\tvar c;\n\twhile (c = mounts.pop()) {\n\t\tif (options.afterMount) options.afterMount(c);\n\t\tif (c.componentDidMount) c.componentDidMount();\n\t}\n}\n\nfunction diff(dom, vnode, context, mountAll, parent, componentRoot) {\n\tif (!diffLevel++) {\n\t\tisSvgMode = parent != null && parent.ownerSVGElement !== undefined;\n\n\t\thydrating = dom != null && !('__preactattr_' in dom);\n\t}\n\n\tvar ret = idiff(dom, vnode, context, mountAll, componentRoot);\n\n\tif (parent && ret.parentNode !== parent) parent.appendChild(ret);\n\n\tif (! --diffLevel) {\n\t\thydrating = false;\n\n\t\tif (!componentRoot) flushMounts();\n\t}\n\n\treturn ret;\n}\n\nfunction idiff(dom, vnode, context, mountAll, componentRoot) {\n\tvar out = dom,\n\t prevSvgMode = isSvgMode;\n\n\tif (vnode == null || typeof vnode === 'boolean') vnode = '';\n\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\t\tif (dom && dom.splitText !== undefined && dom.parentNode && (!dom._component || componentRoot)) {\n\t\t\tif (dom.nodeValue != vnode) {\n\t\t\t\tdom.nodeValue = vnode;\n\t\t\t}\n\t\t} else {\n\t\t\tout = document.createTextNode(vnode);\n\t\t\tif (dom) {\n\t\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\t\t\t\trecollectNodeTree(dom, true);\n\t\t\t}\n\t\t}\n\n\t\tout['__preactattr_'] = true;\n\n\t\treturn out;\n\t}\n\n\tvar vnodeName = vnode.nodeName;\n\tif (typeof vnodeName === 'function') {\n\t\treturn buildComponentFromVNode(dom, vnode, context, mountAll);\n\t}\n\n\tisSvgMode = vnodeName === 'svg' ? true : vnodeName === 'foreignObject' ? false : isSvgMode;\n\n\tvnodeName = String(vnodeName);\n\tif (!dom || !isNamedNode(dom, vnodeName)) {\n\t\tout = createNode(vnodeName, isSvgMode);\n\n\t\tif (dom) {\n\t\t\twhile (dom.firstChild) {\n\t\t\t\tout.appendChild(dom.firstChild);\n\t\t\t}\n\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\n\t\t\trecollectNodeTree(dom, true);\n\t\t}\n\t}\n\n\tvar fc = out.firstChild,\n\t props = out['__preactattr_'],\n\t vchildren = vnode.children;\n\n\tif (props == null) {\n\t\tprops = out['__preactattr_'] = {};\n\t\tfor (var a = out.attributes, i = a.length; i--;) {\n\t\t\tprops[a[i].name] = a[i].value;\n\t\t}\n\t}\n\n\tif (!hydrating && vchildren && vchildren.length === 1 && typeof vchildren[0] === 'string' && fc != null && fc.splitText !== undefined && fc.nextSibling == null) {\n\t\tif (fc.nodeValue != vchildren[0]) {\n\t\t\tfc.nodeValue = vchildren[0];\n\t\t}\n\t} else if (vchildren && vchildren.length || fc != null) {\n\t\t\tinnerDiffNode(out, vchildren, context, mountAll, hydrating || props.dangerouslySetInnerHTML != null);\n\t\t}\n\n\tdiffAttributes(out, vnode.attributes, props);\n\n\tisSvgMode = prevSvgMode;\n\n\treturn out;\n}\n\nfunction innerDiffNode(dom, vchildren, context, mountAll, isHydrating) {\n\tvar originalChildren = dom.childNodes,\n\t children = [],\n\t keyed = {},\n\t keyedLen = 0,\n\t min = 0,\n\t len = originalChildren.length,\n\t childrenLen = 0,\n\t vlen = vchildren ? vchildren.length : 0,\n\t j,\n\t c,\n\t f,\n\t vchild,\n\t child;\n\n\tif (len !== 0) {\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar _child = originalChildren[i],\n\t\t\t props = _child['__preactattr_'],\n\t\t\t key = vlen && props ? _child._component ? _child._component.__key : props.key : null;\n\t\t\tif (key != null) {\n\t\t\t\tkeyedLen++;\n\t\t\t\tkeyed[key] = _child;\n\t\t\t} else if (props || (_child.splitText !== undefined ? isHydrating ? _child.nodeValue.trim() : true : isHydrating)) {\n\t\t\t\tchildren[childrenLen++] = _child;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (vlen !== 0) {\n\t\tfor (var i = 0; i < vlen; i++) {\n\t\t\tvchild = vchildren[i];\n\t\t\tchild = null;\n\n\t\t\tvar key = vchild.key;\n\t\t\tif (key != null) {\n\t\t\t\tif (keyedLen && keyed[key] !== undefined) {\n\t\t\t\t\tchild = keyed[key];\n\t\t\t\t\tkeyed[key] = undefined;\n\t\t\t\t\tkeyedLen--;\n\t\t\t\t}\n\t\t\t} else if (min < childrenLen) {\n\t\t\t\t\tfor (j = min; j < childrenLen; j++) {\n\t\t\t\t\t\tif (children[j] !== undefined && isSameNodeType(c = children[j], vchild, isHydrating)) {\n\t\t\t\t\t\t\tchild = c;\n\t\t\t\t\t\t\tchildren[j] = undefined;\n\t\t\t\t\t\t\tif (j === childrenLen - 1) childrenLen--;\n\t\t\t\t\t\t\tif (j === min) min++;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\tchild = idiff(child, vchild, context, mountAll);\n\n\t\t\tf = originalChildren[i];\n\t\t\tif (child && child !== dom && child !== f) {\n\t\t\t\tif (f == null) {\n\t\t\t\t\tdom.appendChild(child);\n\t\t\t\t} else if (child === f.nextSibling) {\n\t\t\t\t\tremoveNode(f);\n\t\t\t\t} else {\n\t\t\t\t\tdom.insertBefore(child, f);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (keyedLen) {\n\t\tfor (var i in keyed) {\n\t\t\tif (keyed[i] !== undefined) recollectNodeTree(keyed[i], false);\n\t\t}\n\t}\n\n\twhile (min <= childrenLen) {\n\t\tif ((child = children[childrenLen--]) !== undefined) recollectNodeTree(child, false);\n\t}\n}\n\nfunction recollectNodeTree(node, unmountOnly) {\n\tvar component = node._component;\n\tif (component) {\n\t\tunmountComponent(component);\n\t} else {\n\t\tif (node['__preactattr_'] != null && node['__preactattr_'].ref) node['__preactattr_'].ref(null);\n\n\t\tif (unmountOnly === false || node['__preactattr_'] == null) {\n\t\t\tremoveNode(node);\n\t\t}\n\n\t\tremoveChildren(node);\n\t}\n}\n\nfunction removeChildren(node) {\n\tnode = node.lastChild;\n\twhile (node) {\n\t\tvar next = node.previousSibling;\n\t\trecollectNodeTree(node, true);\n\t\tnode = next;\n\t}\n}\n\nfunction diffAttributes(dom, attrs, old) {\n\tvar name;\n\n\tfor (name in old) {\n\t\tif (!(attrs && attrs[name] != null) && old[name] != null) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = undefined, isSvgMode);\n\t\t}\n\t}\n\n\tfor (name in attrs) {\n\t\tif (name !== 'children' && name !== 'innerHTML' && (!(name in old) || attrs[name] !== (name === 'value' || name === 'checked' ? dom[name] : old[name]))) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode);\n\t\t}\n\t}\n}\n\nvar recyclerComponents = [];\n\nfunction createComponent(Ctor, props, context) {\n\tvar inst,\n\t i = recyclerComponents.length;\n\n\tif (Ctor.prototype && Ctor.prototype.render) {\n\t\tinst = new Ctor(props, context);\n\t\tComponent.call(inst, props, context);\n\t} else {\n\t\tinst = new Component(props, context);\n\t\tinst.constructor = Ctor;\n\t\tinst.render = doRender;\n\t}\n\n\twhile (i--) {\n\t\tif (recyclerComponents[i].constructor === Ctor) {\n\t\t\tinst.nextBase = recyclerComponents[i].nextBase;\n\t\t\trecyclerComponents.splice(i, 1);\n\t\t\treturn inst;\n\t\t}\n\t}\n\n\treturn inst;\n}\n\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n\nfunction setComponentProps(component, props, renderMode, context, mountAll) {\n\tif (component._disable) return;\n\tcomponent._disable = true;\n\n\tcomponent.__ref = props.ref;\n\tcomponent.__key = props.key;\n\tdelete props.ref;\n\tdelete props.key;\n\n\tif (typeof component.constructor.getDerivedStateFromProps === 'undefined') {\n\t\tif (!component.base || mountAll) {\n\t\t\tif (component.componentWillMount) component.componentWillMount();\n\t\t} else if (component.componentWillReceiveProps) {\n\t\t\tcomponent.componentWillReceiveProps(props, context);\n\t\t}\n\t}\n\n\tif (context && context !== component.context) {\n\t\tif (!component.prevContext) component.prevContext = component.context;\n\t\tcomponent.context = context;\n\t}\n\n\tif (!component.prevProps) component.prevProps = component.props;\n\tcomponent.props = props;\n\n\tcomponent._disable = false;\n\n\tif (renderMode !== 0) {\n\t\tif (renderMode === 1 || options.syncComponentUpdates !== false || !component.base) {\n\t\t\trenderComponent(component, 1, mountAll);\n\t\t} else {\n\t\t\tenqueueRender(component);\n\t\t}\n\t}\n\n\tif (component.__ref) component.__ref(component);\n}\n\nfunction renderComponent(component, renderMode, mountAll, isChild) {\n\tif (component._disable) return;\n\n\tvar props = component.props,\n\t state = component.state,\n\t context = component.context,\n\t previousProps = component.prevProps || props,\n\t previousState = component.prevState || state,\n\t previousContext = component.prevContext || context,\n\t isUpdate = component.base,\n\t nextBase = component.nextBase,\n\t initialBase = isUpdate || nextBase,\n\t initialChildComponent = component._component,\n\t skip = false,\n\t snapshot = previousContext,\n\t rendered,\n\t inst,\n\t cbase;\n\n\tif (component.constructor.getDerivedStateFromProps) {\n\t\tstate = extend(extend({}, state), component.constructor.getDerivedStateFromProps(props, state));\n\t\tcomponent.state = state;\n\t}\n\n\tif (isUpdate) {\n\t\tcomponent.props = previousProps;\n\t\tcomponent.state = previousState;\n\t\tcomponent.context = previousContext;\n\t\tif (renderMode !== 2 && component.shouldComponentUpdate && component.shouldComponentUpdate(props, state, context) === false) {\n\t\t\tskip = true;\n\t\t} else if (component.componentWillUpdate) {\n\t\t\tcomponent.componentWillUpdate(props, state, context);\n\t\t}\n\t\tcomponent.props = props;\n\t\tcomponent.state = state;\n\t\tcomponent.context = context;\n\t}\n\n\tcomponent.prevProps = component.prevState = component.prevContext = component.nextBase = null;\n\tcomponent._dirty = false;\n\n\tif (!skip) {\n\t\trendered = component.render(props, state, context);\n\n\t\tif (component.getChildContext) {\n\t\t\tcontext = extend(extend({}, context), component.getChildContext());\n\t\t}\n\n\t\tif (isUpdate && component.getSnapshotBeforeUpdate) {\n\t\t\tsnapshot = component.getSnapshotBeforeUpdate(previousProps, previousState);\n\t\t}\n\n\t\tvar childComponent = rendered && rendered.nodeName,\n\t\t toUnmount,\n\t\t base;\n\n\t\tif (typeof childComponent === 'function') {\n\n\t\t\tvar childProps = getNodeProps(rendered);\n\t\t\tinst = initialChildComponent;\n\n\t\t\tif (inst && inst.constructor === childComponent && childProps.key == inst.__key) {\n\t\t\t\tsetComponentProps(inst, childProps, 1, context, false);\n\t\t\t} else {\n\t\t\t\ttoUnmount = inst;\n\n\t\t\t\tcomponent._component = inst = createComponent(childComponent, childProps, context);\n\t\t\t\tinst.nextBase = inst.nextBase || nextBase;\n\t\t\t\tinst._parentComponent = component;\n\t\t\t\tsetComponentProps(inst, childProps, 0, context, false);\n\t\t\t\trenderComponent(inst, 1, mountAll, true);\n\t\t\t}\n\n\t\t\tbase = inst.base;\n\t\t} else {\n\t\t\tcbase = initialBase;\n\n\t\t\ttoUnmount = initialChildComponent;\n\t\t\tif (toUnmount) {\n\t\t\t\tcbase = component._component = null;\n\t\t\t}\n\n\t\t\tif (initialBase || renderMode === 1) {\n\t\t\t\tif (cbase) cbase._component = null;\n\t\t\t\tbase = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, true);\n\t\t\t}\n\t\t}\n\n\t\tif (initialBase && base !== initialBase && inst !== initialChildComponent) {\n\t\t\tvar baseParent = initialBase.parentNode;\n\t\t\tif (baseParent && base !== baseParent) {\n\t\t\t\tbaseParent.replaceChild(base, initialBase);\n\n\t\t\t\tif (!toUnmount) {\n\t\t\t\t\tinitialBase._component = null;\n\t\t\t\t\trecollectNodeTree(initialBase, false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (toUnmount) {\n\t\t\tunmountComponent(toUnmount);\n\t\t}\n\n\t\tcomponent.base = base;\n\t\tif (base && !isChild) {\n\t\t\tvar componentRef = component,\n\t\t\t t = component;\n\t\t\twhile (t = t._parentComponent) {\n\t\t\t\t(componentRef = t).base = base;\n\t\t\t}\n\t\t\tbase._component = componentRef;\n\t\t\tbase._componentConstructor = componentRef.constructor;\n\t\t}\n\t}\n\n\tif (!isUpdate || mountAll) {\n\t\tmounts.unshift(component);\n\t} else if (!skip) {\n\n\t\tif (component.componentDidUpdate) {\n\t\t\tcomponent.componentDidUpdate(previousProps, previousState, snapshot);\n\t\t}\n\t\tif (options.afterUpdate) options.afterUpdate(component);\n\t}\n\n\twhile (component._renderCallbacks.length) {\n\t\tcomponent._renderCallbacks.pop().call(component);\n\t}if (!diffLevel && !isChild) flushMounts();\n}\n\nfunction buildComponentFromVNode(dom, vnode, context, mountAll) {\n\tvar c = dom && dom._component,\n\t originalComponent = c,\n\t oldDom = dom,\n\t isDirectOwner = c && dom._componentConstructor === vnode.nodeName,\n\t isOwner = isDirectOwner,\n\t props = getNodeProps(vnode);\n\twhile (c && !isOwner && (c = c._parentComponent)) {\n\t\tisOwner = c.constructor === vnode.nodeName;\n\t}\n\n\tif (c && isOwner && (!mountAll || c._component)) {\n\t\tsetComponentProps(c, props, 3, context, mountAll);\n\t\tdom = c.base;\n\t} else {\n\t\tif (originalComponent && !isDirectOwner) {\n\t\t\tunmountComponent(originalComponent);\n\t\t\tdom = oldDom = null;\n\t\t}\n\n\t\tc = createComponent(vnode.nodeName, props, context);\n\t\tif (dom && !c.nextBase) {\n\t\t\tc.nextBase = dom;\n\n\t\t\toldDom = null;\n\t\t}\n\t\tsetComponentProps(c, props, 1, context, mountAll);\n\t\tdom = c.base;\n\n\t\tif (oldDom && dom !== oldDom) {\n\t\t\toldDom._component = null;\n\t\t\trecollectNodeTree(oldDom, false);\n\t\t}\n\t}\n\n\treturn dom;\n}\n\nfunction unmountComponent(component) {\n\tif (options.beforeUnmount) options.beforeUnmount(component);\n\n\tvar base = component.base;\n\n\tcomponent._disable = true;\n\n\tif (component.componentWillUnmount) component.componentWillUnmount();\n\n\tcomponent.base = null;\n\n\tvar inner = component._component;\n\tif (inner) {\n\t\tunmountComponent(inner);\n\t} else if (base) {\n\t\tif (base['__preactattr_'] && base['__preactattr_'].ref) base['__preactattr_'].ref(null);\n\n\t\tcomponent.nextBase = base;\n\n\t\tremoveNode(base);\n\t\trecyclerComponents.push(component);\n\n\t\tremoveChildren(base);\n\t}\n\n\tif (component.__ref) component.__ref(null);\n}\n\nfunction Component(props, context) {\n\tthis._dirty = true;\n\n\tthis.context = context;\n\n\tthis.props = props;\n\n\tthis.state = this.state || {};\n\n\tthis._renderCallbacks = [];\n}\n\nextend(Component.prototype, {\n\tsetState: function setState(state, callback) {\n\t\tif (!this.prevState) this.prevState = this.state;\n\t\tthis.state = extend(extend({}, this.state), typeof state === 'function' ? state(this.state, this.props) : state);\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\tenqueueRender(this);\n\t},\n\tforceUpdate: function forceUpdate(callback) {\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\trenderComponent(this, 2);\n\t},\n\trender: function render() {}\n});\n\nfunction render(vnode, parent, merge) {\n return diff(merge, vnode, {}, false, parent, false);\n}\n\nvar preact = {\n\th: h,\n\tcreateElement: h,\n\tcloneElement: cloneElement,\n\tComponent: Component,\n\trender: render,\n\trerender: rerender,\n\toptions: options\n};\n\nexport default preact;\nexport { h, h as createElement, cloneElement, Component, render, rerender, options };\n//# sourceMappingURL=preact.mjs.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../node_modules/preact/dist/preact.mjs\n// module id = 0\n// module chunks = 0","/** MobX - (c) Michel Weststrate 2015, 2016 - MIT Licensed */\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n\r\nfunction __extends(d, b) {\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\n\n/**\n * Anything that can be used to _store_ state is an Atom in mobx. Atoms have two important jobs\n *\n * 1) detect when they are being _used_ and report this (using reportObserved). This allows mobx to make the connection between running functions and the data they used\n * 2) they should notify mobx whenever they have _changed_. This way mobx can re-run any functions (derivations) that are using this atom.\n */\nvar BaseAtom = /** @class */ (function () {\n /**\n * Create a new atom. For debugging purposes it is recommended to give it a name.\n * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.\n */\n function BaseAtom(name) {\n if (name === void 0) { name = \"Atom@\" + getNextId(); }\n this.name = name;\n this.isPendingUnobservation = true; // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed\n this.observers = [];\n this.observersIndexes = {};\n this.diffValue = 0;\n this.lastAccessedBy = 0;\n this.lowestObserverState = IDerivationState.NOT_TRACKING;\n }\n BaseAtom.prototype.onBecomeUnobserved = function () {\n // noop\n };\n /**\n * Invoke this method to notify mobx that your atom has been used somehow.\n */\n BaseAtom.prototype.reportObserved = function () {\n reportObserved(this);\n };\n /**\n * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.\n */\n BaseAtom.prototype.reportChanged = function () {\n startBatch();\n propagateChanged(this);\n endBatch();\n };\n BaseAtom.prototype.toString = function () {\n return this.name;\n };\n return BaseAtom;\n}());\nvar Atom = /** @class */ (function (_super) {\n __extends(Atom, _super);\n /**\n * Create a new atom. For debugging purposes it is recommended to give it a name.\n * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.\n */\n function Atom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) {\n if (name === void 0) { name = \"Atom@\" + getNextId(); }\n if (onBecomeObservedHandler === void 0) { onBecomeObservedHandler = noop; }\n if (onBecomeUnobservedHandler === void 0) { onBecomeUnobservedHandler = noop; }\n var _this = _super.call(this, name) || this;\n _this.name = name;\n _this.onBecomeObservedHandler = onBecomeObservedHandler;\n _this.onBecomeUnobservedHandler = onBecomeUnobservedHandler;\n _this.isPendingUnobservation = false; // for effective unobserving.\n _this.isBeingTracked = false;\n return _this;\n }\n Atom.prototype.reportObserved = function () {\n startBatch();\n _super.prototype.reportObserved.call(this);\n if (!this.isBeingTracked) {\n this.isBeingTracked = true;\n this.onBecomeObservedHandler();\n }\n endBatch();\n return !!globalState.trackingDerivation;\n // return doesn't really give useful info, because it can be as well calling computed which calls atom (no reactions)\n // also it could not trigger when calculating reaction dependent on Atom because Atom's value was cached by computed called by given reaction.\n };\n Atom.prototype.onBecomeUnobserved = function () {\n this.isBeingTracked = false;\n this.onBecomeUnobservedHandler();\n };\n return Atom;\n}(BaseAtom));\nvar isAtom = createInstanceofPredicate(\"Atom\", BaseAtom);\n\nfunction hasInterceptors(interceptable) {\n return interceptable.interceptors && interceptable.interceptors.length > 0;\n}\nfunction registerInterceptor(interceptable, handler) {\n var interceptors = interceptable.interceptors || (interceptable.interceptors = []);\n interceptors.push(handler);\n return once(function () {\n var idx = interceptors.indexOf(handler);\n if (idx !== -1)\n interceptors.splice(idx, 1);\n });\n}\nfunction interceptChange(interceptable, change) {\n var prevU = untrackedStart();\n try {\n var interceptors = interceptable.interceptors;\n if (interceptors)\n for (var i = 0, l = interceptors.length; i < l; i++) {\n change = interceptors[i](change);\n invariant(!change || change.type, \"Intercept handlers should return nothing or a change object\");\n if (!change)\n break;\n }\n return change;\n }\n finally {\n untrackedEnd(prevU);\n }\n}\n\nfunction hasListeners(listenable) {\n return listenable.changeListeners && listenable.changeListeners.length > 0;\n}\nfunction registerListener(listenable, handler) {\n var listeners = listenable.changeListeners || (listenable.changeListeners = []);\n listeners.push(handler);\n return once(function () {\n var idx = listeners.indexOf(handler);\n if (idx !== -1)\n listeners.splice(idx, 1);\n });\n}\nfunction notifyListeners(listenable, change) {\n var prevU = untrackedStart();\n var listeners = listenable.changeListeners;\n if (!listeners)\n return;\n listeners = listeners.slice();\n for (var i = 0, l = listeners.length; i < l; i++) {\n listeners[i](change);\n }\n untrackedEnd(prevU);\n}\n\nfunction isSpyEnabled() {\n return !!globalState.spyListeners.length;\n}\nfunction spyReport(event) {\n if (!globalState.spyListeners.length)\n return;\n var listeners = globalState.spyListeners;\n for (var i = 0, l = listeners.length; i < l; i++)\n listeners[i](event);\n}\nfunction spyReportStart(event) {\n var change = objectAssign({}, event, { spyReportStart: true });\n spyReport(change);\n}\nvar END_EVENT = { spyReportEnd: true };\nfunction spyReportEnd(change) {\n if (change)\n spyReport(objectAssign({}, change, END_EVENT));\n else\n spyReport(END_EVENT);\n}\nfunction spy(listener) {\n globalState.spyListeners.push(listener);\n return once(function () {\n var idx = globalState.spyListeners.indexOf(listener);\n if (idx !== -1)\n globalState.spyListeners.splice(idx, 1);\n });\n}\n\nfunction iteratorSymbol() {\n return (typeof Symbol === \"function\" && Symbol.iterator) || \"@@iterator\";\n}\nvar IS_ITERATING_MARKER = \"__$$iterating\";\nfunction arrayAsIterator(array) {\n // returning an array for entries(), values() etc for maps was a mis-interpretation of the specs..,\n // yet it is quite convenient to be able to use the response both as array directly and as iterator\n // it is suboptimal, but alas...\n invariant(array[IS_ITERATING_MARKER] !== true, \"Illegal state: cannot recycle array as iterator\");\n addHiddenFinalProp(array, IS_ITERATING_MARKER, true);\n var idx = -1;\n addHiddenFinalProp(array, \"next\", function next() {\n idx++;\n return {\n done: idx >= this.length,\n value: idx < this.length ? this[idx] : undefined\n };\n });\n return array;\n}\nfunction declareIterator(prototType, iteratorFactory) {\n addHiddenFinalProp(prototType, iteratorSymbol(), iteratorFactory);\n}\n\nvar MAX_SPLICE_SIZE = 10000; // See e.g. https://github.com/mobxjs/mobx/issues/859\n// Detects bug in safari 9.1.1 (or iOS 9 safari mobile). See #364\nvar safariPrototypeSetterInheritanceBug = (function () {\n var v = false;\n var p = {};\n Object.defineProperty(p, \"0\", {\n set: function () {\n v = true;\n }\n });\n Object.create(p)[\"0\"] = 1;\n return v === false;\n})();\n/**\n * This array buffer contains two lists of properties, so that all arrays\n * can recycle their property definitions, which significantly improves performance of creating\n * properties on the fly.\n */\nvar OBSERVABLE_ARRAY_BUFFER_SIZE = 0;\n// Typescript workaround to make sure ObservableArray extends Array\nvar StubArray = /** @class */ (function () {\n function StubArray() {\n }\n return StubArray;\n}());\nfunction inherit(ctor, proto) {\n if (typeof Object[\"setPrototypeOf\"] !== \"undefined\") {\n Object[\"setPrototypeOf\"](ctor.prototype, proto);\n }\n else if (typeof ctor.prototype.__proto__ !== \"undefined\") {\n ctor.prototype.__proto__ = proto;\n }\n else {\n ctor[\"prototype\"] = proto;\n }\n}\ninherit(StubArray, Array.prototype);\n// Weex freeze Array.prototype\n// Make them writeable and configurable in prototype chain\n// https://github.com/alibaba/weex/pull/1529\nif (Object.isFrozen(Array)) {\n \n [\n \"constructor\",\n \"push\",\n \"shift\",\n \"concat\",\n \"pop\",\n \"unshift\",\n \"replace\",\n \"find\",\n \"findIndex\",\n \"splice\",\n \"reverse\",\n \"sort\"\n ].forEach(function (key) {\n Object.defineProperty(StubArray.prototype, key, {\n configurable: true,\n writable: true,\n value: Array.prototype[key]\n });\n });\n}\nvar ObservableArrayAdministration = /** @class */ (function () {\n function ObservableArrayAdministration(name, enhancer, array, owned) {\n this.array = array;\n this.owned = owned;\n this.values = [];\n this.lastKnownLength = 0;\n this.interceptors = null;\n this.changeListeners = null;\n this.atom = new BaseAtom(name || \"ObservableArray@\" + getNextId());\n this.enhancer = function (newV, oldV) { return enhancer(newV, oldV, name + \"[..]\"); };\n }\n ObservableArrayAdministration.prototype.dehanceValue = function (value) {\n if (this.dehancer !== undefined)\n return this.dehancer(value);\n return value;\n };\n ObservableArrayAdministration.prototype.dehanceValues = function (values) {\n if (this.dehancer !== undefined)\n return values.map(this.dehancer);\n return values;\n };\n ObservableArrayAdministration.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n ObservableArrayAdministration.prototype.observe = function (listener, fireImmediately) {\n if (fireImmediately === void 0) { fireImmediately = false; }\n if (fireImmediately) {\n listener({\n object: this.array,\n type: \"splice\",\n index: 0,\n added: this.values.slice(),\n addedCount: this.values.length,\n removed: [],\n removedCount: 0\n });\n }\n return registerListener(this, listener);\n };\n ObservableArrayAdministration.prototype.getArrayLength = function () {\n this.atom.reportObserved();\n return this.values.length;\n };\n ObservableArrayAdministration.prototype.setArrayLength = function (newLength) {\n if (typeof newLength !== \"number\" || newLength < 0)\n throw new Error(\"[mobx.array] Out of range: \" + newLength);\n var currentLength = this.values.length;\n if (newLength === currentLength)\n return;\n else if (newLength > currentLength) {\n var newItems = new Array(newLength - currentLength);\n for (var i = 0; i < newLength - currentLength; i++)\n newItems[i] = undefined; // No Array.fill everywhere...\n this.spliceWithArray(currentLength, 0, newItems);\n }\n else\n this.spliceWithArray(newLength, currentLength - newLength);\n };\n // adds / removes the necessary numeric properties to this object\n ObservableArrayAdministration.prototype.updateArrayLength = function (oldLength, delta) {\n if (oldLength !== this.lastKnownLength)\n throw new Error(\"[mobx] Modification exception: the internal structure of an observable array was changed. Did you use peek() to change it?\");\n this.lastKnownLength += delta;\n if (delta > 0 && oldLength + delta + 1 > OBSERVABLE_ARRAY_BUFFER_SIZE)\n reserveArrayBuffer(oldLength + delta + 1);\n };\n ObservableArrayAdministration.prototype.spliceWithArray = function (index, deleteCount, newItems) {\n var _this = this;\n checkIfStateModificationsAreAllowed(this.atom);\n var length = this.values.length;\n if (index === undefined)\n index = 0;\n else if (index > length)\n index = length;\n else if (index < 0)\n index = Math.max(0, length + index);\n if (arguments.length === 1)\n deleteCount = length - index;\n else if (deleteCount === undefined || deleteCount === null)\n deleteCount = 0;\n else\n deleteCount = Math.max(0, Math.min(deleteCount, length - index));\n if (newItems === undefined)\n newItems = [];\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n object: this.array,\n type: \"splice\",\n index: index,\n removedCount: deleteCount,\n added: newItems\n });\n if (!change)\n return EMPTY_ARRAY;\n deleteCount = change.removedCount;\n newItems = change.added;\n }\n newItems = newItems.map(function (v) { return _this.enhancer(v, undefined); });\n var lengthDelta = newItems.length - deleteCount;\n this.updateArrayLength(length, lengthDelta); // create or remove new entries\n var res = this.spliceItemsIntoValues(index, deleteCount, newItems);\n if (deleteCount !== 0 || newItems.length !== 0)\n this.notifyArraySplice(index, newItems, res);\n return this.dehanceValues(res);\n };\n ObservableArrayAdministration.prototype.spliceItemsIntoValues = function (index, deleteCount, newItems) {\n if (newItems.length < MAX_SPLICE_SIZE) {\n return (_a = this.values).splice.apply(_a, [index, deleteCount].concat(newItems));\n }\n else {\n var res = this.values.slice(index, index + deleteCount);\n this.values = this.values\n .slice(0, index)\n .concat(newItems, this.values.slice(index + deleteCount));\n return res;\n }\n var _a;\n };\n ObservableArrayAdministration.prototype.notifyArrayChildUpdate = function (index, newValue, oldValue) {\n var notifySpy = !this.owned && isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy\n ? {\n object: this.array,\n type: \"update\",\n index: index,\n newValue: newValue,\n oldValue: oldValue\n }\n : null;\n if (notifySpy)\n spyReportStart(change);\n this.atom.reportChanged();\n if (notify)\n notifyListeners(this, change);\n if (notifySpy)\n spyReportEnd();\n };\n ObservableArrayAdministration.prototype.notifyArraySplice = function (index, added, removed) {\n var notifySpy = !this.owned && isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy\n ? {\n object: this.array,\n type: \"splice\",\n index: index,\n removed: removed,\n added: added,\n removedCount: removed.length,\n addedCount: added.length\n }\n : null;\n if (notifySpy)\n spyReportStart(change);\n this.atom.reportChanged();\n // conform: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/observe\n if (notify)\n notifyListeners(this, change);\n if (notifySpy)\n spyReportEnd();\n };\n return ObservableArrayAdministration;\n}());\nvar ObservableArray = /** @class */ (function (_super) {\n __extends(ObservableArray, _super);\n function ObservableArray(initialValues, enhancer, name, owned) {\n if (name === void 0) { name = \"ObservableArray@\" + getNextId(); }\n if (owned === void 0) { owned = false; }\n var _this = _super.call(this) || this;\n var adm = new ObservableArrayAdministration(name, enhancer, _this, owned);\n addHiddenFinalProp(_this, \"$mobx\", adm);\n if (initialValues && initialValues.length) {\n _this.spliceWithArray(0, 0, initialValues);\n }\n if (safariPrototypeSetterInheritanceBug) {\n // Seems that Safari won't use numeric prototype setter untill any * numeric property is\n // defined on the instance. After that it works fine, even if this property is deleted.\n Object.defineProperty(adm.array, \"0\", ENTRY_0);\n }\n return _this;\n }\n ObservableArray.prototype.intercept = function (handler) {\n return this.$mobx.intercept(handler);\n };\n ObservableArray.prototype.observe = function (listener, fireImmediately) {\n if (fireImmediately === void 0) { fireImmediately = false; }\n return this.$mobx.observe(listener, fireImmediately);\n };\n ObservableArray.prototype.clear = function () {\n return this.splice(0);\n };\n ObservableArray.prototype.concat = function () {\n var arrays = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n arrays[_i] = arguments[_i];\n }\n this.$mobx.atom.reportObserved();\n return Array.prototype.concat.apply(this.peek(), arrays.map(function (a) { return (isObservableArray(a) ? a.peek() : a); }));\n };\n ObservableArray.prototype.replace = function (newItems) {\n return this.$mobx.spliceWithArray(0, this.$mobx.values.length, newItems);\n };\n /**\n * Converts this array back to a (shallow) javascript structure.\n * For a deep clone use mobx.toJS\n */\n ObservableArray.prototype.toJS = function () {\n return this.slice();\n };\n ObservableArray.prototype.toJSON = function () {\n // Used by JSON.stringify\n return this.toJS();\n };\n ObservableArray.prototype.peek = function () {\n this.$mobx.atom.reportObserved();\n return this.$mobx.dehanceValues(this.$mobx.values);\n };\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find\n ObservableArray.prototype.find = function (predicate, thisArg, fromIndex) {\n if (fromIndex === void 0) { fromIndex = 0; }\n var idx = this.findIndex.apply(this, arguments);\n return idx === -1 ? undefined : this.get(idx);\n };\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex\n ObservableArray.prototype.findIndex = function (predicate, thisArg, fromIndex) {\n if (fromIndex === void 0) { fromIndex = 0; }\n var items = this.peek(), l = items.length;\n for (var i = fromIndex; i < l; i++)\n if (predicate.call(thisArg, items[i], i, this))\n return i;\n return -1;\n };\n /*\n * functions that do alter the internal structure of the array, (based on lib.es6.d.ts)\n * since these functions alter the inner structure of the array, the have side effects.\n * Because the have side effects, they should not be used in computed function,\n * and for that reason the do not call dependencyState.notifyObserved\n */\n ObservableArray.prototype.splice = function (index, deleteCount) {\n var newItems = [];\n for (var _i = 2; _i < arguments.length; _i++) {\n newItems[_i - 2] = arguments[_i];\n }\n switch (arguments.length) {\n case 0:\n return [];\n case 1:\n return this.$mobx.spliceWithArray(index);\n case 2:\n return this.$mobx.spliceWithArray(index, deleteCount);\n }\n return this.$mobx.spliceWithArray(index, deleteCount, newItems);\n };\n ObservableArray.prototype.spliceWithArray = function (index, deleteCount, newItems) {\n return this.$mobx.spliceWithArray(index, deleteCount, newItems);\n };\n ObservableArray.prototype.push = function () {\n var items = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n items[_i] = arguments[_i];\n }\n var adm = this.$mobx;\n adm.spliceWithArray(adm.values.length, 0, items);\n return adm.values.length;\n };\n ObservableArray.prototype.pop = function () {\n return this.splice(Math.max(this.$mobx.values.length - 1, 0), 1)[0];\n };\n ObservableArray.prototype.shift = function () {\n return this.splice(0, 1)[0];\n };\n ObservableArray.prototype.unshift = function () {\n var items = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n items[_i] = arguments[_i];\n }\n var adm = this.$mobx;\n adm.spliceWithArray(0, 0, items);\n return adm.values.length;\n };\n ObservableArray.prototype.reverse = function () {\n // reverse by default mutates in place before returning the result\n // which makes it both a 'derivation' and a 'mutation'.\n // so we deviate from the default and just make it an dervitation\n var clone = this.slice();\n return clone.reverse.apply(clone, arguments);\n };\n ObservableArray.prototype.sort = function (compareFn) {\n // sort by default mutates in place before returning the result\n // which goes against all good practices. Let's not change the array in place!\n var clone = this.slice();\n return clone.sort.apply(clone, arguments);\n };\n ObservableArray.prototype.remove = function (value) {\n var idx = this.$mobx.dehanceValues(this.$mobx.values).indexOf(value);\n if (idx > -1) {\n this.splice(idx, 1);\n return true;\n }\n return false;\n };\n ObservableArray.prototype.move = function (fromIndex, toIndex) {\n function checkIndex(index) {\n if (index < 0) {\n throw new Error(\"[mobx.array] Index out of bounds: \" + index + \" is negative\");\n }\n var length = this.$mobx.values.length;\n if (index >= length) {\n throw new Error(\"[mobx.array] Index out of bounds: \" + index + \" is not smaller than \" + length);\n }\n }\n checkIndex.call(this, fromIndex);\n checkIndex.call(this, toIndex);\n if (fromIndex === toIndex) {\n return;\n }\n var oldItems = this.$mobx.values;\n var newItems;\n if (fromIndex < toIndex) {\n newItems = oldItems.slice(0, fromIndex).concat(oldItems.slice(fromIndex + 1, toIndex + 1), [\n oldItems[fromIndex]\n ], oldItems.slice(toIndex + 1));\n }\n else {\n // toIndex < fromIndex\n newItems = oldItems.slice(0, toIndex).concat([\n oldItems[fromIndex]\n ], oldItems.slice(toIndex, fromIndex), oldItems.slice(fromIndex + 1));\n }\n this.replace(newItems);\n };\n // See #734, in case property accessors are unreliable...\n ObservableArray.prototype.get = function (index) {\n var impl = this.$mobx;\n if (impl) {\n if (index < impl.values.length) {\n impl.atom.reportObserved();\n return impl.dehanceValue(impl.values[index]);\n }\n console.warn(\"[mobx.array] Attempt to read an array index (\" + index + \") that is out of bounds (\" + impl\n .values\n .length + \"). Please check length first. Out of bound indices will not be tracked by MobX\");\n }\n return undefined;\n };\n // See #734, in case property accessors are unreliable...\n ObservableArray.prototype.set = function (index, newValue) {\n var adm = this.$mobx;\n var values = adm.values;\n if (index < values.length) {\n // update at index in range\n checkIfStateModificationsAreAllowed(adm.atom);\n var oldValue = values[index];\n if (hasInterceptors(adm)) {\n var change = interceptChange(adm, {\n type: \"update\",\n object: this,\n index: index,\n newValue: newValue\n });\n if (!change)\n return;\n newValue = change.newValue;\n }\n newValue = adm.enhancer(newValue, oldValue);\n var changed = newValue !== oldValue;\n if (changed) {\n values[index] = newValue;\n adm.notifyArrayChildUpdate(index, newValue, oldValue);\n }\n }\n else if (index === values.length) {\n // add a new item\n adm.spliceWithArray(index, 0, [newValue]);\n }\n else {\n // out of bounds\n throw new Error(\"[mobx.array] Index out of bounds, \" + index + \" is larger than \" + values.length);\n }\n };\n return ObservableArray;\n}(StubArray));\ndeclareIterator(ObservableArray.prototype, function () {\n return arrayAsIterator(this.slice());\n});\nObject.defineProperty(ObservableArray.prototype, \"length\", {\n enumerable: false,\n configurable: true,\n get: function () {\n return this.$mobx.getArrayLength();\n },\n set: function (newLength) {\n this.$mobx.setArrayLength(newLength);\n }\n});\n[\n \"every\",\n \"filter\",\n \"forEach\",\n \"indexOf\",\n \"join\",\n \"lastIndexOf\",\n \"map\",\n \"reduce\",\n \"reduceRight\",\n \"slice\",\n \"some\",\n \"toString\",\n \"toLocaleString\"\n].forEach(function (funcName) {\n var baseFunc = Array.prototype[funcName];\n invariant(typeof baseFunc === \"function\", \"Base function not defined on Array prototype: '\" + funcName + \"'\");\n addHiddenProp(ObservableArray.prototype, funcName, function () {\n return baseFunc.apply(this.peek(), arguments);\n });\n});\n/**\n * We don't want those to show up in `for (const key in ar)` ...\n */\nmakeNonEnumerable(ObservableArray.prototype, [\n \"constructor\",\n \"intercept\",\n \"observe\",\n \"clear\",\n \"concat\",\n \"get\",\n \"replace\",\n \"toJS\",\n \"toJSON\",\n \"peek\",\n \"find\",\n \"findIndex\",\n \"splice\",\n \"spliceWithArray\",\n \"push\",\n \"pop\",\n \"set\",\n \"shift\",\n \"unshift\",\n \"reverse\",\n \"sort\",\n \"remove\",\n \"move\",\n \"toString\",\n \"toLocaleString\"\n]);\n// See #364\nvar ENTRY_0 = createArrayEntryDescriptor(0);\nfunction createArrayEntryDescriptor(index) {\n return {\n enumerable: false,\n configurable: false,\n get: function () {\n // TODO: Check `this`?, see #752?\n return this.get(index);\n },\n set: function (value) {\n this.set(index, value);\n }\n };\n}\nfunction createArrayBufferItem(index) {\n Object.defineProperty(ObservableArray.prototype, \"\" + index, createArrayEntryDescriptor(index));\n}\nfunction reserveArrayBuffer(max) {\n for (var index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max; index++)\n createArrayBufferItem(index);\n OBSERVABLE_ARRAY_BUFFER_SIZE = max;\n}\nreserveArrayBuffer(1000);\nvar isObservableArrayAdministration = createInstanceofPredicate(\"ObservableArrayAdministration\", ObservableArrayAdministration);\nfunction isObservableArray(thing) {\n return isObject(thing) && isObservableArrayAdministration(thing.$mobx);\n}\n\nvar UNCHANGED = {};\nvar ObservableValue = /** @class */ (function (_super) {\n __extends(ObservableValue, _super);\n function ObservableValue(value, enhancer, name, notifySpy) {\n if (name === void 0) { name = \"ObservableValue@\" + getNextId(); }\n if (notifySpy === void 0) { notifySpy = true; }\n var _this = _super.call(this, name) || this;\n _this.enhancer = enhancer;\n _this.hasUnreportedChange = false;\n _this.dehancer = undefined;\n _this.value = enhancer(value, undefined, name);\n if (notifySpy && isSpyEnabled()) {\n // only notify spy if this is a stand-alone observable\n spyReport({ type: \"create\", object: _this, newValue: _this.value });\n }\n return _this;\n }\n ObservableValue.prototype.dehanceValue = function (value) {\n if (this.dehancer !== undefined)\n return this.dehancer(value);\n return value;\n };\n ObservableValue.prototype.set = function (newValue) {\n var oldValue = this.value;\n newValue = this.prepareNewValue(newValue);\n if (newValue !== UNCHANGED) {\n var notifySpy = isSpyEnabled();\n if (notifySpy) {\n spyReportStart({\n type: \"update\",\n object: this,\n newValue: newValue,\n oldValue: oldValue\n });\n }\n this.setNewValue(newValue);\n if (notifySpy)\n spyReportEnd();\n }\n };\n ObservableValue.prototype.prepareNewValue = function (newValue) {\n checkIfStateModificationsAreAllowed(this);\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n object: this,\n type: \"update\",\n newValue: newValue\n });\n if (!change)\n return UNCHANGED;\n newValue = change.newValue;\n }\n // apply modifier\n newValue = this.enhancer(newValue, this.value, this.name);\n return this.value !== newValue ? newValue : UNCHANGED;\n };\n ObservableValue.prototype.setNewValue = function (newValue) {\n var oldValue = this.value;\n this.value = newValue;\n this.reportChanged();\n if (hasListeners(this)) {\n notifyListeners(this, {\n type: \"update\",\n object: this,\n newValue: newValue,\n oldValue: oldValue\n });\n }\n };\n ObservableValue.prototype.get = function () {\n this.reportObserved();\n return this.dehanceValue(this.value);\n };\n ObservableValue.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n ObservableValue.prototype.observe = function (listener, fireImmediately) {\n if (fireImmediately)\n listener({\n object: this,\n type: \"update\",\n newValue: this.value,\n oldValue: undefined\n });\n return registerListener(this, listener);\n };\n ObservableValue.prototype.toJSON = function () {\n return this.get();\n };\n ObservableValue.prototype.toString = function () {\n return this.name + \"[\" + this.value + \"]\";\n };\n ObservableValue.prototype.valueOf = function () {\n return toPrimitive(this.get());\n };\n return ObservableValue;\n}(BaseAtom));\nObservableValue.prototype[primitiveSymbol()] = ObservableValue.prototype.valueOf;\nvar isObservableValue = createInstanceofPredicate(\"ObservableValue\", ObservableValue);\n\nvar messages = {\n m001: \"It is not allowed to assign new values to @action fields\",\n m002: \"`runInAction` expects a function\",\n m003: \"`runInAction` expects a function without arguments\",\n m004: \"autorun expects a function\",\n m005: \"Warning: attempted to pass an action to autorun. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.\",\n m006: \"Warning: attempted to pass an action to autorunAsync. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.\",\n m007: \"reaction only accepts 2 or 3 arguments. If migrating from MobX 2, please provide an options object\",\n m008: \"wrapping reaction expression in `asReference` is no longer supported, use options object instead\",\n m009: \"@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'. It looks like it was used on a property.\",\n m010: \"@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'\",\n m011: \"First argument to `computed` should be an expression. If using computed as decorator, don't pass it arguments\",\n m012: \"computed takes one or two arguments if used as function\",\n m013: \"[mobx.expr] 'expr' should only be used inside other reactive functions.\",\n m014: \"extendObservable expected 2 or more arguments\",\n m015: \"extendObservable expects an object as first argument\",\n m016: \"extendObservable should not be used on maps, use map.merge instead\",\n m017: \"all arguments of extendObservable should be objects\",\n m018: \"extending an object with another observable (object) is not supported. Please construct an explicit propertymap, using `toJS` if need. See issue #540\",\n m019: \"[mobx.isObservable] isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.\",\n m020: \"modifiers can only be used for individual object properties\",\n m021: \"observable expects zero or one arguments\",\n m022: \"@observable can not be used on getters, use @computed instead\",\n m024: \"whyRun() can only be used if a derivation is active, or by passing an computed value / reaction explicitly. If you invoked whyRun from inside a computation; the computation is currently suspended but re-evaluating because somebody requested its value.\",\n m025: \"whyRun can only be used on reactions and computed values\",\n m026: \"`action` can only be invoked on functions\",\n m028: \"It is not allowed to set `useStrict` when a derivation is running\",\n m029: \"INTERNAL ERROR only onBecomeUnobserved shouldn't be called twice in a row\",\n m030a: \"Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: \",\n m030b: \"Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, the render function of a React component? Tried to modify: \",\n m031: \"Computed values are not allowed to cause side effects by changing observables that are already being observed. Tried to modify: \",\n m032: \"* This computation is suspended (not in use by any reaction) and won't run automatically.\\n\tDidn't expect this computation to be suspended at this point?\\n\t 1. Make sure this computation is used by a reaction (reaction, autorun, observer).\\n\t 2. Check whether you are using this computation synchronously (in the same stack as they reaction that needs it).\",\n m033: \"`observe` doesn't support the fire immediately property for observable maps.\",\n m034: \"`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead\",\n m035: \"Cannot make the designated object observable; it is not extensible\",\n m036: \"It is not possible to get index atoms from arrays\",\n m037: \"Hi there! I'm sorry you have just run into an exception.\\nIf your debugger ends up here, know that some reaction (like the render() of an observer component, autorun or reaction)\\nthrew an exception and that mobx caught it, to avoid that it brings the rest of your application down.\\nThe original cause of the exception (the code that caused this reaction to run (again)), is still in the stack.\\n\\nHowever, more interesting is the actual stack trace of the error itself.\\nHopefully the error is an instanceof Error, because in that case you can inspect the original stack of the error from where it was thrown.\\nSee `error.stack` property, or press the very subtle \\\"(...)\\\" link you see near the console.error message that probably brought you here.\\nThat stack is more interesting than the stack of this console.error itself.\\n\\nIf the exception you see is an exception you created yourself, make sure to use `throw new Error(\\\"Oops\\\")` instead of `throw \\\"Oops\\\"`,\\nbecause the javascript environment will only preserve the original stack trace in the first form.\\n\\nYou can also make sure the debugger pauses the next time this very same exception is thrown by enabling \\\"Pause on caught exception\\\".\\n(Note that it might pause on many other, unrelated exception as well).\\n\\nIf that all doesn't help you out, feel free to open an issue https://github.com/mobxjs/mobx/issues!\\n\",\n m038: \"Missing items in this list?\\n 1. Check whether all used values are properly marked as observable (use isObservable to verify)\\n 2. Make sure you didn't dereference values too early. MobX observes props, not primitives. E.g: use 'person.name' instead of 'name' in your computation.\\n\"\n};\nfunction getMessage(id) {\n return messages[id];\n}\n\nfunction createAction(actionName, fn) {\n invariant(typeof fn === \"function\", getMessage(\"m026\"));\n invariant(typeof actionName === \"string\" && actionName.length > 0, \"actions should have valid names, got: '\" + actionName + \"'\");\n var res = function () {\n return executeAction(actionName, fn, this, arguments);\n };\n res.originalFn = fn;\n res.isMobxAction = true;\n return res;\n}\nfunction executeAction(actionName, fn, scope, args) {\n var runInfo = startAction(actionName, fn, scope, args);\n try {\n return fn.apply(scope, args);\n }\n finally {\n endAction(runInfo);\n }\n}\nfunction startAction(actionName, fn, scope, args) {\n var notifySpy = isSpyEnabled() && !!actionName;\n var startTime = 0;\n if (notifySpy) {\n startTime = Date.now();\n var l = (args && args.length) || 0;\n var flattendArgs = new Array(l);\n if (l > 0)\n for (var i = 0; i < l; i++)\n flattendArgs[i] = args[i];\n spyReportStart({\n type: \"action\",\n name: actionName,\n fn: fn,\n object: scope,\n arguments: flattendArgs\n });\n }\n var prevDerivation = untrackedStart();\n startBatch();\n var prevAllowStateChanges = allowStateChangesStart(true);\n return {\n prevDerivation: prevDerivation,\n prevAllowStateChanges: prevAllowStateChanges,\n notifySpy: notifySpy,\n startTime: startTime\n };\n}\nfunction endAction(runInfo) {\n allowStateChangesEnd(runInfo.prevAllowStateChanges);\n endBatch();\n untrackedEnd(runInfo.prevDerivation);\n if (runInfo.notifySpy)\n spyReportEnd({ time: Date.now() - runInfo.startTime });\n}\nfunction useStrict(strict) {\n invariant(globalState.trackingDerivation === null, getMessage(\"m028\"));\n globalState.strictMode = strict;\n globalState.allowStateChanges = !strict;\n}\nfunction isStrictModeEnabled() {\n return globalState.strictMode;\n}\nfunction allowStateChanges(allowStateChanges, func) {\n // TODO: deprecate / refactor this function in next major\n // Currently only used by `@observer`\n // Proposed change: remove first param, rename to `forbidStateChanges`,\n // require error callback instead of the hardcoded error message now used\n // Use `inAction` instead of allowStateChanges in derivation.ts to check strictMode\n var prev = allowStateChangesStart(allowStateChanges);\n var res;\n try {\n res = func();\n }\n finally {\n allowStateChangesEnd(prev);\n }\n return res;\n}\nfunction allowStateChangesStart(allowStateChanges) {\n var prev = globalState.allowStateChanges;\n globalState.allowStateChanges = allowStateChanges;\n return prev;\n}\nfunction allowStateChangesEnd(prev) {\n globalState.allowStateChanges = prev;\n}\n\n/**\n * Constructs a decorator, that normalizes the differences between\n * TypeScript and Babel. Mainly caused by the fact that legacy-decorator cannot assign\n * values during instance creation to properties that have a getter setter.\n *\n * - Sigh -\n *\n * Also takes care of the difference between @decorator field and @decorator(args) field, and different forms of values.\n * For performance (cpu and mem) reasons the properties are always defined on the prototype (at least initially).\n * This means that these properties despite being enumerable might not show up in Object.keys() (but they will show up in for...in loops).\n */\nfunction createClassPropertyDecorator(\n/**\n * This function is invoked once, when the property is added to a new instance.\n * When this happens is not strictly determined due to differences in TS and Babel:\n * Typescript: Usually when constructing the new instance\n * Babel, sometimes Typescript: during the first get / set\n * Both: when calling `runLazyInitializers(instance)`\n */\nonInitialize, get, set, enumerable, \n/**\n * Can this decorator invoked with arguments? e.g. @decorator(args)\n */\nallowCustomArguments) {\n function classPropertyDecorator(target, key, descriptor, customArgs, argLen) {\n if (argLen === void 0) { argLen = 0; }\n invariant(allowCustomArguments || quacksLikeADecorator(arguments), \"This function is a decorator, but it wasn't invoked like a decorator\");\n if (!descriptor) {\n // typescript (except for getter / setters)\n var newDescriptor = {\n enumerable: enumerable,\n configurable: true,\n get: function () {\n if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true)\n typescriptInitializeProperty(this, key, undefined, onInitialize, customArgs, descriptor);\n return get.call(this, key);\n },\n set: function (v) {\n if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true) {\n typescriptInitializeProperty(this, key, v, onInitialize, customArgs, descriptor);\n }\n else {\n set.call(this, key, v);\n }\n }\n };\n if (arguments.length < 3 || (arguments.length === 5 && argLen < 3)) {\n // Typescript target is ES3, so it won't define property for us\n // or using Reflect.decorate polyfill, which will return no descriptor\n // (see https://github.com/mobxjs/mobx/issues/333)\n Object.defineProperty(target, key, newDescriptor);\n }\n return newDescriptor;\n }\n else {\n // babel and typescript getter / setter props\n if (!hasOwnProperty(target, \"__mobxLazyInitializers\")) {\n addHiddenProp(target, \"__mobxLazyInitializers\", (target.__mobxLazyInitializers && target.__mobxLazyInitializers.slice()) || [] // support inheritance\n );\n }\n var value_1 = descriptor.value, initializer_1 = descriptor.initializer;\n target.__mobxLazyInitializers.push(function (instance) {\n onInitialize(instance, key, initializer_1 ? initializer_1.call(instance) : value_1, customArgs, descriptor);\n });\n return {\n enumerable: enumerable,\n configurable: true,\n get: function () {\n if (this.__mobxDidRunLazyInitializers !== true)\n runLazyInitializers(this);\n return get.call(this, key);\n },\n set: function (v) {\n if (this.__mobxDidRunLazyInitializers !== true)\n runLazyInitializers(this);\n set.call(this, key, v);\n }\n };\n }\n }\n if (allowCustomArguments) {\n /** If custom arguments are allowed, we should return a function that returns a decorator */\n return function () {\n /** Direct invocation: @decorator bla */\n if (quacksLikeADecorator(arguments))\n return classPropertyDecorator.apply(null, arguments);\n /** Indirect invocation: @decorator(args) bla */\n var outerArgs = arguments;\n var argLen = arguments.length;\n return function (target, key, descriptor) {\n return classPropertyDecorator(target, key, descriptor, outerArgs, argLen);\n };\n };\n }\n return classPropertyDecorator;\n}\nfunction typescriptInitializeProperty(instance, key, v, onInitialize, customArgs, baseDescriptor) {\n if (!hasOwnProperty(instance, \"__mobxInitializedProps\"))\n addHiddenProp(instance, \"__mobxInitializedProps\", {});\n instance.__mobxInitializedProps[key] = true;\n onInitialize(instance, key, v, customArgs, baseDescriptor);\n}\nfunction runLazyInitializers(instance) {\n if (instance.__mobxDidRunLazyInitializers === true)\n return;\n if (instance.__mobxLazyInitializers) {\n addHiddenProp(instance, \"__mobxDidRunLazyInitializers\", true);\n instance.__mobxDidRunLazyInitializers &&\n instance.__mobxLazyInitializers.forEach(function (initializer) { return initializer(instance); });\n }\n}\nfunction quacksLikeADecorator(args) {\n return (args.length === 2 || args.length === 3) && typeof args[1] === \"string\";\n}\n\nvar actionFieldDecorator = createClassPropertyDecorator(function (target, key, value, args, originalDescriptor) {\n var actionName = args && args.length === 1 ? args[0] : value.name || key || \"<unnamed action>\";\n var wrappedAction = action(actionName, value);\n addHiddenProp(target, key, wrappedAction);\n}, function (key) {\n return this[key];\n}, function () {\n invariant(false, getMessage(\"m001\"));\n}, false, true);\nvar boundActionDecorator = createClassPropertyDecorator(function (target, key, value) {\n defineBoundAction(target, key, value);\n}, function (key) {\n return this[key];\n}, function () {\n invariant(false, getMessage(\"m001\"));\n}, false, false);\nvar action = function action(arg1, arg2, arg3, arg4) {\n if (arguments.length === 1 && typeof arg1 === \"function\")\n return createAction(arg1.name || \"<unnamed action>\", arg1);\n if (arguments.length === 2 && typeof arg2 === \"function\")\n return createAction(arg1, arg2);\n if (arguments.length === 1 && typeof arg1 === \"string\")\n return namedActionDecorator(arg1);\n return namedActionDecorator(arg2).apply(null, arguments);\n};\naction.bound = function boundAction(arg1, arg2, arg3) {\n if (typeof arg1 === \"function\") {\n var action_1 = createAction(\"<not yet bound action>\", arg1);\n action_1.autoBind = true;\n return action_1;\n }\n return boundActionDecorator.apply(null, arguments);\n};\nfunction namedActionDecorator(name) {\n return function (target, prop, descriptor) {\n if (descriptor && typeof descriptor.value === \"function\") {\n // TypeScript @action method() { }. Defined on proto before being decorated\n // Don't use the field decorator if we are just decorating a method\n descriptor.value = createAction(name, descriptor.value);\n descriptor.enumerable = false;\n descriptor.configurable = true;\n return descriptor;\n }\n if (descriptor !== undefined && descriptor.get !== undefined) {\n throw new Error(\"[mobx] action is not expected to be used with getters\");\n }\n // bound instance methods\n return actionFieldDecorator(name).apply(this, arguments);\n };\n}\nfunction runInAction(arg1, arg2, arg3) {\n var actionName = typeof arg1 === \"string\" ? arg1 : arg1.name || \"<unnamed action>\";\n var fn = typeof arg1 === \"function\" ? arg1 : arg2;\n var scope = typeof arg1 === \"function\" ? arg2 : arg3;\n invariant(typeof fn === \"function\", getMessage(\"m002\"));\n invariant(fn.length === 0, getMessage(\"m003\"));\n invariant(typeof actionName === \"string\" && actionName.length > 0, \"actions should have valid names, got: '\" + actionName + \"'\");\n return executeAction(actionName, fn, scope, undefined);\n}\nfunction isAction(thing) {\n return typeof thing === \"function\" && thing.isMobxAction === true;\n}\nfunction defineBoundAction(target, propertyName, fn) {\n var res = function () {\n return executeAction(propertyName, fn, target, arguments);\n };\n res.isMobxAction = true;\n addHiddenProp(target, propertyName, res);\n}\n\nvar toString = Object.prototype.toString;\nfunction deepEqual(a, b) {\n return eq(a, b);\n}\n// Copied from https://github.com/jashkenas/underscore/blob/5c237a7c682fb68fd5378203f0bf22dce1624854/underscore.js#L1186-L1289\n// Internal recursive comparison function for `isEqual`.\nfunction eq(a, b, aStack, bStack) {\n // Identical objects are equal. `0 === -0`, but they aren't identical.\n // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n if (a === b)\n return a !== 0 || 1 / a === 1 / b;\n // `null` or `undefined` only equal to itself (strict comparison).\n if (a == null || b == null)\n return false;\n // `NaN`s are equivalent, but non-reflexive.\n if (a !== a)\n return b !== b;\n // Exhaust primitive checks\n var type = typeof a;\n if (type !== \"function\" && type !== \"object\" && typeof b != \"object\")\n return false;\n return deepEq(a, b, aStack, bStack);\n}\n// Internal recursive comparison function for `isEqual`.\nfunction deepEq(a, b, aStack, bStack) {\n // Unwrap any wrapped objects.\n a = unwrap(a);\n b = unwrap(b);\n // Compare `[[Class]]` names.\n var className = toString.call(a);\n if (className !== toString.call(b))\n return false;\n switch (className) {\n // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n case \"[object RegExp]\":\n // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n case \"[object String]\":\n // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n // equivalent to `new String(\"5\")`.\n return \"\" + a === \"\" + b;\n case \"[object Number]\":\n // `NaN`s are equivalent, but non-reflexive.\n // Object(NaN) is equivalent to NaN.\n if (+a !== +a)\n return +b !== +b;\n // An `egal` comparison is performed for other numeric values.\n return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n case \"[object Date]\":\n case \"[object Boolean]\":\n // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n // millisecond representations. Note that invalid dates with millisecond representations\n // of `NaN` are not equivalent.\n return +a === +b;\n case \"[object Symbol]\":\n return (typeof Symbol !== \"undefined\" && Symbol.valueOf.call(a) === Symbol.valueOf.call(b));\n }\n var areArrays = className === \"[object Array]\";\n if (!areArrays) {\n if (typeof a != \"object\" || typeof b != \"object\")\n return false;\n // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n // from different frames are.\n var aCtor = a.constructor, bCtor = b.constructor;\n if (aCtor !== bCtor &&\n !(typeof aCtor === \"function\" &&\n aCtor instanceof aCtor &&\n typeof bCtor === \"function\" &&\n bCtor instanceof bCtor) &&\n (\"constructor\" in a && \"constructor\" in b)) {\n return false;\n }\n }\n // Assume equality for cyclic structures. The algorithm for detecting cyclic\n // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n // Initializing stack of traversed objects.\n // It's done here since we only need them for objects and arrays comparison.\n aStack = aStack || [];\n bStack = bStack || [];\n var length = aStack.length;\n while (length--) {\n // Linear search. Performance is inversely proportional to the number of\n // unique nested structures.\n if (aStack[length] === a)\n return bStack[length] === b;\n }\n // Add the first object to the stack of traversed objects.\n aStack.push(a);\n bStack.push(b);\n // Recursively compare objects and arrays.\n if (areArrays) {\n // Compare array lengths to determine if a deep comparison is necessary.\n length = a.length;\n if (length !== b.length)\n return false;\n // Deep compare the contents, ignoring non-numeric properties.\n while (length--) {\n if (!eq(a[length], b[length], aStack, bStack))\n return false;\n }\n }\n else {\n // Deep compare objects.\n var keys = Object.keys(a), key;\n length = keys.length;\n // Ensure that both objects contain the same number of properties before comparing deep equality.\n if (Object.keys(b).length !== length)\n return false;\n while (length--) {\n // Deep compare each member\n key = keys[length];\n if (!(has(b, key) && eq(a[key], b[key], aStack, bStack)))\n return false;\n }\n }\n // Remove the first object from the stack of traversed objects.\n aStack.pop();\n bStack.pop();\n return true;\n}\nfunction unwrap(a) {\n if (isObservableArray(a))\n return a.peek();\n if (isObservableMap(a))\n return a.entries();\n if (isES6Map(a))\n return iteratorToArray(a.entries());\n return a;\n}\nfunction has(a, key) {\n return Object.prototype.hasOwnProperty.call(a, key);\n}\n\nfunction identityComparer(a, b) {\n return a === b;\n}\nfunction structuralComparer(a, b) {\n return deepEqual(a, b);\n}\nfunction defaultComparer(a, b) {\n return areBothNaN(a, b) || identityComparer(a, b);\n}\nvar comparer = {\n identity: identityComparer,\n structural: structuralComparer,\n default: defaultComparer\n};\n\nfunction autorun(arg1, arg2, arg3) {\n var name, view, scope;\n if (typeof arg1 === \"string\") {\n name = arg1;\n view = arg2;\n scope = arg3;\n }\n else {\n name = arg1.name || \"Autorun@\" + getNextId();\n view = arg1;\n scope = arg2;\n }\n invariant(typeof view === \"function\", getMessage(\"m004\"));\n invariant(isAction(view) === false, getMessage(\"m005\"));\n if (scope)\n view = view.bind(scope);\n var reaction = new Reaction(name, function () {\n this.track(reactionRunner);\n });\n function reactionRunner() {\n view(reaction);\n }\n reaction.schedule();\n return reaction.getDisposer();\n}\nfunction when(arg1, arg2, arg3, arg4) {\n var name, predicate, effect, scope;\n if (typeof arg1 === \"string\") {\n name = arg1;\n predicate = arg2;\n effect = arg3;\n scope = arg4;\n }\n else {\n name = \"When@\" + getNextId();\n predicate = arg1;\n effect = arg2;\n scope = arg3;\n }\n var disposer = autorun(name, function (r) {\n if (predicate.call(scope)) {\n r.dispose();\n var prevUntracked = untrackedStart();\n effect.call(scope);\n untrackedEnd(prevUntracked);\n }\n });\n return disposer;\n}\nfunction autorunAsync(arg1, arg2, arg3, arg4) {\n var name, func, delay, scope;\n if (typeof arg1 === \"string\") {\n name = arg1;\n func = arg2;\n delay = arg3;\n scope = arg4;\n }\n else {\n name = arg1.name || \"AutorunAsync@\" + getNextId();\n func = arg1;\n delay = arg2;\n scope = arg3;\n }\n invariant(isAction(func) === false, getMessage(\"m006\"));\n if (delay === void 0)\n delay = 1;\n if (scope)\n func = func.bind(scope);\n var isScheduled = false;\n var r = new Reaction(name, function () {\n if (!isScheduled) {\n isScheduled = true;\n setTimeout(function () {\n isScheduled = false;\n if (!r.isDisposed)\n r.track(reactionRunner);\n }, delay);\n }\n });\n function reactionRunner() {\n func(r);\n }\n r.schedule();\n return r.getDisposer();\n}\nfunction reaction(expression, effect, arg3) {\n if (arguments.length > 3) {\n fail(getMessage(\"m007\"));\n }\n if (isModifierDescriptor(expression)) {\n fail(getMessage(\"m008\"));\n }\n var opts;\n if (typeof arg3 === \"object\") {\n opts = arg3;\n }\n else {\n opts = {};\n }\n opts.name =\n opts.name || expression.name || effect.name || \"Reaction@\" + getNextId();\n opts.fireImmediately = arg3 === true || opts.fireImmediately === true;\n opts.delay = opts.delay || 0;\n opts.compareStructural = opts.compareStructural || opts.struct || false;\n // TODO: creates ugly spy events, use `effect = (r) => runInAction(opts.name, () => effect(r))` instead\n effect = action(opts.name, opts.context ? effect.bind(opts.context) : effect);\n if (opts.context) {\n expression = expression.bind(opts.context);\n }\n var firstTime = true;\n var isScheduled = false;\n var value;\n var equals = opts.equals\n ? opts.equals\n : opts.compareStructural || opts.struct ? comparer.structural : comparer.default;\n var r = new Reaction(opts.name, function () {\n if (firstTime || opts.delay < 1) {\n reactionRunner();\n }\n else if (!isScheduled) {\n isScheduled = true;\n setTimeout(function () {\n isScheduled = false;\n reactionRunner();\n }, opts.delay);\n }\n });\n function reactionRunner() {\n if (r.isDisposed)\n return;\n var changed = false;\n r.track(function () {\n var nextValue = expression(r);\n changed = firstTime || !equals(value, nextValue);\n value = nextValue;\n });\n if (firstTime && opts.fireImmediately)\n effect(value, r);\n if (!firstTime && changed === true)\n effect(value, r);\n if (firstTime)\n firstTime = false;\n }\n r.schedule();\n return r.getDisposer();\n}\n\n/**\n * A node in the state dependency root that observes other nodes, and can be observed itself.\n *\n * ComputedValue will remember the result of the computation for the duration of the batch, or\n * while being observed.\n *\n * During this time it will recompute only when one of its direct dependencies changed,\n * but only when it is being accessed with `ComputedValue.get()`.\n *\n * Implementation description:\n * 1. First time it's being accessed it will compute and remember result\n * give back remembered result until 2. happens\n * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.\n * 3. When it's being accessed, recompute if any shallow dependency changed.\n * if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.\n * go to step 2. either way\n *\n * If at any point it's outside batch and it isn't observed: reset everything and go to 1.\n */\nvar ComputedValue = /** @class */ (function () {\n /**\n * Create a new computed value based on a function expression.\n *\n * The `name` property is for debug purposes only.\n *\n * The `equals` property specifies the comparer function to use to determine if a newly produced\n * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`\n * compares based on identity comparison (===), and `structualComparer` deeply compares the structure.\n * Structural comparison can be convenient if you always produce an new aggregated object and\n * don't want to notify observers if it is structurally the same.\n * This is useful for working with vectors, mouse coordinates etc.\n */\n function ComputedValue(derivation, scope, equals, name, setter) {\n this.derivation = derivation;\n this.scope = scope;\n this.equals = equals;\n this.dependenciesState = IDerivationState.NOT_TRACKING;\n this.observing = []; // nodes we are looking at. Our value depends on these nodes\n this.newObserving = null; // during tracking it's an array with new observed observers\n this.isPendingUnobservation = false;\n this.observers = [];\n this.observersIndexes = {};\n this.diffValue = 0;\n this.runId = 0;\n this.lastAccessedBy = 0;\n this.lowestObserverState = IDerivationState.UP_TO_DATE;\n this.unboundDepsCount = 0;\n this.__mapid = \"#\" + getNextId();\n this.value = new CaughtException(null);\n this.isComputing = false; // to check for cycles\n this.isRunningSetter = false;\n this.isTracing = TraceMode.NONE;\n this.name = name || \"ComputedValue@\" + getNextId();\n if (setter)\n this.setter = createAction(name + \"-setter\", setter);\n }\n ComputedValue.prototype.onBecomeStale = function () {\n propagateMaybeChanged(this);\n };\n ComputedValue.prototype.onBecomeUnobserved = function () {\n clearObserving(this);\n this.value = undefined;\n };\n /**\n * Returns the current value of this computed value.\n * Will evaluate its computation first if needed.\n */\n ComputedValue.prototype.get = function () {\n invariant(!this.isComputing, \"Cycle detected in computation \" + this.name, this.derivation);\n if (globalState.inBatch === 0) {\n // This is an minor optimization which could be omitted to simplify the code\n // The computedValue is accessed outside of any mobx stuff. Batch observing should be enough and don't need\n // tracking as it will never be called again inside this batch.\n startBatch();\n if (shouldCompute(this)) {\n if (this.isTracing !== TraceMode.NONE) {\n console.log(\"[mobx.trace] '\" + this\n .name + \"' is being read outside a reactive context and doing a full recompute\");\n }\n this.value = this.computeValue(false);\n }\n endBatch();\n }\n else {\n reportObserved(this);\n if (shouldCompute(this))\n if (this.trackAndCompute())\n propagateChangeConfirmed(this);\n }\n var result = this.value;\n if (isCaughtException(result))\n throw result.cause;\n return result;\n };\n ComputedValue.prototype.peek = function () {\n var res = this.computeValue(false);\n if (isCaughtException(res))\n throw res.cause;\n return res;\n };\n ComputedValue.prototype.set = function (value) {\n if (this.setter) {\n invariant(!this.isRunningSetter, \"The setter of computed value '\" + this\n .name + \"' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?\");\n this.isRunningSetter = true;\n try {\n this.setter.call(this.scope, value);\n }\n finally {\n this.isRunningSetter = false;\n }\n }\n else\n invariant(false, \"[ComputedValue '\" + this\n .name + \"'] It is not possible to assign a new value to a computed value.\");\n };\n ComputedValue.prototype.trackAndCompute = function () {\n if (isSpyEnabled()) {\n spyReport({\n object: this.scope,\n type: \"compute\",\n fn: this.derivation\n });\n }\n var oldValue = this.value;\n var wasSuspended = \n /* see #1208 */ this.dependenciesState === IDerivationState.NOT_TRACKING;\n var newValue = (this.value = this.computeValue(true));\n return (wasSuspended ||\n isCaughtException(oldValue) ||\n isCaughtException(newValue) ||\n !this.equals(oldValue, newValue));\n };\n ComputedValue.prototype.computeValue = function (track) {\n this.isComputing = true;\n globalState.computationDepth++;\n var res;\n if (track) {\n res = trackDerivedFunction(this, this.derivation, this.scope);\n }\n else {\n try {\n res = this.derivation.call(this.scope);\n }\n catch (e) {\n res = new CaughtException(e);\n }\n }\n globalState.computationDepth--;\n this.isComputing = false;\n return res;\n };\n ComputedValue.prototype.observe = function (listener, fireImmediately) {\n var _this = this;\n var firstTime = true;\n var prevValue = undefined;\n return autorun(function () {\n var newValue = _this.get();\n if (!firstTime || fireImmediately) {\n var prevU = untrackedStart();\n listener({\n type: \"update\",\n object: _this,\n newValue: newValue,\n oldValue: prevValue\n });\n untrackedEnd(prevU);\n }\n firstTime = false;\n prevValue = newValue;\n });\n };\n ComputedValue.prototype.toJSON = function () {\n return this.get();\n };\n ComputedValue.prototype.toString = function () {\n return this.name + \"[\" + this.derivation.toString() + \"]\";\n };\n ComputedValue.prototype.valueOf = function () {\n return toPrimitive(this.get());\n };\n ComputedValue.prototype.whyRun = function () {\n var isTracking = Boolean(globalState.trackingDerivation);\n var observing = unique(this.isComputing ? this.newObserving : this.observing).map(function (dep) { return dep.name; });\n var observers = unique(getObservers(this).map(function (dep) { return dep.name; }));\n return (\"\\nWhyRun? computation '\" + this.name + \"':\\n * Running because: \" + (isTracking\n ? \"[active] the value of this computation is needed by a reaction\"\n : this.isComputing\n ? \"[get] The value of this computed was requested outside a reaction\"\n : \"[idle] not running at the moment\") + \"\\n\" +\n (this.dependenciesState === IDerivationState.NOT_TRACKING\n ? getMessage(\"m032\")\n : \" * This computation will re-run if any of the following observables changes:\\n \" + joinStrings(observing) + \"\\n \" + (this.isComputing && isTracking\n ? \" (... or any observable accessed during the remainder of the current run)\"\n : \"\") + \"\\n \" + getMessage(\"m038\") + \"\\n\\n * If the outcome of this computation changes, the following observers will be re-run:\\n \" + joinStrings(observers) + \"\\n\"));\n };\n return ComputedValue;\n}());\nComputedValue.prototype[primitiveSymbol()] = ComputedValue.prototype.valueOf;\nvar isComputedValue = createInstanceofPredicate(\"ComputedValue\", ComputedValue);\n\nvar ObservableObjectAdministration = /** @class */ (function () {\n function ObservableObjectAdministration(target, name) {\n this.target = target;\n this.name = name;\n this.values = {};\n this.changeListeners = null;\n this.interceptors = null;\n }\n /**\n * Observes this object. Triggers for the events 'add', 'update' and 'delete'.\n * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe\n * for callback details\n */\n ObservableObjectAdministration.prototype.observe = function (callback, fireImmediately) {\n invariant(fireImmediately !== true, \"`observe` doesn't support the fire immediately property for observable objects.\");\n return registerListener(this, callback);\n };\n ObservableObjectAdministration.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n return ObservableObjectAdministration;\n}());\nfunction asObservableObject(target, name) {\n if (isObservableObject(target) && target.hasOwnProperty(\"$mobx\"))\n return target.$mobx;\n invariant(Object.isExtensible(target), getMessage(\"m035\"));\n if (!isPlainObject(target))\n name = (target.constructor.name || \"ObservableObject\") + \"@\" + getNextId();\n if (!name)\n name = \"ObservableObject@\" + getNextId();\n var adm = new ObservableObjectAdministration(target, name);\n addHiddenFinalProp(target, \"$mobx\", adm);\n return adm;\n}\nfunction defineObservablePropertyFromDescriptor(adm, propName, descriptor, defaultEnhancer) {\n if (adm.values[propName] && !isComputedValue(adm.values[propName])) {\n // already observable property\n invariant(\"value\" in descriptor, \"The property \" + propName + \" in \" + adm.name + \" is already observable, cannot redefine it as computed property\");\n adm.target[propName] = descriptor.value; // the property setter will make 'value' reactive if needed.\n return;\n }\n // not yet observable property\n if (\"value\" in descriptor) {\n // not a computed value\n if (isModifierDescriptor(descriptor.value)) {\n // x : ref(someValue)\n var modifierDescriptor = descriptor.value;\n defineObservableProperty(adm, propName, modifierDescriptor.initialValue, modifierDescriptor.enhancer);\n }\n else if (isAction(descriptor.value) && descriptor.value.autoBind === true) {\n defineBoundAction(adm.target, propName, descriptor.value.originalFn);\n }\n else if (isComputedValue(descriptor.value)) {\n // x: computed(someExpr)\n defineComputedPropertyFromComputedValue(adm, propName, descriptor.value);\n }\n else {\n // x: someValue\n defineObservableProperty(adm, propName, descriptor.value, defaultEnhancer);\n }\n }\n else {\n // get x() { return 3 } set x(v) { }\n defineComputedProperty(adm, propName, descriptor.get, descriptor.set, comparer.default, true);\n }\n}\nfunction defineObservableProperty(adm, propName, newValue, enhancer) {\n assertPropertyConfigurable(adm.target, propName);\n if (hasInterceptors(adm)) {\n var change = interceptChange(adm, {\n object: adm.target,\n name: propName,\n type: \"add\",\n newValue: newValue\n });\n if (!change)\n return;\n newValue = change.newValue;\n }\n var observable = (adm.values[propName] = new ObservableValue(newValue, enhancer, adm.name + \".\" + propName, false));\n newValue = observable.value; // observableValue might have changed it\n Object.defineProperty(adm.target, propName, generateObservablePropConfig(propName));\n notifyPropertyAddition(adm, adm.target, propName, newValue);\n}\nfunction defineComputedProperty(adm, propName, getter, setter, equals, asInstanceProperty) {\n if (asInstanceProperty)\n assertPropertyConfigurable(adm.target, propName);\n adm.values[propName] = new ComputedValue(getter, adm.target, equals, adm.name + \".\" + propName, setter);\n if (asInstanceProperty) {\n Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName));\n }\n}\nfunction defineComputedPropertyFromComputedValue(adm, propName, computedValue) {\n var name = adm.name + \".\" + propName;\n computedValue.name = name;\n if (!computedValue.scope)\n computedValue.scope = adm.target;\n adm.values[propName] = computedValue;\n Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName));\n}\nvar observablePropertyConfigs = {};\nvar computedPropertyConfigs = {};\nfunction generateObservablePropConfig(propName) {\n return (observablePropertyConfigs[propName] ||\n (observablePropertyConfigs[propName] = {\n configurable: true,\n enumerable: true,\n get: function () {\n return this.$mobx.values[propName].get();\n },\n set: function (v) {\n setPropertyValue(this, propName, v);\n }\n }));\n}\nfunction generateComputedPropConfig(propName) {\n return (computedPropertyConfigs[propName] ||\n (computedPropertyConfigs[propName] = {\n configurable: true,\n enumerable: false,\n get: function () {\n return this.$mobx.values[propName].get();\n },\n set: function (v) {\n return this.$mobx.values[propName].set(v);\n }\n }));\n}\nfunction setPropertyValue(instance, name, newValue) {\n var adm = instance.$mobx;\n var observable = adm.values[name];\n // intercept\n if (hasInterceptors(adm)) {\n var change = interceptChange(adm, {\n type: \"update\",\n object: instance,\n name: name,\n newValue: newValue\n });\n if (!change)\n return;\n newValue = change.newValue;\n }\n newValue = observable.prepareNewValue(newValue);\n // notify spy & observers\n if (newValue !== UNCHANGED) {\n var notify = hasListeners(adm);\n var notifySpy = isSpyEnabled();\n var change = notify || notifySpy\n ? {\n type: \"update\",\n object: instance,\n oldValue: observable.value,\n name: name,\n newValue: newValue\n }\n : null;\n if (notifySpy)\n spyReportStart(change);\n observable.setNewValue(newValue);\n if (notify)\n notifyListeners(adm, change);\n if (notifySpy)\n spyReportEnd();\n }\n}\nfunction notifyPropertyAddition(adm, object, name, newValue) {\n var notify = hasListeners(adm);\n var notifySpy = isSpyEnabled();\n var change = notify || notifySpy\n ? {\n type: \"add\",\n object: object,\n name: name,\n newValue: newValue\n }\n : null;\n if (notifySpy)\n spyReportStart(change);\n if (notify)\n notifyListeners(adm, change);\n if (notifySpy)\n spyReportEnd();\n}\nvar isObservableObjectAdministration = createInstanceofPredicate(\"ObservableObjectAdministration\", ObservableObjectAdministration);\nfunction isObservableObject(thing) {\n if (isObject(thing)) {\n // Initializers run lazily when transpiling to babel, so make sure they are run...\n runLazyInitializers(thing);\n return isObservableObjectAdministration(thing.$mobx);\n }\n return false;\n}\n\n/**\n * Returns true if the provided value is reactive.\n * @param value object, function or array\n * @param property if property is specified, checks whether value.property is reactive.\n */\nfunction isObservable(value, property) {\n if (value === null || value === undefined)\n return false;\n if (property !== undefined) {\n if (isObservableArray(value) || isObservableMap(value))\n throw new Error(getMessage(\"m019\"));\n else if (isObservableObject(value)) {\n var o = value.$mobx;\n return o.values && !!o.values[property];\n }\n return false;\n }\n // For first check, see #701\n return (isObservableObject(value) ||\n !!value.$mobx ||\n isAtom(value) ||\n isReaction(value) ||\n isComputedValue(value));\n}\n\nfunction createDecoratorForEnhancer(enhancer) {\n invariant(!!enhancer, \":(\");\n return createClassPropertyDecorator(function (target, name, baseValue, _, baseDescriptor) {\n assertPropertyConfigurable(target, name);\n invariant(!baseDescriptor || !baseDescriptor.get, getMessage(\"m022\"));\n var adm = asObservableObject(target, undefined);\n defineObservableProperty(adm, name, baseValue, enhancer);\n }, function (name) {\n var observable = this.$mobx.values[name];\n if (observable === undefined // See #505\n )\n return undefined;\n return observable.get();\n }, function (name, value) {\n setPropertyValue(this, name, value);\n }, true, false);\n}\n\nfunction extendObservable(target) {\n var properties = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n properties[_i - 1] = arguments[_i];\n }\n return extendObservableHelper(target, deepEnhancer, properties);\n}\nfunction extendShallowObservable(target) {\n var properties = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n properties[_i - 1] = arguments[_i];\n }\n return extendObservableHelper(target, referenceEnhancer, properties);\n}\nfunction extendObservableHelper(target, defaultEnhancer, properties) {\n invariant(arguments.length >= 2, getMessage(\"m014\"));\n invariant(typeof target === \"object\", getMessage(\"m015\"));\n invariant(!isObservableMap(target), getMessage(\"m016\"));\n properties.forEach(function (propSet) {\n invariant(typeof propSet === \"object\", getMessage(\"m017\"));\n invariant(!isObservable(propSet), getMessage(\"m018\"));\n });\n var adm = asObservableObject(target);\n var definedProps = {};\n // Note could be optimised if properties.length === 1\n for (var i = properties.length - 1; i >= 0; i--) {\n var propSet = properties[i];\n for (var key in propSet)\n if (definedProps[key] !== true && hasOwnProperty(propSet, key)) {\n definedProps[key] = true;\n if (target === propSet && !isPropertyConfigurable(target, key))\n continue; // see #111, skip non-configurable or non-writable props for `observable(object)`.\n var descriptor = Object.getOwnPropertyDescriptor(propSet, key);\n defineObservablePropertyFromDescriptor(adm, key, descriptor, defaultEnhancer);\n }\n }\n return target;\n}\n\nvar deepDecorator = createDecoratorForEnhancer(deepEnhancer);\nvar shallowDecorator = createDecoratorForEnhancer(shallowEnhancer);\nvar refDecorator = createDecoratorForEnhancer(referenceEnhancer);\nvar deepStructDecorator = createDecoratorForEnhancer(deepStructEnhancer);\nvar refStructDecorator = createDecoratorForEnhancer(refStructEnhancer);\n/**\n * Turns an object, array or function into a reactive structure.\n * @param v the value which should become observable.\n */\nfunction createObservable(v) {\n if (v === void 0) { v = undefined; }\n // @observable someProp;\n if (typeof arguments[1] === \"string\")\n return deepDecorator.apply(null, arguments);\n invariant(arguments.length <= 1, getMessage(\"m021\"));\n invariant(!isModifierDescriptor(v), getMessage(\"m020\"));\n // it is an observable already, done\n if (isObservable(v))\n return v;\n // something that can be converted and mutated?\n var res = deepEnhancer(v, undefined, undefined);\n // this value could be converted to a new observable data structure, return it\n if (res !== v)\n return res;\n // otherwise, just box it\n return observable.box(v);\n}\nvar observableFactories = {\n box: function (value, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"box\");\n return new ObservableValue(value, deepEnhancer, name);\n },\n shallowBox: function (value, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"shallowBox\");\n return new ObservableValue(value, referenceEnhancer, name);\n },\n array: function (initialValues, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"array\");\n return new ObservableArray(initialValues, deepEnhancer, name);\n },\n shallowArray: function (initialValues, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"shallowArray\");\n return new ObservableArray(initialValues, referenceEnhancer, name);\n },\n map: function (initialValues, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"map\");\n return new ObservableMap(initialValues, deepEnhancer, name);\n },\n shallowMap: function (initialValues, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"shallowMap\");\n return new ObservableMap(initialValues, referenceEnhancer, name);\n },\n object: function (props, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"object\");\n var res = {};\n // convert to observable object\n asObservableObject(res, name);\n // add properties\n extendObservable(res, props);\n return res;\n },\n shallowObject: function (props, name) {\n if (arguments.length > 2)\n incorrectlyUsedAsDecorator(\"shallowObject\");\n var res = {};\n asObservableObject(res, name);\n extendShallowObservable(res, props);\n return res;\n },\n ref: function () {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(referenceEnhancer, arguments[0]);\n }\n else {\n return refDecorator.apply(null, arguments);\n }\n },\n shallow: function () {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(shallowEnhancer, arguments[0]);\n }\n else {\n return shallowDecorator.apply(null, arguments);\n }\n },\n deep: function () {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(deepEnhancer, arguments[0]);\n }\n else {\n return deepDecorator.apply(null, arguments);\n }\n },\n struct: function () {\n if (arguments.length < 2) {\n // although ref creates actually a modifier descriptor, the type of the resultig properties\n // of the object is `T` in the end, when the descriptors are interpreted\n return createModifierDescriptor(deepStructEnhancer, arguments[0]);\n }\n else {\n return deepStructDecorator.apply(null, arguments);\n }\n }\n};\nvar observable = createObservable;\n// weird trick to keep our typings nicely with our funcs, and still extend the observable function\nObject.keys(observableFactories).forEach(function (name) { return (observable[name] = observableFactories[name]); });\nobservable.deep.struct = observable.struct;\nobservable.ref.struct = function () {\n if (arguments.length < 2) {\n return createModifierDescriptor(refStructEnhancer, arguments[0]);\n }\n else {\n return refStructDecorator.apply(null, arguments);\n }\n};\nfunction incorrectlyUsedAsDecorator(methodName) {\n fail(\"Expected one or two arguments to observable.\" + methodName + \". Did you accidentally try to use observable.\" + methodName + \" as decorator?\");\n}\n\nfunction isModifierDescriptor(thing) {\n return typeof thing === \"object\" && thing !== null && thing.isMobxModifierDescriptor === true;\n}\nfunction createModifierDescriptor(enhancer, initialValue) {\n invariant(!isModifierDescriptor(initialValue), \"Modifiers cannot be nested\");\n return {\n isMobxModifierDescriptor: true,\n initialValue: initialValue,\n enhancer: enhancer\n };\n}\nfunction deepEnhancer(v, _, name) {\n if (isModifierDescriptor(v))\n fail(\"You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it\");\n // it is an observable already, done\n if (isObservable(v))\n return v;\n // something that can be converted and mutated?\n if (Array.isArray(v))\n return observable.array(v, name);\n if (isPlainObject(v))\n return observable.object(v, name);\n if (isES6Map(v))\n return observable.map(v, name);\n return v;\n}\nfunction shallowEnhancer(v, _, name) {\n if (isModifierDescriptor(v))\n fail(\"You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it\");\n if (v === undefined || v === null)\n return v;\n if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v))\n return v;\n if (Array.isArray(v))\n return observable.shallowArray(v, name);\n if (isPlainObject(v))\n return observable.shallowObject(v, name);\n if (isES6Map(v))\n return observable.shallowMap(v, name);\n return fail(\"The shallow modifier / decorator can only used in combination with arrays, objects and maps\");\n}\nfunction referenceEnhancer(newValue) {\n // never turn into an observable\n return newValue;\n}\nfunction deepStructEnhancer(v, oldValue, name) {\n // don't confuse structurally compare enhancer with ref enhancer! The latter is probably\n // more suited for immutable objects\n if (deepEqual(v, oldValue))\n return oldValue;\n // it is an observable already, done\n if (isObservable(v))\n return v;\n // something that can be converted and mutated?\n if (Array.isArray(v))\n return new ObservableArray(v, deepStructEnhancer, name);\n if (isES6Map(v))\n return new ObservableMap(v, deepStructEnhancer, name);\n if (isPlainObject(v)) {\n var res = {};\n asObservableObject(res, name);\n extendObservableHelper(res, deepStructEnhancer, [v]);\n return res;\n }\n return v;\n}\nfunction refStructEnhancer(v, oldValue, name) {\n if (deepEqual(v, oldValue))\n return oldValue;\n return v;\n}\n\n/**\n * During a transaction no views are updated until the end of the transaction.\n * The transaction will be run synchronously nonetheless.\n *\n * @param action a function that updates some reactive state\n * @returns any value that was returned by the 'action' parameter.\n */\nfunction transaction(action, thisArg) {\n if (thisArg === void 0) { thisArg = undefined; }\n startBatch();\n try {\n return action.apply(thisArg);\n }\n finally {\n endBatch();\n }\n}\n\nvar ObservableMapMarker = {};\nvar ObservableMap = /** @class */ (function () {\n function ObservableMap(initialData, enhancer, name) {\n if (enhancer === void 0) { enhancer = deepEnhancer; }\n if (name === void 0) { name = \"ObservableMap@\" + getNextId(); }\n this.enhancer = enhancer;\n this.name = name;\n this.$mobx = ObservableMapMarker;\n this._data = Object.create(null);\n this._hasMap = Object.create(null); // hasMap, not hashMap >-).\n this._keys = new ObservableArray(undefined, referenceEnhancer, this.name + \".keys()\", true);\n this.interceptors = null;\n this.changeListeners = null;\n this.dehancer = undefined;\n this.merge(initialData);\n }\n ObservableMap.prototype._has = function (key) {\n return typeof this._data[key] !== \"undefined\";\n };\n ObservableMap.prototype.has = function (key) {\n if (!this.isValidKey(key))\n return false;\n key = \"\" + key;\n if (this._hasMap[key])\n return this._hasMap[key].get();\n return this._updateHasMapEntry(key, false).get();\n };\n ObservableMap.prototype.set = function (key, value) {\n this.assertValidKey(key);\n key = \"\" + key;\n var hasKey = this._has(key);\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n type: hasKey ? \"update\" : \"add\",\n object: this,\n newValue: value,\n name: key\n });\n if (!change)\n return this;\n value = change.newValue;\n }\n if (hasKey) {\n this._updateValue(key, value);\n }\n else {\n this._addValue(key, value);\n }\n return this;\n };\n ObservableMap.prototype.delete = function (key) {\n var _this = this;\n this.assertValidKey(key);\n key = \"\" + key;\n if (hasInterceptors(this)) {\n var change = interceptChange(this, {\n type: \"delete\",\n object: this,\n name: key\n });\n if (!change)\n return false;\n }\n if (this._has(key)) {\n var notifySpy = isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy\n ? {\n type: \"delete\",\n object: this,\n oldValue: this._data[key].value,\n name: key\n }\n : null;\n if (notifySpy)\n spyReportStart(change);\n transaction(function () {\n _this._keys.remove(key);\n _this._updateHasMapEntry(key, false);\n var observable$$1 = _this._data[key];\n observable$$1.setNewValue(undefined);\n _this._data[key] = undefined;\n });\n if (notify)\n notifyListeners(this, change);\n if (notifySpy)\n spyReportEnd();\n return true;\n }\n return false;\n };\n ObservableMap.prototype._updateHasMapEntry = function (key, value) {\n // optimization; don't fill the hasMap if we are not observing, or remove entry if there are no observers anymore\n var entry = this._hasMap[key];\n if (entry) {\n entry.setNewValue(value);\n }\n else {\n entry = this._hasMap[key] = new ObservableValue(value, referenceEnhancer, this.name + \".\" + key + \"?\", false);\n }\n return entry;\n };\n ObservableMap.prototype._updateValue = function (name, newValue) {\n var observable$$1 = this._data[name];\n newValue = observable$$1.prepareNewValue(newValue);\n if (newValue !== UNCHANGED) {\n var notifySpy = isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy\n ? {\n type: \"update\",\n object: this,\n oldValue: observable$$1.value,\n name: name,\n newValue: newValue\n }\n : null;\n if (notifySpy)\n spyReportStart(change);\n observable$$1.setNewValue(newValue);\n if (notify)\n notifyListeners(this, change);\n if (notifySpy)\n spyReportEnd();\n }\n };\n ObservableMap.prototype._addValue = function (name, newValue) {\n var _this = this;\n transaction(function () {\n var observable$$1 = (_this._data[name] = new ObservableValue(newValue, _this.enhancer, _this.name + \".\" + name, false));\n newValue = observable$$1.value; // value might have been changed\n _this._updateHasMapEntry(name, true);\n _this._keys.push(name);\n });\n var notifySpy = isSpyEnabled();\n var notify = hasListeners(this);\n var change = notify || notifySpy\n ? {\n type: \"add\",\n object: this,\n name: name,\n newValue: newValue\n }\n : null;\n if (notifySpy)\n spyReportStart(change);\n if (notify)\n notifyListeners(this, change);\n if (notifySpy)\n spyReportEnd();\n };\n ObservableMap.prototype.get = function (key) {\n key = \"\" + key;\n if (this.has(key))\n return this.dehanceValue(this._data[key].get());\n return this.dehanceValue(undefined);\n };\n ObservableMap.prototype.dehanceValue = function (value) {\n if (this.dehancer !== undefined) {\n return this.dehancer(value);\n }\n return value;\n };\n ObservableMap.prototype.keys = function () {\n return arrayAsIterator(this._keys.slice());\n };\n ObservableMap.prototype.values = function () {\n return arrayAsIterator(this._keys.map(this.get, this));\n };\n ObservableMap.prototype.entries = function () {\n var _this = this;\n return arrayAsIterator(this._keys.map(function (key) { return [key, _this.get(key)]; }));\n };\n ObservableMap.prototype.forEach = function (callback, thisArg) {\n var _this = this;\n this.keys().forEach(function (key) { return callback.call(thisArg, _this.get(key), key, _this); });\n };\n /** Merge another object into this object, returns this. */\n ObservableMap.prototype.merge = function (other) {\n var _this = this;\n if (isObservableMap(other)) {\n other = other.toJS();\n }\n transaction(function () {\n if (isPlainObject(other))\n Object.keys(other).forEach(function (key) { return _this.set(key, other[key]); });\n else if (Array.isArray(other))\n other.forEach(function (_a) {\n var key = _a[0], value = _a[1];\n return _this.set(key, value);\n });\n else if (isES6Map(other))\n other.forEach(function (value, key) { return _this.set(key, value); });\n else if (other !== null && other !== undefined)\n fail(\"Cannot initialize map from \" + other);\n });\n return this;\n };\n ObservableMap.prototype.clear = function () {\n var _this = this;\n transaction(function () {\n untracked(function () {\n _this.keys().forEach(_this.delete, _this);\n });\n });\n };\n ObservableMap.prototype.replace = function (values) {\n var _this = this;\n transaction(function () {\n // grab all the keys that are present in the new map but not present in the current map\n // and delete them from the map, then merge the new map\n // this will cause reactions only on changed values\n var newKeys = getMapLikeKeys(values);\n var oldKeys = _this.keys();\n var missingKeys = oldKeys.filter(function (k) { return newKeys.indexOf(k) === -1; });\n missingKeys.forEach(function (k) { return _this.delete(k); });\n _this.merge(values);\n });\n return this;\n };\n Object.defineProperty(ObservableMap.prototype, \"size\", {\n get: function () {\n return this._keys.length;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Returns a shallow non observable object clone of this map.\n * Note that the values might still be observable. For a deep clone use mobx.toJS.\n */\n ObservableMap.prototype.toJS = function () {\n var _this = this;\n var res = {};\n this.keys().forEach(function (key) { return (res[key] = _this.get(key)); });\n return res;\n };\n ObservableMap.prototype.toJSON = function () {\n // Used by JSON.stringify\n return this.toJS();\n };\n ObservableMap.prototype.isValidKey = function (key) {\n if (key === null || key === undefined)\n return false;\n if (typeof key === \"string\" || typeof key === \"number\" || typeof key === \"boolean\")\n return true;\n return false;\n };\n ObservableMap.prototype.assertValidKey = function (key) {\n if (!this.isValidKey(key))\n throw new Error(\"[mobx.map] Invalid key: '\" + key + \"', only strings, numbers and booleans are accepted as key in observable maps.\");\n };\n ObservableMap.prototype.toString = function () {\n var _this = this;\n return (this.name +\n \"[{ \" +\n this.keys().map(function (key) { return key + \": \" + (\"\" + _this.get(key)); }).join(\", \") +\n \" }]\");\n };\n /**\n * Observes this object. Triggers for the events 'add', 'update' and 'delete'.\n * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe\n * for callback details\n */\n ObservableMap.prototype.observe = function (listener, fireImmediately) {\n invariant(fireImmediately !== true, getMessage(\"m033\"));\n return registerListener(this, listener);\n };\n ObservableMap.prototype.intercept = function (handler) {\n return registerInterceptor(this, handler);\n };\n return ObservableMap;\n}());\ndeclareIterator(ObservableMap.prototype, function () {\n return this.entries();\n});\nfunction map(initialValues) {\n deprecated(\"`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead\");\n return observable.map(initialValues);\n}\n/* 'var' fixes small-build issue */\nvar isObservableMap = createInstanceofPredicate(\"ObservableMap\", ObservableMap);\n\nvar EMPTY_ARRAY = [];\nObject.freeze(EMPTY_ARRAY);\nfunction getGlobal() {\n return typeof window !== \"undefined\" ? window : global;\n}\nfunction getNextId() {\n return ++globalState.mobxGuid;\n}\nfunction fail(message, thing) {\n invariant(false, message, thing);\n throw \"X\"; // unreachable\n}\nfunction invariant(check, message, thing) {\n if (!check)\n throw new Error(\"[mobx] Invariant failed: \" + message + (thing ? \" in '\" + thing + \"'\" : \"\"));\n}\n/**\n * Prints a deprecation message, but only one time.\n * Returns false if the deprecated message was already printed before\n */\nvar deprecatedMessages = [];\nfunction deprecated(msg) {\n if (deprecatedMessages.indexOf(msg) !== -1)\n return false;\n deprecatedMessages.push(msg);\n console.error(\"[mobx] Deprecated: \" + msg);\n return true;\n}\n/**\n * Makes sure that the provided function is invoked at most once.\n */\nfunction once(func) {\n var invoked = false;\n return function () {\n if (invoked)\n return;\n invoked = true;\n return func.apply(this, arguments);\n };\n}\nvar noop = function () { };\nfunction unique(list) {\n var res = [];\n list.forEach(function (item) {\n if (res.indexOf(item) === -1)\n res.push(item);\n });\n return res;\n}\nfunction joinStrings(things, limit, separator) {\n if (limit === void 0) { limit = 100; }\n if (separator === void 0) { separator = \" - \"; }\n if (!things)\n return \"\";\n var sliced = things.slice(0, limit);\n return \"\" + sliced.join(separator) + (things.length > limit\n ? \" (... and \" + (things.length - limit) + \"more)\"\n : \"\");\n}\nfunction isObject(value) {\n return value !== null && typeof value === \"object\";\n}\nfunction isPlainObject(value) {\n if (value === null || typeof value !== \"object\")\n return false;\n var proto = Object.getPrototypeOf(value);\n return proto === Object.prototype || proto === null;\n}\nfunction objectAssign() {\n var res = arguments[0];\n for (var i = 1, l = arguments.length; i < l; i++) {\n var source = arguments[i];\n for (var key in source)\n if (hasOwnProperty(source, key)) {\n res[key] = source[key];\n }\n }\n return res;\n}\nvar prototypeHasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwnProperty(object, propName) {\n return prototypeHasOwnProperty.call(object, propName);\n}\nfunction makeNonEnumerable(object, propNames) {\n for (var i = 0; i < propNames.length; i++) {\n addHiddenProp(object, propNames[i], object[propNames[i]]);\n }\n}\nfunction addHiddenProp(object, propName, value) {\n Object.defineProperty(object, propName, {\n enumerable: false,\n writable: true,\n configurable: true,\n value: value\n });\n}\nfunction addHiddenFinalProp(object, propName, value) {\n Object.defineProperty(object, propName, {\n enumerable: false,\n writable: false,\n configurable: true,\n value: value\n });\n}\nfunction isPropertyConfigurable(object, prop) {\n var descriptor = Object.getOwnPropertyDescriptor(object, prop);\n return !descriptor || (descriptor.configurable !== false && descriptor.writable !== false);\n}\nfunction assertPropertyConfigurable(object, prop) {\n invariant(isPropertyConfigurable(object, prop), \"Cannot make property '\" + prop + \"' observable, it is not configurable and writable in the target object\");\n}\nfunction createInstanceofPredicate(name, clazz) {\n var propName = \"isMobX\" + name;\n clazz.prototype[propName] = true;\n return function (x) {\n return isObject(x) && x[propName] === true;\n };\n}\nfunction areBothNaN(a, b) {\n return typeof a === \"number\" && typeof b === \"number\" && isNaN(a) && isNaN(b);\n}\n/**\n * Returns whether the argument is an array, disregarding observability.\n */\nfunction isArrayLike(x) {\n return Array.isArray(x) || isObservableArray(x);\n}\nfunction isES6Map(thing) {\n if (getGlobal().Map !== undefined && thing instanceof getGlobal().Map)\n return true;\n return false;\n}\nfunction getMapLikeKeys(map$$1) {\n if (isPlainObject(map$$1))\n return Object.keys(map$$1);\n if (Array.isArray(map$$1))\n return map$$1.map(function (_a) {\n var key = _a[0];\n return key;\n });\n if (isES6Map(map$$1))\n return Array.from(map$$1.keys());\n if (isObservableMap(map$$1))\n return map$$1.keys();\n return fail(\"Cannot get keys from \" + map$$1);\n}\nfunction iteratorToArray(it) {\n var res = [];\n while (true) {\n var r = it.next();\n if (r.done)\n break;\n res.push(r.value);\n }\n return res;\n}\nfunction primitiveSymbol() {\n return (typeof Symbol === \"function\" && Symbol.toPrimitive) || \"@@toPrimitive\";\n}\nfunction toPrimitive(value) {\n return value === null ? null : typeof value === \"object\" ? \"\" + value : value;\n}\n\n/**\n * These values will persist if global state is reset\n */\nvar persistentKeys = [\"mobxGuid\", \"resetId\", \"spyListeners\", \"strictMode\", \"runId\"];\nvar MobXGlobals = /** @class */ (function () {\n function MobXGlobals() {\n /**\n * MobXGlobals version.\n * MobX compatiblity with other versions loaded in memory as long as this version matches.\n * It indicates that the global state still stores similar information\n */\n this.version = 5;\n /**\n * Currently running derivation\n */\n this.trackingDerivation = null;\n /**\n * Are we running a computation currently? (not a reaction)\n */\n this.computationDepth = 0;\n /**\n * Each time a derivation is tracked, it is assigned a unique run-id\n */\n this.runId = 0;\n /**\n * 'guid' for general purpose. Will be persisted amongst resets.\n */\n this.mobxGuid = 0;\n /**\n * Are we in a batch block? (and how many of them)\n */\n this.inBatch = 0;\n /**\n * Observables that don't have observers anymore, and are about to be\n * suspended, unless somebody else accesses it in the same batch\n *\n * @type {IObservable[]}\n */\n this.pendingUnobservations = [];\n /**\n * List of scheduled, not yet executed, reactions.\n */\n this.pendingReactions = [];\n /**\n * Are we currently processing reactions?\n */\n this.isRunningReactions = false;\n /**\n * Is it allowed to change observables at this point?\n * In general, MobX doesn't allow that when running computations and React.render.\n * To ensure that those functions stay pure.\n */\n this.allowStateChanges = true;\n /**\n * If strict mode is enabled, state changes are by default not allowed\n */\n this.strictMode = false;\n /**\n * Used by createTransformer to detect that the global state has been reset.\n */\n this.resetId = 0;\n /**\n * Spy callbacks\n */\n this.spyListeners = [];\n /**\n * Globally attached error handlers that react specifically to errors in reactions\n */\n this.globalReactionErrorHandlers = [];\n }\n return MobXGlobals;\n}());\nvar globalState = new MobXGlobals();\nvar shareGlobalStateCalled = false;\nvar runInIsolationCalled = false;\nvar warnedAboutMultipleInstances = false;\n{\n var global_1 = getGlobal();\n if (!global_1.__mobxInstanceCount) {\n global_1.__mobxInstanceCount = 1;\n }\n else {\n global_1.__mobxInstanceCount++;\n setTimeout(function () {\n if (!shareGlobalStateCalled && !runInIsolationCalled && !warnedAboutMultipleInstances) {\n warnedAboutMultipleInstances = true;\n console.warn(\"[mobx] Warning: there are multiple mobx instances active. This might lead to unexpected results. See https://github.com/mobxjs/mobx/issues/1082 for details.\");\n }\n }, 1);\n }\n}\nfunction isolateGlobalState() {\n runInIsolationCalled = true;\n getGlobal().__mobxInstanceCount--;\n}\nfunction shareGlobalState() {\n // TODO: remove in 4.0; just use peer dependencies instead.\n deprecated(\"Using `shareGlobalState` is not recommended, use peer dependencies instead. See https://github.com/mobxjs/mobx/issues/1082 for details.\");\n shareGlobalStateCalled = true;\n var global = getGlobal();\n var ownState = globalState;\n /**\n * Backward compatibility check\n */\n if (global.__mobservableTrackingStack || global.__mobservableViewStack)\n throw new Error(\"[mobx] An incompatible version of mobservable is already loaded.\");\n if (global.__mobxGlobal && global.__mobxGlobal.version !== ownState.version)\n throw new Error(\"[mobx] An incompatible version of mobx is already loaded.\");\n if (global.__mobxGlobal)\n globalState = global.__mobxGlobal;\n else\n global.__mobxGlobal = ownState;\n}\nfunction getGlobalState() {\n return globalState;\n}\n\n/**\n * For testing purposes only; this will break the internal state of existing observables,\n * but can be used to get back at a stable state after throwing errors\n */\nfunction resetGlobalState() {\n globalState.resetId++;\n var defaultGlobals = new MobXGlobals();\n for (var key in defaultGlobals)\n if (persistentKeys.indexOf(key) === -1)\n globalState[key] = defaultGlobals[key];\n globalState.allowStateChanges = !globalState.strictMode;\n}\n\nfunction getAtom(thing, property) {\n if (typeof thing === \"object\" && thing !== null) {\n if (isObservableArray(thing)) {\n invariant(property === undefined, getMessage(\"m036\"));\n return thing.$mobx.atom;\n }\n if (isObservableMap(thing)) {\n var anyThing = thing;\n if (property === undefined)\n return getAtom(anyThing._keys);\n var observable = anyThing._data[property] || anyThing._hasMap[property];\n invariant(!!observable, \"the entry '\" + property + \"' does not exist in the observable map '\" + getDebugName(thing) + \"'\");\n return observable;\n }\n // Initializers run lazily when transpiling to babel, so make sure they are run...\n runLazyInitializers(thing);\n if (property && !thing.$mobx)\n thing[property]; // See #1072 // TODO: remove in 4.0\n if (isObservableObject(thing)) {\n if (!property)\n return fail(\"please specify a property\");\n var observable = thing.$mobx.values[property];\n invariant(!!observable, \"no observable property '\" + property + \"' found on the observable object '\" + getDebugName(thing) + \"'\");\n return observable;\n }\n if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {\n return thing;\n }\n }\n else if (typeof thing === \"function\") {\n if (isReaction(thing.$mobx)) {\n // disposer function\n return thing.$mobx;\n }\n }\n return fail(\"Cannot obtain atom from \" + thing);\n}\nfunction getAdministration(thing, property) {\n invariant(thing, \"Expecting some object\");\n if (property !== undefined)\n return getAdministration(getAtom(thing, property));\n if (isAtom(thing) || isComputedValue(thing) || isReaction(thing))\n return thing;\n if (isObservableMap(thing))\n return thing;\n // Initializers run lazily when transpiling to babel, so make sure they are run...\n runLazyInitializers(thing);\n if (thing.$mobx)\n return thing.$mobx;\n invariant(false, \"Cannot obtain administration from \" + thing);\n}\nfunction getDebugName(thing, property) {\n var named;\n if (property !== undefined)\n named = getAtom(thing, property);\n else if (isObservableObject(thing) || isObservableMap(thing))\n named = getAdministration(thing);\n else\n named = getAtom(thing); // valid for arrays as well\n return named.name;\n}\n\nfunction getDependencyTree(thing, property) {\n return nodeToDependencyTree(getAtom(thing, property));\n}\nfunction nodeToDependencyTree(node) {\n var result = {\n name: node.name\n };\n if (node.observing && node.observing.length > 0)\n result.dependencies = unique(node.observing).map(nodeToDependencyTree);\n return result;\n}\nfunction getObserverTree(thing, property) {\n return nodeToObserverTree(getAtom(thing, property));\n}\nfunction nodeToObserverTree(node) {\n var result = {\n name: node.name\n };\n if (hasObservers(node))\n result.observers = getObservers(node).map(nodeToObserverTree);\n return result;\n}\n\nfunction hasObservers(observable) {\n return observable.observers && observable.observers.length > 0;\n}\nfunction getObservers(observable) {\n return observable.observers;\n}\nfunction addObserver(observable, node) {\n // invariant(node.dependenciesState !== -1, \"INTERNAL ERROR, can add only dependenciesState !== -1\");\n // invariant(observable._observers.indexOf(node) === -1, \"INTERNAL ERROR add already added node\");\n // invariantObservers(observable);\n var l = observable.observers.length;\n if (l) {\n // because object assignment is relatively expensive, let's not store data about index 0.\n observable.observersIndexes[node.__mapid] = l;\n }\n observable.observers[l] = node;\n if (observable.lowestObserverState > node.dependenciesState)\n observable.lowestObserverState = node.dependenciesState;\n // invariantObservers(observable);\n // invariant(observable._observers.indexOf(node) !== -1, \"INTERNAL ERROR didn't add node\");\n}\nfunction removeObserver(observable, node) {\n // invariant(globalState.inBatch > 0, \"INTERNAL ERROR, remove should be called only inside batch\");\n // invariant(observable._observers.indexOf(node) !== -1, \"INTERNAL ERROR remove already removed node\");\n // invariantObservers(observable);\n if (observable.observers.length === 1) {\n // deleting last observer\n observable.observers.length = 0;\n queueForUnobservation(observable);\n }\n else {\n // deleting from _observersIndexes is straight forward, to delete from _observers, let's swap `node` with last element\n var list = observable.observers;\n var map = observable.observersIndexes;\n var filler = list.pop(); // get last element, which should fill the place of `node`, so the array doesn't have holes\n if (filler !== node) {\n // otherwise node was the last element, which already got removed from array\n var index = map[node.__mapid] || 0; // getting index of `node`. this is the only place we actually use map.\n if (index) {\n // map store all indexes but 0, see comment in `addObserver`\n map[filler.__mapid] = index;\n }\n else {\n delete map[filler.__mapid];\n }\n list[index] = filler;\n }\n delete map[node.__mapid];\n }\n // invariantObservers(observable);\n // invariant(observable._observers.indexOf(node) === -1, \"INTERNAL ERROR remove already removed node2\");\n}\nfunction queueForUnobservation(observable) {\n if (!observable.isPendingUnobservation) {\n // invariant(globalState.inBatch > 0, \"INTERNAL ERROR, remove should be called only inside batch\");\n // invariant(observable._observers.length === 0, \"INTERNAL ERROR, should only queue for unobservation unobserved observables\");\n observable.isPendingUnobservation = true;\n globalState.pendingUnobservations.push(observable);\n }\n}\n/**\n * Batch starts a transaction, at least for purposes of memoizing ComputedValues when nothing else does.\n * During a batch `onBecomeUnobserved` will be called at most once per observable.\n * Avoids unnecessary recalculations.\n */\nfunction startBatch() {\n globalState.inBatch++;\n}\nfunction endBatch() {\n if (--globalState.inBatch === 0) {\n runReactions();\n // the batch is actually about to finish, all unobserving should happen here.\n var list = globalState.pendingUnobservations;\n for (var i = 0; i < list.length; i++) {\n var observable = list[i];\n observable.isPendingUnobservation = false;\n if (observable.observers.length === 0) {\n observable.onBecomeUnobserved();\n // NOTE: onBecomeUnobserved might push to `pendingUnobservations`\n }\n }\n globalState.pendingUnobservations = [];\n }\n}\nfunction reportObserved(observable) {\n var derivation = globalState.trackingDerivation;\n if (derivation !== null) {\n /**\n * Simple optimization, give each derivation run an unique id (runId)\n * Check if last time this observable was accessed the same runId is used\n * if this is the case, the relation is already known\n */\n if (derivation.runId !== observable.lastAccessedBy) {\n observable.lastAccessedBy = derivation.runId;\n derivation.newObserving[derivation.unboundDepsCount++] = observable;\n }\n }\n else if (observable.observers.length === 0) {\n queueForUnobservation(observable);\n }\n}\n/**\n * NOTE: current propagation mechanism will in case of self reruning autoruns behave unexpectedly\n * It will propagate changes to observers from previous run\n * It's hard or maybe impossible (with reasonable perf) to get it right with current approach\n * Hopefully self reruning autoruns aren't a feature people should depend on\n * Also most basic use cases should be ok\n */\n// Called by Atom when its value changes\nfunction propagateChanged(observable) {\n // invariantLOS(observable, \"changed start\");\n if (observable.lowestObserverState === IDerivationState.STALE)\n return;\n observable.lowestObserverState = IDerivationState.STALE;\n var observers = observable.observers;\n var i = observers.length;\n while (i--) {\n var d = observers[i];\n if (d.dependenciesState === IDerivationState.UP_TO_DATE) {\n if (d.isTracing !== TraceMode.NONE) {\n logTraceInfo(d, observable);\n }\n d.onBecomeStale();\n }\n d.dependenciesState = IDerivationState.STALE;\n }\n // invariantLOS(observable, \"changed end\");\n}\n// Called by ComputedValue when it recalculate and its value changed\nfunction propagateChangeConfirmed(observable) {\n // invariantLOS(observable, \"confirmed start\");\n if (observable.lowestObserverState === IDerivationState.STALE)\n return;\n observable.lowestObserverState = IDerivationState.STALE;\n var observers = observable.observers;\n var i = observers.length;\n while (i--) {\n var d = observers[i];\n if (d.dependenciesState === IDerivationState.POSSIBLY_STALE)\n d.dependenciesState = IDerivationState.STALE;\n else if (d.dependenciesState === IDerivationState.UP_TO_DATE // this happens during computing of `d`, just keep lowestObserverState up to date.\n )\n observable.lowestObserverState = IDerivationState.UP_TO_DATE;\n }\n // invariantLOS(observable, \"confirmed end\");\n}\n// Used by computed when its dependency changed, but we don't wan't to immediately recompute.\nfunction propagateMaybeChanged(observable) {\n // invariantLOS(observable, \"maybe start\");\n if (observable.lowestObserverState !== IDerivationState.UP_TO_DATE)\n return;\n observable.lowestObserverState = IDerivationState.POSSIBLY_STALE;\n var observers = observable.observers;\n var i = observers.length;\n while (i--) {\n var d = observers[i];\n if (d.dependenciesState === IDerivationState.UP_TO_DATE) {\n d.dependenciesState = IDerivationState.POSSIBLY_STALE;\n if (d.isTracing !== TraceMode.NONE) {\n logTraceInfo(d, observable);\n }\n d.onBecomeStale();\n }\n }\n // invariantLOS(observable, \"maybe end\");\n}\nfunction logTraceInfo(derivation, observable) {\n console.log(\"[mobx.trace] '\" + derivation.name + \"' is invalidated due to a change in: '\" + observable.name + \"'\");\n if (derivation.isTracing === TraceMode.BREAK) {\n var lines = [];\n printDepTree(getDependencyTree(derivation), lines, 1);\n // prettier-ignore\n new Function(\"debugger;\\n/*\\nTracing '\" + derivation.name + \"'\\n\\nYou are entering this break point because derivation '\" + derivation.name + \"' is being traced and '\" + observable.name + \"' is now forcing it to update.\\nJust follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update\\nThe stackframe you are looking for is at least ~6-8 stack-frames up.\\n\\n\" + (derivation instanceof ComputedValue ? derivation.derivation.toString() : \"\") + \"\\n\\nThe dependencies for this derivation are:\\n\\n\" + lines.join(\"\\n\") + \"\\n*/\\n \")();\n }\n}\nfunction printDepTree(tree, lines, depth) {\n if (lines.length >= 1000) {\n lines.push(\"(and many more)\");\n return;\n }\n lines.push(\"\" + new Array(depth).join(\"\\t\") + tree.name); // MWE: not the fastest, but the easiest way :)\n if (tree.dependencies)\n tree.dependencies.forEach(function (child) { return printDepTree(child, lines, depth + 1); });\n}\n\nvar IDerivationState;\n(function (IDerivationState) {\n // before being run or (outside batch and not being observed)\n // at this point derivation is not holding any data about dependency tree\n IDerivationState[IDerivationState[\"NOT_TRACKING\"] = -1] = \"NOT_TRACKING\";\n // no shallow dependency changed since last computation\n // won't recalculate derivation\n // this is what makes mobx fast\n IDerivationState[IDerivationState[\"UP_TO_DATE\"] = 0] = \"UP_TO_DATE\";\n // some deep dependency changed, but don't know if shallow dependency changed\n // will require to check first if UP_TO_DATE or POSSIBLY_STALE\n // currently only ComputedValue will propagate POSSIBLY_STALE\n //\n // having this state is second big optimization:\n // don't have to recompute on every dependency change, but only when it's needed\n IDerivationState[IDerivationState[\"POSSIBLY_STALE\"] = 1] = \"POSSIBLY_STALE\";\n // A shallow dependency has changed since last computation and the derivation\n // will need to recompute when it's needed next.\n IDerivationState[IDerivationState[\"STALE\"] = 2] = \"STALE\";\n})(IDerivationState || (IDerivationState = {}));\nvar TraceMode;\n(function (TraceMode) {\n TraceMode[TraceMode[\"NONE\"] = 0] = \"NONE\";\n TraceMode[TraceMode[\"LOG\"] = 1] = \"LOG\";\n TraceMode[TraceMode[\"BREAK\"] = 2] = \"BREAK\";\n})(TraceMode || (TraceMode = {}));\nvar CaughtException = /** @class */ (function () {\n function CaughtException(cause) {\n this.cause = cause;\n // Empty\n }\n return CaughtException;\n}());\nfunction isCaughtException(e) {\n return e instanceof CaughtException;\n}\n/**\n * Finds out whether any dependency of the derivation has actually changed.\n * If dependenciesState is 1 then it will recalculate dependencies,\n * if any dependency changed it will propagate it by changing dependenciesState to 2.\n *\n * By iterating over the dependencies in the same order that they were reported and\n * stopping on the first change, all the recalculations are only called for ComputedValues\n * that will be tracked by derivation. That is because we assume that if the first x\n * dependencies of the derivation doesn't change then the derivation should run the same way\n * up until accessing x-th dependency.\n */\nfunction shouldCompute(derivation) {\n switch (derivation.dependenciesState) {\n case IDerivationState.UP_TO_DATE:\n return false;\n case IDerivationState.NOT_TRACKING:\n case IDerivationState.STALE:\n return true;\n case IDerivationState.POSSIBLY_STALE: {\n var prevUntracked = untrackedStart(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.\n var obs = derivation.observing, l = obs.length;\n for (var i = 0; i < l; i++) {\n var obj = obs[i];\n if (isComputedValue(obj)) {\n try {\n obj.get();\n }\n catch (e) {\n // we are not interested in the value *or* exception at this moment, but if there is one, notify all\n untrackedEnd(prevUntracked);\n return true;\n }\n // if ComputedValue `obj` actually changed it will be computed and propagated to its observers.\n // and `derivation` is an observer of `obj`\n if (derivation.dependenciesState === IDerivationState.STALE) {\n untrackedEnd(prevUntracked);\n return true;\n }\n }\n }\n changeDependenciesStateTo0(derivation);\n untrackedEnd(prevUntracked);\n return false;\n }\n }\n}\nfunction isComputingDerivation() {\n return globalState.trackingDerivation !== null; // filter out actions inside computations\n}\nfunction checkIfStateModificationsAreAllowed(atom) {\n var hasObservers$$1 = atom.observers.length > 0;\n // Should never be possible to change an observed observable from inside computed, see #798\n if (globalState.computationDepth > 0 && hasObservers$$1)\n fail(getMessage(\"m031\") + atom.name);\n // Should not be possible to change observed state outside strict mode, except during initialization, see #563\n if (!globalState.allowStateChanges && hasObservers$$1)\n fail(getMessage(globalState.strictMode ? \"m030a\" : \"m030b\") + atom.name);\n}\n/**\n * Executes the provided function `f` and tracks which observables are being accessed.\n * The tracking information is stored on the `derivation` object and the derivation is registered\n * as observer of any of the accessed observables.\n */\nfunction trackDerivedFunction(derivation, f, context) {\n // pre allocate array allocation + room for variation in deps\n // array will be trimmed by bindDependencies\n changeDependenciesStateTo0(derivation);\n derivation.newObserving = new Array(derivation.observing.length + 100);\n derivation.unboundDepsCount = 0;\n derivation.runId = ++globalState.runId;\n var prevTracking = globalState.trackingDerivation;\n globalState.trackingDerivation = derivation;\n var result;\n try {\n result = f.call(context);\n }\n catch (e) {\n result = new CaughtException(e);\n }\n globalState.trackingDerivation = prevTracking;\n bindDependencies(derivation);\n return result;\n}\n/**\n * diffs newObserving with observing.\n * update observing to be newObserving with unique observables\n * notify observers that become observed/unobserved\n */\nfunction bindDependencies(derivation) {\n // invariant(derivation.dependenciesState !== IDerivationState.NOT_TRACKING, \"INTERNAL ERROR bindDependencies expects derivation.dependenciesState !== -1\");\n var prevObserving = derivation.observing;\n var observing = (derivation.observing = derivation.newObserving);\n var lowestNewObservingDerivationState = IDerivationState.UP_TO_DATE;\n // Go through all new observables and check diffValue: (this list can contain duplicates):\n // 0: first occurrence, change to 1 and keep it\n // 1: extra occurrence, drop it\n var i0 = 0, l = derivation.unboundDepsCount;\n for (var i = 0; i < l; i++) {\n var dep = observing[i];\n if (dep.diffValue === 0) {\n dep.diffValue = 1;\n if (i0 !== i)\n observing[i0] = dep;\n i0++;\n }\n // Upcast is 'safe' here, because if dep is IObservable, `dependenciesState` will be undefined,\n // not hitting the condition\n if (dep.dependenciesState > lowestNewObservingDerivationState) {\n lowestNewObservingDerivationState = dep.dependenciesState;\n }\n }\n observing.length = i0;\n derivation.newObserving = null; // newObserving shouldn't be needed outside tracking (statement moved down to work around FF bug, see #614)\n // Go through all old observables and check diffValue: (it is unique after last bindDependencies)\n // 0: it's not in new observables, unobserve it\n // 1: it keeps being observed, don't want to notify it. change to 0\n l = prevObserving.length;\n while (l--) {\n var dep = prevObserving[l];\n if (dep.diffValue === 0) {\n removeObserver(dep, derivation);\n }\n dep.diffValue = 0;\n }\n // Go through all new observables and check diffValue: (now it should be unique)\n // 0: it was set to 0 in last loop. don't need to do anything.\n // 1: it wasn't observed, let's observe it. set back to 0\n while (i0--) {\n var dep = observing[i0];\n if (dep.diffValue === 1) {\n dep.diffValue = 0;\n addObserver(dep, derivation);\n }\n }\n // Some new observed derivations may become stale during this derivation computation\n // so they have had no chance to propagate staleness (#916)\n if (lowestNewObservingDerivationState !== IDerivationState.UP_TO_DATE) {\n derivation.dependenciesState = lowestNewObservingDerivationState;\n derivation.onBecomeStale();\n }\n}\nfunction clearObserving(derivation) {\n // invariant(globalState.inBatch > 0, \"INTERNAL ERROR clearObserving should be called only inside batch\");\n var obs = derivation.observing;\n derivation.observing = [];\n var i = obs.length;\n while (i--)\n removeObserver(obs[i], derivation);\n derivation.dependenciesState = IDerivationState.NOT_TRACKING;\n}\nfunction untracked(action) {\n var prev = untrackedStart();\n var res = action();\n untrackedEnd(prev);\n return res;\n}\nfunction untrackedStart() {\n var prev = globalState.trackingDerivation;\n globalState.trackingDerivation = null;\n return prev;\n}\nfunction untrackedEnd(prev) {\n globalState.trackingDerivation = prev;\n}\n/**\n * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0\n *\n */\nfunction changeDependenciesStateTo0(derivation) {\n if (derivation.dependenciesState === IDerivationState.UP_TO_DATE)\n return;\n derivation.dependenciesState = IDerivationState.UP_TO_DATE;\n var obs = derivation.observing;\n var i = obs.length;\n while (i--)\n obs[i].lowestObserverState = IDerivationState.UP_TO_DATE;\n}\n\nfunction log(msg) {\n console.log(msg);\n return msg;\n}\nfunction whyRun(thing, prop) {\n deprecated(\"`whyRun` is deprecated in favor of `trace`\");\n thing = getAtomFromArgs(arguments);\n if (!thing)\n return log(getMessage(\"m024\"));\n if (isComputedValue(thing) || isReaction(thing))\n return log(thing.whyRun());\n return fail(getMessage(\"m025\"));\n}\nfunction trace() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n var enterBreakPoint = false;\n if (typeof args[args.length - 1] === \"boolean\")\n enterBreakPoint = args.pop();\n var derivation = getAtomFromArgs(args);\n if (!derivation) {\n return fail(\"'trace(break?)' can only be used inside a tracked computed value or a Reaction. Consider passing in the computed value or reaction explicitly\");\n }\n if (derivation.isTracing === TraceMode.NONE) {\n console.log(\"[mobx.trace] '\" + derivation.name + \"' tracing enabled\");\n }\n derivation.isTracing = enterBreakPoint ? TraceMode.BREAK : TraceMode.LOG;\n}\nfunction getAtomFromArgs(args) {\n switch (args.length) {\n case 0:\n return globalState.trackingDerivation;\n case 1:\n return getAtom(args[0]);\n case 2:\n return getAtom(args[0], args[1]);\n }\n}\n\nvar Reaction = /** @class */ (function () {\n function Reaction(name, onInvalidate) {\n if (name === void 0) { name = \"Reaction@\" + getNextId(); }\n this.name = name;\n this.onInvalidate = onInvalidate;\n this.observing = []; // nodes we are looking at. Our value depends on these nodes\n this.newObserving = [];\n this.dependenciesState = IDerivationState.NOT_TRACKING;\n this.diffValue = 0;\n this.runId = 0;\n this.unboundDepsCount = 0;\n this.__mapid = \"#\" + getNextId();\n this.isDisposed = false;\n this._isScheduled = false;\n this._isTrackPending = false;\n this._isRunning = false;\n this.isTracing = TraceMode.NONE;\n }\n Reaction.prototype.onBecomeStale = function () {\n this.schedule();\n };\n Reaction.prototype.schedule = function () {\n if (!this._isScheduled) {\n this._isScheduled = true;\n globalState.pendingReactions.push(this);\n runReactions();\n }\n };\n Reaction.prototype.isScheduled = function () {\n return this._isScheduled;\n };\n /**\n * internal, use schedule() if you intend to kick off a reaction\n */\n Reaction.prototype.runReaction = function () {\n if (!this.isDisposed) {\n startBatch();\n this._isScheduled = false;\n if (shouldCompute(this)) {\n this._isTrackPending = true;\n this.onInvalidate();\n if (this._isTrackPending && isSpyEnabled()) {\n // onInvalidate didn't trigger track right away..\n spyReport({\n object: this,\n type: \"scheduled-reaction\"\n });\n }\n }\n endBatch();\n }\n };\n Reaction.prototype.track = function (fn) {\n startBatch();\n var notify = isSpyEnabled();\n var startTime;\n if (notify) {\n startTime = Date.now();\n spyReportStart({\n object: this,\n type: \"reaction\",\n fn: fn\n });\n }\n this._isRunning = true;\n var result = trackDerivedFunction(this, fn, undefined);\n this._isRunning = false;\n this._isTrackPending = false;\n if (this.isDisposed) {\n // disposed during last run. Clean up everything that was bound after the dispose call.\n clearObserving(this);\n }\n if (isCaughtException(result))\n this.reportExceptionInDerivation(result.cause);\n if (notify) {\n spyReportEnd({\n time: Date.now() - startTime\n });\n }\n endBatch();\n };\n Reaction.prototype.reportExceptionInDerivation = function (error) {\n var _this = this;\n if (this.errorHandler) {\n this.errorHandler(error, this);\n return;\n }\n var message = \"[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '\" + this;\n var messageToUser = getMessage(\"m037\");\n console.error(message || messageToUser /* latter will not be true, make sure uglify doesn't remove */, error);\n /** If debugging brought you here, please, read the above message :-). Tnx! */\n if (isSpyEnabled()) {\n spyReport({\n type: \"error\",\n message: message,\n error: error,\n object: this\n });\n }\n globalState.globalReactionErrorHandlers.forEach(function (f) { return f(error, _this); });\n };\n Reaction.prototype.dispose = function () {\n if (!this.isDisposed) {\n this.isDisposed = true;\n if (!this._isRunning) {\n // if disposed while running, clean up later. Maybe not optimal, but rare case\n startBatch();\n clearObserving(this);\n endBatch();\n }\n }\n };\n Reaction.prototype.getDisposer = function () {\n var r = this.dispose.bind(this);\n r.$mobx = this;\n r.onError = registerErrorHandler;\n return r;\n };\n Reaction.prototype.toString = function () {\n return \"Reaction[\" + this.name + \"]\";\n };\n Reaction.prototype.whyRun = function () {\n var observing = unique(this._isRunning ? this.newObserving : this.observing).map(function (dep) { return dep.name; });\n return \"\\nWhyRun? reaction '\" + this.name + \"':\\n * Status: [\" + (this.isDisposed\n ? \"stopped\"\n : this._isRunning ? \"running\" : this.isScheduled() ? \"scheduled\" : \"idle\") + \"]\\n * This reaction will re-run if any of the following observables changes:\\n \" + joinStrings(observing) + \"\\n \" + (this._isRunning\n ? \" (... or any observable accessed during the remainder of the current run)\"\n : \"\") + \"\\n\\t\" + getMessage(\"m038\") + \"\\n\";\n };\n Reaction.prototype.trace = function (enterBreakPoint) {\n if (enterBreakPoint === void 0) { enterBreakPoint = false; }\n trace(this, enterBreakPoint);\n };\n return Reaction;\n}());\nfunction registerErrorHandler(handler) {\n invariant(this && this.$mobx && isReaction(this.$mobx), \"Invalid `this`\");\n invariant(!this.$mobx.errorHandler, \"Only one onErrorHandler can be registered\");\n this.$mobx.errorHandler = handler;\n}\nfunction onReactionError(handler) {\n globalState.globalReactionErrorHandlers.push(handler);\n return function () {\n var idx = globalState.globalReactionErrorHandlers.indexOf(handler);\n if (idx >= 0)\n globalState.globalReactionErrorHandlers.splice(idx, 1);\n };\n}\n/**\n * Magic number alert!\n * Defines within how many times a reaction is allowed to re-trigger itself\n * until it is assumed that this is gonna be a never ending loop...\n */\nvar MAX_REACTION_ITERATIONS = 100;\nvar reactionScheduler = function (f) { return f(); };\nfunction runReactions() {\n // Trampolining, if runReactions are already running, new reactions will be picked up\n if (globalState.inBatch > 0 || globalState.isRunningReactions)\n return;\n reactionScheduler(runReactionsHelper);\n}\nfunction runReactionsHelper() {\n globalState.isRunningReactions = true;\n var allReactions = globalState.pendingReactions;\n var iterations = 0;\n // While running reactions, new reactions might be triggered.\n // Hence we work with two variables and check whether\n // we converge to no remaining reactions after a while.\n while (allReactions.length > 0) {\n if (++iterations === MAX_REACTION_ITERATIONS) {\n console.error(\"Reaction doesn't converge to a stable state after \" + MAX_REACTION_ITERATIONS + \" iterations.\" +\n (\" Probably there is a cycle in the reactive function: \" + allReactions[0]));\n allReactions.splice(0); // clear reactions\n }\n var remainingReactions = allReactions.splice(0);\n for (var i = 0, l = remainingReactions.length; i < l; i++)\n remainingReactions[i].runReaction();\n }\n globalState.isRunningReactions = false;\n}\nvar isReaction = createInstanceofPredicate(\"Reaction\", Reaction);\nfunction setReactionScheduler(fn) {\n var baseScheduler = reactionScheduler;\n reactionScheduler = function (f) { return fn(function () { return baseScheduler(f); }); };\n}\n\nfunction asReference(value) {\n deprecated(\"asReference is deprecated, use observable.ref instead\");\n return observable.ref(value);\n}\nfunction asStructure(value) {\n deprecated(\"asStructure is deprecated. Use observable.struct, computed.struct or reaction options instead.\");\n return observable.struct(value);\n}\nfunction asFlat(value) {\n deprecated(\"asFlat is deprecated, use observable.shallow instead\");\n return observable.shallow(value);\n}\nfunction asMap(data) {\n deprecated(\"asMap is deprecated, use observable.map or observable.shallowMap instead\");\n return observable.map(data || {});\n}\n\nfunction createComputedDecorator(equals) {\n return createClassPropertyDecorator(function (target, name, _, __, originalDescriptor) {\n invariant(typeof originalDescriptor !== \"undefined\", getMessage(\"m009\"));\n invariant(typeof originalDescriptor.get === \"function\", getMessage(\"m010\"));\n var adm = asObservableObject(target, \"\");\n defineComputedProperty(adm, name, originalDescriptor.get, originalDescriptor.set, equals, false);\n }, function (name) {\n var observable = this.$mobx.values[name];\n if (observable === undefined // See #505\n )\n return undefined;\n return observable.get();\n }, function (name, value) {\n this.$mobx.values[name].set(value);\n }, false, false);\n}\nvar computedDecorator = createComputedDecorator(comparer.default);\nvar computedStructDecorator = createComputedDecorator(comparer.structural);\n/**\n * Decorator for class properties: @computed get value() { return expr; }.\n * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;\n */\nvar computed = function computed(arg1, arg2, arg3) {\n if (typeof arg2 === \"string\") {\n return computedDecorator.apply(null, arguments);\n }\n invariant(typeof arg1 === \"function\", getMessage(\"m011\"));\n invariant(arguments.length < 3, getMessage(\"m012\"));\n var opts = typeof arg2 === \"object\" ? arg2 : {};\n opts.setter = typeof arg2 === \"function\" ? arg2 : opts.setter;\n var equals = opts.equals\n ? opts.equals\n : opts.compareStructural || opts.struct ? comparer.structural : comparer.default;\n return new ComputedValue(arg1, opts.context, equals, opts.name || arg1.name || \"\", opts.setter);\n};\ncomputed.struct = computedStructDecorator;\ncomputed.equals = createComputedDecorator;\n\nfunction isComputed(value, property) {\n if (value === null || value === undefined)\n return false;\n if (property !== undefined) {\n if (isObservableObject(value) === false)\n return false;\n if (!value.$mobx.values[property])\n return false;\n var atom = getAtom(value, property);\n return isComputedValue(atom);\n }\n return isComputedValue(value);\n}\n\nfunction observe(thing, propOrCb, cbOrFire, fireImmediately) {\n if (typeof cbOrFire === \"function\")\n return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately);\n else\n return observeObservable(thing, propOrCb, cbOrFire);\n}\nfunction observeObservable(thing, listener, fireImmediately) {\n return getAdministration(thing).observe(listener, fireImmediately);\n}\nfunction observeObservableProperty(thing, property, listener, fireImmediately) {\n return getAdministration(thing, property).observe(listener, fireImmediately);\n}\n\nfunction intercept(thing, propOrHandler, handler) {\n if (typeof handler === \"function\")\n return interceptProperty(thing, propOrHandler, handler);\n else\n return interceptInterceptable(thing, propOrHandler);\n}\nfunction interceptInterceptable(thing, handler) {\n return getAdministration(thing).intercept(handler);\n}\nfunction interceptProperty(thing, property, handler) {\n return getAdministration(thing, property).intercept(handler);\n}\n\n/**\n * expr can be used to create temporarily views inside views.\n * This can be improved to improve performance if a value changes often, but usually doesn't affect the outcome of an expression.\n *\n * In the following example the expression prevents that a component is rerender _each time_ the selection changes;\n * instead it will only rerenders when the current todo is (de)selected.\n *\n * reactiveComponent((props) => {\n * const todo = props.todo;\n * const isSelected = mobx.expr(() => props.viewState.selection === todo);\n * return <div className={isSelected ? \"todo todo-selected\" : \"todo\"}>{todo.title}</div>\n * });\n *\n */\nfunction expr(expr, scope) {\n if (!isComputingDerivation())\n console.warn(getMessage(\"m013\"));\n // optimization: would be more efficient if the expr itself wouldn't be evaluated first on the next change, but just a 'changed' signal would be fired\n return computed(expr, { context: scope }).get();\n}\n\nfunction toJS(source, detectCycles, __alreadySeen) {\n if (detectCycles === void 0) { detectCycles = true; }\n if (__alreadySeen === void 0) { __alreadySeen = []; }\n // optimization: using ES6 map would be more efficient!\n // optimization: lift this function outside toJS, this makes recursion expensive\n function cache(value) {\n if (detectCycles)\n __alreadySeen.push([source, value]);\n return value;\n }\n if (isObservable(source)) {\n if (detectCycles && __alreadySeen === null)\n __alreadySeen = [];\n if (detectCycles && source !== null && typeof source === \"object\") {\n for (var i = 0, l = __alreadySeen.length; i < l; i++)\n if (__alreadySeen[i][0] === source)\n return __alreadySeen[i][1];\n }\n if (isObservableArray(source)) {\n var res = cache([]);\n var toAdd = source.map(function (value) { return toJS(value, detectCycles, __alreadySeen); });\n res.length = toAdd.length;\n for (var i = 0, l = toAdd.length; i < l; i++)\n res[i] = toAdd[i];\n return res;\n }\n if (isObservableObject(source)) {\n var res = cache({});\n for (var key in source)\n res[key] = toJS(source[key], detectCycles, __alreadySeen);\n return res;\n }\n if (isObservableMap(source)) {\n var res_1 = cache({});\n source.forEach(function (value, key) { return (res_1[key] = toJS(value, detectCycles, __alreadySeen)); });\n return res_1;\n }\n if (isObservableValue(source))\n return toJS(source.get(), detectCycles, __alreadySeen);\n }\n return source;\n}\n\nfunction createTransformer(transformer, onCleanup) {\n invariant(typeof transformer === \"function\" && transformer.length < 2, \"createTransformer expects a function that accepts one argument\");\n // Memoizes: object id -> reactive view that applies transformer to the object\n var objectCache = {};\n // If the resetId changes, we will clear the object cache, see #163\n // This construction is used to avoid leaking refs to the objectCache directly\n var resetId = globalState.resetId;\n // Local transformer class specifically for this transformer\n var Transformer = /** @class */ (function (_super) {\n __extends(Transformer, _super);\n function Transformer(sourceIdentifier, sourceObject) {\n var _this = _super.call(this, function () { return transformer(sourceObject); }, undefined, comparer.default, \"Transformer-\" + transformer.name + \"-\" + sourceIdentifier, undefined) || this;\n _this.sourceIdentifier = sourceIdentifier;\n _this.sourceObject = sourceObject;\n return _this;\n }\n Transformer.prototype.onBecomeUnobserved = function () {\n var lastValue = this.value;\n _super.prototype.onBecomeUnobserved.call(this);\n delete objectCache[this.sourceIdentifier];\n if (onCleanup)\n onCleanup(lastValue, this.sourceObject);\n };\n return Transformer;\n }(ComputedValue));\n return function (object) {\n if (resetId !== globalState.resetId) {\n objectCache = {};\n resetId = globalState.resetId;\n }\n var identifier = getMemoizationId(object);\n var reactiveTransformer = objectCache[identifier];\n if (reactiveTransformer)\n return reactiveTransformer.get();\n // Not in cache; create a reactive view\n reactiveTransformer = objectCache[identifier] = new Transformer(identifier, object);\n return reactiveTransformer.get();\n };\n}\nfunction getMemoizationId(object) {\n if (typeof object === \"string\" || typeof object === \"number\")\n return object;\n if (object === null || typeof object !== \"object\")\n throw new Error(\"[mobx] transform expected some kind of object or primitive value, got: \" + object);\n var tid = object.$transformId;\n if (tid === undefined) {\n tid = getNextId();\n addHiddenProp(object, \"$transformId\", tid);\n }\n return tid;\n}\n\nfunction interceptReads(thing, propOrHandler, handler) {\n var target;\n if (isObservableMap(thing) || isObservableArray(thing) || isObservableValue(thing)) {\n target = getAdministration(thing);\n }\n else if (isObservableObject(thing)) {\n if (typeof propOrHandler !== \"string\")\n return fail(\"InterceptReads can only be used with a specific property, not with an object in general\");\n target = getAdministration(thing, propOrHandler);\n }\n else {\n return fail(\"Expected observable map, object or array as first array\");\n }\n if (target.dehancer !== undefined)\n return fail(\"An intercept reader was already established\");\n target.dehancer = typeof propOrHandler === \"function\" ? propOrHandler : handler;\n return function () {\n target.dehancer = undefined;\n };\n}\n\n/**\n * (c) Michel Weststrate 2015 - 2016\n * MIT Licensed\n *\n * Welcome to the mobx sources! To get an global overview of how MobX internally works,\n * this is a good place to start:\n * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74\n *\n * Source folders:\n * ===============\n *\n * - api/ Most of the public static methods exposed by the module can be found here.\n * - core/ Implementation of the MobX algorithm; atoms, derivations, reactions, dependency trees, optimizations. Cool stuff can be found here.\n * - types/ All the magic that is need to have observable objects, arrays and values is in this folder. Including the modifiers like `asFlat`.\n * - utils/ Utility stuff.\n *\n */\nvar extras = {\n allowStateChanges: allowStateChanges,\n deepEqual: deepEqual,\n getAtom: getAtom,\n getDebugName: getDebugName,\n getDependencyTree: getDependencyTree,\n getAdministration: getAdministration,\n getGlobalState: getGlobalState,\n getObserverTree: getObserverTree,\n interceptReads: interceptReads,\n isComputingDerivation: isComputingDerivation,\n isSpyEnabled: isSpyEnabled,\n onReactionError: onReactionError,\n reserveArrayBuffer: reserveArrayBuffer,\n resetGlobalState: resetGlobalState,\n isolateGlobalState: isolateGlobalState,\n shareGlobalState: shareGlobalState,\n spyReport: spyReport,\n spyReportEnd: spyReportEnd,\n spyReportStart: spyReportStart,\n setReactionScheduler: setReactionScheduler\n};\nvar everything = {\n Reaction: Reaction,\n untracked: untracked,\n Atom: Atom,\n BaseAtom: BaseAtom,\n useStrict: useStrict,\n isStrictModeEnabled: isStrictModeEnabled,\n spy: spy,\n comparer: comparer,\n asReference: asReference,\n asFlat: asFlat,\n asStructure: asStructure,\n asMap: asMap,\n isModifierDescriptor: isModifierDescriptor,\n isObservableObject: isObservableObject,\n isBoxedObservable: isObservableValue,\n isObservableArray: isObservableArray,\n ObservableMap: ObservableMap,\n isObservableMap: isObservableMap,\n map: map,\n transaction: transaction,\n observable: observable,\n computed: computed,\n isObservable: isObservable,\n isComputed: isComputed,\n extendObservable: extendObservable,\n extendShallowObservable: extendShallowObservable,\n observe: observe,\n intercept: intercept,\n autorun: autorun,\n autorunAsync: autorunAsync,\n when: when,\n reaction: reaction,\n action: action,\n isAction: isAction,\n runInAction: runInAction,\n expr: expr,\n toJS: toJS,\n createTransformer: createTransformer,\n whyRun: whyRun,\n isArrayLike: isArrayLike,\n extras: extras\n};\nvar warnedAboutDefaultExport = false;\nvar _loop_1 = function (p) {\n var val = everything[p];\n Object.defineProperty(everything, p, {\n get: function () {\n if (!warnedAboutDefaultExport) {\n warnedAboutDefaultExport = true;\n console.warn(\"Using default export (`import mobx from 'mobx'`) is deprecated \" +\n \"and won’t work in mobx@4.0.0\\n\" +\n \"Use `import * as mobx from 'mobx'` instead\");\n }\n return val;\n }\n });\n};\nfor (var p in everything) {\n _loop_1(p);\n}\nif (typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === \"object\") {\n __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx({ spy: spy, extras: extras });\n}\n\nexport { extras, Reaction, untracked, IDerivationState, Atom, BaseAtom, useStrict, isStrictModeEnabled, spy, comparer, asReference, asFlat, asStructure, asMap, isModifierDescriptor, isObservableObject, isObservableValue as isBoxedObservable, isObservableArray, ObservableMap, isObservableMap, map, transaction, observable, computed, isObservable, isComputed, extendObservable, extendShallowObservable, observe, intercept, autorun, autorunAsync, when, reaction, action, isAction, runInAction, expr, toJS, createTransformer, whyRun, trace, isArrayLike };export default everything;\n\n\n\n// WEBPACK FOOTER //\n// ../node_modules/mobx/lib/mobx.module.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Provider = exports.inject = exports.connect = exports.useStaticRendering = exports.Observer = exports.observer = undefined;\n\nvar _observer = require('./observer');\n\nObject.defineProperty(exports, 'observer', {\n enumerable: true,\n get: function get() {\n return _observer.observer;\n }\n});\nObject.defineProperty(exports, 'Observer', {\n enumerable: true,\n get: function get() {\n return _observer.Observer;\n }\n});\nObject.defineProperty(exports, 'useStaticRendering', {\n enumerable: true,\n get: function get() {\n return _observer.useStaticRendering;\n }\n});\n\nvar _connect = require('./connect');\n\nObject.defineProperty(exports, 'connect', {\n enumerable: true,\n get: function get() {\n return _connect.connect;\n }\n});\n\nvar _inject = require('./inject');\n\nObject.defineProperty(exports, 'inject', {\n enumerable: true,\n get: function get() {\n return _inject.inject;\n }\n});\n\nvar _Provider = require('./Provider');\n\nObject.defineProperty(exports, 'Provider', {\n enumerable: true,\n get: function get() {\n return _Provider.Provider;\n }\n});\n\nvar _mobx = require('mobx');\n\nvar _preact = require('preact');\n\nif (!_preact.Component) {\n throw new Error('mobx-preact requires Preact to be available');\n}\nif (!_mobx.extras) {\n throw new Error('mobx-preact requires mobx to be available');\n}\n\n\n// WEBPACK FOOTER //\n// ../node_modules/mobx-preact/lib/index.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Observer = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.useStaticRendering = useStaticRendering;\nexports.observer = observer;\n\nvar _mobx = require('mobx');\n\nvar _preact = require('preact');\n\nvar _utils = require('./utils/utils');\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar isUsingStaticRendering = false;\n\nvar logger = console; // eslint-disable-line no-console\n\nfunction useStaticRendering(useStaticRendering) {\n isUsingStaticRendering = useStaticRendering;\n}\n\n/**\n Workaround\n\n allowStateChanges from mobX must be patched so that props, state and args are passed to the render() function\n */\n\nfunction allowStateChangesStart(allowStateChanges) {\n var prev = _mobx.extras.getGlobalState().allowStateChanges;\n _mobx.extras.getGlobalState().allowStateChanges = allowStateChanges;\n return prev;\n}\nfunction allowStateChangesEnd(prev) {\n _mobx.extras.getGlobalState().allowStateChanges = prev;\n}\n\nfunction allowStateChanges(allowStateChanges, func, props, state, context) {\n var prev = allowStateChangesStart(allowStateChanges);\n var res = void 0;\n try {\n res = func(props, state, context);\n } finally {\n allowStateChangesEnd(prev);\n }\n return res;\n}\n\n/**\n * Utilities\n */\n\nfunction patch(target, funcName) {\n var runMixinFirst = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n var base = target[funcName];\n var mixinFunc = reactiveMixin[funcName];\n var f = !base ? mixinFunc : runMixinFirst === true ? function () {\n mixinFunc.apply(this, arguments);\n base.apply(this, arguments);\n } : function () {\n base.apply(this, arguments);\n mixinFunc.apply(this, arguments);\n };\n\n // MWE: ideally we freeze here to protect against accidental overwrites in component instances, see #195\n // ...but that breaks react-hot-loader, see #231...\n target[funcName] = f;\n}\n\nfunction isObjectShallowModified(prev, next) {\n if (null == prev || null == next || (typeof prev === 'undefined' ? 'undefined' : _typeof(prev)) !== 'object' || (typeof next === 'undefined' ? 'undefined' : _typeof(next)) !== 'object') {\n return prev !== next;\n }\n var keys = Object.keys(prev);\n if (keys.length !== Object.keys(next).length) {\n return true;\n }\n var key = void 0;\n for (var i = keys.length - 1; i >= 0, key = keys[i]; i--) {\n if (next[key] !== prev[key]) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * ReactiveMixin\n */\nvar reactiveMixin = {\n componentWillMount: function componentWillMount() {\n var _this = this;\n\n if (isUsingStaticRendering === true) {\n return;\n }\n // Generate friendly name for debugging\n var initialName = (0, _utils.makeDisplayName)(this);\n\n /**\n * If props are shallowly modified, react will render anyway,\n * so atom.reportChanged() should not result in yet another re-render\n */\n var skipRender = false;\n /**\n * forceUpdate will re-assign this.props. We don't want that to cause a loop,\n * so detect these changes\n */\n var isForcingUpdate = false;\n\n function makePropertyObservableReference(propName) {\n var valueHolder = this[propName];\n var atom = new _mobx.Atom('reactive ' + propName);\n Object.defineProperty(this, propName, {\n configurable: true,\n enumerable: true,\n get: function get() {\n atom.reportObserved();\n return valueHolder;\n },\n set: function set(v) {\n if (!isForcingUpdate && isObjectShallowModified(valueHolder, v)) {\n valueHolder = v;\n skipRender = true;\n atom.reportChanged();\n skipRender = false;\n } else {\n valueHolder = v;\n }\n }\n });\n }\n\n // make this.props an observable reference, see #124\n makePropertyObservableReference.call(this, 'props');\n // make state an observable reference\n makePropertyObservableReference.call(this, 'state');\n\n // wire up reactive render\n var baseRender = this.render.bind(this);\n var reaction = null;\n var isRenderingPending = false;\n\n var initialRender = function initialRender() {\n reaction = new _mobx.Reaction(initialName + '.render()', function () {\n if (!isRenderingPending) {\n // N.B. Getting here *before mounting* means that a component constructor has side effects (see the relevant test in misc.js)\n // This unidiomatic React usage but React will correctly warn about this so we continue as usual\n // See #85 / Pull #44\n isRenderingPending = true;\n if (typeof _this.componentWillReact === 'function') {\n _this.componentWillReact();\n } // TODO: wrap in action?\n if (_this.__$mobxIsUnmounted !== true) {\n // If we are unmounted at this point, componentWillReact() had a side effect causing the component to unmounted\n // TODO: remove this check? Then react will properly warn about the fact that this should not happen? See #73\n // However, people also claim this migth happen during unit tests..\n var hasError = true;\n try {\n isForcingUpdate = true;\n if (!skipRender) {\n _preact.Component.prototype.forceUpdate.call(_this);\n }\n hasError = false;\n } finally {\n isForcingUpdate = false;\n if (hasError) {\n reaction.dispose();\n }\n }\n }\n }\n });\n reaction.reactComponent = _this;\n reactiveRender.$mobx = reaction;\n _this.render = reactiveRender;\n return reactiveRender(_this.props, _this.state, _this.context);\n };\n\n var reactiveRender = function reactiveRender(props, state, context) {\n isRenderingPending = false;\n var exception = undefined;\n var rendering = undefined;\n reaction.track(function () {\n try {\n rendering = allowStateChanges(false, baseRender, props, state, context);\n } catch (e) {\n exception = e;\n }\n });\n if (exception) {\n throw exception;\n }\n return rendering;\n };\n\n this.render = initialRender;\n },\n\n componentWillUnmount: function componentWillUnmount() {\n if (isUsingStaticRendering === true) {\n return;\n }\n this.render.$mobx && this.render.$mobx.dispose();\n this.__$mobxIsUnmounted = true;\n },\n\n componentDidMount: function componentDidMount() {},\n\n componentDidUpdate: function componentDidUpdate() {},\n\n shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {\n if (isUsingStaticRendering) {\n logger.warn('[mobx-preact] It seems that a re-rendering of a React component is triggered while in static (server-side) mode. Please make sure components are rendered only once server-side.');\n }\n // update on any state changes (as is the default)\n if (this.state !== nextState) {\n return true;\n }\n // update if props are shallowly not equal, inspired by PureRenderMixin\n // we could return just 'false' here, and avoid the `skipRender` checks etc\n // however, it is nicer if lifecycle events are triggered like usually,\n // so we return true here if props are shallowly modified.\n return isObjectShallowModified(this.props, nextProps);\n }\n};\n\n/**\n * Observer function / decorator\n */\nfunction observer(componentClass) {\n if (arguments.length > 1) {\n logger.warn('Mobx observer: Using observer to inject stores is not supported. Use `@connect([\"store1\", \"store2\"]) ComponentClass instead or preferably, use `@inject(\"store1\", \"store2\") @observer ComponentClass` or `inject(\"store1\", \"store2\")(observer(componentClass))``');\n }\n\n if (componentClass.isMobxInjector === true) {\n logger.warn('Mobx observer: You are trying to use \\'observer\\' on a component that already has \\'inject\\'. Please apply \\'observer\\' before applying \\'inject\\'');\n }\n\n // Stateless function component:\n if ((0, _utils.isStateless)(componentClass)) {\n var _class, _temp;\n\n return observer((_temp = _class = function (_Component) {\n _inherits(_class, _Component);\n\n function _class() {\n _classCallCheck(this, _class);\n\n return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments));\n }\n\n _createClass(_class, [{\n key: 'render',\n value: function render() {\n return componentClass.call(this, this.props, this.context);\n }\n }]);\n\n return _class;\n }(_preact.Component), _class.displayName = (0, _utils.makeDisplayName)(componentClass), _temp));\n }\n\n if (!componentClass) {\n throw new Error('Please pass a valid component to \\'observer\\'');\n }\n\n var target = componentClass.prototype || componentClass;\n mixinLifecycleEvents(target);\n componentClass.isMobXReactObserver = true;\n return componentClass;\n}\n\nfunction mixinLifecycleEvents(target) {\n patch(target, 'componentWillMount', true);\n patch(target, 'componentDidMount');\n\n if (!target.shouldComponentUpdate) {\n target.shouldComponentUpdate = reactiveMixin.shouldComponentUpdate;\n }\n}\n\nvar Observer = exports.Observer = observer(function (_ref) {\n var children = _ref.children;\n return children[0]();\n});\n\nObserver.displayName = 'Observer';\n\n\n// WEBPACK FOOTER //\n// ../node_modules/mobx-preact/lib/observer.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.isStateless = isStateless;\nexports.makeDisplayName = makeDisplayName;\n\nvar _preact = require('preact');\n\nfunction isStateless(component) {\n // `function() {}` has prototype, but `() => {}` doesn't\n // `() => {}` via Babel has prototype too.\n return !(component.prototype && component.prototype.render) && !_preact.Component.isPrototypeOf(component);\n}\n\nfunction makeDisplayName(component) {\n var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n _ref$prefix = _ref.prefix,\n prefix = _ref$prefix === undefined ? '' : _ref$prefix,\n _ref$suffix = _ref.suffix,\n suffix = _ref$suffix === undefined ? '' : _ref$suffix;\n\n var displayName = component.displayName || component.name || component.constructor && component.constructor.name || '<component>';\n return prefix + displayName + suffix;\n}\n\n\n// WEBPACK FOOTER //\n// ../node_modules/mobx-preact/lib/utils/utils.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.inject = inject;\n\nvar _preact = require('preact');\n\nvar _hoistNonReactStatics = require('hoist-non-react-statics');\n\nvar _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);\n\nvar _observer = require('./observer');\n\nvar _utils = require('./utils/utils');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar proxiedInjectorProps = {\n isMobxInjector: {\n value: true,\n writable: true,\n configurable: true,\n enumerable: true\n }\n};\n\n/**\n * Store Injection\n */\nfunction createStoreInjector(grabStoresFn, component, injectNames) {\n var _class, _temp;\n\n var prefix = 'inject-';\n var suffix = injectNames ? '-with-' + injectNames : '';\n var displayName = (0, _utils.makeDisplayName)(component, { prefix: prefix, suffix: suffix });\n\n var Injector = (_temp = _class = function (_Component) {\n _inherits(Injector, _Component);\n\n function Injector() {\n _classCallCheck(this, Injector);\n\n return _possibleConstructorReturn(this, (Injector.__proto__ || Object.getPrototypeOf(Injector)).apply(this, arguments));\n }\n\n _createClass(Injector, [{\n key: 'render',\n value: function render() {\n // Optimization: it might be more efficient to apply the mapper function *outside* the render method\n // (if the mapper is a function), that could avoid expensive(?) re-rendering of the injector component\n // See this test: 'using a custom injector is not too reactive' in inject.js\n var newProps = {};\n for (var key in this.props) {\n if (this.props.hasOwnProperty(key)) {\n newProps[key] = this.props[key];\n }\n }\n var additionalProps = grabStoresFn(this.context.mobxStores || {}, newProps, this.context) || {};\n for (var _key in additionalProps) {\n newProps[_key] = additionalProps[_key];\n }\n\n return (0, _preact.h)(component, newProps);\n }\n }]);\n\n return Injector;\n }(_preact.Component), _class.displayName = displayName, _temp);\n\n // Static fields from component should be visible on the generated Injector\n\n (0, _hoistNonReactStatics2.default)(Injector, component);\n\n Injector.wrappedComponent = component;\n Object.defineProperties(Injector, proxiedInjectorProps);\n\n return Injector;\n}\n\nfunction grabStoresByName(storeNames) {\n return function (baseStores, nextProps) {\n storeNames.forEach(function (storeName) {\n // prefer props over stores\n if (storeName in nextProps) {\n return;\n }\n if (!(storeName in baseStores)) {\n throw new Error('MobX injector: Store \\'' + storeName + '\\' is not available! Make sure it is provided by some Provider');\n }\n nextProps[storeName] = baseStores[storeName];\n });\n return nextProps;\n };\n}\n\n/**\n * higher order component that injects stores to a child.\n * takes either a varargs list of strings, which are stores read from the context,\n * or a function that manually maps the available stores from the context to props:\n * storesToProps(mobxStores, props, context) => newProps\n */\nfunction inject() /* fn(stores, nextProps) or ...storeNames */{\n var grabStoresFn = void 0;\n if (typeof arguments[0] === 'function') {\n grabStoresFn = arguments[0];\n return function (componentClass) {\n var injected = createStoreInjector(grabStoresFn, componentClass);\n injected.isMobxInjector = false; // suppress warning\n // mark the Injector as observer, to make it react to expressions in `grabStoresFn`,\n // see #111\n injected = (0, _observer.observer)(injected);\n injected.isMobxInjector = true; // restore warning\n return injected;\n };\n } else {\n var storeNames = [];\n for (var i = 0; i < arguments.length; i++) {\n storeNames[i] = arguments[i];\n }\n grabStoresFn = grabStoresByName(storeNames);\n return function (componentClass) {\n return createStoreInjector(grabStoresFn, componentClass, storeNames.join('-'));\n };\n }\n}\n\n\n// WEBPACK FOOTER //\n// ../node_modules/mobx-preact/lib/inject.js","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.JSONHTTPError = exports.TextHTTPError = exports.HTTPError = exports.getPagination = undefined;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _pagination = require(\"./pagination\");\n\nObject.defineProperty(exports, \"getPagination\", {\n enumerable: true,\n get: function get() {\n return _pagination.getPagination;\n }\n});\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nfunction _extendableBuiltin(cls) {\n function ExtendableBuiltin() {\n var instance = Reflect.construct(cls, Array.from(arguments));\n Object.setPrototypeOf(instance, Object.getPrototypeOf(this));\n return instance;\n }\n\n ExtendableBuiltin.prototype = Object.create(cls.prototype, {\n constructor: {\n value: cls,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(ExtendableBuiltin, cls);\n } else {\n ExtendableBuiltin.__proto__ = cls;\n }\n\n return ExtendableBuiltin;\n}\n\nvar HTTPError = exports.HTTPError = function (_extendableBuiltin2) {\n _inherits(HTTPError, _extendableBuiltin2);\n\n function HTTPError(response) {\n _classCallCheck(this, HTTPError);\n\n var _this = _possibleConstructorReturn(this, (HTTPError.__proto__ || Object.getPrototypeOf(HTTPError)).call(this, response.statusText));\n\n _this.name = _this.constructor.name;\n if (typeof Error.captureStackTrace === \"function\") {\n Error.captureStackTrace(_this, _this.constructor);\n } else {\n _this.stack = new Error(response.statusText).stack;\n }\n _this.status = response.status;\n return _this;\n }\n\n return HTTPError;\n}(_extendableBuiltin(Error));\n\nvar TextHTTPError = exports.TextHTTPError = function (_HTTPError) {\n _inherits(TextHTTPError, _HTTPError);\n\n function TextHTTPError(response, data) {\n _classCallCheck(this, TextHTTPError);\n\n var _this2 = _possibleConstructorReturn(this, (TextHTTPError.__proto__ || Object.getPrototypeOf(TextHTTPError)).call(this, response));\n\n _this2.data = data;\n return _this2;\n }\n\n return TextHTTPError;\n}(HTTPError);\n\nvar JSONHTTPError = exports.JSONHTTPError = function (_HTTPError2) {\n _inherits(JSONHTTPError, _HTTPError2);\n\n function JSONHTTPError(response, json) {\n _classCallCheck(this, JSONHTTPError);\n\n var _this3 = _possibleConstructorReturn(this, (JSONHTTPError.__proto__ || Object.getPrototypeOf(JSONHTTPError)).call(this, response));\n\n _this3.json = json;\n return _this3;\n }\n\n return JSONHTTPError;\n}(HTTPError);\n\nvar API = function () {\n function API() {\n var apiURL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n var options = arguments[1];\n\n _classCallCheck(this, API);\n\n this.apiURL = apiURL;\n if (this.apiURL.match(/\\/[^\\/]?/)) {\n // eslint-disable-line no-useless-escape\n this._sameOrigin = true;\n }\n this.defaultHeaders = options && options.defaultHeaders || {};\n }\n\n _createClass(API, [{\n key: \"headers\",\n value: function headers() {\n var _headers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n return _extends({}, this.defaultHeaders, {\n \"Content-Type\": \"application/json\"\n }, _headers);\n }\n }, {\n key: \"parseJsonResponse\",\n value: function parseJsonResponse(response) {\n return response.json().then(function (json) {\n if (!response.ok) {\n return Promise.reject(new JSONHTTPError(response, json));\n }\n\n var pagination = (0, _pagination.getPagination)(response);\n return pagination ? { pagination: pagination, items: json } : json;\n });\n }\n }, {\n key: \"request\",\n value: function request(path) {\n var _this4 = this;\n\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n var headers = this.headers(options.headers || {});\n if (this._sameOrigin) {\n options.credentials = options.credentials || \"same-origin\";\n }\n return fetch(this.apiURL + path, _extends({}, options, { headers: headers })).then(function (response) {\n var contentType = response.headers.get(\"Content-Type\");\n if (contentType && contentType.match(/json/)) {\n return _this4.parseJsonResponse(response);\n }\n\n if (!response.ok) {\n return response.text().then(function (data) {\n return Promise.reject(new TextHTTPError(response, data));\n });\n }\n return response.text().then(function (data) {\n data;\n });\n });\n }\n }]);\n\n return API;\n}();\n\nexports.default = API;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../node_modules/micro-api-client/lib/index.js\n// module id = 6\n// module chunks = 0","import { h, Component } from \"preact\";\n\nexport default class Button extends Component {\n render() {\n const { saving, text, saving_text } = this.props;\n\n return (\n <button type=\"submit\" className={`btn${saving ? \" saving\" : \"\"}`}>\n {saving ? saving_text || \"Saving\" : text || \"Save\"}\n </button>\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/forms/button.js","import { h, Component } from \"preact\";\n\nconst messages = {\n confirm: {\n type: \"success\",\n text:\n \"A confirmation message was sent to your email, click the link there to continue.\"\n },\n password_mail: {\n type: \"success\",\n text:\n \"We've sent a recovery email to your account, follow the link there to reset your password.\"\n },\n email_changed: {\n type: \"sucess\",\n text: \"Your email address has been updated!\"\n },\n verfication_error: {\n type: \"error\",\n text:\n \"There was an error verifying your account. Please try again or contact an administrator.\"\n },\n signup_disabled: {\n type: \"error\",\n text:\n \"Public signups are disabled. Contact an administrator and ask for an invite.\"\n }\n};\n\nexport default class Message extends Component {\n render() {\n const { type } = this.props;\n const msg = messages[type];\n\n return (\n <div className={`flashMessage ${msg.type}`}>\n <span>{msg.text}</span>\n </div>\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/forms/message.js","import netlifyIdentity from \"./netlify-identity\";\n\nif (typeof exports !== undefined) {\n exports.netlifyIdentity = netlifyIdentity;\n}\nif (typeof window !== undefined) {\n window.netlifyIdentity = netlifyIdentity;\n}\nif (document.readyState === \"loading\") {\n document.addEventListener(\"DOMContentLoaded\", () => {\n netlifyIdentity.init();\n });\n} else {\n netlifyIdentity.init();\n}\n\n\n\n// WEBPACK FOOTER //\n// ./index.js","import { h, render } from \"preact\";\nimport { observe } from \"mobx\";\nimport { Provider } from \"mobx-preact\";\nimport GoTrue from \"gotrue-js\";\nimport App from \"./components/app\";\nimport store from \"./state/store\";\nimport Controls from \"./components/controls\";\nimport modalCSS from \"./components/modal.css\";\n\nconst callbacks = {};\nfunction trigger(callback) {\n (callbacks[callback] || []).forEach(cb => {\n cb.apply(cb, Array.prototype.slice.call(arguments, 1));\n });\n}\n\nconst validActions = {\n login: true,\n signup: true,\n error: true\n};\n\nconst netlifyIdentity = {\n on: (event, cb) => {\n callbacks[event] = callbacks[event] || [];\n callbacks[event].push(cb);\n },\n open: action => {\n action = action || \"login\";\n if (!validActions[action]) {\n throw new Error(`Invalid action for open: ${action}`);\n }\n store.openModal(store.user ? \"user\" : action);\n },\n close: () => {\n store.closeModal();\n },\n currentUser: () => {\n return store.gotrue && store.gotrue.currentUser();\n },\n logout: () => {\n return store.logout();\n },\n get gotrue() {\n if (!store.gotrue) {\n store.openModal(\"login\");\n }\n return store.gotrue;\n },\n init: options => {\n init(options);\n },\n store\n};\n\nlet queuedIframeStyle = null;\nfunction setStyle(el, css) {\n let style = \"\";\n for (const key in css) {\n style += `${key}: ${css[key]}; `;\n }\n if (el) {\n el.setAttribute(\"style\", style);\n } else {\n queuedIframeStyle = style;\n }\n}\n\nconst localHosts = {\n localhost: true,\n \"127.0.0.1\": true,\n \"0.0.0.0\": true\n};\n\nfunction instantiateGotrue(APIUrl) {\n const isLocal = localHosts[document.location.host.split(\":\").shift()];\n const siteURL = isLocal && localStorage.getItem(\"netlifySiteURL\");\n if (APIUrl) {\n return new GoTrue({ APIUrl, setCookie: !isLocal });\n }\n if (isLocal && siteURL) {\n const parts = [siteURL];\n if (!siteURL.match(/\\/$/)) {\n parts.push(\"/\");\n }\n parts.push(\".netlify/identity\");\n store.setIsLocal(isLocal);\n store.setSiteURL(siteURL);\n return new GoTrue({ APIUrl: parts.join(\"\"), setCookie: !isLocal });\n }\n if (isLocal) {\n store.setIsLocal(isLocal);\n return null;\n }\n\n return new GoTrue({ setCookie: !isLocal });\n}\n\nlet root;\nlet iframe;\nconst iframeStyle = {\n position: \"fixed\",\n top: 0,\n left: 0,\n border: \"none\",\n width: \"100%\",\n height: \"100%\",\n overflow: \"visible\",\n background: \"transparent\",\n display: \"none\",\n \"z-index\": 99\n};\n\nobserve(store.modal, \"isOpen\", () => {\n if (!store.settings) {\n store.loadSettings();\n }\n setStyle(iframe, {\n ...iframeStyle,\n display: store.modal.isOpen ? \"block !important\" : \"none\"\n });\n if (store.modal.isOpen) {\n trigger(\"open\", store.modal.page);\n } else {\n trigger(\"close\");\n }\n});\n\nobserve(store, \"siteURL\", () => {\n if (store.siteURL === null || store.siteURL === undefined) {\n localStorage.removeItem(\"netlifySiteURL\");\n } else {\n localStorage.setItem(\"netlifySiteURL\", store.siteURL);\n }\n store.init(instantiateGotrue(), true);\n});\n\nobserve(store, \"user\", () => {\n if (store.user) {\n trigger(\"login\", store.user);\n } else {\n trigger(\"logout\");\n }\n});\n\nobserve(store, \"gotrue\", () => {\n store.gotrue && trigger(\"init\", store.gotrue.currentUser());\n});\n\nobserve(store, \"error\", () => {\n trigger(\"error\", store.error);\n});\n\nconst routes = /(confirmation|invite|recovery|email_change)_token=([^&]+)/;\nconst errorRoute = /error=access_denied&error_description=403/;\nconst accessTokenRoute = /access_token=/;\n\nfunction runRoutes() {\n const hash = (document.location.hash || \"\").replace(/^#\\/?/, \"\");\n if (!hash) {\n return;\n }\n\n const m = hash.match(routes);\n if (m) {\n store.verifyToken(m[1], m[2]);\n document.location.hash = \"\";\n }\n\n const em = hash.match(errorRoute);\n if (em) {\n store.openModal(\"signup\");\n document.location.hash = \"\";\n }\n\n const am = hash.match(accessTokenRoute);\n if (am) {\n const params = {};\n hash.split(\"&\").forEach(pair => {\n const [key, value] = pair.split(\"=\");\n params[key] = value;\n });\n if (!!document && params[\"access_token\"]) {\n document.cookie = `nf_jwt=${params[\"access_token\"]}`;\n }\n if (params[\"state\"]) {\n try {\n // skip initialization for implicit auth\n const state = decodeURIComponent(params[\"state\"]);\n const { auth_type } = JSON.parse(state);\n if (auth_type === \"implicit\") {\n return;\n }\n // eslint-disable-next-line no-empty\n } catch (e) {}\n }\n document.location.hash = \"\";\n store.openModal(\"login\");\n store.completeExternalLogin(params);\n }\n}\n\nfunction init(options = {}) {\n const { APIUrl, logo = true, namePlaceholder } = options;\n const controlEls = document.querySelectorAll(\n \"[data-netlify-identity-menu],[data-netlify-identity-button]\"\n );\n Array.prototype.slice.call(controlEls).forEach(el => {\n let controls = null;\n const mode =\n el.getAttribute(\"data-netlify-identity-menu\") === null\n ? \"button\"\n : \"menu\";\n render(\n <Provider store={store}>\n <Controls mode={mode} text={el.innerText.trim()} />\n </Provider>,\n el,\n controls\n );\n });\n\n store.init(instantiateGotrue(APIUrl));\n store.modal.logo = logo;\n store.setNamePlaceholder(namePlaceholder);\n iframe = document.createElement(\"iframe\");\n iframe.id = \"netlify-identity-widget\";\n iframe.title = \"Netlify identity widget\";\n iframe.onload = () => {\n const styles = iframe.contentDocument.createElement(\"style\");\n styles.innerHTML = modalCSS.toString();\n iframe.contentDocument.head.appendChild(styles);\n root = render(\n <Provider store={store}>\n <App />\n </Provider>,\n iframe.contentDocument.body,\n root\n );\n runRoutes();\n };\n setStyle(iframe, iframeStyle);\n iframe.src = \"about:blank\";\n const container = options.container\n ? document.querySelector(options.container)\n : document.body;\n container.appendChild(iframe);\n /* There's a certain case where we might have called setStyle before the iframe was ready.\n\t Make sure we take the last style and apply it */\n if (queuedIframeStyle) {\n iframe.setAttribute(\"style\", queuedIframeStyle);\n queuedIframeStyle = null;\n }\n}\n\nexport default netlifyIdentity;\n\n\n\n// WEBPACK FOOTER //\n// ./netlify-identity.js","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\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// WEBPACK FOOTER //\n// ../node_modules/webpack/buildin/global.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.connect = connect;\n\nvar _observer = require('./observer');\n\nvar _inject = require('./inject');\n\nfunction connect(arg1, arg2) {\n if (typeof arg1 === 'string') {\n throw new Error('Store names should be provided as array');\n }\n if (Array.isArray(arg1)) {\n if (!arg2) {\n // invoked as decorator\n return function (componentClass) {\n return connect(arg1, componentClass);\n };\n } else {\n return _inject.inject.apply(null, arg1)(connect(arg2));\n }\n }\n return (0, _observer.observer)(arg1);\n}\n\n\n// WEBPACK FOOTER //\n// ../node_modules/mobx-preact/lib/connect.js","'use strict';\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n childContextTypes: true,\n contextTypes: true,\n defaultProps: true,\n displayName: true,\n getDefaultProps: true,\n getDerivedStateFromProps: true,\n mixins: true,\n propTypes: true,\n type: true\n};\n\nvar KNOWN_STATICS = {\n name: true,\n length: true,\n prototype: true,\n caller: true,\n callee: true,\n arguments: true,\n arity: true\n};\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = getPrototypeOf && getPrototypeOf(Object);\n\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components\n\n if (objectPrototype) {\n var inheritedComponent = getPrototypeOf(sourceComponent);\n if (inheritedComponent && inheritedComponent !== objectPrototype) {\n hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n }\n }\n\n var keys = getOwnPropertyNames(sourceComponent);\n\n if (getOwnPropertySymbols) {\n keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n }\n\n for (var i = 0; i < keys.length; ++i) {\n var key = keys[i];\n if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) {\n var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n try { // Avoid failures from read-only properties\n defineProperty(targetComponent, key, descriptor);\n } catch (e) {}\n }\n }\n\n return targetComponent;\n }\n\n return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n\n\n\n// WEBPACK FOOTER //\n// ../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Provider = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = require('preact');\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar specialReactKeys = { children: true, key: true, ref: true };\n\nvar logger = console; // eslint-disable-line no-console\n\nvar Provider = exports.Provider = function (_Component) {\n _inherits(Provider, _Component);\n\n function Provider() {\n _classCallCheck(this, Provider);\n\n return _possibleConstructorReturn(this, (Provider.__proto__ || Object.getPrototypeOf(Provider)).apply(this, arguments));\n }\n\n _createClass(Provider, [{\n key: 'render',\n value: function render(_ref) {\n var children = _ref.children;\n\n return children.length > 1 ? (0, _preact.h)(\n 'div',\n null,\n ' ',\n children,\n ' '\n ) : children[0];\n }\n }, {\n key: 'getChildContext',\n value: function getChildContext() {\n var stores = {};\n // inherit stores\n var baseStores = this.context.mobxStores;\n if (baseStores) {\n for (var key in baseStores) {\n stores[key] = baseStores[key];\n }\n }\n // add own stores\n for (var _key in this.props) {\n if (!specialReactKeys[_key] && _key !== 'suppressChangedStoreWarning') {\n stores[_key] = this.props[_key];\n }\n }\n\n return {\n mobxStores: stores\n };\n }\n }, {\n key: 'componentWillReceiveProps',\n value: function componentWillReceiveProps(nextProps) {\n // Maybe this warning is too aggressive?\n if (Object.keys(nextProps).length !== Object.keys(this.props).length) {\n logger.warn('MobX Provider: The set of provided stores has changed. Please avoid changing stores as the change might not propagate to all children');\n }\n if (!nextProps.suppressChangedStoreWarning) {\n for (var key in nextProps) {\n if (!specialReactKeys[key] && this.props[key] !== nextProps[key]) {\n logger.warn('MobX Provider: Provided store \\'' + key + '\\' has changed. Please avoid replacing stores as the change might not propagate to all children');\n }\n }\n }\n }\n }]);\n\n return Provider;\n}(_preact.Component);\n\n\n// WEBPACK FOOTER //\n// ../node_modules/mobx-preact/lib/Provider.js","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _microApiClient = require(\"micro-api-client\");\n\nvar _microApiClient2 = _interopRequireDefault(_microApiClient);\n\nvar _user = require(\"./user\");\n\nvar _user2 = _interopRequireDefault(_user);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar HTTPRegexp = /^http:\\/\\//;\nvar defaultApiURL = \"/.netlify/identity\";\n\nvar GoTrue = function () {\n function GoTrue() {\n var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n _ref$APIUrl = _ref.APIUrl,\n APIUrl = _ref$APIUrl === undefined ? defaultApiURL : _ref$APIUrl,\n _ref$audience = _ref.audience,\n audience = _ref$audience === undefined ? \"\" : _ref$audience,\n _ref$setCookie = _ref.setCookie,\n setCookie = _ref$setCookie === undefined ? false : _ref$setCookie;\n\n _classCallCheck(this, GoTrue);\n\n if (APIUrl.match(HTTPRegexp)) {\n console.warn(\"Warning:\\n\\nDO NOT USE HTTP IN PRODUCTION FOR GOTRUE EVER!\\nGoTrue REQUIRES HTTPS to work securely.\");\n }\n\n if (audience) {\n this.audience = audience;\n }\n\n this.setCookie = setCookie;\n\n this.api = new _microApiClient2.default(APIUrl);\n }\n\n _createClass(GoTrue, [{\n key: \"_request\",\n value: function _request(path) {\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n options.headers = options.headers || {};\n var aud = options.audience || this.audience;\n if (aud) {\n options.headers[\"X-JWT-AUD\"] = aud;\n }\n return this.api.request(path, options).catch(function (err) {\n if (err instanceof _microApiClient.JSONHTTPError && err.json) {\n if (err.json.msg) {\n err.message = err.json.msg;\n } else if (err.json.error) {\n err.message = err.json.error + \": \" + err.json.error_description;\n }\n }\n return Promise.reject(err);\n });\n }\n }, {\n key: \"settings\",\n value: function settings() {\n return this._request(\"/settings\");\n }\n }, {\n key: \"signup\",\n value: function signup(email, password, data) {\n return this._request(\"/signup\", {\n method: \"POST\",\n body: JSON.stringify({ email: email, password: password, data: data })\n });\n }\n }, {\n key: \"login\",\n value: function login(email, password, remember) {\n var _this = this;\n\n this._setRememberHeaders(remember);\n return this._request(\"/token\", {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n body: \"grant_type=password&username=\" + encodeURIComponent(email) + \"&password=\" + encodeURIComponent(password)\n }).then(function (response) {\n _user2.default.removeSavedSession();\n return _this.createUser(response, remember);\n });\n }\n }, {\n key: \"loginExternalUrl\",\n value: function loginExternalUrl(provider) {\n return this.api.apiURL + \"/authorize?provider=\" + provider;\n }\n }, {\n key: \"confirm\",\n value: function confirm(token, remember) {\n this._setRememberHeaders(remember);\n return this.verify(\"signup\", token, remember);\n }\n }, {\n key: \"requestPasswordRecovery\",\n value: function requestPasswordRecovery(email) {\n return this._request(\"/recover\", {\n method: \"POST\",\n body: JSON.stringify({ email: email })\n });\n }\n }, {\n key: \"recover\",\n value: function recover(token, remember) {\n this._setRememberHeaders(remember);\n return this.verify(\"recovery\", token, remember);\n }\n }, {\n key: \"acceptInvite\",\n value: function acceptInvite(token, password, remember) {\n var _this2 = this;\n\n this._setRememberHeaders(remember);\n return this._request(\"/verify\", {\n method: \"POST\",\n body: JSON.stringify({ token: token, password: password, type: \"signup\" })\n }).then(function (response) {\n return _this2.createUser(response, remember);\n });\n }\n }, {\n key: \"acceptInviteExternalUrl\",\n value: function acceptInviteExternalUrl(provider, token) {\n return this.api.apiURL + \"/authorize?provider=\" + provider + \"&invite_token=\" + token;\n }\n }, {\n key: \"createUser\",\n value: function createUser(tokenResponse) {\n var remember = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n this._setRememberHeaders(remember);\n var user = new _user2.default(this.api, tokenResponse, this.audience);\n return user.getUserData().then(function (user) {\n if (remember) {\n user._saveSession();\n }\n return user;\n });\n }\n }, {\n key: \"currentUser\",\n value: function currentUser() {\n var user = _user2.default.recoverSession(this.api);\n user && this._setRememberHeaders(user._fromStorage);\n return user;\n }\n }, {\n key: \"verify\",\n value: function verify(type, token, remember) {\n var _this3 = this;\n\n this._setRememberHeaders(remember);\n return this._request(\"/verify\", {\n method: \"POST\",\n body: JSON.stringify({ token: token, type: type })\n }).then(function (response) {\n return _this3.createUser(response, remember);\n });\n }\n }, {\n key: \"_setRememberHeaders\",\n value: function _setRememberHeaders(remember) {\n if (this.setCookie) {\n this.api.defaultHeaders = this.api.defaultHeaders || {};\n this.api.defaultHeaders[\"X-Use-Cookie\"] = remember ? \"1\" : \"session\";\n }\n }\n }]);\n\n return GoTrue;\n}();\n\nexports.default = GoTrue;\n\n\nif (typeof window !== \"undefined\") {\n window.GoTrue = GoTrue;\n}\n\n\n// WEBPACK FOOTER //\n// ../node_modules/gotrue-js/lib/index.js","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nexports.getPagination = getPagination;\nfunction getPagination(response) {\n var links = response.headers.get(\"Link\");\n var pagination = {};\n //var link, url, rel, m, page;\n if (links == null) {\n return null;\n }\n links = links.split(\",\");\n var total = response.headers.get(\"X-Total-Count\");\n\n for (var i = 0, len = links.length; i < len; i++) {\n var link = links[i].replace(/(^\\s*|\\s*$)/, \"\");\n\n var _link$split = link.split(\";\"),\n _link$split2 = _slicedToArray(_link$split, 2),\n url = _link$split2[0],\n rel = _link$split2[1];\n\n var m = url.match(/page=(\\d+)/);\n var page = m && parseInt(m[1], 10);\n if (rel.match(/last/)) {\n pagination.last = page;\n } else if (rel.match(/next/)) {\n pagination.next = page;\n } else if (rel.match(/prev/)) {\n pagination.prev = page;\n } else if (rel.match(/first/)) {\n pagination.first = page;\n }\n }\n\n pagination.last = Math.max(pagination.last || 0, pagination.prev && pagination.prev + 1 || 0);\n pagination.current = pagination.next ? pagination.next - 1 : pagination.last || 1;\n pagination.total = total ? parseInt(total, 10) : null;\n\n return pagination;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../node_modules/micro-api-client/lib/pagination.js\n// module id = 16\n// module chunks = 0","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _microApiClient = require(\"micro-api-client\");\n\nvar _microApiClient2 = _interopRequireDefault(_microApiClient);\n\nvar _admin = require(\"./admin\");\n\nvar _admin2 = _interopRequireDefault(_admin);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ExpiryMargin = 60 * 1000;\nvar storageKey = \"gotrue.user\";\nvar refreshPromises = {};\nvar currentUser = null;\nvar forbiddenUpdateAttributes = { api: 1, token: 1, audience: 1, url: 1 };\nvar forbiddenSaveAttributes = { api: 1 };\n\nvar User = function () {\n function User(api, tokenResponse, audience) {\n _classCallCheck(this, User);\n\n this.api = api;\n this.url = api.apiURL;\n this.audience = audience;\n this._processTokenResponse(tokenResponse);\n currentUser = this;\n }\n\n _createClass(User, [{\n key: \"update\",\n value: function update(attributes) {\n var _this = this;\n\n return this._request(\"/user\", {\n method: \"PUT\",\n body: JSON.stringify(attributes)\n }).then(function (response) {\n return _this._saveUserData(response)._refreshSavedSession();\n });\n }\n }, {\n key: \"jwt\",\n value: function jwt(forceRefresh) {\n var _tokenDetails = this.tokenDetails(),\n expires_at = _tokenDetails.expires_at,\n refresh_token = _tokenDetails.refresh_token,\n access_token = _tokenDetails.access_token;\n\n if (forceRefresh || expires_at - ExpiryMargin < Date.now()) {\n return this._refreshToken(refresh_token);\n }\n return Promise.resolve(access_token);\n }\n }, {\n key: \"logout\",\n value: function logout() {\n return this._request(\"/logout\", { method: \"POST\" }).then(this.clearSession.bind(this)).catch(this.clearSession.bind(this));\n }\n }, {\n key: \"_refreshToken\",\n value: function _refreshToken(refresh_token) {\n var _this2 = this;\n\n if (refreshPromises[refresh_token]) {\n return refreshPromises[refresh_token];\n }\n return refreshPromises[refresh_token] = this.api.request(\"/token\", {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n body: \"grant_type=refresh_token&refresh_token=\" + refresh_token\n }).then(function (response) {\n delete refreshPromises[refresh_token];\n _this2._processTokenResponse(response);\n _this2._refreshSavedSession();\n return _this2.token.access_token;\n }).catch(function (error) {\n delete refreshPromises[refresh_token];\n _this2.clearSession();\n return Promise.reject(error);\n });\n }\n }, {\n key: \"_request\",\n value: function _request(path) {\n var _this3 = this;\n\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n options.headers = options.headers || {};\n\n var aud = options.audience || this.audience;\n if (aud) {\n options.headers[\"X-JWT-AUD\"] = aud;\n }\n\n return this.jwt().then(function (token) {\n return _this3.api.request(path, _extends({\n headers: Object.assign(options.headers, {\n Authorization: \"Bearer \" + token\n })\n }, options)).catch(function (err) {\n if (err instanceof _microApiClient.JSONHTTPError && err.json) {\n if (err.json.msg) {\n err.message = err.json.msg;\n } else if (err.json.error) {\n err.message = err.json.error + \": \" + err.json.error_description;\n }\n }\n return Promise.reject(err);\n });\n });\n }\n }, {\n key: \"getUserData\",\n value: function getUserData() {\n return this._request(\"/user\").then(this._saveUserData.bind(this)).then(this._refreshSavedSession.bind(this));\n }\n }, {\n key: \"_saveUserData\",\n value: function _saveUserData(attributes, fromStorage) {\n for (var key in attributes) {\n if (key in User.prototype || key in forbiddenUpdateAttributes) {\n continue;\n }\n this[key] = attributes[key];\n }\n if (fromStorage) {\n this._fromStorage = true;\n }\n return this;\n }\n }, {\n key: \"_processTokenResponse\",\n value: function _processTokenResponse(tokenResponse) {\n this.token = tokenResponse;\n var claims = void 0;\n try {\n claims = JSON.parse(urlBase64Decode(tokenResponse.access_token.split(\".\")[1]));\n this.token.expires_at = claims.exp * 1000;\n } catch (e) {\n console.error(new Error(\"Gotrue-js: Failed to parse tokenResponse claims: \" + JSON.stringify(tokenResponse)));\n }\n }\n }, {\n key: \"_refreshSavedSession\",\n value: function _refreshSavedSession() {\n // only update saved session if we previously saved something\n if (localStorage.getItem(storageKey)) {\n this._saveSession();\n }\n return this;\n }\n }, {\n key: \"_saveSession\",\n value: function _saveSession() {\n localStorage.setItem(storageKey, JSON.stringify(this._details));\n return this;\n }\n }, {\n key: \"tokenDetails\",\n value: function tokenDetails() {\n return this.token;\n }\n }, {\n key: \"clearSession\",\n value: function clearSession() {\n User.removeSavedSession();\n this.token = null;\n currentUser = null;\n }\n }, {\n key: \"admin\",\n get: function get() {\n return new _admin2.default(this);\n }\n }, {\n key: \"_details\",\n get: function get() {\n var userCopy = {};\n for (var key in this) {\n if (key in User.prototype || key in forbiddenSaveAttributes) {\n continue;\n }\n userCopy[key] = this[key];\n }\n return userCopy;\n }\n }], [{\n key: \"removeSavedSession\",\n value: function removeSavedSession() {\n localStorage.removeItem(storageKey);\n }\n }, {\n key: \"recoverSession\",\n value: function recoverSession(apiInstance) {\n if (currentUser) {\n return currentUser;\n }\n\n var json = localStorage.getItem(storageKey);\n if (json) {\n try {\n var data = JSON.parse(json);\n var url = data.url,\n token = data.token,\n audience = data.audience;\n\n if (!url || !token) {\n return null;\n }\n\n var api = apiInstance || new _microApiClient2.default(url, {});\n return new User(api, token, audience)._saveUserData(data, true);\n } catch (ex) {\n console.error(new Error(\"Gotrue-js: Error recovering session: \" + ex));\n return null;\n }\n }\n\n return null;\n }\n }]);\n\n return User;\n}();\n\nexports.default = User;\n\n\nfunction urlBase64Decode(str) {\n // From https://jwt.io/js/jwt.js\n var output = str.replace(/-/g, '+').replace(/_/g, '/');\n switch (output.length % 4) {\n case 0:\n break;\n case 2:\n output += '==';\n break;\n case 3:\n output += '=';\n break;\n default:\n throw 'Illegal base64url string!';\n }\n var result = window.atob(output); //polifyll https://github.com/davidchambers/Base64.js\n try {\n return decodeURIComponent(escape(result));\n } catch (err) {\n return result;\n }\n}\n\n\n// WEBPACK FOOTER //\n// ../node_modules/gotrue-js/lib/user.js","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Admin = function () {\n function Admin(user) {\n _classCallCheck(this, Admin);\n\n this.user = user;\n }\n\n // Return a list of all users in an audience\n\n\n _createClass(Admin, [{\n key: \"listUsers\",\n value: function listUsers(aud) {\n return this.user._request(\"/admin/users\", {\n method: \"GET\",\n audience: aud\n });\n }\n }, {\n key: \"getUser\",\n value: function getUser(user) {\n return this.user._request(\"/admin/users/\" + user.id);\n }\n }, {\n key: \"updateUser\",\n value: function updateUser(user) {\n var attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n return this.user._request(\"/admin/users/\" + user.id, {\n method: \"PUT\",\n body: JSON.stringify(attributes)\n });\n }\n }, {\n key: \"createUser\",\n value: function createUser(email, password) {\n var attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n attributes.email = email;\n attributes.password = password;\n return this.user._request(\"/admin/users\", {\n method: \"POST\",\n body: JSON.stringify(attributes)\n });\n }\n }, {\n key: \"deleteUser\",\n value: function deleteUser(user) {\n return this.user._request(\"/admin/users/\" + user.id, {\n method: \"DELETE\"\n });\n }\n }]);\n\n return Admin;\n}();\n\nexports.default = Admin;\n\n\n// WEBPACK FOOTER //\n// ../node_modules/gotrue-js/lib/admin.js","import { h, Component } from \"preact\";\nimport { connect } from \"mobx-preact\";\nimport Modal from \"./modal\";\nimport SiteURLForm from \"./forms/siteurl\";\nimport LogoutForm from \"./forms/logout\";\nimport UserForm from \"./forms/user\";\nimport Providers from \"./forms/providers\";\nimport Message from \"./forms/message\";\n\nconst pagesWithHeader = { login: true, signup: true };\nconst pages = {\n login: {\n login: true,\n button: \"Log in\",\n button_saving: \"Logging in\",\n email: true,\n password: true,\n link: \"amnesia\",\n link_text: \"Forgot password?\",\n providers: true\n },\n signup: {\n signup: true,\n button: \"Sign up\",\n button_saving: \"Signing Up\",\n name: true,\n email: true,\n password: true,\n providers: true\n },\n amnesia: {\n title: \"Recover password\",\n button: \"Send recovery email\",\n button_saving: \"Sending recovery email\",\n email: true,\n link: \"login\",\n link_text: \"Never mind\"\n },\n recovery: {\n title: \"Recover password\",\n button: \"Update password\",\n button_saving: \"Updating password\",\n password: true,\n link: \"login\",\n link_text: \"Never mind\"\n },\n invite: {\n title: \"Complete your signup\",\n button: \"Sign up\",\n button_saving: \"Signing Up\",\n password: true,\n providers: true\n },\n user: {\n title: \"Logged in\"\n }\n};\n\n@connect([\"store\"])\nclass App extends Component {\n handleClose = () => this.props.store.closeModal();\n handlePage = page => this.props.store.openModal(page);\n handleLogout = () => this.props.store.logout();\n handleSiteURL = url => this.props.store.setSiteURL(url);\n clearSiteURL = url => this.props.store.clearSiteURL();\n handleExternalLogin = provider => this.props.store.externalLogin(provider);\n handleUser = ({ name, email, password }) => {\n const { store } = this.props;\n\n switch (store.modal.page) {\n case \"login\":\n store.login(email, password);\n break;\n case \"signup\":\n store.signup(name, email, password);\n break;\n case \"amnesia\":\n store.requestPasswordRecovery(email);\n break;\n case \"invite\":\n store.acceptInvite(password);\n break;\n case \"recovery\":\n store.updatePassword(password);\n break;\n }\n };\n\n renderBody() {\n const { store } = this.props;\n const page = pages[store.modal.page] || {};\n const pageLinkHandler = () => this.handlePage(page.link);\n\n if (store.isLocal && store.siteURL === null) {\n return (\n <SiteURLForm\n devMode={store.siteURL != null}\n onSiteURL={store.siteURL ? this.clearSiteURL : this.handleSiteURL}\n />\n );\n }\n if (!store.settings) {\n return;\n }\n if (store.user) {\n return (\n <LogoutForm\n user={store.user}\n saving={store.saving}\n onLogout={this.handleLogout}\n />\n );\n }\n if (store.modal.page === \"signup\" && store.settings.disable_signup) {\n return <Message type=\"signup_disabled\" />;\n }\n\n return (\n <div>\n <UserForm\n page={pages[store.modal.page] || {}}\n message={store.message}\n saving={store.saving}\n onSubmit={this.handleUser}\n namePlaceholder={store.namePlaceholder}\n />\n {!store.user && page.link && store.gotrue && (\n <button\n onclick={pageLinkHandler}\n className=\"btnLink forgotPasswordLink\"\n >\n {page.link_text}\n </button>\n )}\n {store.isLocal ? (\n <SiteURLForm\n devMode={store.siteURL != null}\n onSiteURL={store.siteURL ? this.clearSiteURL : this.handleSiteURL}\n />\n ) : (\n <div />\n )}\n </div>\n );\n }\n\n renderProviders() {\n const { store } = this.props;\n\n if (!(store.gotrue && store.settings)) {\n return null;\n }\n if (store.modal.page === \"signup\" && store.settings.disable_signup) {\n return null;\n }\n const page = pages[store.modal.page] || {};\n\n if (!page.providers) {\n return null;\n }\n\n const providers = [\n \"Google\",\n \"GitHub\",\n \"GitLab\",\n \"BitBucket\",\n \"SAML\"\n ].filter(p => store.settings.external[p.toLowerCase()]);\n\n return providers.length ? (\n <Providers\n providers={providers}\n labels={store.settings.external_labels || {}}\n onLogin={this.handleExternalLogin}\n />\n ) : null;\n }\n\n render() {\n const { store } = this.props;\n const showHeader = pagesWithHeader[store.modal.page];\n const showSignup = store.settings && !store.settings.disable_signup;\n const page = pages[store.modal.page] || {};\n\n return (\n <div>\n <Modal\n page={page}\n error={store.error}\n showHeader={showHeader}\n showSignup={showSignup}\n devSettings={!store.gotrue}\n loading={!store.error && store.gotrue && !store.settings}\n isOpen={store.modal.isOpen}\n onPage={this.handlePage}\n onClose={this.handleClose}\n logo={store.modal.logo}\n >\n {this.renderBody()}\n {this.renderProviders()}\n </Modal>\n </div>\n );\n }\n}\n\nexport default App;\n\n\n\n// WEBPACK FOOTER //\n// ./components/app.js","import { h, Component } from \"preact\";\n\nfunction formatError(error) {\n return (\n (error.json && error.json.error_description) ||\n error.message ||\n error.toString()\n );\n}\n\nexport default class Modal extends Component {\n handleClose = e => {\n e.preventDefault();\n this.props.onClose();\n };\n\n blockEvent = e => {\n e.stopPropagation();\n };\n\n linkHandler = page => e => {\n e.preventDefault();\n this.props.onPage(page);\n };\n\n render() {\n const {\n page,\n error,\n loading,\n showHeader,\n showSignup,\n devSettings,\n isOpen,\n children,\n logo\n } = this.props;\n const hidden = loading || !isOpen;\n return (\n <div\n className=\"modalContainer\"\n role=\"dialog\"\n aria-hidden={`${hidden}`}\n onClick={this.handleClose}\n >\n <div\n className={`modalDialog${loading ? \" visuallyHidden\" : \"\"}`}\n onClick={this.blockEvent}\n >\n <div className=\"modalContent\">\n <button onclick={this.handleClose} className=\"btn btnClose\">\n <span className=\"visuallyHidden\">Close</span>\n </button>\n {showHeader && (\n <div className=\"header\">\n {showSignup && (\n <button\n className={`btn btnHeader ${page.signup ? \"active\" : \"\"}`}\n onclick={this.linkHandler(\"signup\")}\n >\n Sign up\n </button>\n )}\n {!devSettings && (\n <button\n className={`btn btnHeader ${page.login ? \"active\" : \"\"}`}\n onclick={this.linkHandler(\"login\")}\n >\n Log in\n </button>\n )}\n </div>\n )}\n {page.title && (\n <div className=\"header\">\n <button className=\"btn btnHeader active\">{page.title}</button>\n </div>\n )}\n {devSettings && (\n <div className=\"header\">\n <button className=\"btn btnHeader active\">\n Development Settings\n </button>\n </div>\n )}\n {error && (\n <div className=\"flashMessage error\">\n <span>{formatError(error)}</span>\n </div>\n )}\n {children}\n </div>\n </div>\n {logo && (\n <a\n href=\"https://www.netlify.com\"\n className={`callOut${loading ? \" visuallyHidden\" : \"\"}`}\n >\n <span className=\"netlifyLogo\" />\n Coded by Netlify\n </a>\n )}\n </div>\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/modal/index.js","import { h, Component } from \"preact\";\n\nexport default class SiteURLForm extends Component {\n constructor(props) {\n super(props);\n this.state = { url: \"\", development: props.devMode || false };\n }\n\n handleInput = e => {\n this.setState({ [e.target.name]: e.target.value });\n };\n\n addSiteURL = e => {\n e.preventDefault();\n this.props.onSiteURL(this.state.url);\n };\n\n clearSiteURL = e => {\n e.preventDefault;\n this.props.onSiteURL();\n };\n\n render() {\n const { url, development } = this.state;\n\n return (\n <div>\n {development ? (\n <div class=\"subheader\">\n <h3>Development Settings</h3>\n <button\n onclick={e => this.clearSiteURL(e)}\n className=\"btnLink forgotPasswordLink\"\n >\n Clear localhost URL\n </button>\n </div>\n ) : (\n <form onsubmit={this.addSiteURL} className=\"form\">\n <div className=\"flashMessage\">\n {\n \"Looks like you're running a local server. Please let us know the URL of your Netlify site.\"\n }\n </div>\n <div className=\"formGroup\">\n <label>\n <span className=\"visuallyHidden\">\n Enter your Netlify Site URL\n </span>\n <input\n className=\"formControl\"\n type=\"url\"\n name=\"url\"\n value={url}\n placeholder=\"URL of your Netlify site\"\n autocapitalize=\"off\"\n required\n oninput={this.handleInput}\n />\n <div className=\"inputFieldIcon inputFieldUrl\" />\n </label>\n </div>\n <button type=\"submit\" className=\"btn\">\n Set site's URL\n </button>\n </form>\n )}\n </div>\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/forms/siteurl.js","import { h, Component } from \"preact\";\nimport Button from \"./button\";\n\nexport default class LogoutForm extends Component {\n handleLogout = e => {\n e.preventDefault();\n this.props.onLogout();\n };\n render() {\n const { user, saving } = this.props;\n\n return (\n <form\n onSubmit={this.handleLogout}\n className={`form ${saving ? \"disabled\" : \"\"}`}\n >\n <p className=\"infoText\">\n Logged in as <br />\n <span className=\"infoTextEmail\">\n {user.user_metadata.full_name ||\n user.user_metadata.name ||\n user.email}\n </span>\n </p>\n <Button saving={saving} text=\"Log out\" saving_text=\"Logging out\" />\n </form>\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/forms/logout.js","import { h, Component } from \"preact\";\nimport Message from \"./message\";\nimport Button from \"./button\";\n\nexport default class UserForm extends Component {\n constructor(props) {\n super(props);\n this.state = { name: \"\", email: \"\", password: \"\" };\n }\n\n handleInput = e => {\n this.setState({ [e.target.name]: e.target.value });\n };\n\n handleLogin = e => {\n e.preventDefault();\n this.props.onSubmit(this.state);\n };\n\n render() {\n const { page, message, saving, namePlaceholder } = this.props;\n const { name, email, password } = this.state;\n\n return (\n <form\n onsubmit={this.handleLogin}\n className={`form ${saving ? \"disabled\" : \"\"}`}\n >\n {message && <Message type={message} />}\n {page.name && (\n <div className=\"formGroup\">\n <label>\n <span className=\"visuallyHidden\">Enter your name</span>\n <input\n className=\"formControl\"\n type=\"name\"\n name=\"name\"\n value={name}\n placeholder={namePlaceholder ? namePlaceholder : \"Name\"}\n autocapitalize=\"off\"\n required\n oninput={this.handleInput}\n />\n <div className=\"inputFieldIcon inputFieldName\" />\n </label>\n </div>\n )}\n {page.email && (\n <div className=\"formGroup\">\n <label>\n <span className=\"visuallyHidden\">Enter your email</span>\n <input\n className=\"formControl\"\n type=\"email\"\n name=\"email\"\n value={email}\n placeholder=\"Email\"\n autocapitalize=\"off\"\n required\n oninput={this.handleInput}\n />\n <div className=\"inputFieldIcon inputFieldEmail\" />\n </label>\n </div>\n )}\n {page.password && (\n <div className=\"formGroup\">\n <label>\n <span className=\"visuallyHidden\">Enter your password</span>\n <input\n className=\"formControl\"\n type=\"password\"\n name=\"password\"\n value={password}\n placeholder=\"Password\"\n required\n oninput={this.handleInput}\n />\n <div className=\"inputFieldIcon inputFieldPassword\" />\n </label>\n </div>\n )}\n <Button\n saving={saving}\n text={page.button}\n saving_text={page.button_saving}\n />\n </form>\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/forms/user.js","import { h, Component } from \"preact\";\n\nclass Provider extends Component {\n handleLogin = e => {\n e.preventDefault();\n this.props.onLogin(this.props.provider.toLowerCase());\n };\n\n render() {\n const { provider, label } = this.props;\n\n return (\n <button\n onClick={this.handleLogin}\n className={`provider${provider} btn btnProvider`}\n >\n Continue with {label}\n </button>\n );\n }\n}\n\nexport default class Providers extends Component {\n getLabel(p) {\n const pId = p.toLowerCase();\n if (pId in this.props.labels) {\n return this.props.labels[pId];\n }\n return p;\n }\n\n render() {\n const { providers, onLogin } = this.props;\n\n return (\n <div className=\"providersGroup\">\n <hr className=\"hr\" />\n {providers.map(p => (\n <Provider\n key={p}\n provider={p}\n label={this.getLabel(p)}\n onLogin={onLogin}\n />\n ))}\n </div>\n );\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/forms/providers.js","import { observable, action } from \"mobx\";\n\nconst store = observable({\n user: null,\n recovered_user: null,\n message: null,\n settings: null,\n gotrue: null,\n error: null,\n siteURL: null,\n remember: true,\n saving: false,\n invite_token: null,\n email_change_token: null,\n namePlaceholder: null,\n modal: {\n page: \"login\",\n isOpen: false,\n logo: true\n }\n});\n\nstore.setNamePlaceholder = action(function setNamePlaceholder(namePlaceholder) {\n store.namePlaceholder = namePlaceholder;\n});\n\nstore.startAction = action(function startAction() {\n store.saving = true;\n store.error = null;\n store.message = null;\n});\n\nstore.setError = action(function setError(err) {\n store.saving = false;\n store.error = err;\n});\n\nstore.init = action(function init(gotrue, reloadSettings) {\n if (gotrue) {\n store.gotrue = gotrue;\n store.user = gotrue.currentUser();\n if (store.user) {\n store.modal.page = \"user\";\n }\n }\n if (reloadSettings) {\n store.loadSettings();\n }\n});\n\nstore.loadSettings = action(function loadSettings() {\n if (store.settings) {\n return;\n }\n if (!store.gotrue) {\n return;\n }\n\n store.gotrue\n .settings()\n .then(action(settings => (store.settings = settings)))\n .catch(\n action(err => {\n store.error = new Error(\n `Failed to load settings from ${store.gotrue.api.apiURL}`\n );\n })\n );\n});\n\nstore.setIsLocal = action(function setIsLocal(isLocal) {\n store.isLocal = isLocal;\n});\n\nstore.setSiteURL = action(function setSiteURL(url) {\n store.siteURL = url;\n});\n\nstore.clearSiteURL = action(function clearSiteURL() {\n store.gotrue = null;\n store.siteURL = null;\n store.settings = null;\n});\n\nstore.login = action(function login(email, password) {\n store.startAction();\n return store.gotrue\n .login(email, password, store.remember)\n .then(\n action(user => {\n store.user = user;\n store.modal.page = \"user\";\n store.invite_token = null;\n if (store.email_change_token) {\n store.doEmailChange();\n }\n store.saving = false;\n })\n )\n .catch(store.setError);\n});\n\nstore.externalLogin = action(function externalLogin(provider) {\n // store.startAction();\n store.error = null;\n store.message = null;\n const url = store.invite_token\n ? store.gotrue.acceptInviteExternalUrl(provider, store.invite_token)\n : store.gotrue.loginExternalUrl(provider);\n window.location.href = url;\n});\n\nstore.completeExternalLogin = action(function completeExternalLogin(params) {\n store.startAction();\n store.gotrue\n .createUser(params, store.remember)\n .then(user => {\n store.user = user;\n store.modal.page = \"user\";\n store.saving = false;\n })\n .catch(store.setError);\n});\n\nstore.signup = action(function signup(name, email, password) {\n store.startAction();\n return store.gotrue\n .signup(email, password, { full_name: name })\n .then(\n action(() => {\n if (store.settings.autoconfirm) {\n store.login(email, password, store.remember);\n } else {\n store.message = \"confirm\";\n }\n store.saving = false;\n })\n )\n .catch(store.setError);\n});\n\nstore.logout = action(function logout() {\n if (store.user) {\n store.startAction();\n return store.user\n .logout()\n .then(\n action(() => {\n store.user = null;\n store.modal.page = \"login\";\n store.saving = false;\n })\n )\n .catch(store.setError);\n } else {\n store.modal.page = \"login\";\n store.saving = false;\n }\n});\n\nstore.updatePassword = action(function updatePassword(password) {\n store.startAction();\n const user = store.recovered_user || store.user;\n user\n .update({ password })\n .then(user => {\n store.user = user;\n store.recovered_user = null;\n store.modal.page = \"user\";\n store.saving = false;\n })\n .catch(store.setError);\n});\n\nstore.acceptInvite = action(function acceptInvite(password) {\n store.startAction();\n store.gotrue\n .acceptInvite(store.invite_token, password, store.remember)\n .then(user => {\n store.saving = false;\n store.invite_token = null;\n store.user = user;\n store.modal.page = \"user\";\n })\n .catch(store.setError);\n});\n\nstore.doEmailChange = action(function doEmailChange() {\n store.startAction();\n return store.user\n .update({ email_change_token: store.email_change_token })\n .then(\n action(user => {\n store.user = user;\n store.email_change_token = null;\n store.message = \"email_changed\";\n store.saving = false;\n })\n )\n .catch(store.setError);\n});\n\nstore.verifyToken = action(function verifyToken(type, token) {\n const gotrue = store.gotrue;\n store.modal.isOpen = true;\n\n switch (type) {\n case \"confirmation\":\n store.startAction();\n store.modal.page = \"signup\";\n gotrue\n .confirm(token, store.remember)\n .then(\n action(user => {\n store.user = user;\n store.saving = false;\n })\n )\n .catch(\n action(err => {\n console.error(err);\n store.message = \"verfication_error\";\n store.modal.page = \"signup\";\n store.saving = false;\n })\n );\n break;\n case \"email_change\":\n store.email_change_token = token;\n store.modal.page = \"message\";\n if (store.user) {\n store.doEmailChange();\n } else {\n store.modal.page = \"login\";\n }\n break;\n case \"invite\":\n store.modal.page = type;\n store.invite_token = token;\n break;\n case \"recovery\":\n store.startAction();\n store.modal.page = type;\n store.gotrue\n .recover(token, store.remember)\n .then(user => {\n store.saving = false;\n store.recovered_user = user;\n })\n .catch(err => {\n store.saving = false;\n store.error = err;\n store.modal.page = \"login\";\n });\n break;\n default:\n store.error = \"Unkown token type\";\n }\n});\n\nstore.requestPasswordRecovery = action(function requestPasswordRecovery(email) {\n store.startAction();\n store.gotrue\n .requestPasswordRecovery(email)\n .then(\n action(() => {\n store.message = \"password_mail\";\n store.saving = false;\n })\n )\n .catch(store.setError);\n});\n\nstore.openModal = action(function open(page) {\n store.modal.page = page;\n store.modal.isOpen = true;\n});\n\nstore.closeModal = action(function close() {\n store.modal.isOpen = false;\n store.error = null;\n store.message = null;\n store.saving = false;\n});\n\nexport default store;\n\n\n\n// WEBPACK FOOTER //\n// ./state/store.js","import { h, Component } from \"preact\";\nimport { connect } from \"mobx-preact\";\n\n@connect([\"store\"])\nclass Controls extends Component {\n handleSignup = e => {\n e.preventDefault();\n this.props.store.openModal(\"signup\");\n };\n\n handleLogin = e => {\n e.preventDefault();\n this.props.store.openModal(\"login\");\n };\n\n handleLogout = e => {\n e.preventDefault();\n this.props.store.openModal(\"user\");\n };\n\n handleButton = e => {\n e.preventDefault();\n this.props.store.openModal(this.props.store.user ? \"user\" : \"login\");\n };\n\n render() {\n const { user } = this.props.store;\n\n if (this.props.mode === \"button\") {\n return (\n <a\n className=\"netlify-identity-button\"\n href=\"#\"\n onClick={this.handleButton}\n >\n {this.props.text || (user ? \"Log out\" : \"Log in\")}\n </a>\n );\n }\n\n if (user) {\n return (\n <ul className=\"netlify-identity-menu\">\n <li className=\"netlify-identity-item netlify-identity-user-details\">\n Logged in as{\" \"}\n <span className=\"netlify-identity-user\">\n {user.user_metadata.name || user.email}\n </span>\n </li>\n <li className=\"netlify-identity-item\">\n <a\n className=\"netlify-identity-logout\"\n href=\"#\"\n onClick={this.handleLogout}\n >\n Log out\n </a>\n </li>\n </ul>\n );\n }\n\n return (\n <ul className=\"netlify-identity-menu\">\n <li className=\"netlify-identity-item\">\n <a\n className=\"netlify-identity-signup\"\n href=\"#\"\n onClick={this.handleSignup}\n >\n Sign up\n </a>\n </li>\n <li className=\"netlify-identity-item\">\n <a\n className=\"netlify-identity-login\"\n href=\"#\"\n onClick={this.handleLogin}\n >\n Log in\n </a>\n </li>\n </ul>\n );\n }\n}\n\nexport default Controls;\n\n\n\n// WEBPACK FOOTER //\n// ./components/controls.js","exports = module.exports = require(\"../../node_modules/css-loader/lib/css-base.js\")(false);\n// imports\n\n\n// module\nexports.push([module.id, \"::-webkit-input-placeholder {\\n /* Chrome/Opera/Safari */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n::-moz-placeholder {\\n /* Firefox 19+ */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n:-ms-input-placeholder {\\n /* IE 10+ */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n:-moz-placeholder {\\n /* Firefox 18- */\\n color: #a3a9ac;\\n font-weight: 500;\\n}\\n\\n.modalContainer {\\n position: absolute;\\n top: 0;\\n left: 0;\\n width: 100%;\\n min-height: 100%;\\n overflow-x: hidden;\\n overflow-y: auto;\\n -webkit-box-sizing: border-box;\\n box-sizing: border-box;\\n font-family: -apple-system, BlinkMacSystemFont, \\\"Segoe UI\\\", Roboto, Helvetica,\\n Arial, sans-serif, \\\"Apple Color Emoji\\\", \\\"Segoe UI Emoji\\\", \\\"Segoe UI Symbol\\\";\\n font-size: 14px;\\n line-height: 1.5;\\n display: -webkit-box;\\n display: -ms-flexbox;\\n display: flex;\\n -webkit-box-orient: vertical;\\n -webkit-box-direction: normal;\\n -ms-flex-direction: column;\\n flex-direction: column;\\n -webkit-box-align: center;\\n -ms-flex-align: center;\\n align-items: center;\\n z-index: 99999;\\n}\\n\\n.modalContainer::before {\\n content: \\\"\\\";\\n display: block;\\n position: fixed;\\n top: 0;\\n bottom: 0;\\n left: 0;\\n right: 0;\\n background-color: #fff;\\n z-index: -1;\\n}\\n\\n.modalDialog {\\n -webkit-box-flex: 1;\\n -ms-flex-positive: 1;\\n flex-grow: 1;\\n display: -webkit-box;\\n display: -ms-flexbox;\\n display: flex;\\n -webkit-box-orient: vertical;\\n -webkit-box-direction: normal;\\n -ms-flex-direction: column;\\n flex-direction: column;\\n width: 100%;\\n}\\n\\n.modalContent {\\n position: relative;\\n padding: 32px;\\n opacity: 0;\\n -webkit-transform: translateY(10px) scale(1);\\n transform: translateY(10px) scale(1);\\n background: #fff;\\n}\\n\\n[aria-hidden=\\\"false\\\"] .modalContent {\\n -webkit-animation: bouncyEntrance 0.2s cubic-bezier(0.18, 0.89, 0.32, 1.28);\\n animation: bouncyEntrance 0.2s cubic-bezier(0.18, 0.89, 0.32, 1.28);\\n -webkit-animation-fill-mode: forwards;\\n animation-fill-mode: forwards;\\n }\\n\\n@-webkit-keyframes bouncyEntrance {\\n 0% {\\n opacity: 0;\\n -webkit-transform: translateY(10px) scale(0.9);\\n transform: translateY(10px) scale(0.9);\\n }\\n\\n 100% {\\n opacity: 1;\\n -webkit-transform: translateY(0) scale(1);\\n transform: translateY(0) scale(1);\\n }\\n}\\n\\n@keyframes bouncyEntrance {\\n 0% {\\n opacity: 0;\\n -webkit-transform: translateY(10px) scale(0.9);\\n transform: translateY(10px) scale(0.9);\\n }\\n\\n 100% {\\n opacity: 1;\\n -webkit-transform: translateY(0) scale(1);\\n transform: translateY(0) scale(1);\\n }\\n}\\n\\n@media (min-width: 480px) {\\n .modalContainer::before {\\n background-color: rgb(14, 30, 37);\\n -webkit-animation: fadeIn 0.1s ease-in;\\n animation: fadeIn 0.1s ease-in;\\n -webkit-animation-fill-mode: forwards;\\n animation-fill-mode: forwards;\\n }\\n\\n .modalDialog {\\n max-width: 364px;\\n -webkit-box-pack: center;\\n -ms-flex-pack: center;\\n justify-content: center;\\n }\\n\\n .modalContent {\\n background: #fff;\\n -webkit-box-shadow: 0 4px 12px 0 rgba(0, 0, 0, .07),\\n 0 12px 32px 0 rgba(14, 30, 37, .1);\\n box-shadow: 0 4px 12px 0 rgba(0, 0, 0, .07),\\n 0 12px 32px 0 rgba(14, 30, 37, .1);\\n border-radius: 8px;\\n margin-top: 32px;\\n }\\n}\\n\\n@-webkit-keyframes fadeIn {\\n 0% {\\n opacity: 0;\\n }\\n\\n 100% {\\n opacity: 0.67;\\n }\\n}\\n\\n@keyframes fadeIn {\\n 0% {\\n opacity: 0;\\n }\\n\\n 100% {\\n opacity: 0.67;\\n }\\n}\\n\\n.flashMessage {\\n text-align: center;\\n color: rgb(14, 30, 37);\\n font-weight: 500;\\n font-size: 14px;\\n background-color: #f2f3f3;\\n padding: 6px;\\n border-radius: 4px;\\n opacity: 0.7;\\n -webkit-transition: opacity 0.2s linear;\\n transition: opacity 0.2s linear;\\n}\\n\\n.flashMessage:hover,\\n.flashMessage:focus {\\n opacity: 1;\\n}\\n\\n.error {\\n color: #fa3946;\\n background-color: #fceef0;\\n opacity: 1;\\n}\\n\\n.error span::before {\\n content: \\\"\\\";\\n display: inline-block;\\n position: relative;\\n top: 3px;\\n margin-right: 4px;\\n width: 16px;\\n height: 16px;\\n background: no-repeat center center;\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgdmlld0JveD0iMCAwIDE2IDE2Ij4KICA8cGF0aCBmaWxsPSIjRkEzOTQ2IiBkPSJNOCwxLjMzMzMzMzMzIEMxMS42NzYsMS4zMzMzMzMzMyAxNC42NjY2NjY3LDQuMzI0IDE0LjY2NjY2NjcsOCBDMTQuNjY2NjY2NywxMS42NzYgMTEuNjc2LDE0LjY2NjY2NjcgOCwxNC42NjY2NjY3IEM0LjMyNCwxNC42NjY2NjY3IDEuMzMzMzMzMzMsMTEuNjc2IDEuMzMzMzMzMzMsOCBDMS4zMzMzMzMzMyw0LjMyNCA0LjMyNCwxLjMzMzMzMzMzIDgsMS4zMzMzMzMzMyBaIE04LDAgQzMuNTgyLDAgMCwzLjU4MiAwLDggQzAsMTIuNDE4IDMuNTgyLDE2IDgsMTYgQzEyLjQxOCwxNiAxNiwxMi40MTggMTYsOCBDMTYsMy41ODIgMTIuNDE4LDAgOCwwIFogTTcuMTI2NjY2NjcsNS4wMTczMzMzMyBDNy4wNjA2NjY2Nyw0LjQ3OTMzMzMzIDcuNDc4NjY2NjcsNCA4LjAyNTMzMzMzLDQgQzguNTM5MzMzMzMsNCA4Ljk0MzMzMzMzLDQuNDUwNjY2NjcgOC44Nzg2NjY2Nyw0Ljk2NzMzMzMzIEw4LjM3NCw5LjAwMjY2NjY3IEM4LjM1MDY2NjY3LDkuMTkxMzMzMzMgOC4xOSw5LjMzMzMzMzMzIDgsOS4zMzMzMzMzMyBDNy44MSw5LjMzMzMzMzMzIDcuNjQ5MzMzMzMsOS4xOTEzMzMzMyA3LjYyNTMzMzMzLDkuMDAyNjY2NjcgTDcuMTI2NjY2NjcsNS4wMTczMzMzMyBMNy4xMjY2NjY2Nyw1LjAxNzMzMzMzIFogTTgsMTIuMTY2NjY2NyBDNy41NCwxMi4xNjY2NjY3IDcuMTY2NjY2NjcsMTEuNzkzMzMzMyA3LjE2NjY2NjY3LDExLjMzMzMzMzMgQzcuMTY2NjY2NjcsMTAuODczMzMzMyA3LjU0LDEwLjUgOCwxMC41IEM4LjQ2LDEwLjUgOC44MzMzMzMzMywxMC44NzMzMzMzIDguODMzMzMzMzMsMTEuMzMzMzMzMyBDOC44MzMzMzMzMywxMS43OTMzMzMzIDguNDYsMTIuMTY2NjY2NyA4LDEyLjE2NjY2NjcgWiIvPgo8L3N2Zz4K);\\n}\\n\\n.success {\\n}\\n\\n.disabled {\\n opacity: 0.38;\\n pointer-events: none;\\n}\\n\\n.infoText {\\n text-align: center;\\n margin: 32px 0;\\n}\\n\\n.infoTextEmail {\\n font-size: 16px;\\n font-weight: 500;\\n}\\n\\n.saving {\\n background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABQCAMAAACeYYN3AAAAxlBMVEUAAAD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////DTx3aAAAAQnRSTlMAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEGgjKRfAAACk0lEQVR4AYXQDXP5WhAG8CUhiSQqSv4RRRMVL1Fa1VZf3PL9v9Tde9wc9M8+P8/M7s6czJiHgNIvVCJO6YiAMlAiWckASiQrm4bJMZTDrmbBIEC9qpgVjp6n4B+oyEwCzKrMQBVaQIlkpmXZln1dhQB+49gOh5dLexlV6MhsAqyazEQVugCqsOK5nsQmwPWZ53ucvyczSGb4l9T9OsdnLgFOXVZFFd4AqEKrIasR4AdBI2hw1GR6VzMwSWY2A60ZNDl6KnUC3KbMRhXeAqhCpyXzCAjarNVucdqXVEhWaRfCdsj5vQcE1EOZQ7Jy+EcUlklWi2Q3BLQ6nagTcTra2Y0qrHZirRN3OOezTUAjvq4bd7suqpDfSGJUoXcnCwiIerIqqlC96vf6HD1ZsUcE3PYH/QGnrx3uYnqoQn4l6aMK/XtZi4BuIrNIZqVJkiapkhx37Y6AcDgcpsNU44Nz3OuoQn4jSVGFNw+ykID+SGaTzM5G2YiTFVM73AMConE2zjhj7XAXs4EqHE/4d12GKgwmsoiAZCpzSObMptPZdHZVSkCc5/ksnym8cPRUmiQzpvNcmedzTl4o7qlBsuZc1iVg9ChDFdYWshEBveV/FssFZ/l7Z7eowsfl0/JJ4UXj43A/ogpbT7IeAZNnWQ1VuJJNCBi8HKxeVhw9tRaq8JkfrV/WHDULxb1CFbbX7HX9yllfck9A/ipzSea+yeYEJO+yEFX4tim8b94VXjj/zzdU4Z/NmY/NB+fkTglYfMg8knmfsiUBD1+yCFX4+X309f3FOds/UYVR8fH2e6vwovExIuB5K/NJ5v8jWxGQ/chiVOF2d+pn98M5zt3WJFm83+/2O4UXjprabkzAWn+o56k9qvBfX4hMaM+SxOMAAAAASUVORK5CYII=);\\n background-repeat: repeat-x;\\n background-size: contain;\\n background-origin: border-box;\\n background-position: 0% 0%;\\n -webkit-animation: loading 20s linear infinite;\\n animation: loading 20s linear infinite;\\n pointer-events: none;\\n}\\n\\n.saving::after {\\n content: \\\"\\\\2026\\\";\\n}\\n\\n@-webkit-keyframes loading {\\n 0% {\\n background-position: 0% 0%;\\n }\\n\\n 100% {\\n background-position: 700% 0%;\\n }\\n}\\n\\n@keyframes loading {\\n 0% {\\n background-position: 0% 0%;\\n }\\n\\n 100% {\\n background-position: 700% 0%;\\n }\\n}\\n\\n.btn {\\n display: block;\\n position: relative;\\n width: 100%;\\n height: auto;\\n margin: 14px 0 0;\\n padding: 6px;\\n outline: 0;\\n cursor: pointer;\\n border: 2px solid rgb(14, 30, 37);\\n border-radius: 4px;\\n background-color: #2d3b41;\\n color: #fff;\\n -webkit-transition: background-color 0.2s ease;\\n transition: background-color 0.2s ease;\\n font-family: -apple-system, BlinkMacSystemFont, \\\"Segoe UI\\\", Roboto, Helvetica,\\n Arial, sans-serif, \\\"Apple Color Emoji\\\", \\\"Segoe UI Emoji\\\", \\\"Segoe UI Symbol\\\";\\n font-size: 14px;\\n font-weight: 500;\\n line-height: 24px;\\n text-align: center;\\n text-decoration: none;\\n white-space: nowrap;\\n}\\n\\n.btn:hover,\\n.btn:focus {\\n background-color: rgb(14, 30, 37);\\n text-decoration: none;\\n}\\n\\n.btnClose {\\n position: absolute;\\n top: 0;\\n right: 0;\\n margin: 0;\\n padding: 0;\\n border: 0;\\n width: 24px;\\n height: 24px;\\n border-radius: 50%;\\n margin: 6px;\\n background: #fff;\\n color: #a3a9ac;\\n}\\n\\n.btnClose::before {\\n content: \\\"\\\\D7\\\";\\n font-size: 25px;\\n line-height: 9px;\\n}\\n\\n.btnClose:hover,\\n.btnClose:focus {\\n background: #e9ebeb;\\n color: rgb(14, 30, 37);\\n}\\n\\n.header {\\n display: -webkit-box;\\n display: -ms-flexbox;\\n display: flex;\\n margin-top: -8px;\\n margin-bottom: 32px;\\n}\\n\\n.btnHeader {\\n font-size: 16px;\\n line-height: 24px;\\n background: #fff;\\n color: #a3a9ac;\\n border: 0;\\n border-bottom: 2px solid #e9ebeb;\\n border-radius: 4px 4px 0 0;\\n margin: 0;\\n}\\n\\n.btnHeader:focus,\\n.btnHeader.active {\\n background: #fff;\\n color: rgb(14, 30, 37);\\n border-color: rgb(14, 30, 37);\\n font-weight: 700;\\n}\\n\\n.btnHeader:not(:only-child):hover {\\n background-color: #e9ebeb;\\n color: rgb(14, 30, 37);\\n}\\n\\n.btnHeader:only-child {\\n cursor: auto;\\n}\\n\\n.btnLink {\\n display: block;\\n position: relative;\\n width: auto;\\n height: auto;\\n margin: 14px auto 0;\\n padding: 6px;\\n padding-bottom: 0;\\n outline: 0;\\n cursor: pointer;\\n color: rgb(14, 30, 37);\\n border: none;\\n border-bottom: 2px solid #e9ebeb;\\n border-radius: 0;\\n background-color: inherit;\\n -webkit-transition: border-color 0.2s ease;\\n transition: border-color 0.2s ease;\\n font-family: -apple-system, BlinkMacSystemFont, \\\"Segoe UI\\\", Roboto, Helvetica,\\n Arial, sans-serif, \\\"Apple Color Emoji\\\", \\\"Segoe UI Emoji\\\", \\\"Segoe UI Symbol\\\";\\n font-size: 14px;\\n font-weight: 500;\\n line-height: 24px;\\n text-align: center;\\n white-space: nowrap;\\n}\\n\\n.btnLink:hover,\\n.btnLink:focus {\\n background-color: inherit;\\n border-color: #a3a9ac;\\n}\\n\\n.form {\\n}\\n\\n.formGroup {\\n position: relative;\\n margin-top: 14px;\\n}\\n\\n.formControl {\\n -webkit-box-sizing: border-box;\\n box-sizing: border-box;\\n display: block;\\n width: 100%;\\n height: 40px;\\n margin: 0;\\n padding: 6px 12px 6px 34px;\\n border: 2px solid #e9ebeb;\\n border-radius: 4px;\\n background: #fff;\\n color: rgb(14, 30, 37);\\n -webkit-box-shadow: none;\\n box-shadow: none;\\n font-size: 14px;\\n font-weight: 500;\\n line-height: 24px;\\n -webkit-transition: -webkit-box-shadow ease-in-out 0.15s;\\n transition: -webkit-box-shadow ease-in-out 0.15s;\\n transition: box-shadow ease-in-out 0.15s;\\n transition: box-shadow ease-in-out 0.15s, -webkit-box-shadow ease-in-out 0.15s;\\n -webkit-appearance: none;\\n -moz-appearance: none;\\n}\\n\\n.inputFieldIcon {\\n position: absolute;\\n top: 12px;\\n left: 12px;\\n display: inline-block;\\n width: 16px;\\n height: 16px;\\n background-repeat: no-repeat;\\n background-position: center;\\n pointer-events: none;\\n}\\n\\n.inputFieldName {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMCAwIDE0IDE0Ij4gIDxwYXRoIGZpbGw9IiNBM0E5QUMiIGZpbGwtcnVsZT0iZXZlbm9kZCIgZD0iTTgsNyBDNi4zNDMxNDU3NSw3IDUsNS42NTY4NTQyNSA1LDQgQzUsMi4zNDMxNDU3NSA2LjM0MzE0NTc1LDEgOCwxIEM5LjY1Njg1NDI1LDEgMTEsMi4zNDMxNDU3NSAxMSw0IEMxMSw1LjY1Njg1NDI1IDkuNjU2ODU0MjUsNyA4LDcgWiBNOCwxNSBMMS41LDE1IEMxLjUsMTEuMTM0MDA2OCA0LjQxMDE0OTEzLDggOCw4IEMxMS41ODk4NTA5LDggMTQuNSwxMS4xMzQwMDY4IDE0LjUsMTUgTDgsMTUgWiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEgLTEpIi8+PC9zdmc+);\\n}\\n\\n.inputFieldEmail {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxMSIgdmlld0JveD0iMCAwIDE2IDExIj4gIDxwYXRoIGZpbGw9IiNBM0E5QUMiIGQ9Ik0xLjE3MDczMTcxLDMgQzAuNTIyMTQ2MzQxLDMgMy45MDI0NTk4N2UtMDgsMy41NDUxMTA4MSAzLjkwMjQ1OTg3ZS0wOCw0LjIyMjIyMTU0IEwzLjkwMjQ1OTg3ZS0wOCwxMi43Nzc3Nzg1IEMzLjkwMjQ1OTg3ZS0wOCwxMy40NTQ4ODkyIDAuNTIyMTQ2MzQxLDE0IDEuMTcwNzMxNzEsMTQgTDE0LjgyOTI2ODMsMTQgQzE1LjQ3Nzg1MzcsMTQgMTYsMTMuNDU0ODg5MiAxNiwxMi43Nzc3Nzg1IEwxNiw0LjIyMjIyMTU0IEMxNiwzLjU0NTExMDgxIDE1LjQ3Nzg1MzcsMyAxNC44MjkyNjgzLDMgTDEuMTcwNzMxNzEsMyBaIE0yLjMzNzQyMTE5LDUuMDAxODY1NjYgQzIuNDU3NTExNzUsNC45ODk1NTIxNCAyLjU2MDcxNDU3LDUuMDM5MzM5OCAyLjYzNjM1OTg1LDUuMTE3Mjg0MzcgTDcuNDgyNjA2MTcsMTAuMTEzMjU0NSBDNy43ODQ0ODgyMiwxMC40MjQ3NDU1IDguMjAzMjc4MjksMTAuNDI0NzY2IDguNTA1ODk2MTksMTAuMTEzMjU0NSBMMTMuMzYzNjQwMiw1LjExNzI4NDM3IEMxMy41MDUxMjU1LDQuOTcxMjA0OTkgMTMuNzUyOTc3OSw0Ljk4MTg5NzIzIDEzLjg4MzkyMjIsNS4xMzk3MzYwMiBDMTQuMDE0ODY2NSw1LjI5NzU3NDgxIDE0LjAwNTI4MjEsNS41NzQwNzQ4OCAxMy44NjM3OTY3LDUuNzIwMTU0MjYgTDExLjExNTg2MDYsOC41NDg0MTE1MiBMMTMuODU4MDU3MSwxMS4yNjc2NDY5IEMxNC4wMjE3ODM1LDExLjQwMzE5ODIgMTQuMDQ4OTM2MywxMS43MDE0OTMyIDEzLjkxMjk4ODIsMTEuODcwOTg4OCBDMTMuNzc3MDQwMSwxMi4wNDA1MDQ5IDEzLjUwODI4OTcsMTIuMDQzNDE5MSAxMy4zNjkzOTgyLDExLjg3Njk0MDQgTDEwLjU3NTQ3MTUsOS4xMDYzOTg2MiBMOS4wMDYwNTI3NSwxMC43MTYxMjQ0IEM4LjQzNDk0MTk1LDExLjMwNDAzMzQgNy41NTMzMDI4NiwxMS4zMDUxNjIxIDYuOTgyNDY4LDEwLjcxNjEyNDQgTDUuNDI0NTI4NSw5LjEwNjM5ODYyIEwyLjYzMDYwMTgzLDExLjg3Njk0MDQgQzIuNDkxNzEwMzMsMTIuMDQzNDM5NyAyLjIyMjk1OTg4LDEyLjA0MDUyNTUgMi4wODcwMTE3OCwxMS44NzA5ODg4IEMxLjk1MTA2MzY3LDExLjcwMTQ5MzIgMS45NzgyMTY1LDExLjQwMzE5ODIgMi4xNDE5NDI5LDExLjI2NzY0NjkgTDQuODg0MTM5MzksOC41NDg0MTE1MiBMMi4xMzYyMDMyOCw1LjcyMDE1NDI2IEMyLjAyODcxNDE0LDUuNjE2MjI4MTYgMS45ODM1NTE0MSw1LjQzODk1NDUzIDIuMDI1OTkxNSw1LjI4NzQ5ODI1IEMyLjA2ODQxMzE5LDUuMTM2MDYyNDkgMi4xOTYwMjc4MSw1LjAxOTAyMjQ5IDIuMzM3NDIxMTksNS4wMDE4NjU2NiBaIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0zKSIvPjwvc3ZnPg==);\\n}\\n\\n.inputFieldPassword {\\n background-image: url(data:image/svg+xml;base64,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);\\n}\\n\\n.inputFieldUrl {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMCAwIDE0IDE0Ij4gIDxwYXRoIGZpbGw9IiNBM0E5QUMiIGQ9Ik0xMCw1IEMxMCwzLjg5NTQzMDUgOS4xMDQ1Njk1LDMgOCwzIEM2Ljg5NTQzMDUsMyA2LDMuODk1NDMwNSA2LDUgTTQsMTAgTDQsMTEgTDYsMTEgTDYsMTAgQzYsOS40NDc3MTUyNSA1LjU1MjI4NDc1LDkgNSw5IEM0LjQ0NzcxNTI1LDkgNCw5LjQ0NzcxNTI1IDQsMTAgWiBNMTIsMTAgQzEyLDkuNDQ3NzE1MjUgMTEuNTUyMjg0Nyw5IDExLDkgQzEwLjQ0NzcxNTMsOSAxMCw5LjQ0NzcxNTI1IDEwLDEwIEwxMCwxMSBMMTIsMTEgTDEyLDEwIFogTTYsNiBMNiw1IEw0LDUgTDQsNiBDNCw2LjU1MjI4NDc1IDQuNDQ3NzE1MjUsNyA1LDcgQzUuNTUyMjg0NzUsNyA2LDYuNTUyMjg0NzUgNiw2IFogTTEwLDYgQzEwLDYuNTUyMjg0NzUgMTAuNDQ3NzE1Myw3IDExLDcgQzExLjU1MjI4NDcsNyAxMiw2LjU1MjI4NDc1IDEyLDYgTDEyLDUgTDEwLDUgTDEwLDYgWiBNNCw1IEM0LDIuNzkwODYxIDUuNzkwODYxLDEgOCwxIEMxMC4yMDkxMzksMSAxMiwyLjc5MDg2MSAxMiw1IEw0LDUgWiBNNCwxMSBMMTIsMTEgQzEyLDEzLjIwOTEzOSAxMC4yMDkxMzksMTUgOCwxNSBDNS43OTA4NjEsMTUgNCwxMy4yMDkxMzkgNCwxMSBaIE0xMCwxMSBMNiwxMSBDNiwxMi4xMDQ1Njk1IDYuODk1NDMwNSwxMyA4LDEzIEM5LjEwNDU2OTUsMTMgMTAsMTIuMTA0NTY5NSAxMCwxMSBaIE04LDExIEM3LjQ0NzcxNTI1LDExIDcsMTAuNTUyMjg0NyA3LDEwIEw3LDYgQzcsNS40NDc3MTUyNSA3LjQ0NzcxNTI1LDUgOCw1IEM4LjU1MjI4NDc1LDUgOSw1LjQ0NzcxNTI1IDksNiBMOSwxMCBDOSwxMC41NTIyODQ3IDguNTUyMjg0NzUsMTEgOCwxMSBaIiB0cmFuc2Zvcm09InJvdGF0ZSg0NSA4LjcwNyA2LjI5MykiLz48L3N2Zz4=);\\n}\\n\\n.formLabel {\\n}\\n\\n.hr {\\n border: 0;\\n border-top: 2px solid #e9ebeb;\\n margin: 32px 0 -1px;\\n text-align: center;\\n overflow: visible;\\n}\\n\\n.hr::before {\\n content: \\\"or\\\";\\n position: relative;\\n display: inline-block;\\n font-size: 12px;\\n font-weight: 800;\\n line-height: 1;\\n text-transform: uppercase;\\n background-color: #fff;\\n color: rgb(14, 30, 37);\\n padding: 4px;\\n top: -11px;\\n}\\n\\n.btnProvider {\\n padding-left: 40px;\\n padding-right: 40px;\\n}\\n\\n.btnProvider::before {\\n content: \\\"\\\";\\n position: absolute;\\n display: inline-block;\\n vertical-align: middle;\\n width: 32px;\\n height: 40px;\\n background-repeat: no-repeat;\\n background-position: left center;\\n top: -2px;\\n left: 14px;\\n}\\n\\n.providerGoogle {\\n background-color: #4285f4;\\n border-color: #366dc7;\\n}\\n\\n.providerGoogle:hover,\\n.providerGoogle:focus {\\n background-color: #366dc7;\\n}\\n\\n.providerGitHub {\\n background-color: #333;\\n border-color: #000;\\n}\\n\\n.providerGitHub:hover,\\n.providerGitHub:focus {\\n background-color: #000;\\n}\\n\\n.providerGitLab {\\n background-color: #e24329;\\n border-color: #b03320;\\n}\\n\\n.providerGitLab:hover,\\n.providerGitLab:focus {\\n background-color: #b03320;\\n}\\n\\n.providerBitbucket {\\n background-color: #205081;\\n border-color: #14314f;\\n}\\n\\n.providerBitbucket:hover,\\n.providerBitbucket:focus {\\n background-color: #14314f;\\n}\\n\\n.providerGoogle:before {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMyIgaGVpZ2h0PSIxMiIgdmlld0JveD0iMCAwIDEzIDEyIj4gIDxnIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEuNDg4IC0yKSI+ICAgIDxyZWN0IHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIvPiAgICA8cGF0aCBmaWxsPSIjRkZGRkZGIiBmaWxsLXJ1bGU9Im5vbnplcm8iIGQ9Ik0wLjY1MjczNDM3NSwzLjI5NTI4MjQ0IEMwLjIzNzk4NDM3NSw0LjEwNTgzMjA2IDIuODQyMTcwOTRlLTE0LDUuMDE2MDQ1OCAyLjg0MjE3MDk0ZS0xNCw1Ljk3OTM4OTMxIEMyLjg0MjE3MDk0ZS0xNCw2Ljk0MjczMjgyIDAuMjM3OTg0Mzc1LDcuODUyOTAwNzYgMC42NTI3MzQzNzUsOC42NjM0NTAzOCBDMS42NTkwNDY4NywxMC42MTY3MDIzIDMuNzI2MDkzNzUsMTEuOTU4Nzc4NiA2LjExOTUzMTI1LDExLjk1ODc3ODYgQzcuNzcxNzgxMjUsMTEuOTU4Nzc4NiA5LjE1ODg1OTM3LDExLjQyNzI1MTkgMTAuMTcyMDE1NiwxMC41MTA0NDI3IEMxMS4zMjc5MDYyLDkuNDY3MzU4NzggMTEuOTk0MjgxMiw3LjkzMjY0MTIyIDExLjk5NDI4MTIsNi4xMTIyNTk1NCBDMTEuOTk0MjgxMiw1LjYyMDYyNTk1IDExLjk1MzQ1MzEsNS4yNjE4NjI2IDExLjg2NTA5MzcsNC44ODk4MTY3OSBMNi4xMTk1MzEyNSw0Ljg4OTgxNjc5IEw2LjExOTUzMTI1LDcuMTA4ODA5MTYgTDkuNDkyMDQ2ODcsNy4xMDg4MDkxNiBDOS40MjQwNzgxMiw3LjY2MDI1OTU0IDkuMDU2OTA2MjUsOC40OTA3MzI4MiA4LjI0MDk1MzEyLDkuMDQ4Nzc4NjMgQzcuNzI0MjAzMTIsOS40MDA5MDA3NiA3LjAzMDY0MDYyLDkuNjQ2NzE3NTYgNi4xMTk1MzEyNSw5LjY0NjcxNzU2IEM0LjUwMTI2NTYyLDkuNjQ2NzE3NTYgMy4xMjc3ODEyNSw4LjYwMzY3OTM5IDIuNjM4MTcxODcsNy4xNjE5ODQ3MyBMMi42Mjg3MTIwNSw3LjE2Mjc2OTU5IEMyLjUwNTM0MTU4LDYuNzk3Mjk0NjggMi40MzQyMTg3NSw2LjM4MTEyMjg1IDIuNDM0MjE4NzUsNS45NzkzODkzMSBDMi40MzQyMTg3NSw1LjU2NzQ1MDM4IDIuNTA4OTg0MzgsNS4xNjg4Mzk2OSAyLjYzMTM3NSw0Ljc5Njc5Mzg5IEMzLjEyNzc4MTI1LDMuMzU1MDk5MjQgNC41MDEyNjU2MiwyLjMxMjAxNTI3IDYuMTE5NTMxMjUsMi4zMTIwMTUyNyBDNy4yNjg2MjUsMi4zMTIwMTUyNyA4LjA0Mzc1LDIuNzk3MDA3NjMgOC40ODU3MzQzNywzLjIwMjMwNTM0IEwxMC4yMTI3OTY5LDEuNTU0NjQxMjIgQzkuMTUyMTA5MzcsMC41OTEyOTc3MSA3Ljc3MTc4MTI1LDguODgxNzg0MmUtMTYgNi4xMTk1MzEyNSw4Ljg4MTc4NDJlLTE2IEMzLjcyNjA5Mzc1LDguODgxNzg0MmUtMTYgMS42NTkwNDY4NywxLjM0MjAzMDUzIDAuNjUyNzM0Mzc1LDMuMjk1MjgyNDQgTDAuNjUyNzM0Mzc1LDMuMjk1MjgyNDQgWiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMiAyKSIvPiAgPC9nPjwvc3ZnPg==);\\n}\\n\\n.providerGitHub:before {\\n background-image: url(data:image/svg+xml;base64,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);\\n}\\n\\n.providerGitLab:before {\\n background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxMyIgdmlld0JveD0iMCAwIDE0IDEzIj4gIDxnIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEgLTIpIj4gICAgPHJlY3Qgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+ICAgIDxwYXRoIGZpbGw9IiNGRkZGRkYiIGZpbGwtcnVsZT0ibm9uemVybyIgZD0iTTcuMDA0MDkzMzYsMTIuOTQ5MjQzMyBMNC40MjgwOTMzMyw0Ljk5NzI4MjU0IEw5LjU4MDA5MzM2LDQuOTk3MjgyNTQgTDcuMDA0MDkzMzYsMTIuOTQ5MjQzMyBaIE03LjAwNDA5MzM2LDEyLjk0OTIzIEwwLjgxNzg5MzMzMyw0Ljk5NzI2OTE3IEw0LjQyODA5MzMzLDQuOTk3MjY5MTcgTDcuMDA0MDkzMzYsMTIuOTQ5MjMgWiBNMC44MTc4OTk5OTksNC45OTcyODkyMyBMNy4wMDQwOTk5OCwxMi45NDkyNSBMMC4yMjg4MzMzMzMsOC4wMTE4ODA4IEMwLjA0MTksNy44NzU2NzE1MiAtMC4wMzYzLDcuNjM0MjEyNyAwLjAzNTEsNy40MTM4MTcxMiBMMC44MTc4OTk5OTksNC45OTcyODkyMyBaIE0wLjgxNzg5OTk5OSw0Ljk5NzI5NTkxIEwyLjM2OTM2NjY3LDAuMjA3OTA0NzE0IEMyLjQ0OTE2NjY3LC0wLjAzODUwMjM1ODggMi43OTY3NjY2NywtMC4wMzg1NjkyMjY1IDIuODc2NTY2NjcsMC4yMDc5MDQ3MTQgTDQuNDI4MSw0Ljk5NzI5NTkxIEwwLjgxNzg5OTk5OSw0Ljk5NzI5NTkxIFogTTcuMDA0MDkzMzYsMTIuOTQ5MjMgTDkuNTgwMDkzMzYsNC45OTcyNjkxNyBMMTMuMTkwMjkzMyw0Ljk5NzI2OTE3IEw3LjAwNDA5MzM2LDEyLjk0OTIzIFogTTEzLjE5MDI5MzMsNC45OTcyODkyMyBMMTMuOTczMDkzMyw3LjQxMzgxNzEyIEMxNC4wNDQ0OTMzLDcuNjM0MjEyNyAxMy45NjYyOTM0LDcuODc1NjcxNTIgMTMuNzc5MzYsOC4wMTE4ODA4IEw3LjAwNDA5MzM2LDEyLjk0OTI1IEwxMy4xOTAyOTMzLDQuOTk3Mjg5MjMgWiBNMTMuMTkwMjkzMyw0Ljk5NzI5NTkxIEw5LjU4MDA5MzM2LDQuOTk3Mjk1OTEgTDExLjEzMTYyNjcsMC4yMDc5MDQ3MTQgQzExLjIxMTQyNjcsLTAuMDM4NTY5MjI2NSAxMS41NTkwMjY3LC0wLjAzODUwMjM1ODggMTEuNjM4ODI2NywwLjIwNzkwNDcxNCBMMTMuMTkwMjkzMyw0Ljk5NzI5NTkxIFoiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDEgMikiLz4gIDwvZz48L3N2Zz4=);\\n}\\n\\n.providerBitbucket:before {\\n background-image: url(data:image/svg+xml;base64,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);\\n}\\n\\n.callOut {\\n display: block;\\n padding: 32px;\\n font-size: 14px;\\n font-weight: 500;\\n text-decoration: none;\\n color: #a3a9ac;\\n text-align: center;\\n}\\n\\n.callOut:after {\\n content: \\\" \\\\2665\\\";\\n -webkit-transition: color 4s ease;\\n transition: color 4s ease;\\n}\\n\\n.callOut:hover:after {\\n color: red;\\n}\\n\\n.callOut .netlifyLogo {\\n display: block;\\n margin: auto;\\n width: 32px;\\n height: 32px;\\n margin-bottom: 8px;\\n background-image: url(data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">  <defs>    <radialGradient id="a" cy="0%" r="100%" fx="50%" fy="0%" gradientTransform="matrix(0 1 -1.15185 0 .5 -.5)">      <stop stop-color="#20C6B7" offset="0%"/>      <stop stop-color="#4D9ABF" offset="100%"/>    </radialGradient>  </defs>  <path fill="url(#a)" fill-rule="evenodd" d="M22.980623,11.6262377 C22.8717107,11.5051306 22.7355704,11.3974798 22.5722021,11.3167418 C22.5585881,11.3167418 22.544974,11.2898291 22.53136,11.2763727 L23.1712194,7.36057661 C23.1712194,7.33366392 23.1848334,7.32020758 23.1984475,7.32020758 L23.2120615,7.32020758 C23.2120615,7.32020758 23.2256755,7.32020758 23.2392896,7.33366392 L26.166306,10.2267779 C26.17992,10.2402343 26.17992,10.2536906 26.17992,10.2671469 C26.17992,10.2806033 26.166306,10.2940596 26.1526919,10.307516 L23.0214651,11.639694 L23.007851,11.639694 C22.994237,11.639694 22.994237,11.639694 22.980623,11.6262377 Z M16.3505736,9.4597381 C16.3233453,9.19061274 16.2280463,8.92148738 16.0782906,8.69273083 C16.0646765,8.67927456 16.0646765,8.65236202 16.0782906,8.62544949 L19.359301,3.53898022 C19.359301,3.52552395 19.3729151,3.51206768 19.3865293,3.51206768 C19.4001434,3.51206768 19.4001434,3.51206768 19.4137576,3.52552395 L22.3271858,6.41862155 C22.3408,6.43207782 22.3408,6.44553409 22.3408,6.45899035 L21.5784076,11.1821404 C21.5784076,11.2090529 21.5647934,11.2225092 21.5511793,11.2225092 C21.3741953,11.2763343 21.2108255,11.3570719 21.074684,11.464722 C21.074684,11.4781783 21.0610698,11.4781783 21.0338415,11.4781783 L16.3778019,9.5001069 C16.3641878,9.48665063 16.3505736,9.47319437 16.3505736,9.4597381 Z M26.9831907,11.0207669 L31.9795788,15.972664 C32.0068071,15.9861202 32.0068071,16.0264889 31.9795788,16.0264889 L31.9523505,16.0534014 C31.9523505,16.0668577 31.9387364,16.0668577 31.9115081,16.0668577 L23.5524283,12.527866 C23.5388141,12.527866 23.5252,12.5009535 23.5252,12.4874973 C23.5252,12.474041 23.5388141,12.4605848 23.5524283,12.4471286 L26.9559624,11.0073107 C26.9559624,11.0073107 26.9695765,11.0073107 26.9831907,11.0207669 Z M23.1304363,13.3890881 L31.1491858,16.7800761 C31.1628,16.7935324 31.1628,16.8069887 31.1628,16.820445 C31.1628,16.8339013 31.1628,16.8473576 31.1491858,16.8608139 L26.7109645,21.2610245 C26.7109645,21.2744808 26.6973503,21.2744808 26.670122,21.2744808 L21.8234754,20.2652582 C21.796247,20.2652582 21.7826329,20.2518019 21.7826329,20.2248893 C21.7417903,19.8481128 21.564806,19.5117053 21.2652942,19.2829481 C21.25168,19.2694918 21.25168,19.2560355 21.25168,19.2425792 L22.1093731,13.9811653 C22.1093731,13.9542527 22.1366014,13.9407964 22.1502156,13.9407964 C22.5314125,13.8869712 22.8581527,13.698583 23.0759796,13.4025444 C23.0895937,13.3890881 23.1032079,13.3890881 23.1304363,13.3890881 Z M16.146379,10.4286859 L20.5301317,12.2856532 C20.5437459,12.2991095 20.55736,12.3125658 20.55736,12.3394783 C20.5437459,12.4067598 20.5301317,12.4874975 20.5301317,12.5682352 L20.5301317,12.6355166 L20.5301317,12.6893417 C20.5301317,12.702798 20.5165176,12.7162543 20.5029034,12.7297106 C20.5029034,12.7297106 10.8777072,16.8338775 10.864093,16.8338775 C10.8504789,16.8338775 10.8368647,16.8338775 10.8232506,16.8204212 C10.8096365,16.8069649 10.8096365,16.7800524 10.8232506,16.7665961 L14.4309974,11.1822378 C14.4446116,11.1687815 14.4582257,11.1553253 14.485454,11.1553253 C14.580753,11.1687815 14.6624378,11.1822378 14.7441226,11.1822378 C15.2886882,11.1822378 15.7924113,10.9131121 16.0919224,10.4555984 C16.1055365,10.4421422 16.1191507,10.4286859 16.146379,10.4286859 Z M21.5511429,21.1802433 L25.8123717,22.0549053 C25.8259859,22.0549053 25.8396,22.0683616 25.8396,22.1087307 C25.8396,22.122187 25.8396,22.1356433 25.8259859,22.1490997 L19.9174449,28.0026072 C19.9174449,28.0160636 19.9038307,28.0160636 19.8902166,28.0160636 L19.8629883,28.0160636 C19.8493741,28.0026072 19.83576,27.9891509 19.83576,27.9622382 L20.8568212,21.6915841 C20.8568212,21.6781278 20.8704354,21.6512151 20.8840495,21.6512151 C21.1291042,21.5570208 21.3333165,21.3955447 21.4966863,21.1936996 C21.5103004,21.1936996 21.5239146,21.1802433 21.5511429,21.1802433 Z M19.0461679,20.682403 C19.1550814,21.0995487 19.4545933,21.4628692 19.8630187,21.6243449 C19.8902471,21.6378012 19.8902471,21.6647139 19.8630187,21.6647139 C19.8630187,21.6647139 18.6241283,29.2137054 18.6241283,29.2271617 L18.1884746,29.6577637 C18.1884746,29.6712201 18.1748604,29.6712201 18.1612462,29.6712201 C18.147632,29.6712201 18.147632,29.6712201 18.1340178,29.6577637 L10.9457306,19.2694901 C10.9321165,19.2560338 10.9321165,19.2291212 10.9457306,19.2156649 C10.9865732,19.1618396 11.0138015,19.1080144 11.0546441,19.0407328 C11.0682583,19.0272765 11.0818724,19.0138202 11.1091008,19.0138202 L19.0053254,20.6420341 C19.0325537,20.6554904 19.0461679,20.6689467 19.0461679,20.682403 Z M11.3133647,18.0987286 C11.2861365,18.0987286 11.2725224,18.0852724 11.2725224,18.0583598 C11.2725224,17.9507096 11.2452941,17.8565157 11.23168,17.7488654 C11.23168,17.7219529 11.23168,17.7084966 11.2589082,17.6950403 C11.2589082,17.6950403 20.9385459,13.5639635 20.95216,13.5639635 C20.95216,13.5639635 20.9657741,13.5639635 20.9793882,13.5774197 C21.0474588,13.6447011 21.1019153,13.6850699 21.1563718,13.7254388 C21.1836,13.7254388 21.1836,13.7523513 21.1836,13.7658076 L20.3395247,18.9464741 C20.3395247,18.9733866 20.3259106,18.9868429 20.2986824,18.9868429 C19.8358024,19.0137554 19.4273788,19.282881 19.1959388,19.6865693 C19.1823247,19.7000255 19.1687106,19.7134818 19.1414824,19.7134818 L11.3133647,18.0987286 Z M7.86897758,19.1887291 C7.9098203,19.2560111 7.95066303,19.3098367 7.99150576,19.3636623 C8.00512,19.3771187 8.00512,19.3905751 8.00512,19.3905751 L6.13996879,22.2837007 C6.12635455,22.2971571 6.1127403,22.3106135 6.09912606,22.3106135 C6.09912606,22.3106135 6.08551182,22.3106135 6.07189758,22.2971571 L4.42457424,20.6689329 C4.41096,20.6554765 4.41096,20.6420201 4.41096,20.6285637 C4.41096,20.6151073 4.42457424,20.6016509 4.43818848,20.6016509 L7.81452061,19.1618163 L7.82813485,19.1618163 C7.84174909,19.1618163 7.85536333,19.1752727 7.86897758,19.1887291 Z M10.1833191,19.8615579 C10.1969332,19.8615579 10.2105473,19.8750142 10.2241614,19.8884706 L17.4396294,30.3574878 C17.4532435,30.3709441 17.4532435,30.3978567 17.4396294,30.4113131 L15.8603949,31.9857025 C15.8603949,31.9991589 15.8467808,31.9991589 15.8059386,31.9857025 L6.79341057,23.0641622 C6.77979648,23.0507058 6.77979648,23.0237932 6.80702466,22.9968806 L8.76745371,19.9557522 C8.7810678,19.9422958 8.79468189,19.9288395 8.82191007,19.9288395 C9.02612143,19.9961211 9.2167187,20.0230338 9.42093006,20.0230338 C9.67959778,20.0230338 9.92465141,19.9692085 10.1833191,19.8615579 Z M8.99891856,16.4032322 C8.98530439,16.4032322 8.97169022,16.3897759 8.95807604,16.3763196 L5.09165063,10.7381388 C5.07803646,10.7246825 5.07803646,10.69777 5.09165063,10.6843137 L8.563265,7.23950633 C8.563265,7.22605006 8.57687917,7.22605006 8.60410752,7.22605006 C8.60410752,7.23950633 12.7019739,8.96191002 13.1648558,9.1637542 C13.17847,9.17721048 13.1920842,9.19066676 13.1920842,9.21757932 C13.1648558,9.33868583 13.1512416,9.45979234 13.1512416,9.58089884 C13.1512416,9.99804349 13.3146117,10.3882756 13.6005094,10.6843137 C13.6141235,10.69777 13.6141235,10.7246825 13.6005094,10.7381388 L9.95191074,16.3897759 C9.93829657,16.4032322 9.92468239,16.4166885 9.89745405,16.4166885 C9.74769813,16.3763196 9.58432804,16.3494071 9.43457213,16.3494071 C9.29843039,16.3494071 9.14867448,16.3763196 8.99891856,16.4032322 Z M13.6686019,8.35642034 C13.4916186,8.27568198 9.35293324,6.52635083 9.35293324,6.52635083 C9.33931914,6.51289444 9.32570505,6.51289444 9.33931914,6.48598165 C9.33931914,6.47252526 9.33931914,6.45906886 9.35293324,6.44561247 L15.8332432,0.0134563935 C15.8332432,0 15.8468573,0 15.8604714,0 C15.8740855,0 15.8740855,0 15.8876996,0.0134563935 L18.6785894,2.77201705 C18.6922035,2.78547345 18.6922035,2.81238623 18.6785894,2.82584263 L15.3159076,8.0334669 C15.3022935,8.04692329 15.2886794,8.06037969 15.2614512,8.06037969 C15.0844679,8.00655411 14.9074847,7.97964133 14.7305014,7.97964133 C14.3629208,7.97964133 13.9953402,8.11420526 13.7094442,8.34296395 C13.6958301,8.35642034 13.6958301,8.35642034 13.6686019,8.35642034 Z M7.78728995,17.3317511 C7.77367581,17.3452074 7.76006167,17.3586637 7.74644752,17.3586637 L0.0408424298,15.743908 C0.0136141433,15.743908 0,15.7304517 0,15.7169954 C0,15.7035391 0,15.6900828 0.0136141433,15.6766265 L4.31568342,11.4244363 C4.31568342,11.4109801 4.32929756,11.4109801 4.34291171,11.4109801 C4.37013999,11.4244363 4.37013999,11.4244363 4.38375413,11.4378926 C4.38375413,11.4513489 8.07318696,16.7800429 8.11402939,16.8338681 C8.12764354,16.8473244 8.12764354,16.874237 8.11402939,16.8876933 C7.9915021,17.0222563 7.86897481,17.1702755 7.78728995,17.3317511 Z M7.35155783,18.2467464 C7.37878594,18.2467464 7.3924,18.2602027 7.3924,18.2871151 C7.3924,18.3005713 7.37878594,18.3140275 7.35155783,18.3409399 L3.63492,19.9153165 C3.63492,19.9153165 3.62130594,19.9153165 3.60769188,19.9018603 L0.626213185,16.9414941 C0.612599127,16.9280378 0.598985069,16.9011254 0.612599127,16.8876692 C0.626213185,16.874213 0.639827243,16.8607568 0.667055359,16.8607568 L7.35155783,18.2467464 Z"/></svg>);\\n}\\n\\n.visuallyHidden {\\n border: 0;\\n clip: rect(0 0 0 0);\\n height: 1px;\\n margin: -1px;\\n overflow: hidden;\\n padding: 0;\\n position: absolute;\\n width: 1px;\\n #fff-space: nowrap;\\n}\\n\\n.subheader {\\n margin-top: 2em;\\n border-top: 1px solid rgb(14, 30, 37);\\n}\\n\\n.subheader h3 {\\n padding-top: 1em;\\n text-align: center;\\n }\\n\", \"\"]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./components/modal.css\n// module id = 27\n// module chunks = 0","/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n// css base code, injected by the css-loader\nmodule.exports = function(useSourceMap) {\n\tvar list = [];\n\n\t// return the list of modules as css string\n\tlist.toString = function toString() {\n\t\treturn this.map(function (item) {\n\t\t\tvar content = cssWithMappingToString(item, useSourceMap);\n\t\t\tif(item[2]) {\n\t\t\t\treturn \"@media \" + item[2] + \"{\" + content + \"}\";\n\t\t\t} else {\n\t\t\t\treturn content;\n\t\t\t}\n\t\t}).join(\"\");\n\t};\n\n\t// import a list of modules into the list\n\tlist.i = function(modules, mediaQuery) {\n\t\tif(typeof modules === \"string\")\n\t\t\tmodules = [[null, modules, \"\"]];\n\t\tvar alreadyImportedModules = {};\n\t\tfor(var i = 0; i < this.length; i++) {\n\t\t\tvar id = this[i][0];\n\t\t\tif(typeof id === \"number\")\n\t\t\t\talreadyImportedModules[id] = true;\n\t\t}\n\t\tfor(i = 0; i < modules.length; i++) {\n\t\t\tvar item = modules[i];\n\t\t\t// skip already imported module\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\n\t\t\t// when a module is imported multiple times with different media queries.\n\t\t\t// I hope this will never occur (Hey this way we have smaller bundles)\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\n\t\t\t\tif(mediaQuery && !item[2]) {\n\t\t\t\t\titem[2] = mediaQuery;\n\t\t\t\t} else if(mediaQuery) {\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\n\t\t\t\t}\n\t\t\t\tlist.push(item);\n\t\t\t}\n\t\t}\n\t};\n\treturn list;\n};\n\nfunction cssWithMappingToString(item, useSourceMap) {\n\tvar content = item[1] || '';\n\tvar cssMapping = item[3];\n\tif (!cssMapping) {\n\t\treturn content;\n\t}\n\n\tif (useSourceMap && typeof btoa === 'function') {\n\t\tvar sourceMapping = toComment(cssMapping);\n\t\tvar sourceURLs = cssMapping.sources.map(function (source) {\n\t\t\treturn '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'\n\t\t});\n\n\t\treturn [content].concat(sourceURLs).concat([sourceMapping]).join('\\n');\n\t}\n\n\treturn [content].join('\\n');\n}\n\n// Adapted from convert-source-map (MIT)\nfunction toComment(sourceMap) {\n\t// eslint-disable-next-line no-undef\n\tvar base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));\n\tvar data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;\n\n\treturn '/*# ' + data + ' */';\n}\n\n\n\n// WEBPACK FOOTER //\n// ../node_modules/css-loader/lib/css-base.js"],"sourceRoot":""}
Reference in New Issue View Git Blame Copy Permalink